Linux下阻塞IO驱动实验实例一

一.  简介

前面几篇文章学习了 Linux内核提供的 阻塞与非阻塞IO相关的知识。

应用程序以阻塞方式访问设备时，Linux内核提供了等待队列来处理。当应用程序以非阻塞方式访问设备时，Linux内核提供了 poll轮训机制来处理。

前面一篇文章学习了Linux内核提供的非阻塞式访问设备的处理机制-等待队列。文章地址如下：

Linux 内核中处理阻塞访问的方法：等待队列-CSDN博客

本文通过写驱动来实现，Linux下应用程序以阻塞方式访问设备。

二.  Linux下阻塞IO驱动实验实例一

本文在前面实验 13_key_irq 的基础上进行更改。

 1.  创建工程

本实验是在上面定时器消抖实验代码的基础上进行更改的。

（1）首先，创建 14_block_io工程目录：

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers$ mkdir 14_block_io

（2）其次，将 13_key_irq工程目录下所有文件拷贝到 14_block_io 目录下：

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/14_wait_queue$ cp ../13_key_irq/* ./ -rf

将 .vscode及其下文件也拷贝到 14_block_io目录下：

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/14_wait_queue$ cp ../13_key_irq/.vscode/ ./ -rf

注意： .vscode目录下的文件，设置了驱动可能会调用到的 Linux内核源码（这里是NXP官方提供的Linux内核源码）的路径。

2.  Linux下阻塞IO驱动代码实现

因为应用程序以阻塞式访问设备，所以，这里Linux驱动来使用等待队列的方法进行处理。

这里具体使用  "等待事件"+"等待唤醒" 来实现，主要使用的等待队列函数如下：

wait_event(wq, condition)
void wake_up(wait_queue_head_t *q)

加入阻塞处理后，key_irq.c文件代码如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.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/timer.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/types.h>
#include <asm/atomic.h>
#include <linux/wait.h>
#include <linux/sched.h>


#define   IRQ_NAME          "key_irq"
#define   IRQ_CNT           1
#define   KEY_NUM           1 
#define   KEY0_VALUE        0x01  //key0按键值
#define   INVAL_KEY_VALUE   0xFF  //无效的按键值


/*key按键结构体 */
struct key_dev{
    int gpio_number;        //IO编号
    int interrupt_number;   //中断号
    unsigned char value;    //键值
    unsigned char name[50]; //按键名字
    irqreturn_t (*handler)(int, void*); //中断处理函数
};

/*imx6ull_irq设备结构体 */
struct irq_dev{
    dev_t devid;  //主设备号+次设备号
    int major; //主设备号
    int minor; //次设备号
    struct cdev cdev;
    struct class* class;
    struct device* device;
    struct device_node * dev_node;//设备节点
    struct key_dev key[KEY_NUM];
    struct timer_list timer; //定时器
    atomic_t key_value;      //按键值
    atomic_t key_release;    //按键释放标志

    wait_queue_head_t wait_queue_head; //等待队列头
};

struct irq_dev irq;

/* 打开设备函数*/
static int irq_dev_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &irq;

    return 0;
}

ssize_t irq_dev_read(struct file * filp, char __user * buf, size_t count, loff_t * ppos)
{
    int ret = 0;
    struct irq_dev* dev = filp->private_data;

    unsigned char key_release = 0;
    unsigned char key_value = 0;

    /*等待事件*/
    wait_event(dev->wait_queue_head, atomic_read(&dev->key_release)); //等待按键有效

    key_release = atomic_read(&dev->key_release);
    key_value = atomic_read(&dev->key_value);
    if(key_release) //判断按键是否释放
    {
        if(key_value&0x80)
        {
            key_value &= ~(0x80); //去掉标志位
            ret = copy_to_user(buf, &key_value, sizeof(key_value));
            if(ret != 0)
            {
                printk("copy_to_user failed!\n");
                goto invalid_key;
            }
        }
    key_release = 0;
    atomic_set(&dev->key_release, 0);
    }
    else
    {
        goto invalid_key;
    }


    return ret;

invalid_key: 
    return -EINVAL;
}

/* 关闭设备函数 */
int irq_dev_close(struct inode * inode, struct file * filp)
{
    return 0;
}

static const struct file_operations irq_fops = {
	.open = irq_dev_open,
	.owner = THIS_MODULE,
	.read = irq_dev_read,
    .release = irq_dev_close, 
};

/*定时器处理函数：对按键进行消抖处理 */
void timer_handler(unsigned long data)
{
    int value = 0;
    struct irq_dev* dev = (struct irq_dev*)data;
    //读取按键值
    value = gpio_get_value(dev->key[0].gpio_number);
    if(value == 0) //按键按下
    {
        // printk("KEY0 Press!\n");
        atomic_set(&dev->key_value, dev->key[0].value);
    }
    else if(value == 1) //按键释放
    {
        // printk("KEY0 Release!\n");
        //按键值最高位置1，打上标志
        atomic_set(&dev->key_value, (0x80|dev->key[0].value));
        atomic_set(&dev->key_release, 1); //一次完整的按键标志
    }

    /*按键有效时，唤醒进入休眠状态的进程 */ 
    if(atomic_read(&dev->key_release)) //完成一次按键过程
    {
        wake_up(&dev->wait_queue_head);
    } 
}

/* 中断处理函数 */
static irqreturn_t key0_irq_handler(int irq, void *param)
{
    struct irq_dev* dev = param;
    
    dev->timer.data = (volatile unsigned long)param;
    //设置定时器超时时间，开启定时器
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(20)); //按键按下后延时20ms
    
    return IRQ_HANDLED;
}

/*按键初始化 */
static int key_io_init(struct irq_dev* dev)
{
    int ret = 0;
    int i = 0;
    int n = 0;

    /*1.获取设备节点 */
    dev->dev_node = of_find_node_by_path("/key");
    if(NULL == dev->dev_node)
    {
        printk("find dev_node failed!\n");
        goto find_dev_node;
    }
    
    /*2.获取IO编号 */
    for(i=0; i< KEY_NUM; i++)
    {   
       dev->key[i].gpio_number = of_get_named_gpio(dev->dev_node, "key-gpio", i);
        if(dev->key[i].gpio_number < 0)
        {
            printk("get gpio number failed!\n");
            goto get_gpio_number;
        }
    }

    /*3.申请IO */
    for(i = 0; i< KEY_NUM; i++)
    {
        memset(dev->key[i].name, 0, sizeof(dev->key[i].name));
        sprintf(dev->key[i].name, "KEY%d", i);
        ret = gpio_request(dev->key[i].gpio_number, dev->key[i].name);
        if(ret != 0)
        {
            printk("gpio request fail!\n");
            goto gpio_request;
        }
        /* 将GPIO设置为输入*/
        gpio_direction_input(dev->key[i].gpio_number);

        /* 获取中断号*/
        dev->key[i].interrupt_number = gpio_to_irq(dev->key[i].gpio_number);
        if(!dev->key[i].interrupt_number)
        {
            printk("irq_of_parse_and_map fail!\n");
            goto get_irq_number;
        }
    }

    dev->key[0].handler = key0_irq_handler;
    dev->key[0].value = KEY0_VALUE;
    /*申请中断 */
    for(i=0; i<KEY_NUM; i++)
    {
        ret = request_irq(dev->key[i].interrupt_number, dev->key[i].handler, 
                         (IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING), dev->key[i].name, dev);  
        printk("request_irq ret: %d\n", ret);
        if(ret != 0)
        {
            printk("%d request interrupt fail!\n", i);
            goto irq_request;
        }                     
    }

    /*定时器初始化 */
    init_timer(&dev->timer);
    dev->timer.function = timer_handler;

    return 0;

irq_request:
get_irq_number:
    for(i=0; i<KEY_NUM; i++)
    {
         gpio_free(dev->key[i].gpio_number);
    }
gpio_request:
    for(n = 0; n<i; n++)
    {
        gpio_free(dev->key[n].gpio_number);
    }
get_gpio_number:
find_dev_node:
    return ret;
}

/*驱动入口函数 */
static int __init imx6ull_irq_init(void)
{
    int ret = 0;

    /*1. 注册/申请设备号 */
    irq.major = 0;  
    if(irq.major) //如果给出主设备号，则注册设备号
    {
        irq.devid = MKDEV(irq.major, 0);
        ret = register_chrdev_region(irq.devid, IRQ_CNT, IRQ_NAME);	
    }
    else //否则申请设备号
    {
      ret = alloc_chrdev_region(&irq.devid, 0, IRQ_CNT, IRQ_NAME);
      irq.major = MAJOR(irq.devid);
      irq.minor = MINOR(irq.devid);
    }
    if(ret < 0)
    {
        printk("devid apply failed!\n");
        goto devid_failed;
    }
    printk("dev: major: %d minor: %d\n", irq.major,irq.minor);

    /*2. 设备初始化，添加设备*/
    irq.cdev.owner = THIS_MODULE;
    cdev_init(&irq.cdev, &irq_fops);
    ret = cdev_add(&irq.cdev, irq.devid, IRQ_CNT);
    if(ret < 0)
    {
        printk("cdev_add failed!\n");
        goto cdev_init_failed;
    }
    /*3. 自动创建设备节点 */
    irq.class = class_create(THIS_MODULE, IRQ_NAME);
    if(IS_ERR(irq.class)){
        printk(KERN_ERR "class_create failed!\n");
        ret = PTR_ERR(irq.class);
		goto class_create_failed;
    }
    irq.device = device_create(irq.class, NULL, irq.devid, NULL, IRQ_NAME);
    if (IS_ERR(irq.device)) {
		printk(KERN_ERR "device_create failed!\n");
		ret = PTR_ERR(irq.device);
		goto device_create_failed;
	}
    
    /*4. 按键初始化*/
    ret = key_io_init(&irq);
    if(ret != 0)
    {
        printk("key_io_init failed!\n");
        goto key_io_init_failed;
    }

    /*初始原子变量*/
    atomic_set(&irq.key_value, INVAL_KEY_VALUE);
    atomic_set(&irq.key_release, 0); 

    /*初始化等待队列头 */
    init_waitqueue_head(&irq.wait_queue_head);

    return 0;

key_io_init_failed:
    device_destroy(irq.class, irq.devid);
device_create_failed:
    class_destroy(irq.class);
class_create_failed:
    cdev_del(&irq.cdev);
cdev_init_failed: 
    unregister_chrdev_region(irq.devid, IRQ_CNT);
devid_failed:
    return ret;
}

/*驱动出口函数 */
static void __exit imx6ull_irq_exit(void)
{
    int i = 0;

    /*删除定时器 */
    del_timer(&irq.timer);

    /*释放中断 */
    for(i=0; i < KEY_NUM; i++)
    {
        free_irq(irq.key[i].interrupt_number, &irq);
    }
    /*释放GPIO编号 */
    for(i=0; i < KEY_NUM; i++)
    {
        gpio_free(irq.key[i].gpio_number);
    }

    /*2. 删除设备 */
    cdev_del(&irq.cdev);
    /*3. 注销设备号*/
    unregister_chrdev_region(irq.devid, IRQ_CNT);

    /*4. 销毁设备 & 类*/
    device_destroy(irq.class, irq.devid);
    class_destroy(irq.class);
}

/*驱动入口与出口函数 */
module_init(imx6ull_irq_init);
module_exit(imx6ull_irq_exit);
MODULE_LICENSE("GPL"); //驱动 License
MODULE_AUTHOR("WeiYing"); //作者

三.  编译驱动

ubuntu终端进入 14_block_io工程目录下，编译驱动模块：

wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/14_wait_queue$ make
make -C /home/wangtian/zhengdian_Linux/linux/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/wangtian/zhengdian_Linux/Linux_Drivers/14_wait_queue modules
make[1]: 进入目录“/home/wangtian/zhengdian_Linux/linux/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga”
  CC [M]  /home/wangtian/zhengdian_Linux/Linux_Drivers/14_wait_queue/key_irq.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/wangtian/zhengdian_Linux/Linux_Drivers/14_wait_queue/key_irq.mod.o
  LD [M]  /home/wangtian/zhengdian_Linux/Linux_Drivers/14_wait_queue/key_irq.ko
make[1]: 离开目录“/home/wangtian/zhengdian_Linux/linux/kernel/linux-imx-rel_imx_4.1.15_2.1.0_ga”
wangtian@wangtian-virtual-machine:~/zhengdian_Linux/Linux_Drivers/14_wait_queue$ 

可以看出，驱动模块可以正常编译通过。

接下来对驱动模块进行测试。