mcan.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 MCAN_H_
#define MCAN_H_
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <drivers/hw_include/cslr.h>
#include <drivers/hw_include/cslr_mcan.h>
#include <drivers/hw_include/csl_types.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                             Macros & Typedefs                              */
/* ========================================================================== */
#define MCAN_STATUS_SUCCESS         ((int32_t)0)
 
#define MCAN_STATUS_FAILURE         ((int32_t)-1)
 
#define MCAN_TIMEOUT                ((int32_t)-2)
 
#define MCAN_INVALID_PARAM          ((int32_t)-3)
 
#define MCAN_STATUS_BUSY            ((int32_t)-4)
 
#define MCAN_INVALID_STATE          ((int32_t)-5)
 
#define MCAN_OUT_OF_RESOURCES  ((int32_t)-6) //TODO
 
#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_HEADER_SIZE_BYTES              (8U)
 
#define MCAN_MAX_PAYLOAD_BYTES              (64U)
 
#define MCAN_MSG_RAM_STD_ELEM_SIZE          (1U)
 
#define MCAN_MSG_RAM_EXT_ELEM_SIZE          (2U)
 
#define MCAN_MSG_RAM_TX_RX_ELEM_SIZE        (18U)
 
#define MCAN_RX_FIFO_OPERATION_MODE_BLOCKING               (0U)
 
#define MCAN_RX_FIFO_OPERATION_MODE_OVERWRITE              (1U)
 
#define MCAN_TX_MEM_TYPE_BUF                               (0U)
 
#define MCAN_TX_MEM_TYPE_QUEUE                             (1U)
 
#define MCAN_DATA_SIZE_0BYTES                  (0U)
 
#define MCAN_DATA_SIZE_1BYTES                  (1U)
 
#define MCAN_DATA_SIZE_2BYTES                  (2U)
 
#define MCAN_DATA_SIZE_3BYTES                  (3U)
 
#define MCAN_DATA_SIZE_4BYTES                  (4U)
 
#define MCAN_DATA_SIZE_5BYTES                  (5U)
 
#define MCAN_DATA_SIZE_6BYTES                  (6U)
 
#define MCAN_DATA_SIZE_7BYTES                  (7U)
 
#define MCAN_DATA_SIZE_8BYTES                  (8U)
 
#define MCAN_DATA_SIZE_12BYTES                 (9U)
 
#define MCAN_DATA_SIZE_16BYTES                 (10U)
 
#define MCAN_DATA_SIZE_20BYTES                 (11U)
 
#define MCAN_DATA_SIZE_24BYTES                 (12U)
 
#define MCAN_DATA_SIZE_32BYTES                 (13U)
 
#define MCAN_DATA_SIZE_48BYTES                 (14U)
 
#define MCAN_DATA_SIZE_64BYTES                 (15U)
 
#define MCAN_STD_FILT_ELEM_DISABLE                            (0U)
 
#define MCAN_STD_FILT_ELEM_FIFO0                              (1U)
 
#define MCAN_STD_FILT_ELEM_FIFO1                              (2U)
 
#define MCAN_STD_FILT_ELEM_REJECT                             (3U)
 
#define MCAN_STD_FILT_ELEM_SET_PRIORITY                       (4U)
 
#define MCAN_STD_FILT_ELEM_SET_PRIORITY_FIFO0                 (5U)
 
#define MCAN_STD_FILT_ELEM_SET_PRIORITY_FIFO1                 (6U)
 
#define MCAN_STD_FILT_ELEM_BUFFER                             (7U)
 
#define MCAN_STD_FILT_TYPE_RANGE                              (0U)
 
#define MCAN_STD_FILT_TYPE_DUAL                               (1U)
 
#define MCAN_STD_FILT_TYPE_CLASSIC                            (2U)
 
#define MCAN_STD_FILT_TYPE_DISABLE                            (3U)
 
#define MCAN_EXT_FILT_ELEM_DISABLE                            (0U)
 
#define MCAN_EXT_FILT_ELEM_FIFO0                              (1U)
 
#define MCAN_EXT_FILT_ELEM_FIFO1                              (2U)
 
#define MCAN_EXT_FILT_ELEM_REJECT                             (3U)
 
#define MCAN_EXT_FILT_ELEM_SET_PRIORITY                       (4U)
 
#define MCAN_EXT_FILT_ELEM_SET_PRIORITY_FIFO0                 (5U)
 
#define MCAN_EXT_FILT_ELEM_SET_PRIORITY_FIFO1                 (6U)
 
#define MCAN_EXT_FILT_ELEM_BUFFER                             (7U)
 
#define MCAN_EXT_FILT_TYPE_RANGE                              (0U)
 
#define MCAN_EXT_FILT_TYPE_DUAL                               (1U)
 
#define MCAN_EXT_FILT_TYPE_CLASSIC                            (2U)
 
#define MCAN_EXT_FILT_TYPE_DISABLE                            (3U)
 
#define MCAN_MAX_TX_MSG_OBJECTS             (32U)
 
#define MCAN_MAX_RX_MSG_OBJECTS             (32U)
 
#define MCAN_MAX_MSG_OBJECTS                (MCAN_MAX_TX_MSG_OBJECTS + MCAN_MAX_RX_MSG_OBJECTS)
 
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)
 
/* ========================================================================== */
/*                         Structures and Enums                               */
/* ========================================================================== */
 
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 lss;
    uint32_t lse;
    uint32_t txBufCnt;
    uint32_t txFIFOCnt;
    uint32_t txBufMode;
    uint32_t txEventFIFOCnt;
    uint32_t rxFIFO0Cnt;
    uint32_t rxFIFO0OpMode;
    uint32_t rxFIFO1Cnt;
    uint32_t rxFIFO1OpMode;
    uint32_t rxBufElemSize;
    uint32_t rxFIFO0ElemSize;
    uint32_t rxFIFO1ElemSize;
    uint32_t txEventFIFOWaterMark;
    uint32_t rxFIFO0WaterMark;
    uint32_t rxFIFO1WaterMark;
    uint32_t flssa;
    uint32_t flesa;
    uint32_t txStartAddr;
    uint32_t txBufElemSize;
    uint32_t txEventFIFOStartAddr;
    uint32_t rxFIFO0StartAddr;
    uint32_t rxFIFO1StartAddr;
    uint32_t rxBufStartAddr;
}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_writeDmaHeader( const void* data, const MCAN_TxBufElement *elem);
 
int32_t MCAN_msgRAMConfig(uint32_t                       baseAddr,
                          const MCAN_MsgRAMConfigParams *msgRAMConfigParams);
 
int32_t MCAN_setExtIDAndMask(uint32_t baseAddr, uint32_t idMask);
 
int32_t MCAN_getWriteMsgElemAddress(uint32_t                 baseAddr,
                                     uint32_t                 memType,
                                     uint32_t                 bufNum,
                                     uint32_t                 *elemAddr);
 
void MCAN_writeHeaderToMsgRam(uint32_t                 baseAddr,
                              uint32_t                 memType,
                              uint32_t                 bufNum,
                              const MCAN_TxBufElement *elem);
 
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);
 
int32_t MCAN_getReadMsgElemAddress(uint32_t    baseAddr,
                                   uint32_t    memType,
                                   uint32_t    bufNum,
                                   uint32_t    fifoNum,
                                   uint32_t    *elemAddr);
 
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_txBufCancellationIntrEnable(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);
 
/* ========================================================================== */
/*                       Advanced Function Declarations                       */
/* ========================================================================== */
void MCAN_initTxBufElement(MCAN_TxBufElement *txMsg);
 
void MCAN_initOperModeParams(MCAN_InitParams *initParams);
 
void MCAN_initGlobalFilterConfigParams(MCAN_ConfigParams *configParams);
 
void MCAN_initSetBitTimeParams(MCAN_BitTimingParams *bitTimes);
 
void MCAN_initMsgRamConfigParams(MCAN_MsgRAMConfigParams
                                 *msgRAMConfigParams);
 
int32_t MCAN_calcMsgRamParamsStartAddr(MCAN_MsgRAMConfigParams
                                       *msgRAMConfigParams);
 
#ifdef __cplusplus
}
 
#endif /*extern "C" */
 
#endif