EDMA

Table of Contents

• Features Supported
• SysConfig Features
• Features NOT Supported
• Usage Overview
  • API Sequence
• Important Usage Guidelines
• Example Usage
• API

EDMA driver provides API to perform DMA tranfers.

Features Supported

• DMA, QDMA channels
• Interrupt and Polled mode of operations
• PaRAM Linking
• Channel Chaining
• Manual and Event triggered transfers

SysConfig Features

Note

It is strongly recommend to use SysConfig where it is available instead of using direct SW API calls. This will help simplify the SW application and also catch common mistakes early in the development cycle.

• EDMA instances selection
• Region Id selection
• Interrupt mode selection
• DMA Channel management
• QDMA Channel management
• TCC management
• PaRAM management

Features NOT Supported

• None

Usage Overview

API Sequence

To transfer the data using edma, application calls following APIs

• EDMA_init(): Initialize the EDMA driver.
• EDMA_open(): Open an instance of the EDMA driver
• EDMA_getBaseAddr(): Get the edma base address corresponding to the driver handle. This is used in further APIs for initiating the transfers.
• EDMA_configureChannelRegion(): Configure the DMA channel used for transfer
• EDMA_setPaRAM(): Configure the PaRAM corresponding to the transfer
• EDMA_enableTransferRegion(): Enable the data transfer
• EDMA_close(): Closes the EDMA instance.
• EDMA_deinit(): De-Initialize the EDMA driver.

Important Usage Guidelines

• None

Example Usage

Include the below file to access the APIs

#include <drivers/edma.h>

Instance Open Example

    EDMA_Params         params;
 
    params.intrEnable = TRUE;
    gEdmaHandle = EDMA_open(CONFIG_EDMA0, &params);
    DebugP_assert(gEdmaHandle != NULL);

Instance Close Example

    EDMA_close(gEdmaHandle);

Instance transfer Example

    uint32_t            baseAddr, regionId;
    uint8_t            *srcBuffPtr, *dstBuffPtr;
    int32_t             testStatus = SystemP_SUCCESS;
    EDMACCPaRAMEntry   edmaParam;
    uint32_t            dmaCh, tcc, param;
 
    baseAddr = EDMA_getBaseAddr(gEdmaHandle);
    DebugP_assert(baseAddr != 0);
 
    regionId = EDMA_getRegionId(gEdmaHandle);
    DebugP_assert(regionId < SOC_EDMA_NUM_REGIONS);
 
    /* Allocate the resources dma channel, tcc and param */
    dmaCh = EDMA_RESOURCE_ALLOC_ANY;
    testStatus = EDMA_allocDmaChannel(gEdmaHandle, &dmaCh);
    DebugP_assert(testStatus == SystemP_SUCCESS);
 
    tcc = EDMA_RESOURCE_ALLOC_ANY;
    testStatus = EDMA_allocTcc(gEdmaHandle, &tcc);
    DebugP_assert(testStatus == SystemP_SUCCESS);
 
    param = EDMA_RESOURCE_ALLOC_ANY;
    testStatus = EDMA_allocParam(gEdmaHandle, &param);
    DebugP_assert(testStatus == SystemP_SUCCESS);
 
    srcBuffPtr = (uint8_t *) gEdmaTestSrcBuff;
    dstBuffPtr = (uint8_t *) gEdmaTestDstBuff;
 
    /* Request channel */
    EDMA_configureChannelRegion(baseAddr, regionId, EDMA_CHANNEL_TYPE_DMA,
         dmaCh, tcc, param, EDMA_TEST_EVT_QUEUE_NO);
 
    /* Program Param Set */
    EDMA_ccPaRAMEntry_init(&edmaParam);
    edmaParam.srcAddr       = (uint32_t) (srcBuffPtr);
    edmaParam.destAddr      = (uint32_t) (dstBuffPtr);
    edmaParam.aCnt          = (uint16_t) EDMA_TEST_A_COUNT;
    edmaParam.bCnt          = (uint16_t) EDMA_TEST_B_COUNT;
    edmaParam.cCnt          = (uint16_t) EDMA_TEST_C_COUNT;
    edmaParam.bCntReload    = (uint16_t) EDMA_TEST_B_COUNT;
    edmaParam.srcBIdx       = (int16_t) EDMA_PARAM_BIDX(EDMA_TEST_A_COUNT);
    edmaParam.destBIdx      = (int16_t) EDMA_PARAM_BIDX(EDMA_TEST_A_COUNT);
    edmaParam.srcCIdx       = (int16_t) EDMA_TEST_A_COUNT;
    edmaParam.destCIdx      = (int16_t) EDMA_TEST_A_COUNT;
    edmaParam.linkAddr      = 0xFFFFU;
    edmaParam.srcBIdxExt    = (int8_t) EDMA_PARAM_BIDX_EXT(EDMA_TEST_A_COUNT);
    edmaParam.destBIdxExt   = (int8_t) EDMA_PARAM_BIDX_EXT(EDMA_TEST_A_COUNT);
    edmaParam.opt          |=
        (EDMA_OPT_TCINTEN_MASK | EDMA_OPT_ITCINTEN_MASK |
         ((((uint32_t)tcc) << EDMA_OPT_TCC_SHIFT) & EDMA_OPT_TCC_MASK));
    EDMA_setPaRAM(baseAddr, param, &edmaParam);
 
    EDMA_enableTransferRegion(
            baseAddr, regionId, dmaCh, EDMA_TRIG_MODE_MANUAL);
 
    /* Free channel */
    EDMA_freeChannelRegion(baseAddr, regionId, EDMA_CHANNEL_TYPE_DMA,
        dmaCh, EDMA_TRIG_MODE_MANUAL, tcc, EDMA_TEST_EVT_QUEUE_NO);
 
    /* Free the EDMA resources managed by driver. */
    testStatus = EDMA_freeDmaChannel(gEdmaHandle, &dmaCh);
    DebugP_assert(testStatus == SystemP_SUCCESS);
    testStatus = EDMA_freeTcc(gEdmaHandle, &tcc);
    DebugP_assert(testStatus == SystemP_SUCCESS);
    testStatus = EDMA_freeParam(gEdmaHandle, &param);
    DebugP_assert(testStatus == SystemP_SUCCESS);
 

API

APIs for EDMA