文章目录
- 异常与中断的关系
- 中断的处理流程
- 异常向量表
- Linux 系统对中断的处理
- ARM 处理器程序运行的过程
- 程序被中断时,怎么保存现场
- Linux 系统对中断处理的演进
- Linux 对中断的扩展:硬件中断、软件中断
- 硬件中断
- 软件中断
- 中断处理原则:
- 耗时中断的拆分:上半部分和下半部分
- 中断下半部分的实现:tasklet
- 中断下半部分的实现:工作队列
- 耗时中断的新技术:threaded irq(线程化的中断)
- Linux 中断系统中的重要数据结构
- 概述
- irq_desc数组
- irqaction结构体
- irq_domain结构体
- irq_data结构体
- irq_chip结构体
- 在设备树中指定中断、在驱动中获得中断
- 设备树里中断节点的语法
- 设备树里的中断控制器
- 设备树里使用中断
- 设备树里中断节点的示例
- 在代码中获得中断
- 对于 platform_device
- 对于 I2C 设备、SPI 设备
- 调用 of_irq_get 获得中断号
- 对于 GPIO
异常与中断的关系
异常有:
- ①指令未定义
- ② 指令、数据访问有问题
- ③ SWI(软中断)
- ④ 快中断
- ⑤ 中断
中断也属于一种“异常”,导致中断发生的情况有很多,比如:
- 按键
- 定时器
- ADC 转换完成
- UART 发送完数据、收到数据
众多的“中断源”,汇集到“中断控制器”,由“中断控制器”选择优先级最高的中断并通知 CPU,中断控制器也可以屏蔽中断信号。
中断的处理流程
arm 对异常(中断)处理过程:
- ① 初始化:
- a) 设置中断源,让它可以产生中断
- b) 设置中断控制器(可以屏蔽某个中断,优先级)
- c) 设置 CPU 总开关(使能中断)
- ② 执行其他程序:正常程序
- ③ 产生中断:比如按下按键—>中断控制器—>CPU
- ④ CPU 每执行完一条指令都会检查有无中断/异常产生
- ⑤ CPU 发现有中断/异常产生,开始处理。
- 对于不同的异常,跳去不同的地址执行程序。这地址上,只是一条跳转指令,跳去执行某个函数(地址),这个就是异常向量。③④⑤都是硬件做的。
- ⑥ 这些函数做什么事情?软件做的:
- a) 保存现场(各种寄存器)
- b) 处理异常(中断):分辨中断源,再调用不同的处理函数
- c) 恢复现场
异常向量表
u-boot 或是 Linux 内核,都有类似如下的代码:
_start: b reset
ldr pc, _undefined_instruction
ldr pc, _software_interrupt
ldr pc, _prefetch_abort
ldr pc, _data_abort
ldr pc, _not_used
ldr pc, _irq // 发生中断时,CPU 跳到这个地址执行该指令 ** 假设地址为 0x18**
ldr pc, _fiq
这就是异常向量表,每一条指令对应一种异常。
- 发生复位时,CPU 就去 执行第 1 条指令:b reset。
- 发生中断时,CPU 就去执行“ldr pc, _irq”这条指令。
- 这些指令存放的位置是固定的,比如对于 ARM9 芯片中断向量的地址是0x18。当发生中断时,CPU 就强制跳去执行 0x18 处的代码。
在向量表里,一般都是放置一条跳转指令
,发生该异常时,CPU 就会执行向量表中的跳转指令,去调用更复杂的函数。当然,向量表的位置并不总是从 0 地址开始,很多芯片可以设置某个vector base 寄存器,指定向量表在其他位置,比如设置 vector base 为0x80000000,指定为 DDR 的某个地址。但是表中的各个异常向量的偏移地址,是固定的:复位向量偏移地址是 0,中断是 0x18。
Linux 系统对中断的处理
ARM 处理器程序运行的过程
ARM 芯片属于精简指令集计算机(RISC:Reduced Instruction SetComputing),它所用的指令比较简单,有如下特点:
- ① 对内存只有读、写指令
- ② 对于数据的运算是在 CPU 内部实现
- ③ 使用 RISC 指令的 CPU 复杂度小一点,易于设计
比如对于 a=a+b 这样的算式,需要经过下面 4 个步骤才可以实现,CPU 运行时,先去取得指令,再执行指令:
- ① 把内存 a 的值读入 CPU 寄存器 R0
- ② 把内存 b 的值读入 CPU 寄存器 R1
- ③ 把 R0、R1 累加,存入 R0
- ④ 把 R0 的值写入内存 a
程序被中断时,怎么保存现场
如果要暂停一个程序,中断一个程序,就需要把这些寄存器的值保存下来:这就称为保存现场。
寄存器保存在内存中,这块内存就称之为栈。程序要继续执行,就先从栈中恢复那些 CPU 内部寄存器的值。如图所示:概括程序 A、B 的切换过程
这个场景并不局限于A、B 的切换过程,也可以中断,函数调用等
① 函数调用:
- a) 在函数 A 里调用函数 B,实际就是中断函数 A 的执行。
- b) 那么需要把函数 A 调用 B 之前瞬间的 CPU 寄存器的值,保存到栈里;
- c) 再去执行函数 B;
- d) 函数 B 返回之后,就从栈中恢复函数 A 对应的 CPU 寄存器值,继续执行。
② 中断处理
- a) 进程 A 正在执行,这时候发生了中断。
- b)
CPU 强制跳到中断异常向量地址去执行,
- c) 这时就需要保存进程 A 被中断瞬间的 CPU 寄存器值,
- d)
可以保存在进程 A 的内核态栈,也可以保存在进程 A 的内核结构体中
。 - e) 中断处理完毕,要继续运行进程 A 之前,恢复这些值。
③ 进程切换
- a) 在所谓的多任务操作系统中,我们以为多个程序是同时运行的。
- b) 如果我们能感知微秒、纳秒级的事件,可以发现操作系统时让这些程序依次执行一小段时间,进程 A 的时间用完了,就切换到进程 B。
- c) 怎么切换?
- d) 切换过程是发生在内核态里的,跟中断的处理类似。
- e) 进程 A 的被切换瞬间的 CPU 寄存器值保存在某个地方;
- f) 恢复进程 B 之前保存的 CPU 寄存器值,这样就可以运行进程 B 了。
进程的调度也是使用栈来保存、恢复现场;在linux中,线程才是调度的最小单位,这些线程共用打开的文件句柄、全局变量等等。而这些线程,之间是互相独立的,“同时运行”,也就是说:每一个线程,都有自己的栈
,那么在同一个进程里面,所有的线程共享代码段和数据段,同时,他们还有各自的栈内存,保存CPU寄存器里面的值
Linux 系统对中断处理的演进
Linux 对中断的扩展:硬件中断、软件中断
硬件中断
对于按键中断等硬件产生的中断,称之为“硬件中断”(hard irq)。每个硬件中断都有对应的处理函数
可以认为对硬件中断的处理是用数组来实现的,数组里存放的是函数指针:
当硬件触发中断,系统会根据中断号调用中断处理函数
软件中断
相对的,可以人为地制造中断:软件中断(soft irq)
如何触发软中断?——由软件决定,对于 X 号软件中断,只需要把它的 flag 设置为 1 就表示发生了该中断
软件中断何时处理?——Linux 系统中,各种硬件中断频繁发生,例如定时器中断每 10ms 发生一次,那将软件中断设计在处理完硬件中断后,再去处理软件中断
有哪些软件中断?——查内核源码 include/linux/interrupt.h
enum
{HI_SOFTIRQ=0, TIMER_SOFTIRQ, NET_TX_SOFTIRQ, NET_RX_SOFTIRQ, BLOCK_SOFTIRQ, TASKLET_SOFTIRQ SCHED_SOFTIRQ,
#ifdef CONFIG_HIGH_RES_TIMERSHRTIMER_SOFTIRQ,
#endif
};
怎么触发软件中断?——最核心的函数是 raise_softirq,简单地理解就是设置 softirq_veq[nr]的标记位:
extern void raise_softirq(unsigned int nr) //用于引发一个软中断(类似普通中断)
怎么设置软件中断的处理函数:
extern void open_softirq(int nr, void (*action) (struct soft_action*));
中断处理原则:
-
Linux系统中,中断不能嵌套,否则会导致栈不够用
-
中断处理要越快越好,即在注册中断 handler 函数中指定中断处理函数,代码尽可能高效
在 Linux 系统中使用中断是挺简单的,为某个中断 irq 注册中断处理函数handler,可以使用 request_irq
函数:
如果中断要做的事情就是很多,没办法加快,则需要将耗时的事情拆分
耗时中断的拆分:上半部分和下半部分
当一个中断要耗费很多时间来处理时,它的坏处是:在这段时间内,其他中断无法被处理。换句话说,在这段时间内,系统是关中断的
耗时的中断:中断分为上半部分/下半部分;在 handler 函数里只做紧急的事,然后就重新开中断
,让系统得以正常运行;那些不紧急的事,以后再处理,处理时是开中断的。
中断下半部的实现有很多种方法,主要讲2种:
- tasklet(小任务)
- work queue(工作队列)。
中断下半部分的实现:tasklet
当下半部比较耗时但是能忍受,并且它的处理比较简单时,可以用tasklet 来处理下半部。tasklet 是使用软件中断
来实现。
使用流程图简化一下:
- 中断下半部执行时,有可能会被多次打断,有可能会再次发生同一个中断
- 中断下半部执行时再次发生同一个中断:则同一个中断的上半部、下半部,在执行时是多对一的关系。
- 中断下半部执行时如果被多次打断:如果在A中断的下半部出现中断,则会执行B中断的上半部分,然后再进行preemot_count判断时,直接进入完成处理;之后是恢复整个软件中断的处理:包含A中断和B中断的下半部分。【软件中断时定时处理的】
中断下半部分属于软件中断的一种,在枚举类型里面对应TASKLET_SOFTIRQ
中断下半部分的实现:工作队列
在中断下半部的执行过程中,虽然是开中断的,期间可以处理各类中断。但是毕竟整个中断的处理还没走完,这期间 APP 是无法执行的
。在中断上半部唤醒内核线程。内核线程和APP 都一样竞争执行,APP 有机会执行,系统不会卡顿。
这个内核线程是系统帮我们创建的,一般是 kworker 线程,内核中有很多这样的线程:
kworker 线程要去“工作队列”(work queue)上取出一个一个“工作”(work 结构体),来执行它里面的函数。
使用:
①创建 work:
你得先写出一个函数,然后用这个函数填充一个 work 结构体。比如:
static DECLARE_WORK(aer_recover_work,aer_recover_work_fun);
//第一参数是work结构体
② 要执行这个函数时,把 work 提交给 work queue 就可以了:
schedule_work(&aer_recover_work);
上述函数会把 work 提供给系统默认的 work queue:system_wq,它是一个队列。
在中断上半部调用 schedule_work 函数,触发 work 的处理
③ 谁来执行 work 中的函数?
schedule_work 函数不仅仅是把 work 放入队列,还会把kworker 线程唤醒。此线程抢到时间运行时,它就会从队列中取出 work,执行里面的函数。
④ 谁把 work 提交给 work queue?
在中断场景中,可以在中断上半部调用 schedule_work 函数。
工作队列只是创建一个线程,对于多核CPU来说,可以处理多个线程,所以将中断下部分实现的技术换为threaded irq,这样每个中断下半部分为一个线程,在任意一个CPU中都可以执行
耗时中断的新技术:threaded irq(线程化的中断)
你可以只提供 thread_fn
,系统会为这个函数创建一个内核线程。发生中断时,内核线程就会执行这个函数。
以前用 work 来线程化地处理中断,一个 worker 线程只能由一个 CPU 执行,多个中断的 work 都由同一个 worker线程来处理,在单 CPU 系统中也只能忍着了。但是在 SMP 系统中,明明有那么多 CPU 空着,你偏偏让多个中断挤在这个CPU 上?新技术threaded irq,为每一个中断都创建一个内核线程;多个中断的内核线程可以分配到多个 CPU 上执行,这提高了效率。
Linux 中断系统中的重要数据结构
概述
本节内容,可以从request_irq
函数(头文件:include/linux/interrupt.h)一路分析得到。
注意:如果内核配置了CONFIG_SPARSE_IRQ,那么它就会用基数树(radixtree)来代替irq_desc数组。SPARSE的意思是“稀疏”,假设大小为1000的数组中只用到2个数组项,那不是浪费嘛?所以在中断比较“稀疏”的情况下可以用基数树来代替数组。
irq_desc数组
irq_desc结构体在include/linux/irqdesc.h
中定义,主要内容如下图:
每一个irq_desc数组项中都有一个函数:handle_irq
,还有一个action链表
。要理解它们,需要先看中断结构图:硬件中断的信号从左到右,函数的处理从右到左(函数主要是读取寄存器确定中断的来源)。由图可知共享中断会出现两个中断号:A号中断和B号中断
在Linux内核中对于每一个硬件中断,都有一个数组成员项,所以下图有GIC结构体和GPIO结构体,每个结构体都有:handle_irq
,还有一个action链表
。
首先GIC中断CPU时,CPU读取GIC状态得到中断A。
① GIC的处理函数:
- irq_desc[A].handle_irq是XXX_gpio_irq_handler(XXX指厂家),假设A号中断对应的是GPIO中断,这个函数需要读取芯片的GPIO控制器,细分发生的是哪一个GPIO中断(假设是B),
再去调用irq_desc[B]. handle_irq。
② 模块的中断处理函数:
- 导致GPIO中断B发生的原因很多,可能是外部设备1,可能是外部设备n,可能只是某一个设备,也可能是多个设备。所以irq_desc[B].handle_irq会依次调用某个链表(action链表)里的函数【BSP开发人员会设置对应的处理函数,一般是handle_level_irq或handle_edge_irq,从名字上看是用来处理电平触发的中断、边沿触发的中断】,这些函数由外部设备提供。这些函数自行判断该中断是否自己产生,若是则处理。
③ 外部设备提供的处理函数:
- 这里说的“外部设备”可能是芯片,也可能总是简单的按键。它们的处理函数由自己驱动程序提供,这是最熟悉这个设备的“人”:它知道如何判断设备是否发生了中断,如何处理中断。
irqaction结构体
irqaction结构体在include/linux/interrupt.h
中定义,主要内容如下图:
当调用request_irq、request_threaded_irq
注册中断处理函数时,内核就会构造一个irqaction结构体。在里面保存name、dev_id等,最重要的是handler、thread_fn、thread。
- handler是中断处理的上半部函数,用来处理紧急的事情。
- thread_fn对应一个内核线程thread,当handler执行完毕,Linux内核会唤醒对应的内核线程。在内核线程里,会调用thread_fn函数。
可以提供handler而不提供thread_fn,就退化为一般的request_irq函数。
可以不提供handler只提供thread_fn,完全由内核线程来处理中断。
也可以既提供handler也提供thread_fn,这就是中断上半部、下半部。
在调用reqeust_irq
函数时可以传入dev_id
作用有2个:
- ① 中断处理函数执行时,可以使用dev_id
- ② 卸载中断时要传入dev_id,这样才能在action链表中根据dev_id找到对应项所以在共享中断中必须提供dev_id,非共享中断可以不提供。
irq_domain结构体
irq_domain结构体在include/linux/irqdomain.h
中定义,主要内容如下图:
在设备树中有这样的属性:
interrupt-parent = <&gpio1>;
interrupts = <5 IRQ_TYPE_EDGE_RISING>;
它表示要使用gpio1里的第5号中断,hwirq就是5。
但是我们在驱动中会使用request_irq(irq, handler)这样的函数来注册中断,irq是软件中断号
,它应该从“gpio1的第5号中断”转换得来。
谁把hwirq转换为irq?由gpio1的相关数据结构,就是gpio1对应的irq_domain结构体
。即每个一GPIO都有自己的irq_domain结构体
irq_domain结构体中有一个irq_domain_ops结构体,里面有各种操作函数,主要是:
- ① xlate:用来解析设备树的中断属性,提取出hwirq、type等信息。
- ② map:把hwirq转换为irq。即转为为虚拟中断号【软件中断号会保存在platform_diverce】
map函数会完成映射关系,会保存在unsigned int linear_revmap[];
数组里面
例如:读取GPIO寄存器得到hwirq,根据hwirq得到之前映射的irq(软件中断号B)
irq_data结构体
irq_data结构体在include/linux/irq.h
中定义,主要内容如下图:
它就是个中转站,里面有irq_chip指针 irq_domain指针,都是指向别的结构体。
irq是软件中断号,hwirq是硬件中断号。比如上面我们举的例子,在GPIO中断B是软件中断号,可以找到irq_desc[B]这个数组项;GPIO里的第x号中断,这就是hwirq。
谁来建立irq、hwirq之间的联系呢?由irq_domain来建立。irq_domain会把本地的hwirq映射为全局的irq,什么意思?比如GPIO控制器里有第1号中断,UART模块里也有第1号中断,这两个“第1号中断”是不一样的,它们属于不同的“域”──irq_domain。
irq_chip结构体
irq_chip结构体在include/linux/irq.h
中定义,主要内容如下图:
这个结构体跟“chip”即芯片相关,里面各成员的作用在头文件中也列得很清楚,摘录部分如下:
@irq_startup: start up the interrupt (defaults to ->enable if NULL)
@irq_shutdown: shut down the interrupt (defaults to ->disable if NULL)
@irq_enable: enable the interrupt (defaults to chip->unmask if NULL)
@irq_disable: disable the interrupt
@irq_ack: start of a new interrupt
@irq_mask: mask an interrupt source
@irq_mask_ack: ack and mask an interrupt source
@irq_unmask: unmask an interrupt source
@irq_eoi: end of interrupt
我们在request_irq后,并不需要手工去使能中断,原因就是系统调用对应的irq_chip里的函数帮我们使能了中断。
我们提供的中断处理函数中,也不需要执行主芯片相关的清中断操作,也是系统帮我们调用irq_chip中的相关函数。
但是对于外部设备相关的清中断操作,还是需要我们自己做的。
就像上面图里的“外部设备1“、“外部设备n”,外设备千变万化,内核里可没有对应的清除中断操作
在设备树中指定中断、在驱动中获得中断
可以参考文档:内核的Documentation\devicetree\bindings\interrupt-controller\interrupts.txt
设备树里中断节点的语法
设备树里的中断控制器
比如中断的硬件框图如下:设备树会将这个硬件图转化为节点
在硬件上,“中断控制器”只有 GIC 这一个,但是我们在软件上也可以把上图中的“GPIO”称为“中断控制器”。很多芯片有多个 GPIO 模块,比如 GPIO1、GPIO2 等等。所以软件上的“中断控制器”就有多个。各个中断控制器之间有父子关系。
假设 GPIO1 有 32 个中断源,但是它把其中的 16 个汇聚起来向 GIC 发出一个中断,把另外 16 个汇聚起来向 GIC 发出另一个中断。这就意味着 GPIO1 会用到 GIC 的两个中断,会涉及 GIC 里的 2 个 hwirq。这些层级关系、中断号(hwirq),都会在设备树中有所体现。
在设备树中,中断控制器节点中必须有一个属性:interrupt-controller
,表明它是“中断控制器”。还必须有一个属性:#interrupt-cells
,表明引用这个中断控制器的话需要多少个 cell。
#interrupt-cells
的值一般有如下取值:
- #interrupt-cells=<1>
别的节点要使用这个中断控制器时,只需要一个 cell 来表明使用“哪一个中断”。 - #interrupt-cells=<2>
别的节点要使用这个中断控制器时,需要一个 cell 来表明使用“哪一个中断”;还需要另一个 cell 来描述中断,一般是表明触发类型:
第 2 个 cell 的 的 bits[3:0] 用来表示中断触发类型(trigger type and level flags) :
1 = low-to-high edge triggered ,上升沿触发
2 = high-to-low edge triggered ,下降沿触发
4 = active high level-sensitive ,高电平触发
8 = active low level-sensitive , 低电平触发
如果中断控制器有级联关系,下级的中断控制器还需要表明它的“ interrupt-parent ”
是 谁 , 用 了 interrupt-parent ” 中的哪一个“interrupts”
设备树里使用中断
一个外设,它的中断信号接到哪个“中断控制器”的哪个“中断引脚”,这个中断的触发方式是怎样的?这 3个问题,在设备树里使用中断时,都要有所体现。
例如:
i2c@7000c000 {gpioext: gpio-adnp@41 {compatible = "ad,gpio-adnp";//用哪一个中断控制器里的中断?interrupt-parent = <&gpio>;//用哪一个中断?Interrupts 里要用几个 cell,由 interrupt-parent 对应的中断控制器决定interrupts = <160 1>;gpio-controller;#gpio-cells = <1>;interrupt-controller;#interrupt-cells = <2>;//指明子节点的指定中断控制器的话需要多少个 cell};
......
};
新的写法:interrupts-extended,指明了上述的三个问题
一个“interrupts-extended”属性就可以既指定“interrupt-parent”,也指定“interrupts”,比如:
interrupts-extended = <&intc1 5 1>, <&intc2 1 0>;
设备树里中断节点的示例
从设备树文件里面将有关中断的部分内容抽取出来:
对于第一个节点,是GIC控制器,使用到该控制器需要三个cell,因为对于多CPU系统,GIC可以发出两种信号(SPI,PPI)而CPU之间可以通过SGI进行通信,所以GIC控制器的第一个cell必须要指定是哪种信号(SPI或PPI或SGI)
从设备树反推 IMX6ULL 的中断体系,如下,比之前的框图多了一个“GPC INTC”
在代码中获得中断
根据博文:哪些设备树节点会被转换为 platform_device提到,设备树中的节点有些能被转换为内核里的platform_device,有些不能
对于 platform_device
一个节点能被转换为 platform_device,如果它的设备树里指定了中断属性,那么可以从platform_device 中获得“中断资源”,函数如下,可以使用下列函数获得 IORESOURCE_IRQ 资源,即中断号:
/**
* platform_get_resource - get a resource for a device
* @dev: platform device
* @type: resource type // 取哪类资源?IORESOURCE_MEM 、IORESOURCE_REG
* // IORESOURCE_IRQ 等
* @num: resource index // 这类资源中的哪一个?
*/
struct resource *platform_get_resource(struct platform_device *dev,unsigned int type,unsigned int num);
对于 I2C 设备、SPI 设备
对于 I2C 设备节点,I2C 总线驱动在处理设备树里的 I2C 子节点时,也会处理其中的中断信息。一个 I2C 设备会被转换为一个 i2c_client 结构体,中断号会保存在 i2c_client 的 irq 成员里,代码如下(drivers/i2c/i2c-core.c):
对于 SPI 设备节点,SPI 总线驱动在处理设备树里的 SPI 子节点时,也会处理其中的中断信息。一个 SPI 设备会被转换为一个 spi_device 结构体,中断号会保存在 spi_device 的 irq 成员里,代码如下(drivers/spi/spi.c):
调用 of_irq_get 获得中断号
如果你的设备节点既不能转换为 platform_device,它也不是 I2C 设备,不是 SPI 设备,那么在驱动程序中可以自行调用 of_irq_get 函数
去解析设备树,得到中断号。
对于 GPIO
参考:drivers/input/keyboard/gpio_keys.c;可以使用 gpio_to_irq 或 gpiod_to_irq 获得中断号。
举例,假设在设备树中有如下节点:
gpio-keys {compatible = "gpio-keys";pinctrl-names = "default";user {label = "User Button";gpios = <&gpio5 1 GPIO_ACTIVE_HIGH>;gpio-key,wakeup;linux,code = <KEY_1>;};
};
那么可以使用下面的函数获得引脚和 flag:
button->gpio = of_get_gpio_flags(pp, 0, &flags);
bdata->gpiod = gpio_to_desc(button->gpio);
再去使用 gpiod_to_irq 获得中断号:
irq = gpiod_to_irq(bdata->gpiod);