/* * ======== main.c ======== */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Platform utilities include */ #include "ti/platform/platform.h" /* CSL Chip Functional Layer */ #include /* CSL Cache Functional Layer */ #include /* CSL IPC Layer */ #include #include /* PSC CSL Include Files */ #include #include /* CSL SRIO Functional Layer */ #include #include /* CSL CPINTC Include Files. */ #include #include "ti/csl/device/k2h/src/csl_device_interrupt.h" #include "common_imgdeal.h" #include "addr_assign.h" /* Global Buffers (Source and Destination) for PING-PONG */ Uint8 srcBuff1[512]; Uint8 srcBuff2[512]; Uint8 dstBuff1[512]; Uint8 dstBuff2[512]; /********************************************************************** ************************ EDMA TEST FUNCTIONS ************************* **********************************************************************/ /** * @b Description * @n * This is utility function used by the EDMA example to verify the * Data transfer. * * @retval * Success - TRUE * @retval * Error - FALSE */ static Bool Verify_Transfer ( Uint16 aCnt, Uint16 bCnt, Uint16 cCnt, Uint16 srcBIdx, Uint16 dstBIdx, Uint16 srcCIdx, Uint16 dstCIdx, Uint8 *srcBuff, Uint8 *dstBuff, Bool abSync ) { Uint32 loopIndex1; Uint32 loopIndex2; Uint32 loopIndex3; Uint8* srcArrayPtr = (Uint8*)srcBuff; Uint8* dstArrayPtr = (Uint8*)dstBuff; Uint8* srcFramePtr = (Uint8*)srcBuff; Uint8* dstFramePtr = (Uint8*)dstBuff; for (loopIndex1 = 0; loopIndex1 < cCnt; loopIndex1++) { for (loopIndex2 = 0; loopIndex2 < bCnt; loopIndex2++) { for (loopIndex3 = 0; loopIndex3 < aCnt; loopIndex3++) if (srcArrayPtr[loopIndex3] != dstArrayPtr[loopIndex3]) return FALSE; srcArrayPtr = srcArrayPtr + srcBIdx; dstArrayPtr = dstArrayPtr + dstBIdx; } if (abSync) { srcFramePtr = srcFramePtr + srcCIdx; srcArrayPtr = srcFramePtr; dstFramePtr = dstFramePtr + dstCIdx; dstArrayPtr = dstFramePtr; } else { srcFramePtr = srcArrayPtr + srcCIdx - srcBIdx; srcArrayPtr = srcFramePtr; dstFramePtr = dstArrayPtr + dstCIdx - dstBIdx; dstArrayPtr = dstFramePtr; } } return TRUE; } /** * @b Description * @n * This is the example routine which perform EDMA ping pong buffer transfer * where channel is open in the global region. * It implements following steps * - Intializes and Opens the EDMA Module . * - Sets up the interrupt for the EDMA global region. * - Sets up the EDMA module using the API csl_edma3Hwsetup () * - Enables the EDMA global region * - Opens the channel 'channelNum' get the param handle for PARAM 1, 2 * - PING is mapped to PARAM Entry 1 * - PONG is mapped to PARAM Entry 2 * - PING is Linked with PONG... * - Enables the EDMA interrupt using CSL_EDMA3_CMD_INTR_ENABLE. * - Enables Interrupt (Bit 0-2) for the global region interrupts * - Manually triggers the DMA channel 'channelNum'(This should be PING) * - Polls on IPR bit 0 (Since TCC for PING is 0) * - Clear the pending bit * - Manually triggers the channel 'channelNum' (This should be PONG) * - Polls on IPR bit 1 (Since TCC for PONG is 1) * - Clears the pending bit * - Compares the data in the destination buffer is proper or not. * - Closes the EDMA module and channel. * * @param[in] instNum * EDMA Instance Number on which the test is executed. * @param[in] channelNum * EDMA Channel Number on which the test is executed * * @retval * Success - 0 * @retval * Failure - <0 */static Int32 edma_ping_pong_xfer_gbl_region (Int32 instNum, Uint8 channelNum) { CSL_Edma3Handle hModule; CSL_Edma3Obj edmaObj; CSL_Edma3ParamHandle hParamPing; CSL_Edma3ParamHandle hParamPong; CSL_Edma3ChannelObj chObj; CSL_Edma3CmdIntr regionIntr; CSL_Edma3ChannelHandle hChannel; CSL_Edma3ParamSetup myParamSetup; CSL_Edma3Context context; CSL_Edma3ChannelAttr chAttr; CSL_Status status; Uint32 loopIndex; /* Start the EDMA PING-PONG test over the Global Region. */ System_printf ("Debug: Testing EDMA(%d) Ping-Pong Test (Global) Region for Channel %d...\n", instNum, channelNum); /* Initialize data */ for (loopIndex = 0; loopIndex < 256; loopIndex++) { srcBuff1[loopIndex] = loopIndex; srcBuff2[loopIndex] = loopIndex; dstBuff1[loopIndex] = 0; dstBuff2[loopIndex] = 0; } /* Module initialization */ if (CSL_edma3Init(&context) != CSL_SOK) { System_printf ("Error: EDMA module initialization failed\n"); return -1; } /* Open the EDMA Module using the provided instance number */ hModule = CSL_edma3Open(&edmaObj, instNum, NULL, &status); if ( (hModule == NULL) || (status != CSL_SOK)) { System_printf ("Error: EDMA module open failed\n"); return -1; } /* Channel open */ chAttr.regionNum = CSL_EDMA3_REGION_GLOBAL; chAttr.chaNum = channelNum; hChannel = CSL_edma3ChannelOpen(&chObj, instNum, &chAttr, &status); if ((hChannel == NULL) || (status != CSL_SOK)) { System_printf ("Error: Unable to open EDMA Channel:%d\n", channelNum); return -1; } /* Change Channel Default queue setup from 0 to 3 */ if (CSL_edma3HwChannelSetupQue(hChannel,CSL_EDMA3_QUE_1) != CSL_SOK) { System_printf ("Error: EDMA channel setup queue failed\n"); return -1; } /* Map the DMA Channel to PARAM Block 2. */ CSL_edma3MapDMAChannelToParamBlock (hModule, channelNum, 2); /* Obtain a handle to parameter set 2 */ hParamPing = CSL_edma3GetParamHandle(hChannel, 2, &status); if (hParamPing == NULL) { System_printf ("Error: EDMA Get Parameter Entry failed for 2.\n"); return -1; } /* Obtain a handle to parameter set 1 */ hParamPong = CSL_edma3GetParamHandle(hChannel, 1, &status); if (hParamPong == NULL) { System_printf ("Error: EDMA Get Parameter Entry failed for 1.\n"); return -1; } /* Setup the parameter entry parameters (Ping buffer) */ myParamSetup.option = CSL_EDMA3_OPT_MAKE(CSL_EDMA3_ITCCH_DIS, \ CSL_EDMA3_TCCH_DIS, \ CSL_EDMA3_ITCINT_DIS, \ CSL_EDMA3_TCINT_EN, \ 0, CSL_EDMA3_TCC_NORMAL,\ CSL_EDMA3_FIFOWIDTH_NONE, \ CSL_EDMA3_STATIC_DIS, \ CSL_EDMA3_SYNC_A, \ CSL_EDMA3_ADDRMODE_INCR, \ CSL_EDMA3_ADDRMODE_INCR ); myParamSetup.srcAddr = (Uint32)srcBuff1; myParamSetup.aCntbCnt = CSL_EDMA3_CNT_MAKE(256,1); myParamSetup.dstAddr = (Uint32)dstBuff1; myParamSetup.srcDstBidx = CSL_EDMA3_BIDX_MAKE(1,1); myParamSetup.linkBcntrld= CSL_EDMA3_LINKBCNTRLD_MAKE(hParamPong,0); myParamSetup.srcDstCidx = CSL_EDMA3_CIDX_MAKE(0,1); myParamSetup.cCnt = 1; /* Ping setup */ if (CSL_edma3ParamSetup(hParamPing,&myParamSetup) != CSL_SOK) { System_printf ("Error: EDMA Parameter Entry Setup failed\n"); return -1; } /* Pong setup */ myParamSetup.linkBcntrld = CSL_EDMA3_LINKBCNTRLD_MAKE(hParamPing,0); myParamSetup.option = CSL_EDMA3_OPT_MAKE(CSL_EDMA3_ITCCH_DIS, \ CSL_EDMA3_TCCH_DIS, \ CSL_EDMA3_ITCINT_DIS, \ CSL_EDMA3_TCINT_EN,\ 1, CSL_EDMA3_TCC_NORMAL,\ CSL_EDMA3_FIFOWIDTH_NONE, \ CSL_EDMA3_STATIC_EN, \ CSL_EDMA3_SYNC_A, \ CSL_EDMA3_ADDRMODE_INCR, \ CSL_EDMA3_ADDRMODE_INCR ); myParamSetup.srcAddr = (Uint32)srcBuff2; myParamSetup.dstAddr = (Uint32)dstBuff2; if (CSL_edma3ParamSetup(hParamPong,&myParamSetup) != CSL_SOK) { System_printf ("Error: EDMA Parameter Entry Setup failed\n"); return -1; } /* Interrupt enable (Bits 0-1) for the global region interrupts */ regionIntr.region = CSL_EDMA3_REGION_GLOBAL; regionIntr.intr = 0x3; regionIntr.intrh = 0x0000; CSL_edma3HwControl(hModule,CSL_EDMA3_CMD_INTR_ENABLE,®ionIntr); /* Trigger channel */ CSL_edma3HwChannelControl(hChannel,CSL_EDMA3_CMD_CHANNEL_SET,NULL); regionIntr.region = CSL_EDMA3_REGION_GLOBAL; regionIntr.intr = 0; regionIntr.intrh = 0; /* Poll on IPR bit 0 */ do { CSL_edma3GetHwStatus(hModule,CSL_EDMA3_QUERY_INTRPEND,®ionIntr); } while (!(regionIntr.intr & 0x1)); /* Clear the pending bit */ CSL_edma3HwControl(hModule,CSL_EDMA3_CMD_INTRPEND_CLEAR,®ionIntr); /* Trigger Channel */ CSL_edma3HwChannelControl(hChannel,CSL_EDMA3_CMD_CHANNEL_SET,NULL); /* Poll on IPR bit 2 */ do { CSL_edma3GetHwStatus(hModule,CSL_EDMA3_QUERY_INTRPEND,®ionIntr); } while (!(regionIntr.intr & 0x2)); /* Check transfer by comparing the source and destination buffers */ if(Verify_Transfer( 256, 1, 1, 0, 0, 0, 0, srcBuff1, dstBuff1, TRUE) == FALSE) { System_printf ("Error: Verification (Source1/Destination1) Failed\n"); return -1; } if(Verify_Transfer( 256, 1, 1, 0, 0, 0, 0, srcBuff2, dstBuff2, TRUE) == FALSE) { System_printf ("Error: Verification (Source2/Destination2) Failed\n"); return -1; } /* Close channel */ if (CSL_edma3ChannelClose(hChannel) != CSL_SOK) { System_printf("Error: EDMA Channel Close failed\n"); return -1; } /* Close EDMA module */ if (CSL_edma3Close(hModule) != CSL_SOK) { System_printf("Error: EDMA Module Close failed\n"); return -1; } /* The test passed. */ return 0; } /* * ======== main ======== */ Int main() { Uint8 channelNum; Int32 regionNum; Uint8 instNum = 0; int status,i,j; int32_t eventId; System_printf ("**************************************************\n"); System_printf ("************* EDMA Testing Start ************\n"); System_printf ("**************************************************\n"); /* EDMA Instance 0: Supports only 16 DMA Channels. */ for (channelNum = 0; channelNum < 16; channelNum++) { if (edma_ping_pong_xfer_gbl_region(instNum, channelNum) < 0) { System_printf("Error: Testing EDMA(%d) Ping-Pong Test (Global) Region for Channel %d FAILED\n", instNum, channelNum); return; } System_printf("Debug: Testing EDMA(%d) Ping-Pong Test (Global) Region for Channel %d Passed\n", instNum, channelNum); } System_printf ("**************************************************\n"); System_printf ("************* EDMA Testing Successful ************\n"); System_printf ("**************************************************\n"); BIOS_start(); /* does not return */ return(0); }