12 中断
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吧!