Linux Input子系统

1. Input子系统

按键、鼠标、键盘、触摸屏等都属于输入(input)设备，Linux 内核为此专门做了一个叫做 input子系统的框架来处理输入事件。输入设备本质上还是字符设备，只是在此基础上套上了 input 框架，用户只需要负责上报输入事件，比如按键值、坐标等信息，input 核心层负责处理这些事件。

1.1 Input 子系统简介

input 就是输入的意思，因此 input 子系统就是管理输入的子系统，和 pinctrl、gpio 子系统一样，都是 Linux 内核针对某一类设备而创建的框架。比如按键输入、键盘、鼠标、触摸屏等等这些都属于输入设备，不同的输入设备所代表的含义不同，按键和键盘就是代表按键信息，鼠标和触摸屏代表坐标信息，因此在应用层的处理就不同，对于驱动编写者而言不需要去关心应用层的事情，我们只需要按照要求上报这些输入事件即可。为此 input 子系统分为 input 驱动层、input 核心层、input 事件处理层，最终给用户空间提供可访问的设备节点，input 子系统框架如图 58.1.1.1 所示：
image
图 58.1.1.1 中左边就是最底层的具体设备，比如按键、USB 键盘/鼠标等，中间部分属于Linux 内核空间，分为驱动层、核心层和事件层，最右边的就是用户空间，所有的输入设备以文件的形式供用户应用程序使用。可以看出 input 子系统用到了我们前面讲解的驱动分层模型，我们编写驱动程序的时候只需要关注中间的驱动层、核心层和事件层，这三个层的分工如下：
驱动层：输入设备的具体驱动程序，比如按键驱动程序，向内核层报告输入内容。
核心层：承上启下，为驱动层提供输入设备注册和操作接口。通知事件层对输入事件进行处理。
事件层：主要和用户空间进行交互。

1.2 Input 驱动流程

image
image
image

注册 input_dev

在使用 input 子系统的时候我们只需要注册一个 input 设备即可，input_dev 结构体表示 input设备，此结构体定义在 include/linux/input.h 文件中，定义如下(有省略)：
image
image
继续回到示例代码 58.1.2.2 中，第 129 行~137 行的 evbit、keybit、relbit 等等都是存放不同事件对应的值。比如我们本章要使用按键事件，因此要用到 keybit，keybit 就是按键事件使用的位图，Linux 内核定义了很多按键值，这些按键值定义在 include/uapi/linux/input.h 文件中，按键值如下：
image
在编写 input 设备驱动的时候我们需要先申请一个 input_dev 结构体变量，使用input_allocate_device 函数来申请一个 input_dev，此函数原型如下所示：
image

  • 使用 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 */
}

上报输入事件

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

1.3 input_event结构体

image
image

2. 驱动代码

#include <linux/types.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/ide.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.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 <linux/of_irq.h>
#include <asm/mach/map.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/fcntl.h>                        /* 异步通知 */

#include <linux/input.h>

#define KEYINPUT_CNT            1               /* 设备号个数 */
#define KEYINPUT_NAME           "keyinput"      /* 名字 */
#define KEY0VALUE               0X01            /* KEY0 按键值 */
#define INVAKEY                 0XFF            /* 无效的按键值 */
#define KEY_NUM                 1               /* 按键数量 */

/* 可能会有好多按键，通过结构体数组来描述按键 */
/* 中断 IO 描述结构体 */
struct irq_keydesc {
    int gpio;                               /* gpio */
    int irqnum;                             /* 中断号 */
    unsigned char value;                    /* 按键对应的键值 */
    char name[10];                          /* 名字 */
    irqreturn_t (*handler)(int, void *);    /* 中断服务函数 */
};

/* irq设备结构体 */
struct keyinput_dev {
    dev_t               devid;          /* 设备号 */
    struct class        *class;         /* 类 */
    struct device       *device;        /* 设备 */
    struct device_node  *nd;            /* 设备节点 */

    struct timer_list   timer;          /* 定义一个定时器*/
    struct irq_keydesc  irqkeydesc[KEY_NUM]; /* 按键描述数组 */
    unsigned char       curkeynum;      /* 当前的按键号 */
    
    struct input_dev    *inputdev;      /* input 结构体 */
};

struct keyinput_dev  keyinputdev; /* 定义LED结构体 */

/* @description : 中断服务函数，开启定时器，延时 10ms，
* 定时器用于按键消抖。
* 两个参数是中断处理函数的必须写法
* @param - irq : 中断号
* @param - dev_id : 设备结构。
* @return : 中断执行结果
*/
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    struct keyinput_dev *dev = (struct keyinput_dev *)dev_id;

    /* 采用定时器削抖，如果再定时器时间内还是这个值，说明是真的按下了，在定时器中断中处理 */
    /* 这里设置为0是简易处理，因为只有一个按键 */
    /* 有其他按键要再建一个中断处理函数，并把curkeynum改成相应的按键值 */
    /* 注意不能所有按键用一个中断函数，第一是一起按的时候会出错 */
    /* 第二，无法用curkeynum判断使用的是第几个按键 */
    dev->curkeynum = 0;
    /* 传递给定时器的参数，注意要强转，在中断处理函数里面再转回来 */
    dev->timer.data = (volatile long)dev_id;
    /* mod_timer会启动定时器，第二个参数是要修改的超时时间 */
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));
    return IRQ_RETVAL(IRQ_HANDLED);
}

 /* @description : 定时器服务函数，用于按键消抖，定时器到了以后
* 再次读取按键值，如果按键还是处于按下状态就表示按键有效。
* @param – arg : 设备结构变量
* @return : 无
*/
void timer_function(unsigned long arg)
{
    unsigned char value;
    unsigned char num;
    struct irq_keydesc *keydesc;
    struct keyinput_dev *dev = (struct keyinput_dev *)arg; 

    /* 因为只有一个按键，这里是0 */
    num = dev->curkeynum;
    keydesc = &dev->irqkeydesc[num]; 
    value = gpio_get_value(keydesc->gpio); /* 读取 IO 值 */

    if(value == 0){ /* 按下按键 */
    /* 上报按键值 */
        //input_event(dev->inputdev, EV_KEY, keydesc->value, 1);
        input_report_key(dev->inputdev, keydesc->value, 1);/*1，按下*/
        input_sync(dev->inputdev);
    } else { /* 按键松开 */
        //input_event(dev->inputdev, EV_KEY, keydesc->value, 0);
        input_report_key(dev->inputdev, keydesc->value, 0);
        input_sync(dev->inputdev);//i
    }
}

/*
* @description : 按键 IO 初始化
* @param : 无
* @return : 无
*/
static int keyio_init(void)
{
    unsigned char i = 0;
    char name[10];
    int ret = 0;

    /* 1.获取key节点 */
    keyinputdev.nd = of_find_node_by_path("/key");
    if (keyinputdev.nd== NULL){
        printk("key node not find!\r\n");
        return -EINVAL;
    }
    /* 对每个按键都提取 GPIO */
    for (i = 0; i < KEY_NUM; i++) {
        keyinputdev.irqkeydesc[i].gpio = of_get_named_gpio(keyinputdev.nd, "key-gpios", i);
        if (keyinputdev.irqkeydesc[i].gpio < 0) {
            printk("can't get key%d\r\n", i);
        }
    }

    /* 初始化 key 所使用的 IO，并且设置成中断模式 */
    for (i = 0; i < KEY_NUM; i++) {
        /* 先对每一个IO命名 */
        /* 先对命名清0 */
        memset(keyinputdev.irqkeydesc[i].name, 0, sizeof(keyinputdev.irqkeydesc[i].name)); 
        /* 给IO命名 */
        sprintf(keyinputdev.irqkeydesc[i].name, "KEY%d", i); 
        /* 请求GPIO */
        gpio_request(keyinputdev.irqkeydesc[i].gpio, keyinputdev.irqkeydesc[i].name);
        
        /* 设置GPIO为输入 */
        gpio_direction_input(keyinputdev.irqkeydesc[i].gpio); 

        /* 获取中断号，以下为两个方法，都可以获取到 */
        /* 从interrupts属性里面获取 */
        /* 注意i是根据设备树里面设置了多少个就是多少个，都会获取到 */
        /* 下面的方法是通用的获取中断号的函数 */
        keyinputdev.irqkeydesc[i].irqnum = irq_of_parse_and_map(keyinputdev.nd, i);
#if 0
        /* 此方法是gpio获取中断号的方法 */
        keyinputdev.irqkeydesc[i].irqnum = gpio_to_irq(keyinputdev.irqkeydesc[i].gpio);
#endif
        printk("key%d:gpio=%d, irqnum=%d\r\n", i, keyinputdev.irqkeydesc[i].gpio,
                                                  keyinputdev.irqkeydesc[i].irqnum);
    }

    /* 2. 按键中断初始化 */
    /* 设置中断处理函数和按键初始值 */
    /* 因为只有一个key0.，所以这里也没用循环 */
    keyinputdev.irqkeydesc[0].handler = key0_handler;
    keyinputdev.irqkeydesc[0].value = KEY_0;
     /* 申请中断 */
    for (i = 0; i < KEY_NUM; i++) {
        /* request_irq参数
         * 中断号，中断函数，中断触发类型，中断名字，传递给中断处理函数的参数（第二个），这里传的结构体
         * */
        ret = request_irq(keyinputdev.irqkeydesc[i].irqnum, keyinputdev.irqkeydesc[i].handler,
                        IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
                        keyinputdev.irqkeydesc[i].name, &keyinputdev);
        if(ret < 0){
            printk("irq %d request failed!\r\n", keyinputdev.irqkeydesc[i].irqnum);
            return -EFAULT;
        }
    }

    /* 3. 创建定时器 */
    init_timer(&keyinputdev.timer);
    keyinputdev.timer.function = timer_function;
    /* 注意下面不能让定时器运行，因为要按下按键之后再运行 */
    /* 启动定时器通过mod_timer启动，通常在初始化阶段的定时器用的是add_timer */

    
    /* 申请 input_dev */
    keyinputdev.inputdev = input_allocate_device();
    keyinputdev.inputdev->name = KEYINPUT_NAME;

    keyinputdev.inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
    input_set_capability(keyinputdev.inputdev, EV_KEY, KEY_0);

    /* 注册输入设备 */
    ret = input_register_device(keyinputdev.inputdev);
    if (ret) {
        printk("register input device failed!\r\n");
        return ret;
    }
    return 0;
}

/* 模块入口函数 */
static int __init keyinput_init(void)
{
    keyio_init();
    return 0;
}

/* 模块出口函数 */
static void __exit keyinput_exit(void)
{
    unsigned int i = 0;
    /* 删除定时器 */
    del_timer_sync(&keyinputdev.timer);

    /* 释放中断 */
    for (i = 0; i < KEY_NUM; i++) {
        free_irq(keyinputdev.irqkeydesc[i].irqnum, &keyinputdev);
    }

    /* 释放 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("Shao Zheming");

应用代码:

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "linux/ioctl.h"
#include "poll.h"
#include "sys/select.h"
#include "sys/time.h"
#include "signal.h"

#include <linux/input.h>


/* 定义一个 input_event 变量，存放输入事件信息 */
static struct input_event inputevent;

/*
* @description : main 主程序
* @param - argc : argv 数组元素个数
* @param - argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("retor Usage!\r\n");
        return -1;
    }
    
    int fd;
    int ret = 0;
    char *filename;

    filename = argv[1];
    fd = open(filename, O_RDWR); /* 设置成非阻塞打开 */
    if(fd < 0)
    {
        printf("file %s open failed! \r\n", filename);
        return -1;
    }

    
    while (1) {
        ret = read(fd, &inputevent, sizeof(inputevent));

        if (ret > 0) { /* 读取数据成功 */
            printf("press\r\n");
            switch (inputevent.type) {
                case EV_KEY:
                    if (inputevent.code < BTN_MISC) { /* 键盘键值 */ /* 0x100是256，即所有值 */
                        printf("key %d %s\r\n", inputevent.code, inputevent.value ? "press" : "release");
                    } else {
                        printf("button %d %s\r\n", inputevent.code, inputevent.value ? "press" : "release");
                    }
                    break;

                /* 其他类型的事件，自行处理 */
                case EV_REL:
                    break;
                case EV_ABS:
                    break;
                case EV_MSC:
                    break;
                case EV_SW:
                    break;
            }
        } else {
            printf("读取数据失败\r\n");
        }
    }

    close(fd);
    return 0;
}

3. linux自带按键驱动测试

image
image
image

posted @   蘑菇王国大聪明  阅读(508)  评论(0)  编辑  收藏  举报
相关博文：
· Linux内核中断
· 内核定时器
· linux驱动-17-input子系统
· 23 Linux INPUT 子系统
· input子系统
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· AI技术革命，工作效率10个最佳AI工具
点击右上角即可分享
微信分享提示
AI IDE Trae