Linux input子系统驱动_linux evbit-CSDN博客

本文链接：https://blog.csdn.net/sweeting_QQ/article/details/132692928

本文详细介绍了Linux内核的Input子系统，包括input_dev的组成、注册流程、事件类型和值的设置，以及如何通过GPIO上报按键事件。展示了如何初始化并注册input_dev，以及关键的事件上报函数和中断处理机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

input 子系统分为 input 驱动层、input 核心层、input 事件处理层，最终给用户空间提供可访问的设备节点。

驱动层：输入设备的具体驱动程序，比如按键驱动程序，向内核层报告输入内容。

核心层：承上启下，为驱动层提供输入设备注册和操作接口。通知事件层对输入事件进行处理。

事件层：主要和用户空间进行交互。

1、注册input_ev

在使用 input 子系统的时候我们只需要注册一个 input 设备即可，input_dev 结构体表示 input 设备，定义如下：

struct input_dev {
 const char *name;
 const char *phys;
 const char *uniq;
 struct input_id id;

 unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];

 unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; /* 事件类型的位图 */
 unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; /* 按键值的位图 */
 unsigned long relbit[BITS_TO_LONGS(REL_CNT)]; /* 相对坐标的位图 */ 
 unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; /* 绝对坐标的位图 */
 unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)]; /* 杂项事件的位图 */
 unsigned long ledbit[BITS_TO_LONGS(LED_CNT)]; /*LED 相关的位图 */
 unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];/* sound 有关的位图 */
 unsigned long ffbit[BITS_TO_LONGS(FF_CNT)]; /* 压力反馈的位图 */
 unsigned long swbit[BITS_TO_LONGS(SW_CNT)]; /*开关状态的位图 */
......
 bool devres_managed;
 };

其中，evbit表示输入事件类型，可选事件类型定义有：

#define EV_SYN 0x00         /* 同步事件 */
#define EV_KEY 0x01         /* 按键事件 */
#define EV_REL 0x02         /* 相对坐标事件 */
#define EV_ABS 0x03         /* 绝对坐标事件 */
#define EV_MSC 0x04         /* 杂项(其他)事件 */
#define EV_SW 0x05         /* 开关事件 */
#define EV_LED 0x11         /* LED */
#define EV_SND 0x12         /* sound(声音) */
#define EV_REP 0x14         /* 重复事件 */
#define EV_FF 0x15             /* 压力事件 */
#define EV_PWR 0x16            /* 电源事件 */
#define EV_FF_STATUS 0x17     /* 压力状态事件 */

input_dev设备中的evbit,keybit,relbot等都是存放不同事件对应的值。

可以使用input_allocate_device 函数来申请一个 input_dev，此函数原型如下所示：

struct input_dev *input_allocate_device(void)

返回值：申请到的input_dev

如果要注销的 input 设备的话需要使用 input_free_device 函数来释放掉前面申请到的 input_dev，input_free_device 函数原型如下：

void input_free_device(struct input_dev *dev)

dev：要释放的input_dev

申请好一个 input_dev 以后就需要初始化这个 input_dev，需要初始化的内容主要为事件类型(evbit)和事件值(keybit)这两种。input_dev 初始化完成以后就需要向 Linux 内核注册 input_dev 了，需要用到 input_register_device 函数，此函数原型如下：

int input_register_device(struct input_dev *dev)

dev：要注册的input_dev

返回值：0，注册成功；负值，注册失败

同样的，注销 input 驱动的时候也需要使用 input_unregister_device 函数来注销掉前面注册的 input_dev，input_unregister_device 函数原型如下：

void input_unregister_device(struct input_dev *dev)

dev：要注销的input_dev

综上，input_dev 注册过程如下：

①、使用 input_allocate_device 函数申请一个 input_dev。

②、初始化 input_dev 的事件类型以及事件值。

③、使用 input_register_device 函数向 Linux 系统注册前面初始化好的 input_dev。

④、卸载input驱动的时候需要先使用input_unregister_device 函数注销掉注册的input_dev，然后使用 input_free_device 函数释放掉前面申请的 input_dev。

总体来看，input_dev的注册过程示例代码如下：

 struct input_dev *inputdev; /* input 结构体变量 */
 
 /* 驱动入口函数 */
 static int __init xxx_init(void)
 {
 ......
 inputdev = input_allocate_device(); /* 申请 input_dev */
 inputdev->name = "test_inputdev"; /* 设置 input_dev 名字 */
 
 /*********第一种设置事件和事件值的方法***********/
 __set_bit(EV_KEY, inputdev->evbit); /* 设置产生按键事件 */
 __set_bit(EV_REP, inputdev->evbit); /* 重复事件 */
 __set_bit(KEY_0, inputdev->keybit); /*设置产生哪些按键值 */
 /************************************************/
 
 /*********第二种设置事件和事件值的方法***********/
 keyinputdev.inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 keyinputdev.inputdev->keybit[BIT_WORD(KEY_0)] |= BIT_MASK(KEY_0);
 /************************************************/

 /*********第三种设置事件和事件值的方法***********/
 keyinputdev.inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 input_set_capability(keyinputdev.inputdev, EV_KEY, KEY_0);
 /************************************************/
 
 /* 注册 input_dev */
 input_register_device(inputdev);
 ......
 return 0;
 }

 /* 驱动出口函数 */
 static void __exit xxx_exit(void)
 {
 input_unregister_device(inputdev); /* 注销 input_dev */
 input_free_device(inputdev); /* 删除 input_dev */
 }

2、上报输入事件

当我们向 Linux 内核注册好 input_dev 以后还不能高枕无忧的使用 input 设备，input 设备都是具有输入功能的，但是具体是什么样的输入值 Linux 内核是不知道的，我们需要获取到具体的输入值，或者说是输入事件，然后将输入事件上报给 Linux 内核。比如按键，我们需要在按键中断处理函数，或者消抖定时器中断函数中将按键值上报给 Linux 内核，这样 Linux 内核才能获取到正确的输入值。不同的事件，其上报事件的 API 函数不同，我们依次来看一下一些常用的事件上报 API 函数。

首先是 input_event 函数，此函数用于上报指定的事件以及对应的值，函数原型如下：

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

dev：需要上报的input_dev。

type：上报的事件类型，比如EV_KEY。

code：事件码，也就是我们注册的按键值，比如 KEY_0、KEY_1 等等。

value：事件值，比如 1 表示按键按下，0 表示按键松开。

input_event 函数可以上报所有的事件类型和事件值，Linux 内核也提供了其他的针对具体事件的上报函数，这些函数其实都用到了 input_event 函数。比如上报按键所使用的 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 函数的本质就是 input_event 函数，如果要上报按键事件的话还是建议大家使用 input_report_key 函数。同样的还有一些其他的事件上报函数，这些函数如下所示：

void input_report_rel(struct input_dev *dev, unsigned int code, int value)
void input_report_abs(struct input_dev *dev, unsigned int code, int value)
void input_report_ff_status(struct input_dev *dev, unsigned int code, int value)
void input_report_switch(struct input_dev *dev, unsigned int code, int value)
void input_mt_sync(struct input_dev *dev)

当我们上报事件以后还需要使用 input_sync 函数来告诉 Linux 内核 input 子系统上报结束， input_sync 函数本质是上报一个同步事件，此函数原型如下所示：

void input_sync(struct input_dev *dev)

dev：需要上报同步事件的input_dev

综上，按键的上报事件的参考代码如下所示：

/* 用于按键消抖的定时器服务函数 */
 void timer_function(unsigned long arg)
 {
 unsigned char value;
 
 value = gpio_get_value(keydesc->gpio); /* 读取 IO 值 */
 if(value == 0){ /* 按下按键 */
 /* 上报按键值 */
 input_report_key(inputdev, KEY_0, 1); /* 最后一个参数 1，按下 */
 input_sync(inputdev); /* 同步事件 */
 } else { /* 按键松开 */
 input_report_key(inputdev, KEY_0, 0); /* 最后一个参数 0，松开 */
 input_sync(inputdev); /* 同步事件 */
 } 
 }

3、input_event结构体

Linux 内核使用 input_event 这个结构体来表示所有的输入事件，input_envent 结构体定义在 include/uapi/linux/input.h 文件中，结构体内容如下：

struct input_event {
 struct timeval time;
 __u16 type;
 __u16 code;
 __s32 value;
 };

time：时间，也就是此事件发生的时间，为 timeval 结构体类型，timeval 结构体定义如下：

 typedef long __kernel_long_t;
 typedef __kernel_long_t __kernel_time_t;
 typedef __kernel_long_t __kernel_suseconds_t;

 struct timeval {
 __kernel_time_t tv_sec; /* 秒 */
 __kernel_suseconds_t tv_usec; /* 微秒 */
 };

type：事件类型，比如 EV_KEY，表示此次事件为按键事件，此成员变量为 16 位。

code：事件码，比如在 EV_KEY 事件中 code 就表示具体的按键码，如：KEY_0、KEY_1 等等这些按键。此成员变量为 16 位。

value：值，比如 EV_KEY 事件中 value 就是按键值，表示按键有没有被按下，如果为 1 的话说明按键按下，如果为 0 的话说明按键没有被按下或者按键松开了。

input_envent 这个结构体非常重要，因为所有的输入设备最终都是按照 input_event 结构体呈现给用户的，用户应用程序可以通过 input_event 来获取到具体的输入事件或相关的值，比如按键值等。

实验代码，使用按键input：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include<linux/atomic.h>
#include<linux/string.h>
#include<linux/interrupt.h>
#include<linux/input.h>


#define KEYINPUT_CNT       1
#define KEYINPUT_NAME      "keyinput"
#define KEY_NUM             1
#define KEY0VALUE           0X01
#define INVAKEY             0XFF

/*key结构体*/
struct irq_keydesc{
    int gpio;       //io编号
    int irqnum;     //中断号
    int  value;        //键值
    char name[10];      //名字
    irqreturn_t (*handler) (int ,void*);                    //中断处理函数
};


/*gpio设备结构体*/
struct keyinput_dev{
    
    struct device_node *nd;
    struct irq_keydesc irqkey[KEY_NUM];
    struct timer_list timer;

    struct input_dev *inputdev; //输入设备

};

struct keyinput_dev keyinputdev; //keyinputdev


/*中断处理函数*/
static irqreturn_t key0_handler(int irq,void * dev_id)
{
    //int value = 0;
    struct keyinput_dev *dev = dev_id;

    dev->timer.data = (volatile unsigned long)dev_id;       //dev_id = &keyinputdev
    mod_timer(&dev->timer,jiffies + msecs_to_jiffies(10));      //10ms定时

    return IRQ_HANDLED;
}
/*定时器处理函数*/
static void timer_func(unsigned long arg)
{
    int value = 0;
    struct keyinput_dev *dev = (struct keyinput_dev * )arg;

    
    value = gpio_get_value(dev->irqkey[0].gpio);
    if(value == 0){     //按下
        /* 上报按键值 */
        input_event(dev->inputdev,EV_KEY,BTN_0,1);
        input_sync(dev->inputdev);
    }else if(value == 1){       //释放
        /* 上报按键值 */
        input_event(dev->inputdev,EV_KEY,BTN_0,0);
        input_sync(dev->inputdev);
    }

}


/* 按键初始化 */
static int keyio_init(struct keyinput_dev *dev)
{
    int ret = 0;
    int i = 0;
    /* 1、按键初始化 */
    dev->nd = of_find_node_by_path("/key");
    if(dev->nd == NULL){
        ret = -EINVAL;
        goto fail_nd;
    }
    for(i = 0;i < KEY_NUM; i++){
        dev->irqkey[i].gpio = of_get_named_gpio(dev->nd,"key-gpios",i);
    }

    for(i = 0; i<KEY_NUM; i++){
        memset(dev->irqkey[i].name,0,sizeof(dev->irqkey[i].name));
        sprintf(dev->irqkey[i].name,"KEY%d",i);
        gpio_request(dev->irqkey[i].gpio,dev->irqkey[i].name);
        gpio_direction_input(dev->irqkey[i].gpio);

        dev->irqkey[i].irqnum = gpio_to_irq(dev->irqkey[i].gpio);       //获取中断号
#if 0
        dev->irqkey[i].irqnum = irq_of_parse_and_map(dev->nd,i);
#endif
    }
    dev->irqkey[0].handler = key0_handler;
    dev->irqkey[0].value = BTN_0;
    /* 2、按键中断初始化 */
    for(i = 0;i < KEY_NUM; i++){
        ret = request_irq(dev->irqkey[i].irqnum,dev->irqkey[i].handler,
                        IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,dev->irqkey[i].name,
                        &keyinputdev);
        if(ret ){
            printk("irq %d request failed!\r\n",dev->irqkey[i].irqnum);
            goto fail_irq;
        }
    }
    /*初始化定时器*/
    init_timer(&keyinputdev.timer);
    keyinputdev.timer.function = timer_func;



    return 0;

fail_irq:
    for(i = 0;i<KEY_NUM;i++){
        gpio_free(dev->irqkey[i].gpio);
    }
fail_nd:
    return ret;
}

/* 驱动入口出口函数*/
static int __init keyinput_init(void)
{
    int ret = 0;
    
    /* 初始化IO */
    ret = keyio_init(&keyinputdev);
    if(ret < 0){
        goto fail_keyinit;
    }

    /* 注册input_dev */
    keyinputdev.inputdev = input_allocate_device();
    if(keyinputdev.inputdev == NULL){
        ret = -EINVAL;
        goto fail_keyinit;
    }
    keyinputdev.inputdev->name = KEYINPUT_NAME;

    __set_bit(EV_KEY,keyinputdev.inputdev->evbit);      //按键事件
    __set_bit(EV_REP,keyinputdev.inputdev->evbit);      //重复事件
    __set_bit(BTN_0,keyinputdev.inputdev->keybit);      //按键事件

    ret = input_register_device(keyinputdev.inputdev);
    if (ret) {
		goto input_register_fail;
	}


    return 0;
input_register_fail:
    input_free_device(keyinputdev.inputdev);
fail_keyinit:
    return ret;
}

static void __exit keyinput_exit(void)
{
    int i = 0;
    /*释放中断*/
    for(i = 0;i<KEY_NUM;i++){
        free_irq(keyinputdev.irqkey[i].irqnum,&keyinputdev);

    }
    /*释放IO*/
    for(i=0;i<KEY_NUM;i++){
        gpio_free(keyinputdev.irqkey[i].gpio);
    }

    /*删除定时器*/
    del_timer_sync(&keyinputdev.timer);

    /*注销input_dev*/
    input_unregister_device(keyinputdev.inputdev);
    input_free_device(keyinputdev.inputdev);



}


module_init(keyinput_init);
module_exit(keyinput_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("wzh");