linux输入子系统（input subsystem）之evdev.c事件处理过程

1.代码

input_subsys.drv.c 在linux输入子系统（input subsystem）之按键输入和LED控制的基础上有小改动，input_subsys_test.c不变。

input_subsys.drv.c

#include <linux/module.h>
#include <linux/version.h>

#include <linux/init.h>
#include <linux/fs.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/pm.h>
#include <linux/sysctl.h>
#include <linux/proc_fs.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/input.h>
#include <linux/irq.h>

#include <asm/gpio.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>


struct pin_desc{
    int irq;
    char *name;
    unsigned int pin;
    unsigned int key_val;
};

struct pin_desc pins_desc[4] = {
    {IRQ_EINT0,  "S2", S3C2410_GPF0,   KEY_L},
    {IRQ_EINT2,  "S3", S3C2410_GPF2,   KEY_S},
    {IRQ_EINT11, "S4", S3C2410_GPG3,   KEY_ENTER},
    {IRQ_EINT19, "S5",  S3C2410_GPG11, KEY_LEFTSHIFT},
};

static struct input_dev *input_subsys_dev;
static struct pin_desc *irq_pd;
static struct timer_list buttons_timer;

static irqreturn_t buttons_irq(int irq, void *dev_id)
{
    /* [cgw]: 按键IO发生边沿中断时重新设置定时间隔
     * 用于按键消抖
     */
    irq_pd = (struct pin_desc *)dev_id;
    buttons_timer.data = irq_pd->pin;
    mod_timer(&buttons_timer, jiffies+USER_HZ/10);
    return IRQ_RETVAL(IRQ_HANDLED);
}

static void buttons_timer_function(unsigned long data)
{
    struct pin_desc * pindesc = irq_pd;
    unsigned int pinval;

    if (!pindesc)
        return;
        
    /* [cgw]: 获取按键IO状态 */
    pinval = s3c2410_gpio_getpin((unsigned int)data);

    /* [cgw]: 根据按键IO状态上报按键事件 */
    if (pinval)
    {
        /* [cgw]: 上报按键弹起 */
        input_report_key(input_subsys_dev, pindesc->key_val, 0);
        //input_sync(input_subsys_dev);
    }
    else
    {
        /* [cgw]: 上报按键按下 */
        input_report_key(input_subsys_dev, pindesc->key_val, 1);
        //input_sync(input_subsys_dev);
    }

    //printk("timer occur!
");
}


static int event_handler(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
    #if 0
    /* [cgw]: 根据应用程序下发的LED控制事件
     * 亮灭LED
     */
    //if (code == SND_BELL) {
    if (code == LED_MUTE) {
        if (value == 0xAA) {
            /* [cgw]: 点亮 */
            s3c2410_gpio_setpin(S3C2410_GPF4, 0);
        } else if (value == 0xEE) {
            /* [cgw]: 熄灭 */
            s3c2410_gpio_setpin(S3C2410_GPF4, 1);
        }
        
        return 0;
    }
    #endif

    switch (type) {
        case EV_REP:
            return 0;
            //break;

        case EV_LED:
            if (code == LED_MUTE) {
                if (value == 0xAA) {
                    /* [cgw]: 点亮 */
                    s3c2410_gpio_setpin(S3C2410_GPF4, 0);
                } else if (value == 0xEE) {
                    /* [cgw]: 熄灭 */
                    s3c2410_gpio_setpin(S3C2410_GPF4, 1);
                }
                
                return 0;
            }
            //break;

        case EV_SND:
            return 0;
            //break;
    }
    
    return -1;
}

int input_subsys_open(struct input_dev *dev)
{ 
    int i, retval;
    
    /* [cgw]: 设置按键IO为中断输入 */
    s3c2410_gpio_cfgpin(S3C2410_GPF0, S3C2410_GPF0_EINT0);
    s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
    s3c2410_gpio_cfgpin(S3C2410_GPG3, S3C2410_GPG3_EINT11);
    s3c2410_gpio_cfgpin(S3C2410_GPG11, S3C2410_GPG11_EINT19);

    /* [cgw]: 设置LED IO为输出，初始为熄灭LED */
    s3c2410_gpio_cfgpin(S3C2410_GPF4, S3C2410_GPF4_OUTP);
    s3c2410_gpio_setpin(S3C2410_GPF4, 1);

    s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
    s3c2410_gpio_setpin(S3C2410_GPF5, 1);

    s3c2410_gpio_cfgpin(S3C2410_GPF5, S3C2410_GPF5_OUTP);
    s3c2410_gpio_setpin(S3C2410_GPF5, 1);

    /* [cgw]: 为按键IO分配中断线 */
    for (i = 0; i < 4; i++)
    {
        retval = request_irq(pins_desc[i].irq, buttons_irq, IRQT_BOTHEDGE, pins_desc[i].name, &pins_desc[i]);
    }

    printk("input subsys open!
");
    //printk("USER_HZ: %d
", USER_HZ);

    return 0;
}



static int input_subsys_init(void)
{
    /* [cgw]: 分配一个输入设备 */
    input_subsys_dev = input_allocate_device();
    input_subsys_dev->name = "input_subsys_dev";

    /* [cgw]: 设置支持的事件类型 */
    set_bit(EV_KEY, input_subsys_dev->evbit);
    set_bit(EV_REP, input_subsys_dev->evbit);
    
    set_bit(EV_LED, input_subsys_dev->evbit);
    //set_bit(EV_SND, input_subsys_dev->evbit);

    /* [cgw]: 设置支持的事件码 */
    set_bit(KEY_L, input_subsys_dev->keybit);
    set_bit(KEY_S, input_subsys_dev->keybit);
    set_bit(KEY_ENTER, input_subsys_dev->keybit);
    set_bit(KEY_LEFTSHIFT, input_subsys_dev->keybit);

    set_bit(LED_MUTE, input_subsys_dev->ledbit);
    //set_bit(SND_BELL, input_subsys_dev->sndbit);

    /* [cgw]: 分配输入设备的open方法 */
    input_subsys_dev->open = input_subsys_open;
    /* [cgw]: 分配输入设备的event方法，用户在应用程序write()时 */
    input_subsys_dev->event = event_handler;

    /* [cgw]: 注册输入设备 */
    input_register_device(input_subsys_dev);

    //input_subsys_dev->rep[REP_DELAY] = 250;
    //input_subsys_dev->rep[REP_PERIOD] = 100;

    /* [cgw]: 初始化定时器，用于按键消抖 */
    init_timer(&buttons_timer);
    buttons_timer.function = buttons_timer_function;
    add_timer(&buttons_timer);

    printk("input subsys init!
");
    
    return 0;
}

static void input_subsys_exit(void)
{
    int i;

    /* [cgw]: 释放按键IO中断 */
    for (i = 0; i < 4; i++)
    {
        free_irq(pins_desc[i].irq, &pins_desc[i]);
    }

    /* [cgw]: 删除定时器 */
    del_timer(&buttons_timer);
    /* [cgw]: 注销输入设备 */
    input_unregister_device(input_subsys_dev);
    /* [cgw]: 释放输入设备内存空间 */
    input_free_device(input_subsys_dev);    
}

module_init(input_subsys_init);

module_exit(input_subsys_exit);

MODULE_LICENSE("GPL");

2. input_subsys_drv.c, input.c, evdev.c 三者之间的关系：

input_subsys_drv.c: 负责获取底层硬件产生的事件，如：中断，按键输入等，收集到这些事件传递给input.c, 并通过设置evdev.c可以支持的事件类型，和evdev.c建立连接

input.c: 输入子系统内核，收集底层硬件发来的（如：如中断，按键输入）和用户空间发来的（如：write，ioctl）事件，传递给evdev.c

evdev.c: 收集从input.c传递过来的事件，存储到一个环形缓冲队列，并产生一个异步通知，通知用户空间读取事件

3. 按键输入（底层硬件）和LED（用户空间）事件处理过程

3.1 按键输入事件处理过程：

input_subsys_drv.c 同过外部中断获得按键的状态，经过消抖之后，向input.c上报：

static void buttons_timer_function(unsigned long data)
{
    struct pin_desc * pindesc = irq_pd;
    unsigned int pinval;

    if (!pindesc)
        return;
        
    /* [cgw]: 获取按键IO状态 */
    pinval = s3c2410_gpio_getpin((unsigned int)data);

    /* [cgw]: 根据按键IO状态上报按键事件 */
    if (pinval)
    {
        /* [cgw]: 上报按键弹起 */
        input_report_key(input_subsys_dev, pindesc->key_val, 0);
        //input_sync(input_subsys_dev);
    }
    else
    {
        /* [cgw]: 上报按键按下 */
        input_report_key(input_subsys_dev, pindesc->key_val, 1);
        //input_sync(input_subsys_dev);
    }

    //printk("timer occur!
");
}

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_event()

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
    ...

    switch (type) {
        ...

        case EV_KEY:

            if (code > KEY_MAX || !test_bit(code, dev->keybit) || !!test_bit(code, dev->key) == value)
                return;

            if (value == 2)
                break;

            change_bit(code, dev->key);

            if (test_bit(EV_REP, dev->evbit) && dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] && dev->timer.data && value) {
                dev->repeat_key = code;
                mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
            }

            break;

            ...

    }

    ....
    handle->handler->event(handle, type, code, value);
}

其中：case EV_KEY中，对按键连发做初步检测，即检测是否有按键的按下和弹起这两个状态，缺一个都不行（后面解析）。

接着就调用handle->handler->event()，实际上是调用了evdev_event（）；

因为

static struct input_handler evdev_handler = {
    .event =    evdev_event,
    ...
};

evdev_event():

static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
    ...
    /* [cgw]: 把接收到的事件加入到一个环形队列 */
    do_gettimeofday(&client->buffer[client->head].time);
    client->buffer[client->head].type = type;
    client->buffer[client->head].code = code;
    client->buffer[client->head].value = value;
    client->head = (client->head + 1) & (EVDEV_BUFFER_SIZE - 1);

    /* [cgw]: 发送一个异步通知 */
    kill_fasync(&client->fasync, SIGIO, POLL_IN);

    /* [cgw]: 唤醒正在等待这个事件的进程 */
    wake_up_interruptible(&evdev->wait);
}

在evdev_event中发送了异步通知并唤醒了再睡眠的进程，所以在应用程序调用read时，就会获得这个事件。

/* [cgw]: 异步通知产生时返回的数据 */
    read(fd, &buttons_event, sizeof(struct input_event));

3.1.1 按键连发的处理过程

首先在input_subsys_init() 使能EV_REP按键连发功能

static int input_subsys_init(void)
{
    /* [cgw]: 分配一个输入设备 */
    input_subsys_dev = input_allocate_device();
    input_subsys_dev->name = "input_subsys_dev";

    /* [cgw]: 设置支持的事件类型 */
    set_bit(EV_KEY, input_subsys_dev->evbit);
    set_bit(EV_REP, input_subsys_dev->evbit);
    
    set_bit(EV_LED, input_subsys_dev->evbit);
    //set_bit(EV_SND, input_subsys_dev->evbit);

    /* [cgw]: 设置支持的事件码 */
    set_bit(KEY_L, input_subsys_dev->keybit);
    set_bit(KEY_S, input_subsys_dev->keybit);
    set_bit(KEY_ENTER, input_subsys_dev->keybit);
    set_bit(KEY_LEFTSHIFT, input_subsys_dev->keybit);

    set_bit(LED_MUTE, input_subsys_dev->ledbit);
    //set_bit(SND_BELL, input_subsys_dev->sndbit);

    /* [cgw]: 分配输入设备的open方法 */
    input_subsys_dev->open = input_subsys_open;
    /* [cgw]: 分配输入设备的event方法，用户在应用程序write()时 */
    input_subsys_dev->event = event_handler;

    /* [cgw]: 注册输入设备 */
    input_register_device(input_subsys_dev);

    ...
    
    return 0;
}

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
    ...

    switch (type) {
        ...

        case EV_KEY:

            if (code > KEY_MAX || !test_bit(code, dev->keybit) || !!test_bit(code, dev->key) == value)
                return;

            /* [cgw]: 收到连发按键的事件，返回 */
            if (value == 2)  
                break;

            /* [cgw]: 这个函数的设置，用于上面!!test_bit(code, dev->key) == value判断
             * 是否为按下弹起操作
             */
            change_bit(code, dev->key);

            /* [cgw]: 如果当前操作为按下，并且连发功能使能，则设置连发的触发时间 */
            if (test_bit(EV_REP, dev->evbit) && dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] && dev->timer.data && value) {
                dev->repeat_key = code;
                mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
            }

            break;

            ...

    }

    ....
    handle->handler->event(handle, type, code, value);
}

在input_event()中如果检测到按键按下，一直到连发功能触发，则定时器超时调用超时处理函数：

因为在注册输入设备时，就分配了定时器的超时处理函数input_repeat_key()

int input_register_device(struct input_dev *dev)
{
    ...
    /*
     * 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;
    }

    ...
}

在input_repeat_key()中

static void input_repeat_key(unsigned long data)
{
    struct input_dev *dev = (void *) data;

    /* [cgw]: 是否分配了连发的键值 */
    if (!test_bit(dev->repeat_key, dev->key))
        return;

    /* [cgw]: 发送连发事件 */
    input_event(dev, EV_KEY, dev->repeat_key, 2);
    input_sync(dev);

    /* [cgw]: 设置连发间隔 */
    if (dev->rep[REP_PERIOD])
        mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_PERIOD]));
}

3.2 led控制事件处理过程

用户在应用程序中操作write时

/* [cgw]: 发送LED控制事件 */
            write(fd, &leds_event, sizeof(struct input_event));

对应的是操作了evdev_write()

static ssize_t evdev_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
{
    ...
    /* [cgw]: 收到来自用户空间的事件 */
    if (evdev_event_from_user(buffer + retval, &event))
        return -EFAULT;
    /* [cgw]: 调用input_event() */
    input_inject_event(&evdev->handle, event.type, event.code, event.value);

    return retval;
}

input_event()

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
    ...

    switch (type) {
        ...

        case EV_LED:
            
            if (code > LED_MAX || !test_bit(code, dev->ledbit) || !!test_bit(code, dev->led) == value)
                return;

            /* [cgw]: 这个函数用于上面!!test_bit(code, dev->led) == value是否为不同的LED状态(亮，灭) */
            change_bit(code, dev->led);

            /* [cgw]: 调用事件处理，这个事件处理需要驱动提供，做一些特别的处理 
             * 本例提供了
             * static int event_handler(struct input_dev *dev, unsigned int type, unsigned int code, int value)
             * 不影响调用evdev_event()
             */
            if (dev->event)
                dev->event(dev, type, code, value);

            break;

            ...

    }

    ....
    handle->handler->event(handle, type, code, value);
}

event_handler()

static int event_handler(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{

    switch (type) {
        case EV_REP:
            return 0;
            //break;

        case EV_LED:
            if (code == LED_MUTE) {
                if (value == 0xAA) {
                    /* [cgw]: 点亮 */
                    s3c2410_gpio_setpin(S3C2410_GPF4, 0);
                } else if (value == 0xEE) {
                    /* [cgw]: 熄灭 */
                    s3c2410_gpio_setpin(S3C2410_GPF4, 1);
                }
                
                return 0;
            }
            //break;

        case EV_SND:
            return 0;
            //break;
    }
    
    return -1;
}

因此用户空间发下来的事件，分两个路径处理

1.dev->event()  即：event_handler,由驱动程序提供

2.handler-event()  即：evdev_event(), 由evdev.c提供