canfd.h

Go to the documentation of this file.

/*
 * Copyright (C) 2024 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 CANFD__H_
#define CANFD__H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <drivers/mcan/v0/mcan.h>
#include <drivers/hw_include/cslr_soc.h>
#include <kernel/dpl/SemaphoreP.h>
#include <kernel/dpl/HwiP.h>
#include <drivers/mcan/v0/dma/canfd_dma.h>
 
typedef struct CANFD_Config_s *CANFD_Handle;
 
extern uint32_t             gCANFDConfigNum;
 
#define MCAN_STATUS_SUCCESS         ((int32_t)0)
 
#define MCAN_STATUS_FAILURE         ((int32_t)-1)
 
#define CANFD_TRANSFER_MODE_BLOCKING    (0U)
 
#define CANFD_TRANSFER_MODE_CALLBACK    (1U)
 
#define CANFD_OPER_MODE_POLLED                 (0U)
#define CANFD_OPER_MODE_INTERRUPT              (1U)
#define CANFD_OPER_MODE_DMA                    (2U)
 
#define MCAN_MSG_RAM_STD_ELEM_SIZE          (1U)
 
#define MCAN_MSG_RAM_EXT_ELEM_SIZE          (2U)
 
#define MCAN_MSG_HEADER_SIZE                (8U)
 
#define MCAN_FRAME_TYPE_FD                  (1U)
 
#define MCAN_MSG_RAM_TX_RX_ELEM_SIZE        (18U)
 
#define XTD_MSGID_MASK                      (0x1fffffffU)
#define STD_MSGID_MASK                      (0x7ffU)
#define STD_MSGID_SHIFT                     (18U)
 
#define MCAN_MAX_PAYLOAD_BYTES              (64U)
 
#define MCAN_MAX_RX_BUFFERS                 (64U)
 
#define MCAN_MAX_TX_BUFFERS                 (32U)
 
#define CANFD_UTILS_ARRAYSIZE(x)  (sizeof(x) / sizeof(x[0]))
 
#define CANFD_UTILS_GETARRAYINDEX(member, array)   (member - &array[0])
 
#define CANFD_UTILS_ARRAYISMEMBER(member, array)                              \
    (((((uint32)member - (uint32) & array[0]) % sizeof(array[0])) == 0)       \
     && (member >= &array[0])                                                 \
     && (CANFD_UTILS_GETARRAYINDEX(member, array) < CANFD_UTILS_ARRAYSIZE(array)))
 
#define MCAN_INTR_MASK       ((uint32_t)MCAN_INTR_SRC_RX_FIFO0_NEW_MSG | \
                              (uint32_t)MCAN_INTR_SRC_RX_FIFO0_MSG_LOST |  \
                              (uint32_t)MCAN_INTR_SRC_RX_FIFO1_NEW_MSG | \
                              (uint32_t)MCAN_INTR_SRC_TRANS_COMPLETE |  \
                              (uint32_t)MCAN_INTR_SRC_TRANS_CANCEL_FINISH |  \
                              (uint32_t)MCAN_INTR_SRC_DEDICATED_RX_BUFF_MSG |  \
                              (uint32_t)MCAN_INTR_SRC_PROTOCOL_ERR_ARB |  \
                              (uint32_t)MCAN_INTR_SRC_PROTOCOL_ERR_DATA |  \
                              (uint32_t)MCAN_INTR_SRC_RX_FIFO1_MSG_LOST | \
                              (uint32_t)MCAN_INTR_SRC_BUS_OFF_STATUS)
 
#define CANFD_DMA_TX_COMPLETION_INTERMEDIATE        (1U)
 
#define CANFD_DMA_TX_COMPLETION_FINAL               (2U)
 
#define CANFD_DMA_RX_COMPLETION_INTERMEDIATE        (1U)
 
#define CANFD_DMA_RX_COMPLETION_FINAL               (2U)
 
#define CANFD_MAX_DLC_MAPPING                        (16U)
 
#define CANFD_DRIVER_STATE_UNINIT        (0U)
 
#define CANFD_DRIVER_STATE_STARTED       (1U)
 
#define CANFD_DRIVER_STATE_STOPPED       (2U)
 
#define CCANFD_DRIVER_STATE_SLEEP        (3U)
 
typedef enum CANFD_MCANElemSize_t
{
    CANFD_MCANElemSize_8BYTES = 0U,
 
    CANFD_MCANElemSize_12BYTES = 1U,
 
    CANFD_MCANElemSize_16BYTES = 2U,
 
    CANFD_MCANElemSize_20BYTES = 3U,
 
    CANFD_MCANElemSize_24BYTES = 4U,
 
    CANFD_MCANElemSize_32BYTES = 5U,
 
    CANFD_MCANElemSize_48BYTES = 6U,
 
    CANFD_MCANElemSize_64BYTES = 7U
}CANFD_MCANElemSize;
 
typedef enum CANFD_MCANOperationMode_t
{
    CANFD_MCANOperationMode_NORMAL = 0U,
 
    CANFD_MCANOperationMode_SW_INIT = 1U
}CANFD_MCANOperationMode;
 
typedef enum CANFD_Direction_t
{
    CANFD_Direction_RX,
 
    CANFD_Direction_TX
} CANFD_Direction;
 
typedef enum CANFD_MCANXidType_t
{
    CANFD_MCANXidType_11_BIT,
 
    CANFD_MCANXidType_29_BIT
} CANFD_MCANXidType;
 
typedef enum CANFD_MCANFrameType_t
{
    CANFD_MCANFrameType_CLASSIC,
 
    CANFD_MCANFrameType_FD
} CANFD_MCANFrameType;
 
typedef enum CANFD_MCANTimeOutSelect_t
{
    CANFD_MCANTimeOutSelect_CONT = 0U,
 
    CANFD_MCANTimeOutSelect_TX_EVENT_FIFO = 1U,
 
    CANFD_MCANTimeOutSelect_RX_FIFO0 = 2U,
 
    CANFD_MCANTimeOutSelect_RX_FIFO1 = 3U
}CANFD_MCANTimeOutSelect;
 
typedef uint32_t CANFD_MCANECCErrType;
 
#define CANFD_MCAN_ECC_ERR_TYPE_SEC                   (0U)
 
#define CANFD_MCAN_ECC_ERR_TYPE_DED                   (1U)
 
typedef enum CANFD_MCANLoopBackMode_t
{
    CANFD_MCANLoopBackMode_INTERNAL = 0U,
 
    CANFD_MCANLoopBackMode_EXTERNAL = 1U
}CANFD_MCANLoopBackMode;
 
typedef enum CANFD_MCANCommState_t
{
    CANFD_MCANCommState_SYNCHRONIZING = 0U,
 
    CANFD_MCANCommState_IDLE = 1U,
 
    CANFD_MCANCommState_RECEIVER = 2U,
 
    CANFD_MCANCommState_TRANSMITTER = 3U
}CANFD_MCANCommState;
 
typedef enum CANFD_MCANErrCode_t
{
    CANFD_MCANErrCode_NO_ERROR = 0U,
 
    CANFD_MCANErrCode_STUFF_ERROR = 1U,
 
    CANFD_MCANErrCode_FORM_ERROR = 2U,
 
    CANFD_MCANErrCode_ACK_ERROR = 3U,
 
    CANFD_MCANErrCode_BIT1_ERROR = 4U,
 
    CANFD_MCANErrCode_BIT0_ERROR = 5U,
 
    CANFD_MCANErrCode_CRC_ERROR = 6U,
 
    CANFD_MCANErrCode_NO_CHANGE = 7U
}CANFD_MCANErrCode;
 
typedef enum CANFD_Reason_t
{
    CANFD_Reason_RX                         = 0x1,
 
    CANFD_Reason_TX_COMPLETION              = 0x2,
 
    CANFD_Reason_TX_CANCELED                = 0x3,
 
    CANFD_Reason_ECC_ERROR                  = 0x4,
 
    CANFD_Reason_BUSOFF                     = 0x5,
 
    CANFD_Reason_PROTOCOL_ERR_DATA_PHASE    = 0x6,
 
    CANFD_Reason_PROTOCOL_ERR_ARB_PHASE     = 0x7,
    
    CANFD_Reason_SRC_RX_FIFO0_MSG_LOST     = 0x8,
 
    CANFD_Reason_SRC_RX_FIFO1_MSG_LOST     = 0x9
}CANFD_Reason;
 
typedef enum CANFD_Option_t
{
    CANFD_Option_MCAN_ERROR_COUNTER,
 
    CANFD_Option_MCAN_PROTOCOL_STATUS,
 
    CANFD_Option_MCAN_MSG_OBJECT_STATS,
 
    CANFD_Option_MCAN_MODE,
 
    CANFD_Option_MCAN_LOOPBACK,
 
    CANFD_Option_MCAN_POWER_DOWN
} CANFD_Option;
 
typedef struct CANFD_MCANLoopbackCfgParams_t
{
    uint32_t                enable;
 
    CANFD_MCANLoopBackMode  mode;
}CANFD_MCANLoopbackCfgParams;
 
typedef struct CANFD_MCANBitTimingParams_t
{
    uint32_t        nomBrp;
 
    uint32_t        nomPropSeg;
 
    uint32_t        nomPseg1;
 
    uint32_t        nomPseg2;
 
    uint32_t        nomSjw;
 
    uint32_t        dataBrp;
 
    uint32_t        dataPropSeg;
 
    uint32_t        dataPseg1;
 
    uint32_t        dataPseg2;
 
    uint32_t        dataSjw;
}CANFD_MCANBitTimingParams;
 
typedef struct CANFD_MCANTdcConfig_t
{
    uint32_t        tdcf;
 
    uint32_t        tdco;
}CANFD_MCANTdcConfig;
 
typedef struct CANFD_MCANGlobalFiltConfig_t
{
    uint32_t        rrfe;
 
    uint32_t        rrfs;
 
    uint32_t        anfe;
 
    uint32_t        anfs;
}CANFD_MCANGlobalFiltConfig;
 
typedef struct CANFD_MCANMsgRAMCfgParams_t
{
    uint32_t            lss;
 
    uint32_t            lse;
 
    uint32_t            txBufNum;
 
    uint32_t            txFIFOSize;
 
    uint32_t            txBufMode;
 
    uint32_t            txEventFIFOSize;
 
    uint32_t            txEventFIFOWaterMark;
 
    uint32_t            rxFIFO0size;
 
    uint32_t            rxFIFO0waterMark;
 
    uint32_t            rxFIFO0OpMode;
 
    uint32_t            rxFIFO1size;
 
    uint32_t            rxFIFO1waterMark;
 
    uint32_t            rxFIFO1OpMode;
}CANFD_MCANMsgRAMCfgParams;
 
typedef struct CANFD_MCANECCConfigParams_t
{
    uint32_t            enable;
 
    uint32_t            enableChk;
 
    uint32_t            enableRdModWr;
}CANFD_MCANECCConfigParams;
 
typedef struct CANFD_MCANErrCntStatus_t
{
    uint32_t            transErrLogCnt;
 
    uint32_t            recErrCnt;
 
    uint32_t            rpStatus;
 
    uint32_t            canErrLogCnt;
}CANFD_MCANErrCntStatus;
 
typedef struct CANFD_MCANProtocolStatus_t
{
    uint32_t                lastErrCode;
 
    uint32_t                act;
 
    uint32_t                errPassive;
 
    uint32_t                warningStatus;
 
    uint32_t                busOffStatus;
 
    uint32_t                dlec;
 
    uint32_t                resi;
 
    uint32_t                rbrs;
 
    uint32_t                rfdf;
 
    uint32_t                pxe;
 
    uint32_t                tdcv;
}CANFD_MCANProtocolStatus;
 
typedef struct CANFD_MCANECCErrForceParams_t
{
    uint32_t                errType;
 
    uint32_t                rowNum;
 
    uint32_t                bit1;
 
    uint32_t                bit2;
 
    uint32_t                errOnce;
 
    uint32_t                errForce;
}CANFD_MCANECCErrForceParams;
 
typedef struct CANFD_MCANECCErrStatus_t
{
    uint32_t                secErr;
 
    uint32_t                dedErr;
 
    uint32_t                row;
 
    uint32_t                bit1;
 
    uint32_t                bit2;
}CANFD_MCANECCErrStatus;
 
typedef union CANFD_ErrStatusResp_t
{
    CANFD_MCANECCErrStatus      eccErrStatus;
 
    CANFD_MCANProtocolStatus    protocolStatus;
} CANFD_ErrStatusResp;
 
 
typedef struct CANFD_Attrs_s
{
    /* Peripheral base address */
    uint32_t                baseAddr;
 
    uint32_t                intrNum0;
 
    uint32_t                intrNum1;
 
    uint32_t                operMode;
 
    uint8_t                 intrPriority;
 
    uint32_t                OptionTLVtype;
 
    /* MCAN Loopback parameters. */
    CANFD_MCANLoopbackCfgParams    CANFDMcanloopbackParams;
 
    /* parameters for bit timing calculation. */
    CANFD_MCANBitTimingParams      CANFDMcanBitTimingParams;
 
    uint32_t         txMemType;
 
    uint32_t         rxMemType;
 
    void                *filterConfig;
} CANFD_Attrs;
 
typedef struct CANFD_OptionTLV_t
{
    CANFD_Option            type;
 
    int32_t                 length;
 
    void*                   value;
}CANFD_OptionTLV;
 
typedef void (*CANFD_TransferCallbackFxn) (void *args, CANFD_Reason reason);
 
typedef void (*CANFD_ErrorCallbackFxn) (void *args, CANFD_Reason reason, 
                          CANFD_ErrStatusResp* errStatusResp);
 
 
typedef struct CANFD_OpenParams_t
{
    uint32_t                transferMode;
 
    CANFD_TransferCallbackFxn       transferCallbackFxn;
 
    CANFD_ErrorCallbackFxn           errorCallbackFxn;
 
    uint32_t                    fdMode;
 
    uint32_t                    brsEnable;
 
    uint32_t                    txpEnable;
 
    uint32_t                    efbi;
 
    uint32_t                    pxhddisable;
 
    uint32_t                    darEnable;
 
    uint32_t                    wkupReqEnable;
 
    uint32_t                    autoWkupEnable;
 
    uint32_t                    emulationEnable;
 
    uint32_t                    emulationFAck;
 
    uint32_t                    clkStopFAck;
 
    uint32_t                    wdcPreload;
 
    uint32_t                    tdcEnable;
 
    CANFD_MCANTdcConfig         tdcConfig;
 
    uint32_t                    monEnable;
 
    uint32_t                    asmEnable;
 
    uint32_t                    tsPrescalar;
 
    uint32_t                    tsSelect;
 
    CANFD_MCANTimeOutSelect     timeoutSelect;
 
    uint32_t                    timeoutPreload;
 
    uint32_t                    timeoutCntEnable;
 
    CANFD_MCANGlobalFiltConfig  filterConfig;
 
    CANFD_MCANMsgRAMCfgParams   msgRAMConfig;
 
    CANFD_MCANECCConfigParams   eccConfig;
 
    uint32_t                    errInterruptEnable;
 
    uint32_t                    dataInterruptEnable;
}CANFD_OpenParams;
 
typedef struct CANFD_Object_t
{
    CANFD_Handle            handle;
 
    uint32_t                regBaseAddress;
 
    uint32_t                state;
 
    CANFD_OpenParams               *openParams;
 
    uint8_t                         mcanDataSize[CANFD_MAX_DLC_MAPPING];
 
    struct CANFD_MessageObject_t*  msgObjectHandle[MCAN_MAX_MSG_OBJECTS];
 
    struct CANFD_MessageObject_t*   txMapping[MCAN_MAX_TX_MSG_OBJECTS];
 
    struct CANFD_MessageObject_t*   rxMapping[MCAN_MAX_RX_MSG_OBJECTS];
 
    uint32_t                        errStatusInterrupts;
 
    uint32_t                        interrupts;
 
    uint32_t                        eccInterrupts;
 
    uint32_t                        busOffInterrupts;
 
    uint32_t                        protoDataErrInterrupts;
 
    uint32_t                        protoArbErrInterrupts;
 
    uint8_t                         txStatus[MCAN_MAX_TX_MSG_OBJECTS];
 
    uint32_t                        useFifoNum;
 
    MCAN_RxBufElement               rxBuffElem;
 
    CANFD_DmaHandle             canfdDmaHandle;
 
    CANFD_DmaChConfig           canfdDmaChCfg;
 
    void*                          args;
 
    void                   *readTransferSem;
 
    SemaphoreP_Object       readTransferSemObj;
 
    void                   *writeTransferSem;
 
    SemaphoreP_Object       writeTransferSemObj;
 
    void                   *hwiHandle;
 
    HwiP_Object             hwiObj0;
 
    HwiP_Object             hwiObj1;
 
    /* Revision ID and Core Release Info */
    MCAN_RevisionId         revId;
 
}CANFD_Object;
 
typedef struct CANFD_Config_s
{
    CANFD_Attrs      *attrs;
    CANFD_Object     *object;
} CANFD_Config;
 
typedef struct CANFD_DmaMsgConfig_s
{
    uint32_t        dataLengthPerMsg;
    uint32_t        numMsgs;
    const void      *data;
    uint32_t        currentMsgNum;
}CANFD_DmaMsgConfig;
 
typedef struct CANFD_DmaRxBuf_s
{
    /* Header word 1 in Rx buffer in message ram */
    uint32_t        header1;
    /* Header word 2 in Rx buffer in message ram */
    uint32_t        header2;
    /* Data Bytes Rx buffer in message ram */
    uint8_t         data[MCAN_MAX_RX_BUFFERS];
}CANFD_DmaRxBuf;
 
typedef struct CANFD_MessageObject_t
{
    uint32_t                startMsgId;
 
    uint32_t                endMsgId;
 
    CANFD_Config*           canfdHandle;
 
    CANFD_Direction         direction;
 
    CANFD_MCANXidType       msgIdType;
 
    uint32_t                messageObjNum;
 
    uint32_t                dataLength;
 
    uint32_t                txElement;
 
    uint32_t                rxElement;
 
    MCAN_MemType            txMemType;
 
    MCAN_MemType            rxMemType;
 
    uint32_t               rxFifoNum;
 
    uint32_t                interruptsRxed;
 
    uint32_t                messageProcessed;
 
    uint32_t                dmaEventNo;
    CANFD_DmaMsgConfig      dmaMsgConfig;
 
    void                   *args;
 
    void                *filterConfig;
}CANFD_MessageObject;
 
typedef CANFD_MessageObject* CANFD_MsgObjHandle;
 
typedef struct CANFD_MCANMsgObjectStats_t
{
    CANFD_MsgObjHandle      handle;
 
    uint32_t                direction;
 
    uint32_t                startMsgIdentifier;
 
    uint32_t                endMsgIdentifier;
 
    uint32_t                interruptsRxed;
 
    uint32_t                messageProcessed;
} CANFD_MCANMsgObjectStats;
 
void CANFD_init(void);
 
void CANFD_deinit(void);
 
CANFD_Handle CANFD_open(uint32_t index, CANFD_OpenParams *openPrms);
 
void CANFD_close(CANFD_Handle handle);
 
int32_t CANFD_configBitTime(CANFD_Handle handle, const CANFD_MCANBitTimingParams* bitTimeParams);
 
int32_t CANFD_createMsgObject(CANFD_Handle handle, 
                              CANFD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_createRxRangeMsgObject(CANFD_Handle handle, 
                                     CANFD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_deleteMsgObject(CANFD_MsgObjHandle handle);
 
int32_t CANFD_write(CANFD_MsgObjHandle handle, uint32_t id, 
                    CANFD_MCANFrameType frameType, uint32_t numMsgs, 
                    const uint8_t* data);
 
int32_t CANFD_writeCancel(CANFD_MsgObjHandle handle);
 
int32_t CANFD_writeDma(CANFD_MsgObjHandle handle, uint32_t id, 
                       CANFD_MCANFrameType frameType, 
                       uint32_t numMsgs, const void* data);
 
int32_t CANFD_writeDmaTriggerNext(CANFD_MsgObjHandle handle);
 
uint32_t CANFD_getFilterEventConfig(uint32_t eventNum);
 
int32_t CANFD_read(CANFD_MsgObjHandle rxMsgHandle, uint32_t numMsgs, uint8_t* data);
 
int32_t CANFD_readDmaConfig(CANFD_MsgObjHandle handle, const void* data, uint32_t numMsgs);
 
int32_t CANFD_getOptions(CANFD_Handle handle, const CANFD_OptionTLV* ptrOptInfo);
 
int32_t CANFD_setOptions(CANFD_Handle handle, const CANFD_OptionTLV* ptrOptInfo);
 
void CANFD_int0Isr (void *args);
 
void CANFD_int1Isr (void *args);
 
void CANFD_transferCallBack(void *args, CANFD_Reason reason);
 
void CANFD_errStatusCallBack(CANFD_Handle handle, CANFD_Reason reason, 
                             CANFD_ErrStatusResp* errStatusResp);
 
int32_t CANFD_dmaOpen(CANFD_Handle canfdHandle, CANFD_DmaChConfig dmaChCfg);
 
int32_t CANFD_dmaClose(CANFD_Handle canfdHandle);
 
int32_t CANFD_createDmaTxMsgObject(const CANFD_Object *ptrCanFdObj, 
                                   CANFD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_deleteDmaTxMsgObject(const CANFD_Object *ptrCanFdObj, 
                            const CANFD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_configureDmaTx(const CANFD_Object *ptrCanFdObj, 
                    CANFD_MessageObject* ptrCanMsgObj, uint32_t dataLengthPerMsg, 
                    uint32_t numMsgs, const void* data);
 
int32_t CANFD_cancelDmaTx(const CANFD_Object *ptrCanFdObj, 
                const CANFD_MessageObject* ptrCanMsgObj);
 
void CANFD_dmaTxCompletionCallback(CANFD_MessageObject* ptrCanMsgObj, 
                const void *data, uint32_t completionType);
 
int32_t CANFD_createDmaRxMsgObject(const CANFD_Object *ptrCanFdObj, 
                CANFD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_deleteDmaRxMsgObject(const CANFD_Object *ptrCanFdObj, 
                                   const CANFD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_configureDmaRx(const CANFD_Object *ptrCanFdObj, 
                             CANFD_MessageObject* ptrCanMsgObj, 
                             uint32_t dataLengthPerMsg, uint32_t numMsgs, 
                             const void* data);
 
void CANFD_dmaRxCompletionCallback(CANFD_MessageObject* ptrCanMsgObj, const void *data, 
                                   uint32_t completionType);
 
 
int32_t CANFD_isDataSizeValid(uint32_t dataSize);
 
/* ========================================================================== */
/*                          Advance Functions                                 */
/* ========================================================================== */
 
int32_t CANFD_getEndianVal(CANFD_Handle canfdHandle);
 
void CANFD_getRevisionId(CANFD_Handle canfdHandle);
 
void CANFD_addClockStopRequest(CANFD_Handle canfdHandle, uint32_t enable);
 
uint32_t CANFD_clockStopReq(CANFD_Handle canfdHandle);
 
uint32_t CANFD_getClkStopAck(CANFD_Handle canfdHandle);
 
uint32_t CANFD_getRxPinState(CANFD_Handle canfdHandle);
 
void CANFD_setTxPinState(CANFD_Handle canfdHandle, uint32_t state);
 
uint32_t CANFD_getTxPinState(CANFD_Handle canfdHandle);
 
void CANFD_getBitTime(CANFD_Handle canfdHandle);
 
uint32_t CANFD_getTSCounterVal(CANFD_Handle canfdHandle);
 
void CANFD_resetTSCounter(CANFD_Handle canfdHandle);
 
#ifdef __cplusplus
}
#endif
 
#endif /* #ifndef CANFD__H_ */