Linux 系统中异常与中断

文章目录

  • 异常与中断的关系
  • 中断的处理流程
  • 异常向量表
  • 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

异常与中断的关系

Linux 系统中异常与中断_第1张图片
异常有:

  • ①指令未定义
  • ② 指令、数据访问有问题
  • ③ 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
    Linux 系统中异常与中断_第2张图片

程序被中断时,怎么保存现场

如果要暂停一个程序,中断一个程序,就需要把这些寄存器的值保存下来:这就称为保存现场。

寄存器保存在内存中,这块内存就称之为栈。程序要继续执行,就先从栈中恢复那些 CPU 内部寄存器的值。如图所示:概括程序 A、B 的切换过程

Linux 系统中异常与中断_第3张图片
这个场景并不局限于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 系统中异常与中断_第4张图片

Linux 系统对中断处理的演进

Linux 对中断的扩展:硬件中断、软件中断

硬件中断

对于按键中断等硬件产生的中断,称之为“硬件中断”(hard irq)。每个硬件中断都有对应的处理函数

可以认为对硬件中断的处理是用数组来实现的,数组里存放的是函数指针:
Linux 系统中异常与中断_第5张图片
当硬件触发中断,系统会根据中断号调用中断处理函数

软件中断

相对的,可以人为地制造中断:软件中断(soft irq)
Linux 系统中异常与中断_第6张图片

如何触发软中断?——由软件决定,对于 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_TIMERS
    HRTIMER_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*));

中断处理原则:

  1. Linux系统中,中断不能嵌套,否则会导致栈不够用

  2. 中断处理要越快越好,即在注册中断 handler 函数中指定中断处理函数,代码尽可能高效

在 Linux 系统中使用中断是挺简单的,为某个中断 irq 注册中断处理函数handler,可以使用 request_irq 函数:
在这里插入图片描述

如果中断要做的事情就是很多,没办法加快,则需要将耗时的事情拆分

耗时中断的拆分:上半部分和下半部分

当一个中断要耗费很多时间来处理时,它的坏处是:在这段时间内,其他中断无法被处理。换句话说,在这段时间内,系统是关中断的

耗时的中断:中断分为上半部分/下半部分;在 handler 函数里只做紧急的事,然后就重新开中断,让系统得以正常运行;那些不紧急的事,以后再处理,处理时是开中断的。

Linux 系统中异常与中断_第7张图片

中断下半部的实现有很多种方法,主要讲2种:

  • tasklet(小任务)
  • work queue(工作队列)。

中断下半部分的实现:tasklet

当下半部比较耗时但是能忍受,并且它的处理比较简单时,可以用tasklet 来处理下半部。tasklet 是使用软件中断来实现。

Linux 系统中异常与中断_第8张图片

使用流程图简化一下:

Linux 系统中异常与中断_第9张图片

  • 中断下半部执行时,有可能会被多次打断,有可能会再次发生同一个中断
    • 中断下半部执行时再次发生同一个中断:则同一个中断的上半部、下半部,在执行时是多对一的关系。
    • 中断下半部执行时如果被多次打断:如果在A中断的下半部出现中断,则会执行B中断的上半部分,然后再进行preemot_count判断时,直接进入完成处理;之后是恢复整个软件中断的处理:包含A中断和B中断的下半部分。【软件中断时定时处理的】

中断下半部分属于软件中断的一种,在枚举类型里面对应TASKLET_SOFTIRQ

Linux 系统中异常与中断_第10张图片

中断下半部分的实现:工作队列

在中断下半部的执行过程中,虽然是开中断的,期间可以处理各类中断。但是毕竟整个中断的处理还没走完,这期间 APP 是无法执行的。在中断上半部唤醒内核线程。内核线程和APP 都一样竞争执行,APP 有机会执行,系统不会卡顿。

这个内核线程是系统帮我们创建的,一般是 kworker 线程,内核中有很多这样的线程:
Linux 系统中异常与中断_第11张图片

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)一路分析得到。

Linux 系统中异常与中断_第12张图片

注意:如果内核配置了CONFIG_SPARSE_IRQ,那么它就会用基数树(radixtree)来代替irq_desc数组。SPARSE的意思是“稀疏”,假设大小为1000的数组中只用到2个数组项,那不是浪费嘛?所以在中断比较“稀疏”的情况下可以用基数树来代替数组。

irq_desc数组

irq_desc结构体在include/linux/irqdesc.h中定义,主要内容如下图:
Linux 系统中异常与中断_第13张图片
每一个irq_desc数组项中都有一个函数:handle_irq,还有一个action链表。要理解它们,需要先看中断结构图:硬件中断的信号从左到右,函数的处理从右到左(函数主要是读取寄存器确定中断的来源)。由图可知共享中断会出现两个中断号:A号中断和B号中断

Linux 系统中异常与中断_第14张图片
在Linux内核中对于每一个硬件中断,都有一个数组成员项,所以下图有GIC结构体和GPIO结构体,每个结构体都有:handle_irq,还有一个action链表
Linux 系统中异常与中断_第15张图片
首先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中定义,主要内容如下图:
Linux 系统中异常与中断_第16张图片

当调用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中定义,主要内容如下图:
Linux 系统中异常与中断_第17张图片

它就是个中转站,里面有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中定义,主要内容如下图:
Linux 系统中异常与中断_第18张图片

这个结构体跟“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

设备树里中断节点的语法

设备树里的中断控制器

比如中断的硬件框图如下:设备树会将这个硬件图转化为节点
Linux 系统中异常与中断_第19张图片

在硬件上,“中断控制器”只有 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>;

设备树里中断节点的示例

从设备树文件里面将有关中断的部分内容抽取出来:
Linux 系统中异常与中断_第20张图片
对于第一个节点,是GIC控制器,使用到该控制器需要三个cell,因为对于多CPU系统,GIC可以发出两种信号(SPI,PPI)而CPU之间可以通过SGI进行通信,所以GIC控制器的第一个cell必须要指定是哪种信号(SPI或PPI或SGI)

Linux 系统中异常与中断_第21张图片

从设备树反推 IMX6ULL 的中断体系,如下,比之前的框图多了一个“GPC INTC”

Linux 系统中异常与中断_第22张图片

在代码中获得中断

根据博文:哪些设备树节点会被转换为 platform_device提到,设备树中的节点有些能被转换为内核里的platform_device,有些不能
Linux 系统中异常与中断_第23张图片

对于 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):

Linux 系统中异常与中断_第24张图片
对于 SPI 设备节点,SPI 总线驱动在处理设备树里的 SPI 子节点时,也会处理其中的中断信息。一个 SPI 设备会被转换为一个 spi_device 结构体,中断号会保存在 spi_device 的 irq 成员里,代码如下(drivers/spi/spi.c):
Linux 系统中异常与中断_第25张图片

调用 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);

你可能感兴趣的:(linux,运维,服务器)