中断深入--＞中断下半部线程化(工作队列+ threaded irq)

在此之前

前定时器、下半部 tasklet，它们都是在中断上下文中执行，它们无法休眠。
所以复杂的事情,就不能放在下半部,不然系统会很卡
如果使用线程来处理这些耗时的工作，那就可以解决系统卡顿的问题：因为线程可以休眠。

不自己创建线程 —> 工作队列

在内核中，我们并不需要自己去创建线程，可以使用“工作队列”(workqueue)。内核初始化工作队列
是，就为它创建了内核线程。以后我们要使用“工作队列”，只需要把“工作”放入“工作队列中”，对应的
内核线程就会取出“工作”，执行里面的函数。
工作队列的应用场合：要做的事情比较耗时，甚至可能需要休眠，那么可以使用工作队列。

缺点
多个工作(函数)是在某个内核线程中依序执行的，前面函数执行很慢，就会影响到后面的函数。
在多 CPU 的系统下，一个工作队列可以有多个内核线程，可以在一定程度上缓解这个问题。

自己创建线程 —> threaded irq

工作队列用起来挺简单，但是它有一个
缺点：工作队列中有多个 work，前一个 work 没处理完会影响后面的 work。解决方法有很多种，比如干脆自
己创建一个内核线程，不跟别的 work 凑在一块了。在 Linux 系统中，对于存储设备比如 SD/TF 卡，它的驱
动程序就是这样做的，它有自己的内核线程。
对于中断处理，还有另一种方法：threaded irq，线程化的中断处理。中断的处理仍然可以认为分为上
半部、下半部。上半部用来处理紧急的事情，下半部用一个内核线程来处理，这个内核线程专用于这个中断。

你可以只提供 thread_fn，系统会为这个函数创建一个内核线程。发生中断时，系统会立刻调用 handler
函数，然后唤醒某个内核线程，内核线程再来执行 thread_fn 函数。

顺带讲解一个函数 container_of()

有一个结构体内部变量的地址,用这个函数能推测出结构体的地址(自己算也可以)

比如知道参数 button_work的地址 我们就能算出gpio_key的地址
得到gpio_key这个结构体

工作队列

驱动中如何使用

①构造 work_struct 结构体

从这个定义函数我们知道,构造结构体,先要传入一个work结构体,和他要执行的方法 func

struct gpio_key{
   
	int gpio;
	struct gpio_desc *gpiod;
	int flag;
	int irq;
	struct tasklet_struct button_tasklet;
	struct work_struct	button_work;
} ;

INIT_WORK(&gpio_keys_100ask[i].button_work,button_tasklet);

② 把这个 work_struct 结构体放入工作队列，内核线程就会运行 work 中的函数。

schedule_work( &(gpio_key->button_work) );

③其他函数

驱动代码

#include <linux/module.h>
#include <linux/poll.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>
#include <linux/fcntl.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <asm/current.h>


struct gpio_key{
   
	int gpio;
	struct gpio_desc *gpiod;
	int flag;
	int irq;
	struct timer_list key_timer;
	struct tasklet_struct tasklet;
	struct work_struct work;
} ;

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;

struct fasync_struct *button_fasync;

#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);

static void key_timer_expire(unsigned long data)
{
   
	/* data ==> gpio */
	struct gpio_key *gpio_key = data;
	int val;
	int key;

	val = gpiod_get_value(gpio_key->gpiod);


	printk("key_timer_expire key %d %d\n", gpio_key->gpio, val);
	key = (gpio_key->gpio << 8) | val;
	put_key(key);
	wake_up_interruptible(&gpio_key_wait);
	kill_fasync(&button_fasync, SIGIO, POLL_IN);
}

static void key_tasklet_func(unsigned long data)
{
   
	/* data ==> gpio */
	struct gpio_key *gpio_key = data;
	int val;
	int key;

	val = gpiod_get_value(gpio_key->gpiod);


	printk("key_tasklet_func key %d %d\n", gpio_key->gpio, val);
}

static void key_work_func(struct work_struct *work)
{
   
	struct gpio_key *gpio_key = container_of(work, struct gpio_key, work);
	int val;

	val = gpiod_get_value(gpio_key->gpiod);

	printk("key_work_func: the process is %s pid %d\n",current->comm, current->pid);	
	printk("key_work_func key %d %d\n", gpio_key->gpio, val);
}