Linux设备驱动剖析之Input（一）

前言

       以前在移植Qt到开发板上时只知道在配置文件中需要指定触摸屏的设备文件/dev/input/event0，仅此而已。直到一年半前突然想到用红外遥控器控制Tiny6410开发板上的Android系统，从而代替物理按键。实现原理是很简单的，就是首先解码红外信号，然后根据解码出的键值模拟一个按键信号。既然要模拟按键信号，那得首先找到按键信号产生的地方，通过查看内核编译生成的文件知道drivers/input/keyboard/gpio_keys.c文件是产生按键信号的源头，这是一个通用的用IO口模拟键盘的驱动程序。别小看这样一个功能，这是开发Android机顶盒、Android盒子必须要接触到的。

     虽说当时功能是实现了，但是对Linux的整个Input子系统的了解一点都不深入，本文就是来解决这个问题的。基于Linux-2.6.36版本，本文讲解的Input子系统的主线是这样的：和前面讲SPI、IIC子系统的方法类似，先讲Input核心的初始化，再从底层往上，分别是Input设备驱动程序（以drivers/input/keyboard/gpio_keys.c为例）、Input核心、Input事件驱动程序（以drivers/input/evdev.c为例）。按照输入信号的产生以及在内核中的传递过程，最后到应用程序这条线路，从而深入理解Linux的Input子系统。

     先给出Linux Input子系统的架构图，如下图所示。

                                               Linux Input子系统架构图

下面开始进入Input子系统的学习。

首先找到Input子系统的初始化函数，它是位于drivers/input/input.c中的input_init函数：

00002052 static int __init input_init(void)
00002053 {
00002054     int err;
00002055 
00002056     err = class_register(&input_class);
00002057     if (err) {
00002058         printk(KERN_ERR "input: unable to register input_dev class\n");
00002059         return err;
00002060     }
00002061 
00002062     err = input_proc_init();
00002063     if (err)
00002064         goto fail1;
00002065 
00002066     err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
00002067     if (err) {
00002068         printk(KERN_ERR "input: unable to register char major %d", INPUT_MAJOR);
00002069         goto fail2;
00002070     }
00002071 
00002072     return 0;
00002073 
00002074  fail2:    input_proc_exit();
00002075  fail1:    class_unregister(&input_class);
00002076     return err;
00002077 }

2056行，向系统注册input_class这么一个类，以后向Input子系统注册设备时，所注册的设备都会从属于这个类。

2062行，proc文件系统相关的，不细讲，但可以看下它的定义：

00001110 static int __init input_proc_init(void)
00001111 {
00001112     struct proc_dir_entry *entry;
00001113 
00001114     proc_bus_input_dir = proc_mkdir("bus/input", NULL);
00001115     if (!proc_bus_input_dir)
00001116         return -ENOMEM;
00001117 
00001118     entry = proc_create("devices", 0, proc_bus_input_dir,
00001119                 &input_devices_fileops);
00001120     if (!entry)
00001121         goto fail1;
00001122 
00001123     entry = proc_create("handlers", 0, proc_bus_input_dir,
00001124                 &input_handlers_fileops);
00001125     if (!entry)
00001126         goto fail2;
00001127 
00001128     return 0;
00001129 
00001130  fail2:    remove_proc_entry("devices", proc_bus_input_dir);
00001131  fail1: remove_proc_entry("bus/input", NULL);
00001132     return -ENOMEM;
00001133 }

1114行，很明显，在/proc下创建一个目录bus/input。

1118行，在/proc/bus/input目录下创建proc文件，文件名为devices。

1123行，在/proc/bus/input目录下创建proc文件，文件名为handlers。

回到input_init函数，2066行，注册字符设备，主设备号为INPUT_MAJOR，它的值为13，该设备的文件操集作实例为input_fops，它的定义为：

00002047 static const struct file_operations input_fops = {
00002048     .owner = THIS_MODULE,
00002049     .open = input_open_file,
00002050 };

可以看到，里面只将open函数指针指向input_open_file函数，这个函数放到最后再说。

input_init函数说完了，下面进入Input设备驱动程序，也就是Input子系统的最底层部分。首先看drivers/input/keyboard/gpio_keys.c驱动程序的初始化函数gpio_keys_init的定义：

00000632 static int __init gpio_keys_init(void)
00000633 {
00000634     return platform_driver_register(&gpio_keys_device_driver);
00000635 }

这是一个平台驱动，关于平台设备和平台驱动绑定过程应该都很了解了吧，634行，platform_driver_register函数参数gpio_keys_device_driver的定义：

00000620 static struct platform_driver gpio_keys_device_driver = {
00000621     .probe        = gpio_keys_probe,
00000622     .remove        = __devexit_p(gpio_keys_remove),
00000623     .driver        = {
00000624         .name    = "gpio-keys",
00000625         .owner    = THIS_MODULE,
00000626 #ifdef CONFIG_PM
00000627         .pm    = &gpio_keys_pm_ops,
00000628 #endif
00000629     }
00000630 };

注意，该结构体实例里没有为id_table变量赋值，因此写平台设备结构体实例的时候name成员的值要设置为gpio-keys，这样才能与该驱动匹配和绑定，从而该驱动中的probe函数才会被调用。下面看gpio_keys_probe函数的定义：

00000443 static int __devinit gpio_keys_probe(struct platform_device *pdev)
00000444 {
00000445     struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
00000446     struct gpio_keys_drvdata *ddata;
00000447     struct device *dev = &pdev->dev;
00000448     struct input_dev *input;
00000449     int i, error;
00000450     int wakeup = 0;
00000451 
00000452     ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
00000453             pdata->nbuttons * sizeof(struct gpio_button_data),
00000454             GFP_KERNEL);
00000455     input = input_allocate_device();
00000456     if (!ddata || !input) {
00000457         dev_err(dev, "failed to allocate state\n");
00000458         error = -ENOMEM;
00000459         goto fail1;
00000460     }
00000461 
00000462     ddata->input = input;
00000463     ddata->n_buttons = pdata->nbuttons;
00000464     ddata->enable = pdata->enable;
00000465     ddata->disable = pdata->disable;
00000466     mutex_init(&ddata->disable_lock);
00000467 
00000468     platform_set_drvdata(pdev, ddata);
00000469     input_set_drvdata(input, ddata);
00000470 
00000471     input->name = pdev->name;
00000472     input->phys = "gpio-keys/input0";
00000473     input->dev.parent = &pdev->dev;
00000474     input->open = gpio_keys_open;
00000475     input->close = gpio_keys_close;
00000476 
00000477     input->id.bustype = BUS_HOST;
00000478     input->id.vendor = 0x0001;
00000479     input->id.product = 0x0001;
00000480     input->id.version = 0x0100;
00000481 
00000482     /* Enable auto repeat feature of Linux input subsystem */
00000483     if (pdata->rep)
00000484         __set_bit(EV_REP, input->evbit);
00000485 
00000486     for (i = 0; i < pdata->nbuttons; i++) {
00000487         struct gpio_keys_button *button = &pdata->buttons[i];
00000488         struct gpio_button_data *bdata = &ddata->data[i];
00000489         unsigned int type = button->type ?: EV_KEY;
00000490 
00000491         bdata->input = input;
00000492         bdata->button = button;
00000493 
00000494         error = gpio_keys_setup_key(pdev, bdata, button);
00000495         if (error)
00000496             goto fail2;
00000497 
00000498         if (button->wakeup)
00000499             wakeup = 1;
00000500 
00000501         input_set_capability(input, type, button->code);
00000502     }
00000503 
00000504     error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
00000505     if (error) {
00000506         dev_err(dev, "Unable to export keys/switches, error: %d\n",
00000507             error);
00000508         goto fail2;
00000509     }
00000510 
00000511     error = input_register_device(input);
00000512     if (error) {
00000513         dev_err(dev, "Unable to register input device, error: %d\n",
00000514             error);
00000515         goto fail3;
00000516     }
00000517 
00000518     /* get current state of buttons */
00000519     for (i = 0; i < pdata->nbuttons; i++)
00000520         gpio_keys_report_event(&ddata->data[i]);
00000521     input_sync(input);
00000522 
00000523     device_init_wakeup(&pdev->dev, wakeup);
00000524 
00000525     return 0;
00000526 
00000527  fail3:
00000528     sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
00000529  fail2:
00000530     while (--i >= 0) {
00000531         free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
00000532         if (ddata->data[i].timer_debounce)
00000533             del_timer_sync(&ddata->data[i].timer);
00000534         cancel_work_sync(&ddata->data[i].work);
00000535         gpio_free(pdata->buttons[i].gpio);
00000536     }
00000537 
00000538     platform_set_drvdata(pdev, NULL);
00000539  fail1:
00000540     input_free_device(input);
00000541     kfree(ddata);
00000542 
00000543     return error;
00000544 }

445行，获取平台设备数据。

452行，为struct gpio_keys_drvdata对象分配内存，注意，另外还分配pdata->nbuttons * sizeof(struct gpio_button_data)内存，pdata->nbuttons的值为按键的个数。struct gpio_keys_platform_data的定义在include/linux/gpio_keys.h：

00000016 struct gpio_keys_platform_data {
00000017     struct gpio_keys_button *buttons;
00000018     int nbuttons;
00000019     unsigned int rep:1;        /* enable input subsystem auto repeat */
00000020     int (*enable)(struct device *dev);
00000021     void (*disable)(struct device *dev);
00000022 };

17行，buttons，指向板文件中定义的struct gpio_keys_button数组。

18行，nbuttons，按键的个数。

19行，rep，是否支持按键自动重复。

20、21行，使能和失能按键的函数指针。

下面看一下struct gpio_keys_drvdata的定义：

00000038 struct gpio_keys_drvdata {
00000039     struct input_dev *input;
00000040     struct mutex disable_lock;
00000041     unsigned int n_buttons;
00000042     int (*enable)(struct device *dev);
00000043     void (*disable)(struct device *dev);
00000044     struct gpio_button_data data[0];
00000045 };

39行，input，当前Input设备。

41行，n_buttons，按键的个数。

44行，是一个变长数组，当获取到平台数据时才能确定该数组的长度。看下该数组类型struct gpio_button_data的定义：

00000029 struct gpio_button_data {
00000030     struct gpio_keys_button *button;
00000031     struct input_dev *input;
00000032     struct timer_list timer;
00000033     struct work_struct work;
00000034     int timer_debounce;    /* in msecs */
00000035     bool disabled;
00000036 };

先看31行，input，设备的指针。

32行，timer，用来延时的定时器。

33行，work，工作队列。

34行，timer_debounce，定时器的定时时间，单位为ms。

35行，disabled，按键是否已经使能。

看回30行，struct gpio_keys_button的定义在include/linux/gpio_keys.h中：

00000004 struct gpio_keys_button {
00000005     /* Configuration parameters */
00000006     int code;        /* input event code (KEY_*, SW_*) */
00000007     int gpio;
00000008     int active_low;
00000009     char *desc;
00000010     int type;        /* input event type (EV_KEY, EV_SW) */
00000011     int wakeup;        /* configure the button as a wake-up source */
00000012     int debounce_interval;    /* debounce ticks interval in msecs */
00000013     bool can_disable;
00000014 };

6行，code，键值。

7行，gpio，所使用的IO口。

8行，active_low，1表示低电平有效。

9行，desc，按键的名字。

10行，type，按键的事件类型。

11行，wakeup，1表示按键作为唤醒源。

12行，debounce_interval，延时消抖所需要的时间，单位为ms。

13行，can_disable，按键是否可以失能。

回到gpio_keys_probe函数，455行，分配Input设备，input_allocate_device函数在drivers/input/input.c里定义：

00001555 struct input_dev *input_allocate_device(void)
00001556 {
00001557     struct input_dev *dev;
00001558 
00001559     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
00001560     if (dev) {
00001561         dev->dev.type = &input_dev_type;
00001562         dev->dev.class = &input_class;
00001563         device_initialize(&dev->dev);
00001564         mutex_init(&dev->mutex);
00001565         spin_lock_init(&dev->event_lock);
00001566         INIT_LIST_HEAD(&dev->h_list);
00001567         INIT_LIST_HEAD(&dev->node);
00001568 
00001569         __module_get(THIS_MODULE);
00001570     }
00001571 
00001572     return dev;
00001573 }

1557行，看下struct input_dev结构体在include/linux/input.h中的定义：

00001150 struct input_dev {
00001151     const char *name;
00001152     const char *phys;
00001153     const char *uniq;
00001154     struct input_id id;
00001155 
00001156     unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
00001157     unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
00001158     unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
00001159     unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
00001160     unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
00001161     unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
00001162     unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
00001163     unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
00001164     unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
00001165 
00001166     unsigned int hint_events_per_packet;
00001167 
00001168     unsigned int keycodemax;
00001169     unsigned int keycodesize;
00001170     void *keycode;
00001171     int (*setkeycode)(struct input_dev *dev,
00001172               unsigned int scancode, unsigned int keycode);
00001173     int (*getkeycode)(struct input_dev *dev,
00001174               unsigned int scancode, unsigned int *keycode);
00001175 
00001176     struct ff_device *ff;
00001177 
00001178     unsigned int repeat_key;
00001179     struct timer_list timer;
00001180 
00001181     int rep[REP_CNT];
00001182 
00001183     struct input_mt_slot *mt;
00001184     int mtsize;
00001185     int slot;
00001186 
00001187     struct input_absinfo *absinfo;
00001188 
00001189     unsigned long key[BITS_TO_LONGS(KEY_CNT)];
00001190     unsigned long led[BITS_TO_LONGS(LED_CNT)];
00001191     unsigned long snd[BITS_TO_LONGS(SND_CNT)];
00001192     unsigned long sw[BITS_TO_LONGS(SW_CNT)];
00001193 
00001194     int (*open)(struct input_dev *dev);
00001195     void (*close)(struct input_dev *dev);
00001196     int (*flush)(struct input_dev *dev, struct file *file);
00001197     int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
00001198 
00001199     struct input_handle *grab;
00001200 
00001201     spinlock_t event_lock;
00001202     struct mutex mutex;
00001203 
00001204     unsigned int users;
00001205     bool going_away;
00001206 
00001207     bool sync;
00001208 
00001209     struct device dev;
00001210 
00001211     struct list_head    h_list;
00001212     struct list_head    node;
00001213 };

1151行，name，设备的名字。

1152行，phys，设备在系统层次结构中的路径。

1153行，uniq，设备的识别码。

1154行，id，还是ID，直接看它的定义更直接。

00000043 struct input_id {
00000044     __u16 bustype;
00000045     __u16 vendor;
00000046     __u16 product;
00000047     __u16 version;
00000048 };