字符设备驱动——按键中断+定时器消抖

前言

写文章的目的是想通过记录自己的学习过程，以便以后使用到相关的知识点可以回顾和参考。

一、中断号

每个中断都有一个中断号，通过中断号即可区分不同的中断。在内核源码的根目录打开/arch/arm/mach-s5p6818/include/mach/s5p6818_irq.h，里面有如下内容：

可以看出一共有5*32=160个中断号提供给GPIO使用，每一个GPIO口对应一个中断号，有如下规则：GPIOA15对应的中断号为：IRQ_GPIO_A_START+15。
也可以通过函数gpio_to_irq获取gpio对应的中断号，函数原型如下：

int gpio_to_irq(unsigned int gpio)
函数参数和返回值含义如下：
gpio：要获取的 GPIO 编号。
返回值：GPIO 对应的中断号。

二、request_irq 函数和free_irq 函数

1、request_irq
request_irq 函数用于申请中断，request_irq函数可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用 request_irq 函数。request_irq 函数会激活(使能)中断，所以不需要我们手动去使能中断，request_irq 函数原型如下：

int request_irq(unsigned int irq, 
				irq_handler_t handler, 
				unsigned long flags,
 				const char *name, 
				void *dev)

函数参数和返回值含义如下：
irq：要申请中断的中断号。
handler：中断处理函数，当中断发生以后就会执行此中断处理函数。
flags：中断标志，可以在文件 include/linux/interrupt.h 里面查看所有的中断标志，这里我们介绍几个常用的中断标志，如下图所示：

这些标志可以通过“|”来实现多种组合。
name：中断名字，设置以后可以在/proc/interrupts 文件中看到对应的中断名字。
dev：如果将 flags 设置为 IRQF_SHARED 的话，dev 用来区分不同的中断，一般情况下将 dev 设置为设备结构体，dev 会传递给中断处理函数 irq_handler_t 的第二个参数。
返回值：0 中断申请成功，其他负值 中断申请失败，如果返回-EBUSY 的话表示中断已经被申请了。

2、free_irq 函数
使用完成以后就要通过 free_irq 函数释放掉相应的中断。如果中断不是共享的，那么 free_irq 会删除中断处理函数并且禁止中断。free_irq函数原型如下所示：

void free_irq(unsigned int irq, void dev)
函数参数和返回值含义如下：
irq：要释放的中断。
dev：如果中断设置为共享(IRQF_SHARED)的话，此参数用来区分具体的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉。
返回值：无。

三、中断处理函数

使用 request_irq 函数申请中断的时候需要设置中断处理函数，中断处理函数格式如下所示：

irqreturn_t (*irq_handler_t) (int, void *)

第一个参数是要中断处理函数要相应的中断号。第二个参数是一个指向 void 的指针，也就是个通用指针，需要与 request_irq 函数的 dev 参数保持一致。用于区分共享中断的不同设备，dev 也可以指向设备数据结构。中断处理函数的返回值为 irqreturn_t 类型，irqreturn_t 类型定义如下所示：

enum irqreturn {
	IRQ_NONE = (0 << 0),
	IRQ_HANDLED = (1 << 0),		/* 中断处理结束，正常返回 */
	IRQ_WAKE_THREAD = (1 << 1),
};
typedef enum irqreturn irqreturn_t;

可以看出 irqreturn_t 是个枚举类型，一共有三种返回值。一般中断服务函数返回值使用如下形式：

return IRQ_RETVAL(IRQ_HANDLED)

四、实验

s5p6818上有四个按键，它们的引脚分别接到是GPIOB31,GPIOB30,GPIOA28,GPIOB9上，通过对这四个gpio申请双边沿触发中断，就能够实现按键检测功能，并且采用上一章学到的定时器来实现按键消抖。
大概思路：

1、驱动程序

#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/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <cfg_type.h>


#define KEY_CNT     1           /* 设备号个数 */
#define KEY_NAME    "key_irq"   /* 设备名字 */
#define KEY_NUM     4           /* 按键的个数 */
#define INVAKEY     0xFF        /* 无效键值 */
const static unsigned int KEY_VALUE[4]={0x01, 0x02, 0x03, 0x04};    /* 有效键值 */


struct keyirq_dev{
    dev_t devid;                    /* 设备号 */
    struct cdev cdev;               /* cdev */
    struct class *class;            /* 类 */
    struct device *device;          /* 设备 */
    int major;                      /* 主设备号 */
    int minor;                      /* 次设备号 */
    unsigned int key_value[KEY_NUM];/* 键值 */
    unsigned int releasekey;        /* 标记完成一次完整的按键 */
    spinlock_t lock;                /* 自旋锁 */
    unsigned int curkeynum;         /* 当前的按键号 */
    struct timer_list timer;        /* 定义一个定时器 */
}; 

struct keyirq_dev keyirqdev;

struct key_irq_info{
    unsigned int gpio;      /* gpio标号 */
    char *name;             /* 名字 */
    int irqnum;             /* 中断号 */
    irqreturn_t (*irq_handler_t)(int, void*); /* 中断服务函数 */
};

/* GPIOB31,GPIOB30,GPIOA28,GPIOB9 */
/* gpio信息的结构体数组 */
const struct key_irq_info key_irq_info_tbl[KEY_NUM] = {
    {
        .gpio = PAD_GPIO_B+31,
        .name = "gpiob31",
        .irqnum = IRQ_GPIO_B_START+31,
    },
    {
        .gpio = PAD_GPIO_B+30,
        .name = "gpiob30",
        .irqnum = IRQ_GPIO_B_START+30,
    },
    {
        .gpio = PAD_GPIO_A+28,
        .name = "gpioa28",
        .irqnum = IRQ_GPIO_A_START+28,
    },
    {
        .gpio = PAD_GPIO_B+9,
        .name = "gpiob9",
        .irqnum = IRQ_GPIO_B_START+9,
    },
};

/* 按键中断服务函数 */
static irqreturn_t key_irqhandler(int irq, void *dev)
{
    int i;

    struct keyirq_dev *dev_t = (struct keyirq_dev *)dev;

    /* 判断是哪个按键按下了 */
    for(i=0;i<KEY_NUM;i++){
        if(gpio_get_value(key_irq_info_tbl[i].gpio) == 0){
            dev_t->curkeynum = i;
        }
    }
    dev_t->timer.data = (volatile long)dev;
    mod_timer(&dev_t->timer, jiffies + msecs_to_jiffies(10));   /* 启动一个10ms的定时器 */

    return IRQ_RETVAL(IRQ_HANDLED);
}

/* 定时器服务函数 */
void timer_function(unsigned long arg)
{
    unsigned int num;
    unsigned int value;

    struct keyirq_dev *dev_t = (struct keyirq_dev *)arg;
    num = dev_t->curkeynum;
    value = gpio_get_value(key_irq_info_tbl[num].gpio);
    if(value == 0){ /* 按下 */
        
    }else{  /* 弹起,完成一次完整的按键 */
        spin_lock(&dev_t->lock);   
        dev_t->key_value[num] = KEY_VALUE[num];     
        dev_t->releasekey = 1;
        spin_unlock(&dev_t->lock);  
    }
}

static int key_open(struct inode *inode, struct file *filp)
{
    int i,ret;
    unsigned long flags;

    filp->private_data = &keyirqdev;

    /* 把GPIO设置为输入模式 */
    for(i=0;i<KEY_NUM;i++){
        ret = gpio_direction_input(key_irq_info_tbl[i].gpio);
        if(ret < 0){
            printk(KERN_EMERG "set input failed!\r\n");
        }

        /* 初始化键值 */
        spin_lock_irqsave(&keyirqdev.lock, flags);   /* 上锁 */
        keyirqdev.key_value[i] = INVAKEY;
        spin_unlock_irqrestore(&keyirqdev.lock, flags); /* 释放锁 */
    }
    return 0;
}

static ssize_t key_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int i;
    unsigned int keyvalue[4];
    int retvalue;
    unsigned long flags;

    struct keyirq_dev *dev_t = filp->private_data;

    if(dev_t->releasekey == 1){     /* 完成一次按键操作 */
        for(i=0;i<KEY_NUM;i++)
        {
            keyvalue[i] = dev_t->key_value[i];

            spin_lock_irqsave(&dev_t->lock, flags);   /* 上锁 */
            dev_t->key_value[i] = INVAKEY;      /* 无效键值 */
            spin_unlock_irqrestore(&dev_t->lock, flags); /* 释放锁 */
        }
        dev_t->releasekey = 0;
    }else{
        for(i=0;i<KEY_NUM;i++)
            keyvalue[i] = dev_t->key_value[i];
    }
    retvalue = copy_to_user(buf, keyvalue, sizeof(keyvalue));

    return 0;
}

static ssize_t key_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}

static int key_realease(struct inode *inode, struct file *filp)
{
    return 0;
}

static struct file_operations key_fops = {
    .owner = THIS_MODULE,
    .open = key_open,
    .read = key_read,
    .write = key_write,
    .release = key_realease,
};

static int __init keys_init(void)
{
    int retvalue;
    int i;

    /* 初始化自旋锁 */
    spin_lock_init(&keyirqdev.lock);

    /* 初始化定时器 */
    init_timer(&keyirqdev.timer);
    keyirqdev.timer.function = timer_function;

    /* 申请GPIO */
    for(i=0; i<KEY_NUM; i++)  //先释放
		gpio_free(key_irq_info_tbl[i].gpio);

    for (i=0;i<KEY_NUM;i++){
        retvalue = gpio_request(key_irq_info_tbl[i].gpio, key_irq_info_tbl[i].name);
        if(retvalue < 0){
            printk(KERN_EMERG "kernel gpio_request failed!\r\n");
            return -EIO;
        }
    }
    /* 为4个GPIO申请中断 */
    for (i=0;i<KEY_NUM;i++){
        retvalue = request_irq(key_irq_info_tbl[i].irqnum,
                               key_irqhandler,
                               IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
                               key_irq_info_tbl[i].name,
                               &keyirqdev);

        if(retvalue < 0){
            printk("request %s irq failed!\r\n",key_irq_info_tbl[i].name);
            return -EFAULT;
        }
    }
    
    /* 注册设备号 */
    if(keyirqdev.major){
        keyirqdev.devid = MKDEV(keyirqdev.major, 0);
        retvalue = register_chrdev_region(keyirqdev.devid, KEY_CNT, KEY_NAME);
    }else{
        retvalue = alloc_chrdev_region(&keyirqdev.devid, 0, KEY_CNT, KEY_NAME);
        keyirqdev.major = MAJOR(keyirqdev.devid);
        keyirqdev.minor = MINOR(keyirqdev.devid);
    }
    if(retvalue < 0){
        printk(KERN_EMERG "kernel register chrdev failed!\r\n");
        return -EIO;
    }
    printk(KERN_EMERG "key_major = %d\r\n",keyirqdev.major);
	printk(KERN_EMERG "key_minor = %d\r\n",keyirqdev.minor);

    /* 初始化字符设备 */
    cdev_init(&keyirqdev.cdev, &key_fops);

    /* 把字符设备添加到内核 */
    cdev_add(&keyirqdev.cdev, keyirqdev.devid, KEY_CNT);

    /* 创建类 */
    keyirqdev.class = class_create(THIS_MODULE, KEY_NAME);

    /* 创建设备 */
    keyirqdev.device = device_create(keyirqdev.class, NULL, keyirqdev.devid, NULL, KEY_NAME);

    return 0;
}

static void __exit keys_exit(void)
{
    int i;

    /* 释放GPIO */
    for(i=0; i<4; i++)
		gpio_free(key_irq_info_tbl[i].gpio);

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

    /* 释放中断 */
    for(i=0; i<4; i++)
        free_irq(key_irq_info_tbl[i].irqnum, &keyirqdev);


    device_destroy(keyirqdev.class, keyirqdev.devid);
    class_destroy(keyirqdev.class);
    cdev_del(&keyirqdev.cdev);
    unregister_chrdev_region(keyirqdev.devid, KEY_CNT);
}

module_init(keys_init);
module_exit(keys_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("xzj");

2、应用程序

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

const static unsigned int KEY_VALUE[4]={0x01, 0x02, 0x03, 0x04};    /* 有效键值 */

int main(int argc , char *argv[])
{
    int fd, retvalue, i;
    char *filename;
    unsigned int keyvalue[4];

    if(argc != 2){
        printf("Error Usage!\r\n");
        return -1;
    }

    filename = argv[1];

    /* 打开驱动文件 */
    fd = open(filename, O_RDWR);
    if(fd < 0){
        printf("Can't open file %s\r\n", filename);
        return -1;
    }

    /* 循环读按键 */
    while(1)
    {
        retvalue = read(fd, keyvalue, sizeof(keyvalue));
    
        for(i=0; i<4; i++){
            if(keyvalue[i] == KEY_VALUE[i]){
                printf("KEY PRESS, value = %#X\r\n",keyvalue[i]);
            }
        }  
    }

    /* 关闭设备 */
    retvalue = close(fd);
    if(retvalue < 0){
        printf("Can't close file %s\r\n", filename);
        return -1;
    }

    return 0;
}

3、测试