canfd_lld.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 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_LLD_H_
#define CANFD_LLD_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ========================================================================== */
/*                             Include Files                                  */
/* ========================================================================== */
 
#include <stdint.h>
#include <stddef.h>
#include <drivers/mcan/v0/lld/mcan_lld.h>
#include <drivers/hw_include/cslr_soc.h>
 
/* ========================================================================== */
/*                             Macros & Typedefs                              */
/* ========================================================================== */
 
#define ATTRIBUTE_WEAK      __attribute__((weak))
 
#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)
 
#define MCAN_MSG_RAM_STD_ELEM_SIZE          (1U)
 
#define MCAN_MSG_RAM_EXT_ELEM_SIZE          (2U)
 
#define MCAN_MSG_HEADER_SIZE                (8U)
 
#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_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)
 
typedef enum CANFDLLD_MCANElemSize_t
{
    CANFDLLD_MCANElemSize_8BYTES = 0U,
 
    CANFDLLD_MCANElemSize_12BYTES = 1U,
 
    CANFDLLD_MCANElemSize_16BYTES = 2U,
 
    CANFDLLD_MCANElemSize_20BYTES = 3U,
 
    CANFDLLD_MCANElemSize_24BYTES = 4U,
 
    CANFDLLD_MCANElemSize_32BYTES = 5U,
 
    CANFDLLD_MCANElemSize_48BYTES = 6U,
 
    CANFDLLD_MCANElemSize_64BYTES = 7U
}CANFDLLD_MCANElemSize;
 
typedef enum CANFDLLD_DriverState_t
{
    CANFDLLD_DriverState_UNINIT,
 
    CANFDLLD_DriverState_STARTED,
 
    CANFDLLD_DriverState_STOPPED,
 
    CANFDLLD_DriverState_SLEEP
}CANFDLLD_DriverState;
 
typedef enum CANFDLLD_MCANOperationMode_t
{
    CANFDLLD_MCANOperationMode_NORMAL = 0U,
 
    CANFDLLD_MCANOperationMode_SW_INIT = 1U
}CANFDLLD_MCANOperationMode;
 
typedef enum CANFDLLD_Direction_t
{
    CANFDLLD_Direction_RX,
 
    CANFDLLD_Direction_TX
} CANFDLLD_Direction;
 
typedef enum CANFDLLD_MCANXidType_t
{
    CANFDLLD_MCANXidType_11_BIT,
 
    CANFDLLD_MCANXidType_29_BIT
} CANFDLLD_MCANXidType;
 
typedef enum CANFDLLD_MCANFrameType_t
{
    CANFDLLD_MCANFrameType_CLASSIC,
 
    CANFDLLD_MCANFrameType_FD
} CANFDLLD_MCANFrameType;
 
typedef enum CANFDLLD_MCANTimeOutSelect_t
{
    CANFDLLD_MCANTimeOutSelect_CONT = 0U,
 
    CANFDLLD_MCANTimeOutSelect_TX_EVENT_FIFO = 1U,
 
    CANFDLLD_MCANTimeOutSelect_RX_FIFO0 = 2U,
 
    CANFDLLD_MCANTimeOutSelect_RX_FIFO1 = 3U
}CANFDLLD_MCANTimeOutSelect;
 
typedef enum CANFDLLD_MCANECCErrType_t
{
    CANFDLLD_MCANECCErrType_SEC = 0U,
 
    CANFDLLD_MCANECCErrType_DED = 1U
}CANFDLLD_MCANECCErrType;
 
typedef enum CANFDLLD_MCANLoopBackMode_t
{
    CANFDLLD_MCANLoopBackMode_INTERNAL = 0U,
 
    CANFDLLD_MCANLoopBackMode_EXTERNAL = 1U
}CANFDLLD_MCANLoopBackMode;
 
typedef enum CANFDLLD_MCANCommState_t
{
    CANFDLLD_MCANCommState_SYNCHRONIZING = 0U,
 
    CANFDLLD_MCANCommState_IDLE = 1U,
 
    CANFDLLD_MCANCommState_RECEIVER = 2U,
 
    CANFDLLD_MCANCommState_TRANSMITTER = 3U
}CANFDLLD_MCANCommState;
 
typedef enum CANFDLLD_MCANErrCode_t
{
    CANFDLLD_MCANErrCode_NO_ERROR = 0U,
 
    CANFDLLD_MCANErrCode_STUFF_ERROR = 1U,
 
    CANFDLLD_MCANErrCode_FORM_ERROR = 2U,
 
    CANFDLLD_MCANErrCode_ACK_ERROR = 3U,
 
    CANFDLLD_MCANErrCode_BIT1_ERROR = 4U,
 
    CANFDLLD_MCANErrCode_BIT0_ERROR = 5U,
 
    CANFDLLD_MCANErrCode_CRC_ERROR = 6U,
 
    CANFDLLD_MCANErrCode_NO_CHANGE = 7U
}CANFDLLD_MCANErrCode;
 
typedef enum CANFDLLD_Reason_t
{
    CANFDLLD_Reason_RX                         = 0x1,
 
    CANFDLLD_Reason_TX_COMPLETION              = 0x2,
 
    CANFDLLD_Reason_TX_CANCELED                = 0x3,
 
    CANFDLLD_Reason_ECC_ERROR                  = 0x4,
 
    CANFDLLD_Reason_BUSOFF                     = 0x5,
 
    CANFDLLD_Reason_PROTOCOL_ERR_DATA_PHASE    = 0x6,
 
    CANFDLLD_Reason_PROTOCOL_ERR_ARB_PHASE     = 0x7
}CANFDLLD_Reason;
 
typedef enum CANFDLLD_Option_t
{
    CANFDLLD_Option_MCAN_ERROR_COUNTER,
 
    CANFDLLD_Option_MCAN_PROTOCOL_STATUS,
 
    CANFDLLD_Option_MCAN_MSG_OBJECT_STATS,
 
    CANFDLLD_Option_MCAN_MODE,
 
    CANFDLLD_Option_MCAN_LOOPBACK,
 
    CANFDLLD_Option_MCAN_POWER_DOWN
} CANFDLLD_Option;
 
typedef void *CANFDLLD_DmaHandle;
 
typedef void *CANFDLLD_DmaChConfig;
 
typedef struct CANFDLLD_MCANLoopbackCfgParams_t
{
    uint32_t                enable;
 
    CANFDLLD_MCANLoopBackMode  mode;
}CANFDLLD_MCANLoopbackCfgParams;
 
typedef struct CANFDLLD_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;
}CANFDLLD_MCANBitTimingParams;
 
typedef struct CANFDLLD_MCANTdcConfig_t
{
    uint32_t        tdcf;
 
    uint32_t        tdco;
}CANFDLLD_MCANTdcConfig;
 
typedef struct CANFDLLD_MCANGlobalFiltConfig_t
{
    uint32_t        rrfe;
 
    uint32_t        rrfs;
 
    uint32_t        anfe;
 
    uint32_t        anfs;
}CANFDLLD_MCANGlobalFiltConfig;
 
typedef struct CANFDLLD_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;
}CANFDLLD_MCANMsgRAMCfgParams;
 
typedef struct CANFDLLD_MCANECCConfigParams_t
{
    uint32_t            enable;
 
    uint32_t            enableChk;
 
    uint32_t            enableRdModWr;
}CANFDLLD_MCANECCConfigParams;
 
typedef struct CANFDLLD_MCANErrCntStatus_t
{
    uint32_t            transErrLogCnt;
 
    uint32_t            recErrCnt;
 
    uint32_t            rpStatus;
 
    uint32_t            canErrLogCnt;
}CANFDLLD_MCANErrCntStatus;
 
typedef struct CANFDLLD_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;
}CANFDLLD_MCANProtocolStatus;
 
typedef struct CANFDLLD_MCANECCErrForceParams_t
{
    uint32_t                errType;
 
    uint32_t                rowNum;
 
    uint32_t                bit1;
 
    uint32_t                bit2;
 
    uint32_t                errOnce;
 
    uint32_t                errForce;
}CANFDLLD_MCANECCErrForceParams;
 
typedef struct CANFDLLD_MCANECCErrStatus_t
{
    uint32_t                secErr;
 
    uint32_t                dedErr;
 
    uint32_t                row;
 
    uint32_t                bit1;
 
    uint32_t                bit2;
}CANFDLLD_MCANECCErrStatus;
 
typedef struct CANFDLLD_ErrStatusResp_t
{
    union
    {
        CANFDLLD_MCANECCErrStatus      eccErrStatus;
 
        CANFDLLD_MCANProtocolStatus    protocolStatus;
    }u;
} CANFDLLD_ErrStatusResp;
 
typedef struct CANFDLLD_MCANInitParams_t
{
    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;
 
    CANFDLLD_MCANTdcConfig         tdcConfig;
 
    uint32_t                    monEnable;
 
    uint32_t                    asmEnable;
 
    uint32_t                    tsPrescalar;
 
    uint32_t                    tsSelect;
 
    CANFDLLD_MCANTimeOutSelect     timeoutSelect;
 
    uint32_t                    timeoutPreload;
 
    uint32_t                    timeoutCntEnable;
 
    CANFDLLD_MCANGlobalFiltConfig  filterConfig;
 
    CANFDLLD_MCANMsgRAMCfgParams   msgRAMConfig;
 
    CANFDLLD_MCANECCConfigParams   eccConfig;
 
    uint32_t                    errInterruptEnable;
 
    uint32_t                    dataInterruptEnable;
}CANFDLLD_MCANInitParams;
 
typedef struct CANFDLLD_OptionTLV_t
{
    CANFDLLD_Option            type;
 
    int32_t                 length;
 
    void*                   value;
}CANFDLLD_OptionTLV;
 
typedef struct CANFDLLD_Object_t
{
    uint32_t                regBaseAddress;
 
    CANFDLLD_DriverState               state;
 
    CANFDLLD_MCANInitParams            initParams;
 
    uint8_t                         mcanDataSize[16];
 
    struct CANFDLLD_MessageObject_t*  msgObjectHandle[MCAN_MAX_MSG_OBJECTS];
 
    struct CANFDLLD_MessageObject_t*   txMapping[MCAN_MAX_TX_MSG_OBJECTS];
 
    struct CANFDLLD_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;
 
    CANFDLLD_DmaHandle             canfdDmaHandle;
 
    CANFDLLD_DmaChConfig           canfdDmaChCfg;
 
    void*                          args;
}CANFDLLD_Object;
 
typedef struct CANFDLLD_DmaMsgConfig_s
{
    uint32_t        dataLengthPerMsg;
    uint32_t        numMsgs;
    const void      *data;
    uint32_t        currentMsgNum;
}CANFDLLD_DmaMsgConfig;
 
typedef struct CANFDLLD_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[64];
}CANFDLLD_DmaRxBuf;
 
typedef struct CANFDLLD_MessageObject_t
{
    uint32_t                startMsgId;
 
    uint32_t                endMsgId;
 
    CANFDLLD_Object*           ptrCanFdObj;
 
    CANFDLLD_Direction         direction;
 
    CANFDLLD_MCANXidType       msgIdType;
 
    uint32_t                messageObjNum;
 
    uint32_t                txElement;
 
    uint32_t                rxElement;
 
    MCAN_MemType            memType;
 
    uint32_t                interruptsRxed;
 
    uint32_t                messageProcessed;
 
    uint32_t                enableDmaMode;
 
    uint32_t                dmaEventNo;
 
    CANFDLLD_DmaMsgConfig   dmaMsgConfig;
 
}CANFDLLD_MessageObject;
 
typedef CANFDLLD_Object* CANFDLLD_Handle;
 
typedef CANFDLLD_MessageObject* CANFDLLD_MsgObjHandle;
 
typedef struct CANFDLLD_MCANMsgObjectStats_t
{
    CANFDLLD_MsgObjHandle      handle;
 
    uint32_t                direction;
 
    uint32_t                startMsgIdentifier;
 
    uint32_t                endMsgIdentifier;
 
    uint32_t                interruptsRxed;
 
    uint32_t                messageProcessed;
} CANFDLLD_MCANMsgObjectStats;
 
int32_t CANFD_lld_init(CANFDLLD_Handle hCanfd);
 
int32_t CANFD_lld_deInit(CANFDLLD_Handle handle);
 
int32_t CANFD_lld_configBitTime(CANFDLLD_Handle handle, const CANFDLLD_MCANBitTimingParams* bitTimeParams);
 
int32_t CANFD_lld_createMsgObject(CANFDLLD_Handle handle, CANFDLLD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_lld_createRxRangeMsgObject(CANFDLLD_Handle handle, CANFDLLD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_lld_deleteMsgObject(CANFDLLD_MsgObjHandle handle);
 
int32_t CANFD_lld_write(CANFDLLD_MsgObjHandle handle, uint32_t id, CANFDLLD_MCANFrameType frameType, uint32_t dataLength, const uint8_t* data);
 
int32_t CANFD_lld_writeCancel(CANFDLLD_MsgObjHandle handle);
 
int32_t CANFD_lld_writeDma(CANFDLLD_MsgObjHandle handle, uint32_t id, CANFDLLD_MCANFrameType frameType, uint32_t dataLengthPerMsg, uint32_t numMsgs, void* data);
 
int32_t CANFD_lld_writeDmaTriggerNext(CANFDLLD_MsgObjHandle handle);
 
uint32_t CANFD_lld_getFilterEventConfig(uint32_t eventNum);
 
int32_t CANFD_lld_read(CANFDLLD_MsgObjHandle handle, uint32_t* id, CANFDLLD_MCANFrameType* ptrFrameType, CANFDLLD_MCANXidType* idType, uint32_t* ptrDataLength, uint8_t* data);
 
int32_t CANFD_lld_readDmaConfig(CANFDLLD_MsgObjHandle handle, void* data, uint32_t numDmaRxBuf);
 
int32_t CANFD_lld_getOptions(CANFDLLD_Handle handle, CANFDLLD_OptionTLV* ptrOptInfo);
 
int32_t CANFD_lld_setOptions(CANFDLLD_Handle handle, const CANFDLLD_OptionTLV* ptrOptInfo);
 
void CANFD_lld_int0Isr (CANFDLLD_Object* ptrCanFdObj);
 
void CANFD_lld_int1Isr (CANFDLLD_Object* ptrCanFdObj);
 
ATTRIBUTE_WEAK void CANFD_lld_dataAppCallBack(CANFDLLD_MsgObjHandle handle, CANFDLLD_Reason reason);
 
ATTRIBUTE_WEAK void CANFD_lld_errStatusAppCallBack(CANFDLLD_Handle handle, CANFDLLD_Reason reason, CANFDLLD_ErrStatusResp* errStatusResp);
 
int32_t CANFD_lld_dmaOpen(CANFDLLD_Handle canfdHandle, CANFDLLD_DmaChConfig dmaChCfg);
 
int32_t CANFD_lld_dmaClose(CANFDLLD_Handle canfdHandle);
 
int32_t CANFD_lld_createDmaTxMsgObject(CANFDLLD_Object *ptrCanFdObj, CANFDLLD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_lld_deleteDmaTxMsgObject(CANFDLLD_Object *ptrCanFdObj, CANFDLLD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_lld_configureDmaTx(CANFDLLD_Object *ptrCanFdObj, CANFDLLD_MessageObject* ptrCanMsgObj, uint32_t dataLengthPerMsg, uint32_t numMsgs, const void* data);
 
int32_t CANFD_lld_cancelDmaTx(CANFDLLD_Object *ptrCanFdObj, CANFDLLD_MessageObject* ptrCanMsgObj);
 
ATTRIBUTE_WEAK void CANFD_dmaTxCompletionCallback(CANFDLLD_MessageObject* ptrCanMsgObj, void *data, uint32_t completionType);
 
int32_t CANFD_lld_createDmaRxMsgObject(CANFDLLD_Object *ptrCanFdObj, CANFDLLD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_lld_deleteDmaRxMsgObject(CANFDLLD_Object *ptrCanFdObj, CANFDLLD_MessageObject* ptrCanMsgObj);
 
int32_t CANFD_lld_configureDmaRx(CANFDLLD_Object *ptrCanFdObj, CANFDLLD_MessageObject* ptrCanMsgObj, uint32_t dataLengthPerMsg, uint32_t numMsgs, const void* data);
 
ATTRIBUTE_WEAK void CANFD_dmaRxCompletionCallback(CANFDLLD_MessageObject* ptrCanMsgObj, void *data, uint32_t completionType);
 
#ifdef __cplusplus
}
#endif
 
#endif /* #ifndef CANFD_LLD_H_ */