Linux驱动学习—中断

最新推荐文章于 2024-01-12 10:20:45 发布
最新推荐文章于 2024-01-12 10:20:45 发布
阅读量1.1k 收藏 24
点赞数 28
文章标签： linux 学习 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suifen_/article/details/135434176
版权

1、中断基础概念

1.1 什么是中断

CPU在正常运行期间，由外部或者内部引起的时间，让CPU停下当前正在运行的程序，转而去执行触发他的中断所对应的程序，这就是中断。

响应中断的过程：

<1>中断请求
<2>中断响应
<3>保护现场
<4>中断处理
<5>恢复现场
<6>中断返回

如果不响应中断，就是中断屏蔽。

1.2 什么是中断上下文，为什么会有中断上下文？

中断的存在可以极大的提高CPU的运行效率，但是中断会打断内核进程中的正常调度和运行，所以为保证系统实时性，中断服务程序必须足够简短，但实际应用中某些时候发生中断时需要处理大量的事务，这时候如果都在中断服务程序中完成，则会严重降低中断的实时性，基于这个原因，Linux系统提出一个概念：把中断服务程序分为两部分：中断上文和中断下文。

中断上文：完成尽可能少却比较急的任务，中断上文的特点就是响应速度快。

中断下文：处理中断剩余的大量比较耗时间的任务，而且可以被中断打断。

总之：中断上文越快也好，中断下文可以做比较耗时间的事情，但是不能死循环。

1.3 Linux中断可以嵌套吗？

以前可以，现在不可以。

2、设备树上的中断节点以及相关函数

2.1 设备树中的中断节点

如果一个设备需要用到中断功能，开发人员就需要在设备树中配置好中断属性信息，因为设备树是用来描述硬件信息的，然后Linux内核通过设备树配置的中断属性来配置中断功能。

设备树中断的参考绑定文档：

Documentation\devicetree\bindings\arm\gic.txt

中断实际上是非常复杂，但是作为开发人员，只需要关心怎么在设备树中指定中断，怎么在代码中获得中断就可以。其他的事情，比如设备树中的中断控制器，这些都是由原厂的BSP工程师帮我们写好了，不需要我们修改。

比如在imx6ull,dtsi文件，其中的inc节点就是imx6ull的中断控制器节点，如下：

intc: interrupt-controller@00a01000 {
    compatible = "arm,cortex-a7-gic";
    #interrupt-cells = <3>;
    interrupt-controller;
    reg = <0x00a01000 0x1000>,
    <0x00a02000 0x100>;
};

比如，对于GPIO来说，GPIO的节点也可以作为中断控制器，在imx6ull.dtsi中GPIO1是节点如下所示：

gpio1: gpio@0209c000 {
    compatible = "fsl,imx6ul-gpio", "fsl,imx35-gpio";
    reg = <0x0209c000 0x4000>;
    interrupts = <GIC_SPI 66 IRQ_TYPE_LEVEL_HIGH>,
    <GIC_SPI 67 IRQ_TYPE_LEVEL_HIGH>;
    gpio-controller;
    #gpio-cells = <2>;
    interrupt-controller;
    #interrupt-cells = <2>;
};

这些工作都是由原厂的BSP工程师来帮我我们写好的，并不需要我们来写，除非将来你有机会去原厂工作，否则不会从头开始写一个设备树文件的，分工是非常明确的，我们需要关注的点是怎么在设备树里面 描述一个外设的中断节点，下面请看一下例子。

key {
    #address-cells = <1>,
    #size-cells = <1>,
    compatible = "key";
    pinctrl-name = "default";
    pinctrl-0 = <&pinctrl_key>;
    key-gpio = <&gpio1 18 GPIO_ACTIVE_LOW>;
    interrupt-parent = <&gpio1>;
    interrupts = <18 IRQ_TYPE_EDOGE_BOTH>;
    status = "okay";
}

在上面这个例子中，先使用pinctrl和gpio子系统把这个引脚设置为gpio功能，因为在使用中断功能的时候需要把引脚设置为输入，然后使用interrupt-parent和interrupts属性来描述中断。 interrupt-parent属性值为gpio1，也就是要使用gpio1这个中断控制器，为什么是gpio1呢，因为我们引脚使用的是gpio1里面的io18，所以我们使用的是gpio1这个中断控制器。 ​ interrupts属性设置的是中断源，为啥里面有两个中断源呢，因为gpio1这个中断控制器里面#interrupts-cells的值为2。例子中的第一个cells的18表示GPIO1组的18号，IRQ_TYPE_EDOGE_BOTH表示上升沿和下降沿都有效。IRQ_TYPE_EDOGE_BOTH定义在include/linux/irq.h中。

所以在设备树里面配置中断的时候只需要两个步骤即可，第一个就是把管脚设置为功能。第一个步骤就是使用 interrupt-parent 和 interrupts 属性来描述中断。

2.2 中断相关函数

<1>获取中断号的相关函数

编写驱动的时候需要用到中断号，每一个中断都有一个中断号，我们用到中断号，中断信息已经写到了设备树里面，因此可以通过irq_of_parse_and_map函数从interupts属性中提取到对应的设备号，函数原型在include/linux/of_irq.h，如下：

unsigned int irq_of_parse_and_map(struct device_node *node, int index);
参数：
node:设备节点。
index:索引号，interrupts属性可能包含多条中毒啊您西，通过index指定要获取的信息。
返回值：中断号。

如果使用GPIO的话，可以使用gpio_to_irq函数来获取gpio对应的中断号，函数原型在include/linux/gpio.h，如下：

int gpio_to_irq(unsigned int gpio)；
参数：
gpio：要获取的GPIO编号。
返回值：GPIO对应的中断号。
<2>申请中断函数

同GPIO一样，在Linux内核里面，如果我们要使用某个中断也是需要申请的，申请中断我们使用的函数是requst_irq,其在include/linux/interrupt.h中，如下：

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设置为IRQ_SHARED的话，dev用来区分不同的中断，一般情况下将dev设置为设备结构体，dev将传递给中断函数irq_handler_t的第二个人参数。
返回值：0中断申请成功，其他负值申请失败，如果返回-EBUSY的话表示中断已经被申请了。
<3>中断处理函数

使用给request_irq函数申请中断的时候需要设置中断处理函数，中断处理函数格式如下所示：

typedef irqreturn_t (*irq_handler_t)(int, void *);
//第一个参数是要申请的中断处理函数要对应的中断号。第二个参数是一个指向void的指针，也就是个通用指针，需要与request_irq函数的dev参数保持一致。用于区分共享中断的不同设备，dev也可以指向设备数据结构。中断 处理函数的返回值比为irqreturn_t类型，irqreturn_t类型如下所示，
其在include\linux\irqreturn.h
enum irqreturn {
    IRQ_NONE        = (0 << 0),
    IRQ_HANDLED     = (1 << 0),
    IRQ_WAKE_THREAD     = (1 << 1),
};
可以看出irqreturn_t是个枚举类型，一共有三种返回值。一般中断服务函数返回值如下形式：
return IRQ_RETVAL(IRQ_HANDLED);
<4> free_irq函数

中断使用完成以后就要通过free_irq函数释放掉相应的中断。如果中断不是共享的，那么free_irq会删除中断处理函数并且禁止中断。free_irq函数原型：在include/linux/interrupt.h

void free_irq(unsigned int, void *);
函数：
irq：要释放的中断号。
dev:如果中断设置为共享的话，此参数用来区分具体的中断，共享中断只有在释放最后中断处理函数的时候才会被禁止掉。
返回值:无。

3、按键中断实验

3.1 设备树中不加intrrupt-parent和interrupts属性

由于使用的是GPIO中断，所以可以不用intrrupt-parent和interrupts属性这两个属性，设备树添加节点如下：

test_key{
    compatible = "keys";
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_gpio_keys>;
    gpios = <&gpio1 18 GPIO_ACTIVE_LOW>;
}
​
pinctrl-gpio_keys:gpio-keys{
    fsl,pins = <
        MX6UL_PAD_UART1_CTS_B__GPIO1_IO18       0x80000000
    >;
}

注意：下面 这两个地方的值要一致，因为匹配成功才会进入probe函数。

将这个改动的设备树文件编译，然后烧写到开发板上，在/proc/devive-tree/上查询到设备树添加的节点：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
#include <linux/of.h>
#include <linux/of_address.h>
​
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
​
struct device_node *test_device_node;
struct property *test_node_property;
int gpio_num;
int irq = 0;
​
static const of_device_id of_match_table_test[] = {//匹配表
    {.compatible = "keys"},
};
​
static const platform_device_id beep_id_table ={
    .name = "beep_test",
};
​
irqreturn_t test_key(int irq, void *args)
{
    printk("test_key\n");
    return IRQ_HANDLED;
}
​
/*设备树节点compatible属性与of_match_table_test的compatible相匹配就会进入该函数,pdev是匹配成功后传入的设备树节点*/
int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe\n");
    
    //查找要查找的节点
    test_device_node = of_find_node_by_path("/test_key");
    if (test_device_node == NULL) {
        printk("test_device_node find error\n");
        return -1;
    }
    printk("test_device_node name is %s\n",test_device_node->name);//test_key
    
    gpio_num = of_get_named_gpio(test_device_node, "gpios", 0);
    if (gpio_num < 0) {
        printk("of_get_named_gpio error\n");
        return -1;
    }
    printk("gpio_num name is %d\n",gpio_num);
    
    gpio_direction_input(gpio_num);
    irq = gpio_to_irq(gpio_num);
    printk("irq is %d\n",irq);
    
    ret = request_irq(irq, test_key, IRQF_TRIGGER_RISING, "test_key", NULL);//
    if (ret < 0) {
        printk("request_irq error\n");
        return -1;
    }
    
    return 0;
}
​
int beep_remove(struct platform_device *pdev)
{
    pritnk("beep_remove \n");
    return 0;
}
​
strcut platform_driver beep_device = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "123",
        .of_match_table = of_match_table_test,//匹配表 
    },
    .id_table = &beep_id_table,
};
​
static int beep_driver_init(void)
{
    int ret = -1;
    ret = platform_driver_register(&beep_device);
    if(ret < 0) {
        printk("platform_driver_register error \n");
    }
    printk("platform_driver_register ok\n");
    return 0;
}
​
static void  beep_driver_exit(void)
{
    free_irq(irq, NULL);
    platform_driver_unregister(&beep_device);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

编译加载驱动：

、

怎么看成功申请了中断呢？下图可以看到申请成功了，中断号是48.

按下开发板的按键,会打印对应的信息：

怎么看中断发生了几次呢？

上图也打印了五次信息.

3.2 设备树中加intrrupt-parent和interrupts属性

设备树中加intrrupt-parent和interrupts属性，下面修改dts，改成边沿触发都可以，即上升沿和下降沿都可以：

修改驱动：

主要区别就是获取中断号的函数你变了，改成irq_of_parse_and_map获取。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
#include <linux/of.h>
#include <linux/of_address.h>
​
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
​
#include <linux/of_irq.h>
​
struct device_node *test_device_node;
struct property *test_node_property;
int gpio_num;
int irq = 0;
​
static const of_device_id of_match_table_test[] = {//匹配表
    {.compatible = "keys"},
};
​
static const platform_device_id beep_id_table ={
    .name = "beep_test",
};
​
irqreturn_t test_key(int irq, void *args)
{
    printk("test_key\n");
    return IRQ_HANDLED;
}
​
/*设备树节点compatible属性与of_match_table_test的compatible相匹配就会进入该函数,pdev是匹配成功后传入的设备树节点*/
int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe\n");
    
​
    //查找要查找的节点
    test_device_node = of_find_node_by_path("/test_key");
    if (test_device_node == NULL) {
        printk("test_device_node find error\n");
        return -1;
    }
    printk("test_device_node name is %s\n",test_device_node->name);//test_key
    
    gpio_num = of_get_named_gpio(test_device_node, "gpios", 0);
    if (gpio_num < 0) {
        printk("of_get_named_gpio error\n");
        return -1;
    }
    printk("gpio_num name is %d\n",gpio_num);
    
    gpio_direction_input(gpio_num);
    //获取中断号
    //irq = gpio_to_irq(gpio_num);
    irq = irq_of_parse_and_map(test_device_node, 0);
    printk("irq is %d\n",irq);
    
    ret = request_irq(irq, test_key, IRQF_TRIGGER_RISING, "test_key", NULL);//
    if (ret < 0) {
        printk("request_irq error\n");
        return -1;
    }
    
    return 0;
​
}
​
int beep_remove(struct platform_device *pdev)
{
    pritnk("beep_remove \n");
    return 0;
}
​
strcut platform_driver beep_device = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "123",
        .of_match_table = of_match_table_test,//匹配表 
    },
    .id_table = &beep_id_table,
};
​
static int beep_driver_init(void)
{
    int ret = -1;
    ret = platform_driver_register(&beep_device);
    if(ret < 0) {
        printk("platform_driver_register error \n");
    }
    printk("platform_driver_register ok\n");
    return 0;
}
​
static void  beep_driver_exit(void)
{
    free_irq(irq, NULL);
    platform_driver_unregister(&beep_device);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

编译加载驱动：

按下按键：

4、中断上下文之tasklet

4.1 什么是tasklet

tasklet是中断处理中断下文的常用的一种方法，tasklet是一种特殊的软中断。处理中断下文的机制还有工作队列和软中断。

4.2怎么使用tasklet来设计中断下文

框图如下：

Linux把中断分成两个部分，一个是上半部分，一个是下半部分，在上半部分我们只处理紧急的事情，同时我们可以调用tasklet来启动中断下文，比较耗时间的就要放到下文来处理，调用tasklet以后，tasklet绑定的函数并不会立马执行，而是出中断以后，经过一个很短的不确定时间来执行。

4.3 tasklet定义

tasklet由tasklet_struct结构表示，每个结构体单独代表一个tasklet。在<linux/intrrupt.h>中定义为：

struct tasklet_struct
{
    struct tasklet_struct *next;//链表中的下一个tasklet,方便管理和设置tasklet;
    unsigned long state;//tasklet的状态
    atomic_t count;//表示tasklet是否在激活状态，如果是0，就处在激活状态，如果非0，就处在非激活状态。
    void (*func)(unsigned long);//结构体中的func成员是tasklet的绑定哈桑农户，data是它唯一的参数。
    unsigned long data;//函数执行的时候传递的参数，第五个参数data可以区分不同结构体之间传过来的参数。
};

4.4 tasklet相关函数

<1> tasklet_schdule函数

作用：调度tasklet.

void __tasklet_schedule(struct tasklet_struct *t);
参数：指向tasklet_struct结构的指针。
<2>tasklet_init函数

作用：动态初始化tasklet

tasklet_init(struct tasklet_struct *t,
             void (*func)(unsigned long), unsigned long data);
参数：
*t:指向tasklet_struct结构的指针。
func：tasklet绑定的函数。
data:函数执行的时候传递的函数。
<3>tasklet_kill函数

作用：删除一个tasklet

void tasklet_kill(struct tasklet_struct *t);
参数：指向tasklet_struct结构的指针

4.5 使用tasklet设备及中断下文步骤

<1>步骤一：定义一个tasklet结构体
<2>步骤二：动态初始化tasklet
<3>步骤三：编写tasklet绑定的函数
<4>步骤四：在中断上文调用tasklet
<5>步骤五：卸载模块的时候删除tasklet

4.6 实验代码

在3.2的基础上修改。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
#include <linux/of.h>
#include <linux/of_address.h>
​
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
​
#include <linux/of_irq.h>
​
struct device_node *test_device_node;
struct property *test_node_property;
int gpio_num;
int irq = 0;
​
struct tasklet_struct key_test;
​
static const of_device_id of_match_table_test[] = {//匹配表
    {.compatible = "keys"},
};
​
static const platform_device_id beep_id_table ={
    .name = "beep_test",
};
​
irqreturn_t test_key(int irq, void *args)
{
    printk("start\n");
    tasklet_schedule(&key_test);
    printk("end\n");
    return IRQ_HANDLED;
}
​
void test(void) 
{
    int i = 100;
    while (i--) {
        printk("teat_key is %d\n",i);//中断下文打印一百次
    }
}
​
/*设备树节点compatible属性与of_match_table_test的compatible相匹配就会进入该函数,pdev是匹配成功后传入的设备树节点*/
int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe\n");
    
​
    //查找要查找的节点
    test_device_node = of_find_node_by_path("/test_key");
    if (test_device_node == NULL) {
        printk("test_device_node find error\n");
        return -1;
    }
    printk("test_device_node name is %s\n",test_device_node->name);//test_key
    
    gpio_num = of_get_named_gpio(test_device_node, "gpios", 0);
    if (gpio_num < 0) {
        printk("of_get_named_gpio error\n");
        return -1;
    }
    printk("gpio_num name is %d\n",gpio_num);
    
    gpio_direction_input(gpio_num);
    //获取中断号
    //irq = gpio_to_irq(gpio_num);
    irq = irq_of_parse_and_map(test_device_node, 0);
    printk("irq is %d\n",irq);
    
    ret = request_irq(irq, test_key, IRQF_TRIGGER_RISING, "test_key", NULL);//
    if (ret < 0) {
        printk("request_irq error\n");
        return -1;
    }
    
    tasklet_init(&kety_test, test, 0);
    return 0;
​
}
​
int beep_remove(struct platform_device *pdev)
{
    pritnk("beep_remove \n");
    return 0;
}
​
strcut platform_driver beep_device = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "123",
        .of_match_table = of_match_table_test,//匹配表 
    },
    .id_table = &beep_id_table,
};
​
static int beep_driver_init(void)
{
    int ret = -1;
    ret = platform_driver_register(&beep_device);
    if(ret < 0) {
        printk("platform_driver_register error \n");
    }
    printk("platform_driver_register ok\n");
    return 0;
}
​
static void  beep_driver_exit(void)
{
    free_irq(irq, NULL);
    testlet_kill(&key_test);
    platform_driver_unregister(&beep_device);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

加载驱动，按下按键：

4.6.1 修改代码，看看第tasklet结构体五个参数data的值能不能传进来

编译加载驱动，按下按键：

5、等待队列

5.1 阻塞和非阻塞的概念

阻塞：当前设备如果不可读或不可写时，也就是不能获得资源的时候，那么当前进程会被挂起。只有当设备满足条件的时候才可以返回。默认情况下，文件都是以这种方式打开。

非阻塞：当前设备不可读或不可写时，该函数不糊阻塞当前进程，要么放弃，要么不停的查询，直到可以操作为止。

读写函数是否阻塞可以通过参数来指定：

fd = open(filepath, O_RDWR);    //默认阻塞打开
fd = open(filepath, O_RDWR|O_NONBLOCK); //非阻塞方式打开

5.2 等待队列基础知识

当我们进程去访问设备的时候，经常需要等待有特定事件发生以后在继续往下运行，这个时候就需要在驱动里面实现当条件不满足的时候进程休眠，当条件满足的时候在由内核唤醒进程。那么等待队列就实现了在事件上的条件等待。

<1>等待队列头

等待队列头就是一个等待队列的头部，每个访问设备的进程都是一个队列项，当设备不可用的时候就要将这些进程对应的等待队列添加到等待队列里面。

等待队列头使用结构体wait_queue_head_t来表示，这个结构体定义在文件include/linux/wait.h里面，结构体内容如下：

struct __wait_queue_head {
    spinlock_t      lock;//自旋锁
    struct list_head    task_list;//链表头
};
typedef struct __wait_queue_head wait_queue_head_t;

类型名是wait_queue_head_t，只要记住这个即可。

定义一个等待队列头：wait_queue_head_t test_wq；

定义等待队列头以后需要初始话，可以使用init_wait_queue_head宏初始化等待队列头，函数原型如下：

extern void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
​
#define init_waitqueue_head(q)              \
    do {                        \
        static struct lock_class_key __key; \
                            \
        __init_waitqueue_head((q), #q, &__key); \
    } while (0)

也可以使用宏DECLARE_WAIT_QUEUE_HEAD来一次性完成等待队列头的定义和初始化。

extern void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
#define DECLARE_WAIT_QUEUE_HEAD(name) \
    wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

5.3 等待队列相关函数

<1>init_waitqueue_head宏

作用：动态初始化等待队列头结构。

extern void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
#define init_waitqueue_head(q)              \
    do {                        \
        static struct lock_class_key __key; \
                            \
        __init_waitqueue_head((q), #q, &__key); \
    } while (0)
<2>wait_event宏

作用：不可中断的阻塞等待，让调用进程不可中断的睡眠状态，在等待队列里面睡眠知道condition变成真，被内核唤醒。

long prepare_to_wait_event(wait_queue_head_t *q, wait_queue_t *wait, int state);
#define ___wait_event(wq, condition, state, exclusive, ret, cmd)    \
({                                  \
    __label__ __out;                        \
    wait_queue_t __wait;                        \
    long __ret = ret;   /* explicit shadow */           \
                                    \
    init_wait_entry(&__wait, exclusive ? WQ_FLAG_EXCLUSIVE : 0);    \
    for (;;) {                          \
        long __int = prepare_to_wait_event(&wq, &__wait, state);\
                                    \
        if (condition)                      \
            break;                      \
                                    \
        if (___wait_is_interruptible(state) && __int) {     \
            __ret = __int;                  \
            goto __out;                 \
        }                           \
                                    \
        cmd;                            \
    }                               \
    finish_wait(&wq, &__wait);                  \
__out:  __ret;                              \
})
​
参数：
wq:wait_queue_head_t 指针
condition：为等待的条件，为假时才可以进入休眠。
注意：调用的时候要确认condition的值是真还是假，如果调用condition为真，则不会休眠。
<3> wait_event_interruptible宏

功能：可中断的阻塞等待，让调用的 进程进入可中断的睡眠状态，知道condition变成真被内核唤醒或信号打断唤醒。

#define wait_event_interruptible(wq, condition)             \
({                                  \
    int __ret = 0;                          \
    might_sleep();                          \
    if (!(condition))                       \
        __ret = __wait_event_interruptible(wq, condition);  \
    __ret;                              \
})
参数：
wq:wait_queue_head_t 指针
condition：为等待的条件，为假时才可以进入休眠。
返回：判断condition是否为真，如果为真则返回，反则检查如果进程是被信号唤醒会返回-ERESTARTSYS错误码。如果是condition为真，则返回0。
<4>wake_up宏

功能：唤醒所有休眠进程。

#define wake_up(x)          __wake_up(x, TASK_NORMAL, 1, NULL)
参数：
x：等待队列头结构指针
<5>wake_up_interruptible宏

功能：唤醒可中断 的休眠进程

#define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
参数：
x：等待队列头结构指针

5.4 实验：为什么需要等待队列

5.4.1 不使用等待队列
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#incldue <unistd.h>
​
int main(int argc, char *argv[])
{
    int fd;
    int value;
    fd = open("/dev/test_wq",O_RDWD);
    if (fd < 0) {
        perror("open error");
        return fd;
    }
    while (1) {
        read(fd, &value, sizeof(value));
        printf("value is %d\n",value);
    }
    return 0;
}
​
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
#include <linux/of.h>
#include <linux/of_address.h>
​
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
​
#include <linux/of_irq.h>
​
struct device_node *test_device_node;
struct property *test_node_property;
int value = 0;//用来模拟管脚的状态
​
//struct tasklet_struct key_test;
​
static const of_device_id of_match_table_test[] = {//匹配表
    {.compatible = "keys"},
};
​
static const platform_device_id beep_id_table ={
    .name = "beep_test",
};
​
irqreturn_t test_key(int irq, void *args)
{
    value != value;
    return IRQ_HANDLED;
}
​
​
int misc_open(struct inode *inode, struct file *file)
{
    printk("misc_open\n");
    return 0;
}
​
int misc_release(struct inode *inode, struct file *file)
{
    printk("misc_relese\n");
    return 0;
}
​
ssize_t misc_read(struct file *file,char __user *ubuf, size_t size, loff_t *loff_t)
{
    if(copy_to_user(ubuf, &value, sizeof(value)) != 0) {
        printk("copy_to_user error\n");
        return -1;
    }
    return 0;
}
​
ssize_t misc_wirie(struct file *file,char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[64] = {0};
    
    if(copy_form_user(kbuf, ubuf, strlen(kbuf)) != 0) {
        printk("copy_form_user error\n");
        return -1;
    }
    printk("kbuf is %s\n",kbuf);
    
    if(kbuf[0] == 1)
        get_set_value(beep_gpio, 1);
    else if(kbuf[0] == 0)
        get_set_value(beep_gpio, 0);
    
    return 0;
}
​
struct file_operations misc_fops = {
    .owner      = THIS_MODULE,
    .open       = misc_open,
    .release    = misc_release,
    .write      = misc_wirie,
    .read       = misc_read
};
​
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name  = "test_wq",
    .fops  = &misc_fops
};
​
/*设备树节点compatible属性与of_match_table_test的compatible相匹配就会进入该函数,pdev是匹配成功后传入的设备树节点*/
int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe\n");
    
​
    //查找要查找的节点
    test_device_node = of_find_node_by_path("/test_key");
    if (test_device_node == NULL) {
        printk("test_device_node find error\n");
        return -1;
    }
    printk("test_device_node name is %s\n",test_device_node->name);//test_key
    
    gpio_num = of_get_named_gpio(test_device_node, "gpios", 0);
    if (gpio_num < 0) {
        printk("of_get_named_gpio error\n");
        return -1;
    }
    printk("gpio_num name is %d\n",gpio_num);
    
    gpio_direction_input(gpio_num);
    //获取中断号
    //irq = gpio_to_irq(gpio_num);
    irq = irq_of_parse_and_map(test_device_node, 0);
    printk("irq is %d\n",irq);
    
    ret = request_irq(irq, test_key, IRQF_TRIGGER_RISING, "test_key", NULL);//
    if (ret < 0) {
        printk("request_irq error\n");
        return -1;
    }
    
    //tasklet_init(&key_test, test, 0);
    ret = misc_register(&misc_dev);
    
    return 0;
}
​
int beep_remove(struct platform_device *pdev)
{
    pritnk("beep_remove \n");
    return 0;
}
​
strcut platform_driver beep_device = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "123",
        .of_match_table = of_match_table_test,//匹配表 
    },
    .id_table = &beep_id_table,
};
​
static int beep_driver_init(void)
{
    int ret = -1;
    ret = platform_driver_register(&beep_device);
    if(ret < 0) {
        printk("platform_driver_register error \n");
    }
    printk("platform_driver_register ok\n");
    return 0;
}
​
static void  beep_driver_exit(void)
{
    free_irq(irq, NULL);
    misc_deregister(&misc_dev);
    platform_driver_unregister(&beep_device);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

后台运行app，可以使用top命令查看cpu占用率：

5.4.2 使用等待队列

对上面的驱动进行修改：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
#include <linux/of_irq.h>
​
#include <linux/wait.h>
#inlcude <linux/sched.h>
​
struct device_node *test_device_node;
struct property *test_node_property;
DECLARE_WAIT_QUEUE_HEAD(key_wq);//这种方法是一次性的初始化等待队列头的定义和初始化，还有一种方法是下面这种：
//wait_queue_head_t  key_wq；
//#define init_waitqueue_head(key_wq);  
​
int wq_flags = 0;
int value = 0;//用来模拟管脚的状态
​
//struct tasklet_struct key_test;
​
static const of_device_id of_match_table_test[] = {//匹配表
    {.compatible = "keys"},
};
​
static const platform_device_id beep_id_table ={
    .name = "beep_test",
};
​
irqreturn_t test_key(int irq, void *args)
{
    value != value;
    wq_flags = 1;
    wake_up(&key_wq);
    return IRQ_HANDLED;
}
​
int misc_open(struct inode *inode, struct file *file)
{
    printk("misc_open\n");
    return 0;
}
​
int misc_release(struct inode *inode, struct file *file)
{
    printk("misc_relese\n");
    return 0;
}
​
ssize_t misc_read(struct file *file,char __user *ubuf, size_t size, loff_t *loff_t)
{
    wait_event_interruptible(key_wq, wq_flags);
    if(copy_to_user(ubuf, &value, sizeof(value)) != 0) {
        printk("copy_to_user error\n");
        return -1;
    }
    wq_flags = 0;
    return 0;
}
​
ssize_t misc_wirie(struct file *file,char __user *ubuf, size_t size, loff_t *loff_t)
{
    char kbuf[64] = {0};
    
    if(copy_form_user(kbuf, ubuf, strlen(kbuf)) != 0) {
        printk("copy_form_user error\n");
        return -1;
    }
    printk("kbuf is %s\n",kbuf);
    
    if(kbuf[0] == 1)
        get_set_value(beep_gpio, 1);
    else if(kbuf[0] == 0)
        get_set_value(beep_gpio, 0);
    
    return 0;
}
​
struct file_operations misc_fops = {
    .owner      = THIS_MODULE,
    .open       = misc_open,
    .release    = misc_release,
    .write      = misc_wirie,
    .read       = misc_read
};
​
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name  = "test_wq",
    .fops  = &misc_fops
};
​
/*设备树节点compatible属性与of_match_table_test的compatible相匹配就会进入该函数,pdev是匹配成功后传入的设备树节点*/
int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe\n");
​
    //查找要查找的节点
    test_device_node = of_find_node_by_path("/test_key");
    if (test_device_node == NULL) {
        printk("test_device_node find error\n");
        return -1;
    }
    printk("test_device_node name is %s\n",test_device_node->name);//test_key
    
    gpio_num = of_get_named_gpio(test_device_node, "gpios", 0);
    if (gpio_num < 0) {
        printk("of_get_named_gpio error\n");
        return -1;
    }
    printk("gpio_num name is %d\n",gpio_num);
    
    gpio_direction_input(gpio_num);
    //获取中断号
    //irq = gpio_to_irq(gpio_num);
    irq = irq_of_parse_and_map(test_device_node, 0);
    printk("irq is %d\n",irq);
    
    ret = request_irq(irq, test_key, IRQF_TRIGGER_RISING, "test_key", NULL);//
    if (ret < 0) {
        printk("request_irq error\n");
        return -1;
    }
    
    //tasklet_init(&key_test, test, 0);
    ret = misc_register(&misc_dev);
    
    return 0;
}
​
int beep_remove(struct platform_device *pdev)
{
    pritnk("beep_remove \n");
    return 0;
}
​
strcut platform_driver beep_device = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "123",
        .of_match_table = of_match_table_test,//匹配表 
    },
    .id_table = &beep_id_table,
};
​
static int beep_driver_init(void)
{
    int ret = -1;
    ret = platform_driver_register(&beep_device);
    if(ret < 0) {
        printk("platform_driver_register error \n");
    }
    printk("platform_driver_register ok\n");
    return 0;
}
​
static void  beep_driver_exit(void)
{
    free_irq(irq, NULL);
    misc_deregister(&misc_dev);
    platform_driver_unregister(&beep_device);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

主要改动如下：

编译代码并加载驱动：

再一次后台运行，看看cpu运行率咋样：

6、工作队列

6.1 什么是工作队列

工作队列（workqueue)是实现中断下文的机制之一，是一种将工作退后执行的形式。那工作队列和我们之前学习的tasklet有什么不同呢？tasklet也是实现中断下文的机制。他们两个最主要的区别是tasklet不能休眠，二工作队列可以休眠。所以，tasklet可以用来处理比较耗时间的事情，二工作队列可以处理非常复杂的并且更耗时间的事情。

6.2 工作队列（workqueue)的工作原理

LInux系统在启动期间会创建内核线程，该线程创建以后就处于sleep状态，然后这个线程会一直去队列里面读，看看有没有任务，如果有就执行，如果没有就休眠。工作队列的实现机制实际上是非常复杂的，初学阶段只需要了解这些基本概念接口。可以类比理解为：

流水线的机械：Linux系统自动会创建一个。多种不同的无聊使用同一个流水线机械，那么这个就是共享工作队列的概念。

如果当前的流水线机械不能满足我们加工的无聊，我们是不是就需要重新定制一台流水线机器呢，这个就是自定义工作队列的概念。

共享工作队列有什么缺点呢？

不需要自己 创建，但是如果前面的工作比较耗时间，就会影响后面的工作。

自定义工作队列有什么优缺点呢？

需要自己创建，系统开销大。一抔点是不会受到其他工作的影响。（因为这个流水线就是专门加工这一种零件的。

6.3 工作队列相关API

尽管工作队列的实现机制非常复杂，但是我们使用工作队列其实就是在这个流水线上添加自己的无聊，然后等待自己执行即可。

一个具体的工作（类比就是流水线上的物料）我们使用work_struct来描述的，定义在include\linux\workqueue.h里面。所以我们使用工作队列的第一步就是先定义个工作队列。

struct work_struct {
    atomic_long_t data;
    struct list_head entry;
    work_func_t func;
#ifdef CONFIG_LOCKDEP
    struct lockdep_map lockdep_map;
#endif
};

在这个结构体里面只需要关注func这个成员就可以了，他是一个函数指针，以为我们要把我们需要完成的工作写在这个函数里面。

<1>宏DECLARE_WORK

作用：静态定义并且初始化工作队列。

#define DECLARE_WORK(n, f)                      \
    struct work_struct n = __WORK_INITIALIZER(n, f)
<2>宏INIT_WORK

作用：动态定义并初始化工作结构。

#define INIT_WORK(_work, _func)                     \
    __INIT_WORK((_work), (_func), 0)
参数：
work：工作队列地址。
func:工作函数

举例：

struct work_struct test;
在模块初始化函数中：INIT_WORK(&test, func);
相当于:DECLARE_WORK(test,func);
<3>schedule_work

作用：调度工作，把work_struct挂到CPU相关的工作结构队列链表上，等待工作者线程处理。

static inline bool schedule_work(struct work_struct *work);
参数：
work：工作队列结构体地址

需要注意的是，如果调度完工作，并不会马上执行，只是加到了共享的工作队列里面去，等轮到他才会执行。

如果我们多次调用相同的任务，假如上一次的任务还没有处理完成，那么多次调度相同的任务是无效的。

6.4实验代码

例程在tasklet实验代码上改：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
#include <linux/of.h>
#include <linux/of_address.h>
​
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
​
#include <linux/of_irq.h>
#include <linux/workqueue.h>
​
struct device_node *test_device_node;
struct property *test_node_property;
int gpio_num;
int irq = 0;
​
//struct tasklet_struct key_test;
struct work_struct key_test;
​
static const of_device_id of_match_table_test[] = {//匹配表
    {.compatible = "keys"},
};
​
static const platform_device_id beep_id_table ={
    .name = "beep_test",
};
​
irqreturn_t test_key(int irq, void *args)
{
    printk("start\n");
    tasklet_schedule(&key_test);
    printk("end\n");
    return IRQ_HANDLED;
}
​
void test(void) 
{
    int i = 100;
    while (i--) {
        printk("teat_key is %d\n",i);//中断下文打印一百次
    }
}
​
/*设备树节点compatible属性与of_match_table_test的compatible相匹配就会进入该函数,pdev是匹配成功后传入的设备树节点*/
int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe\n");
    
​
    //查找要查找的节点
    test_device_node = of_find_node_by_path("/test_key");
    if (test_device_node == NULL) {
        printk("test_device_node find error\n");
        return -1;
    }
    printk("test_device_node name is %s\n",test_device_node->name);//test_key
    
    gpio_num = of_get_named_gpio(test_device_node, "gpios", 0);
    if (gpio_num < 0) {
        printk("of_get_named_gpio error\n");
        return -1;
    }
    printk("gpio_num name is %d\n",gpio_num);
    
    gpio_direction_input(gpio_num);
    //获取中断号
    //irq = gpio_to_irq(gpio_num);
    irq = irq_of_parse_and_map(test_device_node, 0);
    printk("irq is %d\n",irq);
    
    ret = request_irq(irq, test_key, IRQF_TRIGGER_RISING, "test_key", NULL);//
    if (ret < 0) {
        printk("request_irq error\n");
        return -1;
    }
    
    //tasklet_init(&kety_test, test, 0);
    INIT_WORK(&key_test, test);
    return 0;
​
}
​
int beep_remove(struct platform_device *pdev)
{
    pritnk("beep_remove \n");
    return 0;
}
​
strcut platform_driver beep_device = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "123",
        .of_match_table = of_match_table_test,//匹配表 
    },
    .id_table = &beep_id_table,
};
​
static int beep_driver_init(void)
{
    int ret = -1;
    ret = platform_driver_register(&beep_device);
    if(ret < 0) {
        printk("platform_driver_register error \n");
    }
    printk("platform_driver_register ok\n");
    return 0;
}
​
static void  beep_driver_exit(void)
{
    free_irq(irq, NULL);
    //testlet_kill(&key_test);
    platform_driver_unregister(&beep_device);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

加载驱动，按下按键：

suifen_
关注
  • 28
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Linux中断和中断处理 “上部分”
qq_62309585的博客
10-27 754
上图中断从硬件到内核的路由。设备产生中断，通过总线把电信号发送给中断控制器。如果中断线是激活的（它们是允许被屏蔽的)，那么中断控制器就会把中断发往处理器。在大多数体系结构中，这个工作就是通过电信号给处理器的特定管脚发送一个信号。除非在处理器上禁止该中断，否则，处理器会立即停止它正在做的事，关闭中断系统，然后跳到内存中预定义的位置开始执行那里的代码。这个预定义的位置是由内核设置的，是中断处理程序的入口点。在内核中，中断的旅程开始于预定义入口点，这类似于系统调用通过预定义的异常句柄进入内核。
Linux 驱动开发 三十九：Linux 中断（一）
OnlyLove_的博客
01-22 1983
一、Linux 中断子系统概述 参考博客：Linux中断（interrupt）子系统之一：中断系统基本原理_DroidPhone的专栏-CSDN博客_linux 中断 1、设备、中断控制器和CPU 一个完整的设备中，与中断相关的硬件可以划分为3类，它们分别是：设备、中断控制器和CPU本身，下图展示了一个smp系统中的中断硬件的组成结构： 设备：发起中断的源，可以发起一个硬件中断信号，该信号发送到中断控制器，由中断处理器进行进一步处理。中断发起设备可能是 SOC 外（外部器件），也可能是 SOC 内（
Linux 中断上下文（一）
枫潇潇
07-09 1984
Linux上下文的理解 1 Linux空间划分 Linux将整个空间划分为用户空间与内核空间，该空间是可配置的，还有一种是用户空间及内核空间各位2G，如下图： 2 Linux内部结构 Linux内部结构分为三部分，从底层往上分别是：硬件——>内核空间——>用户空间，如下图所示。 需要注意的细节问题： 1） 内核空间存放的是内核代码和数据，而进程的用户空间存放的是用户程序的代码和数据。不管是内核空间还是用户空间，他们都处于虚拟空间中； 2） Linux使用两级保护机制：0级供内核使用，3级
【Linux驱动】Linux的中断系统 | 中断的重要数据结构
最新发布
weixin_63726869的博客
01-12 2098
讲解了Linux的中断体系，中断可以分为上下两部分，下半部分有三种处理方式，包括软件中断，内核线程，线程化等方式。还详细介绍了Linux中管理中断的irq_desc数组这个数据结构，以及产生中断后，CPU是如何通过这个数据结构调用中断处理函数的。
【Linux从入门到精通】上下文概念详解
weixin_67596609的博客
05-16 3708
本篇文章结合实例对上下文概念进行详解。在理解上下文概念时，同时会引出了进程上下文、中断上下文、上下文数据、时间片等概念详解。我们都会对此进行详细解释，超级容易理解。
linux设备驱动中断.doc
07-26
讲述Linux设备驱动中断的过程，中断概念：这就不多说了。 中断的分类： 1）根据中断来源分为：内部中断和外部中断。内部中断来源于CPU内部（软中断指令、溢出、语法错误等），外部中断来自CPU外部，由设备提出请求。...
Linux驱动学习资料总结
12-18
Linux驱动学习资料总结 在深入探讨Linux驱动学习之前，我们首先要理解驱动程序的基本概念。驱动程序是操作系统与硬件设备之间的桥梁，它使得操作系统能够控制和通信硬件设备，使其发挥应有的功能。Linux作为开源且...
正点原子Linux驱动学习源码
07-09
《正点原子Linux驱动学习源码》是一份专注于Linux内核驱动程序开发的学习资源，它包含了一系列的例程源码，旨在帮助开发者深入理解和实践Linux驱动编程。在Linux系统中，驱动程序是操作系统与硬件设备之间的桥梁，...
yt8521 linux驱动源码
03-21
Linux驱动源码是操作系统与硬件设备之间的重要桥梁，它使得硬件设备能够被操作系统识别和管理。...总之，深入学习和修改Linux驱动源码是一项挑战性的工作，需要扎实的编程基础和对内核机制的深刻理解。
RTL8188 Linux驱动源码
06-02
RTL8188的Linux驱动源码是用于与Realtek 8188系列无线网卡通信的软件，它包含了初始化、数据传输、中断处理等核心功能。源码通常由多个模块组成，包括设备注册、设备卸载、配置硬件、发送和接收数据等关键部分。 二...
Linux中断处理驱动程序编写
10-22
中断就是CPU正常运行期间，由于内、外部事件引起的CPU暂时停止正在运行的程序，去执行该内部事件或外部事件的引起的服务中去，服务执行完毕后再返回断点处继续执行的情形。这样的中断机制极大的提高了CPU运行效率。
linux设备驱动中断之上半部和下半部
08-28
这份文档详细的叙述了linux中断上半部跟下半部的原理，很容易理解。
linux驱动之中断(二)---- 中断驱动程序(tasklet,workqueue,thread_irq)
qq_40684669的博客
11-06 935
中断驱动程序(tasklet,workqueue,thread_irq)
Linux中的中断处理
张勤一
03-22 5749
与Linux设备驱动中中断处理相关的首先是申请与释放IRQ的API request_irq()和free_irq()， request_irq()的原型为： int request_irq(unsigned int irq, void (*handler)(int irq, void *dev_id, struct pt_regs *regs), unsigned long irq
【嵌入式Linux驱动程序-基础篇】- 中断处理
听过好多编程语言的名字，但又学不会，偶然学会最厉害的操作sudo rm -rf /*（别尝试哦！我不知道干嘛用的哦~），忘记谁教我了。喜欢看开源代码。。。就跟看天书一样。
08-14 1178
中断处理 1 中断的请求和释放 当设备需要中断功能时，应当向内核请求中断。如果驱动工程师没有通过请求中断的方式通知Linux内核需要使用中断，那么内核只会简单的应答并且忽略该中断。   1.1 请求中断线 请求中断线可以使内核知道外设应该使用哪一个中断号，哪一个中断处理函数。请求中断线在需要与外部设备交互时发生。Linux内核提供了request_irq()函数请求中断线。该函数如下： ...
Linux内核驱动中断
小王的博客
01-15 929
Linux内核与外部中断
四、Linux驱动之使用中断
墨、白的博客
11-21 2791
1. 中断基本概念 1.1 中断基础介绍     中断就是CPU正常运行期间，由于内、外部事件引起的CPU暂时停止正在运行的程序，去执行该内部事件或外部事件的引起的服务中去，服务执行完毕后再返回断点处继续执行的情形。    中断的意义：极大提高CPU运行效率。     中断处理程序：在中断发生时被调用的函数称为中断服务函数。     中断服务函数的原则：linux是多进程操作系统。     中...
70.linux驱动--中断
lzs940320的博客
09-10 488
在之前的单片机入门的时候也是hello world，然后led，然后按键中断。 下面我们要开始中中断部分的学习。，在之前的裸机开发中，我们已经了解了中断的开发步骤，在内核中使用按键触发中断，会变的更容易一些，因为内核已经帮我们完成了很多工作，我们只需要理解整个调用及修改过程。 soc中有很多的中断，我们通过中断号进行区分是哪个中断，然后写对应的中断处理函数。 如何获取中断号？ 1， 宏定义（中断相关的头文件） IRQ_EINT...
Linux驱动之------中断上下文
玫瑰花店的博客
10-18 574
中断 中断的顶半部(中断的上文) 中断的上文就是普通的中断服务函数 中断的底半部(中断的下文) 如果中断服务函数里面需要写很多东西，甚至还需要有延迟。但是肯定不能直接写在中断服务函数中，否则就违背了中断快进快出的原则。中断的下半部就相当于另开一个线程。在另一个线程中操作，延时、阻塞…都不影响中断的快进快出原则。 中断底半部的实现方法 中断底半部的实现方法有两种： 1、小任务 2、工作队列 小任务 小任务API 核心结构体： struct tasklet_struct { struct ta
linux驱动开发中断
08-16
在Linux驱动开发中，中断是一种重要的机制。在Linux中，中断有两种类型：可抢占的内核代码运行在进程上下文中，而中断上下文则是不可被抢占的，会一直运行直到结束。对于硬件产生的中断，比如按键中断或网卡中断，被...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值