休眠与唤醒 POLL机制 异步通知

形象的理解
妈妈怎么知道卧室里小孩醒了？
① 时不时进房间看一下：查询方式
简单，但是累
② 进去房间陪小孩一起睡觉，小孩醒了会吵醒她：休眠-唤醒
不累，但是妈妈干不了活了
③ 妈妈要干很多活，但是可以陪小孩睡一会，定个闹钟：poll 方式
要浪费点时间，但是可以继续干活。
妈妈要么是被小孩吵醒，要么是被闹钟吵醒。
④ 妈妈在客厅干活，小孩醒了他会自己走出房门告诉妈妈：异步通知
妈妈、小孩互不耽误

休眠与唤醒

当应用程序必须等待某个事件发生，比如必须等待按键被按下时，可以使用“休眠-唤醒”机制：
① APP 调用 read 等函数试图读取数据，比如读取按键；
② APP 进入内核态，也就是调用驱动中的对应函数，发现有数据则复制到用户空间并马上返回；
③ 如果 APP 在内核态，也就是在驱动程序中发现没有数据，则 APP 休眠；
④ 当有数据时，比如当按下按键时，驱动程序的中断服务程序被调用，它会记录数据、唤醒 APP；
⑤ APP 继续运行它的内核态代码，也就是驱动程序中的函数，复制数据到用户空间并马上返回。

驱动中有数据时，下图中红线就是 APP1 的执行过程，涉及用户态、内核态：

驱动中没有数据时，APP1 在内核态执行到 drv_read 时会休眠。所谓休眠就是把自己的状态改为非
RUNNING，这样内核的调度器就不会让它运行。当按下按键，驱动程序中的中断服务程序被调用，它会记录数据，并唤醒 APP1。所以唤醒就是把程序的状态改为 RUNNING，这样内核的调度器有合适的时间就会让它运行。当 APP1 再次运行时，就会继续执行 drv_read 中剩下的代码，把数据复制回用户空间，返回用户空间。
APP1 的执行过程如下图的红色实线所示，它被分成了 2 段：

值得注意的是，上面 2 个图中红线部分都属于 APP1 的“上下文”，或者这样说：红线所涉及的代码，都
是 APP1 调用的。但是按键的中断服务程序，不属于 APP1 的“上下文”，这是突如其来的，当中断发生时，APP1 正在休眠呢。
在 APP1 的“上下文”，也就是在 APP1 的执行过程中，它是可以休眠的。
在中断的处理过程中，也就是 gpio_key_irq 的执行过程中，它不能休眠：“中断”怎么能休眠？“中
断”休眠了，谁来调度其他 APP 啊？
所以，请记住：在中断处理函数中，不能休眠，也就不能调用会导致休眠的函数。

要休眠的线程，放在 wq 队列里，中断处理函数从 wq 队列里把它取出来唤醒。
所以，我们要做这几件事：
① 初始化 wq 队列
② 在驱动的 read 函数中，调用 wait_event_interruptible：
它本身会判断 event 是否为 FALSE，如果为 FASLE 表示无数据，则休眠。
当从 wait_event_interruptible 返回后，把数据复制回用户空间。
③ 在中断服务程序里：
设置 event 为 TRUE，并调用 wake_up_interruptible 唤醒线程。

休眠与唤醒

gpio_key_grv

#include <linux/module.h>

#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/gpio/consumer.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>


struct gpio_key{
   
   
	int gpio;
	struct gpio_desc *gpiod;
	int flag;
	int irq;
} ;

static struct gpio_key *gpio_keys_100ask;

/* 主设备号                                                                 */
static int major = 0;
static struct class *gpio_key_class;

/* 环形缓冲区 */
#define BUF_LEN 128
static int g_keys[BUF_LEN];
static int r, w;

#define NEXT_POS(x) ((x+1) % BUF_LEN)

static int is_key_buf_empty(void)
{
   
   
	return (r == w);
}

static int is_key_buf_full(void)
{
   
   
	return (r == NEXT_POS(w));
}

static void put_key(int key)
{
   
   
	if (!is_key_buf_full())
	{
   
   
		g_keys[w] = key;
		w = NEXT_POS(w);
	}
}

static int get_key(void)
{
   
   
	int key = 0;
	if (!is_key_buf_empty())
	{
   
   
		key = g_keys[r];
		r = NEXT_POS(r);
	}
	return key;
}


static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);//初始化gpio_key_wait这个队列   wait queue

/* 实现对应的open/read/write等函数，填入file_operations结构体                   */
static ssize_t gpio_key_drv_read (struct file *file, char __user *buf, size_t size, loff_t *offset)
{
   
   
	//printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
	int err;
	int key;
	
	wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());//休眠函数   
	key = get_key();
	err = copy_to_user(buf, &key, 4);
	
	return 4;
}


/* 定义自己的file_operations结构体                                              */
static struct file_operations gpio_key_drv = {
   
   
	.owner	 = THIS_MODULE,
	.read    = gpio_key_drv_read,
};


static irqreturn_t gpio_key_isr(int irq, void *dev_id)
{
   
   
	struct gpio_key *gpio_key = dev_id;
	int val;
	int key;
	
	val = gpiod_get_value(gpio_key->gpiod);
	

	printk("key %d %d\n", gpio_key->gpio, val);
	key = (gpio_key->gpio << 8) | val;
	put_key(key);
	wake_up_interruptible(&gpio_key_wait);//gpio_key_wait从这个队列中唤醒一个线程  唤醒函数
	
	return IRQ_HANDLED;
}

/* 1. 从platform_device获得GPIO
 * 2. gpio=>irq
 * 3. request_irq
 */
static int gpio_key_probe(struct platform_device *pdev)
{
   
   
	int err;
	struct device_node *node = pdev->dev.of_node;
	int count;
	int i;
	enum of_gpio_flags flag;
		
	printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__)