OK6410（256M RAM ，1G SLC NAND）Linux-3.8.3驱动（5.2.2）按键中断驱动2.2

实现功能：通过中断服务函数读取按键值，在没有中断的时候休眠以降低cpu使用率

1.驱动程序button_irq.c代码如下

//moudle.h 包含了大量加载模块需要的函数和符号的定义
#include <linux/module.h>
//kernel.h以便使用printk()等函数
#include <linux/kernel.h>
//fs.h包含常用的数据结构，如struct file等
#include <linux/fs.h>
//uaccess.h 包含copy_to_user()，copy_from_user()等函数
#include <linux/uaccess.h>
//io.h 包含inl()，outl()，readl()，writel()等IO口操作函数
#include <linux/io.h>
#include <linux/miscdevice.h>
#include <linux/pci.h>
//init.h来指定你的初始化和清理函数，例如：module_init(init_function)、module_exit(cleanup_function)
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/gpio.h>
#include <linux/irq.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
//irq.h中断与并发请求事件
#include <asm/irq.h>
//下面这些头文件是IO口在内核的虚拟映射地址，涉及IO口的操作所必须包含
//#include <mach/gpio.h>
#include <mach/regs-gpio.h>
#include <plat/gpio-cfg.h>
#include <mach/hardware.h>
#include <mach/map.h>


static struct class *button_irq_class;
static int major;

static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

/* 中断事件标志, 中断服务程序将它置1，button_irq_read将它清0 */

static volatile int ev_press = 0;

struct pin_desc {
    unsigned int pin;
    unsigned int button_val;
};

static unsigned char button_val;

static struct pin_desc pins_desc[6] = {

    {S3C64XX_GPN(0), 0x01},
    {S3C64XX_GPN(1), 0x02},
    {S3C64XX_GPN(2), 0x03},
    {S3C64XX_GPN(3), 0x04},
    {S3C64XX_GPN(4), 0x05},
    {S3C64XX_GPN(5), 0x06},
};

/*中断服务函数*/
/* 键值: 按下时, 0x01, 0x02, 0x03, 0x04 ...*/

/* 键值: 松开时, 0x81, 0x82, 0x83, 0x84 ...*/
static irqreturn_t button_irq(int irq, void *dev_id)

{
    struct pin_desc *pindesc = (struct pin_desc *)dev_id;
    unsigned char pinval;

    pinval = gpio_get_value(pindesc->pin);

    if(pinval == 1)
        button_val = 0x80 | pindesc->button_val;
    else
        button_val = pindesc->button_val;

    ev_press = 1; /* 表示中断发生了 */

    wake_up_interruptible(&button_waitq); /* 唤醒休眠的进程 */

    return IRQ_HANDLED;

}

static int button_irq_open(struct inode *inode, struct file *file)
{
    int ret;

    /*request_irq注册中断
     *第一个参数是中断号，也是中断处理函数button_irq的第一个参数
     *第二个参数是中断处理函数
     *第三个参数是中断触发方式
     *第四个参数是设备名称
     *第五个参数是设备ID，也是中断处理函数button_irq的第二个参数
     */
    ret = request_irq(IRQ_EINT(0), button_irq, IRQ_TYPE_EDGE_BOTH, "k1", &pins_desc[0]);
    if (ret){
        printk("request IRQ_EINT(0) error!\n");
        free_irq(IRQ_EINT(0), &pins_desc[0]);
    }
    ret = request_irq(IRQ_EINT(1), button_irq, IRQ_TYPE_EDGE_BOTH, "k2", &pins_desc[1]);
    if (ret){
        printk("request IRQ_EINT(1) error!\n");
        free_irq(IRQ_EINT(1), &pins_desc[1]);
    }

    ret = request_irq(IRQ_EINT(2), button_irq, IRQ_TYPE_EDGE_BOTH, "k3", &pins_desc[2]);
    if (ret){
        printk("request IRQ_EINT(2) error!\n");
        free_irq(IRQ_EINT(2), &pins_desc[2]);
    }

    ret = request_irq(IRQ_EINT(3), button_irq, IRQ_TYPE_EDGE_BOTH, "k4", &pins_desc[3]);
    if (ret){
        printk("request IRQ_EINT(3) error!\n");
        free_irq(IRQ_EINT(3), &pins_desc[3]);
    }

    ret = request_irq(IRQ_EINT(4), button_irq, IRQ_TYPE_EDGE_BOTH, "k5", &pins_desc[4]);
    if (ret){
        printk("request IRQ_EINT(4) error!\n");
        free_irq(IRQ_EINT(4), &pins_desc[4]);
    }

    ret = request_irq(IRQ_EINT(5), button_irq, IRQ_TYPE_EDGE_BOTH, "k6", &pins_desc[5]);
    if (ret){
        printk("request IRQ_EINT(5) error!\n");
        free_irq(IRQ_EINT(5), &pins_desc[5]);
    }
    return 0;
}

static ssize_t button_irq_read(struct file *file, char __user *buf, size_t size, loff_t * ppos)
{
    if (size != 1)

        return -EINVAL;

    /* 如果没有按键动作, 休眠 */
    /*ev_press=0时休眠，ev_press=1时继续向下执行程序*/

    wait_event_interruptible(button_waitq, ev_press);

    /* 如果有按键动作, 返回键值 */

    if( copy_to_user(buf, &button_val, 1) ){
        printk("error in function ‘copy_to_user’ !\n");
            return -EFAULT;
    }

    ev_press = 0;
    return 0;
}

static ssize_t button_irq_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
    return 0;
}

static int button_irq_release(struct inode *inode, struct file *file)

{
    free_irq(IRQ_EINT(0), &pins_desc[0]);
    free_irq(IRQ_EINT(1), &pins_desc[1]);
    free_irq(IRQ_EINT(2), &pins_desc[2]);
    free_irq(IRQ_EINT(3), &pins_desc[3]);
    free_irq(IRQ_EINT(4), &pins_desc[4]);
    free_irq(IRQ_EINT(5), &pins_desc[5]);

    return 0;
}

static struct file_operations button_irq_fops = {
    .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
    .open = button_irq_open,
    .read = button_irq_read,
    .write = button_irq_write,
    .release = button_irq_release,
};

static int button_irq_init(void)
{
    major = register_chrdev(0, "button_irq_dev", &button_irq_fops);//注册，告诉内核
    button_irq_class = class_create(THIS_MODULE, "button_irq_cls");
    device_create(button_irq_class, NULL, MKDEV(major, 0), NULL, "button_irq");/* /dev/button_irq */

    return 0;
}

static void button_irq_exit(void)
{
    unregister_chrdev(major, "button_irq_cls");
    device_destroy(button_irq_class, MKDEV(major, 0));
    class_destroy(button_irq_class);
}

module_init(button_irq_init);
module_exit(button_irq_exit);

MODULE_LICENSE("GPL");

2.测试程序button_irq_test.c代码如下

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

int main(int argc, char **argv)
{
    int fd;
    unsigned char button_val;
    int cnt = 0;
    fd = open("/dev/button_irq", O_RDWR);
    if (fd < 0)
    {
        printf("can't open!\n");
        return 0;
    }

    while(1)
    {
        read(fd, &button_val, 1);
        printf("button_val = 0x%x\n", button_val);
    }
    return 0;
}

3.原理
    测试程序中虽然也是用到了死循环while(1)；但是在read(fd, &button_val, 1);时，调用了驱动程序的button_irq_read函数，在这个函数中，在没有发生中断的情况下（即没有调用中断服务程序button_irq），ev_press=0，wait_event_interruptible(button_waitq, ev_press);函数使得程序处于休眠状态，降低了cpu使用率。
    按键被按下时，产生了中断，调用了中断服务程序button_irq，在中断服务程序button_irq中，ev_press的值被设为1，同时唤醒了休眠的进程，使得button_irq_read函数中的copy_to_user得以执行，将读取的按键值传递给测试程序，打印出按键值。