can.h

Go to the documentation of this file.

/******************************************************************************
 *  Filename:       can.h
 *
 *  Description:    Defines and prototypes for the CAN peripheral.
 *
 *  Copyright (c) 2023-2025 Texas Instruments Incorporated
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1) Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *  2) 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.
 *
 *  3) Neither the name of the copyright holder 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 HOLDER 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 __CAN_H__
#define __CAN_H__

//*****************************************************************************
//
//
//*****************************************************************************

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#include "../inc/hw_types.h"
#include "../inc/hw_memmap.h"
#include "../inc/hw_canfd.h"

//*****************************************************************************
//
// Flags that can be passed to CANSSSetControl and CANSSClearControl.
//
//*****************************************************************************
#define CANSS_CTRL_EXT_TIMESTAMP_EN (CANFD_MCANSS_CTRL_EXT_TS_CNTR_EN_M) 
#define CANSS_CTRL_AUTOWAKEUP_EN    (CANFD_MCANSS_CTRL_AUTOWAKEUP_M)     
#define CANSS_CTRL_WAKEUP_REQ_EN    (CANFD_MCANSS_CTRL_WAKEUPREQEN_M)    
#define CANSS_CTRL_DEBUG_SUSPEND_EN (CANFD_MCANSS_CTRL_DBGSUSP_FREE_M)   

//*****************************************************************************
//
// Flags that can be returned by CANSSGetStatus.
//
//*****************************************************************************
#define CANSS_STATUS_ENABLE_FDOE   (CANFD_MCANSS_STAT_ENABLE_FDOE_M)   
#define CANSS_STATUS_MEM_INIT_DONE (CANFD_MCANSS_STAT_MEM_INIT_DONE_M) 

//*****************************************************************************
//
// Flags that can be passed to CANSSClearInt, CANSSEnableInt, and
// CANSSDisableInt or returned by CANSSGetIntStatus.
//
//*****************************************************************************
#define CANSS_INT_EXT_TIMESTAMP_OVERFLOW \
    (CANFD_MCANSS_IRS_EXT_TS_CNTR_OVFL_M) 

//*****************************************************************************
//
// Flags that can be passed to CANSSSetEndOfInterrupt.
//
//*****************************************************************************
#define CANSS_EOI_EXT_TIMESTAMP 0U 
#define CANSS_EOI_MCAN0         1U 
#define CANSS_EOI_MCAN1         2U 

//*****************************************************************************
//
// Interrupt line numbers that can be passed to CANSetIntMask, CANClearIntMask,
// CANGetIntStatus, and CANClearInt.
//
//*****************************************************************************
#define CAN_INT_LINE0 0U 
#define CAN_INT_LINE1 1U 

//*****************************************************************************
//
// Flags that can be passed to CANSetIntMask, CANClearIntMask, and CANClearInt
// or returned by CANGetIntStatus.
//
//*****************************************************************************
#define CAN_INT_DMA_DONE1      (CANFD_IMASK0_DMA_DONE1_M)      
#define CAN_INT_DMA_DONE0      (CANFD_IMASK0_DMA_DONE0_M)      
#define CAN_INT_FILTER_EVENT2  (CANFD_IMASK0_FE2_M)            
#define CAN_INT_EXT_TS_OR_WAKE (CANFD_IMASK0_EXT_TS_OR_WAKE_M) 
#define CAN_INT_DED            (CANFD_IMASK0_DED_M)            
#define CAN_INT_SEC            (CANFD_IMASK0_SEC_M)            
#define CAN_INT_INTL1          (CANFD_IMASK0_INTL1_M)          
#define CAN_INT_INTL0          (CANFD_IMASK0_INTL0_M)          
#define CAN_INT_MASK           (0x0000000FU)                   

//*****************************************************************************
//
// Clock divider ratios that can be passed to CANSSSetClockDivider.
//
//*****************************************************************************
#define CANSS_CLK_DIVIDE_BY_1 0U 
#define CANSS_CLK_DIVIDE_BY_2 1U 
#define CANSS_CLK_DIVIDE_BY_4 2U 

//*****************************************************************************
//
// Flags that can be passed to CANSSSetClkStopCtrl and CANSSClearClkStopCtrl.
//
//*****************************************************************************
#define CANSS_CLKCTRL_WAKEUP_GLITCH_FILTER_EN (CANFD_MCANSS_CLKCTL_WKUP_GLTFLT_EN_M) 
#define CANSS_CLKCTRL_WAKEUP_INT_EN           (CANFD_MCANSS_CLKCTL_WAKEUP_INT_EN_M)  
#define CANSS_CLKCTRL_STOP_REQ                (CANFD_MCANSS_CLKCTL_STOPREQ_M)        

//*****************************************************************************
//
// Flags that can be returned by CANSSGetClkStopCtrlStatus.
//
//*****************************************************************************
#define CANSS_CLKSTAT_CLKSTOP_REQ_OVR \
    (CANFD_MCANSS_CLKSTS_STOPREQ_HW_OVR_M) 
#define CANSS_CLKSTAT_CLKSTOP_ACK (CANFD_MCANSS_CLKSTS_CLKSTOP_ACKSTS_M) 

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSSSetControl(uint32_t flags)
{
    HWREG(CANFD_BASE + CANFD_O_MCANSS_CTRL) |= flags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSSClearControl(uint32_t flags)
{
    HWREG(CANFD_BASE + CANFD_O_MCANSS_CTRL) &= (uint32_t)~flags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t CANSSGetStatus(void)
{
    return (HWREG(CANFD_BASE + CANFD_O_MCANSS_STAT));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t CANSSGetMaskedIntStatus(void)
{
    return (HWREG(CANFD_BASE + CANFD_O_MCANSS_IES));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t CANSSGetRawIntStatus(void)
{
    return (HWREG(CANFD_BASE + CANFD_O_MCANSS_IRS));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSSClearInt(uint32_t flags)
{
    HWREG(CANFD_BASE + CANFD_O_MCANSS_ICS) = flags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSSEnableInt(uint32_t flags)
{
    HWREG(CANFD_BASE + CANFD_O_MCANSS_IE) = flags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSSDisableInt(uint32_t flags)
{
    HWREG(CANFD_BASE + CANFD_O_MCANSS_IECS) = flags;
}

//*****************************************************************************
//
//
//*****************************************************************************
void CANSSSetEndOfInt(uint32_t eoi) __attribute__((weak));

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSSSetExtTimestampPrescaler(uint32_t prescaler)
{
    HWREG(CANFD_BASE + CANFD_O_MCANSS_EXT_TS_PRESCALER) = prescaler;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t CANSSGetExtTSUnservicedIntCounter(void)
{
    return (HWREG(CANFD_BASE + CANFD_O_MCANSS_EXT_TS_UNSERVICED_INTR_CNTR));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSetIntMask(uint32_t lineNum, uint32_t flags)
{
    uint32_t offset = (lineNum == CAN_INT_LINE0) ? CANFD_O_IMASK0 : CANFD_O_IMASK1;

    HWREG(CANFD_BASE + offset) |= flags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANClearIntMask(uint8_t lineNum, uint32_t flags)
{
    uint32_t offset = (lineNum == CAN_INT_LINE0) ? CANFD_O_IMASK0 : CANFD_O_IMASK1;

    HWREG(CANFD_BASE + offset) &= (uint32_t)~flags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t CANGetMaskedIntStatus(uint8_t lineNum)
{
    uint32_t offset = (lineNum == CAN_INT_LINE0) ? CANFD_O_MIS0 : CANFD_O_MIS1;
    return (HWREG(CANFD_BASE + offset));
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t CANGetRawIntStatus(uint8_t lineNum)
{
    uint32_t offset = (lineNum == CAN_INT_LINE0) ? CANFD_O_RIS0 : CANFD_O_RIS1;
    return (HWREG(CANFD_BASE + offset));
}

//*****************************************************************************
//
//
//*****************************************************************************
void CANClearInt(uint8_t lineNum, uint32_t flags) __attribute__((weak));

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void CANSSSetClockDivider(uint32_t ratio)
{
    HWREG(CANFD_BASE + CANFD_O_MCANSS_CLKDIV) = ratio;
}

//*****************************************************************************
//
//
//*****************************************************************************
void CANSSSetClkStopCtrl(uint32_t flags) __attribute__((weak));

//*****************************************************************************
//
//
//*****************************************************************************
void CANSSClearClkStopCtrl(uint32_t flags) __attribute__((weak));

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t CANSSGetClkStopCtrlStatus(void)
{
    return HWREG(CANFD_BASE + CANFD_O_MCANSS_CLKSTS);
}

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

//*****************************************************************************
//
//
//*****************************************************************************

#endif // __CAN_H__