udma.h

Go to the documentation of this file.

/*
 *  Copyright (c) Texas Instruments Incorporated 2018
 *
 *  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 UDMA_H_
#define UDMA_H_

/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */

#include <stdint.h>

/* UDMA_SOC_CFG_* macros are defined udma_soc.h. 
 * So including this first
 */ 
#include <ti/drv/udma/soc/udma_soc.h>

#include <ti/csl/soc.h>
#include <ti/csl/csl_psilcfg.h>
#if (UDMA_SOC_CFG_RA_NORMAL_PRESENT == 1)
#include <ti/csl/csl_ringacc.h>
#endif 
#if (UDMA_SOC_CFG_RA_LCDMA_PRESENT == 1)
#include <ti/csl/csl_lcdma_ringacc.h>
#endif
#if (UDMA_SOC_CFG_UDMAP_PRESENT == 1)
#include <ti/csl/csl_udmap.h>
#endif
#if (UDMA_SOC_CFG_BCDMA_PRESENT == 1)
#include <ti/csl/csl_bcdma.h>
#if (UDMA_SOC_CFG_PKTDMA_PRESENT == 1)
#include <ti/csl/csl_pktdma.h>
#include <ti/csl/src/ip/udmap/V0/csl_udmap_cppi5.h>
#endif
#endif
#include <ti/csl/csl_intaggr.h>
#include <ti/csl/csl_intr_router.h>
#if (UDMA_NUM_UTC_INSTANCE > 0)
#include <ti/csl/csl_dru.h>
#endif
#if (UDMA_SOC_CFG_PROXY_PRESENT == 1)
#include <ti/csl/csl_proxy.h>
#endif
#if (UDMA_SOC_CFG_CLEC_PRESENT == 1)
#include <ti/csl/csl_clec.h>
#endif

#include <ti/osal/osal.h>
#include <ti/drv/sciclient/sciclient.h>

#include <ti/drv/udma/include/udma_cfg.h>
#include <ti/drv/udma/include/udma_types.h>
#include <ti/drv/udma/include/udma_osal.h>
#include <ti/drv/udma/include/udma_ring.h>
#include <ti/drv/udma/include/udma_proxy.h>
#include <ti/drv/udma/include/udma_flow.h>
#include <ti/drv/udma/include/udma_event.h>
#include <ti/drv/udma/include/udma_rm.h>
#include <ti/drv/udma/include/udma_ch.h>
#if (UDMA_NUM_UTC_INSTANCE > 0)
#include <ti/drv/udma/include/udma_dru.h>
#endif
#include <ti/drv/udma/include/udma_utils.h>

#ifdef __cplusplus
extern "C" {
#endif

/* ========================================================================== */
/*                           Macros & Typedefs                                */
/* ========================================================================== */

typedef uint64_t (*Udma_VirtToPhyFxn)(const void *virtAddr,
                                      uint32_t chNum,
                                      void *appData);
typedef void *(*Udma_PhyToVirtFxn)(uint64_t phyAddr,
                                   uint32_t chNum,
                                   void *appData);

typedef void (*Udma_PrintFxn)(const char *str);

typedef void (*Udma_ringHandleClearRegsFxn)(Udma_RingHandle ringHandle);
typedef void (*Udma_ringSetDoorBellFxn)(Udma_RingHandle ringHandle, 
                                        int32_t count);
typedef void (*Udma_ringPrimeFxn)(Udma_RingHandle ringHandle,
                                  uint64_t phyDescMem);
typedef void (*Udma_ringPrimeReadFxn)(Udma_RingHandle ringHandle, 
                                      uint64_t *phyDescMem);
typedef void *(*Udma_ringGetMemPtrFxn)(Udma_RingHandle ringHandle);
typedef uint32_t (*Udma_ringGetModeFxn)(Udma_RingHandle ringHandle);
typedef uint32_t (*Udma_ringGetElementCntFxn)(Udma_RingHandle ringHandle);
typedef uint32_t (*Udma_ringGetForwardRingOccFxn)(Udma_RingHandle ringHandle);
typedef uint32_t (*Udma_ringGetReverseRingOccFxn)(Udma_RingHandle ringHandle);
typedef uint32_t (*Udma_ringGetWrIdxFxn)(Udma_RingHandle ringHandle);
typedef uint32_t (*Udma_ringGetRdIdxFxn)(Udma_RingHandle ringHandle);
typedef int32_t (*Udma_ringDequeueRawFxn)(Udma_DrvHandle  drvHandle, 
                                          Udma_RingHandle ringHandle, 
                                          uint64_t *phyDescMem);
typedef int32_t (*Udma_ringQueueRawFxn)(Udma_DrvHandle  drvHandle, 
                                        Udma_RingHandle ringHandle, 
                                        uint64_t phyDescMem); 
typedef int32_t (*Udma_ringFlushRawFxn)(Udma_DrvHandle  drvHandle, 
                                        Udma_RingHandle ringHandle, 
                                        uint64_t *phyDescMem); 
typedef void (*Udma_ringSetCfgFxn)(Udma_DrvHandle drvHandle,
                                   Udma_RingHandle ringHandle,
                                   const Udma_RingPrms *ringPrms);
/* @} */

/* ========================================================================== */
/*                         Structure Declarations                             */
/* ========================================================================== */

typedef struct
{
    uint32_t                instId;
    Udma_RmInitPrms         rmInitPrms;
    uint32_t                skipRmOverlapCheck;
    uint32_t                skipGlobalEventReg;
    Udma_VirtToPhyFxn       virtToPhyFxn;
    Udma_PhyToVirtFxn       phyToVirtFxn;
    Udma_PrintFxn           printFxn;
    Udma_OsalPrms           osalPrms;
} Udma_InitPrms;

/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */

int32_t Udma_init(Udma_DrvHandle drvHandle, const Udma_InitPrms *initPrms);

int32_t Udma_deinit(Udma_DrvHandle drvHandle);

/*
 * Structure Init functions
 *
 * Requirement: DOX_REQ_TAG(PDK-2600)
 */
int32_t UdmaInitPrms_init(uint32_t instId, Udma_InitPrms *initPrms);

/* ========================================================================== */
/*      Internal Function Declarations (Needed for other static inlines)      */
/* ========================================================================== */

static inline uint64_t Udma_defaultVirtToPhyFxn(const void *virtAddr,
                                                uint32_t chNum,
                                                void *appData);

static inline void *Udma_defaultPhyToVirtFxn(uint64_t phyAddr,
                                             uint32_t chNum,
                                             void *appData);

/* ========================================================================== */
/*                       Static Function Definitions                          */
/* ========================================================================== */

static uint64_t Udma_defaultVirtToPhyFxn(const void *virtAddr,
                                         uint32_t chNum,
                                         void *appData)
{
    return ((uint64_t) virtAddr);
}

static void *Udma_defaultPhyToVirtFxn(uint64_t phyAddr,
                                      uint32_t chNum,
                                      void *appData)
{
#if defined (__aarch64__)
    uint64_t temp = phyAddr;
#else
    /* R5 is 32-bit machine, need to truncate to avoid void * typecast error */
    uint32_t temp = (uint32_t) phyAddr;
#endif

    return ((void *) temp);
}

/* ========================================================================== */
/*                  Internal/Private Structure Declarations                   */
/* ========================================================================== */

struct Udma_DrvObj
{   
    uint32_t                instType;
    uint32_t                raType;
#if (UDMA_SOC_CFG_UDMAP_PRESENT == 1)
    /*
     * NAVSS instance parameters
     */
    CSL_UdmapCfg            udmapRegs;
#endif 
#if (UDMA_SOC_CFG_BCDMA_PRESENT == 1)
    CSL_BcdmaCfg             bcdmaRegs;
#endif
#if (UDMA_SOC_CFG_PKTDMA_PRESENT == 1) 
    CSL_PktdmaCfg            pktdmaRegs; 
#endif 
#if (UDMA_SOC_CFG_RA_NORMAL_PRESENT == 1)  
    CSL_RingAccCfg          raRegs;
#endif
#if (UDMA_SOC_CFG_RA_LCDMA_PRESENT == 1)  
    CSL_LcdmaRingaccCfg     lcdmaRaRegs;
#endif

    CSL_IntaggrCfg          iaRegs;
#if (UDMA_NUM_UTC_INSTANCE > 0)
    Udma_UtcInstInfo        utcInfo[UDMA_NUM_UTC_INSTANCE];
#endif
    uint32_t                udmapSrcThreadOffset;
    uint32_t                udmapDestThreadOffset;
    uint32_t                maxRings;
    uint32_t                maxProxy;
    uint32_t                maxRingMon;
#if (UDMA_SOC_CFG_PROXY_PRESENT == 1)
    /*
     * Proxy parameters
     */
    CSL_ProxyCfg            proxyCfg;
    /*< Proxy register configuration */
    CSL_ProxyTargetParams   proxyTargetRing;
    /*< Proxy ring target register configuration */
    uint32_t                proxyTargetNumRing;
    /*< Proxy ring target index */
#endif    

#if (UDMA_SOC_CFG_CLEC_PRESENT == 1)
    /*
     * Clec parameters
     */
    CSL_CLEC_EVTRegs       *clecRegs;
    uint32_t                clecRtMap;
    uint32_t                clecOffset;
#endif

    /*
     * TISCI RM parameters
     */
    uint16_t                devIdRing;
    uint16_t                devIdUdma;
    uint16_t                devIdPsil;
    uint16_t                devIdIa;
    uint16_t                devIdIr;
    uint16_t                devIdDummyEvtSrc;
#if (UDMA_SOC_CFG_PROXY_PRESENT == 1)
    uint16_t                devIdProxy;
#endif
    uint16_t                devIdCore;
#if (UDMA_NUM_UTC_INSTANCE > 0)
    uint32_t                druCoreId;
#endif  
    /*
     * TISCI Ring event IRQ params
     * 
     * These IRQ offsets should be corresponding TISCI offset - ringNum Offset
     */
    uint16_t                srcIdRingIrq;
    uint16_t                blkCopyRingIrqOffset;
    uint16_t                txRingIrqOffset;
    uint16_t                rxRingIrqOffset;
    /*
     * TISCI TR event IRQ params
     * 
     * These IRQ offsets should be corresponding TISCI offset - chNum Offset
     */
    uint16_t                srcIdTrIrq;
    uint16_t                blkCopyTrIrqOffset;
    uint16_t                txTrIrqOffset;
    uint16_t                rxTrIrqOffset;
    /*
     * Channel Offsets
     */
    uint32_t                txChOffset;
    uint32_t                extChOffset;
    uint32_t                rxChOffset;
    /*
     *  The driver allocates ringNum = chNum (for BlkCpoy)
                                     = chNum + txChOffset (for SplitTR Tx)
                                     = chNum + rxChOffset (for SplitTR Rx)

        For CSL_bcdma* API's passed param ->channel_num = txChNum (for BlkCopy)
                                                        = txChNum + txChOffset (for SplitTR Tx)
                                                        = rxChNum + rxChOffset (for SplitTR Rx)
    */
    /*
     * Other Offsets
     */
    uint32_t                iaGemOffset;
    uint32_t                trigGemOffset;
    struct Udma_EventObj    globalEventObj;
    Udma_EventHandle        globalEventHandle;
    Udma_InitPrms           initPrms;
    uint32_t                drvInitDone;
    /*
     * RM objects.
     * This is a bitwise flag
     * 1 - free, 0 - allocated
     */
    uint32_t                blkCopyChFlag[UDMA_RM_BLK_COPY_CH_ARR_SIZE];
    uint32_t                blkCopyHcChFlag[UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE];
    uint32_t                blkCopyUhcChFlag[UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE];
    uint32_t                txChFlag[UDMA_RM_TX_CH_ARR_SIZE];
    uint32_t                txHcChFlag[UDMA_RM_TX_HC_CH_ARR_SIZE];
    uint32_t                txUhcChFlag[UDMA_RM_TX_UHC_CH_ARR_SIZE];

    uint32_t                rxChFlag[UDMA_RM_RX_CH_ARR_SIZE];
    uint32_t                rxHcChFlag[UDMA_RM_RX_HC_CH_ARR_SIZE];
    uint32_t                rxUhcChFlag[UDMA_RM_RX_UHC_CH_ARR_SIZE];
#if (UDMA_NUM_UTC_INSTANCE > 0)
    uint32_t                utcChFlag[UDMA_NUM_UTC_INSTANCE][UDMA_RM_UTC_CH_ARR_SIZE];
#endif
#if (UDMA_NUM_MAPPED_TX_GROUP > 0)
    uint32_t                mappedTxChFlag[UDMA_NUM_MAPPED_TX_GROUP][UDMA_RM_MAPPED_TX_CH_ARR_SIZE];
#endif
#if (UDMA_NUM_MAPPED_RX_GROUP > 0)
    uint32_t                mappedRxChFlag[UDMA_NUM_MAPPED_RX_GROUP][UDMA_RM_MAPPED_RX_CH_ARR_SIZE];
#endif
#if ((UDMA_NUM_MAPPED_TX_GROUP + UDMA_NUM_MAPPED_RX_GROUP) > 0)
    uint32_t                mappedRingFlag[UDMA_NUM_MAPPED_TX_GROUP + UDMA_NUM_MAPPED_RX_GROUP][UDMA_RM_MAPPED_RING_ARR_SIZE];
#endif

    uint32_t                freeRingFlag[UDMA_RM_FREE_RING_ARR_SIZE];
    uint32_t                freeFlowFlag[UDMA_RM_FREE_FLOW_ARR_SIZE];
    uint32_t                globalEventFlag[UDMA_RM_GLOBAL_EVENT_ARR_SIZE];
    uint32_t                vintrFlag[UDMA_RM_VINTR_ARR_SIZE];
    uint32_t                irIntrFlag[UDMA_RM_IR_INTR_ARR_SIZE];
    uint32_t                proxyFlag[UDMA_RM_PROXY_ARR_SIZE];
    uint32_t                ringMonFlag[UDMA_RM_RING_MON_ARR_SIZE];
    void                   *rmLock;
    void                   *printLock;
    char                    printBuf[UDMA_CFG_PRINT_BUF_LEN];
    /*
     * UDMA Ring Local API's function pointers
     * For Normal RA / LCDMA RA, these function pointers are used
     * to call the appropriate function.
     */
    Udma_ringDequeueRawFxn            ringDequeueRaw;
    Udma_ringQueueRawFxn              ringQueueRaw;
    Udma_ringFlushRawFxn              ringFlushRaw;
    Udma_ringGetElementCntFxn         ringGetElementCnt;
    Udma_ringGetMemPtrFxn             ringGetMemPtr;
    Udma_ringGetModeFxn               ringGetMode;
    Udma_ringGetForwardRingOccFxn     ringGetForwardRingOcc;
    Udma_ringGetReverseRingOccFxn     ringGetReverseRingOcc;
    Udma_ringGetWrIdxFxn              ringGetWrIdx;
    Udma_ringGetRdIdxFxn              ringGetRdIdx;
    Udma_ringPrimeFxn                 ringPrime;
    Udma_ringPrimeReadFxn             ringPrimeRead;
    Udma_ringSetDoorBellFxn           ringSetDoorBell;
    Udma_ringSetCfgFxn                ringSetCfg;
    Udma_ringHandleClearRegsFxn       ringHandleClearRegs;
};

#ifdef __cplusplus
}
#endif

#endif /* #ifndef UDMA_H_ */

/* @} */