isr.c

移植在鱼板上运行的ucos

/*************************************************************************/
/*                                                                       */
/* FILE NAME                                      VERSION                */
/*                                                                       */
/*      isr.c                      KS32C5000, KS32C50100   : version 1.0 */
/*                                                                       */
/* COMPONENT                                                             */
/*                                                                       */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*                                                                       */
/* AUTHOR                                                                */
/*                                                                       */
/*                                                                       */
/* DATA STRUCTURES                                                       */
/*                                                                       */
/*                                                                       */
/* FUNCTIONS                                                             */
/*                                                                       */
/*      Interrupt handler                                                */
/*                                                                       */
/* DEPENDENCIES                                                          */
/*                                                                       */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         NAME            DATE                    REMARKS               */
/*                                                                       */
/*      hbahn           09-15-1998      Created initial version 1.0      */
/*      in4maker        12-18-1998      Some functions added & updated   */
/*************************************************************************/
#include "all.h"
//#include "std.h"
//#include <stdio.h>
//#include <ctype.h>
//#include <string.h>
//#include "snds.h"
//#include "isr.h"
//#include "uart.h"
//#include "pollio.h"
//#include "sysconf.h"
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 = 0x000000;  // 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	ISR_UndefHandler(REG32 *adr)
{
	Print("\n** Trap : Undefined Handler\n") ;
	Print("\rUndefined Address : %08x ",adr);
	Print("\rUndefined Data : %08x ",*adr);
}

void	ISR_PrefetchHandler(REG32 *adr)
{
	Print("\n** Trap : Prefetch Abort Handler\n") ;
	Print("\rPrefetch Abort Address : %08x ",adr);
	Print("\rPrefetch Abort Data : %08x ",*adr);
}

void	ISR_AbortHandler(REG32 *adr)
{
	Print("\n** Trap : Data Abort Handler\n") ;
	Print("\rData Abort Address : %08x ",adr);
	Print("\rData Abort Data : %08x ",*adr);
}

void	ISR_SwiHandler(void)
{
	Print("\r** Trap : SWI Handler\n") ;
}


void	ISR_IrqHandler(void)
{
        //Print("T");
        IntOffSet = (U32)INTOFFSET;
        Clear_PendingBit(IntOffSet>>2) ;
       (*InterruptHandlers[IntOffSet>>2])(); // Call interrupt service routine
	
}


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,in this function will disable the global int
	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;pReg<nPRIREG;pReg++) { 
          *pINTPRI[pReg] = 0x0;
     }

     Print("\r\rAssign Interrupt source to priority!");
     Print("\r>Interrupt source index is two hexdigit.\r\r");
	 //同一行中由高到低分配优先级，以由低到高的优先级行来分配	
     for(pReg=0,nPri=0;pReg<nPRIREG;pReg++) {
         for(bCnt=0;(bCnt<4)&&(nPri<MAXHNDLRS); bCnt++,nPri++) {
              Print("\rInterrupt Priority %d = ",nPri);
              rINTPRI = gethex2dec(2); get_byte();
              *pINTPRI[pReg] |= (rINTPRI <<(bCnt*8)); 
         }
     }
}


void SetIntMode(void)
{
    U32 rINTMASK;
    U32 rINTMODE;
    
    INTMASK = 0x3fffff;  // All interrupt disabled include global bit
    INTMODE = 0x1fffff;  // All FIQ mode

    Print("\r> 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");
}