Linux驱动入门（五）阻塞方式实现按键驱动

Linux驱动入门系列

Linux驱动入门（一）字符设备驱动基础

Linux驱动入门（二）操作硬件

Linux驱动入门（三）Led驱动

Linux驱动入门（四）非阻塞方式实现按键驱动

Linux驱动入门（五）阻塞方式实现按键驱动

Linux驱动入门（六）poll机制实现按键驱动

Linux驱动入门（七）使用定时器消除按键抖动

Linux驱动入门（五）阻塞方式实现按键驱动

本文目标：实现一个阻塞的按键驱动程序，当应用调用read函数读取时阻塞等待，直到按键按下才放回

一、阻塞方式实现按键驱动思路

上一篇文章讲解非阻塞的方式实现按键驱动，而如果以非阻塞方式实现驱动的话，应用层就需要轮询地读取，这无疑是非常耗费cpu的，本文将修改上一篇文章的驱动程序，实现一个阻塞读取的按键驱动程序，下面开始将阻塞方式的实现思路

如果应用调用read函数要阻塞，那么说明驱动程序的button_read也要阻塞，那么谁来唤醒？

答案是中断程序，通过向内核注册中断，当检测到按键按下时，就触发中断，中断程序读取按键的值，并唤醒button_read所阻塞的进程，button_read在放回结果给应用

关于如何阻塞和如何注册中断，下面将一一介绍

二、内核的等待队列

要实现阻塞需要使用内核的等待队列，等待队列很早就作为一个基本的功能单位出现在Linux内核里了，它以队列为基础数据结构，与进程调度机制紧密结合，可以用来同步对系统资源的访问

Linux内核提供对等待队列的操作如下

• 定义一个”等待队列头部“

  wait_queue_head_t my_queue;
  

• 初始化一个”等待队列头部“

  init_waitqueue_head(&my_queue);
  

  Linux内核提供一个更加便捷的宏定义，定义并初始化一个“等待队列头部”

  DECLARE_WAIT_QUEUE_HEAD (name)
  

• 定义等待队列元素

  DEFINE_WAIT(name)
  

• 添加/移除等待队列

  void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
  void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
  

• 唤醒等待队列

  void wake_up(wait_queue_head_t *queue);
  void wake_up_interruptible(wait_queue_head_t *queue);
  

  wake_up可以唤醒处于TASK_UNINTERRUPTIBLE和TASK_INTERRUPTIBLE状态的进程

  wake_up_interruptible只能唤醒处于TASK_INTERRUPTIBLE状态的进程

下面是一个使用等待队列阻塞等待的例子

static DECLARE_WAIT_QUEUE_HEAD (wq_head); //定义并初始化一个等待队列头
static int condition; //等待队列唤醒条件

void my_wait()
{
    DEFINE_WAIT(wait); //定义一个等待队列元素
    
    while(!condition) //当条件满足时退出
    {
        add_wait_queue(&wq_head, &wait); //将等待队列元素加入等待队列中
        
        set_current_state(TASK_UNINTERRUPTIBLE); //设置当前进程状态
        
        schedule(); //调度进程，此时进程将睡眠，等待被唤醒
        
        /* 进程被唤醒后会再次判断条件是否满足
         * 如果满足，进程唤醒
         * 否则进程继续加入等待队列然后调度睡眠 
         */
    }
    
    set_current_state(TASK_RUNNING); //设置进程状态
}

可以使用下面方式唤醒该进程

condition = 1;
wake_up(&wq_head);

上述我们实现的wait_event函数确实有点复杂，为了方便使用，Linux内核又提供了一套等待事件的宏定义，宏定义的实现跟我们所写的my_wait函数类似

• 等待事件

  wait_event(queue, condition)
  wait_event_interruptible(queue, condition)
  wait_event_timeout(queue, condition, timeout)
  wait_event_interruptible_timeout(queue, condition, timeout)
  

  其中queue表示等待队列头，condition表示等待条件，这些宏定义的实现跟我们上面实现的my_wait函数是类似的

  需要注意的是

  如果使用下面宏定义等待事件

  wait_event(queue, condition)
  wait_event_timeout(queue, condition, timeout)
  

  需要用下面函数唤醒

  void wake_up(wait_queue_head_t *queue);
  

  如果使用下面宏定义等待事件

  wait_event_interruptible(queue, condition)
  wait_event_interruptible_timeout(queue, condition, timeout)
  

  可以使用下面函数唤醒

  void wake_up(wait_queue_head_t *queue);
  void wake_up_interruptible(wait_queue_head_t *queue);
  

下面再使用这些宏定义来实现我们的my_wait函数

static DECLARE_WAIT_QUEUE_HEAD (wq_head); //定义并初始化一个等待队列头
static int condition; //等待队列唤醒条件

void my_wait()
{
    wait_event_interruptible(wq_head, condition);
}

唤醒可以使用下面方法

condition = 1;
wake_up_interruptible(&wq_head);

这样子等待队列的使用就变得非常简单了

三、注册中断

首先看Linux内核如何描述中断

• 内核对中断的描述

  对于每款芯片，都有自己对应的一个irqs.h文件

  例如S5PV210的文件位于linux/arch/arm/mach-s5pv210/include/mach/irqs.h

  其中使用宏定义定义了一系列的中断

  /* VIC0: System, DMA, Timer */
  #define IRQ_EINT0		S5P_IRQ_VIC0(0)
  #define IRQ_EINT1		S5P_IRQ_VIC0(1)
  #define IRQ_EINT2		S5P_IRQ_VIC0(2)
  ...
      
  /* VIC1: ARM, Power, Memory, Connectivity, Storage */
  ...
  #define IRQ_UART3		S5P_IRQ_VIC1(13)
  #define IRQ_IIC			S5P_IRQ_VIC1(14)
  #define IRQ_SPI0		S5P_IRQ_VIC1(15)
  ...
      
  /* VIC2: Multimedia, Audio, Security */
  #define IRQ_LCD0		S5P_IRQ_VIC2(0)
  ...
  #define IRQ_FIMC0		S5P_IRQ_VIC2(5)
  ...
      
  /* VIC3: Etc */
  ...
  #define IRQ_ADC1		S5P_IRQ_VIC3(9)
  ...
  

• 内核注册中断的接口

  内核使用request_irq注册中断

  /*
   * irq：中断号（irqs.h）
   * irq_handler_t：中断函数 typedef irqreturn_t (*irq_handler_t)(int, void *);
   * flags：中断触发条件
   * dev：传递给中断函数的操作，如果不是共享中断，此参数允许为NULL
   */
  request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
  	    const char *name, void *dev)
  

  其中typedef irqreturn_t (*irq_handler_t)(int, void *)第一个参数为中断号，第二个参数为申请中断时传递的参数

  内核使用free_irq注销中断

  /*
   * irq：中断号（irqs.h）
   * dev：申请中断时传递的参数
   */
  void free_irq(unsigned int irq, void *dev);
  

在Linux驱动入门（四）非阻塞方式实现按键驱动中，可以看到GPIO的外部中断为外部中断2，所以可以这样注册中断

static irqreturn_t button_irq(int irq, void *data)
{
    
    return IRQ_HANDLED;
}

/* 外部中断2，下降沿触发 */
request_irq(IRQ_EINT2, button_irq, IRQF_TRIGGER_FALLING, "button", NULL);

四、源码

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>

#include <asm/io.h>
#include <asm/uaccess.h>

static dev_t dev_id;
static struct cdev *button_dev;
static struct class *button_class;

/* 定义并初始化一个等待队列头 */
static DECLARE_WAIT_QUEUE_HEAD(button_wq_head);
static int button_conditon;
static int button_val;

static irqreturn_t button_irq(int irq, void *data)
{
    /* 判断等待队列中是否有等待元素 */
    if(!waitqueue_active(&button_wq_head))
        return IRQ_HANDLED;

    /* 读取按键值 */
    button_val = gpio_get_value(S5PV210_GPH0(2));

    /* 唤醒等待队列 */
    button_conditon = 1;
    wake_up_interruptible(&button_wq_head);

    return IRQ_HANDLED;
}

static int button_open(struct inode *inode, struct file *file)
{
    int ret;
    
    ret = request_irq(IRQ_EINT2, button_irq, IRQF_TRIGGER_FALLING, "button_irq", NULL);

    return 0;
}

static ssize_t button_read(struct file *file, char __user *data, size_t size, loff_t *loff)
{
    int ret;
    int val;

    /* 睡眠等待 */
    button_conditon = 0;
    wait_event_interruptible(button_wq_head, button_conditon);
    button_conditon = 0;
    
    val = button_val;
    ret = copy_to_user(data, &val, sizeof(val));

    return sizeof(val);
}

static int button_release(struct inode *inode, struct file *file)
{
    free_irq(IRQ_EINT2, NULL);

    return 0;
}

static struct file_operations button_fops = {
	.owner      = THIS_MODULE,
    .open       = button_open,
    .read       = button_read,
    .release    = button_release,
};

static __init int button_init(void)
{
    /* 申请设备号 */
    alloc_chrdev_region(&dev_id, 1, 1, "button");

    /* 分配字符设备 */
    button_dev = cdev_alloc();

    /* 设置字符设备 */
    cdev_init(button_dev, &button_fops);

    /* 注册字符设备 */
    cdev_add(button_dev, dev_id, 1);

    /* 创建设备节点 */
	button_class = class_create(THIS_MODULE, "button"); //创建类
	device_create(button_class, NULL, dev_id, NULL, "button"); //创建设备节点

    gpio_request(S5PV210_GPH0(2), "button");

    return 0;
}

static __exit void button_exit(void)
{
    /* 注销设备节点 */
    device_destroy(button_class, dev_id);
    class_destroy(button_class);

    /* 注销字符设备 */
    cdev_del(button_dev);
    kfree(button_dev);

    /* 注销注册的设备号 */
    unregister_chrdev_region(dev_id, 1);

    gpio_free(S5PV210_GPH0(2));
}

module_init(button_init);
module_exit(button_exit);

MODULE_LICENSE("GPL");

五、测试

将上面驱动程序保存为button_drv.c，执行Makefile，生成button_drv.ko

加载模块，此时生成设备节点/dev/button

• 应用测试程序

  #include <stdio.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>
  #include <unistd.h>
  
  #define BUTTON_DEV "/dev/button"
  
  int main(int argc, char* argv[])
  {
      int val;
      
      int fd = open(BUTTON_DEV, O_RDONLY);
      if(fd < 0)
      {
          printf("failed to open %s\n", BUTTON_DEV);
          return -1;
      }
  
      while(1)
      {
          read(fd, &val, sizeof(val));
          printf("read return\n");
  
          if(val == 0)
          {
              printf("button press\n");
          }
      }
  
  
      close(fd);
  
      return 0;
  }
  

  编译运行

  效果是只有当按键按下的时候，read函数才会返回