【Linux中断】Linux系统中断机制简述

_Emma_

已于 2024-07-16 10:13:57 修改

阅读量521

点赞数

分类专栏： Linux 文章标签： linux

于 2023-08-23 17:24:28 首次发布

本文链接：https://blog.csdn.net/qq_38089448/article/details/132457300

版权

Linux 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

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;
}