cbuff/v1/cbuff.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 CBUFF_V1_H_
#define CBUFF_V1_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <stdbool.h>
#include <drivers/hw_include/cslr_soc.h>
#include <drivers/hw_include/cslr_cbuff.h>
#include <drivers/edma.h>
#include <drivers/hw_include/hw_types.h>
 
 
/* ========================================================================== */
/*                                 Macros                                     */
/* ========================================================================== */
 
#define CBUFF_ERRNO_BASE                    (-3300)
 
#define CBUFF_MAX_USER_BUFFER               (3U)
 
 
#define CBUFF_STATUS_SUCCESS            ((int32_t)0)
 
#define CBUFF_EINVAL                    (CBUFF_ERRNO_BASE-1)
 
#define CBUFF_ENOMEM                    (CBUFF_ERRNO_BASE-2)
 
#define CBUFF_EINUSE                    (CBUFF_ERRNO_BASE-3)
 
#define CBUFF_ENOTSUP                   (CBUFF_ERRNO_BASE-4)
 
#define CBUFF_EDMA_FAIL                 (CBUFF_ERRNO_BASE-5)
 
#define CBUFF_ELIMIT                    (CBUFF_ERRNO_BASE-6)
 /* end defgroup CBUFF_ERROR_CODES */
 
#define CBUFF_MAX_NUM_SESSION                       (7U)
 
#define CBUFF_EDMA_MAX_NUM_CHANNELS                 (32U)
 
#define CBUFF_MAX_LINKED_LIST_SIZE                  (32U)
 
#define CBUFF_LL_READ_THRESHOLD                     (0x4U)
 
#define CBUFF_LL_WRITE_THRESHOLD                    (0x40U)
 
#define CBUFF_MAX_TRANSFER_SIZE_CBUFF_UNITS         (0x3FFFU)
 
#define CBUFF_MIN_TRANSFER_SIZE_CBUFF_UNITS         ((CBUFF_LL_READ_THRESHOLD * 16U) / 2U)
 
/* ========================================================================== */
/*                             typedefs                                       */
/* ========================================================================== */
 
typedef void*   CBUFF_Handle;
 
typedef void*   CBUFF_SessionHandle;
 
 
typedef uint32_t CBUFF_Interface;
 
#define CBUFF_Interface_MDO       ((uint32_t) 1) 
#define CBUFF_Interface_LVDS      ((uint32_t) 2) 
typedef uint32_t CBUFF_Command;
 
#define CBUFF_Command_GET_CBUFF_STATS       ((uint32_t) 1) 
#define CBUFF_Command_CLEAR_CBUFF_STATS     ((uint32_t) 2) 
#define CBUFF_Command_GET_ACTIVE_SESSION    ((uint32_t) 3) 
typedef uint32_t CBUFF_OutputDataFmt;
 
#define CBUFF_OutputDataFmt_12bit     ((uint32_t) 0) 
#define CBUFF_OutputDataFmt_14bit     ((uint32_t) 1) 
#define CBUFF_OutputDataFmt_16bit     ((uint32_t) 2) 
typedef uint32_t CBUFF_DataType;
 
#define CBUFF_DataType_REAL                   ((uint32_t) 0) 
#define CBUFF_DataType_COMPLEX                ((uint32_t) 1) 
typedef uint32_t CBUFF_LVDSLaneFmtMap;
 
#define CBUFF_LVDSLaneFmtMapLANEx_FMT_0_y             ((uint32_t) 0) 
#define CBUFF_LVDSLaneFmtMapLANEx_FMT_1_y             ((uint32_t) 1) 
typedef uint32_t CBUFF_LLType;
 
#define CBUFF_LLType_UNUSED       ((uint32_t) 0) 
#define CBUFF_LLType_USER         ((uint32_t) 1) 
#define CBUFF_LLType_HEADER       ((uint32_t) 2) 
/* ========================================================================== */
/*                  Internal/Private Structure Declarations                   */
/* ========================================================================== */
 
typedef struct CBUFF_Stats_t
{
    uint32_t    numFrameDone;
 
    uint32_t    numChirpDone;
 
    uint32_t    numErrorInterrupts;
 
    uint8_t     frameStartError;
 
    uint8_t     chirpError;
}CBUFF_Stats;
 
typedef struct CBUFF_BufferCfg_t
{
    uint16_t    size;
 
    uint32_t    address;
}CBUFF_BufferCfg;
 
typedef struct CBUFF_LinkListParams_t
{
    CBUFF_LLType    type;
 
    uint8_t         crcEnable;
 
    uint8_t         lpHdrEn;
 
    uint8_t         outputDataFmt;
 
    uint16_t        transferSize;
 
    uint16_t        totalTransferSize;
 
    uint8_t         align96;
 
    uint8_t         dataFmtMap;
 
    uint8_t         vcNum;
 
    uint8_t         hsyncStart;
 
    uint8_t         hsyncEnd;
 
    uint32_t        lpHeaderValue;
 
    uint32_t        threshold;
}CBUFF_LinkListParams;
 
typedef struct
{
    /*
     * SOC configuration
     */
    uint32_t            baseAddr;
    uint32_t            fifoBaseAddr;
    uint32_t            maxLVDSLanesSupported;
    uint32_t            errorIntrNum;
    uint32_t            intrNum;
    uint32_t            cbuffChannelId[CBUFF_MAX_NUM_SESSION];
} CBUFF_Attrs;
 
/* ========================================================================== */
/*                         Structures                                         */
/* ========================================================================== */
 
typedef struct CBUFF_LVDSCfg_t
{
    uint8_t                 crcEnable;
 
    uint8_t                 lvdsLaneEnable;
 
    uint8_t                 msbFirst;
 
    uint8_t                 ddrClockMode;
 
    uint8_t                 ddrClockModeMux;
 
    CBUFF_LVDSLaneFmtMap    laneFormat;
}CBUFF_LVDSCfg;
 
typedef struct CBUFF_EDMAChannelCfg_t
{
    uint32_t     chainChannelsId;
 
    uint32_t    shadowLinkChannelsId;
}CBUFF_EDMAChannelCfg;
 
typedef struct CBUFF_EDMAInfo_t
{
    EDMA_Handle     edmaHandle;
 
    bool            isFirstEDMAChannel;
 
    uint32_t         dmaNum;
}CBUFF_EDMAInfo;
 
typedef int32_t (*CBUFF_EDMAChannelAllocateFxn) (CBUFF_EDMAInfo* ptrEDMAInfo, CBUFF_EDMAChannelCfg* ptrEDMAChannelCfg);
 
typedef void (*CBUFF_EDMAChannelFreeFxn) (CBUFF_EDMAChannelCfg* ptrEDMAChannelCfg);
 
typedef void (*CBUFF_FrameDoneCallbackFxn) (CBUFF_SessionHandle sessionHandle);
 
typedef struct CBUFF_SwSessionCfg_t
{
    CBUFF_BufferCfg     userBufferInfo[CBUFF_MAX_USER_BUFFER];
}CBUFF_SwSessionCfg;
 
typedef struct CBUFF_SessionCfg_t
{
 
    CBUFF_FrameDoneCallbackFxn      frameDoneCallbackFxn;
 
    EDMA_Handle                     edmaHandle;
 
    CBUFF_EDMAChannelAllocateFxn    allocateEDMAChannelFxn;
 
    CBUFF_EDMAChannelFreeFxn        freeEDMAChannelFxn;
 
    CBUFF_DataType                  dataType;
 
    CBUFF_BufferCfg                 header;
 
    CBUFF_SwSessionCfg      swCfg;
}CBUFF_SessionCfg;
 
typedef struct CBUFF_InitCfg_t
{
 
    CBUFF_OutputDataFmt             outputDataFmt;
 
    uint8_t                         enableECC;
 
    uint8_t                         crcEnable;
 
    uint8_t                         maxSessions;
 
    bool                            enableDebugMode;
 
    CBUFF_Interface                 interface;
 
    CBUFF_LVDSCfg                   lvdsCfg;
}CBUFF_InitCfg;
 
typedef struct CBUFF_EDMATrackingEntry_t
{
    CBUFF_EDMAChannelCfg    cbuffEDMAChannelCfg;
 
    uint32_t                srcAddress;
 
    uint32_t                transferSize;
}CBUFF_EDMATrackingEntry;
 
typedef struct CBUFF_Session_t
{
    bool                            isValid;
 
    struct CBUFF_Driver_t*          ptrDriverMCB;
 
    CBUFF_SessionCfg                sessionCfg;
 
    uint8_t                         dmaNum;
 
    uint8_t                         numActiveADCChannels;
 
    uint16_t                        adcTransferSize;
 
    uint8_t                         linkListIndex;
 
    CBUFF_LinkListParams            linkedListTracker[CBUFF_MAX_LINKED_LIST_SIZE];
 
    uint8_t                         edmaChannelCount;
 
    CBUFF_EDMATrackingEntry         edmaTrackingEntry[CBUFF_EDMA_MAX_NUM_CHANNELS];
 
    uint32_t                        numChirpsPerFrame;
 
    volatile uint32_t               numFrameDone;
 
    volatile uint32_t               numChirpDone;
}CBUFF_Session;
 
typedef struct CBUFF_Driver_t
{
    CBUFF_InitCfg                   initCfg;
 
    CSL_CbuffRegs*                   ptrCBUFFReg;
 
    struct CBUFF_InterfaceFxn_t*    interfaceFxn;
 
    HwiP_Object                     hwiISRHandle;
 
    HwiP_Object                     hwiErrorISRHandle;
 
    CBUFF_Session*                  ptrSessionTable;
 
    CBUFF_Session*                  ptrCurrentActiveSession;
 
    uint8_t                         numActiveLVDSLanes;
 
    CBUFF_Attrs          const       *hwAttrs;
 
    volatile uint32_t               totalNumFrameDone;
 
    volatile uint32_t               totalNumChirpDone;
 
    uint32_t                        totalNumNonActiveSessionInterrupts;
 
    volatile uint32_t               totalNumErrorInterrupts;
}CBUFF_Object;
 
typedef int32_t (*CBUFF_initFxn) (CBUFF_Object* ptrDriverMCB, int32_t* errCode);
 
typedef int32_t (*CBUFF_deinitFxn) (CBUFF_Object* ptrDriverMCB, int32_t* errCode);
 
typedef int32_t (*CBUFF_openFxn) (CBUFF_Session* ptrSession, int32_t* errCode);
 
typedef int32_t (*CBUFF_closeFxn) (CBUFF_Session* ptrSession, int32_t* errCode);
 
typedef void (*CBUFF_initLinkListParamsFxn) (CBUFF_Session* ptrSession, CBUFF_LinkListParams* ptrLinkListParams);
 
typedef void (*CBUFF_finalizeLinkListParamsFxn) (CBUFF_Session* ptrSession, CBUFF_LinkListParams* ptrLinkListParams);
 
typedef struct CBUFF_InterfaceFxn_t
{
    CBUFF_Interface                 interface;
 
    CBUFF_initFxn                   initFxn;
 
    CBUFF_deinitFxn                 deinitFxn;
 
    CBUFF_openFxn                   openFxn;
 
    CBUFF_closeFxn                  closeFxn;
 
    CBUFF_initLinkListParamsFxn     initLinkListParamsFxn;
 
    CBUFF_finalizeLinkListParamsFxn finalizeLinkListParamsFxn;
}CBUFF_InterfaceFxn;
 /* end defgroup CBUFF_DRIVER_EXTERNAL_DATA_STRUCTURE */
 
extern CBUFF_Attrs        gCbuffAttrs[];
extern CBUFF_Object       gCbuffObject[];
extern CBUFF_Object      *gCbuffObjectPtr[];
extern uint32_t           gCbuffConfigNum;
 
/* ========================================================================== */
/*                          Function Declarations                             */
/* ========================================================================== */
 
void CBUFF_init(void);
 
 
CBUFF_Handle CBUFF_open (CBUFF_InitCfg* ptrInitCfg, int32_t* errCode);
 
 
CBUFF_SessionHandle CBUFF_createSession (CBUFF_Handle cbuffHandle, CBUFF_SessionCfg* ptrSessionCfg, int32_t* errCode);
 
 
int32_t CBUFF_close(CBUFF_SessionHandle sessionHandle, int32_t* errCode);
 
int32_t CBUFF_deinit (CBUFF_Handle cBuffHandle, int32_t* errCode);
 
int32_t CBUFF_control(CBUFF_Handle cBuffHandle, CBUFF_Command cmd, void* arg, uint32_t argLen, int32_t* errCode);
 
int32_t CBUFF_activateSession (CBUFF_SessionHandle sessionHandle, int32_t* errCode);
 
int32_t CBUFF_deactivateSession (CBUFF_SessionHandle sessionHandle, int32_t* errCode);
 
#ifdef __cplusplus
}
#endif
 
#endif /* #ifndef CBUFF_V1_H_ */