Exynos_4412——中断处理（中断学习结尾篇）
目录
一、ARM的异常处理机制
1.1异常概念
1.2异常处理机制
1.3ARM异常源
1.4异常模式
1.5ARM异常响应
1.6异常向量表
1.7异常返回
1.8IRQ异常举例
二、工程模板代码结构
三、中断处理框架搭建
四、中断处理程序
五、用key3再试一试
前景提要：
Exynos_4412——轮询与中断_宇努力学习的博客-CSDN博客
Exynos_4412——中断控制器_宇努力学习的博客-CSDN博客
一、ARM的异常处理机制
1.1异常概念
处理器在正常执行程序的过程中可能会遇到一些不正常的事件发生，这时处理器就要将当前的程序暂停下来转而去处理这个异常的事件。异常事件处理完成之后再返回到被异常打断的点，继续执行程序。
1.2异常处理机制
不同的处理器对异常的处理的流程大体相似，但是不同的处理器在具体实现的机制上有所不同；比如处理器遇到哪些事件认为是异常事件遇到异常事件之后处理器有哪些动作、处理器如何跳转到异常处理程序如何处理异常、处理完异常之后又如何返回到被打断的程序继续执行等我们将这些细节的实现称为处理器的异常处理机制。
1.3ARM异常源
导致异常产生的事件称为异常源
FIQ 快速中断请求引脚有效
IRQ 外部中断请求引脚有效
Reset 复位电平有效
Software Interrupt 执行swi指令
Data Abort 数据终止
Prefetch Abort 指令预取终止
Undefined Instruction 遇到不能处理的指令
1.4异常模式
在ARM的基本工作模式中有5个属于异常模式，即ARM遇到异常后会切换成对应的异常模式
1.5ARM异常响应
1.拷贝CPSR中的内容到对应异常模式下的SPSR_
2.修改CPSR的值
2.1.修改中断禁止位禁止相应的中断
2.2.修改模式位进入相应的异常模式
2.3.修改状态位进入ARM状态
3.保存返回地址到对应异常模式下的LR_
4.设置PC为相应的异常向量（异常向量表对应的地址）
1.6异常向量表
> 异常向量表的本质是内存中的一段代码
> 表中为每个异常源分配了四个字节的存储空间
> 遇到异常后处理器自动将PC修改为对应的地址
> 因为异常向量表空间有限一般我们不会再这里写异常处理程序，而是在对应的位置写一条跳
转指令使其跳转到指定的异常处理程序的入口
注：ARM的异常向量表的基地址默认在0x00地址但可以通过配置协处理器来修改其地址
1.7异常返回
1.将SPSR_
2.将LR_
1.8IRQ异常举例
注：整个过程CPSR保存的永远是当前程序运行状态SPSR只是异常时对原来的CPSR进行备份
二、工程模板代码结构
common：老师写好的库函数文件，里面实现了很多功能，比如把所有的寄存器封装，比如手搓了一个printf。
interface.c: 我们自己要实现的c源文件
start： 启动文件，任何芯片一上电执行的第一个程序一定是汇编程序，要初始化栈，初始化芯片，将异常向量表基地址位置改变，打开FIQ、IRQ然后跳转到C程序。
makefile： 编译规则
map.lds: 链接脚本，这个工程模板内有很多的C文件S文件H文件，他们编译链接后只生成一个.bin文件写入开发板，哪个文件放入哪个位置，我们写好的文件在内存中的位置都由它决定
OUTPUT_FORMAT("elf32-littlearm", "elf32-littlearm", "elf32-littlearm")
/*OUTPUT_FORMAT("elf32-arm", "elf32-arm", "elf32-arm")*/
OUTPUT_ARCH(arm)
ENTRY(_start)
SECTIONS
{
. = 0x40008000;
. = ALIGN(4);
.text :
{
start/start.o(.text)
*(.text)
}
. = ALIGN(4);
.rodata :
{ *(.rodata) }
. = ALIGN(4);
.data :
{ *(.data) }
. = ALIGN(4);
.bss :
{ *(.bss) }
}
三、中断处理框架搭建
在执行IRQ中断程序时保存的指令是汇编指令，C语言一条指令转化成汇编可能是很多条
在遇到IRQ时会跳转到以_start：为基地址偏移0x18
然后我们在 b main 后面来写这个中断服务程序
但是我们不能直接在这里写，因为IRQ模式下有很多寄存器都是和USER模式共用的如果在这里写，可定会用到一些寄存器，这样就会覆盖掉寄存器中本来的内容，返回主程序就不能正确返回这个状态了
所以我们需要先压栈保护现场
这个是时候就可以写了吗，还是不能，我们来复习一下LR寄存器
链接寄存器，一般有以下两种用途：
> 执行跳转指令(BL/BLX)时，LR会自动保存跳转指令下一条指令的地址程序需要返回时将LR的值复制到PC即可实现。
> 产生异常时，对应异常模式下的LR会自动保存被异常打断的指令的下一条指令的地址，异常处理结束后将LR的值复制到PC可实现程序返回。
当执行跳转指令或产生异常时，LR寄存器中不会凭空产生一个返回地址。其原理是当执行跳转指令或产生异常时，处理器内部会将PC寄存器中的值拷贝到LR寄存器中，然后再将LR寄存器中的值自减4。
如果不清楚下面用BL指令举例
当执行BL指令时，指令执行过程中处理器内部就会将PC寄存器的值拷贝到LR寄存器，然后再将LR寄存器中的值自减4， 所以LR寄存器中保存的就是BL指令下一条指令的地址。
在遇到IRQ中断时还不太一样
当执行一条指令时产生了一个IRQ中断，执行这条指令过程中处理器不会保存返回地址，而是执行完成后才会保存,但执行完成后PC的值又会自动增4，所以对于IRQ来说LR中保存的是被中断打断的指令的下下条指令的地址。
因为产生IRQ异常后自动保存到LR寄存器中的返回地址是被IRQ打断的指令下一条在下一条指令，所以需要我们人为的修复一下。
那么为什么不直接让他返回一个正确的呢，因为ARM是精简指令集，要想直接返回正确的必须要再加一个电路，这样会增加硬件成本，所以不如软件修复一条指令就解决了。
由于这是一个非叶子函数，在这段程序中可能还会有跳转，所以我们干脆把LR也压栈保护一下。
之后就可以处理异常了。写汇编就直接接着写，写C呢跳转一下
四、中断处理程序
.text
.global _start
_start:
/*
* Vector table
*/
b reset
b .
b .
b .
b .
b .
//IRQ
b irq_handler
b .reset:
/*
* Set vector address in CP15 VBAR register
*/
ldr r0, =_start
mcr p15, 0, r0, c12, c0, 0 @Set VBAR/*
* Set the cpu to SVC32 mode, Disable FIQ/IRQ
*/
mrs r0, cpsr
bic r0, r0, #0x1f
orr r0, r0, #0xd3
msr cpsr ,r0/*
* Defines access permissions for each coprocessor
*/
mov r0, #0xfffffff
mcr p15, 0, r0, c1, c0, 2/*
* Invalidate L1 I/D
*/
mov r0, #0 @Set up for MCR
mcr p15, 0, r0, c8, c7, 0 @Invalidate TLBs
mcr p15, 0, r0, c7, c5, 0 @Invalidate icache
/*
* Set the FPEXC EN bit to enable the FPU
*/
mov r3, #0x40000000
fmxr FPEXC, r3
/*
* Disable MMU stuff and caches
*/
mrc p15, 0, r0, c1, c0, 0
bic r0, r0, #0x00002000 @Clear bits 13 (--V-)
bic r0, r0, #0x00000007 @Clear bits 2:0 (-CAM)
orr r0, r0, #0x00001000 @Set bit 12 (---I) Icache
orr r0, r0, #0x00000002 @Set bit 1 (--A-) Align
orr r0, r0, #0x00000800 @Set bit 11 (Z---) BTB
mcr p15, 0, r0, c1, c0, 0/*
* Initialize stacks
*/
init_stack:
/*svc mode stack*/
msr cpsr, #0xd3
ldr sp, _stack_svc_end/*undef mode stack*/
msr cpsr, #0xdb
ldr sp, _stack_und_end/*abort mode stack*/
msr cpsr,#0xd7
ldr sp,_stack_abt_end/*irq mode stack*/
msr cpsr,#0xd2
ldr sp, _stack_irq_end
/*fiq mode stack*/
msr cpsr,#0xd1
ldr sp, _stack_fiq_end
/*user mode stack, enable FIQ/IRQ*/
msr cpsr,#0x10
ldr sp, _stack_usr_end/*Call main*/
b main
//IRQ异常处理程序
irq_handler:
//跳转修复
sub lr, lr, #4//R0-R12 IRQ模式和USER模式是同一组
stmfd sp!, {r0-r12,lr}
//处理异常
bl do_irq//异常返回
ldmfd sp!,{r0-r12,pc}^
_stack_svc_end:
.word stack_svc + 512
_stack_und_end:
.word stack_und + 512
_stack_abt_end:
.word stack_abt + 512
_stack_irq_end:
.word stack_irq + 512
_stack_fiq_end:
.word stack_fiq + 512
_stack_usr_end:
.word stack_usr + 512.data
stack_svc:
.space 512
stack_und:
.space 512
stack_abt:
.space 512
stack_irq:
.space 512
stack_fiq:
.space 512
//异常返回
ldmfd sp!,{r0-r12,pc}^
有人可能会好奇我们不是要把spsr写入cpsr把LR写入pc
！的作用是在取元素过程中SP发生变化时将变化写入SP
^ 的作用是将栈中元素取出放入寄存器，存的时候存的LR读的时候用pc就已经完成了把LR写入PC
而使用^还有一个功能就是自动将spsr写入cpsr所以完美的解决了这两个问题。
ARM寄存器组织与异常处理_宇努力学习的博客-CSDN博客
#include "exynos_4412.h"
void do_irq()
{
printf("KEY3 pressed\n");
}
void delay(unsigned int time)
{
while(time --);
}
int main()
{
GPX1.CON = GPX1.CON | (0xF << 4);
EXT_INT41_CON = EXT_INT41_CON & (~(0x7 << 4)) | (0x2 << 4);
EXT_INT41_MASK = EXT_INT41_MASK & (~(1 << 1));
ICDDCR = ICDDCR | 1;
ICDISER.ICDISER1 = ICDISER.ICDISER1 | (1 << 25);
ICDIPTR.ICDIPTR14 = ICDIPTR.ICDIPTR14 & (~(0xFF << 8)) | (0x01 << 8);
CPU0.ICCICR = CPU0.ICCICR | 1;
GPX2.CON = GPX2.CON & (~(0xF << 28)) | (0x1 << 28);
GPX1.CON = GPX1.CON & (~(0xF)) | (0x1);
GPF3.CON = GPF3.CON & (~(0xFF << 16)) | (0x11 << 16);
while(1)
{
GPX2.DAT = GPX2.DAT | (1 << 7);
delay(1000000);
GPX2.DAT = GPX2.DAT & (~(1 << 7));
delay(1000000);
GPX1.DAT = GPX1.DAT | 1;
delay(1000000);
GPX1.DAT = GPX1.DAT & (~1);
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 4);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 4));
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 5);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 5));
delay(1000000);
}
return 0;
}
一直发怎么回事呢，想下之前说的我们少干了一件事清除中断标志位，就是清除挂起位
#include "exynos_4412.h"
void do_irq()
{
printf("KEY3 pressed\n");
//清除中断挂起
EXT_INT41_PEND = (1 << 1);
}
void delay(unsigned int time)
{
while(time --);
}
int main()
{
GPX1.CON = GPX1.CON | (0xF << 4);
EXT_INT41_CON = EXT_INT41_CON & (~(0x7 << 4)) | (0x2 << 4);
EXT_INT41_MASK = EXT_INT41_MASK & (~(1 << 1));
ICDDCR = ICDDCR | 1;
ICDISER.ICDISER1 = ICDISER.ICDISER1 | (1 << 25);
ICDIPTR.ICDIPTR14 = ICDIPTR.ICDIPTR14 & (~(0xFF << 8)) | (0x01 << 8);
CPU0.ICCICR = CPU0.ICCICR | 1;
GPX2.CON = GPX2.CON & (~(0xF << 28)) | (0x1 << 28);
GPX1.CON = GPX1.CON & (~(0xF)) | (0x1);
GPF3.CON = GPF3.CON & (~(0xFF << 16)) | (0x11 << 16);
while(1)
{
GPX2.DAT = GPX2.DAT | (1 << 7);
delay(1000000);
GPX2.DAT = GPX2.DAT & (~(1 << 7));
delay(1000000);
GPX1.DAT = GPX1.DAT | 1;
delay(1000000);
GPX1.DAT = GPX1.DAT & (~1);
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 4);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 4));
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 5);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 5));
delay(1000000);
}
return 0;
}我们在试试
这次没毛病了，按一下打印一行
但是有个新问题所有的IRQ异常都会跳到这里，那么我们需要区分一下，但是CPU不知道是谁发来的，所以需要询问中断控制器。
#include "exynos_4412.h"
void do_irq()
{
unsigned int IrqNum;
IrqNum = CPU0.ICCIAR & 0x3FF;
switch(IrqNum)
{
case 0:
//0号中断处理程序
break;
case 1:
break;
case 57:
printf("KEY3 pressed\n");
//清除中断挂起
EXT_INT41_PEND = (1 << 1);
break;
case 159:
break;
default:
break;
}
}
void delay(unsigned int time)
{
while(time --);
}
int main()
{
GPX1.CON = GPX1.CON | (0xF << 4);
EXT_INT41_CON = EXT_INT41_CON & (~(0x7 << 4)) | (0x2 << 4);
EXT_INT41_MASK = EXT_INT41_MASK & (~(1 << 1));
ICDDCR = ICDDCR | 1;
ICDISER.ICDISER1 = ICDISER.ICDISER1 | (1 << 25);
ICDIPTR.ICDIPTR14 = ICDIPTR.ICDIPTR14 & (~(0xFF << 8)) | (0x01 << 8);
CPU0.ICCICR = CPU0.ICCICR | 1;
GPX2.CON = GPX2.CON & (~(0xF << 28)) | (0x1 << 28);
GPX1.CON = GPX1.CON & (~(0xF)) | (0x1);
GPF3.CON = GPF3.CON & (~(0xFF << 16)) | (0x11 << 16);
while(1)
{
GPX2.DAT = GPX2.DAT | (1 << 7);
delay(1000000);
GPX2.DAT = GPX2.DAT & (~(1 << 7));
delay(1000000);
GPX1.DAT = GPX1.DAT | 1;
delay(1000000);
GPX1.DAT = GPX1.DAT & (~1);
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 4);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 4));
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 5);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 5));
delay(1000000);
}
return 0;
}
只有第一次好使，后面都不好使了
因为中断控制器不知道CPU0已经处理完中断处理程序了，所以并没有将新的中断信号发送给CPU0
#include "exynos_4412.h"
void do_irq()
{
unsigned int IrqNum;
IrqNum = CPU0.ICCIAR & 0x3FF;
switch(IrqNum)
{
case 0:
//0号中断处理程序
break;
case 1:
break;
case 57:
printf("KEY2 pressed\n");
//清除中断挂起
EXT_INT41_PEND = (1 << 1);
//将当前中断号写回中断控制器
//告知中断处理完成
CPU0.ICCEOIR = CPU0.ICCEOIR & (~(0x3FF)) | 57;
break;
case 159:
break;
default:
break;
}
}
void delay(unsigned int time)
{
while(time --);
}
int main()
{
GPX1.CON = GPX1.CON | (0xF << 4);
EXT_INT41_CON = EXT_INT41_CON & (~(0x7 << 4)) | (0x2 << 4);
EXT_INT41_MASK = EXT_INT41_MASK & (~(1 << 1));
ICDDCR = ICDDCR | 1;
ICDISER.ICDISER1 = ICDISER.ICDISER1 | (1 << 25);
ICDIPTR.ICDIPTR14 = ICDIPTR.ICDIPTR14 & (~(0xFF << 8)) | (0x01 << 8);
CPU0.ICCICR = CPU0.ICCICR | 1;
GPX2.CON = GPX2.CON & (~(0xF << 28)) | (0x1 << 28);
GPX1.CON = GPX1.CON & (~(0xF)) | (0x1);
GPF3.CON = GPF3.CON & (~(0xFF << 16)) | (0x11 << 16);
while(1)
{
GPX2.DAT = GPX2.DAT | (1 << 7);
delay(1000000);
GPX2.DAT = GPX2.DAT & (~(1 << 7));
delay(1000000);
GPX1.DAT = GPX1.DAT | 1;
delay(1000000);
GPX1.DAT = GPX1.DAT & (~1);
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 4);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 4));
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 5);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 5));
delay(1000000);
}
return 0;
} 
这次没问题了。
真正开发时有操作系统，我们其实只需要写中断程序，然后打开对应中断就可以
FIQ为什么比IRQ快：
1）FIQ的优先级比IRQ高
2）FIQ可以打断IRQ
3）FIQ在异常向量表的最末，别的中断处理程序要跳一下，但是FIQ可以直接在这里接着写
4）FIQ有四组直接独有的寄存器，他不需要压栈保护现场如果只需要r8-r12的话。但是如果用到了
r0-r7还是要压栈保护现场的。
32有中断优先级的概念，但是三星的猎户座只有FIQ和IRQ这两个级别
五、用key3再试一试
58号
还是下降沿触发
把咱们的INT1【2】打开
由于KEY2已经开了外部中断就不在写了
然后找到58号将58号打开
58-32=26
每个寄存器确定4个中断
58/4 = 14……2 （0-159，所以是第三个位置第2号就是左移16位）
同样中断控制器和CPU之间的开关只需要闭合一次因为都是CPU0
读取哪个中断
清除2号中断挂起，已经发生了就不会在挂起
告知中断控制器中断58处理完成
#include "exynos_4412.h"
unsigned int flag = 1;
void do_irq()
{
unsigned int IrqNum;
IrqNum = CPU0.ICCIAR & 0x3FF;
switch(IrqNum)
{
case 0:
//0号中断处理程序
break;
case 1:
break;
case 57:
printf("KEY2 pressed\n");
//清除中断挂起
EXT_INT41_PEND = (1 << 1);
//将当前中断号写回中断控制器
//告知中断处理完成
CPU0.ICCEOIR = CPU0.ICCEOIR & (~(0x3FF)) | 57;
break;
case 58:
printf("KEY3 pressed\n");
if(flag == 1)
{
GPX2.DAT = GPX2.DAT | (1 << 7);
flag = 0;
}else
{
GPX2.DAT = GPX2.DAT & (~(1 << 7));
flag = 1;
}
EXT_INT41_PEND = (1 << 2);
CPU0.ICCEOIR = CPU0.ICCEOIR & (~(0x3FF)) | 58;
break;
case 159:
break;
default:
break;
}
}
void delay(unsigned int time)
{
while(time --);
}
int main()
{
GPX1.CON = GPX1.CON | (0xF << 4);//KEY2
EXT_INT41_CON = EXT_INT41_CON & (~(0x7 << 4)) | (0x2 << 4);
EXT_INT41_MASK = EXT_INT41_MASK & (~(1 << 1));
GPX1.CON = GPX1.CON | (0xF << 8);//KEY3
EXT_INT41_CON = EXT_INT41_CON & (~(0x7 << 8)) | (0x2 << 8);
EXT_INT41_MASK = EXT_INT41_MASK & (~(1 << 2));
//57
ICDDCR = ICDDCR | 1;
ICDISER.ICDISER1 = ICDISER.ICDISER1 | (1 << 25);
ICDIPTR.ICDIPTR14 = ICDIPTR.ICDIPTR14 & (~(0xFF << 8)) | (0x01 << 8);
CPU0.ICCICR = CPU0.ICCICR | 1;
//58
ICDDCR = ICDDCR | 1;
ICDISER.ICDISER1 = ICDISER.ICDISER1 | (1 << 26);
ICDIPTR.ICDIPTR14 = ICDIPTR.ICDIPTR14 & (~(0xFF << 16)) | (0x01 << 16);
CPU0.ICCICR = CPU0.ICCICR | 1;
GPX2.CON = GPX2.CON & (~(0xF << 28)) | (0x1 << 28);//LED2
GPX1.CON = GPX1.CON & (~(0xF)) | (0x1);//LED3
GPF3.CON = GPF3.CON & (~(0xFF << 16)) | (0x11 << 16);//LED4 LED5
while(1)
{
GPX2.DAT = GPX2.DAT | (1 << 7);
delay(1000000);
GPX2.DAT = GPX2.DAT & (~(1 << 7));
delay(1000000);
GPX1.DAT = GPX1.DAT | 1;
delay(1000000);
GPX1.DAT = GPX1.DAT & (~1);
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 4);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 4));
delay(1000000);
GPF3.DAT = GPF3.DAT | (1 << 5);
delay(1000000);
GPF3.DAT = GPF3.DAT & (~(1 << 5));
delay(1000000);
}
return 0;
} 