www.pudn.com > 440B0-LwIP.zip > isr.c

//-+---+---++-+--+-++-+++--++--+++ 
#include "std.h" 
#include "snds.h" 
#include "isr.h" 
#include "sysconf.h" 
 
//这是将系统的一些调用整合到中断处理中来 
#include "includes.h" 
 
void DRAMTOROM_MAP_RESTORE(void); 
volatile U32  IntOffSet; 
/***************************************************************/ 
/* Dummy Function Prototype for Interrupt Service Vector Table */ 
/***************************************************************/ 
static void DummyIsr(void) {} 
//-+---+---++-+--+-++-+++--++--+++ 
void (*InterruptHandlers[MAXHNDLRS])(void); 
 
void ClrIntStatus(void) 
{ 
    INTMASK = 0x3fffff;  // All interrupt disabled include global bit 
    INTPEND = 0x1fffff;  // All clear pending 
    //INTMODE = 0x1fffff;  // All FIQ mode 
    INTMODE = 0x0;  // All IRQ mode	 
     
    /*  
     * Interrupt Priority Reset value. Need to be changed priority, 
     * Set interrupt priority register. In this case, Global interrupt 
     * mask bit must be disabled. 
     * 
     */  
    //INTPRI0 = 0x03020100;   
    //INTPRI1 = 0x07060504; 
    //INTPRI2 = 0x0b0a0908; 
    //INTPRI3 = 0x0f0e0d0c; 
    //INTPRI4 = 0x13121110; 
    //INTPRI5 = 0x00000014; 
    //INTOFFSET =  Read Only Register 
} 
 
 
/******************************************/ 
/****    Exception Handler Function    ****/ 
/******************************************/ 
void (*IntHandlerUndef)(REG32 *adr); 
void	ISR_UndefHandler(REG32 *adr) 
{ 
	IntHandlerUndef(adr); 
 
} 
//-+---+---++-+--+-++-+++--++--+++ 
void (*IntHandlerPrefetch)(REG32 *adr); 
void	ISR_PrefetchHandler(REG32 *adr) 
{ 
	IntHandlerPrefetch(adr); 
 
} 
void (*IntHandlerAbort)(REG32 *adr); 
void	ISR_AbortHandler(REG32 *adr) 
{ 
	IntHandlerAbort(adr); 
	 
} 
//下面是三种系统异常的中断回调函数，应该在C_Entry中配置 
//void (*IntHandlerUndef)(REG32 *adr); 
//void (*IntHandlerPrefetch)(REG32 *adr); 
//void (*IntHandlerAbort)(REG32 *adr); 
 
void	ISR_SwiHandler(void) 
{ 
//	Print("\r** Trap : SWI Handler\n") ; 
} 
 
 
void	ISR_IrqHandler(void) 
{ 
 
//        IntOffSet = (U32)INTOFFSET; 
//        Clear_PendingBit(IntOffSet>>2) ; 
OSIntEnter(); 
//OSIntNesting++; 
       (*InterruptHandlers[IntOffSet>>2])(); // Call interrupt service routine 
OSIntExit();	 
} 
 
 
void	ISR_FiqHandler(void) 
{ 
       IntOffSet = (U32)INTOFFSET; 
       Clear_PendingBit(IntOffSet>>2) ; 
       (*InterruptHandlers[IntOffSet>>2])(); // Call interrupt service routine 
} 
 
 
/***********************************************************************/ 
/* InitIntHandlerTable: Initialize the interrupt handler table         */ 
/*     NOTE(S): This should be called during system initialization     */ 
/***********************************************************************/ 
void InitIntHandlerTable(void) 
{ 
	REG32 i; 
  
	for (i = 0; i < MAXHNDLRS; i++) 
    		InterruptHandlers[i] = DummyIsr; 
 
} 
 
/*********************************************************/ 
/* SysSetInterrupt: Setup Interrupt Handler Vector Table */ 
/*********************************************************/ 
void SysSetInterrupt(REG32 vector, void (*handler)()) 
{ 
	InterruptHandlers[vector] = handler; 
 
} 
 
/*********************************************************/ 
/* InitInterrupt: Initialize Interrupt		 */ 
/*********************************************************/ 
void InitInterrupt(void)  
{ 
    ClrIntStatus();         // Clear All interrupt  
	InitIntHandlerTable() ; 
} 
//-+---+---++-+--+-++-+++--++--+++ 
 
 
 
/*  ================================================= 
 *  Monitoring the interrupt related system register 
 *  ================================================= 
 
void IntConfig(void) 
{ 
 
        Print("\n========================================\r"); 
        Print(">>  Interrupt Status configurations. <<\r"); 
        Print("========================================\r"); 
 
        Print(">>INTMODE[0x%08x] = 0x%08x\r", &INTMODE,INTMODE); 
        Print(">>INTPEND[0x%08x] = 0x%08x\r", &INTPEND,INTPEND); 
        Print(">>INTMASK[0x%08x] = 0x%08x\r", &INTMASK,INTMASK); 
        Print(">>INTPRI0[0x%08x] = 0x%08x\r", &INTPRI0,INTPRI0); 
        Print(">>INTPRI1[0x%08x] = 0x%08x\r", &INTPRI1,INTPRI1); 
        Print(">>INTPRI2[0x%08x] = 0x%08x\r", &INTPRI2,INTPRI2); 
        Print(">>INTPRI3[0x%08x] = 0x%08x\r", &INTPRI3,INTPRI3); 
        Print(">>INTPRI4[0x%08x] = 0x%08x\r", &INTPRI4,INTPRI4); 
        Print(">>INTPRI5[0x%08x] = 0x%08x\r", &INTPRI5,INTPRI5); 
        Print(">>INTOFFSET[0x%08x] = 0x%08x\r", &INTOFFSET,INTOFFSET); 
        Print("========================================\r\r\r"); 
} 
 */ 
 
/*  ================================================= 
 *   Set interrupt priority function 
 *  ================================================= 
 
 
#define nPRIREG  6 
void SetPriority(void) 
{ 
     int pReg; 
     int bCnt; 
     int nPri; 
     U32 rINTPRI; 
     volatile unsigned int *pINTPRI[6] = { 
                &INTPRI0, 
                &INTPRI1, 
                &INTPRI2, 
                &INTPRI3, 
                &INTPRI4, 
                &INTPRI5 
     }; 
      
      
     ClrIntStatus();  // Clear All interrupt  
 
     // Clear Interrupt priority register / 
     for(pReg=0;pRegInterrupt source index is two hexdigit.\r\r"); 
 
     for(pReg=0,nPri=0;pReg Set INTMODE register[6 hexdigit]_"); 
    rINTMODE = gethex2dec(6); get_byte(); 
    Print("\r  - INTMODE input is 0x%08x\r",rINTMODE); 
 
    Print("\r> Set INTMASK register[6 hexdigit]_"); 
    rINTMASK = gethex2dec(6); get_byte(); 
    Print("\r  - INTMASK input is 0x%08x\r",rINTMASK); 
 
    INTMODE = rINTMODE; 
    INTPEND = 0x1fffff;  // All clear pending 
    INTMASK = rINTMASK; 
    Print("\rAll interrupt pending cleared!!!\r\r"); 
} 
 */