输入子系统-CSDN博客

本文链接：https://blog.csdn.net/ZMFeng__/article/details/49925953

- 概述
- 设计流程

1. 概述

1.1 定义

定义
内核的输入子系统是对分散的、多种不同类别的输入设备(如键盘、鼠标、跟踪球、操作杆、触摸屏、加速计和手写板)进行统一处理的驱动程序。
优点
- 统一了物理形态各异的相似的输入设备的处理功能。例如，各种鼠标，不论是PS/2、USB，还是蓝牙，都做同样的处理；
- 提供了用于分发输入报告给用户应用程序的简单的事件接口；
- 抽取出了输入驱动程序的通用部分，简化了驱动程序，并引入了一致性。
位置
- /dev/input目录下显示的是已经注册在内核中的设备编程接口，用户通过查看这些设备文件来打开不同的输入设备进行硬件操作。
- 输入子系统由内核代码drivers/input/input.c构成，它的存在屏蔽了用户到设备驱动的交互细节，为设备驱动层和事件处理层提供了相互通信的统一界面。

1.2 层次结构

Linux input subsystem 从上到下由三层实现：
* 输入子系统事件处理层：是用户编程的接口（设备节点），并处理驱动层提交的数据处理。
* 输入子系统核心层：为设备驱动层提供了规范和接口。设备驱动层只要关心如何驱动硬件并获得硬件数据（例如按下的按键数据），然后调用核心层提供的接口，核心层会自动把数据提交给事件处理层。
* 输入子系统设备驱动层：主要实现对硬件设备的读写访问，中断设置，并把硬件产生的事件转换为核心层定义的规范提交给事件处理层。

输入子系统的时间处理机制：

1.3 数据结构

struct input_dev 物理输入设备的基本数据结构，包含了设备相关的一些信息。该结构体主要用于初始化输入设备。

struct input_dev {  
    const char      *name;  // 输入设备名字
    const char      *phys;  // 设备在系统中的物理路径
    const char      *uniq;  // 设备的唯一标识码（如果设备有）
    /*
    输入输出控制码(0x00 - 0x7f)
    struct input_id {
        __u16 bustype; // 类型号
        __u16 vendor;  // 供应商
        __u16 product; // 产品号
        __u16 version; // 版本号
    };
    */
    struct input_id id;  
    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)];  
    unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];  
    unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];  
    unsigned long swbit[BITS_TO_LONGS(SW_CNT)];  
    ..... 
    struct device           dev;  //内嵌的设备结构体
    // h_list：表示与这个input_dev相联系的前后一个handler
    struct list_head        h_list;  
    // node链表：将此Input_dev连接到全局的input_dev_list链表中，
    // 内核中所有的Input_dev都连接在其上；
    struct list_head        node;  
};

输入事件本身

struct input_event {
    struct timeval time;    // 时间戳
    __u16 type;             // 输入设备的类型：按键和移动鼠标就是不同的类型
    __u16 code;             // 输入设备的编码
    __s32 value;            // 输入设备事件值：按键a和按键b就会对应不同值
};

2. 设计流程

2.1 设计流程

步骤
- 在驱动模块加载函数中设置Input设备支持input子系统的哪些事件；
- 将Input设备注册到input子系统中；
- 在Input设备发生输入操作时(如：键盘被按下/抬起、触摸屏被触摸/抬起/移动、鼠标被移动/单击/抬起时等)，提交所发生的事件及对应的键值/坐标等状态。
流程图

2.2 接口API

2.2.1 分配和撤销一个输入设备

#include <linux/input.h>
/* 返回值：成功返回一个输入设备结构，失败返回NULL */
struct input_dev *input_allocate_device*(void);
void input_unregister_device(struct input_dev *);

2.2.2 注册和撤销一个输入设备

#include <linux/input.h>
/* 返回值：成功返回0，失败返回-1 */
int input_register_device(struct input_dev *dev);
void input_free_device(struct input_dev *dev);

2.2.3 事件支持

/* 告诉input子系统支持哪些事件 */
set_bit(EV_KEY,button_dev.evbit);
/*
 * struct input_dev中有两个成员：
 * evbit：表示设备所支持的事件类型
 * keybit：表示设备所支持的按键类型
 */

事件类型

标志	值	含义
EV_SYN	0x00	同步事件（表示设备支持所有的事件）
EV_KEY	0x01	按键事件（键盘或者按键，表示一个键码）
EV_REL	0x02	相对坐标（鼠标设备，表示一个相对的光标位置结果）
EV_ABS	0x04	绝对坐标（触摸屏产生的值，其是一个绝对整数值）
EV_MSC	0x04	其它类型
EV_LED	0x11	LED灯设备
EV_SND	0x12	声音（蜂鸣器，输入声音）
EV_REP	0x14	Repeat（允许重复按键类型）
EV_FF	0x15	力反馈
EV_PWR	0x16	电源管理事件

* 按键类型
见<linux/input.h>第112行

2.2.4 报告事件

#inclued <linux/input.h>
//报告指定type,code的输入事件
void input_event(struct input_dev *dev,unsigned int type,
                    unsigned int code,int value);
//报告键值
void input_report_key(struct input_dev *dev,
                        unsigned int code,int value);
//报告相对坐标
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_sync(struct input_dev *dev);//报告同步事件

/* 在触摸屏驱动设计中，一次坐标及按下状态的整个报告过程如下 */
input_report_abs(input_dev,ABS_X,x);//X坐标
input_report_abs(input_dev,ABS_Y,y);//Y坐标
input_report_abs(input_dev,ABS_PRESSURE,pres);//压力
/* report 之后必须同步 */ 
input_sync(struct input_dev *dev);//同步

2.3 一个实例

#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <asm/gpio.h>   //芯片S5PV210

#define KEY_NUM     8

static struct pin_desc{
    int     irq;            //按键中断号
    char    *key_name;      //按键名称
    unsigned int    pin;        //按键引脚
    unsigned int    key_val;    //按键值
};

static struct pin_desc pins_desc[KEY_NUM] = {
    { IRQ_EINT(16), "key1", S5PV210_GPH2(0), KEY_1 },
    { IRQ_EINT(17), "key2", S5PV210_GPH2(1), KEY_2 },
    { IRQ_EINT(18), "key3", S5PV210_GPH2(2), KEY_3 },
    { IRQ_EINT(19), "key4", S5PV210_GPH2(3), KEY_4 },
    { IRQ_EINT(24), "key5", S5PV210_GPH3(0), KEY_5 },
    { IRQ_EINT(25), "key6", S5PV210_GPH3(1), KEY_6 },
    { IRQ_EINT(26), "key7", S5PV210_GPH3(2), KEY_7 },
    { IRQ_EINT(27), "key8", S5PV210_GPH3(3), KEY_8 },
};

static struct input_dev *button_dev;
static struct pin_desc *irq_pin_desc;

static irqreturn_t button_interrupt(int irq, void *dev_id)
{
    int value;
    irq_pin_desc = (struct pin_desc *)dev_id;
    value = gpio_get_value(irq_pin_desc->pin);  
    input_report_key(button_dev, irq_pin_desc->key_val, !value);
    input_sync(button_dev);
    return IRQ_HANDLED;
}

static int __init button_init(void)
{
    int ret, i;
    for(i = 0; i < KEY_NUM; i++){
        ret = gpio_request(pins_desc[i].pin, pins_desc[i].key_name);
        if(ret){
            printk(KERN_ERR "gpio_request Failed to register device\n");
            goto err_gpio_request;
        }       
    }

    button_dev = input_allocate_device();
    if (!button_dev) {
        printk(KERN_ERR "can't allocate input mem!\n");
        ret = -ENOMEM;
        goto err_input_allocate_device;
    }
    button_dev->name = "gec_input";
    button_dev->id.bustype = 0x1;
    button_dev->id.product = 0x2;
    button_dev->id.vendor  = 0x3;
    button_dev->id.version = 0x4;

    /* 设置事件为按键事件 */  
    set_bit(EV_KEY, button_dev->evbit);  
    //set_bit(EV_REP, button_dev->evbit);  

    /* 设置按键操作的详细事件 */  
    set_bit(KEY_1, button_dev->keybit);  
    set_bit(KEY_2, button_dev->keybit);  
    set_bit(KEY_3, button_dev->keybit);  
    set_bit(KEY_4, button_dev->keybit);
    set_bit(KEY_6, button_dev->keybit);
    set_bit(KEY_7, button_dev->keybit);
    set_bit(KEY_8, button_dev->keybit);


    ret = input_register_device(button_dev);
    if (ret) {
        printk(KERN_ERR "Failed to register device\n");
        goto input_register_device;
    }
    for(i = 0; i < KEY_NUM; i++){
        ret = request_irq(pins_desc[i].irq, button_interrupt,\
                IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_DISABLED, pins_desc[1].key_name, &pins_desc[i]);
        if (ret) 
        {
            printk(KERN_ERR "Can't request irq %d\n", IRQ_EINT(16));
            goto err_request_irq;
        }
    }

    return 0;

/* 错误处理 */
err_request_irq:
    for(i = i - 1; i >= 0; i--)  
    {  
        free_irq(pins_desc[i].irq, &pins_desc[i]);  
    } 
    input_unregister_device(button_dev);
input_register_device:
    input_free_device(button_dev);
err_input_allocate_device:
    for(i = 0; i < KEY_NUM; i++){
        gpio_free(pins_desc[i].pin);        
    }
err_gpio_request:
    return ret;
}

static void __exit button_exit(void)
{
    int i;
    gpio_free(S5PV210_GPH2(0)); 
    for(i = 0; i < sizeof(pins_desc)/sizeof(pins_desc[0]); i++)  
    {  
        free_irq(pins_desc[i].irq, &pins_desc[i]);  
    }  
    input_unregister_device(button_dev);
}

module_init(button_init);
module_exit(button_exit);

MODULE_LICENSE("GPL");