edma/v0/edma.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Texas Instruments Incorporated
 *
 * 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.
 */
 
#ifndef EDMA_V0_H_
#define EDMA_V0_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <drivers/hw_include/cslr_edma.h>
#include <drivers/hw_include/cslr_soc.h>
#include <drivers/hw_include/tistdtypes.h>
#include <kernel/dpl/SystemP.h>
#include <kernel/dpl/HwiP.h>
 
/* ========================================================================== */
/*                                 Macros                                     */
/* ========================================================================== */
#define EDMACC_DMAQNUM_CLR(chNum) \
    (~((uint32_t) 0x7U << (((chNum) % 8U) * 4U)))
 
#define EDMACC_DMAQNUM_SET(chNum, queNum) \
    (((uint32_t) 0x7U & (queNum)) << (((chNum) % 8U) * 4U))
 
#define EDMACC_QDMAQNUM_CLR(chNum) \
    (~((uint32_t) 0x7U << ((chNum) * 4U)))
 
#define EDMACC_QDMAQNUM_SET(chNum, queNum) \
    (((uint32_t) 0x7U & (queNum)) << ((chNum) * 4U))
 
#define EDMACC_QCHMAP_PAENTRY_CLR ((uint32_t) (~((uint32_t)EDMA_TPCC_QCHMAPN_PAENTRY_MASK)))
 
#define EDMACC_QCHMAP_PAENTRY_SET(paRAMId)                               \
    (((EDMA_TPCC_QCHMAPN_PAENTRY_MASK >> EDMA_TPCC_QCHMAPN_PAENTRY_SHIFT) \
      & (paRAMId)) << EDMA_TPCC_QCHMAPN_PAENTRY_SHIFT)                    \
 
#define EDMACC_QCHMAP_TRWORD_CLR  ((uint32_t) (~((uint32_t)EDMA_TPCC_QCHMAPN_TRWORD_MASK)))
 
#define EDMACC_QCHMAP_TRWORD_SET(paRAMId)                                \
    (((EDMA_TPCC_QCHMAPN_TRWORD_MASK >> EDMA_TPCC_QCHMAPN_TRWORD_SHIFT) & \
      (paRAMId)) << EDMA_TPCC_QCHMAPN_TRWORD_SHIFT)
 
#define EDMA_TRIG_MODE_MANUAL                ((uint32_t) 0U)
 
#define EDMA_TRIG_MODE_QDMA                  ((uint32_t) 1U)
 
#define EDMA_TRIG_MODE_EVENT                 ((uint32_t) 2U)
 
#define EDMA_CHANNEL_TYPE_DMA                ((uint32_t) 0U)
 
#define EDMA_CHANNEL_TYPE_QDMA               ((uint32_t) 1U)
 
#define EDMA_XFER_COMPLETE                   ((uint32_t) 0U)
 
#define EDMA_CC_DMA_EVT_MISS                 ((uint32_t) 1U)
 
#define EDMA_CC_QDMA_EVT_MISS                ((uint32_t) 2U)
 
#define EDMA_SYNC_A                          ((uint32_t) 0U)
 
#define EDMA_SYNC_AB                         ((uint32_t) 1U)
 
#define EDMA_ADDRESSING_MODE_LINEAR          ((uint32_t) 0U)
 
#define EDMA_ADDRESSING_MODE_FIFO_WRAP       ((uint32_t) 1U)
 
#define EDMA_FIFO_WIDTH_8BIT     ((uint32_t) EDMA_TPCC_OPT_FWID_FIFOWIDTH8BIT)
 
#define EDMA_FIFO_WIDTH_16BIT    ((uint32_t) EDMA_TPCC_OPT_FWID_FIFOWIDTH16BIT)
 
#define EDMA_FIFO_WIDTH_32BIT    ((uint32_t) EDMA_TPCC_OPT_FWID_FIFOWIDTH32BIT)
 
#define EDMA_FIFO_WIDTH_64BIT    ((uint32_t) EDMA_TPCC_OPT_FWID_FIFOWIDTH64BIT)
 
#define EDMA_FIFO_WIDTH_128BIT   ((uint32_t) EDMA_TPCC_OPT_FWID_FIFOWIDTH128BIT)
 
#define EDMA_FIFO_WIDTH_256BIT   ((uint32_t) DMA_TPCC_OPT_FWID_FIFOWIDTH256BIT)
 
#define EDMACC_CLR_TCCERR         ((uint32_t) EDMA_TPCC_CCERRCLR_TCERR_MASK)
 
#define EDMACC_CLR_QTHRQ0         ((uint32_t) EDMA_TPCC_CCERRCLR_QTHRXCD0_MASK)
 
#define EDMACC_CLR_QTHRQ1         ((uint32_t) EDMA_TPCC_CCERRCLR_QTHRXCD1_MASK)
 
#define EDMA_OPT_TCCHEN_MASK      ((uint32_t) EDMA_TPCC_OPT_TCCHEN_MASK)
 
#define EDMA_OPT_ITCCHEN_MASK     ((uint32_t) EDMA_TPCC_OPT_ITCCHEN_MASK)
 
#define EDMA_OPT_TCINTEN_MASK     ((uint32_t) EDMA_TPCC_OPT_TCINTEN_MASK)
 
#define EDMA_OPT_ITCINTEN_MASK    ((uint32_t) EDMA_TPCC_OPT_ITCINTEN_MASK)
 
#define EDMA_OPT_TCC_MASK         ((uint32_t) EDMA_TPCC_OPT_TCC_MASK)
 
#define EDMA_OPT_TCC_SHIFT        ((uint32_t) EDMA_TPCC_OPT_TCC_SHIFT)
 
#define EDMA_OPT_SYNCDIM_MASK     ((uint32_t) EDMA_TPCC_OPT_SYNCDIM_MASK)
 
#define EDMA_OPT_SYNCDIM_SHIFT    ((uint32_t) EDMA_TPCC_OPT_SYNCDIM_SHIFT)
 
#define EDMA_OPT_STATIC_MASK      ((uint32_t) EDMA_TPCC_OPT_STATIC_MASK)
 
#define EDMA_OPT_STATIC_SHIFT     ((uint32_t) EDMA_TPCC_OPT_STATIC_SHIFT)
 
#define EDMACC_OPT_TCC_CLR        ((uint32_t) (~EDMA_TPCC_OPT_TCC_MASK))
 
#define EDMACC_OPT_TCC_SET(tcc)                                      \
    (((EDMA_TPCC_OPT_TCC_MASK >> EDMA_TPCC_OPT_TCC_SHIFT) & (tcc)) << \
     EDMA_TPCC_OPT_TCC_SHIFT)
 
#define    EDMACC_PARAM_ENTRY_OPT            ((uint32_t) 0x0U)
 
#define    EDMACC_PARAM_ENTRY_SRC            ((uint32_t) 0x1U)
 
#define    EDMACC_PARAM_ENTRY_ACNT_BCNT      ((uint32_t) 0x2U)
 
#define    EDMACC_PARAM_ENTRY_DST            ((uint32_t) 0x3U)
 
#define    EDMACC_PARAM_ENTRY_SRC_DST_BIDX   ((uint32_t) 0x4U)
 
#define    EDMACC_PARAM_ENTRY_LINK_BCNTRLD   ((uint32_t) 0x5U)
 
#define    EDMACC_PARAM_ENTRY_SRC_DST_CIDX   ((uint32_t) 0x6U)
 
#define    EDMACC_PARAM_ENTRY_CCNT           ((uint32_t) 0x7U)
 
#define    EDMACC_PARAM_FIELD_OFFSET         ((uint32_t) 0x4U)
 
#define    EDMACC_PARAM_ENTRY_FIELDS         ((uint32_t) 0x8U)
 
#define EDMA_NUM_TCC                        ((uint32_t) SOC_EDMA_NUM_DMACH)
 
#define EDMA_RESOURCE_TYPE_DMA                ((uint32_t) 0U)
 
#define EDMA_RESOURCE_TYPE_QDMA               ((uint32_t) 1U)
 
#define EDMA_RESOURCE_TYPE_TCC                ((uint32_t) 2U)
 
#define EDMA_RESOURCE_TYPE_PARAM              ((uint32_t) 3U)
 
#define EDMA_RESOURCE_ALLOC_ANY               ((uint32_t) 0xFFFFU)
 
#define EDMA_SET_ALL_BITS                    ((uint32_t) 0xFFFFFFFFU)
 
#define EDMA_CLR_ALL_BITS                    ((uint32_t) 0x00000000U)
 
#define EDMACC_COMPL_HANDLER_RETRY_COUNT     ((uint32_t) 10U)
 
#define EDMACC_ERR_HANDLER_RETRY_COUNT       ((uint32_t) 10U)
 
/* ========================================================================== */
/*                         Structures                                         */
/* ========================================================================== */
typedef struct {
    /* \brief OPT field of PaRAM Set */
    uint32_t opt;
    uint32_t srcAddr;
    /* \brief Number of bytes in each Array (ACNT) */
    uint16_t aCnt;
    /* \brief Number of Arrays in each Frame (BCNT) */
    uint16_t bCnt;
    uint32_t destAddr;
    /* \brief Index between consec. arrays of a Source Frame (SRCBIDX) */
    int16_t  srcBIdx;
    /* \brief Index between consec. arrays of a Destination Frame (DSTBIDX) */
    int16_t  destBIdx;
    uint16_t linkAddr;
    uint16_t bCntReload;
    /* \brief Index between consecutive frames of a Source Block (SRCCIDX) */
    int16_t  srcCIdx;
    /* \brief Index between consecutive frames of a Dest Block (DSTCIDX) */
    int16_t  destCIdx;
    /* \brief Number of Frames in a block (CCNT) */
    uint16_t cCnt;
    /* \brief Reserved bit field (Should not be written with a non zero value) */
    uint16_t reserved;
 
} __attribute__((packed))
EDMACCPaRAMEntry;
 
typedef struct
{
    uint32_t    dmaCh[SOC_EDMA_NUM_DMACH/32U];
    /* \brief QDMA channels allocated. Each channel will be defined with 1 bit. */
    uint32_t    qdmaCh;
    uint32_t    tcc[EDMA_NUM_TCC/32U];
    uint32_t    paramSet[SOC_EDMA_NUM_PARAMSETS/32U];
} EDMA_ResourceObject;
 
typedef struct {
    /* \brief EDMA region to be used */
    uint32_t    regionId;
    /* \brief EDMA Event queue to be used for all channels */
    uint32_t    queNum;
    /* \brief Parameter to reset the PaRAM memory of the owned PaRAMs */
    uint32_t    initParamSet;
    /* \brief owned resource configuration */
    EDMA_ResourceObject ownResource;
    /* \brief Dma channels reserved for Event triggered transfers */
    uint32_t    reservedDmaCh[SOC_EDMA_NUM_DMACH/32U];
}EDMA_InitParams;
 
typedef struct
{
    uint32_t                intrEnable;
} EDMA_Params;
 
typedef struct Edma_IntrObject_t   *Edma_IntrHandle;
 
typedef void (*Edma_EventCallback)(Edma_IntrHandle intrHandle,
                                   void *appData);
 
typedef struct Edma_IntrObject_t
{
    /* \brief TCC number for which the callback to be reistered. */
    uint32_t                  tccNum;
    /* \brief Application data pointer passed to callback function. */
    void                     *appData;
    /* \brief Callback function pointer. */
    Edma_EventCallback        cbFxn;
    Edma_IntrHandle  nextIntr;
    Edma_IntrHandle  prevIntr;
} Edma_IntrObject;
 
typedef void *EDMA_Handle;
 
typedef struct
{
    /*
     * User parameters
     */
    EDMA_Handle             handle;
    EDMA_Params             openPrms;
    uint32_t                isOpen;
    EDMA_ResourceObject     allocResource;
    void                   *hwiHandle;
    HwiP_Object             hwiObj;
    Edma_IntrHandle  firstIntr;
} EDMA_Object;
 
typedef struct
{
    /*
     * SOC configuration
     */
    uint32_t                baseAddr;
    EDMA_InitParams         initPrms;
    uint32_t                compIntrNumber;
    uint32_t                intrAggEnableAddr;
    uint32_t                intrAggEnableMask;
    uint32_t                intrAggStatusAddr;
    uint32_t                intrAggClearMask;
} EDMA_Attrs;
 
typedef struct
{
    EDMA_Attrs       *attrs;
    EDMA_Object      *object;
} EDMA_Config;
 
extern EDMA_Config gEdmaConfig[];
extern uint32_t    gEdmaConfigNum;
extern EDMA_InitParams gEdmaInitParams[];
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
void EDMA_InitParams_init(EDMA_InitParams *initParam);
 
void EDMACCPaRAMEntry_init(EDMACCPaRAMEntry *paramEntry);
 
void EDMAEnableChInShadowRegRegion(uint32_t baseAddr,
                                    uint32_t regionId,
                                    uint32_t chType,
                                    uint32_t chNum);
 
void EDMADisableChInShadowRegRegion(uint32_t baseAddr,
                                     uint32_t regionId,
                                     uint32_t chType,
                                     uint32_t chNum);
 
void EDMAChannelToParamMap(uint32_t baseAddr,
                            uint32_t channel,
                            uint32_t paramSet);
 
void EDMAMapChToEvtQ(uint32_t baseAddr,
                      uint32_t chType,
                      uint32_t chNum,
                      uint32_t evtQNum);
 
void EDMAUnmapChToEvtQ(uint32_t baseAddr,
                        uint32_t chType,
                        uint32_t chNum);
 
void EDMAMapQdmaChToPaRAM(uint32_t        baseAddr,
                           uint32_t        chNum,
                           const uint32_t *paRAMId);
 
uint32_t EDMAGetMappedPaRAM(uint32_t baseAddr,
                             uint32_t chNum,
                             uint32_t chType,
                             uint32_t *paramId);
void EDMASetQdmaTrigWord(uint32_t baseAddr,
                          uint32_t chNum,
                          uint32_t trigWord);
 
void EDMAClrMissEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMAQdmaClrMissEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMAClrCCErr(uint32_t baseAddr, uint32_t flags);
 
void EDMASetEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMAClrEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMAEnableDmaEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMADisableDmaEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMAEnableQdmaEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMADisableQdmaEvtRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
uint32_t EDMAGetIntrStatusRegion(uint32_t baseAddr, uint32_t regionId);
 
void EDMAEnableEvtIntrRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMADisableEvtIntrRegion(uint32_t baseAddr, uint32_t regionId, uint32_t chNum);
 
void EDMAClrIntrRegion(uint32_t baseAddr, uint32_t regionId, uint32_t value);
 
uint32_t EDMAGetEnabledIntrRegion(uint32_t baseAddr, uint32_t regionId);
 
uint32_t EDMAGetEnabledIntrHighRegion(uint32_t baseAddr, uint32_t regionId);
 
void EDMAGetPaRAM(uint32_t           baseAddr,
                   uint32_t           paRAMId,
                   EDMACCPaRAMEntry *currPaRAM);
 
void EDMAQdmaGetPaRAM(uint32_t           baseAddr,
                       uint32_t           paRAMId,
                       EDMACCPaRAMEntry *currPaRAM);
 
void EDMASetPaRAM(uint32_t           baseAddr,
                   uint32_t           paRAMId,
                   const EDMACCPaRAMEntry *newPaRAM);
 
void EDMAQdmaSetPaRAM(uint32_t           baseAddr,
                       uint32_t           paRAMId,
                       const EDMACCPaRAMEntry *newPaRAM);
 
void EDMAQdmaSetPaRAMEntry(uint32_t baseAddr,
                            uint32_t paRAMId,
                            uint32_t paRAMEntry,
                            uint32_t newPaRAMEntryVal);
 
uint32_t EDMAQdmaGetPaRAMEntry(uint32_t baseAddr,
                                uint32_t paRAMId,
                                uint32_t paRAMEntry);
 
void EDMADmaSetPaRAMEntry(uint32_t baseAddr,
                            uint32_t paRAMId,
                            uint32_t paRAMEntry,
                            uint32_t newPaRAMEntryVal);
 
uint32_t EDMADmaGetPaRAMEntry(uint32_t baseAddr,
                                uint32_t paRAMId,
                                uint32_t paRAMEntry);
 
uint32_t EDMAConfigureChannelRegion(uint32_t baseAddr,
                                     uint32_t regionId,
                                     uint32_t chType,
                                     uint32_t chNum,
                                     uint32_t tccNum,
                                     uint32_t paramId,
                                     uint32_t evtQNum);
 
uint32_t EDMAFreeChannelRegion(uint32_t baseAddr,
                                uint32_t regionId,
                                uint32_t chType,
                                uint32_t chNum,
                                uint32_t trigMode,
                                uint32_t tccNum,
                                uint32_t evtQNum);
 
uint32_t EDMAEnableTransferRegion(uint32_t baseAddr,
                                   uint32_t regionId,
                                   uint32_t chNum,
                                   uint32_t trigMode);
 
uint32_t EDMADisableTransferRegion(uint32_t baseAddr,
                                    uint32_t regionId,
                                    uint32_t chNum,
                                    uint32_t trigMode);
 
void EDMAClearErrorBitsRegion(uint32_t baseAddr,
                               uint32_t regionId,
                               uint32_t chNum,
                               uint32_t evtQNum);
 
uint32_t EDMAGetCCErrStatus(uint32_t baseAddr);
 
uint32_t EDMAGetErrIntrStatus(uint32_t baseAddr);
 
uint32_t EDMAQdmaGetErrIntrStatus(uint32_t baseAddr);
 
uint32_t EDMAPeripheralIdGet(uint32_t baseAddr);
 
uint32_t EDMAIntrStatusHighGetRegion(uint32_t baseAddr, uint32_t regionId);
 
uint32_t EDMAReadIntrStatusRegion(uint32_t baseAddr, uint32_t regionId, uint32_t tccNum);
 
uint32_t EDMAErrIntrHighStatusGet(uint32_t baseAddr);
 
void EDMAChainChannel(uint32_t baseAddr,
                       uint32_t chId1,
                       uint32_t chId2,
                       uint32_t chainOptions);
 
void EDMALinkChannel(uint32_t baseAddr, uint32_t paRAMId1, uint32_t paRAMId2);
 
void EDMA_init(void);
 
void EDMA_deinit(void);
 
EDMA_Handle EDMA_open(uint32_t index, const EDMA_Params *prms);
 
EDMA_Handle EDMA_getHandle(uint32_t index);
 
void EDMA_close(EDMA_Handle handle);
 
uint32_t EDMA_isInterruptEnabled(EDMA_Handle handle);
 
int32_t EDMA_registerIntr(EDMA_Handle handle, Edma_IntrObject *intrObj);
 
int32_t EDMA_unregisterIntr(EDMA_Handle handle, Edma_IntrObject *intrObj);
 
uint32_t EDMA_getBaseAddr(EDMA_Handle handle);
 
uint32_t EDMA_getRegionId(EDMA_Handle handle);
 
int32_t EDMA_allocDmaChannel(EDMA_Handle handle, uint32_t *dmaCh);
 
int32_t EDMA_allocQdmaChannel(EDMA_Handle handle, uint32_t *qdmaCh);
 
int32_t EDMA_allocTcc(EDMA_Handle handle, uint32_t *tcc);
 
int32_t EDMA_allocParam(EDMA_Handle handle, uint32_t *param);
 
int32_t EDMA_freeDmaChannel(EDMA_Handle handle, uint32_t *dmaCh);
 
int32_t EDMA_freeQdmaChannel(EDMA_Handle handle, uint32_t *qdmaCh);
 
int32_t EDMA_freeTcc(EDMA_Handle handle, uint32_t *tcc);
 
int32_t EDMA_freeParam(EDMA_Handle handle, uint32_t *param);
 
#ifdef __cplusplus
}
#endif
 
#endif  /* #ifndef EDMA_V0_H_ */