面向未来：理解ARM处理器的新一代技术（下）-阿里云开发者社区

5.2GNU LD链接器

链接器Linker：是一个程序，将一个或多个编译器或汇编生成的目标文件，及依赖库，链接为一个可执行文件。

GNU Linker采用AT&T链接脚本语言；

链接脚本文件：包含ld程序链接的规则，其决定输出可执行文件的内存布局；

LD命令：arm64版本的连接器是aarch64-linux-gnu-ld

查看命令参数：

aarch64-linux-gnu-ld --help

LD命令的参数有很多，常用的如下：

$(ARMGNU)-ld -T $(SRC_DIR)/linker.ld -Map xxx.map -o $(BUILD_DIR)/xxx.elf  $(OBJ_FILES)

常用参数：

-T：指定连接脚本；
-Map：输出一个符号表文件；
-o: 输出最终可执行二进制文件；

基本概念

输入段(input section)，输出段(output section)
每个段包括name和大小；

段的属性：

loadable:运行时会加载这些段内容到内存中；
allocatable:运行时不加载段的内容；

段的地址：

VMA（virtual memory address）:虚拟地址，运行地址；
LMA（load memory address）:加载地址
通常ROM的地址为加载地址，而RAM地址为VMA；

链接脚本命令

Entry(symbol): 设置程序的入口函数；

GNU-AS程序入口点有以下几种：

a.使用-e参数；
b.使用ENTRY（symbol);
c.在.text的最开始的地方；
d.0地址；
INCLUDE filename:引入filename的链接脚本；
OUTPUT filename：输出二进制文件，类似命令行的"-o filename"
OUTPUT_FORMAT(bfd)：输出BFD格式；
OUTPUT_ARCH(bfdarch): 输出处理器体系架构格式

OUTPUT_ARCH(aarch64)
ENTRY(_text)

赋值符号

符号可以像C语言一样赋值；

"."表示当前位置；

symbol = expression;
symbol += expression;
symbol -= expression;
symbol *= expression;
symbol /= expression;
symbol <<= expression;
symbol >>= expression;
symbol &= expression;
symbol |= expression;

符号的引用

在C语言定义一个变量并初始化，编译器会分配一个符号，且在内存中分配空间存储；

在链接脚本中定义的变量，仅仅是在符号表里定义这个符号，没有分配存储空间；

xxx.ld
start_of_ROM = .ROM;
end_of_ROM = .ROM + sizeof(.ROM)

可以在每个段中设置一些符号，以方便C语言访问每个段的起始地址和结束地址；

C语言中，对链接脚本里定义的符号引用

extern char start_of_ROM[],end_of_ROM[];
char buf[4096];
memcpy(buf, start_of_ROM, end_of_ROM - start_of_ROM);//引用的是地址

SECTIONS命令

告诉链接器如何把输入段(input sections)映射到输出段(output sections)，决定输出程序的内存布局；

输出section的描述符：

LMA加载地址

每个段都有VMA和LMA；

在输出段描述符中使用“AT”指定LMA, 如果没有指定，通常LMA=VMA;

构造一个基于ROM的映像文件，常常会设置输出端的虚拟地址和加载地址不一样；

SECTIONS
{
  .text 0x1000:{*(.text)_etext=.;}
  .mdata 0x2000:
  AT(ADDR(.text)+SIZEOF(.text))  //指定加载地址
  {
    _data=.;
    *(.data);
    _edata=.;  //_data和_edata只是一个符号，用来记录mdata段的VMA地址
  }
  .bss 0x3000;
  {
    _bstart=.;
    *(.bss)*(COMMON);
    -bend=.;
  }
}

mdata段的加载地址和链接地址不一样，因此程序初始化代码需要把data段内容复制到SDRAM中的虚拟地址中；

常见的内建函数(builtin functions)

ADDR(section):返回前面已经定义过的段的VMA地址；
ALIGN(n): 返回下一个与n字节对齐的地址；
SIZEOF(section):返回一个段的大小；
MAX/MIN(exp1,exp2):返回较大/较小值；

实例练习：设置代码段的LMA!=VMA

TEXT_ROM = 0X90000;
SECTIONS
{
  /*
   * -->location, current addr
   *  0x80000 is entrance address
   */
  . = 0x80000,
  /*
   * first instruction
   **/
  _text_boot = .;
  .text.boot : { *(.text.boot) }  
  _etext_boot = .;
  /*
   * code segment
   */
  _text = .;
  .text : AT(TEXT_ROM)
  { *(.text) }
  _etext = .;
  /*
   * readonly data segment
   */
  _rodata = .;
  .rodata : AT(ADDR(.rodata))
  { *(.rodata) }
  _erodata = .;
  /*
   * data segment
   */
  _data = .;
  .data : { *(.data) }
  _edata = .;
  /*
   * bss segment
   * 8bytes algine
   */
  . = ALIGN(0x8);
  _bss = .;
  .bss : { *(.bss*) } 
  _ebss = .;
  /*
   * alloc a page memory, store page table
   * aligne 4096
   */
  . = ALIGN(4096);
  init_pg_dir = .;
  . +=4096;
}

在启动代码，将代码段从LMA(ROM地址)拷贝到VMA(SDRAM地址)

master:
/*
 * copy code segment from rom(LMA) TO ram(VMA)
 */
  adr x0, TEXT_ROM
  adr x1, _text
  adr x2, _etext
1:
  ldr x4, [x0], #8
  str x4, [x1], #8
  cmp x1, x2
  b.cc 1b

六、GCC内嵌汇编补充

目的：

(1)优化，对特定代码进行优化；

(2)C语言需要访问某些特殊指令来实现特殊功能，比如内存屏障指令；

内嵌汇编两种模式：

基础内嵌汇编：不带参数；

扩展的内嵌汇编：C语言变量参数；

(1)基础内嵌汇编

格式：

asm关键字：表明是一个GNU扩展；
修饰词(qualifiers)
volatile:基础内嵌汇编中，通常不需要；
inline:内敛，asm代码会尽可能小；

汇编代码块：

GCC编译器把内嵌汇编当成一个字符串；
GCC编译器不会去解析和分析内嵌汇编；
多条汇编指令，需要使用“\n\t”换行；
GCC的优化器，可能乱序汇编指令，如果需要保持汇编指令的顺序，最好使用多个内嵌汇编的方式；

内核arch/arm64/include/asm/barrier.h文件

(2)扩展内嵌汇编

asm asm-qualifiers(
        Assembler Template;
        :outputOperands
        :inputOperands
        [:Clobbers])

格式：

asm关键字：表明是一个GNU扩展；
修饰词(qualifiers)：
volatile:用来关闭GCC优化；
inline: 内敛，减小汇编代码尺寸；
goto:在内嵌汇编里会跳转到C语言的label;

输出部：

用于描述在指令部中可以被修改的C语言变量以及约束条件；
每个约束通常以"="开头，接着的字母表示对操作类型的说明，然后是关于变量结合的约束；

“=+”+约束修饰符+变量

“=”表示被修饰的操作数具有可写属性；

“+”表示被修饰的操作数具有可读可写属性；

输出部可以是空的；

输入部：

用来描述在指令部中，只读的C语言变量以及约束条件；
输入部描述的参数，是只读属性，不要修改参数内容，因为GCC编译器假定输入部参数，在内嵌汇编前后是一致的；
输入部中不能使用"=/+"约束条件，编译器会报错；
输入部可以是空的；

损坏部：

“memory”告诉GCC内嵌汇编指令改变了内存的值，强迫编译器在执行该汇编代码前，存储所有缓存的值，在执行完汇编代码之后重新加载该值，目的是防止编译乱序；

“cc”:表示内嵌汇编代码影响状态寄存器相关的标志位；

内核里的实例，arch/arm64/include/asm/barrier.h

扩展内嵌汇编指令部中的参数表示：

案例1，用内嵌汇编实现memcpy：

static void my_memcpy_asm_test(unsigned long src, unsigned long dst,unsigned long counter)
  {
      unsigned long tmp;
      unsigned long end = src+counter;
      asm volatile(
              "1: ldr %1, [%2], #8\n"
              "str %1, [%0], #8\n"
              "cmp %2, %3\n"
              "b.cc 1b"
              :"+r"(dst),"+r"(tmp),"+r"(src)   //output list, can write and read
              :"r"(end)                        //input list, readonly
              :"memory"
              );
  }

使用汇编符号名实现内嵌汇编：

static void my_memcpy_asm_test(unsigned long src, unsigned long dst,unsigned long counter)
  {
      unsigned long tmp;
      unsigned long end = src+counter;
      asm volatile(
              "1: ldr %[tmp], [%[src]], #8\n"
              "str %[tmp], [%[dst]], #8\n"
              "cmp %[src], %[end]\n"
              "b.cc 1b"
              :[dst]"+r"(dst),[tmp]"+r"(tmp),[src]"+r"(src)   //output list, can write and read
              :[end]"r"(end)                        //input list, readonly
              :"memory"
              );  
  }

内嵌汇编与宏结合

#define MY_OPS(ops,asm_ops) \
  static inline my_asm_##ops(unsigned long mask, void *p) \
  { \
      unsigned long tmp; \
      asm volatile( \
              "ldr %1, [%0]\n" \
              " "#asm_ops" %1, %1, %2\n" \
              "str %1,[%0]\n" \
              : "+r"(p), "+r"(tmp) \
              :"r"(mask) \
              : "memory" \
              ); \
  }
  MY_OPS(and, and)
  MY_OPS(or, orr)
  MY_OPS(andnot, bic)
  static void my_ops_test(void)
  {
      unsigned long p;
      p = 0xf;
      my_asm_and(0x2, &p);
      printk("test and:p=0x%x\n",p);
      p = 0x0;
      my_asm_or(0x3, &p);
      printk("test or:p=0x%x\n",p);
      p = 0x3;
      my_asm_andnot(0x2, &p);
      printk("test andnot:p=0x%x\n",p);
  }

技巧：

(1)使用了C语言宏中的“＃”和“＃＃”；

“＃”：预处理器把这个参数转换为一个字符串；

“＃＃”：是一种分隔链接方式，它的作用是先分隔，在进行强制链接；

(2)通过一个宏来实现多个类似的函数，这是linux内核常用的技巧；

实现读和写系统寄存器的宏

//equals    asm volatile("mrs %0,""#reg" :"=r"(_val)); _val;}
  #define read_sysreg(reg) ({ \
      unsigned long _val; \
      asm volatile("mrs %0,"#reg \
                   :"=r"(_val)); \
                   _val; \
  })
  #define write_sysreg(val, reg) ({\
          unsigned long _val=(unsigned long)val; \
          asm volatile("msr "#reg ",%0" \
          ::"rZ"(_val)); \
  })
  static test_sysregs(void)
  {
      unsigned long el; 
      el = read_sysreg(CurrentEL);
      printk("el=%d\n",el>>2);
      write_sysreg(0x10000, vbar_el1);
      printk("read vbar:0x%x\n",read_sysreg(vbar_el1));
  }

实现从汇编到C代码的跳转

static void test_asm_goto(int a)                                                                                                           
  {
      asm goto(
              "cmp %w0, 1\n"
              "b.eq %l[label]\n"
              :        //必须为空
              :"r"(a)
              :"memory"
              :label
              );  
      return 0;
  label:
      printk("%s: a=%d.\n",__func__,a);
  }

goto模板的输出部必须为空；

七、ARM64的异常处理之中断处理(以树莓派4采用的BCM2711芯片为例)

ARM64的中断属于异常模式的一种，对中断的处理流程跟上节的异常处理类似，走其中的一个分支；

树莓派4b的中断控制器分两种：传统的中断方式legacy interrupt和GIC(BCM2711支持GIC-400)；

一个典型的ARM64中断处理流程：

7.1树莓派4b上的硬件资源

1.中断控制器：

GIC-400（默认）
传统的中断控制器(legacy interrupt controller)

2.树莓派4b支持多种中断源：

ARM Core N: ARM Core本身的中断源，例如Core里的generic timer;
ARMC: 可以被VPU和CPU访问的中断源，例如mailbox；
ARM_LOCAL：只能被CPU访问的中断源，例如本地timer等；

3.树莓派4b的legacy中断控制器

实例：以ARM Core的generic timer产生中断信号

7.2Cortex-A72支持4个ARM Core的generic timer

这里采用Nonsecure EL1 Physical Timer，演示中断处理过程；

查看ARMv8手册，第一个是EL1 TIMER的控制寄存器CNTP_CTL_EL0；

计数器寄存器CNTP_TVAL_EL0

Timer支持两种触发方式，参考armv8_D11.2.4;

7.3ARM_LOCAL寄存器有：

4个IRQ_SOURCE寄存器，每个CPU一个，表示IRQ中断源状态；
4个FIQ_SOURCE寄存器，每个CPU一个，表示FIQ中断源状态；
4个TIMER_CNTRL寄存器，每个CPU一个，用来使能对应中断源；

1.查看BCM2711手册可知，ARM_LOCAL基地址为0x4c000000或0xff800000

对于IRQ_SOURCE寄存器，可以读取对应中断源状态；

TIMER_CNTRL寄存器用来使能中断响应

7.4EL1的Nonsecure generic timer中断处理流程

初始化

1.初始化timer，设置cntp_ctl_el0寄存器的enable域使能；
2.给timer的TimeValue一个初值，设置cntp_tval_el0寄存器；
3.打开树莓派b4中断控制器中和timer相关的中断，设置TIMER_CNTRL0寄存器的CNT_PNS_IRQ为1；
4.打开PSTATE寄存器中的IRQ中断总开关；

异常中断处理

5.Timer中断发生；
6.跳转到异常向量表的el1_irq1函数；
7.保存中断上下文(kernel_entry宏)；
8.跳转到中断处理函数；
9.读取ARM_LOCAL中断状态寄存器IRQ_SOURCE0；
10.判断中断源，是否为CNT_PNS_IRQ中断；
11.如果是CNT_PNS_IRQ，重置TimerValue；

返回现场

12.返回到el1_irq函数；
13.恢复中断上下文；
14.返回中断现场

中断源的判断：

以一个稍微复杂的中断源为例，根据树莓派4b BCM2711手册：

由上图可知，最多分三级：

1.读SOURCEn中断寄存器；
2.若SOURCEn[8]置位，继续读取PENDING2寄存器；
3.若PENDING2[24]置位，则读PENDING0寄存器；
4.若PENDING2[25]置位，则读PENDING1寄存器；

可见当中断源数量增加到一定程度，中断处理程序将会变得十分繁杂，GIC控制器就是为解决这个问题而生。

7.5中断现场(上下文)

1）中断上下文内容

中断发生瞬间，CPU状态包括：

PSTATE寄存器
PC值
SP值
X0~X30寄存器

Linux使用一个栈框数据结构来描述需要保存的中断现场；

2）保存中断现场

中断发生时，中断上下文保存到当前进程的内核栈里；

代码实现：

.macro kernel_entry
  sub sp, sp, #S_FRAME_SIZE
  /*
     保存通用寄存器x0~x29到栈框里pt_regs->x0~x29
   */
  stp x0, x1, [sp, #16 *0]
  stp x2, x3, [sp, #16 *1]
  stp x4, x5, [sp, #16 *2]
  stp x6, x7, [sp, #16 *3]
  stp x8, x9, [sp, #16 *4]
  stp x10, x11, [sp, #16 *5]
  stp x12, x13, [sp, #16 *6]
  stp x14, x15, [sp, #16 *7]
  stp x16, x17, [sp, #16 *8]
  stp x18, x19, [sp, #16 *9]
  stp x20, x21, [sp, #16 *10]
  stp x22, x23, [sp, #16 *11]
  stp x24, x25, [sp, #16 *12]
  stp x26, x27, [sp, #16 *13]
  stp x28, x29, [sp, #16 *14]
  /* x21: 栈顶 的位置*/
  add     x21, sp, #S_FRAME_SIZE
  mrs     x22, elr_el1
  mrs     x23, spsr_el1
  /* 把lr保存到pt_regs->lr, 把sp保存到pt_regs->sp位置*/
  stp     lr, x21, [sp, #S_LR]
  /* 把elr_el1保存到pt_regs->pc中
     把spsr_elr保存到pt_regs->pstate中*/
  stp     x22, x23, [sp, #S_PC]
  .endm

3）恢复中断现场

中断处理完成后，从内核栈中恢复中断现场；

代码实现：

.macro kernel_exit
  /* 从pt_regs->pc中恢复elr_el1,
     从pt_regs->pstate中恢复spsr_el1
     */
  ldp     x21, x22, [sp, #S_PC]           // load ELR, SPSR
  msr     elr_el1, x21                    // set up the return data
  msr     spsr_el1, x22
  ldp     x0, x1, [sp, #16 * 0]
  ldp     x2, x3, [sp, #16 * 1]
  ldp     x4, x5, [sp, #16 * 2]
  ldp     x6, x7, [sp, #16 * 3]
  ldp     x8, x9, [sp, #16 * 4]
  ldp     x10, x11, [sp, #16 * 5]
  ldp     x12, x13, [sp, #16 * 6]
  ldp     x14, x15, [sp, #16 * 7]
  ldp     x16, x17, [sp, #16 * 8]
  ldp     x18, x19, [sp, #16 * 9]
  ldp     x20, x21, [sp, #16 * 10]
  ldp     x22, x23, [sp, #16 * 11]
  ldp     x24, x25, [sp, #16 * 12]
  ldp     x26, x27, [sp, #16 * 13]
  ldp     x28, x29, [sp, #16 * 14]
  /* 从pt_regs->lr中恢复lr*/
  ldr     lr, [sp, #S_LR]
  add     sp, sp, #S_FRAME_SIZE           // restore sp
  eret
  .endm

5）实例代码：

在树莓派上实现generic timer, 关键代码

timer初始化

#include <asm/timer.h>
#include <asm/irq.h>
#include <io.h>
#include <asm/arm_local_reg.h>
#include <timer.h>
#define HZ 250
#define NSEC_PER_SEC    6000000000L
static unsigned int val = NSEC_PER_SEC / HZ;
static int generic_timer_init(void)
{
  asm volatile(
    "mov x0, #1\n"
    "msr cntp_ctl_el0, x0"
    :
    :
    : "memory");
  return 0;
}
static int generic_timer_reset(unsigned int val)
{
  asm volatile(
    "msr cntp_tval_el0, %x[timer_val]"
    :
    : [timer_val] "r" (val)
    : "memory");
  return 0;
}
static void enable_timer_interrupt(void)
{
  writel(CNT_PNS_IRQ, TIMER_CNTRL0);
}
void timer_init(void)
{
  generic_timer_init();
  generic_timer_reset(val);
  enable_timer_interrupt();
}
void handle_timer_irq(void)
{
  generic_timer_reset(val);
  printk("Core0 Timer interrupt received\r\n");
}

中断服务程序：

#include <asm/irq.h>
#include <io.h>
#include <asm/arm_local_reg.h>
void irq_handle(void)
{
  unsigned int irq = readl(ARM_LOCAL_IRQ_SOURCE0);
  switch (irq) {
  case (CNT_PNS_IRQ):
    handle_timer_irq();
    break;
  default:
    printk("Unknown pending irq: %x\r\n", irq);
  }
}

主应用程序：

void kernel_main(void)
{
  uart_init();
  init_printk_done();
  uart_send_string("Welcome BenOS!\r\n");
  printk("printk init done\n");
  //my_ldr_test();
  my_data_process();
  //my_cmp_test();
  //other_test();
  print_func_name(0x800880);
  //unsigned long val1 = 0,val2=0;
  //val1 = macro_test1(3,5);
  //val2 = macro_test2(3,5);
  print_memmap();
  my_memcpy_asm_test(0x80000, 0x100000, 32);
  my_memset_16bytes_asm(0x600000,0xaabbccdd,4096);
  //test_asm_goto(1);
  //trigger_alignment();
  printk("init done\n");
  timer_init(); //初始化timer
  raw_local_irq_enable();//启动timer
  my_ops_test();
  test_sysregs();
  int count=0;
  while (1) {
    //uart_send(uart_recv());
    printk("printk while...%ds\n",count++);
    delay_s(1);
  }
}

7.6在qemu上模拟结果如下：

八、ARM64的中断处理之GIC400实现(以树莓派4采用的BCM2711芯片为例)

8.1GIC的诞生背景

传统中断控制器，比如树莓派4b的legacy interrupt controller，具备

中断enable寄存器；

中断状态寄存器；

随着新业务的出现，比如：

1.中断源变得越来越多；
2.不同类型的中断出现，比如多核间中断，中断优先级，软中断等；
3.支持虚拟化；

传统中断控制器已经无法满足需求，由此GIC控制器应运而生；

8.2GIC的版本号

GIC演进的版本号如下表

目前最新版本是GIC500/600，比如最新的高端手机大多支持，而在传统嵌入式系统中，大多GIC400就够用，比如这里以树莓派；

8.3GIC支持的中断类型

SGI: 软件产生的中断(Software Generated Interrupt)，用于给其他CPU核发送中断信号；
PPI：私有外设中断(Private Perpheral Interrupt)，该中断是某个指定的CPU独有的；
SPI：共享外设中断(Shared Peripheral Interrupt)，所有CPU都可以访问这个中断；
LPI: 本地特殊外设中断(Locality-specific Peripheral Interrupt)，GICv3新增的中断类型，基于消息传递的中断类型

8.4GIC的中断状态

中断的处理流程是：分发器把收集来的中断先缓存，依次把优先级最高的中断请求送往CPU接口，CPU读取一个中断，其实就是读取接口的一个寄存器，只不过这个寄存器存放的是中断号，此时中断的状态由pending转为active，CPU处理完了以后，将中断号写入GIC的接口，告诉GIC处理完了，可以将这个中断清理，

8.5GIC硬件原理

GIC 是连接外设中断和CPU的桥梁，也是多个CPU之间中断互联的通道，它负责检测、管理、分发中断；

1）GIC结构

上图摘自GIC400官方手册，GIC可以做到

1.使能或禁止中断；

2.把中断分组到FIQ或者IRQ；

3.多核系统中，可以将中断分配到不同CPU上；

4.设置GIC给到CPU的触发方式(不等于外设的触发方式)；

5.支持虚拟化扩展；

2） GIC功能

由上图知，GIC按功能，划分为两部分：仲裁分发和CPU接口；

3）分发器distributor

主要作用是，检测各个中断源的状态，控制各个中断源的行为，分发各个中断源产生的中断事件到一个或多个CPU接口。主要功能包括：

(1) 使能或禁止中断，分发器对中断的控制分两级别，一个是全局中断控制(GIC_DIST_CTRL)，一个是针对具体中断源控制(GIC_DIST_ENABLE_CLEAR)，
(2)控制优先级；
(3)将仲裁后的最高优先级中断事件，分发给一个或多个CPU接口；
(4)中断属性设定，比如触发方式等；

4）CPU接口

(1)禁止或使能CPU接口向相应的CPU提交中断事件；对于ARM核，中断信号线是nIRQ或nFIQ，若禁止GIC中断，即使分发器分发了一个事件到CPU接口，也不会提交nIRQ或nFIQ信号给CPU；

(2)ackowledging中断；ARM核一旦应答了中断，分发器就会把该中断状态从pending改为active, 若没有后续pending中断，CPU接口会deassert nIRQ或nFIQ信号线；若有后续中断，CPU接口将中断状态改为pending and active，此时依然保持nIRQ或nFIQ信号的asserted状态；

(3)中断处理完毕；ARM核处理完中断，回向CPU接口的寄存器写EOI命令，分发器将当前中断状态改为deactive，同时也可以将其他pending的中断向CPU接口提交；

(4)设定优先级掩码；可以屏蔽较低优先级中断，使其不同时给ARM核；

(5)设定中断抢占策略；

(6)始终选定最高优先级中断事件，提交给ARM核；

一个完整的中断处理过程时序图(摘自GIC400手册B1)：

假定：

a.都是电平触发；

b.都是共享外设中断；

c.M/N信号都配置为同一个CPU的为FIQEn中断；

d.N信号优先级高于M信号；

5）GICv2中断控制器

GIC-400包括两组寄存器

D系列:The Distributor registers(GICD_),包含中断设置和配置；

C系列：The CPU Interface registers(GICC_)，包含CPU相关的特殊寄存器；

访问GIC-400寄存器：树莓派4b中GIC-400基地

GIC-400初始化流程

(1)设置distributor和CPU interface寄存器组的基地址；
(2)读取GICD_TYPER寄存器，计算当前GIC最大支持多少个中断源；
(3)初始化distributor:

a.disable distributor;
b.设置中断分组；
b.设置SPI中断的路由；
c.设置SPI中断的触发类型；
d.disactive和disable所有中断源；
e.enable distributor;

(4)初始化CPU Interface：

a.设置GIC_CPU_PRIMASK，设置中断优先级mask level;
b. enable CPU interface;

相关寄存器说明

1.设置分组

group0：安全中断，由nFIQ驱动

group1：非安全中断，由nIRQ驱动

注册中断

(1) 初始化外设；
(2)查找该外设的中断在GIC-400的中断号，例如PNS timer中断号为30；
(3)设置GIC_DIST_ENABLE_SET寄存器来enable这个中断号；
(4)打开设备相关的中断，例如树莓派的generic timer，需要打开ARM_LOCAL寄存器组中的TIMER_CNTRL0寄存器中相应enable位；
(5)打开CPU的PSTATE中I位；

查树莓派手册知，PNS timer中断号为30

中断响应

1.中断触发；
2. 跳转异常向量表；
3. 跳转到GIC中断函数里，gic_handle_irq()；
4. 读取GICC_IAR寄存器，获取中断号；
5. 根据中断号来进行相应中断处理，例如，若读取中断号为30，说明是PNS的generic timer，跳转到generic timer处理函数；

读取中断号；

中断处理完成，写回EOI：

timer部分核心代码：

#include <asm/timer.h>
#include <asm/irq.h>
#include <io.h>
#include <asm/arm_local_reg.h>
#include <timer.h>
#define HZ 250
#define NSEC_PER_SEC    8000000000L
static unsigned int val = NSEC_PER_SEC / HZ;
static int generic_timer_init(void)
{
  asm volatile(
    "mov x0, #1\n"
    "msr cntp_ctl_el0, x0"
    :
    :
    : "memory");
  return 0;
}
static int generic_timer_reset(unsigned int val)
{
  asm volatile(
    "msr cntp_tval_el0, %x[timer_val]"
    :
    : [timer_val] "r" (val)
    : "memory");
  return 0;
}
static void enable_timer_interrupt(void)
{
  writel(CNT_PNS_IRQ, TIMER_CNTRL0);
}
void timer_init(void)
{
  generic_timer_init();
  generic_timer_reset(val);
  gicv2_unmask_irq(GENERIC_TIMER_IRQ);
  //enable_timer_interrupt();
}
void handle_timer_irq(void)
{
  generic_timer_reset(val);
  printk("Core0 Timer interrupt received\r\n");
}

irq部分核心代码：

#include <arm-gic.h>
#include "io.h"
#include <asm/irq.h>
struct gic_chip_data {
  unsigned long raw_dist_base;
  unsigned long raw_cpu_base;
  struct irq_domain *domain;
  struct irq_chip *chip;
  unsigned int gic_irqs;
};
#define gic_dist_base(d) ((d)->raw_dist_base)
#define gic_cpu_base(d) ((d)->raw_cpu_base)
#define ARM_GIC_MAX_NR 1
static struct gic_chip_data gic_data[ARM_GIC_MAX_NR];
/* IRQs start ID */
#define HW_IRQ_START 16
static unsigned long gic_get_dist_base(void)
{
  struct gic_chip_data *gic = &gic_data[0];
  return gic_dist_base(gic);
}
static unsigned long gic_get_cpu_base(void)
{
  struct gic_chip_data *gic = &gic_data[0];
  return gic_cpu_base(gic);
}
static void gic_set_irq(int irq, unsigned int offset)
{
  unsigned int mask = 1 << (irq % 32);
  writel(mask, gic_get_dist_base() + offset + (irq / 32) * 4);
}
void gicv2_mask_irq(int irq)
{
  gic_set_irq(irq, GIC_DIST_ENABLE_CLEAR);
}
void gicv2_unmask_irq(int irq)
{
  gic_set_irq(irq, GIC_DIST_ENABLE_SET);
}
void gicv2_eoi_irq(int irq)
{
  writel(irq, gic_get_cpu_base() + GIC_CPU_EOI);
}
static unsigned int gic_get_cpumask(struct gic_chip_data *gic)
{
  unsigned long base = gic_dist_base(gic);
  unsigned int mask, i;
  for (i = mask = 0; i < 32; i += 4) {
    mask = readl(base + GIC_DIST_TARGET + i);
    printk("mask:0x%x\n",mask);
    mask |= mask >> 16;
    mask |= mask >> 8;
    printk("----irq[%d],mask:0x%x\n",i,mask);
    if (mask)
      break;
  }
  return mask;
}
static void gic_dist_init(struct gic_chip_data *gic)
{
  unsigned long base = gic_dist_base(gic);
  unsigned int cpumask;
  unsigned int gic_irqs = gic->gic_irqs;
  int i;
  /* 关闭中断*/
  writel(GICD_DISABLE, base + GIC_DIST_CTRL);
  unsigned int cpu_group=0;
  for (i = 0; i < 32; i += 4) {
    cpu_group = readl(base + GIC_DIST_IGROUP+i);
    printk("reg[%d],cpu_group:0x%x\n",i/4,cpu_group); //default for group0
  }
  /* 设置中断路由：GIC_DIST_TARGET
   *
   * 前32个中断怎么路由是GIC芯片固定的，因此先读GIC_DIST_TARGET前面的值
   * 然后全部填充到 SPI的中断号 */
  cpumask = gic_get_cpumask(gic);
  cpumask |= cpumask << 8;
  cpumask |= cpumask << 16;
  printk("----cpumask:0x%x\n",cpumask);
  for (i = 32; i < gic_irqs; i += 4)
    ;//writel(cpumask, base + GIC_DIST_TARGET + i * 4 / 4);
  /* Set all global interrupts to be level triggered, active low */
  for (i = 32; i < gic_irqs; i += 16)
    //writel(GICD_INT_ACTLOW_LVLTRIG, base + GIC_DIST_CONFIG + i / 4);
    writel(0x1, base + GIC_DIST_CONFIG + i / 4);
  /* Deactivate and disable all 中断（SGI， PPI， SPI）.
   *
   * 当注册中断的时候才 enable某个一个SPI中断，例如调用gic_unmask_irq()*/
  for (i = 0; i < gic_irqs; i += 32) {
    writel(GICD_INT_EN_CLR_X32, base +
        GIC_DIST_ACTIVE_CLEAR + i / 8);
    writel(GICD_INT_EN_CLR_X32, base +
        GIC_DIST_ENABLE_CLEAR + i / 8);
  }
  /*打开SGI中断（0～15），可能SMP会用到*/
  writel(GICD_INT_EN_SET_SGI, base + GIC_DIST_ENABLE_SET);
  /* 打开中断：Enable group0 and group1 interrupt forwarding.*/
  writel(GICD_ENABLE, base + GIC_DIST_CTRL);
}
void gic_cpu_init(struct gic_chip_data *gic)
{
  int i;
  unsigned long base = gic_cpu_base(gic);
  unsigned long dist_base = gic_dist_base(gic);
  /*
   * Set priority on PPI and SGI interrupts
   */
  for (i = 0; i < 32; i += 4)
    //writel(0xa0a0a0a0,dist_base + GIC_DIST_PRI + i * 4 / 4);
    writel(0x30,dist_base + GIC_DIST_PRI + i * 4 / 4);
  //writel(GICC_INT_PRI_THRESHOLD, base + GIC_CPU_PRIMASK);
  writel(0x80, base + GIC_CPU_PRIMASK);
  writel(GICC_ENABLE, base + GIC_CPU_CTRL);
}
void gic_handle_irq(void)
{
  struct gic_chip_data *gic = &gic_data[0];
  unsigned long base = gic_cpu_base(gic);
  unsigned int irqstat, irqnr;
  do {
    irqstat = readl(base + GIC_CPU_INTACK);
    irqnr = irqstat & GICC_IAR_INT_ID_MASK; //get lower 9bits
    if (irqnr == GENERIC_TIMER_IRQ)
      handle_timer_irq();
    gicv2_eoi_irq(irqnr); //write eoi
  } while (0);
}
int gic_init(int chip, unsigned long dist_base, unsigned long cpu_base)
{
  struct gic_chip_data *gic;
  int gic_irqs;
  int virq_base;
  gic = &gic_data[chip];
  gic->raw_cpu_base = cpu_base;
  gic->raw_dist_base = dist_base;
  /* readout how many interrupts are supported*/
  gic_irqs = readl(gic_dist_base(gic) + GIC_DIST_CTR) & 0x1f;
  gic_irqs = (gic_irqs + 1) * 32;
  if (gic_irqs > 1020)
    gic_irqs = 1020;
  gic->gic_irqs = gic_irqs;
  printk("%s: cpu_base:0x%x, dist_base:0x%x, gic_irqs:%d\n",
      __func__, cpu_base, dist_base, gic->gic_irqs);
  gic_dist_init(gic);
  gic_cpu_init(gic);
  return 0;
}

精品文章推荐阅读：

面向未来：理解ARM处理器的新一代技术（下）