【Linux中断】Linux系统中断机制简述
Linux中断
Linux中断处理过程
1.使能中断，初始化相应的寄存器
2.注册中断服务函数，也就是向irqTable数组的指定标号处写入中断服务函数
3.中断发生以后进入IRQ中断服务函数，IRQ的中断服务函数在irqTable里面查找具体的中断处理函数，找到以后执行相应的中断处理函数
Linux中断处理API函数
request_irq
request_irq函数用于申请中断，但是可能会导致睡眠，因此不能在中断上下文或者其他禁止睡眠的代码段中使用request_irq函数。request_irq函数会使能中断，所以不需要我们手动去使能中断。
函数原型：
int request_irq(unsigned int irq,
irq_handler_t handler,
unsigned long flags,
const char *name,
void *dev);
参数说明：
irq：要申请中断的中断号
handler:中断处理函数，当中断发生以后就会执行此中断处理函数
flags:中断标志，可以在include/linux/interrupt.h里面查看所有的中断标志
name：中断名字，设置以后可以在/proc/interrupts文件中可以看到对应的中断名字
dev:如果flags设置为IRQF_SHARED的话，dev用来区分不同的中断，一般情况下将dev设置为设备结构体，dev会传递给中断处理函数irq_handler_t的第二个参数
常用中断标志：
| 标志 | 描述 |
|---|---|
| IRQF_SHARED | 多个设备共享一个中断线，共享的所有中断都必须指定此标志。如果使用共享中断的话，request_irq函数的dev参数就是唯一区分他们的标志。 |
| IRQF_ONESHOT | 单次中断，中断执行一次就结束 |
| IRQF_TRIGGER_NONE | 无触发 |
| IRQF_TRIGGER_RASING | 上升沿触发 |
| IRQF_TRIGGER_FALLING | 下降沿触发 |
| IRQF_TRIGGER_HIGH | 高电平触发 |
| IRQF_TRIGGER_LOW | 低电平触发 |
free_irq
释放相应的中断，如果中断不是共享的,那么free_irq会删除中断处理函数并且禁止中断.
函数原型：
void free_irq(unsigned int irq,void *dev);
参数说明：
irq:要释放的中断。
dev:如果flags设置为IRQF_SHARED的话，dev用来区分不同的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉
中断处理函数
使用request_irq函数申请中断的时候需要设置中断处理函数
函数原型：
irqreturn (*irq_handler_t)(int , void *);
参数说明：
第一参数：中断处理函数相对应的中断号
第二参数：指向void的指针，也就是一个通用指针，需要与request_irq函数的dev参数保持一致，用于区分共享中断的不同设备
返回值：
enum irqreturn
{
IRQ_NONE = (0 << 0),
IRQ_HANDLED = (1 << 0),
IRQ_WAKE_THREAD = (1 << 1),
};
中断使能与禁止函数
常用中断使用和禁止函数
void enable_irq(unsigned int irq);
void disable_irq(unsigned int irq);
enable_irq和disable_irq用于使能和禁止指定的中断，irq就是要禁止的中断号。disable_irq函数要等到当前正在执行的中断处理函数执行完才返回，因此需要保证不会产生新的中断，并且确保所有已经开始执行的中断处理程序已经全部退出。在这种情况下，可以使用另外一个中断禁止函数：
void disable_irq_nosync(unsigned int irq);
disable_irq_nosync函数调用以后立即返回，不会等待当前中断处理程序执行完毕。上面三个函数都是使能或者禁止某一个中断，如果需要关闭全局中断需要使用一下函数：
local_irq_enbale(); // 使能当前处理器中断系统
local_irq_disbale(); // 禁止当前处理器中断系统
local_irq_save(flags); // 用于禁止中断，并且将中断状态保存到flags中
local_irq_restore(flags); // 用于恢复中断，将中断恢复到flags状态。
中断处理上下部
为了实现中断处理函数的快进快出，对于一些对时间敏感、执行速度快的操作可以放到中断处理函数中，也就是上半部，剩下执行时间久的工作都可以放到下半部执行。
上半部：
上半部就是中断处理函数，一些处理过程比较快，不会占用较长时间可以放到上半部执行。
下半部：
如果中断处理过程比较耗时，那么就将这些比较耗时的代码提出来，交给下半部去执行，这样中断处理函数就可以快进快出。
上半部与下半部使用场景：
1、如果要处理的内容不希望被其他中断打断，可以放在上半部
2、如果要处理的任务对时间敏感，可以放在上半部
3、如果要处理的任务与硬件有关，可以放在上半部
4、除了以上三点外的其他任务，优先考虑放在下半部
上半部的处理比较简单，直接为中断号编写中断处理函数即可，关键是下半部要如何处理，下办部处理机制有3种，软中断，tasklet和workqueue。
软中断
软中断的数据结构
Linux内核使用softirq_action结构体表示软中断，softirq_action定义在文件include/linux/interrupt.h中：
struct softirq_action
{
void (*action)(struct softirq_action *);
};
在kernel/softirq.c文件中共定义了10个软中断，如下：
static struct softirq_action softirq_vec[NR_SOFTIRQS];
软中断的枚举类型定义在include\linux\interrupt.h中：
enum
{
HI_SOFTIRQ=0, /*高优先级软中断*/
TIMER_SOFTIRQ, /*定时器软中断*/
NET_TX_SOFTIRQ, /*网络数据发送软中断*/
NET_RX_SOFTIRQ, /*网络数据接收软中断*/
BLOCK_SOFTIRQ,
IRQ_POLL_SOFTIRQ,
TASKLET_SOFTIRQ, /*tasklet软中断*/
SCHED_SOFTIRQ, /*调度软中断*/
HRTIMER_SOFTIRQ, /*高精度定时器软中断*/
RCU_SOFTIRQ, /* RCU软中断 */
NR_SOFTIRQS
};
共10个软中断，所以NR_SOFTIRQS为10。softirq_action结构体中的action成员变量就是软中断的服务函数，数组softirq_vec是个全局数组，因此所有的CPU都可以访问到，每个CPU都有自己的触发和控制机制，并且只执行自己所触发的软中断。
软中断的使用
软中断必须在编译的时候静态注册，Linux内核使用softirq_init函数初始化软中断，softirq_init函数定义在kernel/softirq.c文件中：
static __latent_entropy void tasklet_action(struct softirq_action *a)
{
tasklet_action_common(a, this_cpu_ptr(&tasklet_vec), TASKLET_SOFTIRQ);
}
static __latent_entropy void tasklet_hi_action(struct softirq_action *a)
{
tasklet_action_common(a, this_cpu_ptr(&tasklet_hi_vec), HI_SOFTIRQ);
}
void __init softirq_init(void)
{
int cpu;
for_each_possible_cpu(cpu) {
per_cpu(tasklet_vec, cpu).tail =
&per_cpu(tasklet_vec, cpu).head;
per_cpu(tasklet_hi_vec, cpu).tail =
&per_cpu(tasklet_hi_vec, cpu).head;
}
open_softirq(TASKLET_SOFTIRQ, tasklet_action); // 默认打开TASKLET_SOFTIRQ,为TASKLET_SOFTIRQ注册软中断处理函数tasklet_action
open_softirq(HI_SOFTIRQ, tasklet_hi_action); // 默认打开HI_SOFTIRQ，为HI_SOFTIRQ注册软中断处理函数tasklet_hi_action
}
open_softirq函数原型：
void open_softirq(int nr,void(*action)(struct softirq_action *))
nr:要开启的软中断
action:软中断对应的处理函数
注册好软中断函数后，就需要在硬中断处理函数中触发软中断，函数原型：
void raise_softirq(unsigned int nr); // 触发软中断
nr:要触发的软中断
tasklet
tasklet是利用软中断来实现的另外一种下半部机制，相比软中断，更建议使用tasklet。
tasklet_struct结构体如下：
struct tasklet_struct
{
struct tasklet_struct *next; /*下一个tasklet*/
unsigned long state; /*tasklet状态*/
atomic_t count; /*计数器，记录对tasklet的引用数*/
bool use_callback;
union {
void (*func)(unsigned long data); /*tasklet执行的函数*/
void (*callback)(struct tasklet_struct *t);
};
unsigned long data; /*函数func的参数*/
};
如果要是使用tasklet，必须先定义一个tasklet_struct变量，然后使用tasklet_init函数进行初始化：
void tasklet_init(struct tasklet_struct *t,
void (*func)(unsigned long),
unsigned long data);
t : 要初始化的tasklet
func : tasklet的处理函数
data：要传递给func函数的参数
也可以使用宏一次性完成tasklet的定义和初始化：
DECLARE_TASKLET(name, func, data);
name:要定义的tasklet名字，就是tasklet_struct类型的变量名
func：tasklet的处理函数
data：传递给func函数的参数。
在中断上半部，就是在中断处理函数中调用tasklet_schedule函数就能使tasklet在合适的时间运行，tasklet_schedule原型：
void task_schedule(struct tasklet_struct *t);
t:要调度的tasklet,也就是DECLARE_TASKLET中的name
tasklet使用示例：
// 定义一个tasklet
struct tasklet_struct testtasklet;
// tasklet处理函数
void testtasklet_func(unsigned long data)
{
// tasklet具体处理内容
...
}
// 中断处理函数
irqreturn_t test_handler(int irq,void *dev_id)
{
...
// 调度tasklet
tasklet_schedule(&testtasklet);
...
}
// 驱动入口函数
static int __init xxxxx_init(void)
{
...
// 初始化tasklet
tasklet_init(&testtasklet,testtasklet_func,data);
// 注册中断处理函数
request_init(xxx_irq,test_handler,0,"xxx",&xxx_dev);
...
}
workqueue
可见：https://www.cnblogs.com/Wangzx000/p/17030415.html
中断程序实例
实验对象为按键中断，即按键KEY0即触发中断
1.在key设备树节点下添加中断相关属性
key{
compatible = "device,key";
status = "okay";
key-gpio = <&gpiog 3 GPIO_ACTIVE_LOW>;
/* 增加中断相关相关属性 */
interrupt-parent = <&gpiog>; /* KEY0使用的GPIO是PG3,所以中断控制器为gpiog */
interrupts = <3 IRQ_TYPE_EDGE_BOTH>; /* 设置中断源，第一个3表示GPIOG组的3号IO, IRQ_TYPE_EDGE_BOTH表示上升沿下降沿皆有效，定义在include/linux/irq.h中 */
};
设备树编写完成后使用make dtbs命令重新编译设备树，然后替换到板子的文件系统中重启Linux系统。
2.按键中断驱动程序
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/semaphore.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#define KEY_CNT 1 /* 设备号个数 */
#define KEY_NAME "key" /* 名字 */
/* 定义按键状态 */
enum key_status {
KEY_PRESS = 0, /* 按键按下 */
KEY_RELEASE, /* 按键松开 */
KEY_KEEP, /* 按键状态保持 */
};
/* key设备结构体 */
struct key_dev{
dev_t devid; /* 设备号 */
struct cdev cdev; /* cdev */
struct class *class; /* 类 */
struct device *device; /* 设备 */
struct device_node *nd; /* 设备节点 */
int key_gpio; /* key所使用的GPIO编号 */
struct timer_list timer; /* 按键值 */
int irq_num; /* 中断号 */
spinlock_t spinlock; /* 自旋锁 */
};
static struct key_dev key; /* 按键设备 */
static int status = KEY_KEEP; /* 按键状态 */
static irqreturn_t key_interrupt(int irq, void *dev_id)
{
/* 按键防抖处理，开启定时器延时15ms */
mod_timer(&key.timer, jiffies + msecs_to_jiffies(15));
return IRQ_HANDLED;
}
/*
* @description : 初始化按键IO，open函数打开驱动的时候
* 初始化按键所使用的GPIO引脚。
* @param : 无
* @return : 无
*/
static int key_parse_dt(void)
{
int ret;
const char *str;
/* 设置LED所使用的GPIO */
/* 1、获取设备节点：key */
key.nd = of_find_node_by_path("/key");
if(key.nd == NULL) {
printk("key node not find!\r\n");
return -EINVAL;
}
/* 2.读取status属性 */
ret = of_property_read_string(key.nd, "status", &str);
if(ret < 0)
return -EINVAL;
if (strcmp(str, "okay"))
return -EINVAL;
/* 3、获取compatible属性值并进行匹配 */
ret = of_property_read_string(key.nd, "compatible", &str);
if(ret < 0) {
printk("key: Failed to get compatible property\n");
return -EINVAL;
}
if (strcmp(str, "alientek,key")) {
printk("key: Compatible match failed\n");
return -EINVAL;
}
/* 4、 获取设备树中的gpio属性，得到KEY0所使用的KYE编号 */
key.key_gpio = of_get_named_gpio(key.nd, "key-gpio", 0);
if(key.key_gpio < 0) {
printk("can't get key-gpio");
return -EINVAL;
}
/* 5 、获取GPIO对应的中断号 */
key.irq_num = irq_of_parse_and_map(key.nd, 0);
if(!key.irq_num){
return -EINVAL;
}
printk("key-gpio num = %d\r\n", key.key_gpio);
return 0;
}
static int key_gpio_init(void)
{
int ret;
unsigned long irq_flags;
ret = gpio_request(key.key_gpio, "KEY0");
if (ret) {
printk(KERN_ERR "key: Failed to request key-gpio\n");
return ret;
}
/* 将GPIO设置为输入模式 */
gpio_direction_input(key.key_gpio);
/* 获取设备树中指定的中断触发类型 */
irq_flags = irq_get_trigger_type(key.irq_num);
if (IRQF_TRIGGER_NONE == irq_flags)
irq_flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
/* 申请中断 */
ret = request_irq(key.irq_num, key_interrupt, irq_flags, "Key0_IRQ", NULL);
if (ret) {
gpio_free(key.key_gpio);
return ret;
}
return 0;
}
static void key_timer_function(struct timer_list *arg)
{
static int last_val = 1;
unsigned long flags;
int current_val;
/* 自旋锁上锁 */
spin_lock_irqsave(&key.spinlock, flags);
/* 读取按键值并判断按键当前状态 */
current_val = gpio_get_value(key.key_gpio);
if (0 == current_val && last_val) /* 按下 */
status = KEY_PRESS;
else if (1 == current_val && !last_val)
status = KEY_RELEASE; /* 松开 */
else
status = KEY_KEEP; /* 状态保持 */
last_val = current_val;
/* 自旋锁解锁 */
spin_unlock_irqrestore(&key.spinlock, flags);
}
/*
* @description : 打开设备
* @param - inode : 传递给驱动的inode
* @param - filp : 设备文件，file结构体有个叫做private_data的成员变量
* 一般在open的时候将private_data指向设备结构体。
* @return : 0 成功;其他 失败
*/
static int key_open(struct inode *inode, struct file *filp)
{
return 0;
}
/*
* @description : 从设备读取数据
* @param – filp : 要打开的设备文件(文件描述符)
* @param – buf : 返回给用户空间的数据缓冲区
* @param – cnt : 要读取的数据长度
* @param – offt : 相对于文件首地址的偏移
* @return : 读取的字节数，如果为负值，表示读取失败
*/
static ssize_t key_read(struct file *filp, char __user *buf,
size_t cnt, loff_t *offt)
{
unsigned long flags;
int ret;
/* 自旋锁上锁 */
spin_lock_irqsave(&key.spinlock, flags);
/* 将按键状态信息发送给应用程序 */
ret = copy_to_user(buf, &status, sizeof(int));
/* 状态重置 */
status = KEY_KEEP;
/* 自旋锁解锁 */
spin_unlock_irqrestore(&key.spinlock, flags);
return ret;
}
/*
* @description : 向设备写数据
* @param - filp : 设备文件，表示打开的文件描述符
* @param - buf : 要写给设备写入的数据
* @param - cnt : 要写入的数据长度
* @param - offt : 相对于文件首地址的偏移
* @return : 写入的字节数，如果为负值，表示写入失败
*/
static ssize_t key_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
return 0;
}
/*
* @description : 关闭/释放设备
* @param - filp : 要关闭的设备文件(文件描述符)
* @return : 0 成功;其他 失败
*/
static int key_release(struct inode *inode, struct file *filp)
{
return 0;
}
/* 设备操作函数 */
static struct file_operations key_fops = {
.owner = THIS_MODULE,
.open = key_open,
.read = key_read,
.write = key_write,
.release = key_release,
};
/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init mykey_init(void)
{
int ret;
/* 初始化自旋锁 */
spin_lock_init(&key.spinlock);
/* 设备树解析 */
ret = key_parse_dt();
if(ret)
return ret;
/* GPIO 中断初始化 */
ret = key_gpio_init();
if(ret)
return ret;
/* 注册字符设备驱动 */
/* 1、创建设备号 */
ret = alloc_chrdev_region(&key.devid, 0, KEY_CNT, KEY_NAME); /* 申请设备号 */
if(ret < 0) {
pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", KEY_NAME, ret);
goto free_gpio;
}
/* 2、初始化cdev */
key.cdev.owner = THIS_MODULE;
cdev_init(&key.cdev, &key_fops);
/* 3、添加一个cdev */
ret = cdev_add(&key.cdev, key.devid, KEY_CNT);
if(ret < 0)
goto del_unregister;
/* 4、创建类 */
key.class = class_create(THIS_MODULE, KEY_NAME);
if (IS_ERR(key.class)) {
goto del_cdev;
}
/* 5、创建设备 */
key.device = device_create(key.class, NULL, key.devid, NULL, KEY_NAME);
if (IS_ERR(key.device)) {
goto destroy_class;
}
/* 6、初始化timer，设置定时器处理函数,还未设置周期，所有不会激活定时器 */
timer_setup(&key.timer, key_timer_function, 0);
return 0;
destroy_class:
class_destroy(key.class);
del_cdev:
cdev_del(&key.cdev);
del_unregister:
unregister_chrdev_region(key.devid, KEY_CNT);
free_gpio:
free_irq(key.irq_num, NULL);
gpio_free(key.key_gpio);
return -EIO;
}
/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit mykey_exit(void)
{
/* 注销字符设备驱动 */
cdev_del(&key.cdev);/* 删除cdev */
unregister_chrdev_region(key.devid, KEY_CNT); /* 注销设备号 */
del_timer_sync(&key.timer); /* 删除timer */
device_destroy(key.class, key.devid);/*注销设备 */
class_destroy(key.class); /* 注销类 */
free_irq(key.irq_num, NULL); /* 释放中断 */
gpio_free(key.key_gpio); /* 释放IO */
}
module_init(mykey_init);
module_exit(mykey_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("ALIENTEK");
MODULE_INFO(intree, "Y");
驱动程序编写完成后，编译成.ko的驱动模块文件，拷贝到Linux的文件系统中，然后加载keyirq.ko驱动模块
depmod // 第一次加载驱动的时候需要运行此命令
modprobe keyirq.ko // 加载驱动
rmmod keyirq.ko // 卸载驱动命令
加载后通过查看/proc/interrupts文件来检查对应中断有没有被注册上：
cat /proc/interrupts
表示KEY0中断已经存在，触发方式为Edge
3.编写测试APP
测试app会通过不断的读取/dev/key设备文件来获取按键值来判断当前按键的状态，从按键驱动中获取的数据有3个值，分别为0、1、2；0表示按键按下状态，1表示按键松开时状态，2表示按键一直被按住或松开。
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
/*
* @description : main主程序
* @param – argc : argv数组元素个数
* @param – argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
int fd, ret;
int key_val;
/* 判断传参个数是否正确 */
if(2 != argc) {
printf("Usage:\n"
"\t./keyApp /dev/key\n"
);
return -1;
}
/* 打开设备 */
fd = open(argv[1], O_RDONLY);
if(0 > fd) {
printf("ERROR: %s file open failed!\n", argv[1]);
return -1;
}
/* 循环读取按键数据 */
for ( ; ; ) {
read(fd, &key_val, sizeof(int));
if (0 == key_val) // 如果读取到的值为0
printf("Key Press\n");
else if (1 == key_val) // 如果读取到的值为1
printf("Key Release\n");
}
/* 关闭设备 */
close(fd);
return 0;
}
将app测试文件使用交叉编译链编译为应用程序，拷贝到Linux文件系统中，运行测试程序:
./keyirqApp /dev/key
然后按键KEY0查看log，判断按键值获取是否成功
参考文章：
【正点原子】STM32MP1嵌入式Linux驱动开发指南V2.0.pdf - 第三十一章
