sdrv_flexcan.h

Go to the documentation of this file.

 
#ifndef SDRV_FLEXCAN_H_
#define SDRV_FLEXCAN_H_
 
#include <stdbool.h>
#include <types.h>
 
#include "../source/flexcan/sdrv_flexcan_priv.h"
#include <sdrv_common.h>
 
/* Doze mode support definition. */
#define FLEXCAN_HAS_DOZE_MODE_SUPPORT 1
 
#define FLEXCAN_COPY_USE_BURST 1
 
#define CORE_LITTLE_ENDIAN 1
 
/* Data index converting between frame and MB. */
#if CORE_LITTLE_ENDIAN
#define IDX_CONVERT(x)  (((x) & 0xFCU) + 3U - ((x) & 3U))
#else
#define IDX_CONVERT(x)  (x)
#endif
 
/* Make Rx FIFO ID filter table content. */
/* ID type */
#define STANDARD_DATA_ID 0U
#define STANDARD_REMOTE_ID 2U
#define EXTENDED_DATA_ID 1U
#define EXTENDED_REMOTE_ID 3U
/* Type A */
#define MAKE_TYPE_A_FILTER(id, type)                                           \
    (((type) << 30) | ((id) << (((type)&1U) ? 1 : 19)))
/* Type B */
#define MAKE_TYPE_B_FILTER(id1, id2, type1, type2)                             \
    (((type1) << 30) | ((id1) << (((type1)&1U) ? 16 : 19)) | ((type2) << 14) | \
     ((id2) << (((type2)&1U) ? 0 : 3)))
/* Type C */
#define MAKE_TYPE_C_FILTER(id1, id2, id3, id4)                                 \
    (((id1)&0xFFU) | ((id2)&0xFFU) | ((id3)&0xFFU) | ((id4)&0xFFU))
 
#define FlexCanRxFifoAcceptRemoteFrame 1UL
#define FlexCanRxFifoAcceptExtFrame 1UL
 
// Aliases data types declarations
typedef struct flexcan_fd_config_t flexcan_fd_config_t;
typedef struct flexcan_pn_config_t flexcan_pn_config_t;
typedef struct flexcan_timing_config_t flexcan_timing_config_t;
typedef struct flexcan_config_t flexcan_config_t;
typedef struct flexcan_rx_fifo_config_t flexcan_rx_fifo_config_t;
 
/******************* FlexCAN data structure *********************/
typedef enum flexcan_fd_data_size {
    CAN_FD_8BYTES_PER_MB = 0,  
    CAN_FD_16BYTES_PER_MB = 1, 
    CAN_FD_32BYTES_PER_MB = 2, 
    CAN_FD_64BYTES_PER_MB = 3  
} flexcan_fd_data_size_e;
 
typedef enum flexcan_clock_source {
    FLEXCAN_ClkSrcOsc =
        0, 
    FLEXCAN_ClkSrcPeri =
        1 
} flexcan_clock_source_e;
 
typedef enum flexcan_rx_fifo_filter_type {
    FLEXCAN_RxFifoFilterTypeA =
        0, 
    FLEXCAN_RxFifoFilterTypeB =
        1, 
    FLEXCAN_RxFifoFilterTypeC = 2, 
    FLEXCAN_RxFifoFilterTypeD = 3  
} flexcan_rx_fifo_filter_type_e;
 
typedef enum flexcan_rx_fifo_priority {
    FLEXCAN_RxFifoPrioLow =
        0, 
    FLEXCAN_RxFifoPrioHigh = 1 
} flexcan_rx_fifo_priority_e;
 
typedef enum flexcan_frame_type {
    FLEXCAN_FrameTypeData = 0,  
    FLEXCAN_FrameTypeRemote = 1 
} flexcan_frame_type_e;
 
typedef enum flexcan_frame_format {
    FLEXCAN_STANDARD_FRAME = 0, 
    FLEXCAN_EXTEND_FRAME = 1    
} flexcan_frame_format_e;
 
// Structures/unions data types declarations
struct flexcan_fd_config_t {
    uint8_t enableISOCANFD;
    uint8_t enableBRS;
    uint8_t enableTDC;
    uint8_t TDCOffset;
    flexcan_fd_data_size_e r0_mb_data_size;
    flexcan_fd_data_size_e r1_mb_data_size;
};
 
typedef struct {
    bool extendedId;  
    bool remoteFrame; 
    uint32_t id;      
} flexcan_pn_id_filter_t;
 
typedef struct {
    uint8_t dlcLow;       
    uint8_t dlcHigh;      
    uint8_t payload1[8U]; 
    uint8_t payload2[8U]; 
} flexcan_pn_payload_filter_t;
 
typedef enum {
    FLEXCAN_FILTER_ID,         
    FLEXCAN_FILTER_ID_PAYLOAD, 
    FLEXCAN_FILTER_ID_NTIMES,  
    FLEXCAN_FILTER_ID_PAYLOAD_NTIMES 
} flexcan_pn_filter_combination_e;
 
typedef enum {
    FLEXCAN_FILTER_MATCH_EXACT, 
    FLEXCAN_FILTER_MATCH_GEQ,   
    FLEXCAN_FILTER_MATCH_LEQ,   
    FLEXCAN_FILTER_MATCH_RANGE  
} flexcan_pn_filter_selection_e;
 
struct flexcan_pn_config_t {
    bool wakeUpTimeout; 
    bool wakeUpMatch; 
    uint16_t numMatches; 
    uint16_t matchTimeout; 
    flexcan_pn_filter_combination_e
        filterComb; 
    flexcan_pn_id_filter_t
        idFilter1; 
    flexcan_pn_id_filter_t idFilter2; 
    flexcan_pn_filter_selection_e
        idFilterType; 
    flexcan_pn_filter_selection_e
        payloadFilterType; 
    flexcan_pn_payload_filter_t
        payloadFilter; 
};
 
struct flexcan_timing_config_t {
    uint16_t preDivider;
    uint8_t rJumpwidth;
    uint8_t propSeg;
    uint8_t phaseSeg1;
    uint8_t phaseSeg2;
};
 
struct flexcan_config_t {
    flexcan_clock_source_e clkSrc;
    uint8_t maxMbNum;
    bool enableLoopBack;
    bool enableLBUFTransmittedFirst;
    bool enableListenOnly;
    bool enableSelfWakeup;
    bool enableIndividMask;
    bool enableDoze;
    bool enableCANFD;
    bool enablePretendedNetworking;
    flexcan_timing_config_t nominalBitTiming;
    flexcan_timing_config_t dataBitTiming;
    flexcan_fd_config_t can_fd_cfg;
    flexcan_pn_config_t pnet_cfg;
};
 
typedef struct flexcan_rx_fifo_filter_table {
    uint32_t filter_code;
    uint32_t filter_mask;
} flexcan_rx_fifo_filter_table_t;
 
struct flexcan_rx_fifo_config_t {
    uint8_t idFilterNum;
    flexcan_rx_fifo_filter_type_e idFilterType;
    flexcan_rx_fifo_priority_e priority;
    flexcan_rx_fifo_filter_table_t *filter_tab;
};
 
typedef struct _flexcan_rx_mb_config {
    uint32_t id; 
    flexcan_frame_format_e
        format; 
    flexcan_frame_type_e type; 
} flexcan_rx_mb_config_t;
 
typedef struct _flexcan_frame {
    uint16_t
        timestamp; 
    uint32_t id;   
    struct {
        uint32_t
            length : 7; 
        uint32_t type : 1;   
        uint32_t format : 1; 
        uint32_t isCANFDFrame : 1; 
        uint32_t isCANFDBrsEn : 1; 
        uint32_t reserved1 : 5;    
        uint32_t idHit : 9; 
        uint32_t reserved2 : 7; 
    };
    uint8_t
        *dataBuffer; 
} flexcan_frame_t;
 
typedef struct _flexcan_mb_transfer {
    flexcan_frame_t *pFrame; 
    uint8_t mbIdx; 
} flexcan_mb_transfer_t;
 
typedef struct _flexcan_fifo_transfer {
    flexcan_frame_t
        *pFrame; 
} flexcan_fifo_transfer_t;
 
typedef struct _flexcan_handle flexcan_handle_t;
 
typedef enum _flexcan_status {
  FLEXCAN_SUCCESS = SDRV_STATUS_OK, 
  FLEXCAN_FAIL =
      SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN, 1), 
  FLEXCAN_TX_BUSY = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                                      2), 
  FLEXCAN_TX_IDLE = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                                      3), 
  FLEXCAN_TX_SWITCH_TO_RX =
      SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN, 4), 
  FLEXCAN_RX_BUSY = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                                      5), 
  FLEXCAN_RX_IDLE = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                                      6), 
  FLEXCAN_RX_OVERFLOW = SDRV_ERROR_STATUS(
      SDRV_STATUS_GROUP_FLEXCAN, 7), 
  FLEXCAN_RX_FIFO_BUSY = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                                           8), 
  FLEXCAN_RX_FIFO_IDLE = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                                           9), 
  FLEXCAN_RX_FIFO_OVERFLOW = SDRV_ERROR_STATUS(
      SDRV_STATUS_GROUP_FLEXCAN, 10), 
  FLEXCAN_RX_FIFO_WARNING =
      SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                        11), 
  FLEXCAN_ERROR_STATUS = SDRV_ERROR_STATUS(
      SDRV_STATUS_GROUP_FLEXCAN, 12), 
  FLEXCAN_WAKEUP_TIMEOUT =
      SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                        13), 
  FLEXCAN_WAKEUP_MATCH =
      SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_FLEXCAN,
                        14), 
  FLEXCAN_UNHANDLED = SDRV_ERROR_STATUS(
      SDRV_STATUS_GROUP_FLEXCAN, 15), 
} flexcan_status_e;
 
typedef enum flexcan_controller_id {
    FLEXCAN1 = 0,
    FLEXCAN2 = 1,
    FLEXCAN3 = 2,
    FLEXCAN4 = 3,
    FLEXCAN5 = 4,
    FLEXCAN6 = 5,
    FLEXCAN7 = 6,
    FLEXCAN8 = 7,
    FLEXCAN9 = 8,
    FLEXCAN10 = 9,
    FLEXCAN11 = 10,
    FLEXCAN12 = 11,
    FLEXCAN13 = 12,
    FLEXCAN14 = 13,
    FLEXCAN15 = 14,
    FLEXCAN16 = 15,
    FLEXCAN17 = 16,
    FLEXCAN18 = 17,
    FLEXCAN19 = 18,
    FLEXCAN20 = 19,
    FLEXCAN21 = 20,
    FLEXCAN22 = 21,
    FLEXCAN23 = 22,
    FLEXCAN24 = 23,
    MAX_FLEXCAN_CH
} flexcan_controller_id_e;
 
typedef void (*flexcan_transfer_callback_t)(flexcan_handle_t *handle,
                                            flexcan_status_e status,
                                            uint32_t result, void *userData);
 
struct _flexcan_handle {
    uint8_t controller_id;
    uint8_t irq_num;
    void *base_addr;
    flexcan_transfer_callback_t callback;
    void *userData;
    flexcan_frame_t
        *volatile pMBFrameBuf[FLEXCAN_HAS_MESSAGE_BUFFER_MAX_NUMBER];
    flexcan_frame_t *volatile pRxFifoFrameBuf;
    volatile uint8_t mbState[FLEXCAN_HAS_MESSAGE_BUFFER_MAX_NUMBER];
    volatile uint8_t rxFifoState;
    /* Bit map used to record if a MB is used. */
    uint32_t mb_used_mask[2];
#if FLEXCAN_HAS_DOZE_MODE_SUPPORT
    bool enableDoze;
#endif
};
 
enum _flexcan_interrupt_enable {
    FLEXCAN_BusOffInterruptEnable =
        0x8000U, 
    FLEXCAN_ErrorInterruptEnable =
        0x4000U, 
    FLEXCAN_RxWarningInterruptEnable =
        0x400U, 
    FLEXCAN_TxWarningInterruptEnable =
        0x800U, 
    FLEXCAN_WakeUpInterruptEnable =
        0x4000000U, 
};
 
/******************************************************************************
 * API
 *****************************************************************************/
 
extern void flexcan_create_handle(flexcan_handle_t *handle, uint8_t controller_id,
                           void *reg_base, uint8_t irq_num,
                           flexcan_transfer_callback_t callback, void *userData);
 
extern flexcan_status_e flexcan_init(flexcan_handle_t *handle,
                                     const flexcan_config_t *config);
 
extern flexcan_status_e flexcan_enable(flexcan_handle_t *handle, bool enable);
 
extern flexcan_status_e flexcan_freeze(flexcan_handle_t *handle, bool freeze);
 
extern flexcan_status_e flexcan_reset(flexcan_handle_t *handle);
 
extern void flexcan_deinit(flexcan_handle_t *handle);
 
extern void
flexcan_classic_set_timing_config(flexcan_handle_t *handle,
                                  const flexcan_timing_config_t *config);
 
extern void
flexcan_fd_set_timing_config(flexcan_handle_t *handle,
                             const flexcan_timing_config_t *arbitrPhaseConfig,
                             const flexcan_timing_config_t *dataPhaseConfig);
 
extern void flexcan_read_wmb(flexcan_handle_t *handle, uint8_t wmbIndex,
                             flexcan_frame_t *wmb);
 
extern flexcan_status_e flexcan_request_sleep(flexcan_handle_t *handle,
                                              bool request);
 
extern void flexcan_set_rx_mb_global_mask(flexcan_handle_t *handle,
                                          uint32_t mask);
 
extern void flexcan_set_rx_fifo_global_mask(flexcan_handle_t *handle,
                                            uint32_t mask);
 
extern void flexcan_set_rx_individual_mask(flexcan_handle_t *handle,
                                           uint8_t maskIdx, uint32_t mask);
 
extern void flexcan_set_tx_mb_config(flexcan_handle_t *handle, uint8_t mbIdx,
                                     bool tx_by_interrupt);
 
extern void flexcan_set_rx_mb_config(flexcan_handle_t *handle, uint8_t mbIdx,
                                     const flexcan_rx_mb_config_t *config);
 
extern void flexcan_set_rx_fifo_config(flexcan_handle_t *handle,
                                       const flexcan_rx_fifo_config_t *config);
 
extern void flexcan_enable_interrupts(flexcan_handle_t *handle, uint32_t mask);
 
extern void flexcan_disable_interrupts(flexcan_handle_t *handle, uint32_t mask);
 
extern uint32_t flexcan_get_mb_iflag(flexcan_handle_t *handle, uint8_t msgBufId);
 
extern flexcan_status_e flexcan_send_nonblocking(flexcan_handle_t *handle,
                                                 flexcan_mb_transfer_t *xfer,
                                                 uint8_t padding_val);
 
extern flexcan_status_e
flexcan_receive_nonblocking(flexcan_handle_t *handle,
                            flexcan_mb_transfer_t *xfer);
 
extern flexcan_status_e
flexcan_receive_fifo_nonblocking(flexcan_handle_t *handle,
                                 flexcan_fifo_transfer_t *xfer);
 
extern flexcan_status_e flexcan_write_tx_mb(flexcan_handle_t *handle,
                                            uint8_t mbIdx,
                                            const flexcan_frame_t *txFrame,
                                            uint8_t padding_val);
 
extern flexcan_status_e flexcan_read_rx_mb(flexcan_handle_t *handle,
                                           uint8_t mbIdx,
                                           flexcan_frame_t *rxFrame);
 
extern flexcan_status_e flexcan_read_rx_fifo(flexcan_handle_t *handle,
                                             flexcan_frame_t *rxFrame);
 
extern void flexcan_abort_mb_send(flexcan_handle_t *handle, uint8_t mbIdx);
 
extern void flexcan_abort_mb_receive(flexcan_handle_t *handle, uint8_t mbIdx);
 
extern void flexcan_abort_receive_fifo(flexcan_handle_t *handle);
 
extern uint32_t flexcan_read_mb_int_status(flexcan_handle_t *handle,
                                           uint8_t mbIdx);
 
extern uint8_t flexcan_get_mb_state(flexcan_handle_t *handle, uint8_t mbIdx);
 
extern bool flexcan_is_mb_occupied(flexcan_handle_t *handle, uint8_t mbIdx);
 
extern uint32_t flexcan_get_error_status(flexcan_handle_t *handle);
 
extern void flexcan_clear_err_status_flag(flexcan_handle_t *handle,
                                          uint32_t mask);
 
extern int flexcan_irq_handler(uint32_t irq, void *arg);
 
#endif /* SDRV_FLEXCAN_H_ */