Input子系统：按键驱动

1. 环境：

1.1 开发板：正点原子 I.MX6U ALPHA V2.2

1.2 开发PC：Ubuntu20.04

1.3 U-boot：uboot-imx-rel_imx_4.1.15_2.1.0_ga.tar.bz2

1.4 LInux内核：linux-imx-rel_imx_4.1.15_2.1.0_ga.tar.bz2

1.5 rootfs：busybox-1.29.0.tar.bz2制作

1.6 交叉编译工具链：gcc-linaro-4.9.4-2017.01-x86_64_arm-linux-gnueabihf.tar.xz

 

2. 硬件控制说明

2.1 由GPIO1 PIN18控制，高---松开， 低---按下

 

3. 设备树修改

3.1 在节点iomuxc/imx6ul-evk下新增pinctrl_key节点，如下

    pinctrl_key: keygrp {
        fsl,pins = <
            MX6UL_PAD_UART1_CTS_B__GPIO1_IO18            0xF080
        >;
    };

 

 3.2 在根目录"/"中创建"gpiokey"子节点

    gpiokey {
        compatible = "imx-gpiokeys";    

        #address-cells = <1>;
        #size-cells = <1>;
        pinctrl-names = "default";
        pinctrl-0 = <&pinctrl_key>;
        key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>;
        interrupt-parent = <&gpio1>;
        interrupts = <18 IRQ_TYPE_EDGE_BOTH>;
        status = "okay";
    };

 

 3.3 检查设备树，将本GPIO做其他用途的属性注释掉

 

4. 驱动代码

#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/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/input.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>


//自定义一个结构体，将一些需要的变量放在其中，以便管理
struct key_device
{  
    struct device_node *node;       //key 设备节点
    struct input_dev *key_inputdev; //输入设备结构体
    int key_gpio;                   //用于保存GPIO编号
    int key_irqnum;                 //用于保存中断号
    unsigned char key_value;        //用于包括按键号
    irqreturn_t (*handler)(int, void *);      //中断处理函数指针
    struct timer_list timer;                  //定时器
};

struct key_device key_in;

//中断处理函数
static irqreturn_t key_handler(int irq, void *dev_id)
{
    struct key_device *key0 = (struct key_device *)dev_id;
    key0->timer.data = (volatile long)dev_id;

    //启动定时器，延时10ms，相当于是按键滤波
    mod_timer(&key0->timer, jiffies + msecs_to_jiffies(10));
    
    return IRQ_RETVAL(IRQ_HANDLED);
}

//定时器处理函数，当按键滤波完成，并且确定产生按键动作时，此函数用于上报按键值
void timer_function(unsigned long arg)
{
    unsigned char value;

    struct key_device *key = (struct key_device *)arg;

    //根据GPIO编号，获取当前读取到的值
    value = gpio_get_value(key->key_gpio);

    //上报按键值，1--松开    0--按下
    if(0 == value)
    {
        input_report_key(key->key_inputdev, key->key_value, 1);
        input_sync(key->key_inputdev);
    }
    else
    {
        input_report_key(key->key_inputdev, key->key_value, 0);
        input_sync(key->key_inputdev);
    }

}


static int __init gpiokey_init(void)
{
    int ret = 0;

    //获取按键节点
    key_in.node = of_find_node_by_path("/gpiokey");
    if(key_in.node == NULL)
    {
        printk("key node find fail\n");
        return -EINVAL;
    }

    //获取GPIO编号
    key_in.key_gpio = of_get_named_gpio(key_in.node, "key-gpio", 0);    //key-gpio为dts下gpiokey节点的key-gpio属性
    if(key_in.key_gpio < 0)
    {
        printk("gpio get fail\n");
    }

    gpio_request(key_in.key_gpio,"key0");   //申请GPIO
    gpio_direction_input(key_in.key_gpio);  //设置GPIO为输入
    key_in.key_irqnum = irq_of_parse_and_map(key_in.node, 0);   //获取中断号

    key_in.handler = key_handler;  //中断函数，上半部
    key_in.key_value = KEY_0;

    //注册中断
    ret = request_irq(key_in.key_irqnum, key_in.handler, IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING, "KEY0", &key_in);
    if(ret < 0)
    {
         printk("request_irq fail,the irqnum is %d\n",key_in.key_irqnum);
         return -EFAULT;
    }

    init_timer(&key_in.timer);  //初始化定时器，此时时钟不会运行，等待mod_timer函数唤醒
    key_in.timer.function = timer_function; //定时器处理函数

    //申请一个输入设备
    key_in.key_inputdev = input_allocate_device();
    key_in.key_inputdev->name = "keyinputdev";

    //设置事件
    key_in.key_inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
    input_set_capability(key_in.key_inputdev, EV_KEY, KEY_0);   //KEY_0--事件码，include\uapi\linux\input.h

    ret = input_register_device(key_in.key_inputdev);
    if(ret < 0)
    {
         printk("input_register_device fail\n");
         return ret;
    }

    return 0;
}

static void __exit gpiokey_exit(void)
{   
    gpio_free(key_in.key_gpio);
    del_timer_sync(&key_in.timer);
    free_irq(key_in.key_irqnum,&key_in);
    input_unregister_device(key_in.key_inputdev);
    input_free_device(key_in.key_inputdev);
   
}

module_init(gpiokey_init);
module_exit(gpiokey_exit);
MODULE_LICENSE("Dual BSD/GPL");

 

5. 测试代码

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/input.h>

int main(int argc, char **argv)
{
    int fd,err;
    static struct input_event key_inputevent;


    fd = open("/dev/input/event1", O_RDWR);

    printf("fd = %d\n", fd);
    if(fd < 0)
    {
        perror("open fail!\n");

        exit(1);
    }

    while(1)
    {   
        err = read(fd, &key_inputevent, sizeof(key_inputevent));
        if(err < 0)
        {
            printf("read fail\n");
            return -1;
        }
        else
        {
            switch(key_inputevent.type)
            {
                case EV_KEY:
                        printf("key input code is %x   && value is %x\n", key_inputevent.code, key_inputevent.value);
                        break;
                default:
                        break;
            }
        }

    }

    close(fd);
    return 0;
}

 

总结：

1. 此input之系统按键驱动，涉及到了中断、定时器

2. 本驱动中断处理放在了上半部，如果是其他比较耗时的中断处理，需要放到中断下半部

3. input子系统产生的文件为/dev/input/eventxx，具体是哪个，可以未加载ko前先查看，然后再加载查看；是否可能指定文件名？不然有多个input ko该如何快速有效区分？

4. 本驱动大概流程为：1.设备树增加pinctrl_、按键节点-->2.获取设备树中的资源-->3.申请、设置GPIO-->4.注册中断-->5.输入设备申请、设置-->6.中断处理函数