rt-thread/libcpu/xilinx/microblaze/trap.c

/*
 * File      : trap.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006, RT-Thread Development Team
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://openlab.rt-thread.com/license/LICENSE
 *
 * Change Logs:
 * Date           Author       Notes
 * 2006-08-23     Bernard      first version
 * 2011-12-17	  nl1031	   for MicroBlaze
 *
 */

#include 	<rtthread.h>
#include 	"xparameters.h"
#include 	"xintc.h"
#include    "xintc_i.h"
#include    "xintc_l.h"

#define MAX_HANDLERS  XPAR_INTC_MAX_NUM_INTR_INPUTS
extern XIntc int_ctl; /* The instance of the Interrupt Controller */

extern rt_uint32_t rt_interrupt_nest;

rt_uint32_t rt_interrupt_from_thread, rt_interrupt_to_thread;
rt_uint32_t rt_thread_switch_interrupt_flag;

void rt_hw_interrupt_handler(int vector)
{
    rt_kprintf("Unhandled interrupt %d occured!!!\n", vector);
}

/**
 * This function will initialize hardware interrupt
 */
void rt_hw_interrupt_init()
{
    rt_base_t index;

    XIntc_Config *CfgPtr;

    CfgPtr = &XIntc_ConfigTable[0];

    for (index = 0; index < MAX_HANDLERS; index++)
    {
        CfgPtr->HandlerTable[index].Handler = (XInterruptHandler) rt_hw_interrupt_handler;
    }

    /* init interrupt nest, and context in thread sp */
    rt_interrupt_nest = 0;
    rt_interrupt_from_thread = 0;
    rt_interrupt_to_thread = 0;
    rt_thread_switch_interrupt_flag = 0;
}

/**
 * This function will mask a interrupt.
 * @param vector the interrupt number
 */
void rt_hw_interrupt_mask(int vector)
{
    /* disable interrupt */
    XIntc_Disable(&int_ctl, vector);
}

/**
 * This function will un-mask a interrupt.
 * @param vector the interrupt number
 */
void rt_hw_interrupt_umask(int vector)
{
    XIntc_Enable(&int_ctl, vector);
}

/**
 * This function will install a interrupt service routine to a interrupt.
 * @param vector the interrupt number
 * @param new_handler the interrupt service routine to be installed
 * @param old_handler the old interrupt service routine
 */
void rt_hw_interrupt_install(int vector, rt_isr_handler_t new_handler, rt_isr_handler_t *old_handler)
{
    XIntc_Config *CfgPtr;

    CfgPtr = &XIntc_ConfigTable[0];

    if (vector >= 0 && vector < MAX_HANDLERS)
    {
        if (*old_handler != RT_NULL)
            *old_handler = (rt_isr_handler_t) CfgPtr->HandlerTable[vector].Handler;
        if (new_handler != RT_NULL)
            CfgPtr->HandlerTable[vector].Handler = (XInterruptHandler) new_handler;
    }
}

/*****************************************************************************/
/** copy from XIntc_DeviceInterruptHandler in xintc_l.c nl1031
 *
 * This function is the primary interrupt handler for the driver. It must be
 * connected to the interrupt source such that is called when an interrupt of
 * the interrupt controller is active. It will resolve which interrupts are
 * active and enabled and call the appropriate interrupt handler. It uses
 * the AckBeforeService flag in the configuration data to determine when to
 * acknowledge the interrupt. Highest priority interrupts are serviced first.
 * The driver can be configured to service only the highest priority interrupt
 * or all pending interrupts using the {XIntc_SetOptions()} function or
 * the {XIntc_SetIntrSrvOption()} function.
 *
 * This function assumes that an interrupt vector table has been previously
 * initialized.  It does not verify that entries in the table are valid before
 * calling an interrupt handler.
 *
 *
 * @return	None.
 *
 * @note
 *
 * The constant XPAR_INTC_MAX_NUM_INTR_INPUTS must be setup for this to compile.
 * Interrupt IDs range from 0 - 31 and correspond to the interrupt input signals
 * for the interrupt controller. XPAR_INTC_MAX_NUM_INTR_INPUTS specifies the
 * highest numbered interrupt input signal that is used.
 *
 ******************************************************************************/

void rt_hw_trap_irq(void)
{
    u32 intr_status;
    u32 intr_mask = 1;
    int intr_number;
    volatile u32 reg; /* used as bit bucket */
    XIntc_Config *cfg_ptr;

    /* Get the configuration data using the device ID */
    cfg_ptr = &XIntc_ConfigTable[0];

    /* Get the interrupts that are waiting to be serviced */
    intr_status = XIntc_GetIntrStatus(XPAR_INTC_0_BASEADDR);

    /* Service each interrupt that is active and enabled by checking each
     * bit in the register from LSB to MSB which corresponds to an interrupt
     * intput signal
     */
    for (intr_number = 0; intr_number < XPAR_INTC_MAX_NUM_INTR_INPUTS; intr_number++)
    {
        if (intr_status & 1)
        {
            XIntc_VectorTableEntry *table_ptr;

            /* If the interrupt has been setup to acknowledge it
             * before servicing the interrupt, then ack it
             */
            if (cfg_ptr->AckBeforeService & intr_mask)
            {
                XIntc_AckIntr(cfg_ptr->BaseAddress, intr_mask);
            }

            /* The interrupt is active and enabled, call the
             * interrupt handler that was setup with the specified
             * parameter
             */
            table_ptr = &(cfg_ptr->HandlerTable[intr_number]);
            table_ptr->Handler(table_ptr->CallBackRef);

            /* If the interrupt has been setup to acknowledge it
             * after it has been serviced then ack it
             */
            if ((cfg_ptr->AckBeforeService & intr_mask) == 0)
            {
                XIntc_AckIntr(cfg_ptr->BaseAddress, intr_mask);
            }

            /*
             * Read the ISR again to handle architectures with posted write
             * bus access issues.
             */
            reg = XIntc_GetIntrStatus(cfg_ptr->BaseAddress);

            /*
             * If only the highest priority interrupt is to be
             * serviced, exit loop and return after servicing
             * the interrupt
             */
            if (cfg_ptr->Options == XIN_SVC_SGL_ISR_OPTION)
            {
                return;
            }
        }

        /* Move to the next interrupt to check */
        intr_mask <<= 1;
        intr_status >>= 1;

        /* If there are no other bits set indicating that all interrupts
         * have been serviced, then exit the loop
         */
        if (intr_status == 0)
        {
            break;
        }
    }
}