void isr_Edma3Completion(unsigned int intnum) { UNUSED(intnum); unsigned int pendingIrqsL, pendingIrqsH; pendingIrqsL = EDMA3GetIntrStatus(EDMA_INST_BASE); pendingIrqsH = EDMA3IntrStatusHighGet(EDMA_INST_BASE); /*shift and test status bit ,if set call hook function that registed by user*/ if (pendingIrqsL) { for (int i = 0; i < 32; i++) { if (pendingIrqsL & (1ul << i)) { if (dma_Fxn[i] != NULL) { (*dma_Fxn[i])(i, EDMA3_XFER_COMPLETE); } EDMA3ClrIntr(EDMA_INST_BASE, i); pendingIrqsL &= ~(1ul << i); if (!pendingIrqsL) break; } } } if (pendingIrqsH) { for (int i = 0; i < 32; i++) { if (pendingIrqsH & (1ul << i)) { if (dma_Fxn[i + 32] != NULL) { (*dma_Fxn[i + 32])(i + 32, EDMA3_XFER_COMPLETE); } EDMA3ClrIntr(EDMA_INST_BASE, i + 32); pendingIrqsH &= ~(1ul << i); if (!pendingIrqsH) break; } } } /*revaluate interrupt bit ,retrig interrupt if interrupt state bit set*/ pendingIrqsL = EDMA3GetIntrStatus(EDMA_INST_BASE); pendingIrqsH = EDMA3IntrStatusHighGet(EDMA_INST_BASE); if (pendingIrqsL || pendingIrqsH) { EDMA3ErrIntrTrig(EDMA_INST_BASE); } }
static void Edma3CCErrorIsr(void) { volatile unsigned int pendingIrqs; volatile unsigned int evtqueNum = 0; /* Event Queue Num */ volatile unsigned int isIPRH = 0; volatile unsigned int isIPR = 0; volatile unsigned int Cnt = 0u; volatile unsigned int index; pendingIrqs = 0u; index = 1u; isIPR = EDMA3GetIntrStatus(EDMA_INST_BASE); isIPRH = EDMA3IntrStatusHighGet(EDMA_INST_BASE); if((isIPR | isIPRH ) || (EDMA3QdmaGetErrIntrStatus(EDMA_INST_BASE) != 0) || (EDMA3GetCCErrStatus(EDMA_INST_BASE) != 0)) { /* Loop for EDMA3CC_ERR_HANDLER_RETRY_COUNT number of time, * breaks when no pending interrupt is found */ while ((Cnt < EDMA3CC_ERR_HANDLER_RETRY_COUNT) && (index != 0u)) { index = 0u; if(isIPR) { pendingIrqs = EDMA3GetErrIntrStatus(EDMA_INST_BASE); } else { pendingIrqs = EDMA3ErrIntrHighStatusGet(EDMA_INST_BASE); } while (pendingIrqs) { /*Process all the pending interrupts*/ if(TRUE == (pendingIrqs & 1u)) { /* Write to EMCR to clear the corresponding EMR bits. */ /*Clear any SER*/ if(isIPR) { EDMA3ClrMissEvt(EDMA_INST_BASE, index); } else { EDMA3ClrMissEvt(EDMA_INST_BASE, index + 32); } } ++index; pendingIrqs >>= 1u; } index = 0u; pendingIrqs = EDMA3QdmaGetErrIntrStatus(EDMA_INST_BASE); while (pendingIrqs) { /*Process all the pending interrupts*/ if(TRUE == (pendingIrqs & 1u)) { /* Here write to QEMCR to clear the corresponding QEMR bits*/ /*Clear any QSER*/ EDMA3QdmaClrMissEvt(EDMA_INST_BASE, index); } ++index; pendingIrqs >>= 1u; } index = 0u; pendingIrqs = EDMA3GetCCErrStatus(EDMA_INST_BASE); if (pendingIrqs != 0u) { /* Process all the pending CC error interrupts. */ /* Queue threshold error for different event queues.*/ for (evtqueNum = 0u; evtqueNum < SOC_EDMA3_NUM_EVQUE; evtqueNum++) { if((pendingIrqs & (1u << evtqueNum)) != 0u) { /* Clear the error interrupt. */ EDMA3ClrCCErr(EDMA_INST_BASE, (1u << evtqueNum)); } } /* Transfer completion code error. */ if ((pendingIrqs & (1 << EDMA3CC_CCERR_TCCERR_SHIFT)) != 0u) { EDMA3ClrCCErr(EDMA_INST_BASE, (0x01u << EDMA3CC_CCERR_TCCERR_SHIFT)); } ++index; } Cnt++; } } }
/* ** Interrupt ISR for Channel controller error. ** ** Note: This function first disables its own interrupt to make it non-entrant. */ void _EDMAAppEdma3ccErrIsr() { volatile unsigned int pendingIrqs; volatile unsigned int evtQueNum = 0u; /* Event Queue Num */ volatile unsigned int isHighIntrPending = 0u; volatile unsigned int isIntrPending = 0u; volatile unsigned int count = 0u; volatile unsigned int index; pendingIrqs = 0u; index = 1u; isIntrPending = EDMA3GetIntrStatus(EDMAAPP_EDMACC_BASE_ADDRESS); isHighIntrPending = EDMA3IntrStatusHighGet(EDMAAPP_EDMACC_BASE_ADDRESS); if((isIntrPending | isHighIntrPending ) || (EDMA3QdmaGetErrIntrStatus(EDMAAPP_EDMACC_BASE_ADDRESS) != 0u) || (EDMA3GetCCErrStatus(EDMAAPP_EDMACC_BASE_ADDRESS) != 0u)) { /* Loop for EDMA3CC_ERR_HANDLER_RETRY_COUNT number of time, ** breaks when no pending interrupt is found */ while ((count < EDMA3CC_ERR_HANDLER_RETRY_COUNT) && (index != 0u)) { index = 0u; if(isIntrPending) { pendingIrqs = EDMA3GetErrIntrStatus(EDMAAPP_EDMACC_BASE_ADDRESS); } else { pendingIrqs = EDMA3ErrIntrHighStatusGet(EDMAAPP_EDMACC_BASE_ADDRESS); } while(pendingIrqs) { /* Process all the pending interrupts */ if(TRUE == (pendingIrqs & 1u)) { /* ** Write to EMCR to clear the corresponding EMR bits. ** Clear any SER */ if(isIntrPending) { EDMA3ClrMissEvt(EDMAAPP_EDMACC_BASE_ADDRESS, index); } else { EDMA3ClrMissEvt(EDMAAPP_EDMACC_BASE_ADDRESS, index + 32u); } } ++index; pendingIrqs >>= 1u; } index = 0u; pendingIrqs = EDMA3QdmaGetErrIntrStatus(EDMAAPP_EDMACC_BASE_ADDRESS); while(pendingIrqs) { /* Process all the pending interrupts */ if(TRUE == (pendingIrqs & 1u)) { /* ** Here write to QEMCR to clear the corresponding QEMR bits ** Clear any QSER */ EDMA3QdmaClrMissEvt(EDMAAPP_EDMACC_BASE_ADDRESS, index); } ++index; pendingIrqs >>= 1u; } index = 0u; pendingIrqs = EDMA3GetCCErrStatus(EDMAAPP_EDMACC_BASE_ADDRESS); if(pendingIrqs != 0u) { /* ** Process all the pending CC error interrupts. ** Queue threshold error for different event queues. */ for(evtQueNum = 0u; evtQueNum < SOC_EDMA3_NUM_EVQUE; evtQueNum++) { if((pendingIrqs & (1u << evtQueNum)) != 0u) { /* Clear the error interrupt. */ EDMA3ClrCCErr(EDMAAPP_EDMACC_BASE_ADDRESS, (1u << evtQueNum)); } } /* Transfer completion code error. */ if((pendingIrqs & (1u << EDMA3CC_CCERR_TCCERR_SHIFT)) != 0u) { EDMA3ClrCCErr(EDMAAPP_EDMACC_BASE_ADDRESS, (1u << EDMA3CC_CCERR_TCCERR_SHIFT)); } ++index; } count++; } } }
/* ** ISR for successful transfer completion. ** ** Note: This function first disables its own interrupt to make it non-entrant. */ void _EDMAAppEdma3ccComplIsr() { volatile unsigned int pendingIrqs; volatile unsigned int isIntrPending = 0u; volatile unsigned int isHighIntrPending = 0u; unsigned int index; unsigned int count = 0u; index = 1u; isIntrPending = EDMA3GetIntrStatus(EDMAAPP_EDMACC_BASE_ADDRESS); isHighIntrPending = EDMA3IntrStatusHighGet(EDMAAPP_EDMACC_BASE_ADDRESS); if(isIntrPending | isHighIntrPending) { while ((count < EDMA3CC_COMPL_HANDLER_RETRY_COUNT)&& (index != 0u)) { index = 0u; if(isIntrPending) { pendingIrqs = EDMA3GetIntrStatus(EDMAAPP_EDMACC_BASE_ADDRESS); } else { pendingIrqs = EDMA3IntrStatusHighGet(EDMAAPP_EDMACC_BASE_ADDRESS); } while(pendingIrqs) { if(TRUE == (pendingIrqs & 1u)) { /* ** ** If the user has not given any Callback function ** while requesting the TCC, its TCC specific bit ** in the IPR register will NOT be cleared. */ if(isIntrPending) { /* ** Here write to ICR to clear the corresponding ** IPR bits */ EDMA3ClrIntr(EDMAAPP_EDMACC_BASE_ADDRESS, index); (*EDMAAppCallbackFxn[index])(EDMA3_XFER_COMPLETE); } else { /* ** Here write to ICR to clear the corresponding ** IPR bits */ EDMA3ClrIntr(EDMAAPP_EDMACC_BASE_ADDRESS, index + 32u); (*EDMAAppCallbackFxn[index + 32u])(EDMA3_XFER_COMPLETE); } } ++index; pendingIrqs >>= 1u; } count++; } } }