exceptions.c

ucos-ii 的完整代码

   lea     -20(sp), sp
   movem.l d0-d2/a0-a1, (sp)
   pea     24(sp)                                                       /* push exception frame address                             */
   jsr     mcf_exception_handler
   movem.l 4(sp), d0-d2/a0-a1
   lea     24(sp), sp
   unlk a6
   rte
}

/*
*********************************************************************************************************
*	                            Default 'C' Exception Handler
*
* Description : The following function serves as the default exception handler. Additional
*               functionality may be added in order to notify the developer of the unhandled
*               exception if desired.
*
* Arguments   : pframe  Pointer to the exceptions stack frame
*********************************************************************************************************
*/

void mcf_exception_handler(void *pframe) 
{
    volatile  unsigned  long   exceptionStackFrame   =  (*(unsigned long *)(pframe)); 
    volatile  unsigned  short  stackFrameSR          =   MCF5XXX_SF_SR(pframe);  
    volatile  unsigned  short  stackFrameWord        =  (*(unsigned short *)(pframe));  
    volatile  unsigned  long   stackFrameFormat      =  (unsigned long)MCF5XXX_RD_SF_FORMAT(&stackFrameWord);
    volatile  unsigned  long   stackFrameFS          =  (unsigned long)MCF5XXX_RD_SF_FS(&stackFrameWord);
    volatile  unsigned  long   stackFrameVector      =  (unsigned long)MCF5XXX_RD_SF_VECTOR(&stackFrameWord);
    volatile  unsigned  long   stackFramePC          =   MCF5XXX_SF_PC(pframe);

    switch (stackFrameFormat) {
        case 4:
        case 5:
        case 6:
        case 7:
             break;
         
        default:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT,"Illegal stack type", stackFramePC);
             break;
    }

    switch (stackFrameVector) {
        case 2:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Access Error", stackFramePC);
             switch (stackFrameFS) {
                 case 4:
                      VECTORDISPLAY("Error on instruction fetch\n");
                      break;
                      
                 case 8:
                      VECTORDISPLAY("Error on operand write\n");
                      break;
                      
                 case 9:
                      VECTORDISPLAY("Attempted write to write-protected space\n");
                      break;
                      
                 case 12:
                      VECTORDISPLAY("Error on operand read\n");
                      break;
                      
                 default:
                      VECTORDISPLAY("Reserved Fault Status Encoding\n");
                      break;
             }
        break;
        
        case 3:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Address Error", stackFramePC);
             switch (stackFrameFS) {
                 case 4:
                      VECTORDISPLAY("Error on instruction fetch\n");
                      break;
                      
                 case 8:
                      VECTORDISPLAY("Error on operand write\n");
                      break;
                      
                 case 9:
                      VECTORDISPLAY("Attempted write to write-protected space\n");
                      break;
                      
                 case 12:
                      VECTORDISPLAY("Error on operand read\n");
                      break;
                      
                 default:
                      VECTORDISPLAY("Reserved Fault Status Encoding\n");
                      break;
            }
        break;
        
        case 4:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Illegal instruction", stackFramePC);
             break;
             
        case 8:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Privilege violation", stackFramePC);
             break;
             
        case 9:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Trace Exception", stackFramePC);
             break;
             
        case 10:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Unimplemented A-Line Instruction", 	stackFramePC);
             break;
             
        case 11:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Unimplemented F-Line Instruction", 	stackFramePC);
             break;
             
        case 12:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Debug Interrupt", stackFramePC);
             break;
             
        case 14:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Format Error", stackFramePC);
             break;
             
        case 15:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Unitialized Interrupt", stackFramePC);
             break;
             
        case 24:
             VECTORDISPLAY3(MCF5XXX_EXCEPTFMT, "Spurious Interrupt", stackFramePC);
             break;
             
        case 25:
        case 26:
        case 27:
        case 28:
        case 29:
        case 30:
        case 31:
             VECTORDISPLAY2("Autovector interrupt level %d\n", stackFrameVector - 24);
             break;
             
        case 32:
        case 33:
        case 34:
        case 35:
        case 36:
        case 37:
        case 38:
        case 39:
        case 40:
        case 41:
        case 42:
        case 43:
        case 44:
        case 45:
        case 46:
        case 47:
             VECTORDISPLAY2("TRAP #%d\n", stackFrameVector - 32);
             break;
             
        case 5:
        case 6:
        case 7:
        case 13:
        case 16:
        case 17:
        case 18:
        case 19:
        case 20:
        case 21:
        case 22:
        case 23:
        case 48:
        case 49:
        case 50:
        case 51:
        case 52:
        case 53:
        case 54:
        case 55:
        case 56:
        case 57:
        case 58:
        case 59:
        case 60:
        case 61:
        case 62:
        case 63:
             VECTORDISPLAY2("Reserved: #%d\n", stackFrameVector);
             break;
             
        default:
             derivative_interrupt(stackFrameVector);
             break;
    }
}

/*
*********************************************************************************************************
*	                            Specific Derivative 'C' Exception Handler
*
* Description : The following function serves as the default exception handler for exceptions
*               that are not common to all Coldfire derivatives.
*
* Arguments   : vector  The vector number of the device specific interrupt that has occured.
*
* Callers     : mcf_exception_handler()
*********************************************************************************************************
*/

void derivative_interrupt(unsigned long vector)
{
    if ((vector < 64) || (vector > 192)) {
        VECTORDISPLAY2("User Defined Vector #%d\n",vector);
    }
}