1、内核中断编程

函数原型：

int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev)
- 功能：在linux内核中,处理器的任何一个硬件中断资源对于linux内核来说都是一种宝贵的资源，如果驱动想要访问某个硬件中断资源，必须先向内核申请这个硬件中断资源，一旦申请成功，然后向内核注册这个硬件中断对应的中断处理函数，一旦注册成功，静静等待着硬件中断触发，一旦触发将来内核自动调用注册的中断处理函数
所以此函数完成两个工作：
	1.申请硬件中断资源
	2.注册中断处理函数
- 参数：
	- irq：在linux内核中，linux内核给每个硬件中断都分配一个软件编号
	- handler:传递要注册的中断处理函数,其实就是传递要注册的中断处理函数名
	- flags:中断触发的类型
	- name:指定中断的名称

void free_irq(int irq, void *dev)
功能：如果驱动不再使用某个硬件中断资源，必须要释放这个硬件中断资源并且删除之前注册的中断处理函数
参数：
irq:传递要释放的硬件中断的中断号
dev:传递给中断处理函数的参数，此参数务必要和request_irq的最后一个参数保持一致，否则系统崩溃

• 函数说明

中断号:中断号由GPIO编号经过gpio_to_irq函数进行换算而得：
	硬件GPIO		GPIO编号		     中断号
	GPIOA28		PAD_GPIO_A+28  	gpio_to_irq(PAD_GPIO_A + 28);
	GPIOB9		PAD_GPIO_B+9	gpio_to_irq(PAD_GPIO_B + 9);
	...	        	...	        	...
中断处理函数:一旦注册完毕,静静等待硬件中断触发，一旦触发，内核自动调用此函数
	编写一个中断处理函数例子：
	irqreturn_t 中断处理函数名(int  irq, void *dev) {
		//根据用户需求编写中断处理函数
		....
		return IRQ_NONE; //中断处理函数执行失败
		或者
		return IRQ_HANDLED; //中断处理函数执行成功	
	}
	注意中断处理函数形参问题：
	irq:保存当前触发中断的中断号，例如：GPIOA28产生的中断，irq=gpio_to_irq(PAD_GPIO_A+28);
	dev:保存给中断处理函数传递的参数
		问:谁来传递参数呢？
		答:request_irq函数的最后一个形参(void *dev)用来给中断处理函数传递参数
		而中断处理函数的第二个形参dev来保存传递的参数！
中断触发的类型:
	IRQF_TRIGGER_HIGH:指定为高电平触发
	IRQF_TRIGGER_LOW:指定为低电平触发
	IRQF_TRIGGER_FALLING:指定为下降沿触发
	IRQF_TRIGGER_RISING:指定为上升沿触发
	IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING:指定为双边沿触发
	对于内部中断(就是各种控制器给中断控制器发送的中断，此中断线不可见)，一律给0

• 案例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>
#include <mach/platform.h>

// 声明gpio
struct key_gpio{
	int gpio;
	char* name;
};
// 定义GPIO
static struct key_gpio key_info[]={
	{
		.name="key_1",
		.gpio=PAD_GPIO_A+28
	},
	{
		.name="key_2",
		.gpio=PAD_GPIO_B+9
	}
};
// 中断处理函数
static irqreturn_t key_interupt (int irq,void *dev){
	struct key_gpio * key = (struct key_gpio *)dev;
	//获取按键的状态
    	int kstate;
    	kstate = gpio_get_value(key->gpio);

    	//打印按键的状态
    	printk("%s: 按键[%s]的状态是[%s]\n", 
                        __func__, key->name, 
                        kstate?"松开":"按下");
    	return IRQ_HANDLED; //成功，失败返回IRQ_NONE
}
static int key_init(void){
	// 申请GPIO资源
	int i=0;
	for(i=0;i<ARRAY_SIZE(key_info);i++){
		gpio_request(key_info[i].gpio,key_info[i].name);
		gpio_direction_input(key_info[i].gpio);
		// 配置中断
		int irq = gpio_to_irq(key_info[i].gpio); // 生成中断号
	    request_irq(irq,key_interupt,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,"key_interupt",&key_info[i]);// 申请硬件中断资源
		printk("%s init success\n",key_info[i].name);
	}
	return 0;
};

static void key_exit(void){	
	int i=0;
	for(i=0;i<ARRAY_SIZE(key_info);i++){
		gpio_free(key_info[i].gpio);
		int irq = gpio_to_irq(key_info[i].gpio); // 生成中断号
		free_irq(irq,&key_info[i]);// 释放硬件中断资源
		printk("%s free success\n",key_info[i].name);
	}
};
module_init(key_init);
module_exit(key_exit);
MODULE_LICENSE("GPL");

• 前置要求
  配置linux内核去除官方的按键驱动：

make menuconfig
	Device Drivers->
		Input device support->
			<*>Keyboard->
				<*>..... //最后一个选项，这个选项对应的按键驱动就是官方的按键驱动
					按N键去除
保存退出

2、顶半部和底半部机制

2.1 任务的相关概念

2.1.1 分类

计算机中的任务细分三类：进程，硬件中断和软中断

• 进程：进程一开始在用户空间运行，一旦调用系统调用立刻陷入内核空间继续运行，运行完毕又回到用户空间继续运行
• 硬件中断：外设给CPU发送的中断信号，内核执行其硬件中断处理函数，此函数永远运行在内核空间
• 软中断：软件单独调用swi或svc指令立刻触发软中断异常，立刻执行其软中断处理函数，此函数同样位于内核空间
  注意：任何一种任务要想运行必须先获取到CPU资源！

2.1.2 优先级

优先级越高，获取CPU资源的能力越强，越能够及早运行，在linux内核中，三类任务的优先级划分：

• 硬件中断高于软中断，软中断高于进程
• 进程之间存在优先级之分(nice命令可以设置优先级)
• 软中断之间存在优先级
• 硬件中断无优先级之分(哪怕中断控制器支持优先级，内核不认)

2.1.3 进程调度

inux内核会给每个进程分配时间片,进程一旦轮到其运行，在此时间片之内可以一直运行，直到时间片到期，进程调度器会将当前进程的CPU资源撤下给其他进程使用
切记：中断不参与进程调度，中断来了，直接会抢夺CPU资源，因为优先级高

2.1.4 休眠sleep

休眠只能用于进程，不可用于中断，当进程进入休眠时，进程会立马释放占用的CPU资源给其他进程

结论：由以上概念得到：在linux内核中，内核希望中断处理函数的执行速度要越快越好，如果中断处理函数长时间占用CPU资源，势必影响系统的并发能力(其他任务无法获取CPU资源投入运行)和响应能力(其他的硬件中断再也无法得到响应，各种卡)。
问：不可能所有的中断处理函数都能够满足内核的希望
例如：网卡利用中断获取网络数据包，其中断处理函数本身执行的速度就很慢，如果长时间占用CPU资源，就会造成丢包现象！
答：对于此种情况，必须要采用内核提供的顶半部和底半部机制来优化

2.2 顶半部和底半部实现机制

2.2.1 顶半部特点

• 硬件中断触发，立刻执行
• 顶半部本质就是中断处理函数，只是现在里面做紧急，耗时较短的内容
• CPU在执行顶半部中断处理函数期间不允许发生CPU资源的切换
• 顶半部同样不能休眠

2.2.2 底半部特点

• 底半部对应的处理函数做不紧急，并且耗时较长的内容
• CPU在"适当"的时候执行底半部的处理函数，在执行期间允许高优先级的任务来抢夺CPU资源，等处理完毕再回到底半部继续运行，所以底半部的处理函数实现可以基于软中断或者进程实现
  底半部实现方法三种：tasklet,工作队列，软中断
• 底半部的本质就是延后执行的一种手段，并不是非要和顶半部配合使用，也就是可以单独用底半部来将你想要延后执行的事情进行延后，可以将宝贵的CPU资源给其他高优先级的任务使用

2.2.3 底半部实现方法之:tasklet

• 特点：
  基于软中断实现，它对应的处理函数的优先级高于进程而低于硬件中断
  tasklet对应的处理函数中不能进行休眠操作
  tasklet对应的处理函数又称延后处理函数，里面做不紧急，耗时较长的内容
• 描述tasklet属性的结构体

struct tasklet_struct {
	void (*func)(unsigned long data);
	unsigned long data;
	...
};	
- 功能：描述tasklet的属性
- func:指定tasklet的延后处理函数,将来内核会在适当时候调用其延后处理函数，不能进行休眠操作，形参data保存给这个延后处理函数传递的参数		
- data：给延后处理函数传递的参数

• 相关函数

void tasklet_init(struct tasklet_struct *tasklet,void (*func)(unsigned long),unsigned long data)	
- 功能：初始化tasklet对象，给tasklet对象指定一个延后处理函数并且给延后处理函数传递参数
- 参数：
	- tasklet:tasklet对象的地址
	- func：给tasklet指定一个延后处理函数
	- data：给延后处理函数传递的参数
void tasklet_schedule(struct tasklet_struct *tasklet)
- 功能：向内核注册tasklet对象和其延后处理函数，一旦注册成功，内核会在适当的时候执行其延后处理函数

• 案例：优化上面的按键中断，使里面的printk使用tasklet实现

// 底半部
static struct tasklet_struct key_tasklet;
struct key_gpio *key; // 指向按键按下的GPIO
// 定义tasklet处理函数
static void key_tasklet_function(unsigned long data){
	//获取按键的状态
	int kstate;
	kstate = gpio_get_value(key->gpio);
	//打印按键的状态
	printk("%s: 按键[%s]的状态是[%s]\n",__func__, key->name,kstate?"松开":"按下");
}
// 顶半部 中断处理函数
static irqreturn_t key_interupt (int irq,void *dev){
	// 保存按下的按键信息
	key = (struct key_gpio*) dev;
    	// 向内核注册tasklet延后处理函数
	tasklet_schedule(&key_tasklet);
	return IRQ_HANDLED; //成功，失败返回IRQ_NONE
}
static int key_init(void){
	// 申请GPIO资源
	int i=0;
	for(i=0;i<ARRAY_SIZE(key_info);i++){
		gpio_request(key_info[i].gpio,key_info[i].name);
		gpio_direction_input(key_info[i].gpio);
		// 配置中断
		int irq = gpio_to_irq(key_info[i].gpio); // 生成中断号
		request_irq(irq,key_interupt,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,"key_interupt",&key_info[i]);// 申请硬件中断资源
		printk("%s init success\n",key_info[i].name);
	}
	// 初始化tasklet对象，指定延后处理函数
	tasklet_init(&key_tasklet,key_tasklet_function,0);
	return 0;
};

2.2.4 底半部实现机制之工作队列

• 工作队列特点：
  工作队列基于进程实现，所以其延后处理函数可以进行休眠操作
  工作队列诞生的本质就是解决tasklet的延后处理函数不能休眠的问题，所以如果在延后执行的内容中有休眠操作，必须采用工作队列
  工作队列的延后处理函数的优先级也是最低的
• 工作队列属性的数据结构：

struct work_struct {
	void (*func)(struct work_struct *work);
};
- func:工作队列的延后处理函数，基于进程实现，可以进行休眠操作
		形参work：指向驱动定义初始化的work_struct对象，work指向自己用于给延后处理函数传递参数
问：如何利用自己的地址给延后处理函数传递参数呢？
答：必须配合container_of宏来实现传递参数！

• 相关函数

INIT_WORK(struct work_struct *work, void (*func)(struct work_struct *work));
- 功能：给work对象指定一个延后处理函数
- 参数：
	- work：work对象的地址
	- func:指定延后处理函数
schedule_work(struct work_struct *work);
- 功能：向内核登记注册一个延后处理函数，一旦注册成功，内核在适当的时候调用其延后处理函数

• 案例：优化上面的按键中断，使里面的printk使用工作队列实现

// 底半部
static struct work_struct key_work;
struct key_gpio *key; // 指向按键按下的GPIO
// 定义work处理函数
static void key_work_function(struct work_struct *work){
	//获取按键的状态
	int kstate;
	kstate = gpio_get_value(key->gpio);
	//打印按键的状态
	printk("%s: 按键[%s]的状态是[%s]\n",__func__, key->name,kstate?"松开":"按下");
}
// 顶半部 中断处理函数
static irqreturn_t key_interupt (int irq,void *dev){
	// 保存按下的按键信息
	key = (struct key_gpio*) dev;
    // 向内核注册工作队列延后处理函数
	schedule_work(&key_work);
	return IRQ_HANDLED; //成功，失败返回IRQ_NONE
}
static int key_init(void){
	// 申请GPIO资源
	int i=0;
	for(i=0;i<ARRAY_SIZE(key_info);i++){
		gpio_request(key_info[i].gpio,key_info[i].name);
		gpio_direction_input(key_info[i].gpio);
		// 配置中断
		int irq = gpio_to_irq(key_info[i].gpio); // 生成中断号
		request_irq(irq,key_interupt,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,"key_interupt",&key_info[i]);// 申请硬件中断资源
		printk("%s init success\n",key_info[i].name);
	}
	// 初始化work对象，指定延后处理函数
	INIT_WORK(&key_work,key_work_function);
	return 0;
};

2.2.5 底半部实现机制之软中断

• 软中断特点：
  软中断同样有对应的延后处理函数,此函数可以同时运行在多个CPU核上,效率极其高，这就要求其延后处理函数如果进行全局变量的访问，记得要做好互斥保护，当一个CPU核在访问全局变量是，禁止其他CPU核访问，但是这种互斥保护势必降低代码的效率
  tasklet基于软中断实现，但是它的延后处理函数同一时刻使能运行在一个CPU核上也不用关心互斥访问的问题！
  软中断的延后处理函数不能insmod和rmmod动态的安装和卸载，必须和uImage编写在一起编译在一起，无形加大了开发的难度和加大了代码的维护难度，但是tasklet就可以动态的insmod和rmmod

2.2.6 总结

• tasklet基于软中断实现，工作队列基于进程实现
• 如果要进行延后执行，并且延后执行的内容中有休眠操作，只能用工作队列
• 如果要进行延后执行，延后执行的内容中无休眠操作，但又要考虑效率问题，建议使用tasklet
• 如果要进行延后执行，延后执行的内容中无休眠操作，但又不考虑效率问题，建议使用工作队列
• 如果要进行延后执行，延后执行的内容中无休眠操作，并且对效率要求极高，并且想让多核同时运行处理,建议采用软中断,如果有对全局变量共享资源的同时访问，建议还是tasklet吧!