S5PV210系列 （裸机十）之按键和CPU的中断系统(一)
什么是按键
按键的物理特性
(1)、平时没人按的时候，弹簧把按键按钮弹开。此时内部断开的。
(2)、有人按下的时候，手的力量克服弹簧的弹力，将按钮按下，此时内部保持接通（闭合）状态；如果手拿开，则弹簧作用下按钮又弹开，同时内部又断开。
(3)、一般的按键都有 4 个引脚，这 4 个引脚成 2 对：其中一对是常开触点（像上面描述的不按则断开，按下则闭合）；一对是常闭触点（平时不按时是闭合的，按下后是断开的）
按键的电学原理（结合原理图分析）
(1)硬件接法： SW5 : GPH0_2 SW6 : GPH0_3 SW78910 : GPH2_0123
(2)按键的电路连接分析：平时按钮没有按下时，按钮内部断开，GPIO 引脚处电压为高电平；当有人按下按钮时，按钮内部导通，外部 VDD 经过电阻和按钮连接到地，形成回路，此时 GPIO 引脚处电压就变成了低电平。此时 VDD 电压全部分压在了电阻上（这个电阻就叫分压电阻，这个电阻不能太小，因为电阻的功率是 U*U/R ）
(3)总结：按键的工作方法：其实就是按键的按下与弹开，分别对应 GPIO 的两种电平状态（按下则 GPIO 为低电平，弹开则 GPIO 为高电平）。此时 SoC 内部可以通过检测这个 GPIO 的电平高低来判断按键有没有被按下，这个判断结果即可作为 SoC 的输入信号。
按键属于输入类设备
(1)按键一般用来做输入设备（由人向 SoC 发送信息的设备，叫输入设备），由人向 SoC 发送按键信号（按键信号有 2 种：按下信号和弹开信号）。
(2)有些设备就是单纯的输入设备，譬如按键、触摸屏等；有些设备就是单纯的输出设备，譬如 LCD；还有一些设备是既能输入又能输出的，叫输入输出设备（IO），譬如串口。
按键的 2 种响应方法
(1) SoC 处理按键有 2 种思路：轮询方式和中断方式。
(2)轮询方式，就是 SoC 主动的每隔一段时间去读取（按键所对应的）GPIO 的电平高低，以此获得按键信息；缺点在于 CPU 要一直注意按键事件，会影响 CPU做其他事情。
(3)中断方式，就是 SoC 事先设定好 GPIO 触发的中断所对应的中断处理程序ISR，当外部按键按下或弹开时会自动触发 GPIO 对应的外部中断，导致 ISR 执行，从而自动处理按键信息。
轮询方式处理按键
X210 开发板的按键接法
(1)查原理图，找到按键对应的 GPIO ：SW5 : GPH0_2 SW6 : GPH0_3 SW78910:GPH2_0123
(2)原理图上可以看出：按下时是低电平，弹起时是高电平
按键对应的 GPIO 模式设置
(1)按键接到 GPIO 上，按键按下还是弹起，决定外部电路的接通与否，从而决定这个 GPIO 引脚的电压是高还是低；这个电压可以作为这个 GPIO 引脚的输入信号，此时 GPIO 配置为输入模式，即可从 SoC 内部读取该引脚的电平为 1 还是 0（1 对应高电平，0 对应低电平）。
(2) GPH0CON( 0xE0200C00 ) GPH2DAT( 0xE0200C04 ) GPH2CON( 0xE0200C40 ) GPH2DAT( 0xE0200C44 )
(3)应该在 CON 寄存器中将 GPIO 设置为 input 模式，然后去读取 DAT 寄存器（读取到的相应位的值为1表示外部是高电平（对应按键弹起），读取到的位的值为 0 表明外部是低电平（按键按下））
轮询方式处理按键的程序流程
(1)第一步，先初始化 GPIO 模式为 input
(2)第二步，循环读取 GPIO 的电平值，然后判断有无按键按下
代码编写和调试
// 定义操作寄存器的宏
#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)
// 初始化按键
void key_init(void)
{
// 设置GPHxCON寄存器，设置为输入模式
// GPH0CON的bit8～15全部设置为0，即可
rGPH0CON &= ~(0xFF<<8);
// GPH2CON的bit0～15全部设置为0，即可
rGPH2CON &= ~(0xFFFF<<0);
}
void key_polling(void)
{
// 依次，挨个去读出每个GPIO的值，判断其值为1还是0.如果为1则按键按下，为0则弹起
// 轮询的意思就是反复循环判断有无按键，隔很短时间
while (1)
{
// 对应开发板上标着LEFT的那个按键
if (rGPH0DAT & (1<<2))
{
// 为1，说明没有按键
led_off();
}
else
{
// 为0，说明有按键
led1();
}
// 对应开发板上标着DOWN的那个按键
if (rGPH0DAT & (1<<3))
{
// 为1，说明没有按键
led_off();
}
else
{
// 为0，说明有按键
led2();
}
// 对应开发板上标着UP的那个按键
if (rGPH2DAT & (1<<0))
{
// 为1，说明没有按键
led_off();
}
else
{
// 为0，说明有按键
led3();
}
}
}按键消抖
什么是按键消抖
(1) 按键这种物理器件本身会有抖动信号，抖动信号指的是在电平由高到低（也就是按键按下时）或者电平由低到高（也就是按键弹起时）过程中，电平的变化不是立刻变化，而是经过了一段时间的不稳定期才完成变化，在这个不稳定期间电平可能会时高时低反复变化，这个不稳定期就叫抖动（抖动期内获取按键信息是不可靠的，要想办法消抖）。
(2) 什么叫消抖？
消抖就是用硬件或者软件方法来尽量减小抖动期对按键获取的影响。消抖常用 2 种思路：第一是硬件消抖，消抖思路就是尽量减小抖动时间，方法是通过硬件添加电容等元件来减小抖动；第二是软件消抖，消抖思路是发现一次按键按下/弹起事件后，不立即处理按键，而是延时一段时间（一般 10〜20ms，这就是消抖时间）后再次获取按键键值，如果此次获取和上次一样是按下/弹起，那就认为真的按下/弹起了。
(3) 一般比较精密需要的时候，需要硬件消抖和软件消抖一起配合。
#include "stdio.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)
// 初始化按键
void key_init(void)
{
// 设置GPHxCON寄存器，设置为输入模式
// GPH0CON的bit8～15全部设置为0，即可
rGPH0CON &= ~(0xFF<<8);
// GPH2CON的bit0～15全部设置为0，即可
rGPH2CON &= ~(0xFFFF<<0);
}
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();
}
}
}S5PV210的中断体系介绍
什么是中断
(1)中断的发明是用来解决宏观上的并行需要的。宏观就是从整体上来看，并行就是多件事情都完成了。
(2)微观上的并行，就是指的真正的并行，就是精确到每一秒甚至每一刻，多个事情都是在同时进行的。宏观上面的并行并不等于围观的并行，有时候宏观上是并行的，微观上是串行的。
(3)例子中一个人在看电影，快递来了暂停电影跑去收快递，收完快递继续回来看电影，这个例子就是宏观上的并行和微观上的串行。例子中一个人等同于 SoC 中 1 个 CPU（也就是单核 CPU ），这个 CPU 看电影就不能收快递，收快递就不能看电影（也就是说不能真正的并行）。单核心 CPU 在微观角度是串行的，但是因为 CPU 很快，所以在宏观看来可以并行。
(4)上例中大部分时间在看电影，中间少量时间去收快递，那么类比于 CPU 来说，看电影就应该是 CPU 的常规任务，而收快递则应该是中断例程。也就是说CPU 平时一直在进行看电影任务，等快递来了（中断发生了）快递员（类似于中断源）会打电话叫人去收快递（中断源会触发中断通知 CPU 去处理中断），人收到电话（ CPU 收到中断信号）后会暂定电影（ CPU 保存常规任务的现场）跑去收快递（ CPU 去执行中断处理程序ISR处理中断），收完快递（执行完 ISR ）回来继续看电影（ CPU 恢复常规任务的现场，继续执行常规任务）
(5)为什么需要中断？因为单核 CPU 实际无法并行的，但是通过中断机制，可以实现假并行（宏观上的并行，微观上实际还是串行的）。
SoC对中断的实现机制：异常向量表
(1)异常向量表是CPU中某些特定地址的特定定义。当中断发生的时候，中断要想办法通知CPU去处理中断，怎么做到？这就要靠异常向量表。
(2)在CPU设计时，就事先定义了CPU中一些特定地址作为特定异常的入口地址（譬如定义0x00000000地址为复位异常向量地址，则发生复位异常时CPU会自动跳转到0x00000000地址去执行指令。又譬如外部中断对应的异常向量地址为0x30000008，则发生外部中断后，CPU会硬件自动跳转到0x30000008地址去执行指令。）
(3)以上讲的是CPU硬件设计时对异常向量表的支持，下来就需要软件支持了。硬件已经决定了发生什么异常CPU自动跳转PC到哪个地址去执行，软件需要做的就是把处理这个异常的代码的首地址填入这个异常向量地址。
S5PV210的异常向量表
(1)异常向量表中各个向量的相对位置是固定的，但是他们的起始地址是不固定的，各种 SoC 可以不一样，而且复杂 ARM 中还可以让用户来软件设置这个异常向量表的基地址。
(2)扩展到所有架构的 CPU 中：所有架构（譬如 51 单片机、PIC 单片机）的 CPU实现中断都是通过异常向量表实现的，这个机制是不变的；但是不同 CPU 异常向量表的构造和位置是不同的。
异常和中断的区别和联系
(1)针对 SoC 来说，发生复位、软中断、中断、快速中断、取指令异常、数据异常等，我们都统一叫异常。所以说：中断其实是异常的一种。
(2)异常的定义就是突发事件，打断了 CPU 的正常常规业务，CPU 不得不跳转到异常向量表中去执行异常处理程序；中断是异常的一种，一般特指 SoC 内的内部外设产生的打断 SoC 常规业务，或者外部中断（ SoC 的 GPIO 引脚传回来的中断）。
异常向量表的编程处理
像内存一样去访问异常向量表
(1) S5PV210 的异常向量表可以改变（在 CP15 协处理器中），以适应操作系统的需求。但是目前系统刚启动时，此时 DRAM 尚未初始化，程序都在 SRAM 中运行。210 在 iRAM 中设置了异常向量表，供暂时性使用。
(2)查 210 的 iROM application note 文档中 iRAM 的地址分配，可知，iRAM 中的异常向量表起始地址为 0xD0037400。知道了异常向量表的起始地址后，各个异常对应的入口就很好知道了。
函数名的实质就是函数的首地址
(1)函数名在 C 语言中的理解方法和变量名其实没区别。编译器会把这个函数的函数体对应的代码段和这个函数的函数名（实质是符号）对应起来，等我们在使用这个函数名符号时，编译器会将函数的函数体实际上做替换。因为函数体都不止 4 字节，而函数名这个符号只能对应 1 个地址，所以实际对应的是函数体那一个代码段的首地址。
(2)拿C语言中的语法来讲，函数名就是这个函数的函数指针。
总结：当我们将异常处理程序的首地址和异常向量表绑定起来后，异常处理初步阶段就完成了。到目前可以保证相应异常发生后，硬件自动跳转到对应异常向量表入口去执行时，可以执行到我们事先绑定的函数。
为什么中断处理要先在汇编中进行
(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 中
汇编保存现场和恢复现场
(1)保护现场关键是保存：中断处理程序的返回地址，r0-r12（cpsr是自动保存的）
(2)恢复现场主要是恢复：r0-r12，pc，cpsr
S5PV210的向量中断控制器
异常处理的 2 个阶段
(1)可以将异常处理分为 2 个阶段来理解。第一个阶段是 异常向量表 跳转；第二个阶段就是进入了真正的异常处理程序 irq_handler 之后的部分。
回顾：中断处理的第一阶段（异常向量表阶段）处理。
(1)第一个阶段之所以能够进行，主要依赖于 CPU 设计时提供的异常向量表机制。第一个阶段的主要任务是从异常发生到响应异常并且保存/恢复现场、跳转到真正的异常处理程序处。
(2)第二个阶段的目的是识别多个中断源中究竟哪一个发生了中断，然后调用相应的中断处理程序来处理这个中断。
S3C2440的第二阶段处理过程
(1)第一个问题，怎么找到具体是哪个中断：S3C2440 的中断控制器中有一个寄存器（ 32 位的），寄存器的每一个位对应一个中断源（为了解决支持更多中断源，2440 又设计了一个子中断机制。在一级中断寄存器中有一些中断是共用的一个 bit 位，譬如 AC97 和 WDT 。对于共用中断，用子中断来区分究竟是哪一个发生了中断）
(2)第二个问题，怎么找到对应的 isr 的问题：首先给每个中断做了个编号，进入isr_handler 之后先通过查阅中断源寄存器和子中断寄存器（中哪一位为 1 ）确定中断的编号，然后用这个编号去 isr 数组（ isr 数组是中断初始化时事先设定好的，就是把各个中断的 isr 的函数名组成一个数组，用中断对应的编号作为索引来查询这个数组）中查阅得到 isr 地址。
评价：2440 的中断处理设计不是特别优秀：第一个过程中使用子中断搞成 2 级的很麻烦；第二个过程中计算中断编号是个麻烦事，很耗费时间。而中断处理的时间是很宝贵的（系统有一个性能指标，叫实时性。实时性就是中断发生到响应的时间，这个时间越短越好。）
S5PV210的第二阶段处理过程
(1)第一个问题，怎么找到具体是哪个中断：S5PV210中因为支持的中断源很多，所以直接设计了4个中断寄存器，每个32位，每位对应一个中断源。（理论上210最多支持 128 个中断，实际支持不足 128 个，有些位是空的）；210 没有子中断寄存器，每个中断源都是并列的。当中断发生时，在 irq_handler 中依次去查询4个中断源寄存器，看哪一个的哪一位被置 1，则这个位对应的寄存器就发生了中断，即找到了中断编号。
(2)第二个问题，怎么找到对应的 isr 的问题：210 中支持的中断源多了很多，如果还使用 2440 的那一套来寻找 isr 地址就太慢了，太影响实时性了。于是 210 开拓了一种全新的寻找 isr 的机制。210 提供了很多寄存器来解决每个中断源对应isr 的寻找问题，具体寻找过程和建立过程见下节，实现的效果是当发生相应中断时，硬件会自动的将相应isr推入一定的寄存器中，我们软件只要去这个寄存器中执行函数就行了。
S5PV210中断处理的主要寄存器
VICnINTENABLE 和 VICnINTENCLEAR
(1) VICnINTENABLE 对应 interrupt enable，INTENCLEAR 对应 interrupt enable clear
(2) INTENABLE 寄存器 负责相应的中断的使能，INTENCLEAR 寄存器 负责相应的中断的禁止。
(3)当我们想使能（意思就是启用这个中断，意思就是当硬件产生中断时 CPU 能接收的到）某个中断时，只要在这个中断编号对应的 VICnINTENABLE 的相应bit 位写 1 即可（注意这个位写 1 其他位写 0 对其他位没有影响）；如果我们想禁止某个中断源时，只要向 VICnINTENCLEAR 中相应的位写 1 即可。
注意：这里的设计一共有 2 种：有些 CPU 是中断使能和禁止是一个寄存器位，写1就使能写 0 就进制（或者反过来写 1 就进制写 0 就使能），这样的中断使能设计就要非常小心，要使用我们之前说过的读改写三部曲来操作；另一种就是使能和禁止分开为 2 个寄存器，要使能就写使能寄存器，要禁止就写禁止寄存器。这样的好处是我们使能/禁止操作时不需要读改写，直接写即可。
VICnINTSELECT
(1)设置各个中断的模式为 irq 还是 fiq。一般都设置成 irq
(2) IRQ 和 FIQ 究竟有何区别。210 中支持 2 种中断，irq 和 fiq。irq 是普通中断，fiq 是快速中断。快速中断提供一种更快响应处理的中断通道，用于对实时性要求很高的中断源。fiq 在 CPU 设计时预先提供了一些机制保证 fiq 可以被快速处理，从而保证实时性。fiq 的限制就是只能有一个中断源被设置为 fiq，其他都是 irq。
(3) CPU 如何保证 fiq比 irq 快？有 2 个原因：第一，fiq 模式有专用的 r8〜r12，因此在 fiq 的 isr 中可以直接使用 r8-r12 而不用保存，这就能节省时间；第二，异常向量表中 fiq 是最后一个异常向量入口。因此 fiq 的 isr 不需要跳转，可以直接写在原地，这样就比其他异常少跳转一次，省了些时间。
VICnIRQSTATUS 和 VICnFIQSTATUS
(1)中断状态寄存器，是只读的。当发生了中断时，硬件会自动将该寄存器的对应位置为 1，表示中断发生了。软件在处理中断第二阶段的第一阶段，就是靠查询这个寄存器来得到中断编号的。
VICnVECTPRIORITY0〜VICnVECTPRIORITY31
(1)中断优先级设置寄存器，设置多个中断同时发生时先处理谁后处理谁的问题。一般来说高优先级的中断可以打断低优先级的中断，从而嵌套处理中断。当然了有些硬件/软件可以设置不支持中断嵌套。
VICnVECTADDR0 〜 VICnVECTADDR31、VICnADDR
(1)这三个寄存器和 210 中断处理第二阶段的第二阶段有关。
(2) VICnVECTADDR0 到 31 这 32 个寄存器分别用来存放真正的各个中断对应的isr 的函数地址。相当于每一个中断源都有一个 VECTADDR 寄存器，程序员在设置中断的时候，把这个中断的 isr 地址直接放入这个中断对应的 VECTADDR 寄存器即可。
(3) VICnADDR 这个寄存器是只需要读的，它里面的内容是由硬件自动设置的。当发生了相应中断时，硬件会自动识别中断编号，并且会自动找到这个中断的VECTADDR 寄存器，然后将其读出复制到 VICnADDR 中，供我们使用。这样的设计避免了软件查找中断源和 isr，节省了时间，提高了 210 的中断响应速度。
S5PV210中断处理的编程实践
main.c
#include "stdio.h"
void uart_init(void);
#define KEY_INTNUM NUM_EINT9 // 暂时随便找的，下节课会具体改
void key_isr(void)
{
// 暂时随便写的，下节课正式的会写到key.c中去
}
int main(void)
{
uart_init();
key_init();
// 如果程序中要使用中断，就要调用中断初始化来初步初始化中断控制器
system_init_exception();
// 绑定isr到中断控制器硬件
intc_setvectaddr(KEY_INTNUM, key_isr);
return 0;
}start.S
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}^interrup.h
#ifndef __INT_H__
#define __INT_H__
void intc_init(void);
void intc_enable(unsigned long intnum);
void intc_disable(unsigned long intnum);
void intc_setvectaddr(unsigned long intnum, void (*handler)(void));
void intc_clearvectaddr(void);
unsigned long intc_getvicirqstatus(unsigned long ucontroller);
void irq_handler(void);
void IRQ_handle(void);
void system_init_exception(void);
//// Interrupt
#define VIC0_BASE (0xF2000000)
#define VIC1_BASE (0xF2100000)
#define VIC2_BASE (0xF2200000)
#define VIC3_BASE (0xF2300000)
// VIC0
#define VIC0IRQSTATUS ( *((volatile unsigned long *)(VIC0_BASE + 0x00)) )
#define VIC0FIQSTATUS ( *((volatile unsigned long *)(VIC0_BASE + 0x04)) )
#define VIC0INTSELECT ( *((volatile unsigned long *)(VIC0_BASE + 0x0c)) )
#define VIC0INTENABLE ( *((volatile unsigned long *)(VIC0_BASE + 0x10)) )
#define VIC0INTENCLEAR ( *((volatile unsigned long *)(VIC0_BASE + 0x14)) )
#define VIC0VECTADDR (VIC0_BASE + 0x100)
#define VIC0ADDR ( *((volatile unsigned long *)(VIC0_BASE + 0xf00)) )
// VIC1
#define VIC1IRQSTATUS ( *((volatile unsigned long *)(VIC1_BASE + 0x00)) )
#define VIC1FIQSTATUS ( *((volatile unsigned long *)(VIC1_BASE + 0x04)) )
#define VIC1INTSELECT ( *((volatile unsigned long *)(VIC1_BASE + 0x0c)) )
#define VIC1INTENABLE ( *((volatile unsigned long *)(VIC1_BASE + 0x10)) )
#define VIC1INTENCLEAR ( *((volatile unsigned long *)(VIC1_BASE + 0x14)) )
#define VIC1VECTADDR (VIC1_BASE + 0x100)
#define VIC1ADDR ( *((volatile unsigned long *)(VIC1_BASE + 0xf00)) )
// VIC2
#define VIC2IRQSTATUS ( *((volatile unsigned long *)(VIC2_BASE + 0x00)) )
#define VIC2FIQSTATUS ( *((volatile unsigned long *)(VIC2_BASE + 0x04)) )
#define VIC2INTSELECT ( *((volatile unsigned long *)(VIC2_BASE + 0x0c)) )
#define VIC2INTENABLE ( *((volatile unsigned long *)(VIC2_BASE + 0x10)) )
#define VIC2INTENCLEAR ( *((volatile unsigned long *)(VIC2_BASE + 0x14)) )
#define VIC2VECTADDR (VIC2_BASE + 0x100)
#define VIC2ADDR ( *((volatile unsigned long *)(VIC2_BASE + 0xf00)) )
// VIC3
#define VIC3IRQSTATUS ( *((volatile unsigned long *)(VIC3_BASE + 0x00)) )
#define VIC3FIQSTATUS ( *((volatile unsigned long *)(VIC3_BASE + 0x04)) )
#define VIC3INTSELECT ( *((volatile unsigned long *)(VIC3_BASE + 0x0c)) )
#define VIC3INTENABLE ( *((volatile unsigned long *)(VIC3_BASE + 0x10)) )
#define VIC3INTENCLEAR ( *((volatile unsigned long *)(VIC3_BASE + 0x14)) )
#define VIC3VECTADDR (VIC3_BASE + 0x100)
#define VIC3ADDR ( *((volatile unsigned long *)(VIC3_BASE + 0xf00)) )
#define exception_vector_table_base 0xD0037400
#define exception_reset (exception_vector_table_base + 0x00)
#define exception_undef (exception_vector_table_base + 0x04)
#define exception_sotf_int (exception_vector_table_base + 0x08)
#define exception_prefetch (exception_vector_table_base + 0x0C)
#define exception_data (exception_vector_table_base + 0x10)
#define exception_irq (exception_vector_table_base + 0x18)
#define exception_fiq (exception_vector_table_base + 0x1C)
#define r_exception_reset (*(volatile unsigned int *)exception_reset)
#define r_exception_undef (*(volatile unsigned int *)exception_undef)
#define r_exception_sotf_int (*(volatile unsigned int *)exception_sotf_int)
#define r_exception_prefetch (*(volatile unsigned int *)exception_prefetch)
#define r_exception_data (*(volatile unsigned int *)exception_data)
#define r_exception_irq (*(volatile unsigned int *)exception_irq)
#define r_exception_fiq (*(volatile unsigned int *)exception_fiq)
// 中断源编号
#define INT_LIMIT (96)
//INT NUM - VIC0
#define NUM_EINT0 (0)
#define NUM_EINT1 (1)
#define NUM_EINT2 (2)
#define NUM_EINT3 (3)
#define NUM_EINT4 (4)
#define NUM_EINT5 (5)
#define NUM_EINT6 (6)
#define NUM_EINT7 (7)
#define NUM_EINT8 (8)
#define NUM_EINT9 (9)
#define NUM_EINT10 (10)
#define NUM_EINT11 (11)
#define NUM_EINT12 (12)
#define NUM_EINT13 (13)
#define NUM_EINT14 (14)
#define NUM_EINT15 (15)
#define NUM_EINT16_31 (16)
#define NUM_Reserved17 (17)
#define NUM_MDMA (18)
#define NUM_PDMA0 (19)
#define NUM_PDMA1 (20)
#define NUM_TIMER0 (21)
#define NUM_TIMER1 (22)
#define NUM_TIMER2 (23)
#define NUM_TIMER3 (24)
#define NUM_TIMER4 (25)
#define NUM_SYSTIMER (26)
#define NUM_WDT (27)
#define NUM_RTC_ALARM (28)
#define NUM_RTC_TICK (29)
#define NUM_GPIOINT (30)
#define NUM_FIMC3 (31)
//INT NUM - VIC1
#define NUM_CORTEX0 (32+0)
#define NUM_CORTEX1 (32+1)
#define NUM_CORTEX2 (32+2)
#define NUM_CORTEX3 (32+3)
#define NUM_CORTEX4 (32+4)
#define NUM_IEM_APC (32+5)
#define NUM_IEM_IEC (32+6)
#define NUM_Reserved39 (32+7)
#define NUM_NFC (32+8)
#define NUM_CFC (32+9)
#define NUM_UART0 (32+10)
#define NUM_UART1 (32+11)
#define NUM_UART2 (32+12)
#define NUM_UART3 (32+13)
#define NUM_I2C (32+14)
#define NUM_SPI0 (32+15)
#define NUM_SPI1 (32+16)
#define NUM_SPI2 (32+17)
#define NUM_AUDIO (32+18)
#define NUM_I2C_PMIC (32+19)
#define NUM_I2C_HDMI (32+20)
#define NUM_HSIRX (32+21)
#define NUM_HSITX (32+22)
#define NUM_UHOST (32+23)
#define NUM_OTG (32+24)
#define NUM_MSM (32+25)
#define NUM_HSMMC0 (32+26)
#define NUM_HSMMC1 (32+27)
#define NUM_HSMMC2 (32+28)
#define NUM_MIPI_CSI (32+29)
#define NUM_MIPI_DSI (32+30)
#define NUM_ONENAND_AUDI (32+31)
//INT NUM - VIC2
#define NUM_LCD0 (64+0)
#define NUM_LCD1 (64+1)
#define NUM_LCD2 (64+2)
#define NUM_LCD3 (64+3)
#define NUM_ROTATOR (64+4)
#define NUM_FIMC_A (64+5)
#define NUM_FIMC_B (64+6)
#define NUM_FIMC_C (64+7)
#define NUM_JPEG (64+8)
#define NUM_2D (64+9)
#define NUM_3D (64+10)
#define NUM_MIXER (64+11)
#define NUM_HDMI (64+12)
#define NUM_HDMI_I2C (64+13)
#define NUM_MFC (64+14)
#define NUM_TVENC (64+15)
#define NUM_I2S0 (64+16)
#define NUM_I2S1 (64+17)
#define NUM_I2S2 (64+18)
#define NUM_AC97 (64+19)
#define NUM_PCM0 (64+20)
#define NUM_PCM1 (64+21)
#define NUM_SPDIF (64+22)
#define NUM_ADC (64+23)
#define NUM_PENDN (64+24)
#define NUM_KEYPAD (64+25)
#define NUM_Reserved90 (64+26)
#define NUM_HASH (64+27)
#define NUM_FEEDCTRL (64+28)
#define NUM_PCM2 (64+29)
#define NUM_SDM_IRQ (64+30)
#define NUM_SMD_FIQ (64+31)
//INT NUM - VIC3
#define NUM_IPC (96+0)
#define NUM_HOSTIF (96+1)
#define NUM_HSMMC3 (96+2)
#define NUM_CEC (96+3)
#define NUM_TSI (96+4)
#define NUM_MDNIE0 (96+5)
#define NUM_MDNIE1 (96+6)
#define NUM_MDNIE2 (96+7)
#define NUM_MDNIE3 (96+8)
#define NUM_ADC1 (96+9)
#define NUM_PENDN1 (96+10)
#define NUM_ALL (200)
#endifinterrup.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)(); // 通过函数指针来调用函数
}
下一篇： 10个超好用的配色网站