1、中断号
中断号又称中断线，每个中断都有一个中断号，通过中断号即可区分不同的中断。
2、Linux中断API函数
需要包含头文件“#include <linux/interrupt.h>”
1)、在使用某个中断功能的时候，需要执行“申请中断”
int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev)
irq：要申请中断的中断号；
handler：中断处理函数，当中断发生以后就会执行此中断处理函数；
fags：中断标志；可以在文件“include/linux/interrupt.h”里面查看所有的中断标志；
name：中断名字，设置以后可以在“/proc/interrupts”文件中看到对应的中断名字；
dev：如果将flags设置为IRQF_SHARED的话，dev用来区分不同的中断。
一般情况下将dev设置为“设备结构体”，dev会传递给中断处理函数irg_handler_t的第二个参数。
返回值：0表示中断申请成功，如果返回“-EBUSY”的话表示中断已经被申请过了, 其他负值，表示中断申请失败。
注意：
在“中断服务程序”中,不能使用request_irq()函数;
在“禁止睡眠的代码段”中，不能使用request_irq()函数；
执行request_irq()函数可能会导致睡眠；
request_irq()函数会使能“中断”，不需要我们手动去使能中断。
2)、常用的中断标志
#define IRQF_SHARED 0x00000080
/*
多个设备共享一个中断线,共享的所有中断都必须指定此标志。如果使用共享中断的话，request_irq()函数的dev参数就是唯区分他们的标志；
*/
#define IRQF_TRIGGER_NONE 0x00000000 //无触发
#define IRQF_ONESHOT 0x00002000 //单次中断，中断执行一次就结束
#define IRQF_TRIGGER_RISING 0x00000001 //上升沿触发
#define IRQF_TRIGGER_FALLING 0x00000002 //下降沿触发
#define IRQF_TRIGGER_HIGH 0x00000004 //高电平触发
#define IRQF_TRIGGER_LOW 0x00000008 //低电平触发
3)、在不需要使用某个中断功能的时候，需要执行“释放中断”
void free_irq(unsigned int irq, void *dev)
irq：要释放的中断号。
dev：如果中断设置为共享(IRQF_SHARED)的话，此参数用来区分具体的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉。
返回值:无。
4)、中断处理函数
irqreturn_t (*irq_handler_t) (int, void *)
“int”：第1个参数中断号，和request_irq()函数的irq参数保持一致。
“void *”：第2个参数是指向void型的指针，和request_irq()函数的dev参数保持一致。至于用于区分“共享中断”的不同设备,dev也可以是指向设备数据结构。
返回值：为irqreturn_t类型；
enum irqreturn {
IRQ_NONE = (0 << 0), /*中断没有被这个设备处理*/
IRQ_HANDLED = (1 << 0), /*中断被这个设备处理*/
IRQ_WAKE_THREAD = (1 << 1), /*处理程序请求唤醒处理程序线程*/
};
typedef enum irqreturn irqreturn_t;//将irqreturn起个别名叫irqreturn_t
typedef irqreturn_t (*irq_handler_t)(int, void *);
#define IRQ_RETVAL(x) ((x) ? IRQ_HANDLED : IRQ_NONE)
一般中断服务函数返回值使用如下形式:
return IRQ_RETVAL(IRQ_HANDLED);
5)、中断使能
void enable_irq(unsigned int irq)
irq：要使能的中断号；
需要包含头文件“interrupt.h”
6)、中断禁止
void disable_irq(unsigned int irq)
irq：要禁止的中断号；
注意：
要等到当前正在执行的中断处理函数执行完才返回，因此使用者需要保证不会产生新的中断，并且确保所有已经开始执行的中断处理程序已经全部退出。
void disable_irq_nosync(unsigned int irq)
irq：要禁止的中断号；
注意：
disable_irq_nosync()调用以后，会立即返回，不会等待当前中断处理程序执行完毕。
7)、使能总中断和关闭总中断
local_irq_enable() //打开全局中断，需要包含头文件“interrupt.h”
local_irq_disable() //关闭全局中断，需要包含头文件“interrupt.h”
local_irq_save(flags) //用于禁止中断，并且将中断状态保存在flags中；
local_irq_restore(flags) //用于恢复中断，将中断到flags状态
3、上半部和下半部
上半部：上半部就是“中断处理函数”，那些“处理过程较快，占用时间较短的中断程序”由上半部完成。
下半部：那些“处理过程比较耗时的中断服务程序”，放到“下半部”去执行。
4、根据实际情况将中断服务程序的代码放到上半部或下半部，通常依据如下：
1)、如果要处理的内容不希望被其他中断打断，那么可以放到上半部。2)、如果要处理的内容对时间敏感，可以放到上半部。3)、如果要处理的内容与硬件有关，可以放到上半部
4)、如果要处理的内容比较耗时的中断服务程序”，则放到“下半部”去执行。
Linux内核提供了多种下半部机制：软中断，tasklet，工作队列。2.5版本的以前Linux内核是使用“bottom half”机制（BH机制）来实现“下半部”，了解一下。
Linux内核将中断程序分为“上半部和下半部”的目的就是实现中断处理函数的快进快出。
5、下半部机制
1)、软中断
软中断是一种下半部机制，要求推后的工作不能睡眠，需要包含头文件“#include <linux/interrupt.h>”
注意：
软中断必须在编译的时候静态注册，使用softirq_init()初始化软中断。
①、softirq_action结构体如下：
struct softirq_action
{
void (*action)(struct softirq_action *);
};
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 /*NR_SOFTIRQS的值是10*/
};
const char * const softirq_to_name[NR_SOFTIRQS];
②、注册软中断处理函数
void open_softirq(int nr, void (*action)(struct softirq_action *))
nr：要开启的软中断。
action：软中断对应的处理函数
注意：需要包含头文件“interrupt.h”
③、触发软中断
void raise_softirq(unsigned int nr)
nr：要触发的软中断。
注意：需要包含头文件“interrupt.h”
④、软中断初始化函数
void softirq_init(void)
注意：需要包含头文件“interrupt.h”
2)、tasklet
tasklet是一种下半部机制，要求推后的工作不能睡眠。在介于软中断和tasklet之间，建议大家使用tasklet，需要包含头文件“#include <linux/interrupt.h>”
①、tasklet_struct结构体如下：
struct tasklet_struct
{
struct tasklet_struct *next;
unsigned long state;
atomic_t count;
void (*func)(unsigned long);
unsigned long data;
};
②、初始化tasklet
void tasklet_init(struct tasklet_struct *t,void (*func)(unsigned long), unsigned long data);
t：要初始化的tasklet；
func：tasklet的处理函数；
data：要传递给func函数的参数；
注意：需要包含头文件“interrupt.h”
DECLARE_TASKLET(name, func, data)
name：为要定义的tasklet名字,其实就是tasklet_struct类型的变量名；
func：就是tasklet的处理函数；
data：是传递给fnc函数的参数；、
注意：需要包含头文件“interrupt.h”
③、tasklet调度函数：
void tasklet_schedule(struct tasklet_struct *t)
t：要调度的tasklet，也就是DECLARE_TASKLET(name, func, data)里面的name；
注意：需要包含头文件“interrupt.h”
注意：
在上半部，也就是“中断处理函数”中调用tasklet_schedule()函数就能使 tasklet在合适的时间运行;
④、举例：
struct tasklet_struct testtasklet; /* 定义taselet */
/* tasklet处理函数 */
void testtasklet_func(unsigned long data)
{
/* tasklet具体处理内容 */
}
/* 中断处理函数 */
irqreturn_t test_handler(int irq, void *dev_id)
{
......
/* 调度tasklet */
tasklet_schedule(&testtasklet);
/*
在上半部，也就是“中断处理函数”中调用tasklet_schedule()函数使 tasklet在合适的时间运行;
*/
......
}
/* 驱动入口函数 */
static int __init xxxx_init(void)
{
......
tasklet_init(&testtasklet, testtasklet_func, data);
/* 初始化tasklet*/
t=&testtasklet，要初始化的tasklet；
func=testtasklet_func，tasklet的处理函数testtasklet_func()；
data：要传递给func函数的参数；
request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
irq=xxx_irq：要申请中断的中断号；
handler=test_handler：中断处理函数test_handler()，当中断发生以后就会执行此中断处理函数；
fags=0：中断标志；
name="xxx"：中断名字，设置以后可以在“/proc/interrupts”文件中看到对应的中断名字；
dev=&xxx_dev：将dev设置为“设备结构体”，dev会传递给中断处理函数irg_handler_t的第二个参数。
返回值：0表示中断申请成功，其他负值，表示中断申请失败，如果返回-EBUSY的话表示中断已经被申请过了。
/* 注册中断处理函数 */
......
}
3)、工作队列
工作队列是一种下半部机制，它工作在进程的上下文处，将要推后的工作交给一个内核线程去执行，因此，允许工作队列进入睡眠或被重新调度。
work_struct结构体表示一个“工作”，需要包含头文件“workqueue.h”，如下;
struct work_struct {
atomic_long_t data;
struct list_head entry;
work_func_t func; /* 工作队列处理函数 */
};
workqueue_struct结构体表示“工作队列”，需要包含头文件“workqueue.h”，如下：
struct workqueue_struct {
struct list_head pwqs;
struct list_head list;
struct mutex mutex;
int work_color;
int flush_color;
atomic_t nr_pwqs_to_flush;
struct wq_flusher *first_flusher;
struct list_head flusher_queue;
struct list_head flusher_overflow;
struct list_head maydays;
struct worker *rescuer;
int nr_drainers;
int saved_max_active;
struct workqueue_attrs *unbound_attrs;
struct pool_workqueue *dfl_pwq;
char name[WQ_NAME_LEN];
struct rcu_head rcu;
unsigned int flags ____cacheline_aligned;
struct pool_workqueue __percpu *cpu_pwqs;
struct pool_workqueue __rcu *numa_pwq_tbl[];
};
worker结构体表示“工作者线程”，需要包含头文件“workqueue_internal.h” ，worker结构体内容如下：
struct worker {
union { struct list_head entry; struct hlist_node hentry; }; struct work_struct *current_work; work_func_t current_func; struct pool_workqueue *current_pwq; struct list_head scheduled; struct task_struct *task; struct worker_pool *pool; struct list_head node; unsigned long last_active; unsigned int flags; int id; int sleeping; char desc[WORKER_DESC_LEN]; struct workqueue_struct *rescue_wq; work_func_t last_func;};
Linux内核使用“工作者线程(worker thread)”来处理工作队列中的各个工作，每个“工作者线程(worker)”都有一个“工作队列(workqueue_struct)”，它会处理属于自己工作队列中的所有“工作(work_struct)”。
在实际驱动开发中，我们只需要定义“工作(work_struct)”即可，关于工作队列和工作者线程我们基本不用去管。
创建“工作(work_struct)”很简单，直接定义一个work_struct结构体变量即可，然后使用INIT_WORK宏来初始化“工作(work_struct)”，也可以使用 DECLARE_WORK宏来一次性完成“工作(work_struct)”的创建和初始化。
INIT_WORK 宏定义，需要包含头文件“workqueue.h”，如下：
#define INIT_WORK(_work, _func)
_work：表示要初始化的工作；
_func：是工作对应的处理函数；
DECLARE_WORK宏定义，需要包含头文件“workqueue.h”，如下：
#define DECLARE_WORK(n, f)
n：表示定义的“工作(work_struct)”
f：表示工作对应的处理函数
工作调度函数，需要包含头文件“workqueue.h”：
bool schedule_work(struct work_struct *work)
work:要调度的工作；返回值:0 成功，其他值 失败；
注意：
在“上半部”，也就是“中断处理函数”中调用schedule_work()函数就能使 “工作队列(workqueue_struct)”在合适的时间运行;
struct work_struct testwork; /* 定义工作(work) */
/* work处理函数 */void testwork_func_t(struct work_struct *work){
/* work具体处理内容 */}
/* 中断处理函数 */irqreturn_t test_handler(int irq, void *dev_id){
.....
schedule_work(&testwork);
/* 调度work */
//work=&testwork:要调度的工作； //返回值:0 成功，其他值 失败；
......}
/* 驱动入口函数 */static int __init xxxx_init(void){
......
INIT_WORK(&testwork, testwork_func_t);
/* 初始化work */
//_work=&testwork：表示要初始化的工作；
//_func= testwork_func_t：是工作对应的处理函数；
request_irq(xxx_irq,test_handler,0,"xxx",&xxx_dev);
/* 注册中断处理函数 */
//irq= xxx_irq：要申请中断的中断号；
//Handler= test_handler：中断处理函数，当中断发生以后就会执行此中断处理函数；
//fags=0：中断标志；
//name="xxx"：中断名字；
//dev=&xxx_dev：将dev设置为“设备结构体”，dev会传递给中断处理函数irg_handler_t的第二个参数。
//返回值：0表示中断申请成功，其他负值，表示中断申请失败，如果返回-EBUSY的话表示中断已经被申请过了。
......
}
6、GIC中断控制器
GIC是ARM公司给Cortex-A/R内核提供的一个中断控制器，类似 Cortex-M 内核中的NVIC；
7、GIC中断源分类：
1)、Shared Peripheral Interrupt，简写SPI，称为“共享中断”，即所有Core共享的中断。比如：GPIO中断、串口中断等，这些中断所有的Core都可以处理，不限定特定 Core；
2)、Private Peripheral Interrupt，简写PPI，称为“私有中断”。 GIC支持多核，每个核有自己专用的中断，且由指定的核心处理，这些中断就叫做私有中断；
3)、Software-generated Interrupt，简写SGI，称为“软件中断”，由软件触发引起的中断，通过向寄存器GICD_SGIR写入数据来触发，系统会使用SGI中断来完成多核之间的通信；
8、中断ID
每个中断源都有一个唯一的中断ID，每个CPU最多支持1020个中断ID，中断ID号为ID0~ID1019。其中IQ0~ID15分配给“软件中断SGI”，IQ16~ID31分配给“私有中断PPI”，ID32~ID1019分配给“共享中断SPI”。
9、外部中断和事件控制器EXTI
Extended interrupt and event controller简写EXTI,它是ST公司设计的，用来辅助GIC管理STM32MP1的相应中断。
1)、EXTI特性：
支持76个输入事件；
两个CPU内核都支持；
所有事件输入均可让CPU唤醒；
2)、EXTI异步输入事件：
①、可配置事件，其特性如下：
可选择的有效触发边沿；
中断挂起状态寄存器位；
单独的中断和事件生成屏蔽；
支持软件触发；
②、直接事件，其特性如下：
固定上升沿有效触发；
EXTI中无中断挂起状态寄存器位(中断挂起状态由生成事件的外设提供)；
单独的中断和事件生成屏蔽；
不支持软件触发；
3)、STM32MP1的中断处理方式：
外设直接产生中断到“GIC中断控制器”，然后由“GIC中断控制器”通知“CPU内核”；GPIO或外设产生中断到“外部中断和事件控制器EXTI”，然后将信号提交给“GIC中断控制器”，再由“GIC中断控制器”通知“CPU内核”；GPIO或外设产生中断到“外部中断和事件控制器EXTI”，然后直接将中断信号提交给“CPU内核”；
4)、GPIO中断
GPIO中断是我们最常用的功能。STM32MP1的所有GPIO都有中断功能，每一组GPIO最多有16个IO，比如：PA0~PA15，因此、每组GPIO就有16个中断，这16个GPIO事件输入对应EXTI0~15，其中 PA0、PB0 等都对应 EXTI0；
5)、设备树绑定信息参考文档
①、“GIC中断控制器”的设备树绑定信息参考文档:
Documentation/devicetree/bindings/interrupt-controller/arm,gic.yaml，
②、EXTI控制器的设备树绑定信息参考文档:
Documentation/devicetree/bindings/interrupt-controller/st,stm32-exti.txt
10、GIC控制器节点
Table 9. Register boundary addresses
在“stm32mp151.dtsi”文件中，“intc节点”就是“ GIC控制器节点”；
intc: interrupt-controller@a0021000 {
compatible = "arm,cortex-a7-gic";
#interrupt-cells = <3>;
/*使用GIC中断控制器需要用3个cells来描述一个中断*/
interrupt-controller;/*这是一个中断控制器*/
reg = <0xa0021000 0x1000>,
<0xa0022000 0x2000>;
/*表示address=0xa0021000，length=0x1000,占4096个字节*/
/*GICD的起始地址为0xa0021000，结束地址为0xA0021FFF，合计4KB*/
/*表示address=0xa0022000，length=0x2000,占8192个字节*/
/*GICC的起始地址为0xa0022000，结束地址为0xA0023FFF，合计8KB*/
};
#interrupt-cells = <3>;
/*使用GIC中断控制器需要用3个cells来描述一个中断*/
第1个cells：中断类型，0表示“共享中断SPI”，1表示“私有中断PPI”。第2个cells：中断号；
对于“共享中断SPI”来说中断号的范围为32~287(256 个)；
对于“私有中断PPI”来说中断号的范围为 16~31，但是该cell描述的中断号是从 0开始。第3个cells：标志，bit[3:0]表示中断触发类型；
bit[3:0]=1表示上升沿触发；
bit[3:0]=2表示下降沿触发；
bit[3:0]=4表示高电平触发；
bit[3:0]=8表示低电平触发；
bit[15:8]为“私有中断PPI”的CPU掩码；
11、SPI6节点
SPI6中断号和中断ID，见下表：
第1列的“Num”就是SPI6的中断号：86
第2列“ID”为118，ID = Num + 32
SPI6地址范围，见下表：
Table 117. STM32MP157 interrupt mapping for Cortex®-A7 GIC
SPI6的起始地址为0x5C001000，结束地址为0x5C0013FF，合计1KB
打开stm32mp151.dtsi，找到SPI6节点内容，如下：
spi6: spi@5c001000 {
#address-cells = <1>;
/*定义子节点的reg和ranges的addres长度为32个位*/
#size-cells = <0>;
/*表示子节点的reg和ranges的length占0个位,即没有length*/
compatible = "st,stm32h7-spi";
reg = <0x5c001000 0x400>;
/*表示address=0x5c001000，length=0x400,占1024个字节*/
/*SPI6的起始地址为0x5C001000，结束地址为0x5C0013FF，合计1KB*/
interrupts = <GIC_SPI 86 IRQ_TYPE_LEVEL_HIGH>;
/*GIC_SPI表示共享中断SPI，86为中断号*/
/*中断触发类型IRQ_TYPE_LEVEL_HIGH*/
clocks = <&scmi0_clk CK_SCMI0_SPI6>;
resets = <&scmi0_reset RST_SCMI0_SPI6>;
dmas = <&mdma1 34 0x0 0x40008 0x0 0x0 0x0>,
<&mdma1 35 0x0 0x40002 0x0 0x0 0x0>;
dma-names = "rx", "tx";
power-domains = <&pd_core>;
status = "disabled";
};
12、EXTI控制器节点
exti: interrupt-controller@5000d000 {
compatible = "st,stm32mp1-exti", "syscon";
interrupt-controller;
#interrupt-cells = <2>;
/*使用EXTI中断控制器需要用2个cells来描述一个中断*/
/*第1个cells：中断号；第2个cells：中断标志位*/
reg = <0x5000d000 0x400>;
/*表示address=0x5000d000，length=0x400,占1024个字节*/
/*EXTI的起始地址为0x5000d000，结束地址为0x5000D3FF，合计1KB*/
hwlocks = <&hsem 1 1>;
/* exti_pwr is an extra interrupt controller used for
* EXTI 55 to 60. It's mapped on pwr interrupt
* controller.
*/
exti_pwr: exti-pwr {
interrupt-controller;
#interrupt-cells = <2>;
interrupt-parent = <&pwr_irq>;
/*指定exti_pwr所有子节点的中断父节点为pwr_irq*/
st,irq-number = <6>;
};
};
#interrupt-cells = <2>;
/*使用EXTI中断控制器需要用2个cells来描述一个中断*/
第1个cells：中断号；第2个cells：中断标志位，bit[3:0]表示中断触发类型；
13、GPIOA~GPIOK寄存器地址
Table 9. Register boundary addresses (continued)
pinctrl: pin-controller@50002000 {
#address-cells = <1>;
/*定义子节点的reg和ranges的addres长度为32个位*/
#size-cells = <1>;
/*定义子节点的reg和ranges的length长度为32个位*/
compatible = "st,stm32mp157-pinctrl";
ranges = <0 0x50002000 0xa400>;
/*子节点寄存器起始地址为0*/
/*父节点寄存器起始地址为0x50002000*/
/*寄存器最大偏移地址为0xa400*/
interrupt-parent = <&exti>;
/*指定pinctrl所有子节点的中断父节点为exti*/
/*这样GPIO的中断就和EXTI联系起来*/
st,syscfg = <&exti 0x60 0xff>;
hwlocks = <&hsem 0 1>;
pins-are-numbered;
gpioa: gpio@50002000 {
gpio-controller;
/*指定gpioa节点是一个GPIO控制器*/
#gpio-cells = <2>;
/*定义描述使用一个gpio口需要提供2个指定的参数*/
interrupt-controller;
/* 指定gpioa节点为中断控制器, 其父节点为pinctrl，其中断为exti*/
#interrupt-cells = <2>;
/*interrupts属性第1个cell为某个IO在所处组的编号*/
/*第2个cell表示中断触发方式*/
reg = <0x0 0x400>;
/*表示address=0，length=0x400,占1024个字节*/
/*GPIOA的起始地址为(0x50002000+0)，结束地址为(0x50002000+0+0x400-1) */
/*GPIOA的起始地址为0x50002000，结束地址为0x500023FF */
clocks = <&rcc GPIOA>;
st,bank-name = "GPIOA";
status = "disabled";
};
gpiob: gpio@50003000 {
gpio-controller;
/*指定gpiob节点是一个GPIO控制器*/
#gpio-cells = <2>;
/*定义描述使用一个gpio口需要提供2个指定的参数*/
interrupt-controller;
/* 指定gpiob节点为中断控制器, 其父节点为pinctrl，其中断为exti*/
#interrupt-cells = <2>;
/*interrupts属性第1个cell为某个IO在所处组的编号*/
/*第2个cell表示中断触发方式*/
reg = <0x1000 0x400>;
/*表示address=0x1000，length=0x400,占1024个字节*/
/*GPIOB的起始地址为(0x50002000+0x1000)*/
/*GPIOB的结束地址为(0x50002000+0x1000+0x400-1) */
/*GPIOB的起始地址为0x50003000，结束地址为0x500033FF */
clocks = <&rcc GPIOB>;
st,bank-name = "GPIOB";
status = "disabled";
};
gpioc: gpio@50004000 {
gpio-controller;
/*指定gpioc节点是一个GPIO控制器*/
#gpio-cells = <2>;
/*定义描述使用一个gpio口需要提供2个指定的参数*/
interrupt-controller;
/* 指定gpioc节点为中断控制器, 其父节点为pinctrl，其中断为exti*/
#interrupt-cells = <2>;
/*interrupts属性第1个cell为某个IO在所处组的编号*/
/*第2个cell表示中断触发方式*/
reg = <0x2000 0x400>;
/*表示address=0x2000，length=0x400,占1024个字节*/
/*GPIOC的起始地址为(0x50002000+0x2000)*/
/*GPIOC的结束地址为(0x50002000+0x2000+0x400-1) */
/*GPIOC的起始地址为0x50004000，结束地址为0x500043FF */
clocks = <&rcc GPIOC>;
st,bank-name = "GPIOC";
status = "disabled";
};
gpiod: gpio@50005000 {
gpio-controller;
/*指定gpiod节点是一个GPIO控制器*/
#gpio-cells = <2>;
/*定义描述使用一个gpio口需要提供2个指定的参数*/
interrupt-controller;
/* 指定gpiod节点为中断控制器, 其父节点为pinctrl，其中断为exti*/
#interrupt-cells = <2>;
/*interrupts属性第1个cell为某个IO在所处组的编号*/
/*第2个cell表示中断触发方式*/
reg = <0x3000 0x400>;
/*表示address=0x3000，length=0x400,占1024个字节*/
/*GPIOD的起始地址为(0x50002000+0x3000)*/
/*GPIOD的结束地址为(0x50002000+0x3000+0x400-1) */
/*GPIOD的起始地址为0x50005000，结束地址为0x500053FF */
clocks = <&rcc GPIOD>;
st,bank-name = "GPIOD";
status = "disabled";
};
gpioe: gpio@50006000 {
gpio-controller;
/*指定gpioe节点是一个GPIO控制器*/
#gpio-cells = <2>;
interrupt-controller;
/* 指定gpioe节点为中断控制器, 其父节点为pinctrl，其中断为exti*/
#interrupt-cells = <2>;
reg = <0x4000 0x400>;
clocks = <&rcc GPIOE>;
st,bank-name = "GPIOE";
status = "disabled";
};
gpiof: gpio@50007000 {
gpio-controller;
#gpio-cells = <2>;
interrupt-controller;
#interrupt-cells = <2>;
reg = <0x5000 0x400>;
clocks = <&rcc GPIOF>;
st,bank-name = "GPIOF";
status = "disabled";
};
gpiog: gpio@50008000 {
gpio-controller;
/*指定gpiogg节点是一个GPIO控制器*/
#gpio-cells = <2>;
interrupt-controller;
#interrupt-cells = <2>;
reg = <0x6000 0x400>;
clocks = <&rcc GPIOG>;
st,bank-name = "GPIOG";
status = "disabled";
};
gpioh: gpio@50009000 {
gpio-controller;
/*指定gpioh节点是一个GPIO控制器*/
#gpio-cells = <2>;
interrupt-controller;
#interrupt-cells = <2>;
reg = <0x7000 0x400>;
clocks = <&rcc GPIOH>;
st,bank-name = "GPIOH";
status = "disabled";
};
gpioi: gpio@5000a000 {
gpio-controller;
/*指定gpioi节点是一个GPIO控制器*/
#gpio-cells = <2>;
interrupt-controller;
#interrupt-cells = <2>;
reg = <0x8000 0x400>;
clocks = <&rcc GPIOI>;
st,bank-name = "GPIOI";
status = "disabled";
};
gpioj: gpio@5000b000 {
gpio-controller;
/*指定gpioj节点是一个GPIO控制器*/
#gpio-cells = <2>;
interrupt-controller;
#interrupt-cells = <2>;
reg = <0x9000 0x400>;
clocks = <&rcc GPIOJ>;
st,bank-name = "GPIOJ";
status = "disabled";
};
gpiok: gpio@5000c000 {
gpio-controller;
/*指定gpiok节点是一个GPIO控制器*/
#gpio-cells = <2>;
interrupt-controller;
#interrupt-cells = <2>;
reg = <0xa000 0x400>;
clocks = <&rcc GPIOK>;
st,bank-name = "GPIOK";
status = "disabled";
};
};
14、GPIOZ寄存器：
Table 9. Register boundary addresses (continued)
pinctrl_z: pin-controller-z@54004000 {
#address-cells = <1>;
/*定义子节点的reg和ranges的addres长度为32个位*/
#size-cells = <1>;
/*定义子节点的reg和ranges的length长度为32个位*/
compatible = "st,stm32mp157-z-pinctrl";
ranges = <0 0x54004000 0x400>;
/*指定子节点寄存器起始地址为0*/
/*父节点寄存器起始地址为0x50004000*/
/*地址长度为0x400*/
pins-are-numbered;
interrupt-parent = <&exti>;
st,syscfg = <&exti 0x60 0xff>;
hwlocks = <&hsem 0 1>;
gpioz: gpio@54004000 {
gpio-controller;
/*指定gpioz节点是一个GPIO控制器*/
#gpio-cells = <2>;
interrupt-controller;
#interrupt-cells = <2>;
/*interrupts属性第1个cell为某个IO在所处组的编号*/
/*第2个cell表示中断触发方式*/
reg = <0 0x400>;
/*表示address=0，length=0x400,占1024个字节*/
/*GPIOZ的起始地址为(0x50004000+0)*/
/*GPIOZ的结束地址为(0x50004000+0+0x400-1) */
/*GPIOZ的起始地址为0x50004000，结束地址为0x500043FF */
clocks = <&scmi0_clk CK_SCMI0_GPIOZ>;
st,bank-name = "GPIOZ";
st,bank-ioport = <11>;
status = "disabled";
};
};
timer {
compatible = "arm,armv7-timer";
interrupts = <GIC_PPI 13 (GIC_CPU_MASK_SIMPLE(4) | IRQ_TYPE_LEVEL_LOW)>,
<GIC_PPI 14 (GIC_CPU_MASK_SIMPLE(4) | IRQ_TYPE_LEVEL_LOW)>,
<GIC_PPI 11 (GIC_CPU_MASK_SIMPLE(4) | IRQ_TYPE_LEVEL_LOW)>,
<GIC_PPI 10 (GIC_CPU_MASK_SIMPLE(4) | IRQ_TYPE_LEVEL_LOW)>;
interrupt-parent = <&intc>;
always-on;
}
15、简单总结一下与中断有关的设备树属性信息:
①、#interrupt-cells，指定中断源的信息cells个数；
②、imnterrupt-controller，表示当前节点为中断控制器；
③、interrupts，指定中断号，触发方式等；
④、imnterrupt-parent，指定父中断，也就是中断控制器；
⑤、interrupts-extended，指定中断控制器、中断号、中断类型和触发方式；
举例：
interrupt-parent = <&gpiog>;/*指定父中断器为&gpiog*/
interrupts = <3 IRQ_TYPE_EDGE_BOTH>;
/*指定中断号为3，中断类型和触发方式为边沿触发*/
使用interrupts-extended可以代替上面的两句：
interrupts-extended = <&gpiog 3 IRQ_TYPE_EDGE_FALLING>;
/*指定中断控制器&gpiog、中断号为3、中断类型和触发方式下降沿触发*/
16、触发类型，位于文件“irq.h”中：
IRQ_TYPE_NONE - default, unspecified type
IRQ_TYPE_EDGE_RISING - rising edge triggered
IRQ_TYPE_EDGE_FALLING - falling edge triggered
IRQ_TYPE_EDGE_BOTH - rising and falling edge triggered
IRQ_TYPE_LEVEL_HIGH - high level triggered
IRQ_TYPE_LEVEL_LOW - low level triggered
IRQ_LEVEL - Interrupt is level type
17、打开stm32mpl57f-ev1-a7-examples.dts文件，里面有如下所示代码
test_keys {
compatible = "gpio-keys";
#address-cells = <1>;
/*定义子节点的reg和ranges的addres长度为32个位*/
#size-cells = <0>;
/*表示子节点的reg和ranges的length占0个位,即没有length*/
autorepeat;
status = "okay";
/* gpio needs vdd core in retention for wakeup */
power-domains = <&pd_core_ret>;
button@1 {
label = "PA13";
linux,code = <BTN_1>;
interrupts-extended = <&gpioa 13 IRQ_TYPE_EDGE_FALLING>;
/*指定中断控制器&gpioa、中断号为13、中断类型和触发方式IRQ_TYPE_EDGE_FALLING*/
status = "okay";
wakeup-source;
};
};
18、相关函数：
1)、获取中断号，需要包含文件“of_irq.h”
unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
dev：为设备节点，Linux内核使用device_node结构体来描述一个节点。
index：索引号，interrupts属性可能包含多条中断信息，通过index指定要获取的信息；
返回值：中断号；
获取GPIO中断号，需要包含文件“gpio.h”
int gpio_to_irq(unsigned int gpio)
gpio：要获取的GPIO编号；返回值：GPIO对应的中断号
![[数据结构]插入和希尔排序](https://img-blog.csdnimg.cn/direct/4178a8c92ab44a49b688378c0b8a9bf5.png)
