hpm_can_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021-2024 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef HPM_CAN_DRV_H
#define HPM_CAN_DRV_H
 
#include "hpm_common.h"
#include "hpm_can_regs.h"
#include "hpm_soc_feature.h"
 
/***********************************************************************************************************************
 *
 * Definitions
 *
 **********************************************************************************************************************/
 
enum {
    status_can_bit_error = MAKE_STATUS(status_group_can, 0),            
    status_can_form_error = MAKE_STATUS(status_group_can, 1),           
    status_can_stuff_error = MAKE_STATUS(status_group_can, 2),          
    status_can_ack_error = MAKE_STATUS(status_group_can, 3),            
    status_can_crc_error = MAKE_STATUS(status_group_can, 4),            
    status_can_other_error = MAKE_STATUS(status_group_can, 5),          
    status_can_tx_fifo_full = MAKE_STATUS(status_group_can, 6),         
    status_can_filter_index_invalid = MAKE_STATUS(status_group_can, 7), 
    status_can_filter_num_invalid = MAKE_STATUS(status_group_can, 8),   
};
 
#define CAN_EVENT_RECEIVE (CAN_RTIF_RIF_MASK)               
#define CAN_EVENT_RX_BUF_OVERRUN (CAN_RTIF_ROIF_MASK)       
#define CAN_EVENT_RX_BUF_FULL (CAN_RTIF_RFIF_MASK)          
#define CAN_EVENT_RX_BUF_ALMOST_FULL (CAN_RTIF_RAFIF_MASK)  
#define CAN_EVENT_TX_PRIMARY_BUF (CAN_RTIF_TPIF_MASK)       
#define CAN_EVENT_TX_SECONDARY_BUF (CAN_RTIF_TSIF_MASK)     
#define CAN_EVENT_ERROR (CAN_RTIF_EIF_MASK)                 
#define CAN_EVENT_ABORT (CAN_RTIF_AIF_MASK)                 
#define CAN_STB_IS_EMPTY (0U)                               
#define CAN_STB_LESS_EQUAL_HALF_FULL (1U)                   
#define CAN_STB_MORE_THAN_HALF_FULL (2U)                    
#define CAN_STB_IS_FULL (3U)                                
#define CAN_RXBUF_IS_EMPTY (0U)                             
#define CAN_RXBUF_HAS_DATA (1U)                             
#define CAN_RXBUF_ALMOST_FULL (2U)                          
#define CAN_RXBUF_IS_FULL (3U)                              
#define CAN_ERROR_WARNING_LIMIT_FLAG            (CAN_ERRINT_EWARN_MASK)     
#define CAN_ERROR_PASSIVE_MODE_ACTIVE_FLAG      (CAN_ERRINT_EPASS_MASK)     
#define CAN_ERROR_PASSIVE_INT_ENABLE            (CAN_ERRINT_EPIE_MASK)      
#define CAN_ERROR_PASSIVE_INT_FLAG              (CAN_ERRINT_EPIF_MASK)      
#define CAN_ERROR_ARBITRAITION_LOST_INT_ENABLE  (CAN_ERRINT_ALIE_MASK)      
#define CAN_ERROR_ARBITRAITION_LOST_INT_FLAG    (CAN_ERRINT_ALIE_MASK)      
#define CAN_ERROR_BUS_ERROR_INT_ENABLE          (CAN_ERRINT_BEIE_MASK)      
#define CAN_ERROR_BUS_ERROR_INT_FLAG            (CAN_ERRINT_BEIF_MASK)      
#define CAN_KIND_OF_ERROR_NO_ERROR      (0U)        
#define CAN_KIND_OF_ERROR_BIT_ERROR     (1U)        
#define CAN_KIND_OF_ERROR_FORM_ERROR    (2U)        
#define CAN_KIND_OF_ERROR_STUFF_ERROR   (3U)        
#define CAN_KIND_OF_ERROR_ACK_ERROR     (4U)        
#define CAN_KIND_OF_ERROR_CRC_ERROR     (5U)        
#define CAN_KIND_OF_ERROR_OTHER_ERROR   (6U)        
#define CAN_KIND_OF_ERROR_BUS_OFF       (7U)        
typedef enum _can_mode {
    can_mode_normal,              
    can_mode_loopback_internal,   
    can_mode_loopback_external,   
    can_mode_listen_only,         
} can_node_mode_t;
 
typedef enum _can_bit_timing_option {
    can_bit_timing_can2_0,          
    can_bit_timing_canfd_norminal,  
    can_bit_timing_canfd_data,      
} can_bit_timing_option_t;
 
enum {
    can_payload_size_0 = 0,                 
    can_payload_size_1,                     
    can_payload_size_2,                     
    can_payload_size_3,                     
    can_payload_size_4,                     
    can_payload_size_5,                     
    can_payload_size_6,                     
    can_payload_size_7,                     
    can_payload_size_8,                     
    can_payload_size_12,                    
    can_payload_size_16,                    
    can_payload_size_20,                    
    can_payload_size_24,                    
    can_payload_size_32,                    
    can_payload_size_48,                    
    can_payload_size_64,                    
    can_payload_size_max = can_payload_size_64,
};
 
typedef struct {
    uint16_t prescaler;     
    uint16_t num_seg1;      
    uint16_t num_seg2;      
    uint16_t num_sjw;       
} can_bit_timing_param_t;
 
typedef union _can_rx_buf {
    uint32_t buffer[20];                        
    struct {
        struct {
            uint32_t id: 29;                    
            uint32_t : 1;
            uint32_t error_state_indicator: 1;  
        };
        struct {
            uint32_t dlc: 4;                   
            uint32_t bitrate_switch: 1;        
            uint32_t canfd_frame: 1;           
            uint32_t remote_frame: 1;          
            uint32_t extend_id: 1;             
            uint32_t : 4;
            uint32_t loopback_message: 1;      
            uint32_t error_type: 3;            
            uint32_t cycle_time: 16;           
        };
        uint8_t data[];                        
    };
} can_receive_buf_t;
 
typedef union _can_tx_buf {
    uint32_t buffer[18];                            
    struct {
        struct {
            uint32_t id: 29;                       
            uint32_t : 2;
            uint32_t transmit_timestamp_enable: 1;  
        };
        struct {
            uint32_t dlc: 4;                        
            uint32_t bitrate_switch: 1;             
            uint32_t canfd_frame: 1;                
            uint32_t remote_frame: 1;               
            uint32_t extend_id: 1;                  
            uint32_t : 24;
        };
        uint8_t data[];                             
    };
} can_transmit_buf_t;
 
typedef enum _can_filter_id_mode {
    can_filter_id_mode_both_frames,                
    can_filter_id_mode_standard_frames,            
    can_filter_id_mode_extended_frames,            
} can_filter_id_mode_t;
 
typedef struct {
    uint16_t index;                            
    can_filter_id_mode_t id_mode;              
    bool enable;                               
    uint32_t code;                             
    uint32_t mask;                             
} can_filter_config_t;
 
typedef struct {
    union {
        struct {
            uint32_t baudrate;                  
            uint32_t baudrate_fd;               
            uint16_t can20_samplepoint_min;
            uint16_t can20_samplepoint_max;
            uint16_t canfd_samplepoint_min;
            uint16_t canfd_samplepoint_max;
        };
        struct {
            can_bit_timing_param_t can_timing;  
            can_bit_timing_param_t canfd_timing;
        };
    };
 
    can_node_mode_t mode;                       
    bool use_lowlevel_timing_setting;           
    bool enable_canfd;                          
    bool enable_self_ack;                       
    bool disable_ptb_retransmission;            
    bool disable_stb_retransmission;            
    bool enable_tdc;                            
    uint8_t filter_list_num;                    
    can_filter_config_t *filter_list;           
    uint8_t irq_txrx_enable_mask;               
    uint8_t irq_error_enable_mask;              
    bool enable_tx_buffer_priority_mode;        
    bool enable_can_fd_iso_mode;                
} can_config_t;
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
static inline void can_reset(CAN_Type *base, bool enable)
{
    if (enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_RESET_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_RESET_MASK;
    }
}
 
static inline void can_set_node_mode(CAN_Type *base, can_node_mode_t mode)
{
    uint32_t cfg_stat = base->CMD_STA_CMD_CTRL & ~(CAN_CMD_STA_CMD_CTRL_LBME_MASK | CAN_CMD_STA_CMD_CTRL_LBMI_MASK | CAN_CMD_STA_CMD_CTRL_LOM_MASK);
    if (mode == can_mode_loopback_internal) {
        cfg_stat |= CAN_CMD_STA_CMD_CTRL_LBMI_MASK;
    } else if (mode == can_mode_loopback_external) {
        cfg_stat |= CAN_CMD_STA_CMD_CTRL_LBME_MASK;
    } else if (mode == can_mode_listen_only) {
        cfg_stat |= CAN_CMD_STA_CMD_CTRL_LOM_MASK;
    } else {
        /* CAN normal work mode, no change needed here */
    }
    base->CMD_STA_CMD_CTRL = cfg_stat;
}
 
static inline void can_enable_listen_only_mode(CAN_Type *base, bool enable)
{
    if (enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_LOM_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_LOM_MASK;
    }
}
 
static inline void can_enter_standby_mode(CAN_Type *base, bool enable)
{
    if (enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_STBY_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_STBY_MASK;
    }
}
 
static inline void can_disable_ptb_retransmission(CAN_Type *base, bool enable)
{
    if (enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TPSS_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_TPSS_MASK;
    }
}
 
static inline bool can_is_ptb_retransmission_disabled(CAN_Type *base)
{
    return ((base->CMD_STA_CMD_CTRL & CAN_CMD_STA_CMD_CTRL_TPSS_MASK) != 0);
}
 
static inline void can_disable_stb_retransmission(CAN_Type *base, bool enable)
{
    if (enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TSSS_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_TSSS_MASK;
    }
}
 
static inline bool can_is_stb_retransmission_disabled(CAN_Type *base)
{
    return ((base->CMD_STA_CMD_CTRL & CAN_CMD_STA_CMD_CTRL_TSSS_MASK) != 0);
}
 
 
static inline void can_select_tx_buffer(CAN_Type *base, bool select_secondary_buffer)
{
    if (select_secondary_buffer) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TBSEL_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_TBSEL_MASK;
    }
}
 
static inline void can_start_high_priority_message_transmit(CAN_Type *base)
{
    base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TPE_MASK;
}
 
static inline void can_abort_high_priority_message_transmit(CAN_Type *base)
{
    base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TPA_MASK;
}
 
static inline void can_start_message_transmit(CAN_Type *base)
{
    base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TSONE_MASK;
}
 
static inline void can_start_all_message_transmit(CAN_Type *base)
{
    base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TSALL_MASK;
}
 
static inline void can_abort_message_transmit(CAN_Type *base)
{
    base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TSA_MASK;
}
 
static inline void can_switch_to_next_tx_buffer(CAN_Type *base)
{
    base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TSNEXT_MASK;
}
 
static inline void can_select_tx_buffer_priority_mode(CAN_Type *base, bool enable_priority_decision)
{
    if (enable_priority_decision) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_TSMODE_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_TSMODE_MASK;
    }
}
 
static inline uint8_t can_get_secondary_transmit_buffer_status(CAN_Type *base)
{
    return CAN_CMD_STA_CMD_CTRL_TSSTAT_GET(base->CMD_STA_CMD_CTRL);
}
 
static inline bool can_is_primary_transmit_buffer_full(CAN_Type *base)
{
    return ((base->CMD_STA_CMD_CTRL & CAN_CMD_STA_CMD_CTRL_TPE_MASK) != 0U);
}
 
static inline bool can_is_secondary_transmit_buffer_full(CAN_Type *base)
{
    return (CAN_CMD_STA_CMD_CTRL_TSSTAT_GET(base->CMD_STA_CMD_CTRL) == CAN_STB_IS_FULL);
}
 
static inline bool can_is_in_bus_off_mode(CAN_Type *base)
{
    return ((base->CMD_STA_CMD_CTRL & CAN_CMD_STA_CMD_CTRL_BUSOFF_MASK) != 0U);
}
 
static inline void can_enable_self_ack(CAN_Type *base, bool enable)
{
    if (enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_SACK_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_SACK_MASK;
    }
}
 
static inline void can_set_receive_buffer_overflow_mode(CAN_Type *base, bool override_enable)
{
    if (override_enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_ROM_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_ROM_MASK;
    }
}
 
static inline bool can_is_receive_buffer_overflow(CAN_Type *base)
{
    return IS_HPM_BITMASK_SET(base->CMD_STA_CMD_CTRL, CAN_CMD_STA_CMD_CTRL_ROV_MASK);
}
 
static inline void can_release_receive_buffer(CAN_Type *base)
{
    base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_RREL_MASK;
}
 
static inline void can_allow_store_all_data_in_receive_buffer(CAN_Type *base, bool allow)
{
    if (allow) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_RBALL_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_RBALL_MASK;
    }
}
 
static inline uint8_t can_get_receive_buffer_status(CAN_Type *base)
{
    return CAN_CMD_STA_CMD_CTRL_RSTAT_GET(base->CMD_STA_CMD_CTRL);
}
 
static inline bool can_is_data_available_in_receive_buffer(CAN_Type *base)
{
    return (CAN_CMD_STA_CMD_CTRL_RSTAT_GET(base->CMD_STA_CMD_CTRL) != CAN_RXBUF_IS_EMPTY);
}
 
 
static inline void can_enable_can_fd_iso_mode(CAN_Type *base, bool enable)
{
    if (enable) {
        base->CMD_STA_CMD_CTRL |= CAN_CMD_STA_CMD_CTRL_FD_ISO_MASK;
    } else {
        base->CMD_STA_CMD_CTRL &= ~CAN_CMD_STA_CMD_CTRL_FD_ISO_MASK;
    }
}
 
static inline void can_enable_tx_rx_irq(CAN_Type *base, uint8_t mask)
{
    base->RTIE |= mask;
}
 
static inline void can_disable_tx_rx_irq(CAN_Type *base, uint8_t mask)
{
    base->RTIE &= ~mask;
}
 
static inline void can_clear_tx_rx_flags(CAN_Type *base, uint8_t flags)
{
    base->RTIF = flags;
}
 
static inline uint8_t can_get_tx_rx_flags(CAN_Type *base)
{
    return base->RTIF;
}
 
static inline void can_enable_error_irq(CAN_Type *base, uint8_t mask)
{
    base->ERRINT |= mask;
}
 
static inline void can_disable_error_irq(CAN_Type *base, uint8_t mask)
{
    base->ERRINT &= ~mask;
}
 
static inline uint8_t can_get_error_interrupt_flags(CAN_Type *base)
{
    return (base->ERRINT & (uint8_t) ~(CAN_ERRINT_EPIE_MASK | CAN_ERRINT_ALIE_MASK | CAN_ERRINT_BEIE_MASK));
}
 
static inline void can_clear_error_interrupt_flags(CAN_Type *base, uint8_t flags)
{
    flags &= (uint8_t)~(CAN_ERRINT_EPIE_MASK | CAN_ERRINT_ALIE_MASK | CAN_ERRINT_BEIE_MASK);
    base->ERRINT |= flags;
}
 
static inline uint8_t can_get_last_error_kind(CAN_Type *base)
{
    return CAN_EALCAP_KOER_GET(base->EALCAP);
}
 
static inline uint8_t can_get_last_arbitration_lost_position(CAN_Type *base)
{
    return CAN_EALCAP_ALC_GET(base->EALCAP);
}
 
static inline void can_set_transmitter_delay_compensation(CAN_Type *base, uint8_t sample_point, bool enable)
{
#if defined(CAN_SOC_CANFD_TDC_REQUIRE_STUFF_EXCEPTION_WORKAROUND) && (CAN_SOC_CANFD_TDC_REQUIRE_STUFF_EXCEPTION_WORKAROUND == 1)
    (void) sample_point;
    (void) enable;
    base->TDC = CAN_TDC_TDCEN_SET((uint8_t) enable);
#else
    base->TDC = CAN_TDC_SSPOFF_SET(sample_point) | CAN_TDC_TDCEN_SET((uint8_t) enable);
#endif
}
 
static inline void can_set_warning_limits(CAN_Type *base, uint8_t almost_full_limit, uint8_t error_warning_limit)
{
    base->LIMIT = CAN_LIMIT_AFWL_SET(almost_full_limit) | CAN_LIMIT_EWL_SET(error_warning_limit);
}
 
static inline uint8_t can_get_receive_error_count(CAN_Type *base)
{
    return base->RECNT;
}
 
static inline uint8_t can_get_transmit_error_count(CAN_Type *base)
{
    return base->TECNT;
}
 
static inline void can_enable_filter(CAN_Type *base, uint32_t index)
{
    base->ACF_EN |= (uint16_t) (1U << index);
}
 
static inline void can_disable_filter(CAN_Type *base, uint32_t index)
{
    base->ACF_EN &= (uint16_t) ~(1U << index);
}
 
hpm_stat_t can_get_default_config(can_config_t *config);
 
hpm_stat_t can_init(CAN_Type *base, can_config_t *config, uint32_t src_clk_freq);
 
 
void can_deinit(CAN_Type *base);
 
 
static inline void can_set_slow_speed_timing(CAN_Type *base, const can_bit_timing_param_t *param)
{
    base->S_PRESC = CAN_S_PRESC_S_PRESC_SET(param->prescaler - 1U) | CAN_S_PRESC_S_SEG_1_SET(param->num_seg1 - 2U) |
                                CAN_S_PRESC_S_SEG_2_SET(param->num_seg2 - 1U) | CAN_S_PRESC_S_SJW_SET(param->num_sjw - 1U);
}
 
static inline void can_set_fast_speed_timing(CAN_Type *base, const can_bit_timing_param_t *param)
{
    base->F_PRESC = CAN_F_PRESC_F_PRESC_SET(param->prescaler - 1U) | CAN_F_PRESC_F_SEG_1_SET(param->num_seg1 - 2U) |
                                CAN_F_PRESC_F_SEG_2_SET(param->num_seg2 - 1U) | CAN_F_PRESC_F_SJW_SET(param->num_sjw - 1U);
}
 
hpm_stat_t can_set_bit_timing(CAN_Type *base, can_bit_timing_option_t option,
                              uint32_t src_clk_freq, uint32_t baudrate,
                              uint16_t samplepoint_min, uint16_t samplepoint_max);
 
 
hpm_stat_t can_calculate_bit_timing(uint32_t src_clk_freq, can_bit_timing_option_t option, uint32_t baudrate,
                              uint16_t samplepoint_min, uint16_t samplepoint_max,
                              can_bit_timing_param_t *timing_param);
 
 
 
hpm_stat_t can_set_filter(CAN_Type *base, const can_filter_config_t *config);
 
hpm_stat_t can_send_message_blocking(CAN_Type *base, const can_transmit_buf_t *message);
 
hpm_stat_t can_send_high_priority_message_blocking(CAN_Type *base, const can_transmit_buf_t *message);
 
 
hpm_stat_t can_send_message_nonblocking(CAN_Type *base, const can_transmit_buf_t *message);
 
hpm_stat_t can_send_high_priority_message_nonblocking(CAN_Type *base, const can_transmit_buf_t *message);
 
hpm_stat_t can_receive_message_blocking(CAN_Type *base, can_receive_buf_t *message);
 
 
hpm_stat_t can_read_received_message(CAN_Type *base, can_receive_buf_t *message);
 
#ifdef __cplusplus
}
#endif
 
 
#endif /* HPM_CAN_DRV_H */