一.轮询方式处理按键
参考 E:\Linux\8.key_open
二.中断方式处理按键 2017/11/21 23:30
1.异常向量表分析：
(1)、复位（RESET)
a、当处理器复位引脚有效时，系统产生复位异常中断，程序跳转到复位异常中断处理程序处执行，包括系统加电和系统复位。
b、通过设置PC跳转到复位中断向量处执行称为软复位。
(2)、未定义的指令
当ARM处理器或者是系统中的协处理器认为当前指令未定义时，产生未定义的指令异常中断，可以通过改异常中断机制仿真浮点向量运算。
(3)、软件中断
这是一个由用户定义的中断指令(SWI)。该异常由执行SWI指令产生,可用于用户模式下的程序调用特权操作指令。在实时操作系统中可以通过该机制实现系统功能调用。
(4)、指令与取终止（Prefech Abort)
如果处理器预取的指令的地址不存在，或者该地址不允许当前指令访问，当被预取的指令执行时，处理器产生指令预取终止异常中断。
(5)、数据访问终止（DATAABORT）
如果数据访问指令的目标地址不存在，或者该地址不允许当前指令访问，处理器产生数据访问终止异常中断。
(6)、外部中断请求(IRQ)
当处理器的外部中断请求引脚有效，而且CPSR的寄存器的I控制位被清除时，处理器产生外部中断请求异常中断。系统中个外设通过该异常中断请求处理服务。
(7)、快速中断请求（FIQ）
当处理器的外部快速中断请求引脚有效，而且CPSR的F控制位被清除时，处理器产生外部中断请求异常中断。
一.CPU自动处理的过程包括如下：
1、 拷贝CPSR到SPSR_
2、 设置适当的CPSR位： 改变处理器状态进入ARM状态；改变处理器模式进入相应的异常模式；设置中断禁止位禁止相应中断。
3、 更新LR_，这个寄存器中保存的是异常返回时的链接地址
4、 设置PC到相应的异常向量
异常中断处理返回
二. 异常处理完毕之后，ARM微处理器会执行以下几步操作从异常返回：
(1)、将所有修改过的用户寄存器从处理程序的保护栈中恢复。
(2)、将SPSR复制回CPSR中，将连接寄存器LR的值减去相应的偏移量后送到PC中。
(3)、若在进入异常处理时设置了中断禁止位，要在此清除。
复位异常处理程序不需要返回。
当异常发生时，内核会跳转到向量表的相应位置，并执行当中的指令。对于每一种异常，保存的返回地址都是不一样的，一般都需要我们手动的跳转，当然调整的时机也需要我们选择，是在进入处理前跳转还是返回时调整都是需要我们程序员控制的。
三.中断处理的第一阶段（异常向量表阶段）处理。 2017/11/23 22:35
第一个阶段的主要任务是从异常发生到响应异常并且保存/恢复现场、跳转到真正的异常处理程序处。
1.查210的iROM application ，iRAM中的异常向量表起始地址为0xD0037400
各个异常对应的入口就等于异常向量表的起始地址+上图中入口的偏移地址：如下图
2.中断处理保存现场，包括：第一：设置IRQ栈；第二，保存LR；第三，保存R0～R12，
1)中断处理要注意保护现场（中断从SVC模式来，则保存SVC模式下的必要寄存器的值）和恢复现场（中断处理完成后，准备返回SVC模式前，要将保存的SVC模式下的必要寄存器的值恢复回去，不然到了SVC模式后寄存器的值乱了，SVC模式下原来正在进行的常规任务就被你搞坏了）
(2)保存现场包括：第一：设置IRQ栈；第二，保存LR；第三，保存R0～R12
(3)为什么要保存LR寄存器？要考虑中断返回的问题。中断ISR执行完后如何返回SVC模式下去接着执行原来的代码。中断返回其实取决于我们进入中断时如何保存现场。中断返回时关键的2个寄存器就是PC和CPSR。所以我们在进入IRQ模式时，应该将SVC模式下的下一句指令的地址（中断返回地址）和CPSR保存起来，将来恢复时才可以将中断返回地址给PC，将保存的CPSR给CPSR。
(4)中断返回地址就保存在LR中，而CPSR（自动）保存在（IRQ模式下的）SPSR中
四、中断处理的第二阶段处理过程
第二个阶段就是进入了真正的异常处理程序irq_handler之后，目的是识别多个中断源中究竟哪一个发生了中断，然后调用相应的中断处理程序来处理这个中断。
1.第一阶段：找到具体是哪个中断：S5PV210中因为支持的中断源很多，所以直接设计了4个中断寄存器，每个32位，每位对应一个中断源。（理论上210最多支持128个中断，实际支持不足128个，有些位是空的）；210没有子中断寄存器，每个中断源都是并列的。当中断发生时，在irq_handler中依次去查询4个中断源寄存器，看哪一个的哪一位被置1，则这个位对应的寄存器就发生了中断，即找到了中断编号。
2.第二阶段，找到对应的中断服务处理isr：2210开拓了一种全新的寻找isr的机制。210提供了很多寄存器来解决每个中断源对应isr的寻找问题，实现的效果是当发生相应中断时，硬件会自动的将相应isr推入一定的寄存器中，程序员在设置中断的时候，把这个中断的isr地址直接放入这个中断对应的VECTADDR寄存器即可。
S5PV210中断处理的主要寄存器：
VIC0INTENABLE：中断使能
VIC0INTENCLEAR：中断禁止
VIC0INTSELECT：中断选择，IRQ/FIQ
VIC0IRQSTATUS：IRQ中断状态寄存器，软件在处理中断第二阶段的第一阶段，就是靠查询这个寄存器来得到中断编号的
VIC0FIQSTATUS：FIQ中断状态寄存器
VIC0VECTADDR:中断源对应的ISR地址，中断发生第二阶段如何获取isr地址由这个寄存器自动完成，只需要拿出ISR地址，调用即可
VICnVECTPRIORITY31：中断优先级设置寄存器
VIC0ADDRESS：向量地址寄存器，当有中断发生时，硬件上会将当前中断的中断服务例程ISR地址从寄存器VICVECTADDR自动拷贝到寄存器VICDDR中
总结：S5PV210的中断体系采用如下的ISR确定策略
(1)、将128个中断源分为4组，每组的ISR组成一个数组，以中断号为数组索引。
(2)、4组ISR数组的首地址分别存放在VICVECTADDR0～VICVECTADDR3中。
绑定ISR时，只需将用户自己编写的ISR地址放入ISR数组中以中断号为索引的位置即可
S5PV210中断处理流程：
1、中断处理前的准备工作
A、初始化中断控制器。
外部中断的中断控制器的初始化包括：绑定第一阶段异常向量表；外设相应GPIO引脚设置为外部中断模式、外部中断控制寄存器的初始化、中断向量控制寄存器的初始化。
内部中断的中断控制器的初始化包括：中断向量控制寄存器的初始化，
B、绑定中断源的ISR到向量中断控制器的VICnVECTADDR。
C、使能中断源中断。
问题1：如何绑定自己实现的isr到VICnVECTADDR
(1)搞清楚2个寄存器的区别：VICnVECTADDR和VICnADDR（寄存器在上面已经解释）
(1)VICVECTADDR寄存器一共有4×32个，每个中断源都有一个VECTADDR寄存器，我们应该将自己为这个中断源写的isr地址丢到这个中断源对应的VECTADDR寄存器中即可。
问题二：真正的中断处理程序如何获取isr？
(1)当发生中断时，硬件会自动把相应中断源的isr地址从VICnVECTADDR寄存器中推入VICnADDR寄存器中，所以我们第二阶段的第二阶段isr_handler中，只需要到相应的VICnADDR中去拿出isr地址，调用执行即可。
2、中断处理流程
A、异常向量表跳转到IRQ入口
CPU处理常规任务时收到中断的通知，于是S5PV210根据iROM固化代码跳转到iRAM的异常向量表的IRQ异常向量地址。一般将负责保护现场、处理中断、恢复现场的汇编代码段的起始地址赋值给IRQ异常向量地址，作为处理中断的入口。
B、保护中断现场（在start.S中），然后跳入isr_handler
处理中断之前先要保护总线 现场，主要工作是：设置IRQ模式下的栈，将R0-R12，LR压栈保存（由于流水线的原因，LR一般为当前执行的指令地址加8，LR减去4就是下一条要运行指令的地址）。
C、执行中断处理程序
在isr_handler中先去搞清楚是哪个VIC中断了。查看VICnADDR寄存器是否有ISR函数地址，如果有，执行ISR。一般在中断发生之前已经绑定好ISR到VICnVECTADDR。
D、恢复现场
执行ISR后，将栈中的R0-R12，LR分别出栈R0-R12，PC，程序将根据PC的值自动跳转会到常规任务执行。
六、S5PV210中断处理
1.S5PV210的外部中断通过外部中断对应的GPIO产生
外部中断寄存器位于文档中GPIO部分。
外部中断的主要寄存器：
EXT_INT_N_CON：设置外部中断的触发方式
EXT_INT_N_PEND：中断挂起寄存器，32位，每位对应一个外部中断源，
EXT_INT_N_MASK:中断掩码控制寄存器，各个外部中断的使能/禁止开关。
分析X210开发板的按键对应的EINT编号：
GPIO ：SW5:GPH0_2 SW6:GPH0_3 SW78910:GPH2_0123
EINT ：EINT2、EINT3、EINT16、EINT17、EINT18、EINT19
2.中断方式处理按键编程
-
按键的初始化（包括外部中断的GPIO，触发模式等设置，分开说明）
2.1. 外部中断对应的GPIO模式设置
rGPH0CON |= 0xFF<<8; // GPH0_2 GPH0_3设置为外部中断模式
rGPH2CON |= 0xFFFF<<0;// GPH2_0123共4个引脚设置为外部中断模式
![]()
.
![]()
2.2. 中断触发模式设置
rEXT_INT_0_CON &= ~(0xFF<<8); // bit8~bit15全部清零
rEXT_INT_0_CON |= ((2<<8)|(2<<12)); // EXT_INT2和EXT_INT3设置为下降沿触发
rEXT_INT_2_CON &= ~(0xFFFF<<0); //EINT16、17、18、19，设置为下降沿触发
rEXT_INT_2_CON |= ((2<<0)|(2<<4)|(2<<8)|(2<<12)); 按键的初始化（包括外部中断的GPIO，触发模式等设置）的整合如下：
2.3. 中断允许
rEXT_INT_0_MASK &= ~(3<<2); // 外部中断允许
rEXT_INT_2_MASK &= ~(0x0f<<0);
![]()
![]()
2.4. 清挂起，清除是写1，不是写0
rEXT_INT_0_PEND |= (3<<2);
rEXT_INT_2_PEND |= (0x0F<<0);
按键的初始化（包括外部中断的GPIO，触发模式等设置）的整合如下：
![]()
3.中断处理程序isr编写及其整体调用
3.1.中断ISR处理函数的编写，即（类似于STM32的中断服务函数）
3.2.绑定isr到中断控制器硬件
3.3.使能中断（不是使能外部中断（因前面的中断初始化已经使能），是使能中断控制器）
3.4.整体调用如下：
3.5最后，上面的理解在结合下图 一起理解，就显得很简单了。
中断处理的编程模型：
int.c:
#include "int.h"
#include "stdio.h"
void reset_exception(void)
{
printf("reset_exception.\n");
}
void undef_exception(void)
{
printf("undef_exception.\n");
}
void sotf_int_exception(void)
{
printf("sotf_int_exception.\n");
}
void prefetch_exception(void)
{
printf("prefetch_exception.\n");
}
void data_exception(void)
{
printf("data_exception.\n");
}
// 主要功能：绑定第一阶段异常向量表；禁止所有中断；选择所有中断类型为IRQ；
// 清除VICnADDR为0
void system_init_exception(void)
{
// 第一阶段处理，绑定异常向量表
r_exception_reset = (unsigned int)reset_exception;
r_exception_undef = (unsigned int)undef_exception;
r_exception_sotf_int = (unsigned int)sotf_int_exception;
r_exception_prefetch = (unsigned int)prefetch_exception;
r_exception_data = (unsigned int)data_exception;
r_exception_irq = (unsigned int)IRQ_handle;
r_exception_fiq = (unsigned int)IRQ_handle;
// 初始化中断控制器的基本寄存器
intc_init();
}
// 清除需要处理的中断的中断处理函数的地址
void intc_clearvectaddr(void)
{
// VICxADDR:当前正在处理的中断的中断处理函数的地址
VIC0ADDR = 0;
VIC1ADDR = 0;
VIC2ADDR = 0;
VIC3ADDR = 0;
}
// 初始化中断控制器
void intc_init(void)
{
// 禁止所有中断
// 为什么在中断初始化之初要禁止所有中断？
// 因为中断一旦打开，因为外部或者硬件自己的原因产生中断后一定就会寻找isr
// 而我们可能认为自己用不到这个中断就没有提供isr，这时它自动拿到的就是乱码
// 则程序很可能跑飞，所以不用的中断一定要关掉。
// 一般的做法是先全部关掉，然后再逐一打开自己感兴趣的中断。一旦打开就必须
// 给这个中断提供相应的isr并绑定好。
VIC0INTENCLEAR = 0xffffffff;
VIC1INTENCLEAR = 0xffffffff;
VIC2INTENCLEAR = 0xffffffff;
VIC3INTENCLEAR = 0xffffffff;
// 选择中断类型为IRQ
VIC0INTSELECT = 0x0;
VIC1INTSELECT = 0x0;
VIC2INTSELECT = 0x0;
VIC3INTSELECT = 0x0;
// 清VICxADDR
intc_clearvectaddr();
}
// 绑定我们写的isr到VICnVECTADDR寄存器
// 绑定过之后我们就把isr地址交给硬件了，剩下的我们不用管了，硬件自己会处理
// 等发生相应中断的时候，我们直接到相应的VICnADDR中去取isr地址即可。
// 参数：intnum是int.h定义的物理中断号，handler是函数指针，就是我们写的isr
// VIC0VECTADDR定义为VIC0VECTADDR0寄存器的地址，就相当于是VIC0VECTADDR0～31这个
// 数组（这个数组就是一个函数指针数组）的首地址，然后具体计算每一个中断的时候
// 只需要首地址+偏移量即可。
void intc_setvectaddr(unsigned long intnum, void (*handler)(void))
{
//VIC0
if(intnum<32)
{
*( (volatile unsigned long *)(VIC0VECTADDR + 4*(intnum-0)) ) = (unsigned)handler;
}
//VIC1
else if(intnum<64)
{
*( (volatile unsigned long *)(VIC1VECTADDR + 4*(intnum-32)) ) = (unsigned)handler;
}
//VIC2
else if(intnum<96)
{
*( (volatile unsigned long *)(VIC2VECTADDR + 4*(intnum-64)) ) = (unsigned)handler;
}
//VIC3
else
{
*( (volatile unsigned long *)(VIC3VECTADDR + 4*(intnum-96)) ) = (unsigned)handler;
}
return;
}
// 使能中断
// 通过传参的intnum来使能某个具体的中断源，中断号在int.h中定义，是物理中断号
void intc_enable(unsigned long intnum)
{
unsigned long temp;
// 确定intnum在哪个寄存器的哪一位
// <32就是0～31，必然在VIC0
if(intnum<32)
{
temp = VIC0INTENABLE;
temp |= (1<<intnum); // 如果是第一种设计则必须位操作，第二种设计可以
// 直接写。
VIC0INTENABLE = temp;
}
else if(intnum<64)
{
temp = VIC1INTENABLE;
temp |= (1<<(intnum-32));
VIC1INTENABLE = temp;
}
else if(intnum<96)
{
temp = VIC2INTENABLE;
temp |= (1<<(intnum-64));
VIC2INTENABLE = temp;
}
else if(intnum<NUM_ALL)
{
temp = VIC3INTENABLE;
temp |= (1<<(intnum-96));
VIC3INTENABLE = temp;
}
// NUM_ALL : enable all interrupt
else
{
VIC0INTENABLE = 0xFFFFFFFF;
VIC1INTENABLE = 0xFFFFFFFF;
VIC2INTENABLE = 0xFFFFFFFF;
VIC3INTENABLE = 0xFFFFFFFF;
}
}
// 禁止中断
// 通过传参的intnum来禁止某个具体的中断源，中断号在int.h中定义，是物理中断号
void intc_disable(unsigned long intnum)
{
unsigned long temp;
if(intnum<32)
{
temp = VIC0INTENCLEAR;
temp |= (1<<intnum);
VIC0INTENCLEAR = temp;
}
else if(intnum<64)
{
temp = VIC1INTENCLEAR;
temp |= (1<<(intnum-32));
VIC1INTENCLEAR = temp;
}
else if(intnum<96)
{
temp = VIC2INTENCLEAR;
temp |= (1<<(intnum-64));
VIC2INTENCLEAR = temp;
}
else if(intnum<NUM_ALL)
{
temp = VIC3INTENCLEAR;
temp |= (1<<(intnum-96));
VIC3INTENCLEAR = temp;
}
// NUM_ALL : disable all interrupt
else
{
VIC0INTENCLEAR = 0xFFFFFFFF;
VIC1INTENCLEAR = 0xFFFFFFFF;
VIC2INTENCLEAR = 0xFFFFFFFF;
VIC3INTENCLEAR = 0xFFFFFFFF;
}
return;
}
// 通过读取VICnIRQSTATUS寄存器，判断其中哪个有一位为1，来得知哪个VIC发生中断了
unsigned long intc_getvicirqstatus(unsigned long ucontroller)
{
if(ucontroller == 0)
return VIC0IRQSTATUS;
else if(ucontroller == 1)
return VIC1IRQSTATUS;
else if(ucontroller == 2)
return VIC2IRQSTATUS;
else if(ucontroller == 3)
return VIC3IRQSTATUS;
else
{}
return 0;
}
// 真正的中断处理程序。意思就是说这里只考虑中断处理，不考虑保护/恢复现场
void irq_handler(void)
{
//printf("irq_handler.\n");
// SoC支持很多个（在低端CPU例如2440中有30多个，在210中有100多个）中断
// 这么多中断irq在第一个阶段走的是一条路，都会进入到irq_handler来
// 我们在irq_handler中要去区分究竟是哪个中断发生了，然后再去调用该中断
// 对应的isr。
// 虽然硬件已经自动帮我们把isr放入了VICnADDR中，但是因为有4个，所以我们必须
// 先去软件的检查出来到底哪个VIC中断了，也就是说isr到底在哪个VICADDR寄存器中
unsigned long vicaddr[4] = {VIC0ADDR,VIC1ADDR,VIC2ADDR,VIC3ADDR};
int i=0;
void (*isr)(void) = NULL;
for(i=0; i<4; i++)
{
// 发生一个中断时，4个VIC中有3个是全0，1个的其中一位不是0
if(intc_getvicirqstatus(i) != 0)
{
isr = (void (*)(void)) vicaddr[i];
break;
}
}
(*isr)(); // 通过函数指针来调用函数
}
key.c:
#include "stdio.h"
#include "main.h"
// 定义操作寄存器的宏
#define GPH0CON 0xE0200C00
#define GPH0DAT 0xE0200C04
#define GPH2CON 0xE0200C40
#define GPH2DAT 0xE0200C44
#define rGPH0CON (*(volatile unsigned int *)GPH0CON)
#define rGPH0DAT (*(volatile unsigned int *)GPH0DAT)
#define rGPH2CON (*(volatile unsigned int *)GPH2CON)
#define rGPH2DAT (*(volatile unsigned int *)GPH2DAT)
#define EXT_INT_0_CON 0xE0200E00
#define EXT_INT_2_CON 0xE0200E08
#define EXT_INT_0_PEND 0xE0200F40
#define EXT_INT_2_PEND 0xE0200F48
#define EXT_INT_0_MASK 0xE0200F00
#define EXT_INT_2_MASK 0xE0200F08
#define rEXT_INT_0_CON (*(volatile unsigned int *)EXT_INT_0_CON)
#define rEXT_INT_2_CON (*(volatile unsigned int *)EXT_INT_2_CON)
#define rEXT_INT_0_PEND (*(volatile unsigned int *)EXT_INT_0_PEND)
#define rEXT_INT_2_PEND (*(volatile unsigned int *)EXT_INT_2_PEND)
#define rEXT_INT_0_MASK (*(volatile unsigned int *)EXT_INT_0_MASK)
#define rEXT_INT_2_MASK (*(volatile unsigned int *)EXT_INT_2_MASK)
//------------------------轮询方式处理按键---------------------------
// 初始化按键
void key_init(void)
{
// 设置GPHxCON寄存器，设置为输入模式
// GPH0CON的bit8～15全部设置为0，即可
rGPH0CON &= ~(0xFF<<8);
// GPH2CON的bit0～15全部设置为0，即可
rGPH2CON &= ~(0xFFFF<<0);
}
static void delay20ms(void)
{
// 这个函数作用是延时20ms
// 因为我们这里是裸机程序，且重点不是真的要消抖，而是教学
// 所以我这里这个程序只是象征性的，并没有实体
// 如果是研发，那就要花时间真的调试出延时20ms的程序
int i, j;
for (i=0; i<100; i++)
{
for (j=0; j<1000; j++)
{
i * j;
}
}
}
void key_polling(void)
{
// 依次，挨个去读出每个GPIO的值，判断其值为1还是0.如果为1则按键按下，为0则弹起
// 轮询的意思就是反复循环判断有无按键，隔很短时间
while (1)
{
// 对应开发板上标着LEFT的那个按键
if (rGPH0DAT & (1<<2))
{
// 为1，说明没有按键
led_off();
}
else
{
// 添加消抖
// 第一步，延时
delay20ms();
// 第二步，再次检验按键状态
if (!(rGPH0DAT & (1<<2)))
{
// 为0，说明有按键
led1();
printf("key left.\n");
}
}
// 对应开发板上标着DOWN的那个按键
if (rGPH0DAT & (1<<3))
{
// 为1，说明没有按键
led_off();
}
else
{
// 为0，说明有按键
led2();
printf("key down.\n");
}
// 对应开发板上标着UP的那个按键
if (rGPH2DAT & (1<<0))
{
// 为1，说明没有按键
led_off();
}
else
{
// 为0，说明有按键
led3();
}
}
}
//-----------------------中断方式处理按键-----------------------------------
// 以中断方式来处理按键的初始化
void key_init_interrupt(void)
{
// 1. 外部中断对应的GPIO模式设置
rGPH0CON |= 0xFF<<8; // GPH0_2 GPH0_3设置为外部中断模式
rGPH2CON |= 0xFFFF<<0; // GPH2_0123共4个引脚设置为外部中断模式
// 2. 中断触发模式设置
rEXT_INT_0_CON &= ~(0xFF<<8); // bit8~bit15全部清零
rEXT_INT_0_CON |= ((2<<8)|(2<<12)); // EXT_INT2和EXT_INT3设置为下降沿触发
rEXT_INT_2_CON &= ~(0xFFFF<<0);
rEXT_INT_2_CON |= ((2<<0)|(2<<4)|(2<<8)|(2<<12));
// 3. 中断允许
rEXT_INT_0_MASK &= ~(3<<2); // 外部中断允许
rEXT_INT_2_MASK &= ~(0x0f<<0);
// 4. 清挂起，清除是写1，不是写0
rEXT_INT_0_PEND |= (3<<2);
rEXT_INT_2_PEND |= (0x0F<<0);
}
// EINT2通道对应的按键，就是GPH0_2引脚对应的按键，就是开发板上标了LEFT的那个按键
void isr_eint2(void)
{
// 真正的isr应该做2件事情。
// 第一，中断处理代码，就是真正干活的代码
printf("isr_eint2_LEFT.\n");
// 第二，清除中断挂起(中断处理后，必须清除中断挂起)
rEXT_INT_0_PEND |= (1<<2);
intc_clearvectaddr();//清除需要处理的中断的中断处理函数的地址
}
void isr_eint3(void)
{
// 真正的isr应该做2件事情。
// 第一，中断处理代码，就是真正干活的代码
printf("isr_eint3_DOWN.\n");
// 第二，清除中断挂起
rEXT_INT_0_PEND |= (1<<3);
intc_clearvectaddr();// 清除需要处理的中断的中断处理函数的地址
}
void isr_eint16171819(void)
{
// 真正的isr应该做2件事情。
// 第一，中断处理代码，就是真正干活的代码
// 因为EINT16～31是共享中断，所以要在这里再次去区分具体是哪个子中断
if (rEXT_INT_2_PEND & (1<<0))
{
printf("eint16\n");
}
if (rEXT_INT_2_PEND & (1<<1))
{
printf("eint17\n");
}
if (rEXT_INT_2_PEND & (1<<2))
{
printf("eint18\n");
}
if (rEXT_INT_2_PEND & (1<<3))
{
printf("eint19\n");
}
// 第二，清除中断挂起
rEXT_INT_2_PEND |= (0x0f<<0);
intc_clearvectaddr();
}
start.S:
#define WTCON 0xE2700000
#define SVC_STACK 0xd0037d80
#define IRQ_STACK 0xd0037f80
.global _start
.global IRQ_handle
// 把_start链接属性改为外部，这样其他文件就可以看见_start了
_start:
// 第1步：关看门狗（向WTCON的bit5写入0即可）
ldr r0, =WTCON
ldr r1, =0x0
str r1, [r0]
// 第2步：初始化时钟
bl clock_init
// 第3步：设置SVC栈
ldr sp, =SVC_STACK
// 第4步：开/关icache
mrc p15,0,r0,c1,c0,0; // 读出cp15的c1到r0中
//bic r0, r0, #(1<<12) // bit12 置0 关icache
orr r0, r0, #(1<<12) // bit12 置1 开icache
mcr p15,0,r0,c1,c0,0;
bl main
// 从这里之后就可以开始调用C程序了
//bl led_blink // led_blink是C语言实现的一个函数
// 汇编最后的这个死循环不能丢
b .
// 在这个汇编函数中，用来做中断模式下的现场保护和恢复，并且调用真正的中断处理程序
IRQ_handle:
// 设置IRQ模式下的栈
ldr sp, =IRQ_STACK
// 保存LR
// 因为ARM有流水线，所以PC的值会比真正执行的代码+8，
sub lr, lr, #4
// 保存r0-r12和lr到irq模式下的栈上面
stmfd sp!, {r0-r12, lr}
// 在此调用真正的isr来处理中断
bl irq_handler
// 处理完成开始恢复现场,其实就是做中断返回，关键是将r0-r12，pc，cpsr一起回复
ldmfd sp!, {r0-r12, pc}^
main.c:
#include "stdio.h"
#include "int.h"
#include "main.h"
void uart_init(void);
#define KEY_EINT2 NUM_EINT2 // left NUM_EINT2为按键对应中断源编号
#define KEY_EINT3 NUM_EINT3 // down
#define KEY_EINT16_19 NUM_EINT16_31 // 其余4个共用的
void delay(int i)
{
volatile int j = 10000;
while (i--)
while(j--);
}
int main(void)
{
uart_init();
key_init_interrupt();//中断方式处理按键的初始化
// 如果程序中要使用中断，就要调用中断初始化来初步初始化中断控制器
system_init_exception();
printf("-------------key interrypt test--------------");
// 绑定isr到中断控制器硬件
intc_setvectaddr(KEY_EINT2, isr_eint2);
intc_setvectaddr(KEY_EINT3, isr_eint3);
intc_setvectaddr(KEY_EINT16_19, isr_eint16171819);
// 使能中断
intc_enable(KEY_EINT2);
intc_enable(KEY_EINT3);
intc_enable(KEY_EINT16_19);
// 在这里加个心跳
while (1)
{
printf("A ");
delay(10000);
}
return 0;
}
作者：wangweijundeqq 发表于2017/11/25 16:13:38
原文链接
.
