linux kernel的中断子系统之(七):GIC代码分析

作者:linuxer 发布于:2014-9-4 16:59 分类:中断子系统

一、前言

GIC(Generic Interrupt Controller)是ARM公司提供的一个通用的中断控制器,其architecture specification目前有四个版本,V1~V4(V2最多支持8个ARM core,V3/V4支持更多的ARM core,主要用于ARM64服务器系统结构)。目前在ARM官方网站只能下载到Version 2的GIC architecture specification,因此,本文主要描述符合V2规范的GIC硬件及其驱动。

具体GIC硬件的实现形态有两种,一种是在ARM vensor研发自己的SOC的时候,会向ARM公司购买GIC的IP,这些IP包括的型号有:PL390,GIC-400,GIC-500。其中GIC-500最多支持128个 cpu core,它要求ARM core必须是ARMV8指令集的(例如Cortex-A57),符合GIC architecture specification version 3。另外一种形态是ARM vensor直接购买ARM公司的Cortex A9或者A15的IP,Cortex A9或者A15中会包括了GIC的实现,当然,这些实现也是符合GIC V2的规格。

本文在进行硬件描述的时候主要是以GIC-400为目标,当然,也会顺便提及一些Cortex A9或者A15上的GIC实现。

本文主要分析了linux kernel中GIC中断控制器的驱动代码(位于drivers/irqchip/irq-gic.c和irq-gic-common.c)。 irq-gic-common.c中是GIC V2和V3的通用代码,而irq-gic.c是V2 specific的代码,irq-gic-v3.c是V3 specific的代码,不在本文的描述范围。本文主要分成三个部分:第二章描述了GIC V2的硬件;第三章描述了GIC V2的初始化过程;第四章描述了底层的硬件call back函数。

注:具体的linux kernel的版本是linux-3.17-rc3。

 

二、GIC-V2的硬件描述

1、GIC-V2的输入和输出信号

(1)GIC-V2的输入和输出信号示意图

要想理解一个building block(无论软件还是硬件),我们都可以先把它当成黑盒子,只是研究其input,output。GIC-V2的输入和输出信号的示意图如下(注:我们以GIC-400为例,同时省略了clock,config等信号):

gic-400 

(2)输入信号

上图中左边就是来自外设的interrupt source输入信号。分成两种类型,分别是PPI(Private Peripheral Interrupt)和SPI(Shared Peripheral Interrupt)。其实从名字就可以看出来两种类型中断信号的特点,PPI中断信号是CPU私有的,每个CPU都有其特定的PPI信号线。而SPI是所有CPU之间共享的。通过寄存器GICD_TYPER可以配置SPI的个数(最多480个)。GIC-400支持多少个SPI中断,其输入信号线就有多少个SPI interrupt request signal。同样的,通过寄存器GICD_TYPER也可以配置CPU interface的个数(最多8个),GIC-400支持多少个CPU interface,其输入信号线就提供多少组PPI中断信号线。一组PPI中断信号线包括6个实际的signal:

(a)nLEGACYIRQ信号线。对应interrupt ID 31,在bypass mode下(这里的bypass是指bypass GIC functionality,直接连接到某个processor上),nLEGACYIRQ可以直接连到对应CPU的nIRQCPU信号线上。在这样的设置下,该CPU不参与其他属于该CPU的PPI以及SPI中断的响应,而是特别为这一根中断线服务。

(b)nCNTPNSIRQ信号线。来自Non-secure physical timer的中断事件,对应interrupt ID 30。

(c)nCNTPSIRQ信号线。来自secure physical timer的中断事件,对应interrupt ID 29。

(d)nLEGACYFIQ信号线。对应interrupt ID 28。概念同nLEGACYIRQ信号线,不再描述。

(e)nCNTVIRQ信号线。对应interrupt ID 27。Virtual Timer Event,和虚拟化相关,这里不与描述。

(f)nCNTHPIRQ信号线。对应interrupt ID 26。Hypervisor Timer Event,和虚拟化相关,这里不与描述。

对于Cortex A15的GIC实现,其PPI中断信号线除了上面的6个,还有一个叫做Virtual Maintenance Interrupt,对应interrupt ID 25。

对于Cortex A9的GIC实现,其PPI中断信号线包括5根:

(a)nLEGACYIRQ信号线和nLEGACYFIQ信号线。对应interrupt ID 31和interrupt ID 28。这部分和上面一致。

(b)由于Cortext A9的每个处理器都有自己的Private timer和watch dog timer,这两个HW block分别使用了ID 29和ID 30

(c)Cortext A9内嵌一个global timer为系统内的所有processor共享,对应interrupt ID 27

关于private timer和global timer的描述,请参考时间子系统的相关文档。

关于一系列和虚拟化相关的中断,请参考虚拟化的系列文档。

 

(3)输出信号

所谓输出信号,其实就是GIC和各个CPU直接的接口,这些接口包括:

(a)触发CPU中断的信号。nIRQCPU和nFIQCPU信号线,熟悉ARM CPU的工程师对这两个信号线应该不陌生,主要用来触发ARM cpu进入IRQ mode和FIQ mode。

(b)Wake up信号。nFIQOUT和nIRQOUT信号线,去ARM CPU的电源管理模块,用来唤醒CPU的

(c)AXI slave interface signals。AXI(Advanced eXtensible Interface)是一种总线协议,属于AMBA规范的一部分。通过这些信号线,ARM CPU可以和GIC硬件block进行通信(例如寄存器访问)。

 

(4)中断号的分配

GIC-V2支持的中断类型有下面几种:

(a)外设中断(Peripheral interrupt)。有实际物理interrupt request signal的那些中断,上面已经介绍过了。

(b)软件触发的中断(SGI,Software-generated interrupt)。软件可以通过写GICD_SGIR寄存器来触发一个中断事件,这样的中断,可以用于processor之间的通信。

(c)虚拟中断(Virtual interrupt)和Maintenance interrupt。这两种中断和本文无关,不再赘述。

为了标识这些interrupt source,我们必须要对它们进行编码,具体的ID分配情况如下:

(a)ID0~ID31是用于分发到一个特定的process的interrupt。标识这些interrupt不能仅仅依靠ID,因为各个interrupt source都用同样的ID0~ID31来标识,因此识别这些interrupt需要interrupt ID + CPU interface number。ID0~ID15用于SGI,ID16~ID31用于PPI。PPI类型的中断会送到其私有的process上,和其他的process无关。SGI是通过写GICD_SGIR寄存器而触发的中断。Distributor通过processor source ID、中断ID和target processor ID来唯一识别一个SGI。

(b)ID32~ID1019用于SPI。 这是GIC规范的最大size,实际上GIC-400最大支持480个SPI,Cortex-A15和A9上的GIC最多支持224个SPI。

 

2、GIC-V2的内部逻辑

(1)GIC的block diagram

GIC的block diagram如下图所示:

 gic

GIC可以清晰的划分成两个block,一个block是Distributor(上图的左边的block),一个是CPU interface。CPU interface有两种,一种就是和普通processor接口,另外一种是和虚拟机接口的。Virtual CPU interface在本文中不会详细描述。

 

(2)Distributor 概述

Distributor的主要的作用是检测各个interrupt source的状态,控制各个interrupt source的行为,分发各个interrupt source产生的中断事件分发到指定的一个或者多个CPU interface上。虽然Distributor可以管理多个interrupt source,但是它总是把优先级最高的那个interrupt请求送往CPU interface。Distributor对中断的控制包括:

(1)中断enable或者disable的控制。Distributor对中断的控制分成两个级别。一个是全局中断的控制(GIC_DIST_CTRL)。一旦disable了全局的中断,那么任何的interrupt source产生的interrupt event都不会被传递到CPU interface。另外一个级别是对针对各个interrupt source进行控制(GIC_DIST_ENABLE_CLEAR),disable某一个interrupt source会导致该interrupt event不会分发到CPU interface,但不影响其他interrupt source产生interrupt event的分发。

(2)控制将当前优先级最高的中断事件分发到一个或者一组CPU interface。当一个中断事件分发到多个CPU interface的时候,GIC的内部逻辑应该保证只assert 一个CPU。

(3)优先级控制。

(4)interrupt属性设定。例如是level-sensitive还是edge-triggered

(5)interrupt group的设定

Distributor可以管理若干个interrupt source,这些interrupt source用ID来标识,我们称之interrupt ID。

 

(3)CPU interface

CPU interface这个block主要用于和process进行接口。该block的主要功能包括:

(a)enable或者disable CPU interface向连接的CPU assert中断事件。对于ARM,CPU interface block和CPU之间的中断信号线是nIRQCPU和nFIQCPU。如果disable了中断,那么即便是Distributor分发了一个中断事件到CPU interface,但是也不会assert指定的nIRQ或者nFIQ通知processor。

(b)ackowledging中断。processor会向CPU interface block应答中断(应答当前优先级最高的那个中断),中断一旦被应答,Distributor就会把该中断的状态从pending状态修改成active或者pending and active(这是和该interrupt source的信号有关,例如如果是电平中断并且保持了该asserted电平,那么就是pending and active)。processor ack了中断之后,CPU interface就会deassert nIRQCPU和nFIQCPU信号线。

(c)中断处理完毕的通知。当interrupt handler处理完了一个中断的时候,会向写CPU interface的寄存器从而通知GIC CPU已经处理完该中断。做这个动作一方面是通知Distributor将中断状态修改为deactive,另外一方面,CPU interface会priority drop,从而允许其他的pending的interrupt向CPU提交。

(d)设定priority mask。通过priority mask,可以mask掉一些优先级比较低的中断,这些中断不会通知到CPU。

(e)设定preemption的策略

(f)在多个中断事件同时到来的时候,选择一个优先级最高的通知processor

 

(4)实例

我们用一个实际的例子来描述GIC和CPU接口上的交互过程,具体过程如下:

xxx

(注:图片太长,因此竖着放,看的时候有点费劲,就当活动一下脖子吧)

首先给出前提条件:

(a)N和M用来标识两个外设中断,N的优先级大于M

(b)两个中断都是SPI类型,level trigger,active-high

(c)两个中断被配置为去同一个CPU

(d)都被配置成group 0,通过FIQ触发中断

下面的表格按照时间轴来描述交互过程:

时间 交互动作的描述
T0时刻 Distributor检测到M这个interrupt source的有效触发电平
T2时刻 Distributor将M这个interrupt source的状态设定为pending
T17时刻 大约15个clock之后,CPU interface拉低nFIQCPU信号线,向CPU报告M外设的中断请求。这时候,CPU interface的ack寄存器(GICC_IAR)的内容会修改成M interrupt source对应的ID
T42时刻 Distributor检测到N这个优先级更高的interrupt source的触发事件
T43时刻 Distributor将N这个interrupt source的状态设定为pending。同时,由于N的优先级更高,因此Distributor会标记当前优先级最高的中断
T58时刻 大约15个clock之后,CPU interface拉低nFIQCPU信号线,向CPU报告N外设的中断请求。当然,由于T17时刻已经assert CPU了,因此实际的电平信号仍然保持asserted。这时候,CPU interface的ack寄存器(GICC_IAR)的内容会被更新成N interrupt source的ID
T61时刻 软件通过读取ack寄存器的内容,获取了当前优先级最高的,并且状态是pending的interrupt ID(也就是N interrupt source对应的ID),通过读该寄存器,CPU也就ack了该interrupt source N。这时候,Distributor将N这个interrupt source的状态设定为pending and active(因为是电平触发,只要外部仍然有asserted的电平信号,那么一定就是pending的,而该中断是正在被CPU处理的中断,因此状态是pending and active)
注意:T61标识CPU开始服务该中断
T64时刻 3个clock之后,由于CPU已经ack了中断,因此GIC中CPU interface模块 deassert nFIQCPU信号线,解除发向该CPU的中断请求
T126时刻 由于中断服务程序操作了N外设的控制寄存器(ack外设的中断),因此N外设deassert了其interrupt request signal
T128时刻 Distributor解除N外设的pending状态,因此N这个interrupt source的状态设定为active
T131时刻 软件操作End of Interrupt寄存器(向GICC_EOIR寄存器写入N对应的interrupt ID),标识中断处理结束。Distributor将N这个interrupt source的状态修改为idle
注意:T61~T131是CPU服务N外设中断的的时间区域,这个期间,如果有高优先级的中断pending,会发生中断的抢占(硬件意义的),这时候CPU interface会向CPU assert 新的中断。
T146时刻 大约15个clock之后,Distributor向CPU interface报告当前pending且优先级最高的interrupt source,也就是M了。漫长的pending之后,M终于迎来了春天。CPU interface拉低nFIQCPU信号线,向CPU报告M外设的中断请求。这时候,CPU interface的ack寄存器(GICC_IAR)的内容会修改成M interrupt source对应的ID
T211时刻 CPU ack M中断(通过读GICC_IAR寄存器),开始处理低优先级的中断。

 

三、GIC-V2 irq chip driver的初始化过程

在linux-3.17-rc3\drivers\irqchip目录下保存在各种不同的中断控制器的驱动代码,这个版本的内核支持了GICV3。irq-gic-common.c是通用的GIC的驱动代码,可以被各个版本的GIC使用。irq-gic.c是用于V2版本的GIC controller,而irq-gic-v3.c是用于V3版本的GIC controller。

1、GIC的device node和GIC irq chip driver的匹配过程

(1)irq chip driver中的声明

在linux-3.17-rc3\drivers\irqchip目录下的irqchip.h文件中定义了IRQCHIP_DECLARE宏如下:

#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  }

这个宏其实就是初始化了一个struct of_device_id的静态常量,并放置在__irqchip_of_table section中。irq-gic.c文件中使用IRQCHIP_DECLARE来定义了若干个静态的struct of_device_id常量,如下:

IRQCHIP_DECLARE(gic_400, "arm,gic-400", gic_of_init);
IRQCHIP_DECLARE(cortex_a15_gic, "arm,cortex-a15-gic", gic_of_init);
IRQCHIP_DECLARE(cortex_a9_gic, "arm,cortex-a9-gic", gic_of_init);
IRQCHIP_DECLARE(cortex_a7_gic, "arm,cortex-a7-gic", gic_of_init);
IRQCHIP_DECLARE(msm_8660_qgic, "qcom,msm-8660-qgic", gic_of_init);
IRQCHIP_DECLARE(msm_qgic2, "qcom,msm-qgic2", gic_of_init);

兼容GIC-V2的GIC实现有很多,不过其初始化函数都是一个。在linux kernel编译的时候,你可以配置多个irq chip进入内核,编译系统会把所有的IRQCHIP_DECLARE宏定义的数据放入到一个特殊的section中(section name是__irqchip_of_table),我们称这个特殊的section叫做irq chip table。这个table也就保存了kernel支持的所有的中断控制器的ID信息(最重要的是驱动代码初始化函数和DT compatible string)。我们来看看struct of_device_id的定义:

struct of_device_id
{
    char    name[32];------要匹配的device node的名字
    char    type[32];-------要匹配的device node的类型
    char    compatible[128];---匹配字符串(DT compatible string),用来匹配适合的device node
    const void *data;--------对于GIC,这里是初始化函数指针
};

这个数据结构主要被用来进行Device node和driver模块进行匹配用的。从该数据结构的定义可以看出,在匹配过程中,device name、device type和DT compatible string都是考虑的因素。更细节的内容请参考__of_device_is_compatible函数。

(2)device node

不同的GIC-V2的实现总会有一些不同,这些信息可以通过Device tree的机制来传递。Device node中定义了各种属性,其中就包括了memory资源,IRQ描述等信息,这些信息需要在初始化的时候传递给具体的驱动,因此需要一个Device node和driver模块的匹配过程。在Device Tree模块中会包括系统中所有的device node,如果我们的系统使用了GIC-400,那么系统的device node数据库中会有一个node是GIC-400的,一个示例性的GIC-400的device node(我们以瑞芯微的RK3288处理器为例)定义如下:

gic: interrupt-controller@ffc01000 {
    compatible = "arm,gic-400";
    interrupt-controller;
    #interrupt-cells = <3>;
    #address-cells = <0>;

    reg = <0xffc01000 0x1000="">,----Distributor address range
          <0xffc02000 0x1000="">,-----CPU interface address range
          <0xffc04000 0x2000="">,-----Virtual interface control block
          <0xffc06000 0x2000="">;-----Virtual CPU interfaces
    interrupts = ;
};

 

(3)device node和irq chip driver的匹配

在machine driver初始化的时候会调用irqchip_init函数进行irq chip driver的初始化。在driver/irqchip/irqchip.c文件中定义了irqchip_init函数,如下:

 

void __init irqchip_init(void)
{
    of_irq_init(__irqchip_begin);
}

__irqchip_begin就是内核irq chip table的首地址,这个table也就保存了kernel支持的所有的中断控制器的ID信息(用于和device node的匹配)。of_irq_init函数执行之前,系统已经完成了device tree的初始化,因此系统中的所有的设备节点都已经形成了一个树状结构,每个节点代表一个设备的device node。of_irq_init是在所有的device node中寻找中断控制器节点,形成树状结构(系统可以有多个interrupt controller,之所以形成中断控制器的树状结构,是为了让系统中所有的中断控制器驱动按照一定的顺序进行初始化)。之后,从root interrupt controller节点开始,对于每一个interrupt controller的device node,扫描irq chip table,进行匹配,一旦匹配到,就调用该interrupt controller的初始化函数,并把该中断控制器的device node以及parent中断控制器的device node作为参数传递给irq chip driver。。具体的匹配过程的代码属于Device Tree模块的内容,更详细的信息可以参考Device Tree代码分析文档

 

2、GIC driver初始化代码分析

(1)gic_of_init的代码如下:

int __init gic_of_init(struct device_node *node, struct device_node *parent)
{
    void __iomem *cpu_base;
    void __iomem *dist_base;
    u32 percpu_offset;
    int irq;

    dist_base = of_iomap(node, 0);----------------映射GIC Distributor的寄存器地址空间

    cpu_base = of_iomap(node, 1);----------------映射GIC CPU interface的寄存器地址空间

    if (of_property_read_u32(node, "cpu-offset", &percpu_offset))--------处理cpu-offset属性。
        percpu_offset = 0;

    gic_init_bases(gic_cnt, -1, dist_base, cpu_base, percpu_offset, node);))-----主处理过程,后面详述
    if (!gic_cnt)
        gic_init_physaddr(node); -----对于不支持big.LITTLE switcher(CONFIG_BL_SWITCHER)的系统,该函数为空。

    if (parent) {--------处理interrupt级联
        irq = irq_of_parse_and_map(node, 0); ---解析second GIC的interrupts属性,并进行mapping,返回IRQ number
        gic_cascade_irq(gic_cnt, irq);
    }
    gic_cnt++;
    return 0;
}

我们首先看看这个函数的参数,node参数代表需要初始化的那个interrupt controller的device node,parent参数指向其parent。在映射GIC-400的memory map I/O space的时候,我们只是映射了Distributor和CPU interface的寄存器地址空间,和虚拟化处理相关的寄存器没有映射,因此这个版本的GIC driver应该是不支持虚拟化的(不知道后续版本是否支持,在一个嵌入式平台上支持虚拟化有实际意义吗?最先支持虚拟化的应该是ARM64+GICV3/4这样的平台)。

要了解cpu-offset属性,首先要了解什么是banked register。所谓banked register就是在一个地址上提供多个寄存器副本。比如说系统中有四个CPU,这些CPU访问某个寄存器的时候地址是一样的,但是对于banked register,实际上,不同的CPU访问的是不同的寄存器,虽然它们的地址是一样的。如果GIC没有banked register,那么需要提供根据CPU index给出一系列地址偏移,而地址偏移=cpu-offset * cpu-nr。

interrupt controller可以级联。对于root GIC,其传入的parent是NULL,因此不会执行级联部分的代码。对于second GIC,它是作为其parent(root GIC)的一个普通的irq source,因此,也需要注册该IRQ的handler。由此可见,非root的GIC的初始化分成了两个部分:一部分是作为一个interrupt controller,执行和root GIC一样的初始化代码。另外一方面,GIC又作为一个普通的interrupt generating device,需要象一个普通的设备驱动一样,注册其中断handler。理解irq_of_parse_and_map需要irq domain的知识,请参考linux kernel的中断子系统之(二):irq domain介绍

 

(2)gic_init_bases的代码如下:

void __init gic_init_bases(unsigned int gic_nr, int irq_start,
               void __iomem *dist_base, void __iomem *cpu_base,
               u32 percpu_offset, struct device_node *node)
{
    irq_hw_number_t hwirq_base;
    struct gic_chip_data *gic;
    int gic_irqs, irq_base, i;

    gic = &gic_data[gic_nr]; 
    gic->dist_base.common_base = dist_base; ----省略了non banked的情况
    gic->cpu_base.common_base = cpu_base; 
    gic_set_base_accessor(gic, gic_get_common_base);


    for (i = 0; i < NR_GIC_CPU_IF; i++) ---后面会具体描述gic_cpu_map的含义
        gic_cpu_map[i] = 0xff;


    if (gic_nr == 0 && (irq_start & 31) > 0) { --------------------(a)
        hwirq_base = 16;
        if (irq_start != -1)
            irq_start = (irq_start & ~31) + 16;
    } else {
        hwirq_base = 32;
    }


    gic_irqs = readl_relaxed(gic_data_dist_base(gic) + GIC_DIST_CTR) & 0x1f; ----(b)
    gic_irqs = (gic_irqs + 1) * 32;
    if (gic_irqs > 1020)
        gic_irqs = 1020;
    gic->gic_irqs = gic_irqs;

    gic_irqs -= hwirq_base;----------------------------(c)
   

    if (of_property_read_u32(node, "arm,routable-irqs",----------------(d)
                 &nr_routable_irqs)) {
        irq_base = irq_alloc_descs(irq_start, 16, gic_irqs,  numa_node_id()); -------(e)
        if (IS_ERR_VALUE(irq_base)) {
            WARN(1, "Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
                 irq_start);
            irq_base = irq_start;
        }

        gic->domain = irq_domain_add_legacy(node, gic_irqs, irq_base, -------(f)
                    hwirq_base, &gic_irq_domain_ops, gic);
    } else {
        gic->domain = irq_domain_add_linear(node, nr_routable_irqs, --------(f)
                            &gic_irq_domain_ops,
                            gic);
    }

    if (gic_nr == 0) { ---只对root GIC操作,因为设定callback、注册Notifier只需要一次就OK了
#ifdef CONFIG_SMP
        set_smp_cross_call(gic_raise_softirq);------------------(g)
        register_cpu_notifier(&gic_cpu_notifier);------------------(h)
#endif
        set_handle_irq(gic_handle_irq); ---这个函数名字也不好,实际上是设定arch相关的irq handler
    }

    gic_chip.flags |= gic_arch_extn.flags;
    gic_dist_init(gic);---------具体的硬件初始代码,参考下节的描述
    gic_cpu_init(gic);
    gic_pm_init(gic);
}

(a)gic_nr标识GIC number,等于0就是root GIC。hwirq的意思就是GIC上的HW interrupt ID,并不是GIC上的每个interrupt ID都有map到linux IRQ framework中的一个IRQ number,对于SGI,是属于软件中断,用于CPU之间通信,没有必要进行HW interrupt ID到IRQ number的mapping。变量hwirq_base表示该GIC上要进行map的base ID,hwirq_base = 16也就意味着忽略掉16个SGI。对于系统中其他的GIC,其PPI也没有必要mapping,因此hwirq_base = 32。

在本场景中,irq_start = -1,表示不指定IRQ number。有些场景会指定IRQ number,这时候,需要对IRQ number进行一个对齐的操作。

(b)变量gic_irqs保存了该GIC支持的最大的中断数目。该信息是从GIC_DIST_CTR寄存器(这是V1版本的寄存器名字,V2中是GICD_TYPER,Interrupt Controller Type Register,)的低五位ITLinesNumber获取的。如果ITLinesNumber等于N,那么最大支持的中断数目是32(N+1)。此外,GIC规范规定最大的中断数目不能超过1020,1020-1023是有特别用户的interrupt ID。

(c)减去不需要map(不需要分配IRQ)的那些interrupt ID,OK,这时候gic_irqs的数值终于和它的名字一致了。gic_irqs从字面上看不就是该GIC需要分配的IRQ number的数目吗?

(d)of_property_read_u32函数把arm,routable-irqs的属性值读出到nr_routable_irqs变量中,如果正确返回0。在有些SOC的设计中,外设的中断请求信号线不是直接接到GIC,而是通过crossbar/multiplexer这个的HW block连接到GIC上。arm,routable-irqs这个属性用来定义那些不直接连接到GIC的中断请求数目。

(e)对于那些直接连接到GIC的情况,我们需要通过调用irq_alloc_descs分配中断描述符。如果irq_start大于0,那么说明是指定IRQ number的分配,对于我们这个场景,irq_start等于-1,因此不指定IRQ 号。如果不指定IRQ number的,就需要搜索,第二个参数16就是起始搜索的IRQ number。gic_irqs指明要分配的irq number的数目。如果没有正确的分配到中断描述符,程序会认为可能是之前已经准备好了。

(f)这段代码主要是向系统中注册一个irq domain的数据结构。为何需要struct irq_domain这样一个数据结构呢?从linux kernel的角度来看,任何外部的设备的中断都是一个异步事件,kernel都需要识别这个事件。在内核中,用IRQ number来标识某一个设备的某个interrupt request。有了IRQ number就可以定位到该中断的描述符(struct irq_desc)。但是,对于中断控制器而言,它不并知道IRQ number,它只是知道HW interrupt number(中断控制器会为其支持的interrupt source进行编码,这个编码被称为Hardware interrupt number )。不同的软件模块用不同的ID来识别interrupt source,这样就需要映射了。如何将Hardware interrupt number 映射到IRQ number呢?这需要一个translation object,内核定义为struct irq_domain。

每个interrupt controller都会形成一个irq domain,负责解析其下游的interrut source。如果interrupt controller有级联的情况,那么一个非root interrupt controller的中断控制器也是其parent irq domain的一个普通的interrupt source。struct irq_domain定义如下:

struct irq_domain {
……
    const struct irq_domain_ops *ops;
    void *host_data;

……
};

这个数据结构是属于linux kernel通用中断子系统的一部分,我们这里只是描述相关的数据成员。host_data成员是底层interrupt controller的私有数据,linux kernel通用中断子系统不应该修改它。对于GIC而言,host_data成员指向一个struct gic_chip_data的数据结构,定义如下:

struct gic_chip_data {
    union gic_base dist_base;------------------GIC Distributor的基地址空间
    union gic_base cpu_base;------------------GIC CPU interface的基地址空间
#ifdef CONFIG_CPU_PM--------------------GIC 电源管理相关的成员
    u32 saved_spi_enable[DIV_ROUND_UP(1020, 32)];
    u32 saved_spi_conf[DIV_ROUND_UP(1020, 16)];
    u32 saved_spi_target[DIV_ROUND_UP(1020, 4)];
    u32 __percpu *saved_ppi_enable;
    u32 __percpu *saved_ppi_conf;
#endif
    struct irq_domain *domain;-----------------该GIC对应的irq domain数据结构
    unsigned int gic_irqs;-------------------GIC支持的IRQ的数目
#ifdef CONFIG_GIC_NON_BANKED
    void __iomem *(*get_base)(union gic_base *);
#endif
};

对于GIC支持的IRQ的数目,这里还要赘述几句。实际上并非GIC支持多少个HW interrupt ID,其就支持多少个IRQ。对于SGI,其处理比较特别,并不归入IRQ number中。因此,对于GIC而言,其SGI(从0到15的那些HW interrupt ID)不需要irq domain进行映射处理,也就是说SGI没有对应的IRQ number。如果系统越来越复杂,一个GIC不能支持所有的interrupt source(目前GIC支持1020个中断源,这个数目已经非常的大了),那么系统还需要引入secondary GIC,这个GIC主要负责扩展外设相关的interrupt source,也就是说,secondary GIC的SGI和PPI都变得冗余了(这些功能,primary GIC已经提供了)。这些信息可以协助理解代码中的hwirq_base的设定。

在注册GIC的irq domain的时候还有一个重要的数据结构gic_irq_domain_ops,其类型是struct irq_domain_ops ,对于GIC,其irq domain的操作函数是gic_irq_domain_ops,定义如下:

static const struct irq_domain_ops gic_irq_domain_ops = {
    .map = gic_irq_domain_map,
    .unmap = gic_irq_domain_unmap,
    .xlate = gic_irq_domain_xlate,
};

irq domain的概念是一个通用中断子系统的概念,在具体的irq chip driver这个层次,我们需要一些解析GIC binding,创建IRQ number和HW interrupt ID的mapping的callback函数,更具体的解析参考后文的描述。

漫长的准备过程结束后,具体的注册比较简单,调用irq_domain_add_legacy或者irq_domain_add_linear进行注册就OK了。关于这两个接口请参考linux kernel的中断子系统之(二):irq domain介绍

(g) 一个函数名字是否起的好足可以看出工程师的功力。set_smp_cross_call这个函数看名字也知道它的含义,就是设定一个多个CPU直接通信的callback函数。当一个CPU core上的软件控制行为需要传递到其他的CPU上的时候(例如在某一个CPU上运行的进程调用了系统调用进行reboot),就会调用这个callback函数。对于GIC,这个callback定义为gic_raise_softirq。这个函数名字起的不好,直观上以为是和softirq相关,实际上其实是触发了IPI中断。

(h)在multi processor环境下,当processor状态发送变化的时候(例如online,offline),需要把这些事件通知到GIC。而GIC driver在收到来自CPU的事件后会对cpu interface进行相应的设定。

 

3、GIC硬件初始化

(1)Distributor初始化,代码如下:

static void __init gic_dist_init(struct gic_chip_data *gic)
{
    unsigned int i;
    u32 cpumask;
    unsigned int gic_irqs = gic->gic_irqs;---------获取该GIC支持的IRQ的数目
    void __iomem *base = gic_data_dist_base(gic); ----获取该GIC对应的Distributor基地址

    writel_relaxed(0, base + GIC_DIST_CTRL); -----------(a)


    cpumask = gic_get_cpumask(gic);---------------(b)
    cpumask |= cpumask << 8;
    cpumask |= cpumask << 16;------------------(c)
    for (i = 32; i < gic_irqs; i += 4)
        writel_relaxed(cpumask, base + GIC_DIST_TARGET + i * 4 / 4); --(d)

    gic_dist_config(base, gic_irqs, NULL); ---------------(e)

    writel_relaxed(1, base + GIC_DIST_CTRL);-------------(f)
}

(a)Distributor Control Register用来控制全局的中断forward情况。写入0表示Distributor不向CPU interface发送中断请求信号,也就disable了全部的中断请求(group 0和group 1),CPU interace再也收不到中断请求信号了。在初始化的最后,step(f)那里会进行enable的动作(这里只是enable了group 0的中断)。在初始化代码中,并没有设定interrupt source的group(寄存器是GIC_DIST_IGROUP),我相信缺省值就是设定为group 0的。

(b)我们先看看gic_get_cpumask的代码:

static u8 gic_get_cpumask(struct gic_chip_data *gic)
{
    void __iomem *base = gic_data_dist_base(gic);
    u32 mask, i;

    for (i = mask = 0; i < 32; i += 4) {
        mask = readl_relaxed(base + GIC_DIST_TARGET + i);
        mask |= mask >> 16;
        mask |= mask >> 8;
        if (mask)
            break;
    }

    return mask;
}

这里操作的寄存器是Interrupt Processor Targets Registers,该寄存器组中,每个GIC上的interrupt ID都有8个bit来控制送达的target CPU。我们来看看下面的图片:

cpu mask

GIC_DIST_TARGETn(Interrupt Processor Targets Registers)位于Distributor HW block中,能控制送达的CPU interface,并不是具体的CPU,如果具体的实现中CPU interface和CPU是严格按照上图中那样一一对应,那么GIC_DIST_TARGET送达了CPU Interface n,也就是送达了CPU n。当然现实未必如你所愿,那么怎样来获取这个CPU的mask呢?我们知道SGI和PPI不需要使用GIC_DIST_TARGET控制target CPU。SGI送达目标CPU有自己特有的寄存器来控制(Software Generated Interrupt Register),对于PPI,其是CPU私有的,因此不需要控制target CPU。GIC_DIST_TARGET0~GIC_DIST_TARGET7是控制0~31这32个interrupt ID(SGI和PPI)的target CPU的,但是实际上SGI和PPI是不需要控制target CPU的,因此,这些寄存器是read only的,读取这些寄存器返回的就是cpu mask值。假设CPU0接在CPU interface 4上,那么运行在CPU 0上的程序在读GIC_DIST_TARGET0~GIC_DIST_TARGET7的时候,返回的就是0b00010000。

当然,由于GIC-400只支持8个CPU,因此CPU mask值只需要8bit,但是寄存器GIC_DIST_TARGETn返回32个bit的值,怎么对应?很简单,cpu mask重复四次就OK了。了解了这些知识,回头看代码就很简单了。

(c)step (b)中获取了8个bit的cpu mask值,通过简单的copy,扩充为32个bit,每8个bit都是cpu mask的值,这么做是为了下一步设定所有IRQ(对于GIC而言就是SPI类型的中断)的CPU mask。

(d)设定每个SPI类型的中断都是只送达该CPU。

(e)配置GIC distributor的其他寄存器,代码如下:

void __init gic_dist_config(void __iomem *base, int gic_irqs,  void (*sync_access)(void))
{
    unsigned int i;

    /* Set all global interrupts to be level triggered, active low.    */
    for (i = 32; i < gic_irqs; i += 16)
        writel_relaxed(0, base + GIC_DIST_CONFIG + i / 4);

    /* Set priority on all global interrupts.   */
    for (i = 32; i < gic_irqs; i += 4)
        writel_relaxed(0xa0a0a0a0, base + GIC_DIST_PRI + i);

    /* Disable all interrupts.  Leave the PPI and SGIs alone as they are enabled by redistributor registers.    */
    for (i = 32; i < gic_irqs; i += 32)
        writel_relaxed(0xffffffff, base + GIC_DIST_ENABLE_CLEAR + i / 8);

    if (sync_access)
        sync_access();
}

程序的注释已经非常清楚了,这里就不细述了。需要注意的是:这里设定的都是缺省值,实际上,在各种driver的初始化过程中,还是有可能改动这些设置的(例如触发方式)。

 

(2)CPU interface初始化,代码如下:

static void gic_cpu_init(struct gic_chip_data *gic)
{
    void __iomem *dist_base = gic_data_dist_base(gic);-------Distributor的基地址空间
    void __iomem *base = gic_data_cpu_base(gic);-------CPU interface的基地址空间
    unsigned int cpu_mask, cpu = smp_processor_id();------获取CPU的逻辑ID
    int i;


    cpu_mask = gic_get_cpumask(gic);-------------(a)
    gic_cpu_map[cpu] = cpu_mask;


    for (i = 0; i < NR_GIC_CPU_IF; i++)
        if (i != cpu)
            gic_cpu_map[i] &= ~cpu_mask; ------------(b)

    gic_cpu_config(dist_base, NULL); --------------(c)

    writel_relaxed(0xf0, base + GIC_CPU_PRIMASK);-------(d)
    writel_relaxed(1, base + GIC_CPU_CTRL);-----------(e)
}

(a)系统软件实际上是使用CPU 逻辑ID这个概念的,通过smp_processor_id可以获得本CPU的逻辑ID。gic_cpu_map这个全部lookup table就是用CPU 逻辑ID作为所以,去寻找其cpu mask,后续通过cpu mask值来控制中断是否送达该CPU。在gic_init_bases函数中,我们将该lookup table中的值都初始化为0xff,也就是说不进行mask,送达所有的CPU。这里,我们会进行重新修正。

(b)清除lookup table中其他entry中本cpu mask的那个bit。

(c)设定SGI和PPI的初始值。具体代码如下:

void gic_cpu_config(void __iomem *base, void (*sync_access)(void))
{
    int i;

    /* Deal with the banked PPI and SGI interrupts - disable all
     * PPI interrupts, ensure all SGI interrupts are enabled.     */
    writel_relaxed(0xffff0000, base + GIC_DIST_ENABLE_CLEAR);
    writel_relaxed(0x0000ffff, base + GIC_DIST_ENABLE_SET);

    /* Set priority on PPI and SGI interrupts    */
    for (i = 0; i < 32; i += 4)
        writel_relaxed(0xa0a0a0a0, base + GIC_DIST_PRI + i * 4 / 4);

    if (sync_access)
        sync_access();
}

程序的注释已经非常清楚了,这里就不细述了。

(d)通过Distributor中的寄存器可以控制送达CPU interface,中断来到了GIC的CPU interface是否可以真正送达CPU呢?也不一定,还有一道关卡,也就是CPU interface中的Interrupt Priority Mask Register。这个寄存器设定了一个中断优先级的值,只有中断优先级高过该值的中断请求才会被送到CPU上去。我们在前面初始化的时候,给每个interrupt ID设定的缺省优先级是0xa0,这里设定的priority filter的优先级值是0xf0。数值越小,优先级越过。因此,这样的设定就是让所有的interrupt source都可以送达CPU,在CPU interface这里不做控制了。

(e)设定CPU interface的control register。enable了group 0的中断,disable了group 1的中断,group 0的interrupt source触发IRQ中断(而不是FIQ中断)。

 

(3)GIC电源管理初始化,代码如下:

static void __init gic_pm_init(struct gic_chip_data *gic)
{
    gic->saved_ppi_enable = __alloc_percpu(DIV_ROUND_UP(32, 32) * 4, sizeof(u32));

    gic->saved_ppi_conf = __alloc_percpu(DIV_ROUND_UP(32, 16) * 4,  sizeof(u32));

    if (gic == &gic_data[0])
        cpu_pm_register_notifier(&gic_notifier_block);
}

这段代码前面主要是分配两个per cpu的内存。这些内存在系统进入sleep状态的时候保存PPI的寄存器状态信息,在resume的时候,写回寄存器。对于root GIC,需要注册一个和电源管理的事件通知callback函数。不得不吐槽一下gic_notifier_block和gic_notifier这两个符号的命名,看不出来和电源管理有任何关系。更优雅的名字应该包括pm这样的符号,以便让其他工程师看到名字就立刻知道是和电源管理相关的。

 

四、GIC callback函数分析

1、irq domain相关callback函数分析

irq domain相关callback函数包括:

(1)gic_irq_domain_map函数:创建IRQ number和GIC hw interrupt ID之间映射关系的时候,需要调用该回调函数。具体代码如下:

static int gic_irq_domain_map(struct irq_domain *d, unsigned int irq, irq_hw_number_t hw)
{
    if (hw < 32) {------------------SGI或者PPI
        irq_set_percpu_devid(irq);--------------------------(a)
        irq_set_chip_and_handler(irq, &gic_chip, handle_percpu_devid_irq);-------(b)
        set_irq_flags(irq, IRQF_VALID | IRQF_NOAUTOEN);--------------(c)
    } else {
        irq_set_chip_and_handler(irq, &gic_chip, handle_fasteoi_irq);----------(d)
        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);

        gic_routable_irq_domain_ops->map(d, irq, hw);----------------(e)
    }
    irq_set_chip_data(irq, d->host_data);-----设定irq chip的私有数据
    return 0;
}

(a)SGI或者PPI和SPI最大的不同是per cpu的,SPI是所有CPU共享的,因此需要分配per cpu的内存,设定一些per cpu的flag。

(b)设定该中断描述符的irq chip和high level的handler

(c)设定irq flag是有效的(因为已经设定好了chip和handler了),并且request后不是auto enable的。

(d)对于SPI,设定的high level irq event handler是handle_fasteoi_irq。对于SPI,是可以probe,并且request后是auto enable的。

(e)有些SOC会在各种外设中断和GIC之间增加cross bar(例如TI的OMAP芯片),这里是为那些ARM SOC准备的

 

(2)gic_irq_domain_unmap是gic_irq_domain_map的逆过程也就是解除IRQ number和GIC hw interrupt ID之间映射关系的时候,需要调用该回调函数。

(3)gic_irq_domain_xlate函数:除了标准的属性之外,各个具体的interrupt controller可以定义自己的device binding。这些device bindings都需在irq chip driver这个层面进行解析。要给定某个外设的device tree node 和interrupt specifier,该函数可以解码出该设备使用的hw interrupt ID和linux irq type value 。具体的代码如下:

static int gic_irq_domain_xlate(struct irq_domain *d,
                struct device_node *controller,
                const u32 *intspec, unsigned int intsize,--------输入参数
                unsigned long *out_hwirq, unsigned int *out_type)----输出参数
{
    unsigned long ret = 0; 
    *out_hwirq = intspec[1] + 16; ---------------------(a)

    *out_type = intspec[2] & IRQ_TYPE_SENSE_MASK; -----------(b)

    return ret;
}

(a)根据gic binding文档的描述,其interrupt specifier包括3个cell,分别是interrupt type(0 表示SPI,1表示PPI),interrupt number(对于PPI,范围是[0-15],对于SPI,范围是[0-987]),interrupt flag(触发方式)。GIC interrupt specifier中的interrupt number需要加上16(也就是加上SGI的那些ID号),才能转换成GIC的HW interrupt ID。

(b)取出bits[3:0]的信息,这些bits保存了触发方式的信息

 

2、电源管理的callback函数

TODO

 

3、irq chip回调函数分析

(1)gic_mask_irq函数

这个函数用来mask一个interrupt source。代码如下:

static void gic_mask_irq(struct irq_data *d)
{
    u32 mask = 1 << (gic_irq(d) % 32);

    raw_spin_lock(&irq_controller_lock);
    writel_relaxed(mask, gic_dist_base(d) + GIC_DIST_ENABLE_CLEAR + (gic_irq(d) / 32) * 4);
    if (gic_arch_extn.irq_mask)
        gic_arch_extn.irq_mask(d);
    raw_spin_unlock(&irq_controller_lock);
}

GIC有若干个叫做Interrupt Clear-Enable Registers(具体数目是和GIC支持的hw interrupt数目相关,我们前面说过的,GIC是一个高度可配置的interrupt controller)。这些Interrupt Clear-Enable Registers寄存器的每个bit可以控制一个interrupt source是否forward到CPU interface,写入1表示Distributor不再forward该interrupt,因此CPU也就感知不到该中断,也就是mask了该中断。特别需要注意的是:写入0无效,而不是unmask的操作。

由于不同的SOC厂商在集成GIC的时候可能会修改,也就是说,也有可能mask的代码要微调,这是通过gic_arch_extn这个全局变量实现的。在gic-irq.c中这个变量的全部成员都设定为NULL,各个厂商在初始中断控制器的时候可以设定其特定的操作函数。

(2)gic_unmask_irq函数

这个函数用来unmask一个interrupt source。代码如下:

static void gic_unmask_irq(struct irq_data *d)
{
    u32 mask = 1 << (gic_irq(d) % 32);

    raw_spin_lock(&irq_controller_lock);
    if (gic_arch_extn.irq_unmask)
        gic_arch_extn.irq_unmask(d);
    writel_relaxed(mask, gic_dist_base(d) + GIC_DIST_ENABLE_SET + (gic_irq(d) / 32) * 4);
    raw_spin_unlock(&irq_controller_lock);
}

GIC有若干个叫做Interrupt Set-Enable Registers的寄存器。这些寄存器的每个bit可以控制一个interrupt source。当写入1的时候,表示Distributor会forward该interrupt到CPU interface,也就是意味这unmask了该中断。特别需要注意的是:写入0无效,而不是mask的操作。

(3)gic_eoi_irq函数

当processor处理中断的时候就会调用这个函数用来结束中断处理。代码如下:

static void gic_eoi_irq(struct irq_data *d)
{
    if (gic_arch_extn.irq_eoi) {
        raw_spin_lock(&irq_controller_lock);
        gic_arch_extn.irq_eoi(d);
        raw_spin_unlock(&irq_controller_lock);
    }

    writel_relaxed(gic_irq(d), gic_cpu_base(d) + GIC_CPU_EOI);
}

对于GIC而言,其中断状态有四种:

中断状态 描述
Inactive 中断未触发状态,该中断即没有Pending也没有Active
Pending 由于外设硬件产生了中断事件(或者软件触发)该中断事件已经通过硬件信号通知到GIC,等待GIC分配的那个CPU进行处理
Active CPU已经应答(acknowledge)了该interrupt请求,并且正在处理中
Active and Pending 当一个中断源处于Active状态的时候,同一中断源又触发了中断,进入pending状态

processor ack了一个中断后,该中断会被设定为active。当处理完成后,仍然要通知GIC,中断已经处理完毕了。这时候,如果没有pending的中断,GIC就会将该interrupt设定为inactive状态。操作GIC中的End of Interrupt Register可以完成end of interrupt事件通知。

(4)gic_set_type函数

这个函数用来设定一个interrupt source的type,例如是level sensitive还是edge triggered。代码如下:

static int gic_set_type(struct irq_data *d, unsigned int type)
{
    void __iomem *base = gic_dist_base(d);
    unsigned int gicirq = gic_irq(d);
    u32 enablemask = 1 << (gicirq % 32);
    u32 enableoff = (gicirq / 32) * 4;
    u32 confmask = 0x2 << ((gicirq % 16) * 2);
    u32 confoff = (gicirq / 16) * 4;
    bool enabled = false;
    u32 val;

    /* Interrupt configuration for SGIs can't be changed */
    if (gicirq < 16)
        return -EINVAL;

    if (type != IRQ_TYPE_LEVEL_HIGH && type != IRQ_TYPE_EDGE_RISING)
        return -EINVAL;

    raw_spin_lock(&irq_controller_lock);

    if (gic_arch_extn.irq_set_type)
        gic_arch_extn.irq_set_type(d, type);

    val = readl_relaxed(base + GIC_DIST_CONFIG + confoff);
    if (type == IRQ_TYPE_LEVEL_HIGH)
        val &= ~confmask;
    else if (type == IRQ_TYPE_EDGE_RISING)
        val |= confmask;

    /*
     * As recommended by the spec, disable the interrupt before changing
     * the configuration
     */
    if (readl_relaxed(base + GIC_DIST_ENABLE_SET + enableoff) & enablemask) {
        writel_relaxed(enablemask, base + GIC_DIST_ENABLE_CLEAR + enableoff);
        enabled = true;
    }

    writel_relaxed(val, base + GIC_DIST_CONFIG + confoff);

    if (enabled)
        writel_relaxed(enablemask, base + GIC_DIST_ENABLE_SET + enableoff);

    raw_spin_unlock(&irq_controller_lock);

    return 0;
}

对于SGI类型的interrupt,是不能修改其type的,因为GIC中SGI固定就是edge-triggered。对于GIC,其type只支持高电平触发(IRQ_TYPE_LEVEL_HIGH)和上升沿触发(IRQ_TYPE_EDGE_RISING)的中断。另外需要注意的是,在更改其type的时候,先disable,然后修改type,然后再enable。

(5)gic_retrigger

这个接口用来resend一个IRQ到CPU。

static int gic_retrigger(struct irq_data *d)
{
    if (gic_arch_extn.irq_retrigger)
        return gic_arch_extn.irq_retrigger(d);

    /* the genirq layer expects 0 if we can't retrigger in hardware */
    return 0;
}

看起来这是功能不是通用GIC拥有的功能,各个厂家在集成GIC的时候,有可能进行功能扩展。

(6)gic_set_affinity

在多处理器的环境下,外部设备产生了一个中断就需要送到一个或者多个处理器去,这个设定是通过设定处理器的affinity进行的。具体代码如下:

static int gic_set_affinity(struct irq_data *d, const struct cpumask *mask_val,    bool force)
{
    void __iomem *reg = gic_dist_base(d) + GIC_DIST_TARGET + (gic_irq(d) & ~3);
    unsigned int cpu, shift = (gic_irq(d) % 4) * 8;
    u32 val, mask, bit;

    if (!force)
        cpu = cpumask_any_and(mask_val, cpu_online_mask);---随机选取一个online的cpu
    else
        cpu = cpumask_first(mask_val); --------选取mask中的第一个cpu,不管是否online

    raw_spin_lock(&irq_controller_lock);
    mask = 0xff << shift;
    bit = gic_cpu_map[cpu] << shift;-------将CPU的逻辑ID转换成要设定的cpu mask
    val = readl_relaxed(reg) & ~mask;
    writel_relaxed(val | bit, reg);
    raw_spin_unlock(&irq_controller_lock);

    return IRQ_SET_MASK_OK;
}

GIC Distributor中有一个寄存器叫做Interrupt Processor Targets Registers,这个寄存器用来设定制定的中断送到哪个process去。由于GIC最大支持8个process,因此每个hw interrupt ID需要8个bit来表示送达的process。每一个Interrupt Processor Targets Registers由32个bit组成,因此每个Interrupt Processor Targets Registers可以表示4个HW interrupt ID的affinity,因此上面的代码中的shift就是计算该HW interrupt ID在寄存器中的偏移。

(7)gic_set_wake

这个接口用来设定唤醒CPU的interrupt source。对于GIC,代码如下:

static int gic_set_wake(struct irq_data *d, unsigned int on)
{
    int ret = -ENXIO;

    if (gic_arch_extn.irq_set_wake)
        ret = gic_arch_extn.irq_set_wake(d, on);

    return ret;
}

设定唤醒的interrupt和具体的厂商相关,这里不再赘述。


4、BSP(bootstrap processor)之外,其他CPU的callback函数

对于multi processor系统,不可能初始化代码在所有的processor上都执行一遍,实际上,系统的硬件会选取一个processor作为引导处理器,我们称之BSP。这个processor会首先执行,其他的CPU都是处于reset状态,等到BSP初始化完成之后,release所有的non-BSP,这时候,系统中的各种外设硬件条件和软件条件(例如per CPU变量)都准备好了,各个non-BSP执行自己CPU specific的初始化就OK了。

上面描述的都是BSP的初始化过程,具体包括:

……
    gic_dist_init(gic);------初始化GIC的Distributor
    gic_cpu_init(gic);------初始化BSP的CPU interface
    gic_pm_init(gic);------初始化GIC的Power management
……

对于GIC的Distributor和Power management,这两部分是全局性的,BSP执行初始化一次就OK了。对于CPU interface,每个processor负责初始化自己的连接的那个CPU interface HW block。我们用下面这个图片来描述这个过程:

booting

  假设CPUx被选定为BSP,那么第三章描述的初始化过程在该CPU上欢畅的执行。这时候,被初始化的GIC硬件包括:root GIC的Distributor、root GIC CPU Interface x(连接BSP的那个CPU interface)以及其他的级联的非root GIC(上图中绿色block,当然,我偷懒,没有画non-root GIC)。

BSP初始化完成之后,各个其他的CPU运行起来,会发送CPU_STARTING消息给关注该消息的模块。毫无疑问,GIC driver模块当然要关注这样的消息,在初始化过程中会注册callback函数如下:

register_cpu_notifier(&gic_cpu_notifier);

GIC相关的回调函数定义如下:

static struct notifier_block gic_cpu_notifier = {
    .notifier_call = gic_secondary_init,
    .priority = 100,
};

static int gic_secondary_init(struct notifier_block *nfb, unsigned long action,  void *hcpu)
{
    if (action == CPU_STARTING || action == CPU_STARTING_FROZEN)
        gic_cpu_init(&gic_data[0]);---------初始化那些非BSP的CPU interface
    return NOTIFY_OK;
}

因此,当non-BSP booting up的时候,发送CPU_STARTING消息,调用GIC的callback函数,对上图中的紫色的CPU Interface HW block进行初始化,这样,就完成了全部GIC硬件的初始化过程。


Change log:
11月3号,修改包括:
1、使用GIC-V2这样更通用的描述,而不是仅仅GIC-400

 

原创文章,转发请注明出处。蜗窝科技,http://www.wowotech.net/linux_kenrel/gic_driver.html

标签: GIC 代码分析

评论:

甲乙丙丁
2016-12-16 23:53
既然GIC只支持高电平和上升沿种中断模式,那么外设的低电平触发中断和下降沿触发中断是怎么处理,是由什么硬件将其翻转为GIC支持的高电平和上升沿信号吗?
wowo
2017-01-04 08:39
@甲乙丙丁:文章中只是说“SGI只支持高电平触发”,其它的还是没有问题的。
zcjfish
2016-06-22 11:14
你好,请问PPI 中断的使用场景都有哪些? 或者说什么样的中断适合走PPI中断?
linuxer
2016-06-23 09:10
@zcjfish:PPI适合per cpu的中断,也就是说,如果一个中断只是送达本CPU,并且每个CPU都有这样的一格外设中断,那么该中断适合PPI。例如,per cpu local timer hw block的中断。
CANAAN
2016-06-15 20:33
博主您好,谢谢写出这么好的文章!我想请教一下,SGI跟软中断有什么联系和区别?如果是一个东西,那么SGI那16个中断号就是软中断的中断号(HI_SOFTIRQ,TIMER_SOFTIRQ等等)?如果有区别,我通过GIC相应寄存器去配置跟触发SGI后,SGI的中断服务程序在哪,硬中断尚且可以在request_irq里指定。
hello_world
2016-06-16 09:09
@CANAAN:SGI是一个硬件概念
softirq是一个linux kernel中的软件机制
这两种东西完全无关的
CANAAN
2016-06-16 14:35
@hello_world:@hello_world,谢谢您的回复,我有点明白了。那SGI就是ipi?想在Linux kernel中用上SGI的话,就是send_ipi_message,smp_cross_call相关函数?
hello_world
2016-06-16 15:46
@CANAAN:是的
CANAAN
2016-06-16 15:50
@hello_world:非常感谢您hello_world!
bsp
2016-04-05 10:50
hi linuxer
对于高电平(SPI)中断,在电平拉高并一直处于高电平时、中断是一直上报吗?
linux处理完一次中断后回来,还会继续处理此中断吗?
bsp
2016-04-05 10:53
@bsp:电平敏感(level-triggered)的中断处理流程是怎样的?
hello_world
2016-04-05 11:39
@bsp:在设备---->GIC---->cpu这个链条中,只要设备检测到出发中断的条件还在,那么设备到GIC之间的irq信号线就会保持asserted(也就是保持触发中断的电平信号),不过具体该中断是否被GIC上报给CPU是和GIC的设定有关,如果mask了该中断,那么其实是不会将该中断通知到CPU的。
tigger
2016-04-03 16:57
HI Hello World
我一直有个疑问,ipi的中断能够撤销吗?
我的理解一般core直接的ipi,如果一个core发出去了,另一个core必须要给回复,发出ipi的core才能继续运行
Rescheduling Interrupts 这个IPI是调度器发出来的,那么调度器可以把发出去的ipi再撤销么?
bsp
2016-04-05 10:24
@tigger:我的理解一般core直接的ipi,如果一个core发出去了,另一个core必须要给回复,发出ipi的core才能继续运行。
-->通过调用smp_cross_call发送ipi(如smp_send_reschedule)的,不需要等待;通过调用smp_call_function_single发送ipi(如on_each_cpu)的,最后一个参数wait是判断是否需要等待的(基于kernel-3.10)。

Rescheduling Interrupts 这个IPI是调度器发出来的,那么调度器可以把发出去的ipi再撤销么?
-->一般没有撤销的使用场景。IPI中断是通过操作gic的GICD_ICDSGIR发出SGI中断的,一旦发出去就无法撤销的(SPI还可以操作相应的Pending寄存器和enable寄存器,来disable此中断),目的cpu会决定是否处理、如何处理此SGI。
jiffy
2016-01-05 17:17
hi,linuxer
T64时刻 3个clock之后,由于CPU已经ack了中断,因此GIC中CPU interface模块 deassert nFIQCPU信号线,解除发向该CPU的中断请求.
--由于是level interrupt我认为是中断控制流层先mask irq导致CPU interface deassert nIRQCPU和nFIQCPU信号线,并ack irq清除pending state.
linuxer
2016-01-05 18:24
@jiffy:中断处理分成两个层次:
1、CPU层次的中断处理
2、各个IRQ层面的处理
由于中文习惯通常中断,因此工程师很容易混淆这两个概念。

T64时刻 3个clock之后,由于CPU已经ack了中断,因此GIC中CPU interface模块 deassert nFIQCPU信号线
-----------------
这里都是CPU层面的中断处理,和具体的IRQ无关
jiffy
2016-01-05 19:00
@linuxer:@linuxer:有点不明白,
void
handle_level_irq(unsigned int irq, struct irq_desc *desc)
{
    raw_spin_lock(&desc->lock);
    mask_ack_irq(desc);   -------------------(a)
    ....
(a)我认为在这里mask interrupt,才让CPU interface deassert nIRQCPU和nFIQCPU信号线,也就是说如果将(a)更改为ack_irq(desc),CPU interface 将保持assert nIRQCPU和nFIQCPU信号线直至interrupt source停止触发并清除pending state.
linuxer
2016-01-05 22:44
@jiffy:你为何会这么认为呢?有什么根据吗?

对于gic而言,根本不会调用handle_level_irq这个函数,其highlevel irq-events handler是handle_fasteoi_irq。

对于GIC而言,其中断处理过程是:
1、ARM中断处理过程
2、gic_handle_irq
3、generic_handle_irq
4、在generic_handle_irq_desc函数中调用desc->handle_irq(irq, desc),对于GIC而言,应该是handle_fasteoi_irq

上面的中断处理过程步骤2会进行ack GIC cpu interface的动作,在步骤4中,回针对某个具体的IRQ进行mask或者ack的动作,但是,那和CPU的中断信号没有关系了。
jiffy
2016-01-06 12:17
@linuxer:不好意思,是我的疏忽,仔细看了GIC 协议发现GIC的中断流控功能是硬件实现的,handle_fasteoi_irq让我们无需关注何时mask/unmask,甚至不需要我们ack,但内核还是利用desc的preflow_handler字段给了我们插手的机会,你是正确的,学习了。
jiffy
2016-01-06 16:30
@jiffy:...
上面的中断处理过程步骤2会进行ack GIC cpu interface的动作,在步骤4中,回针对某个具体的IRQ进行mask或者ack的动作,但是,那和CPU的中断信号没有关系了。--
在步骤4中,也就是中断流控处理层会调用中断通用逻辑层提供的API,而中断通用逻辑层会调用硬件封装层(我们的gic chip)提供的回调接口,所以4中的mask/unmask/ack等操作还是和cpu的中断信号有关系,只是被中断逻辑层封装隔离了。
gzz
2015-07-31 13:23
还是一个原来的疑惑:
假设一个root gic controll下面挂了另一个gic controller。比如是SPI64的。那么如果将次controller的上的2个中断进行request_irq时,是不是都用的irq_num SPI64就行了呢?
如果是那么如何去区分两者的handler呢。
因为chain的irq中断回调处理,还是去找的irq_desc然后找irq_handler.但次controller上的两个不同中断,难道有他自己的一直irq_desc?还是一个domain就一张irq_num?
是不是级联的时候,中断号就是连续的呢,比如root就是0-64.然后次controller是65-128?这样貌似次controller上的2个中断号就可以分为65,66假设。不用读是64了吧?
请指教下。都是假设,但有这种情况,内核是怎么处理的,因为request时没看到有对级联controller的单独处理?
gzz
2015-07-31 13:35
@gzz:可以看到,级联时domain的中断处理:
static void gic_handle_cascade_irq(unsigned int irq, struct irq_desc *desc)
{
    struct gic_chip_data *chip_data = irq_get_handler_data(irq);
    struct irq_chip *chip = irq_get_chip(irq);
    unsigned int cascade_irq, gic_irq;
    unsigned long status;

    chained_irq_enter(chip, desc);

    raw_spin_lock(&irq_controller_lock);
    status = readl_relaxed(gic_data_cpu_base(chip_data) + GIC_CPU_INTACK);//级联的操作对应的chip controll 需要获取gic_irq
    raw_spin_unlock(&irq_controller_lock);

    gic_irq = (status & 0x3ff);
    if (gic_irq == 1023)
        goto out;

    cascade_irq = irq_find_mapping(chip_data->domain, gic_irq);//找到该级controll下hw irq对应的irq num
    if (unlikely(gic_irq < 32 || gic_irq > 1020))
        do_bad_IRQ(cascade_irq, desc);
    else
        generic_handle_irq(cascade_irq);//子controller下hw对应的回调处理

out:
    chained_irq_exit(chip, desc);
}
也是一个中断号,所有我更加猜测,假设就是简单的一对一的映射,root gic controller(比如0-64)+次 controller(对应65-128).这样两者的中断号就不会重合?
passerby
2015-07-31 16:20
@gzz:我在高通里面看到,GPIO INT CONTROLLER和GIC的级联,也许能给你启发。
高通GPIO的控制器会连到GIC 208引脚上,在初始化的时候就会在gpio ontroller init的时候注册这个GIC 208的中断。当GPIO中断发生时,其实会触发GIC的gic_handle_irq处理函数。gic_handle_irq函数就会去读取当前谁发生了中断,最后会发现208引脚中断,然后执行208中断的handler,最后执行desc->action函数。
这个时候gpio controller在初始化时候通过devm_request_irq就会去检查GPIO CONTROLLER的相应位从而知道是哪个GPIO 哪个引脚发生中断,最后调用            generic_handle_irq(virq);
去执行你在gpio request_irq时注册的GPIO 中断函数。
passerby
2015-07-31 16:25
@passerby:次级GIC会使用ROOT GIC一个中断线,通过向这个中断线注册一个中断服务函数A。当这个中断线发生中断后肯定就是次级GIC上的中断引发的,那A函数就会去读取次级GIC中断位状态,从而知道次级GIC哪个位发生了中断。这样就可以调用相应次级GIC的中断服务函数了。
gzz
2015-08-03 09:18
@passerby:按你的说法,那么每个GPIO中断,在注册request时,使用的virq是什么?如果是这样,我猜测这个Virq在domain初始化时,肯定和root controller上的其他中断是不重合的(也许不同平台会做不同处理)。假如是一对一映射的话,目测gpio controller上的中断应该是从208号以后算起的吧,是这样的吧?不然要是也是0开始算,会把root controller注册的相关desc给覆盖掉的吧?
gzz
2015-08-03 09:22
@passerby:我更多的疑问在于主次controller是如何维护着virq的或者说是h_irq。两者应该不能出现重合的吧,不然request如何处理呢,virq毕竟和handle相关联的?
passerby
2015-08-03 17:26
@gzz:对的,virq是不会重合的。每次调用irq_of_parse_and_map去解析都会将传入的hwid转化成一个virq,virq在高通平台里是一个bit map表,所以保证了每个肯定都是唯一的virq。
gzz
2015-08-04 09:00
@passerby:thanks,那应该是合理的
gzz
2015-08-04 09:04
@gzz:能加你QQ,咨询些问题吗?我的是1037701636,谢谢
linuxer
2015-05-18 12:16
@piter,由于有回复限制,因此我copy了一份您的问题:
想請教一下,看到你說的這個gic_dist_init只會讓該中斷對應到一個cpu。然後我就去追當我們註冊irq時的這個function:request_threaded_irq,發現他最後也是call 這個gic_dist_init這個::
request_threaded_irq ->__setup_irq -> setup_affinity -> chip->irq_set_affinity (.irq_set_affinity = gic_set_affinity, drivers/irqchip/irq-gic.c)
  這樣不是代表,當我們用request_threaded_irq註冊interrupt 時候,該interrupt 只會給特定的cpu 嗎(變成大部分都只有cpu0)? 這樣感覺跟以往的認知不一樣。比如說以往會有個觀念是說若cpu0 正在處理interrupt0 這時候若有interrupt1 進來時,cpu1會去處理interrupt 1。感覺若照程式這樣看來,會變成同一時間只能有單一中斷被響應...。
   請問您有什麼看法,感謝
----------------------------------------------
我觉得这是一个策略和机制的问题。对于内核中的中断子系统,当然只是负责提供机制,例如提供set affinity的策略。到底SPI的中断由哪一个cpu处理是一个策略问题。可能是永远的将某个外设(例如ethernet)的中断送达cpu0(配合的系统策略是:在该cpu上启动若干的线程来处理来自网络的请求),也可能是平均分配外设的中断,象你说的那样,一会cpu0处理,一会儿cpu1处理。
但无论如何,内核无法确定策略,因此,在系统初始化的时候,总是先初始化成一种形态,后续应该会有一些其他的软件模块(irq banlance daemon)会根据irq的负荷来控制irq affinity的。
piter
2015-05-19 14:05
@linuxer:irq banlance daemon!!  竟然有這種東西~~
請問一下,知道他在哪個地方有真正設定到irq 分配給哪個cpu 嗎~?
感謝~
linuxer
2015-05-19 18:12
@piter:用户空间的程序(例如irq banlance)可以通过proc文件系统和linux 中断子系统交互IRQ affinity的相关信息:
1、/proc/irq/default_smp_affinity。通过该接口可以访问系统缺省的IRQ affinity。在内核的source code中定义为:
cpumask_var_t irq_default_affinity;
在系统初始化的时候,irq_default_affinity被初始化成送达所有CPU(参考early_irq_init函数)。在具体中断描述符初始化的时候,会用irq_default_affinity来初始化desc->irq_data.affinity成员。
需要注意的是:向该接口写入新的缺省IRQ affinity不会影响已经设定的中断描述符,但是新分配的中断描述符的affinity(desc->irq_data.affinity成员)会按照新的default irq affinity值进行初始化。

2、/proc/irq/<irq>/。linux kernel会为每一个IRQ number建立一个目录,保存该IRQ相关的信息

3、/proc/irq/<irq>/smp_affinity。通过该接口可以访问具体某个IRQ number的IRQ affinity(desc->irq_data.affinity成员)。初始化的时候,该值被设定为系统缺省的IRQ affinity(irq_default_affinity),在系统运行过程中,根据实际系统中断负荷和irq balancing的策略,有可能会修改该值。

4、/proc/irq/<irq>/affinity_hint。通过该接口可以读取(read only)具体某个IRQ number的affinity hint(desc->affinity_hint成员)。
底层的driver可以通过irq_set_affinity_hint接口来设定它期望的affinity值,当然,这只是给用户空间一个提示,运行于用户空间的irq affinity daemon进程会根据这个值进行IRQ affinity的设定

5、/proc/irq/<irq>/smp_affinity_list。这个接口是和/proc/irq/<irq>/smp_affinity接口是一样的,只不过表述形式不一样而已。/proc/irq/<irq>/smp_affinity是用cpu mask的形式给出的,但是当cpu的数目比较大的时候,调整affinity变得不那么方便了,因此,linux kernel增加了smp_affinity_list的接口,这个接口的输出是用ascii的形式输出,我们还是举例子吧:
如果一个IRQ被允许送达cpu3和cpu6,那么读取smp_affinity_list将返回3,6
如果一个IRQ被允许送达所有的cpu(0~7),那么读取smp_affinity_list将返回0-7

.......
tiger20081015
2015-04-10 14:56
@linuxer,有一个问题想请教一下:在 irq_alloc_descs(irq_start, 16, gic_irqs,  numa_node_id()); 中,为什么要从16开始?我理解这个函数只是从一个bitmap上16号位置开始找连续的gic_irqs个非0的bit,和硬件中断本身应该没什么关系。为什么不直接从0开始呢?我在我的平台上(有gic)上试着把16改成0,结果板子启动到一半就hang了。
tigger
2015-04-01 11:09
最近看了一下Cortex-A53的datasheet,发现
The Cortex-A53 processor includes only the GIC CPU Interface.
那外部就只有一个独立的distributor component了
不知道老大对这个有研究吗?
linuxer
2015-04-01 19:10
@tigger:整个系统的components是不会变化的,仍然是CPU interfaces + Distributor,只不过在GICV2上,CPU interfaces + Distributor作为一个外设,挂在AMBA总线上,这时候,GIC都是memory mapped。
来到了GICV3/4上,processor可以通过system register interface来访问CPU interface这个HW block(而不是memory mapped的那些寄存器),访问Distributor则保持了v2的形式。因此,Cortex-A53的datasheet会说The Cortex-A53 processor includes only the GIC CPU Interface。而传统的包含CPU Interfaces和Distributor的GIC则只包括了Distributor了。你可以看看GIC-500的datasheet就明白了。
当然,要强调的是:中断控制器仍然包括CPU Interfaces和Distributor,只不过CPU Interfaces变成了processor的一部分了。
有时间你也可以考虑为何结构会这么变化,呵呵~~~其实也挺有意思的。
tigger
2015-04-01 19:48
@linuxer:那这样之前代码里面读寄存器获得cpu。interface 与core的关系的代码是不是可以省略啦?
linuxer
2015-04-01 23:17
@tigger:当然是可以省略的了。

发表评论:

Copyright @ 2013-2015 蜗窝科技 All rights reserved. Powered by emlog