mcan.h

Go to the documentation of this file.

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

/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
#include <ti/csl/soc.h>
#include <ti/csl/cslr_mcan.h>

#ifdef __cplusplus
extern "C" {
#endif

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

#define MCAN_INTR_MASK_ALL   (MCAN_IR_RF0N_MASK | \
                              MCAN_IR_RF0W_MASK | \
                              MCAN_IR_RF0F_MASK | \
                              MCAN_IR_RF0L_MASK | \
                              MCAN_IR_RF1N_MASK | \
                              MCAN_IR_RF1W_MASK | \
                              MCAN_IR_RF1F_MASK | \
                              MCAN_IR_RF1L_MASK | \
                              MCAN_IR_HPM_MASK |  \
                              MCAN_IR_TC_MASK |   \
                              MCAN_IR_TCF_MASK |  \
                              MCAN_IR_TFE_MASK |  \
                              MCAN_IR_TEFN_MASK | \
                              MCAN_IR_TEFW_MASK | \
                              MCAN_IR_TEFF_MASK | \
                              MCAN_IR_TEFL_MASK | \
                              MCAN_IR_TSW_MASK |  \
                              MCAN_IR_MRAF_MASK | \
                              MCAN_IR_TOO_MASK |  \
                              MCAN_IR_DRX_MASK |  \
                              MCAN_IR_BEC_MASK |  \
                              MCAN_IR_BEU_MASK |  \
                              MCAN_IR_ELO_MASK |  \
                              MCAN_IR_EP_MASK |   \
                              MCAN_IR_EW_MASK |   \
                              MCAN_IR_BO_MASK |   \
                              MCAN_IR_WDI_MASK |  \
                              MCAN_IR_PEA_MASK |  \
                              MCAN_IR_PED_MASK |  \
                              MCAN_IR_ARA_MASK)

#define MCAN_MAX_PAYLOAD_BYTES                          (64U)

/* ========================================================================== */
/*                         Structures and Enums                               */
/* ========================================================================== */
typedef uint32_t MCAN_IntrLineNum;

#define MCAN_INTR_LINE_NUM_0                    (0U)

#define MCAN_INTR_LINE_NUM_1                    (1U)

/* @} */

typedef uint32_t MCAN_IdType;

#define MCAN_ID_TYPE_11_BIT                     (0U)

#define MCAN_ID_TYPE_29_BIT                     (1U)

/* @} */

typedef uint32_t MCAN_OperationMode;

#define MCAN_OPERATION_MODE_NORMAL              (0U)

#define MCAN_OPERATION_MODE_SW_INIT             (1U)

/* @} */

typedef uint32_t MCAN_MemType;

#define MCAN_MEM_TYPE_BUF                       (0U)

#define MCAN_MEM_TYPE_FIFO                      (1U)

/* @} */

typedef uint32_t MCAN_RxFIFONum;

#define MCAN_RX_FIFO_NUM_0                      (0U)

#define MCAN_RX_FIFO_NUM_1                      (1U)

/* @} */

typedef uint32_t MCAN_PinType;

#define MCAN_PIN_TYPE_RX                        (0U)

#define MCAN_PIN_TYPE_TX                        (1U)

/* @} */

typedef uint32_t MCAN_ElemSize;

#define MCAN_ELEM_SIZE_8BYTES                   (0U)

#define MCAN_ELEM_SIZE_12BYTES                  (1U)

#define MCAN_ELEM_SIZE_16BYTES                  (2U)

#define MCAN_ELEM_SIZE_20BYTES                  (3U)

#define MCAN_ELEM_SIZE_24BYTES                  (4U)

#define MCAN_ELEM_SIZE_32BYTES                  (5U)

#define MCAN_ELEM_SIZE_48BYTES                  (6U)

#define MCAN_ELEM_SIZE_64BYTES                  (7U)

/* @} */

typedef uint32_t MCAN_TimeOutSelect;

#define MCAN_TIMEOUT_SELECT_CONT                (0U)

#define MCAN_TIMEOUT_SELECT_TX_EVENT_FIFO       (1U)

#define MCAN_TIMEOUT_SELECT_RX_FIFO0            (2U)

#define MCAN_TIMEOUT_SELECT_RX_FIFO1            (3U)

/* @} */

typedef uint32_t MCAN_IntrSrc;

#define MCAN_INTR_SRC_RX_FIFO0_NEW_MSG          (MCAN_IR_RF0N_MASK)

#define MCAN_INTR_SRC_RX_FIFO0_WATERMARK        (MCAN_IR_RF0W_MASK)

#define MCAN_INTR_SRC_RX_FIFO0_FULL             (MCAN_IR_RF0F_MASK)

#define MCAN_INTR_SRC_RX_FIFO0_MSG_LOST         (MCAN_IR_RF0L_MASK)

#define MCAN_INTR_SRC_RX_FIFO1_NEW_MSG          (MCAN_IR_RF1N_MASK)

#define MCAN_INTR_SRC_RX_FIFO1_WATERMARK        (MCAN_IR_RF1W_MASK)

#define MCAN_INTR_SRC_RX_FIFO1_FULL             (MCAN_IR_RF1F_MASK)

#define MCAN_INTR_SRC_RX_FIFO1_MSG_LOST         (MCAN_IR_RF1L_MASK)

#define MCAN_INTR_SRC_HIGH_PRIO_MSG             (MCAN_IR_HPM_MASK)

#define MCAN_INTR_SRC_TRANS_COMPLETE            (MCAN_IR_TC_MASK)

#define MCAN_INTR_SRC_TRANS_CANCEL_FINISH       (MCAN_IR_TCF_MASK)

#define MCAN_INTR_SRC_TX_FIFO_EMPTY             (MCAN_IR_TFE_MASK)

#define MCAN_INTR_SRC_TX_EVT_FIFO_NEW_ENTRY     (MCAN_IR_TEFN_MASK)

#define MCAN_INTR_SRC_TX_EVT_FIFO_WATERMARK     (MCAN_IR_TEFW_MASK)

#define MCAN_INTR_SRC_TX_EVT_FIFO_FULL          (MCAN_IR_TEFF_MASK)

#define MCAN_INTR_SRC_TX_EVT_FIFO_ELEM_LOST     (MCAN_IR_TEFL_MASK)

#define MCAN_INTR_SRC_TIMESTAMP_WRAPAROUND      (MCAN_IR_TSW_MASK)

#define MCAN_INTR_SRC_MSG_RAM_ACCESS_FAILURE    (MCAN_IR_MRAF_MASK)

#define MCAN_INTR_SRC_TIMEOUT                   (MCAN_IR_TOO_MASK)

#define MCAN_INTR_SRC_DEDICATED_RX_BUFF_MSG     (MCAN_IR_DRX_MASK)

#define MCAN_INTR_SRC_BIT_ERR_CORRECTED         (MCAN_IR_BEC_MASK)

#define MCAN_INTR_SRC_BIT_ERR_UNCORRECTED       (MCAN_IR_BEU_MASK)

#define MCAN_INTR_SRC_ERR_LOG_OVRFLW            (MCAN_IR_ELO_MASK)

#define MCAN_INTR_SRC_ERR_PASSIVE               (MCAN_IR_EP_MASK)

#define MCAN_INTR_SRC_WARNING_STATUS            (MCAN_IR_EW_MASK)

#define MCAN_INTR_SRC_BUS_OFF_STATUS            (MCAN_IR_BO_MASK)

#define MCAN_INTR_SRC_WATCHDOG                  (MCAN_IR_WDI_MASK)

#define MCAN_INTR_SRC_PROTOCOL_ERR_ARB          (MCAN_IR_PEA_MASK)

#define MCAN_INTR_SRC_PROTOCOL_ERR_DATA         (MCAN_IR_PED_MASK)

#define MCAN_INTR_SRC_RES_ADDR_ACCESS           (MCAN_IR_ARA_MASK)

/* @} */

typedef uint32_t MCAN_ECCErrType;

#define MCAN_ECC_ERR_TYPE_SEC                   (0U)

#define MCAN_ECC_ERR_TYPE_DED                   (1U)

/* @} */

typedef uint32_t MCAN_LpbkMode;

#define MCAN_LPBK_MODE_INTERNAL                 (0U)

#define MCAN_LPBK_MODE_EXTERNAL                 (1U)

/* @} */

typedef uint32_t MCAN_ComState;

#define MCAN_COM_STATE_SYNCHRONIZING            (0U)

#define MCAN_COM_STATE_IDLE                     (1U)

#define MCAN_COM_STATE_RECEIVER                 (2U)

#define MCAN_COM_STATE_TRANSMITTER              (3U)

/* @} */

typedef uint32_t MCAN_ErrCode;

#define MCAN_ERR_CODE_NO_ERROR                  (0U)

#define MCAN_ERR_CODE_STUFF_ERROR               (1U)

#define MCAN_ERR_CODE_FORM_ERROR                (2U)

#define MCAN_ERR_CODE_ACK_ERROR                 (3U)

#define MCAN_ERR_CODE_BIT1_ERROR                (4U)

#define MCAN_ERR_CODE_BIT0_ERROR                (5U)

#define MCAN_ERR_CODE_CRC_ERROR                 (6U)

#define MCAN_ERR_CODE_NO_CHANGE                 (7U)

/* @} */

typedef struct
{
    uint32_t nomRatePrescalar;
    uint32_t nomTimeSeg1;
    uint32_t nomTimeSeg2;
    uint32_t nomSynchJumpWidth;
    uint32_t dataRatePrescalar;
    uint32_t dataTimeSeg1;
    uint32_t dataTimeSeg2;
    uint32_t dataSynchJumpWidth;
}MCAN_BitTimingParams;

typedef struct
{
    uint32_t tdcf;
    uint32_t tdco;
}MCAN_TDCConfig;

typedef struct
{
    uint32_t rrfe;
    uint32_t rrfs;
    uint32_t anfe;
    uint32_t anfs;
}MCAN_GlobalFiltConfig;

typedef struct
{
    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;
    MCAN_TDCConfig tdcConfig;
    uint32_t       tdcEnable;
}MCAN_InitParams;

typedef struct
{
    uint32_t              monEnable;
    uint32_t              asmEnable;
    uint32_t              tsPrescalar;
    uint32_t              tsSelect;
    uint32_t              timeoutSelect;
    uint32_t              timeoutPreload;
    uint32_t              timeoutCntEnable;
    MCAN_GlobalFiltConfig filterConfig;
}MCAN_ConfigParams;

typedef struct
{
    uint32_t transErrLogCnt;
    uint32_t recErrCnt;
    uint32_t rpStatus;
    uint32_t canErrLogCnt;
}MCAN_ErrCntStatus;

typedef struct
{
    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;
}MCAN_ProtocolStatus;

typedef struct
{
    uint32_t flssa;
    uint32_t lss;
    uint32_t flesa;
    uint32_t lse;
    uint32_t txStartAddr;
    uint32_t txBufNum;
    uint32_t txFIFOSize;
    uint32_t txBufMode;
    uint32_t txBufElemSize;
    uint32_t txEventFIFOStartAddr;
    uint32_t txEventFIFOSize;
    uint32_t txEventFIFOWaterMark;
    uint32_t rxFIFO0startAddr;
    uint32_t rxFIFO0size;
    uint32_t rxFIFO0waterMark;
    uint32_t rxFIFO0OpMode;
    uint32_t rxFIFO1startAddr;
    uint32_t rxFIFO1size;
    uint32_t rxFIFO1waterMark;
    uint32_t rxFIFO1OpMode;
    uint32_t rxBufStartAddr;
    uint32_t rxBufElemSize;
    uint32_t rxFIFO0ElemSize;
    uint32_t rxFIFO1ElemSize;
}MCAN_MsgRAMConfigParams;

typedef struct
{
    uint32_t bufIdx;
    uint32_t msi;
    uint32_t filterIdx;
    uint32_t filterList;
}MCAN_HighPriorityMsgInfo;

typedef struct
{
    uint32_t statusLow;
    uint32_t statusHigh;
}MCAN_RxNewDataStatus;

typedef struct
{
    uint32_t num;
    uint32_t fillLvl;
    uint32_t getIdx;
    uint32_t putIdx;
    uint32_t fifoFull;
    uint32_t msgLost;
}MCAN_RxFIFOStatus;

typedef struct
{
    uint32_t freeLvl;
    uint32_t getIdx;
    uint32_t putIdx;
    uint32_t fifoFull;
}MCAN_TxFIFOStatus;

typedef struct
{
    uint32_t fillLvl;
    uint32_t getIdx;
    uint32_t putIdx;
    uint32_t fifoFull;
    uint32_t eleLost;
}MCAN_TxEventFIFOStatus;

typedef struct
{
    uint32_t errType;
    uint32_t rowNum;
    uint32_t bit1;
    uint32_t bit2;
    uint32_t errOnce;
    uint32_t errForce;
}MCAN_ECCErrForceParams;

typedef struct
{
    uint32_t secErr;
    uint32_t dedErr;
    uint32_t row;
    uint32_t bit1;
    uint32_t bit2;
}MCAN_ECCErrStatus;

typedef struct
{
    uint32_t scheme;
    uint32_t bu;
    uint32_t modId;
    uint32_t rtlRev;
    uint32_t major;
    uint32_t custom;
    uint32_t minor;
    uint32_t day;
    uint32_t mon;
    uint32_t year;
    uint32_t subStep;
    uint32_t step;
    uint32_t rel;
}MCAN_RevisionId;

typedef struct
{
    uint32_t scheme;
    uint32_t bu;
    uint32_t modId;
    uint32_t rtlRev;
    uint32_t major;
    uint32_t custom;
    uint32_t minor;
}MCAN_ECCAggrRevisionId;

typedef struct
{
    uint32_t enable;
    uint32_t enableChk;
    uint32_t enableRdModWr;
}MCAN_ECCConfigParams;

typedef struct
{
    uint32_t scheme;
    uint32_t bu;
    uint32_t modId;
    uint32_t rtlRev;
    uint32_t major;
    uint32_t custom;
    uint32_t minor;
}MCAN_ECCWrapRevisionId;

typedef struct
{
    uint32_t id;
    uint32_t rtr;
    uint32_t xtd;
    uint32_t esi;
    uint32_t dlc;
    uint32_t brs;
    uint32_t fdf;
    uint32_t efc;
    uint32_t mm;
    uint8_t  data[MCAN_MAX_PAYLOAD_BYTES];
}MCAN_TxBufElement;

typedef struct
{
    uint32_t id;
    uint32_t rtr;
    uint32_t xtd;
    uint32_t esi;
    uint32_t dlc;
    uint32_t brs;
    uint32_t fdf;
    uint32_t efc;
    uint32_t mm;
    uint8_t  *data;
}MCAN_TxBufElementNoCpy;

typedef struct
{
    uint32_t id;
    uint32_t rtr;
    uint32_t xtd;
    uint32_t esi;
    uint32_t rxts;
    uint32_t dlc;
    uint32_t brs;
    uint32_t fdf;
    uint32_t fidx;
    uint32_t anmf;
    uint8_t  data[MCAN_MAX_PAYLOAD_BYTES];
}MCAN_RxBufElement;

typedef struct
{
    uint32_t id;
    uint32_t rtr;
    uint32_t xtd;
    uint32_t esi;
    uint32_t rxts;
    uint32_t dlc;
    uint32_t brs;
    uint32_t fdf;
    uint32_t fidx;
    uint32_t anmf;
    uint8_t  *data;
}MCAN_RxBufElementNoCpy;

typedef struct
{
    uint32_t id;
    uint32_t rtr;
    uint32_t xtd;
    uint32_t esi;
    uint32_t txts;
    uint32_t dlc;
    uint32_t brs;
    uint32_t fdf;
    uint32_t et;
    uint32_t mm;
}MCAN_TxEventFIFOElement;

typedef struct
{
    uint32_t sfid2;
    uint32_t sfid1;
    uint32_t sfec;
    uint32_t sft;
}MCAN_StdMsgIDFilterElement;

typedef struct
{
    uint32_t efid1;
    uint32_t efec;
    uint32_t efid2;
    uint32_t eft;
}MCAN_ExtMsgIDFilterElement;

/* ========================================================================== */
/*                            Global Variables                                */
/* ========================================================================== */

/* None */

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

void MCAN_reset(uint32_t baseAddr);

uint32_t MCAN_isInReset(uint32_t baseAddr);

uint32_t MCAN_isFDOpEnable(uint32_t baseAddr);

uint32_t MCAN_isMemInitDone(uint32_t baseAddr);

void MCAN_setOpMode(uint32_t baseAddr, uint32_t mode);

uint32_t MCAN_getOpMode(uint32_t baseAddr);

int32_t MCAN_init(uint32_t baseAddr, const MCAN_InitParams *initParams);

int32_t MCAN_config(uint32_t baseAddr, const MCAN_ConfigParams *configParams);

void MCAN_eccConfig(uint32_t                    baseAddr,
                    const MCAN_ECCConfigParams *configParams);

int32_t MCAN_setBitTime(uint32_t                    baseAddr,
                        const MCAN_BitTimingParams *configParams);

int32_t MCAN_msgRAMConfig(uint32_t                       baseAddr,
                          const MCAN_MsgRAMConfigParams *msgRAMConfigParams);

int32_t MCAN_setExtIDAndMask(uint32_t baseAddr, uint32_t idMask);

void MCAN_writeMsgRam(uint32_t                 baseAddr,
                      uint32_t                 memType,
                      uint32_t                 bufNum,
                      const MCAN_TxBufElement *elem);

void MCAN_writeMsgRamNoCpy(uint32_t                 baseAddr,
                      uint32_t                 memType,
                      uint32_t                 bufNum,
                      const MCAN_TxBufElementNoCpy *elem);

int32_t MCAN_txBufAddReq(uint32_t baseAddr, uint32_t bufNum);

void  MCAN_getNewDataStatus(uint32_t              baseAddr,
                            MCAN_RxNewDataStatus *newDataStatus);

void  MCAN_clearNewDataStatus(uint32_t                    baseAddr,
                              const MCAN_RxNewDataStatus *newDataStatus);

void MCAN_readMsgRam(uint32_t           baseAddr,
                     uint32_t           memType,
                     uint32_t           bufNum,
                     uint32_t           fifoNum,
                     MCAN_RxBufElement *elem);

void MCAN_readMsgRamNoCpy(uint32_t           baseAddr,
                     uint32_t           memType,
                     uint32_t           bufNum,
                     uint32_t           fifoNum,
                     MCAN_RxBufElementNoCpy *elem);

void MCAN_readTxEventFIFO(uint32_t           baseAddr,
                          MCAN_TxEventFIFOElement *txEventElem);

void MCAN_addStdMsgIDFilter(uint32_t                          baseAddr,
                            uint32_t                          filtNum,
                            const MCAN_StdMsgIDFilterElement *elem);

void MCAN_addExtMsgIDFilter(uint32_t                          baseAddr,
                            uint32_t                          filtNum,
                            const MCAN_ExtMsgIDFilterElement *elem);

void MCAN_lpbkModeEnable(uint32_t baseAddr,
                         uint32_t lpbkMode,
                         uint32_t enable);

void  MCAN_getErrCounters(uint32_t           baseAddr,
                          MCAN_ErrCntStatus *errCounter);

void  MCAN_getProtocolStatus(uint32_t             baseAddr,
                             MCAN_ProtocolStatus *protStatus);

void MCAN_enableIntr(uint32_t baseAddr, uint32_t intrMask, uint32_t enable);

void MCAN_selectIntrLine(uint32_t baseAddr,
                         uint32_t intrMask,
                         uint32_t lineNum);

uint32_t MCAN_getIntrLineSelectStatus(uint32_t baseAddr);

void MCAN_enableIntrLine(uint32_t baseAddr,
                         uint32_t lineNum,
                         uint32_t enable);

uint32_t MCAN_getIntrStatus(uint32_t baseAddr);

void MCAN_clearIntrStatus(uint32_t baseAddr, uint32_t intrMask);

void  MCAN_getHighPriorityMsgStatus(uint32_t                  baseAddr,
                                    MCAN_HighPriorityMsgInfo *hpm);

void MCAN_getRxFIFOStatus(uint32_t           baseAddr,
                          MCAN_RxFIFOStatus *fifoStatus);

int32_t MCAN_writeRxFIFOAck(uint32_t baseAddr,
                            uint32_t fifoNum,
                            uint32_t idx);

void MCAN_getTxFIFOQueStatus(uint32_t           baseAddr,
                             MCAN_TxFIFOStatus *fifoStatus);

uint32_t MCAN_getTxBufReqPend(uint32_t baseAddr);

int32_t MCAN_txBufCancellationReq(uint32_t baseAddr, uint32_t buffNum);

uint32_t MCAN_getTxBufTransmissionStatus(uint32_t baseAddr);

uint32_t MCAN_txBufCancellationStatus(uint32_t baseAddr);

int32_t MCAN_txBufTransIntrEnable(uint32_t baseAddr,
                                  uint32_t bufNum,
                                  uint32_t enable);

int32_t MCAN_getTxBufCancellationIntrEnable(uint32_t baseAddr,
                                            uint32_t bufNum,
                                            uint32_t enable);

void MCAN_addClockStopRequest(uint32_t baseAddr, uint32_t enable);

void MCAN_getTxEventFIFOStatus(uint32_t                baseAddr,
                               MCAN_TxEventFIFOStatus *fifoStatus);

int32_t MCAN_writeTxEventFIFOAck(uint32_t baseAddr, uint32_t idx);

void MCAN_eccForceError(uint32_t                      baseAddr,
                        const MCAN_ECCErrForceParams *eccErr);

void MCAN_eccGetErrorStatus(uint32_t           baseAddr,
                            MCAN_ECCErrStatus *eccErr);

void MCAN_eccClearErrorStatus(uint32_t baseAddr, uint32_t errType);

void MCAN_eccWriteEOI(uint32_t baseAddr, uint32_t errType);

void MCAN_eccEnableIntr(uint32_t baseAddr, uint32_t errType, uint32_t enable);

uint32_t MCAN_eccGetIntrStatus(uint32_t baseAddr, uint32_t errType);

void MCAN_eccClearIntrStatus(uint32_t baseAddr, uint32_t errType);

void MCAN_extTSCounterConfig(uint32_t baseAddr,
                             uint32_t prescalar);

void MCAN_extTSCounterEnable(uint32_t baseAddr, uint32_t enable);

void MCAN_extTSEnableIntr(uint32_t baseAddr, uint32_t enable);

void MCAN_extTSWriteEOI(uint32_t baseAddr);

uint32_t MCAN_extTSGetUnservicedIntrCount(uint32_t baseAddr);

/* ========================================================================== */
/*                          Advance Functions                                 */
/* ========================================================================== */

void MCAN_getRevisionId(uint32_t baseAddr, MCAN_RevisionId *revId);

uint32_t MCAN_getClockStopAck(uint32_t baseAddr);

void MCAN_extTSSetRawStatus(uint32_t baseAddr);

void MCAN_extTSClearRawStatus(uint32_t baseAddr);

uint32_t MCAN_getRxPinState(uint32_t baseAddr);

void MCAN_setTxPinState(uint32_t baseAddr, uint32_t state);

uint32_t MCAN_getTxPinState(uint32_t baseAddr);

uint32_t MCAN_getTSCounterVal(uint32_t baseAddr);

uint32_t MCAN_getClkStopAck(uint32_t baseAddr);

void MCAN_getBitTime(uint32_t              baseAddr,
                     MCAN_BitTimingParams *configParams);

void MCAN_resetTSCounter(uint32_t baseAddr);

uint32_t MCAN_getTOCounterVal(uint32_t baseAddr);

void MCAN_eccAggrGetRevisionId(uint32_t                baseAddr,
                               MCAN_ECCAggrRevisionId *revId);

void MCAN_eccWrapGetRevisionId(uint32_t                baseAddr,
                               MCAN_ECCWrapRevisionId *revId);

uint32_t MCAN_extTSIsIntrEnable(uint32_t baseAddr);

uint32_t MCAN_getEndianVal(uint32_t baseAddr);

uint32_t MCAN_getExtIDANDMassk(uint32_t baseAddr);

#ifdef __cplusplus
}

#endif /*extern "C" */

#endif