EDMA interrupt issue

/*
 * EdmaIntDispatcher.c
 *
 * Interrupt dispatcher for the EDMA3 IPR interrupts to allow a different
 * function/ISR for each bit. 
 *
 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ 
 * 
 * 
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions 
 *  are met:
 *
 *    Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer.
 *
 *    Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the 
 *    documentation and/or other materials provided with the   
 *    distribution.
 *
 *    Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
*/

/** ============================================================================
 *
 *   @file  EdmaIntDispatcher.c
 *
 *   @path  
 *
 *   @desc This is a utility function used by edma as interrupt dispatcher 
 *
 *   Usage:
 *
 *
 *
 *   In your C source file, use the following:
 *
#include "EdmaIntDispatcher.h"

main():
#if EDMA_REGION != CSL_EDMA3_REGION_GLOBAL
    CSL_Edma3CmdDrae            regionAccess;
#endif

   // Open an intc handle for edma interrupt
#if EDMA_REGION != CSL_EDMA3_REGION_GLOBAL
  #error CSL_INTC_EVENTID_EDMA3CC_GINT must be replaced with the appropriate region interrupt number
#endif
    vectId = CSL_INTC_VECTID_4;
    hIntcEdma = CSL_intcOpen (&intcObjEdma, CSL_INTC_EVENTID_EDMA3CC_GINT,
                              &vectId , NULL);

#if ( EDMADISPATCH_METHOD == EDMADISPATCH_IEVAL )
	// if the faster IEVAL option is chosen for the EdmaIntDispatcher, then this interrupt
	// should be masked out of the Dropped Interrupt detection to avoid generating INTERR
    CSL_intcHwControl(hIntcEdma,CSL_INTC_CMD_EVTDROPDISABLE,NULL);
#endif


#if EDMA_REGION != CSL_EDMA3_REGION_GLOBAL
	// Setup the DRAE masks, but not needed for global region
    regionAccess.region = EDMA_REGION ;

	// choose the channels and tcc bits you will use with this region, method 2
	ullTemp  = (unsigned long long)1 << tccGpio4;
	ullTemp |= (unsigned long long)1 << tccCh0;
    regionAccess.drae  = _loll(ullTemp);   
    regionAccess.draeh = _hill(ullTemp);

    status = CSL_edma3HwControl(hModule,CSL_EDMA3_CMD_DMAREGION_ENABLE, \
                                &regionAccess); 
    if (status != CSL_SOK) {
        Sys_Count ++;
        return;    
    }
#endif


#if EDMA_REGION != CSL_EDMA3_REGION_GLOBAL
	 // Disable the region access
    regionAccess.region = EDMA_REGION ;

	// choose the channels and tcc bits you will use with this region, method 2
	ullTemp  = (unsigned long long)1 << tccGpio4;
	ullTemp |= (unsigned long long)1 << tccCh0;
    regionAccess.drae  = _loll(ullTemp);   
    regionAccess.draeh = _hill(ullTemp);

    status = CSL_edma3HwControl(hModule,CSL_EDMA3_CMD_DMAREGION_DISABLE,
                                &regionAccess);
#endif

 *
 *   In your BIOS tcf source file, use the following for any HWI_INTn:
 *
bios.HWI.instance("HWI_INT4").fxn = prog.extern("EdmaIntDispatcher");
bios.HWI.instance("HWI_INT4").interruptSelectNumber = <EDMA3 int from datasheet>;
bios.HWI.instance("HWI_INT4").useDispatcher = 1;
bios.HWI.instance("HWI_INT4").arg = prog.extern("edmaObj"); // must be a global variable

 *
 * ============================================================================
 */

#include <ti/csl/csl_edma3.h>
#include <ti/csl/csl_chip.h>
#include "EdmaIntDispatcher.h"


/* Global Edma Tcc handler table */
#pragma DATA_SECTION(TccHandlerTable,".far:TccHandlerTable");
EdmaTccHandler TccHandlerTable[64];

/*
 * =============================================================================
 *   @func  EdmaIntDispatcher
 *  
 *   @arg
 *      handle        - Edma module handle
 *
 *   @desc
 *      This is the interrupt dispatcher routine for edma interrupts
 *
 *   @return
 *      NONE
 *
 * =============================================================================
 */
void EdmaIntDispatcher (
    void        *handle
)
{
    CSL_Edma3Handle     hModule = (CSL_Edma3Handle)handle;
    CSL_Edma3CmdIntr    regionIntr;
    Uint32              tcc;
    Uint32              intr;
    Uint32              intrh;
	Int32				EdmaRegion;
    
    /* Read the IPR & mask with IER */
	EdmaRegion = (Int32)EDMA_REGION;

    regionIntr.region = EdmaRegion;
    CSL_edma3GetHwStatus(hModule,CSL_EDMA3_QUERY_INTRPEND, &regionIntr);

	// read IER and keep only enabled interrupts from IPR
	if ( EdmaRegion == CSL_EDMA3_REGION_GLOBAL )
	{
	    regionIntr.intr  &= hModule->regs->TPCC_IER;
	    regionIntr.intrh &= hModule->regs->TPCC_IERH;
	}
	else  // get the IER from the shadow region
	{
		regionIntr.intr  &= hModule->regs->SHADOW[EdmaRegion].TPCC_IER;
	    regionIntr.intrh &= hModule->regs->SHADOW[EdmaRegion].TPCC_IERH;
	}
    
#if EDMADISPATCH_METHOD == EDMADISPATCH_REREAD_IPR
    while (regionIntr.intr || regionIntr.intrh)
    {
#endif
        intr  = regionIntr.intr;
        intrh = regionIntr.intrh;
        
		// clear any set & enabled IPR bits quickly to allow repetition
        CSL_edma3HwControl(hModule,CSL_EDMA3_CMD_INTRPEND_CLEAR,&regionIntr);       

        for ( tcc = 0; intr != 0; intr >>= 1, tcc++ )
            if ( intr & 1 )
                InvokeHandle( tcc );
        
        for ( tcc = 32; intrh != 0; intrh >>= 1, tcc++ )
            if ( intrh & 1 )
                InvokeHandle( tcc );
        
#if EDMADISPATCH_METHOD == EDMADISPATCH_REREAD_IPR
		// re-read IPR
        CSL_edma3GetHwStatus(hModule,CSL_EDMA3_QUERY_INTRPEND,&regionIntr);         

		// read IER and keep only enabled interrupts from IPR
		if ( EdmaRegion == CSL_EDMA3_REGION_GLOBAL )
		{
		    regionIntr.intr  &= hModule->regs->TPCC_IER;
		    regionIntr.intrh &= hModule->regs->TPCC_IERH;
		}
		else  // get the IER from the shadow region
		{
			regionIntr.intr  &= hModule->regs->SHADOW[EdmaRegion].TPCC_IER;
		    regionIntr.intrh &= hModule->regs->SHADOW[EdmaRegion].TPCC_IERH;
		}
    }           
#else  // EDMADISPATCH_IEVAL
		// write to the EVAL bit of the IEVAL register for this region
		if ( EdmaRegion == CSL_EDMA3_REGION_GLOBAL )
		{
		    hModule->regs->IEVAL = 1;
		}
		else
		{
			hModule->regs->SHADOW[EdmaRegion].IEVAL = 1;
		}
#endif
}

/*
 * =============================================================================
 *   @func  EdmaEventHook
 *  
 *   @arg
 *      tcc        - Tcc number
 *      fxn        - Pointer to function which points to edma isr
 *
 *   @desc
 *      This loads the hook table for the edma interrupt dispatcher
 *
 *   @return
 *      NONE
 *
 * =============================================================================
 */
void EdmaEventHook (
    Uint16            tcc, 
    EdmaTccHandler    fxn
)
{
    TccHandlerTable[tcc] = (fxn);
}