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吧!
1774
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
