Main函数之Isr-Init分析.doc

飞凌2440 Bootloader学习中的若干问题
1. 2440init.s分析
1） 关于HANDLER宏定义
MACRO
$HandlerLabel HANDLER $HandleLabel ;宏定义
$HandlerLabel
;由于ADS仅支持FD（满递减）型堆栈
sub sp, sp,#4 ;将堆栈退一个字用于保存下面用到的R0
stmfd sp!,{r0} ;将R0压入堆栈
ldr r0,=$HandleLabel ;将HandleLabel的地址赋给R0
ldr r0,[r0] ;将HandleLabel的地址指向的内容
;(实际的中断函数的执行地址)赋给R0
str r0,[sp,#4] ;将对应的中断函数首地址入栈保护
ldmfd sp!,{r0,pc} ;将中断函数的首地址出栈，放入PC中，系统将跳转到
;对应中断处理函数
MEND

HANDLER 是宏名。$HandlerLabel是宏展开后要被别的字符替换掉的标号，不过不叫参数。
例如：HandlerFIQ HANDLER HandleFIQ
展开后为：
HandlerFIQ
sub sp,sp,#4
stmfd sp!,{r0}
ldr r0,=HandleFIQ
ldr r0,[r0]
str r0,[sp,#4]
ldmfd sp!,{r0,pc}
启动代码中有很多的类似下面的语句：
HandlerFIQ HANDLER HandleFIQ
HandlerIRQ HANDLER HandleIRQ
HandlerUndef HANDLER HandleUndef
HandlerSWI HANDLER HandleSWI
HandlerDabort HANDLER HandleDabort
HandlerPabort HANDLER HandlePabort
等等
该宏定义的代码用于将对应中断服务程序ISR的入口地址装载到PC中，可称之为“加载程序”。本初始化程序定义了一个34个字空间的数据区（文件最后），用于存放相应中断服务程序的首地址。每个字空间都有一个标号，以HandleXXX命名。在向量中断模式下使用“加载程序”来执行中断服务程序。
在_ISR_STARTADDRESS=0x33FF_FF00里定义的第一级中断向量表是采用型如Handle***的方式的. 而在程序的ENTRY处(程序开始处)采用的是b Handler***的方式.
在这里Handler***就是通过HANDLER这个宏和Handle***进立联系的.这种方式的优点就是正真定义的向量数据在内存空间里,而不是在ENTRY处的ROM(FLASH)空间里, 这样,我们就可以在程序里灵活的改动向量的数据了.其中HANDLER是一个宏，用于查找中断处理程序的入口地址。这些地址存放在由HandleXXX指向的表项中，该表定位在RAM高端，基地址为_ISR_STARTADDRESS。假如_ISR_STARTADDRESS为 0x800000000,当IRQ中断时,根据b HandlerFIQ,先跳转再根据^ _ISR_STARTADDRESS基地址+HandleIRQ 的偏移地址(4*6)得到的中断地址
0x80000000+0x00000024=0x80000024
2）
ALIGN
AREA RamData, DATA, READWRITE
^ _ISR_STARTADDRESS ; _ISR_STARTADDRESS=0x33FF_FF00
HandleReset # 4
HandleUndef # 4
HandleSWI # 4
HandlePabort # 4
HandleDabort # 4
Ø 这个^起什么作用的呢？
^,是ARM汇编中的一个伪操作，和MAP是同义词，用来定义一个结构化的内存表的首地址。
#，也是一个伪操作，和FIELD是同义词，用来定义结构化的内存表中的一个数据域。
Ø bootloader设定的中断向量表在启动Wince系统之后是不是就没用了？
没有用了，进入CE后会重新初始化中断向量的。
Ø 那么是Wince在启动之后, 自己又重新设定了中断向量表？在哪个文件中设定的呢？又把向量表保存在哪了？
OAL的startup.s中会调用KernelStart，里面会设置向量表。可以参考%_WINCEROOT%\PRIVATE\WINCEOS\COREOS\NK\KERNEL\ARM\armtrap.s。

2.

初始化中断服务程序。当中断产生时，处理相应的程序
void Isr_Init(void)
{
pISR_UNDEF=(unsigned)HaltUndef;
pISR_SWI =(unsigned)HaltSwi;
pISR_PABORT=(unsigned)HaltPabort;
pISR_DABORT=(unsigned)HaltDabort;
rINTMOD=0x0;    // All=IRQ mode
rINTMSK=BIT_ALLMSK;    // All interrupt is masked.
}
pISR_UNDEF=(unsigned)HaltUndef;   就是将函数HaltUndef的地址强制转换为unsigned类型，赋给指针pISR_UNDEF。由pISR_UNDEF定义知，
#define pISR_UNDEF        (*(unsigned *)(_ISR_STARTADDRESS+0x4))
pISR_UNDEF为相应的异常中断地址。 函数名称代表函数的地址，即将HaltUndef函数的地址赋值到_ISR_STARTADDRESS+0x4中。 当发生中断时,系统会去pISR_UNDEF定义的地址里取出中断函数的地址也就是HaltUndef的地址,然后执行. 就相当于当发生中断时,执行HaltUndef函数.

void HaltUndef(void)
{
Uart_Printf("Undefined instruction exception!!!\n");
while(1);
}
注意：
unsigned long *p
p=((unsigned long *) 0x80001000);
上面2句可以写成
unsigned long *p=((unsigned long *) 0x80001000);
*p=0x55555555, 就是给地址 0x80001000 写 0x55555555
＃define AT91C_SDRAM ((unsigned int *) 0x 20000000) // 根据sdram的地址进行修改

unsinged int *pTemp =AT91C_SDRAM ，指针pTemp 的地址为 0x 20000000

/* Pin Connect Block */
#define PINSEL0 (*((volatile unsigned long *) 0xE002C000))
#define PINSEL1 (*((volatile unsigned long *) 0xE002C004))
#define PINSEL2 (*((volatile unsigned long *) 0xE002C014))

PINSEL0 = 0x00050000; 地址0xE002C000 的值为 0x00050000
首先(volatile unsigned long *) 0x48000000的意思是把0x48000000强制转换成volatile unsigned long类型的指针，即对指针的操作的范围是从0x48000000开始的4个字节(long型).暂记为p，那么就是
#define A *p，即A为P指针指向位置的内容了。这里就是通过内存寻址访问到寄存器A，可以读/写操作!

表示处理相应中断。
1. /********************************************************************
2. * 名称：Timer1_ISR()
3. * 功能：定时器1中断服务程序
4. * 入口参数：
5. ********************************************************************/
6. void __irq Timer1_ISR(void)
7. {
8.
9.        static int count;
10.        count ++;
11.        rSRCPND = rSRCPND | (0x1<<11);
12.        rINTPND = rINTPND | (0x1<<11);
13.
14.        //每隔为1秒蜂鸣器响一次，持续时间为0.5秒
15.        if (count % 1000 ==0)
16.               rGPADAT |= (1<<16);                        //蜂鸣器响
17.        else if (count % 1000 ==500)
18.               rGPADAT &= ~(1<<16);                //蜂鸣器不响
19. }
复制代码

1. /********************************************************************
2. * 名称：Timer1_init()
3. * 功能：定时器1初始化
4. * 入口参数：
5. ********************************************************************/
6. void  Timer1_init(void)
7. {
8.         U32        time_val;
9.
10.         rTCFG0 = 3;                                        //配置定时器0，1的预分频值
11.         rTCFG1 = 0<<4;                                //配置定时器1分频值
12.
13.         time_val = PCLK/ (3+1) / 2 / 1000 - 1;        // 1ms = PCLK / prescaler / divider / 1000
14.         
15.         rSRCPND = rSRCPND | (0x1<<11);                        //清除中断源未决寄存器相应位
16.         rINTPND = rINTPND | (0x1<<11);                        //
17.         rINTMSK = ~(0x1<<11);                //打开定时器1中断
18.         
19.         rTCNTB1 = time_val;                        //计数缓存寄存器
20.         rTCMPB1 = time_val>>1;                // 50%
21.         
22.         rTCON &= ~(0xf<<8);                //手动更新位且配置反相器位（开/关）(手动更行位将TCNTBn和TCMPBn的值分别给TCNTn和TCMPn寄存器)
23.         rTCON |= 0xb<<8;                //定时器使能并自动重载
24.         rTCON &= ~(2<<8);                //clear manual update bit
25.         
26.         pISR_TIMER1 = (U32)Timer1_ISR;
27. }
复制代码

► 定时器报警实验
      ♥ 实验设备
      硬件：        PC机                                                        一台
      YX-AIO嵌入式综合创新设计平台        一台
      ARM9核心板                                        一块
      软件：        Windows操作系统，ADS1.2集成开发环境，H-JTAG下载环境

      ♥ 实验内容
      使用定时器中断方式控制YX-AIO嵌入式综合创新设计平台上的蜂鸣器报警。

      ♥ 实验步骤
      ① 在ADS开发环境中使用ARM9_S3C2440工程模版创建一个工程，并将程序代码添加到该工程；
      ② 在ADS开发环境中编译链接并生成目标文件；
      ③ 将JTAG下载器连接YX-AIO嵌入式综合创新设计平台，并将该平台通电；
      ④ 开启H-JTAG软件检测处理器与NOR-Flash；
      ⑤ 使用H-JTAG软件将目标文件（.bin）下载到YX-AIO嵌入式综合创新设计平台上；
      ⑥ 复位平台。
      主程序代码：
1. /********************************************************************
2. ** 文件名：main()
3. **------------------------------------------------------------------
4. **                                  长沙市元享电子科技有限公司
5. **                                      
6. **------------------------------------------------------------------
7. ** 文件名:                        main.c
8. ** 编写人:                        刘凯
9. ** 修改时间:                        2009-6-2
10. ** 描述:
11. ********************************************************************/
12. void Main(void)
13. {
14.         //----------------添加自己的代码-------------------
15.         rGPACON &= ~(1<<16);
16.         Timer1_init();
17.         while (1);

要想正确地执行2440的外部中断，一般需要完成两个部分内容：中断初始化和中断处理函数。
    在具体执行中断之前，要初始化好要用的中断。2440的外部中断引脚EINT与通用IO引脚F和G复用，要想使用中断功能，就要把相应的引脚配置成中断模式，如我们想把端口F0设置成外部中断，而其他引脚功能不变，则GPFCON=(GPFCON & ~0x3) | 0x2。配置完引脚后，还需要配置具体的中断功能。我们要打开某一中断的屏蔽，这样才能响应该中断，相对应的寄存器为INTMSK；还要设置外部中断的触发方式，如低电平、高电平、上升沿、下降沿等，相对应的寄存器为EXTINTn。另外由于EINT4到EINT7共用一个中断向量，EINT8到EINT23也共用一个中断向量，而INTMSK只负责总的中断向量的屏蔽，要具体打开某一具体的中断屏蔽，还需要设置EINTMASK。上面介绍的是最基本的初始化，当然还有一些其他的配置，如当需要用到快速中断时，要使用INTMOD，当需要配置中断优先级时，要使用PRIORITY等。
    中断处理函数负责执行具体的中断指令，除此以外还需要把SRCPND和INTPND中的相应的位清零（通过置1来清零），因为当中断发生时，2440会自动把这两个寄存器中相对应的位置1，以表示某一中断发生，如果不在中断处理函数内把它们清零，系统会一直执行该中断函数。另外还是由于前面介绍过的，有一些中断是共用一个中断向量的，而一个中断向量只能有一个中断执行函数，因此具体是哪个外部中断，还需要EINTPEND来判断，并同样还要通过置1的方式把相应的位清零。一般来说，使用__irq这个关键词来定义中断处理函数，这样系统会为我们自动保存一些必要的变量，并能够在中断处理函数执行完后正确地返回。还需要注意的是，中断处理函数不能有返回值，也不能传递任何参数。
    为了把这个中断处理函数与在2440启动文件中定义的中断向量表相对应上，需要先定义中断入口地址变量，该中断入口地址必须与中断向量表中的地址一致，然后把该中断处理函数的首地址传递给该变量，即中断入口地址。
    下面就是一个外部中断的实例。开发板上一共有四个按键，分别连到了EINT0，EINT1，EINT2和EINT4，我们让这四个按键分别控制连接在B5~B8引脚上的四个LED：按一下键则LED亮，再按一下则灭：
#define _ISR_STARTADDRESS 0x33ffff00
#define U32 unsigned int
#define pISR_EINT0            (*(unsigned *)(_ISR_STARTADDRESS+0x20))
#define pISR_EINT1            (*(unsigned *)(_ISR_STARTADDRESS+0x24))
#define pISR_EINT2            (*(unsigned *)(_ISR_STARTADDRESS+0x28))
#define pISR_EINT4_7 (*(unsigned *)(_ISR_STARTADDRESS+0x30))
#define rSRCPND     (*(volatile unsigned*)0x4a000000)      //Interrupt request status
#define rINTMSK    (*(volatileunsigned*)0x4a000008)       //Interrupt mask control
#define rINTPND   (*(volatile unsigned *)0x4a000010)       //Interrupt request status
#define rGPBCON    (*(volatile unsigned *)0x56000010) //Port B control
#define rGPBDAT    (*(volatile unsigned *)0x56000014) //Port B data
#define rGPBUP     (*(volatile unsigned *)0x56000018) //Pull-up control B
#define rGPFCON    (*(volatile unsigned *)0x56000050) //Port F control
#define rEXTINT0   (*(volatile unsigned *)0x56000088) //External interrupt control register 0
#define rEINTMASK (*(volatile unsigned *)0x560000a4) //External interrupt mask
#define rEINTPEND (*(volatile unsigned *)0x560000a8) //External interrupt pending
static void __irq Key1_ISR(void)   //EINT1
{
       int led;
       rSRCPND = rSRCPND | (0x1<<1);
       rINTPND = rINTPND | (0x1<<1);
       led = rGPBDAT & (0x1<<5);
       if (led ==0)
              rGPBDAT = rGPBDAT | (0x1<<5);
       else
              rGPBDAT = rGPBDAT & ~(0x1<<5);
}
static void __irq Key2_ISR(void)   //EINT4
{
       int led;
       rSRCPND = rSRCPND | (0x1<<4);
       rINTPND = rINTPND | (0x1<<4);
       if(rEINTPEND&(1<<4))
       {
              rEINTPEND = rEINTPEND | (0x1<<4);
              led = rGPBDAT & (0x1<<6);
              if (led ==0)
                     rGPBDAT = rGPBDAT | (0x1<<6);
              else
                     rGPBDAT = rGPBDAT & ~(0x1<<6);
       }
}
static void __irq Key3_ISR(void)   //EINT2
{
       int led;
       rSRCPND = rSRCPND | (0x1<<2);
       rINTPND = rINTPND | (0x1<<2);
       led = rGPBDAT & (0x1<<7);
       if (led ==0)
              rGPBDAT = rGPBDAT | (0x1<<7);
       else
              rGPBDAT = rGPBDAT & ~(0x1<<7);
}
void __irq Key4_ISR(void)   //EINT0
{
       int led;
       rSRCPND = rSRCPND | 0x1;
       rINTPND = rINTPND | 0x1;
       led = rGPBDAT & (0x1<<8);
       if (led ==0)
              rGPBDAT = rGPBDAT | (0x1<<8);
       else
              rGPBDAT = rGPBDAT & ~(0x1<<8);
}
void Main(void)
{
       int light;

       rGPBCON = 0x015550;
       rGPBUP = 0x7ff;
       rGPFCON = 0xaaaa;

       rSRCPND = 0x17;
       rINTMSK = ~0x17;
       rINTPND =0x17;
       rEINTPEND = (1<<4);
       rEINTMASK = ~(1<<4);
       rEXTINT0 = 0x20222;

       light = 0x0;
       rGPBDAT = ~light;

       pISR_EINT0 = (U32)Key4_ISR;
       pISR_EINT1 = (U32)Key1_ISR;
       pISR_EINT2 = (U32)Key3_ISR;
       pISR_EINT4_7 = (U32)Key2_ISR;

       while(1)
              ;     
}

-- ARM中断系统小结
初看ＡＲＭ中断系统觉得有点乱，写点东西希望对大家有点帮助　
中断详细建立过程(1)
首先我们先来看两个东西.
;/* EXCEPTION HANDLER VECTOR TABLE */

^ DRAM_BASE
HandleReset # 4
HandleUndef # 4
HandleSwi # 4
HandlePrefetch # 4
HandleAbort # 4
HandleReserv # 4
HandleIrq # 4
HandleFiq # 4
小注： 这里的^是MAP，#是FIELD
也就是在DARM的BANK0里面开始的地方定义了一个中断向量表，用于存放中断程序的入口地址。

ExceptionHandlerTable
DCD UserCodeArea
DCD SystemUndefinedHandler
DCD SystemSwiHandler
DCD SystemPrefetchHandler
DCD SystemAbortHandler
DCD SystemReserv
DCD SystemIrqHandler
DCD SystemFiqHandler
这个表中存放的是汇编程序中中断处理函数的入口地址，每一项对应一个中断函数。

下面我们从程序的开始处分析：
AREA Init, CODE, READONLY
ENTRY

B Reset_Handler
B Undefined_Handler
B SWI_Handler
B Prefetch_Handler
B Abort_Handler
NOP Reserved vector
B IRQ_Handler
B FIQ_Handler

FIQ_Handler
SUB sp, sp, #4
STMFD sp!, {r0} FD满递减堆栈 执行寄存器压栈操作.
LDR r0, =HandleFiq 汇编里的处理函数地址，然后跳到C中,在DRAM。
LDR r0, [r0] 中断向量地址给R0.
STR r0, [sp, #4] 中断向量地址给
LDMFD sp!, {r0, pc}
在程序的开始处,首先建立了默认的中断调用函数.这个过程大家一定非常熟悉,
首先执行了压栈,然后给出了中断入口地址.这个HandleFiq就是我们前面提到的在DRAM中建立的中断向量其中一个的地址。
在HandleFiq开始的四个字节中，放着汇编中断处理函数的入口地址。

汇编中断处理函数的地址是如何放到DRAM中断向量表里的呢？

我们上面提到的另一个表就发挥作用了。看下面这段程序：
EXCEPTION_VECTOR_TABLE_SETUP
LDR r0, =HandleReset
LDR r1, =ExceptionHandlerTable
MOV r2, #8

ExceptLoop
LDR r3, [r1], #4
STR r3, [r0], #4
SUBS r2, r2, #1 Down Count
BNE ExceptLoop ；； 从表里取出来给了HandleReset后面的空间
这一段把ExceptionHandlerTable里的中断处理函数的地址拷贝给了DRAM里的中断向量表。这样两者就联系起来
在执行程序开始的跳转之后就自然跳到了*******Handler.真正的处理函数之一如下所示：

它实际上只调用了C语言的中断处理函数，其他什么也没做。
SystemFiqHandler
IMPORT ISR_FiqHandler
STMFD sp!, {r0-r7, lr}
BL ISR_FiqHandler
LDMFD sp!, {r0-r7, lr}
SUBS pc, lr, #4

它实际上只调用了C语言的中断处理函数，其他什么也没做。
void ISR_FiqHandler(void)
{
IntOffSet = (U32)INTOFFSET;
(IntOffSet>>2)
(*InterruptHandlers[IntOffSet>>2])(); // Call interrupt service routine