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

Linux爱好者 2021-09-23 2776

描述

GIC 驱动

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

设备树

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

gic: interrupt-controller@51a00000 {
        compatible = "arm,gic-v3";
        reg = <0x0 0x51a00000 0 0x10000>, /* GIC Dist */
              <0x0 0x51b00000 0 0xC0000>, /* GICR */
              <0x0 0x52000000 0 0x2000>,  /* GICC */
              <0x0 0x52010000 0 0x1000>,  /* GICH */
              <0x0 0x52020000 0 0x20000>; /* 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 里边:

#define IRQCHIP_DECLARE(name, compat, fn) OF_DECLARE_2(irqchip, name, compat, fn)

#define OF_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)             
    static const struct of_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 之间，该段用于存放中断控制器信息：

#ifdef CONFIG_IRQCHIP
    #define IRQCHIP_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 流程：

static int __init gic_of_init(struct device_node *node, struct device_node *parent)
{
  ......
 dist_base = of_iomap(node, 0);                                           ------(1)
 if (!dist_base) {
  pr_err("%pOF: unable to map gic dist registers
", node);
  return -ENXIO;
 }

 err = gic_validate_dist_version(dist_base);                              ------(2)
 if (err) {
  pr_err("%pOF: no distributor detected, giving up
", node);
  goto out_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;
  goto out_unmap_dist;
 }

 for (i = 0; i < nr_redist_regions; i++) {                                ------(4)
  struct resource res;
  int ret;

  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't map region %d
", node, i);
   err = -ENODEV;
   goto out_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)
  goto out_unmap_rdist;

 gic_populate_ppi_partitions(node);                                       ------(7)
 gic_of_setup_kvm_info(node);
 return 0;
  ......
 return err;
}

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

static int __init gic_init_bases(void __iomem *dist_base,
     struct redist_region *rdist_regs,
     u32 nr_redist_regions,
     u64 redist_stride,
     struct fwnode_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)

 return 0;
  ......
}

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

中断的映射

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

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

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

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

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

数据结构

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

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

struct irq_desc {
 struct irq_common_data irq_common_data;
 struct irq_data  irq_data;  
 unsigned int __percpu *kstat_irqs;
 irq_flow_handler_t handle_irq;  
  ......
 struct irqaction *action; 
 ......
} ____cacheline_internodealigned_in_smp;

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

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

struct irq_data {
 u32   mask;
 unsigned int  irq;
 unsigned long  hwirq;
 struct irq_common_data *common;
 struct irq_chip  *chip;
 struct irq_domain *domain;
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
 struct irq_data  *parent_data;
#endif
 void   *chip_data;
};

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

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

struct irq_chip {
 struct device *parent_device;
 const char *name;
 unsigned int (*irq_startup)(struct irq_data *data);
 void  (*irq_shutdown)(struct irq_data *data);
 void  (*irq_enable)(struct irq_data *data);
 void  (*irq_disable)(struct irq_data *data);

 void  (*irq_ack)(struct irq_data *data);
 void  (*irq_mask)(struct irq_data *data);
 void  (*irq_mask_ack)(struct irq_data *data);
 void  (*irq_unmask)(struct irq_data *data);
 void  (*irq_eoi)(struct irq_data *data);

 int  (*irq_set_affinity)(struct irq_data *data, const struct cpumask *dest, bool force);
 int  (*irq_retrigger)(struct irq_data *data);
 int  (*irq_set_type)(struct irq_data *data, unsigned int flow_type);
 int  (*irq_set_wake)(struct irq_data *data, unsigned int on);

 void  (*irq_bus_lock)(struct irq_data *data);
 void  (*irq_bus_sync_unlock)(struct irq_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 的映射。

struct irq_domain {
 struct list_head link;
 const char *name;
 const struct irq_domain_ops *ops;
 void *host_data;
 unsigned int flags;
 unsigned int mapcount;

 /* Optional data */
 struct fwnode_handle *fwnode;
 enum irq_domain_bus_token bus_token;
 struct irq_domain_chip_generic *gc;
#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
 struct irq_domain *parent;
#endif
#ifdef CONFIG_GENERIC_IRQ_DEBUGFS
 struct dentry  *debugfs_file;
#endif

 /* reverse map data. The linear map gets appended to the irq_domain */
 irq_hw_number_t hwirq_max;
 unsigned int revmap_direct_max_irq;
 unsigned int revmap_size;
 struct radix_tree_root revmap_tree;
 unsigned int linear_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 映射操作函数集。

struct irq_domain_ops {
 int (*match)(struct irq_domain *d, struct device_node *node,
       enum irq_domain_bus_token bus_token);
 int (*select)(struct irq_domain *d, struct irq_fwspec *fwspec,
        enum irq_domain_bus_token bus_token);
 int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
 void (*unmap)(struct irq_domain *d, unsigned int virq);
 int (*xlate)(struct irq_domain *d, struct device_node *node,
       const u32 *intspec, unsigned int intsize,
       unsigned long *out_hwirq, unsigned int *out_type);
 ......
};

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

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

struct irqaction {
 irq_handler_t  handler; 
 void   *dev_id;  
  ......
 unsigned int  irq;  
 unsigned int  flags;  
  ......
 const char  *name;   
 struct proc_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 用于注册线程化处理的中断，线程化中断的主要目的把中断上下文的任务迁移到线程中，减少系统关中断的时间，增强系统的实时性。

static inline int __must_check
request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
        const char *name, void *dev)
{
    return request_threaded_irq(irq, handler, NULL, flags, name, dev);
}

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

#define IRQF_SHARED  0x00000080              //多个设备共享一个中断号，需要外设硬件支持
#define IRQF_PROBE_SHARED 0x00000100              //中断处理程序允许sharing mismatch发生
#define __IRQF_TIMER  0x00000200               //时钟中断
#define IRQF_PERCPU  0x00000400               //属于特定CPU的中断
#define IRQF_NOBALANCING 0x00000800               //禁止在CPU之间进行中断均衡处理
#define IRQF_IRQPOLL  0x00001000              //中断被用作轮训
#define IRQF_ONESHOT  0x00002000              //一次性触发的中断，不能嵌套，1）在硬件中断处理完成后才能打开中断；2）在中断线程化中保持关闭状态，直到该中断源上的所有thread_fn函数都执行完
#define IRQF_NO_SUSPEND  0x00004000      //系统休眠唤醒操作中，不关闭该中断
#define IRQF_FORCE_RESUME 0x00008000              //系统唤醒过程中必须强制打开该中断
#define IRQF_NO_THREAD  0x00010000      //禁止中断线程化
#define IRQF_EARLY_RESUME 0x00020000      //系统唤醒过程中在syscore阶段resume，而不用等到设备resume阶段
#define IRQF_COND_SUSPEND 0x00040000      //与NO_SUSPEND的用户共享中断时，执行本设备的中断处理函数

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

# ps -A | grep "irq/"
root          1749     2       0      0 irq_thread          0 S [irq/433-imx_drm]
root          1750     2       0      0 irq_thread          0 S [irq/439-imx_drm]
root          1751     2       0      0 irq_thread          0 S [irq/445-imx_drm]
root          1752     2       0      0 irq_thread          0 S [irq/451-imx_drm]
root          2044     2       0      0 irq_thread          0 S [irq/279-isl2902]
root          2192     2       0      0 irq_thread          0 S [irq/114-mmc0]
root          2199     2       0      0 irq_thread          0 S [irq/115-mmc1]
root          2203     2       0      0 irq_thread          0 S [irq/322-5b02000]
root          2361     2       0      0 irq_thread          0 S [irq/294-4-0051]

编辑：jq

打开APP阅读更多精彩内容