全面解读Linux 中断子系统的驱动

GIC 驱动

这里主要分析 linux kernel 中 GIC v3 中断控制器的代码(drivers/irqchip/irq-gic-v3.c)。

设备树

先来看下一个中断控制器的设备树信息：

gic:interrupt-controller@51a00000{
compatible="arm,gic-v3";
reg=<0x00x51a0000000x10000>,/*GICDist*/
<0x00x51b0000000xC0000>,/*GICR*/
<0x00x5200000000x2000>,/*GICC*/
<0x00x5201000000x1000>,/*GICH*/
<0x00x5202000000x20000>;/*GICV*/
#interrupt-cells=<3>;
interrupt-controller;
interrupts=9
(GIC_CPU_MASK_SIMPLE(6)|IRQ_TYPE_LEVEL_HIGH)>;
interrupt-parent=<&gic>;
};

• compatible：用于匹配GICv3驱动
• reg：GIC的物理基地址，分别对应GICD,GICR,GICC…
• #interrupt-cells：这是一个中断控制器节点的属性。它声明了该中断控制器的中断指示符(interrupts)中 cell 的个数
• interrupt-controller: 表示该节点是一个中断控制器
• interrupts：分别代表中断类型，中断号，中断类型， PPI中断亲和， 保留字段

关于设备数的各个字段含义，详细可以参考 Documentation/devicetree/bindings 下的对应信息。

初始化

1. irq chip driver 的声明：

IRQCHIP_DECLARE(gic_v3,"arm,gic-v3",gic_of_init);

定义 IRQCHIP_DECLARE 之后，相应的内容会保存到 __irqchip_of_table 里边:

#defineIRQCHIP_DECLARE(name,compat,fn)OF_DECLARE_2(irqchip,name,compat,fn)

#defineOF_DECLARE_2(table,name,compat,fn)
_OF_DECLARE(table,name,compat,fn,of_init_fn_2)

#define_OF_DECLARE(table,name,compat,fn,fn_type)
staticconststructof_device_id__of_table_##name
__used__section(__##table##_of_table)
={.compatible=compat,
.data=(fn==(fn_type)NULL)?fn:fn}

__irqchip_of_table 在链接脚本 vmlinux.lds 里，被放到了 __irqchip_begin 和 __irqchip_of_end 之间，该段用于存放中断控制器信息：

#ifdefCONFIG_IRQCHIP
#defineIRQCHIP_OF_MATCH_TABLE()
.=ALIGN(8);
VMLINUX_SYMBOL(__irqchip_begin)=.;
*(__irqchip_of_table)
*(__irqchip_of_end)
#endif

在内核启动初始化中断的函数中，of_irq_init 函数会去查找设备节点信息，该函数的传入参数就是 __irqchip_of_table 段，由于 IRQCHIP_DECLARE 已经将信息填充好了，of_irq_init 函数会根据 “arm,gic-v3” 去查找对应的设备节点，并获取设备的信息。or_irq_init 函数中，最终会回调 IRQCHIP_DECLARE 声明的回调函数，也就是 gic_of_init，而这个函数就是 GIC 驱动的初始化入口。

2. gic_of_init 流程：

staticint__initgic_of_init(structdevice_node*node,structdevice_node*parent)
{
......
dist_base=of_iomap(node,0);------(1)
if(!dist_base){
pr_err("%pOF:unabletomapgicdistregisters
",node);
return-ENXIO;
}

err=gic_validate_dist_version(dist_base);------(2)
if(err){
pr_err("%pOF:nodistributordetected,givingup
",node);
gotoout_unmap_dist;
}

if(of_property_read_u32(node,"#redistributor-regions",&nr_redist_regions))------(3)
nr_redist_regions=1;

rdist_regs=kzalloc(sizeof(*rdist_regs)*nr_redist_regions,GFP_KERNEL);
if(!rdist_regs){
err=-ENOMEM;
gotoout_unmap_dist;
}

for(i=0;i< nr_redist_regions; i++) {                                ------(4)
structresourceres;
intret;

ret=of_address_to_resource(node,1+i,&res);
rdist_regs[i].redist_base=of_iomap(node,1+i);
if(ret||!rdist_regs[i].redist_base){
pr_err("%pOF:couldn'tmapregion%d
",node,i);
err=-ENODEV;
gotoout_unmap_rdist;
}
rdist_regs[i].phys_base=res.start;
}

if(of_property_read_u64(node,"redistributor-stride",&redist_stride))------(5)
redist_stride=0;

err=gic_init_bases(dist_base,rdist_regs,nr_redist_regions,------(6)
redist_stride,&node->fwnode);
if(err)
gotoout_unmap_rdist;

gic_populate_ppi_partitions(node);------(7)
gic_of_setup_kvm_info(node);
return0;
......
returnerr;
}

1. 映射 GICD 的寄存器地址空间。
2. 验证 GICD 的版本是 GICv3 还是 GICv4（主要通过读GICD_PIDR2寄存器bit[7:4]. 0x1代表GICv1， 0x2代表GICv2…以此类推）。
3. 通过 DTS 读取 redistributor-regions 的值。
4. 为一个 GICR 域分配基地址。
5. 通过 DTS 读取 redistributor-stride 的值。
6. 下面详细介绍。
7. 设置一组 PPI的亲和性。

staticint__initgic_init_bases(void__iomem*dist_base,
structredist_region*rdist_regs,
u32nr_redist_regions,
u64redist_stride,
structfwnode_handle*handle)
{
......
typer=readl_relaxed(gic_data.dist_base+GICD_TYPER);------(1)
gic_data.rdists.id_bits=GICD_TYPER_ID_BITS(typer);
gic_irqs=GICD_TYPER_IRQS(typer);
if(gic_irqs>1020)
gic_irqs=1020;
gic_data.irq_nr=gic_irqs;

gic_data.domain=irq_domain_create_tree(handle,&gic_irq_domain_ops,------(2)
&gic_data);
gic_data.rdists.rdist=alloc_percpu(typeof(*gic_data.rdists.rdist));
gic_data.rdists.has_vlpis=true;
gic_data.rdists.has_direct_lpi=true;
......
set_handle_irq(gic_handle_irq);------(3)

gic_update_vlpi_properties();------(4)

if(IS_ENABLED(CONFIG_ARM_GIC_V3_ITS)&&gic_dist_supports_lpis())
its_init(handle,&gic_data.rdists,gic_data.domain);------(5)

gic_smp_init();------(6)
gic_dist_init();------(7)
gic_cpu_init();------(8)
gic_cpu_pm_init();------(9)

return0;
......
}

1. 确认支持 SPI 中断号最大的值为多少。
2. 向系统中注册一个 irq domain 的数据结构，irq_domain 主要作用是将硬件中断号映射到 irq number，后面会做详细的介绍。
3. 设定 arch 相关的 irq handler。gic_irq_handle 是内核 gic 中断处理的入口函数，后面会做详细的介绍。
4. gic 虚拟化相关的内容。
5. 初始化 ITS。
6. 设置 SMP 核间交互的回调函数，用于 IPI，回到函数为 gic_raise_softir。
7. 初始化 Distributor。
8. 初始化 CPU interface。
9. 初始化 GIC 电源管理。

中断的映射

当早期的系统只存在一个中断控制器，而且中断数目也不多的时候，一个很简单的做法就是一个中断号对应到中断控制器的一个号，可以说是简单的线性映射：

但当一个系统中有多个中断控制器，而且中断号也逐渐增加的时候。linux 内核为了应对此问题，引入了 irq_domain 的概念。

irq_domain 的引入相当于一个中断控制器就是一个 irq_domain。这样一来所有的中断控制器就会出现级联的布局。利用树状的结构可以充分的利用 irq 数目，而且每一个 irq_domain 区域可以自己去管理自己 interrupt 的特性。

每一个中断控制器对应多个中断号， 而硬件中断号在不同的中断控制器上是会重复编码的， 这时仅仅用硬中断号已经不能唯一标识一个外设中断，因此 linux kernel 提供了一个虚拟中断号的概念。

接下来我们看下硬件中断号是如何映射到虚拟中断号的。

数据结构

在看硬件中断号映射到虚拟中断号之前，先来看下几个比较重要的数据结构。

struct irq_desc描述一个外设的中断，称之中断描述符。

structirq_desc{
structirq_common_datairq_common_data;
structirq_datairq_data;
unsignedint__percpu*kstat_irqs;
irq_flow_handler_thandle_irq;
......
structirqaction*action;
......
}____cacheline_internodealigned_in_smp;

• irq_data：中断控制器的硬件数据
• handle_irq：中断控制器驱动的处理函数，指向一个 struct irqaction 的链表，一个中断源可以多个设备共享，所以一个 irq_desc 可以挂载多个 action，由链表结构组织起来
• action：设备驱动的处理函数

struct irq_data包含中断控制器的硬件数据。

structirq_data{
u32mask;
unsignedintirq;
unsignedlonghwirq;
structirq_common_data*common;
structirq_chip*chip;
structirq_domain*domain;
#ifdefCONFIG_IRQ_DOMAIN_HIERARCHY
structirq_data*parent_data;
#endif
void*chip_data;
};

• irq：虚拟中断号
• hwirq：硬件中断号
• chip：对应的 irq_chip 数据结构
• domain：对应的 irq_domain 数据结构

struct irq_chip用于对中断控制器的硬件操作。

structirq_chip{
structdevice*parent_device;
constchar*name;
unsignedint(*irq_startup)(structirq_data*data);
void(*irq_shutdown)(structirq_data*data);
void(*irq_enable)(structirq_data*data);
void(*irq_disable)(structirq_data*data);

void(*irq_ack)(structirq_data*data);
void(*irq_mask)(structirq_data*data);
void(*irq_mask_ack)(structirq_data*data);
void(*irq_unmask)(structirq_data*data);
void(*irq_eoi)(structirq_data*data);

int(*irq_set_affinity)(structirq_data*data,conststructcpumask*dest,boolforce);
int(*irq_retrigger)(structirq_data*data);
int(*irq_set_type)(structirq_data*data,unsignedintflow_type);
int(*irq_set_wake)(structirq_data*data,unsignedinton);

void(*irq_bus_lock)(structirq_data*data);
void(*irq_bus_sync_unlock)(structirq_data*data);
......
};

• parent_device：指向父设备
• name：/proc/interrupts 中显示的名字
• irq_startup：启动中断，如果设置成 NULL，则默认为 enable
• irq_shutdown：关闭中断，如果设置成 NULL，则默认为 disable
• irq_enable：中断使能，如果设置成 NULL，则默认为 chip->unmask
• irq_disable：中断禁止
• irq_ack：开始新的中断
• irq_mask：中断源屏蔽
• irq_mask_ack：应答并屏蔽中断
• irq_unmask：解除中断屏蔽
• irq_eoi：中断处理结束后调用
• irq_set_affinity：在 SMP 中设置 CPU 亲和力
• irq_retrigger：重新发送中断到 CPU
• irq_set_type：设置中断触发类型
• irq_set_wake：使能/禁止电源管理中的唤醒功能
• irq_bus_lock：慢速芯片总线上的锁
• irq_bus_sync_unlock：同步释放慢速总线芯片的锁

struct irq_domain与中断控制器对应，完成硬件中断号 hwirq 到 virq 的映射。

structirq_domain{
structlist_headlink;
constchar*name;
conststructirq_domain_ops*ops;
void*host_data;
unsignedintflags;
unsignedintmapcount;

/*Optionaldata*/
structfwnode_handle*fwnode;
enumirq_domain_bus_tokenbus_token;
structirq_domain_chip_generic*gc;
#ifdefCONFIG_IRQ_DOMAIN_HIERARCHY
structirq_domain*parent;
#endif
#ifdefCONFIG_GENERIC_IRQ_DEBUGFS
structdentry*debugfs_file;
#endif

/*reversemapdata.Thelinearmapgetsappendedtotheirq_domain*/
irq_hw_number_thwirq_max;
unsignedintrevmap_direct_max_irq;
unsignedintrevmap_size;
structradix_tree_rootrevmap_tree;
unsignedintlinear_revmap[];
};

• link：用于将 irq_domain 连接到全局链表 irq_domain_list 中
• name：irq_domain 的名称
• ops：irq_domain 映射操作函数集
• mapcount：映射好的中断的数量
• fwnode：对应中断控制器的 device node
• parent：指向父级 irq_domain 的指针，用于支持级联 irq_domain
• hwirq_max：该 irq_domain 支持的中断最大数量
• linear_revmap[]：hwirq->virq 反向映射的线性表

struct irq_domain_ops是 irq_domain 映射操作函数集。

structirq_domain_ops{
int(*match)(structirq_domain*d,structdevice_node*node,
enumirq_domain_bus_tokenbus_token);
int(*select)(structirq_domain*d,structirq_fwspec*fwspec,
enumirq_domain_bus_tokenbus_token);
int(*map)(structirq_domain*d,unsignedintvirq,irq_hw_number_thw);
void(*unmap)(structirq_domain*d,unsignedintvirq);
int(*xlate)(structirq_domain*d,structdevice_node*node,
constu32*intspec,unsignedintintsize,
unsignedlong*out_hwirq,unsignedint*out_type);
......
};

• match：用于中断控制器设备与 irq_domain 的匹配
• map：用于硬件中断号与 Linux 中断号的映射
• xlate：通过 device_node，解析硬件中断号和触发方式

struct irqaction主要是用来存设备驱动注册的中断处理函数。

structirqaction{
irq_handler_thandler;
void*dev_id;
......
unsignedintirq;
unsignedintflags;
......
constchar*name;
structproc_dir_entry*dir;
}____cacheline_internodealigned_in_smp;

• handler：设备驱动里的中断处理函数
• dev_id：设备 id
• irq：中断号
• flags：中断标志，注册时设置，比如上升沿中断，下降沿中断等
• name：中断名称,产生中断的硬件的名字
• dir：指向 /proc/irq/ 相关的信息

这里，我们用一张图来汇总下上面的数据结构：

上面的结构体 struct irq_desc 是设备驱动加载的过程中完成的，让设备树中的中断能与具体的中断描述符 irq_desc 匹配，其中 struct irqaction 保存着设备的中断处理函数。右边框内的结构体主要是在中断控制器驱动加载的过程中完成的，其中 struct irq_chip 用于对中断控制器的硬件操作，struct irq_domain 用于硬件中断号到 Linux irq 的映射。

下面我们结合代码看下中断控制器驱动和设备驱动是如何创建这些结构体，并且硬中断和虚拟中断号是如何完成映射的。

中断控制器注册 irq_domain

通过 __irq_domain_add 初始化irq_domain数据结构，然后把 irq_domain 添加到全局的链表 irq_domain_list 中。

外设的驱动创建硬中断和虚拟中断号的映射关系

设备的驱动在初始化的时候可以调用 irq_of_parse_and_map 这个接口函数进行该 device node 中和中断相关的内容的解析，并建立映射关系

• of_irq_parse_one 函数用于解析DTS文件中设备定义的属性，如"reg", “interrupt”
• irq_find_matching_fwspec 遍历 irq_domain_list 链表，找到 device node 匹配的irq_domain
• gic_irq_domain_translate 解析出中断信息，比如硬件中断号 hwirq，中断触发方式
• irq_domain_alloc_descs 分配一个虚拟的中断号 virq，分配和初始化中断描述符irq_desc
• gic_irq_domain_alloc 为 hwirq 和 virq 创建映射关系。内部会通过 irq_domain_set_info 调用 irq_domain_set_hwirq_and_chip，然后通过 virq 获取irq_data结构体，并将 hwirq 设置到 irq_data->hwirq 中， 最终完成 hwirq 到 virq 的映射
• irq_domain_set_info 根据硬件中断号的范围设置 irq_desc->handle_irq 的指针，共享中断入口为 handle_fasteoi_irq，私有中断入口为 handle_percpu_devid_irq

最后，我们可以通过 /proc/interrupts 下的值来看下它们的关系：

现在，我们已经知道内核为硬件中断号与 Linux 中断号做了映射，相关数据结构的绑定及初始化，并且设置了中断处理函数执行的入口。接下来我们再看下设备的中断是怎么来注册的？

中断的注册

设备驱动中，获取到了 irq 中断号后，通常就会采用 request_irq/request_threaded_irq 来注册中断，其中 request_irq 用于注册普通处理的中断。request_threaded_irq 用于注册线程化处理的中断，线程化中断的主要目的把中断上下文的任务迁移到线程中，减少系统关中断的时间，增强系统的实时性。

staticinlineint__must_check
request_irq(unsignedintirq,irq_handler_thandler,unsignedlongflags,
constchar*name,void*dev)
{
returnrequest_threaded_irq(irq,handler,NULL,flags,name,dev);
}

其中 irq 是 linux 中断号，handler 是中断处理函数，flags 是中断标志位，name 是中断的名字。在讲具体的注册流程前，先看一下主要的中断标志位：

#defineIRQF_SHARED0x00000080//多个设备共享一个中断号，需要外设硬件支持
#defineIRQF_PROBE_SHARED0x00000100//中断处理程序允许sharingmismatch发生
#define__IRQF_TIMER0x00000200//时钟中断
#defineIRQF_PERCPU0x00000400//属于特定CPU的中断
#defineIRQF_NOBALANCING0x00000800//禁止在CPU之间进行中断均衡处理
#defineIRQF_IRQPOLL0x00001000//中断被用作轮训
#defineIRQF_ONESHOT0x00002000//一次性触发的中断，不能嵌套，1）在硬件中断处理完成后才能打开中断；2）在中断线程化中保持关闭状态，直到该中断源上的所有thread_fn函数都执行完
#defineIRQF_NO_SUSPEND0x00004000//系统休眠唤醒操作中，不关闭该中断
#defineIRQF_FORCE_RESUME0x00008000//系统唤醒过程中必须强制打开该中断
#defineIRQF_NO_THREAD0x00010000//禁止中断线程化
#defineIRQF_EARLY_RESUME0x00020000//系统唤醒过程中在syscore阶段resume，而不用等到设备resume阶段
#defineIRQF_COND_SUSPEND0x00040000//与NO_SUSPEND的用户共享中断时，执行本设备的中断处理函数

创建完成后，通过 ps 命令可以查看系统中的中断线程，注意这些线程是实时线程 SCHED_FIFO：

#ps-A|grep"irq/"
root1749200irq_thread0S[irq/433-imx_drm]
root1750200irq_thread0S[irq/439-imx_drm]
root1751200irq_thread0S[irq/445-imx_drm]
root1752200irq_thread0S[irq/451-imx_drm]
root2044200irq_thread0S[irq/279-isl2902]
root2192200irq_thread0S[irq/114-mmc0]
root2199200irq_thread0S[irq/115-mmc1]
root2203200irq_thread0S[irq/322-5b02000]
root2361200irq_thread0S[irq/294-4-0051]

编辑：jq