can.h

 
#ifndef CAN_H
#define CAN_H
 
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "syna_device.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*******************************************************************************
*                             Macro Definitions
*******************************************************************************/

#define CAN_MAX_DATA_LENGTH_CLASSIC  8U

#define CAN_MAX_DATA_LENGTH_FD      64U

#define CAN_MAX_DATA_LENGTH         CAN_MAX_DATA_LENGTH_FD

#define CAN_STD_ID_MASK             0x7FFU

#define CAN_EXT_ID_MASK             0x1FFFFFFFU

#define CAN_FILTER_IDE              (1UL << 0)

#define CAN_FILTER_RTR              (1UL << 1)

#define CAN_FILTER_FD               (1UL << 2)

#define CAN_TX_DESCRIPTOR_RESERVED_BYTES 20U

#define CAN_RX_DESCRIPTOR_RESERVED_BYTES 8U

#define CAN_RX_HEADER_RAW_WORDS     6U
 
/***************************************************************************/
 
/*******************************************************************************
*                               Enumerated Types
*******************************************************************************/

typedef enum {
    CAN_OK = 0,                          
    CAN_ERROR,                           
    CAN_ERROR_PARAMETER,                 
    CAN_ERROR_BUSY,                      
    CAN_ERROR_TIMEOUT,                   
    CAN_ERROR_UNSUPPORTED,               
    CAN_ERROR_NOT_INITIALIZED,           
    CAN_ERROR_NOT_RUNNING,               
    CAN_ERROR_NO_RESOURCE,               
    CAN_ERROR_TX_FAILED,                 
    CAN_ERROR_RX_FAILED,                 
    CAN_ERROR_DMA_FAILED,                
    CAN_ERROR_BUS_OFF,                   
    CAN_ERROR_ECC,                       
} can_status_en;

typedef enum {
    CAN_TRANSFER_IN_PROGRESS,            
    CAN_TRANSFER_TIMEOUT,                
    CAN_TRANSFER_ERROR,                  
    CAN_TRANSFER_DONE,                   
    CAN_TRANSFER_ABORTED,                
} can_transfer_status_en;

typedef enum {
    CAN_FRAME_CLASSIC = 0U,              
    CAN_FRAME_FD      = 1U,              
} can_frame_format_en;

typedef enum {
    CAN_RX_FRAME_TYPE_CLASSIC = 1U,      
    CAN_RX_FRAME_TYPE_FD      = 2U,      
} can_rx_frame_type_en;

typedef enum {
    CAN_ID_STANDARD = 0U,                
    CAN_ID_EXTENDED = 1U,                
} can_id_type_en;

typedef enum {
    CAN_FRAME_DATA   = 0U,               
    CAN_FRAME_REMOTE = 1U,               
} can_rtr_type_en;

typedef enum {
    CAN_MODE_NORMAL        = 0U,         
    CAN_MODE_LOOPBACK      = 1U,         
} can_operating_mode_en;

typedef enum {
    CAN_BUS_ERROR_ACTIVE   = 0U,         
    CAN_BUS_ERROR_PASSIVE  = 1U,         
    CAN_BUS_BUS_OFF        = 2U,         
} can_bus_state_en;

typedef enum {
    CAN_INTERRUPT_OVERLOAD_DETECTED             = (1UL << 0),
    CAN_INTERRUPT_CLOSING_GOOD_RX_FRAME         = (1UL << 1),
    CAN_INTERRUPT_TX_RETRANSMIT_REQUEST         = (1UL << 2),
    CAN_INTERRUPT_INCREMENT_REC_8               = (1UL << 3),
    CAN_INTERRUPT_INCREMENT_REC_1               = (1UL << 4),
    CAN_INTERRUPT_INCREMENT_TEC_8               = (1UL << 5),
    CAN_INTERRUPT_ERROR_FRAME_DETECTED          = (1UL << 6),
    CAN_INTERRUPT_ABORTS_HAPPENED               = (1UL << 7),
    CAN_INTERRUPT_TX_FIFO_EMPTY                 = (1UL << 8),
    CAN_INTERRUPT_RX_PTR_BUFS_FIFO_ALMOST_EMPTY = (1UL << 9),
    CAN_INTERRUPT_RX_PTR_BUFS_FIFO_EMPTY        = (1UL << 10),
    CAN_INTERRUPT_USED_BUFFERS_NOT_EMPTY        = (1UL << 11),
    CAN_INTERRUPT_CLTX_NOACK                    = (1UL << 12),
    CAN_INTERRUPT_FDTX_NOACK                    = (1UL << 13),
    CAN_INTERRUPT_CLTX_GOOD                     = (1UL << 14),
    CAN_INTERRUPT_FDTX_GOOD                     = (1UL << 15),
    CAN_INTERRUPT_BUS_STATE1                    = (1UL << 16),
    CAN_INTERRUPT_BUS_STATE2                    = (1UL << 17),
    CAN_INTERRUPT_WATCHDOG                      = (1UL << 18),
    CAN_INTERRUPT_GAP                           = (1UL << 19),
    CAN_INTERRUPT_PANIC_NO_BUFFERS              = (1UL << 20),
    CAN_INTERRUPT_PANIC_TX_BYTE_UNAVAILABLE     = (1UL << 21),
    CAN_INTERRUPT_PANIC_TX_START_FAILED         = (1UL << 22),
    CAN_INTERRUPT_PANIC_TX_WRONG_FRAME          = (1UL << 23),
    CAN_INTERRUPT_CANNOT_FIX                    = (1UL << 24),
    CAN_INTERRUPT_FIXED                         = (1UL << 25),
    CAN_INTERRUPT_PANICS                        = (1UL << 26),
    CAN_INTERRUPT_ILLEGAL_PARITY                = (1UL << 27),
    CAN_INTERRUPT_ILLEGAL_SM_STATES             = (1UL << 28),
    CAN_INTERRUPT_NEW_SAMPLE_TIMESTAMP          = (1UL << 31),
} can_interrupt_en;

 
/*******************************************************************************
*                              Type Definitions
*******************************************************************************/

typedef struct {
    struct {
        union {
            struct {
                uint32_t dlc         :12; 
                uint32_t id          :11; 
                uint32_t reserved    :1;  
                uint32_t esi         :1;  
                uint32_t brs         :1;  
                uint32_t rtr         :1;  
                uint32_t ide         :1;  
                uint32_t frame_type  :4;  
            } fields;
            uint32_t raw;               
        } signal_desc;
        uint32_t ext_id;               
        uint32_t reserved;             
    } header;
    uint8_t data[CAN_MAX_DATA_LENGTH];    
    uint8_t reserved[CAN_TX_DESCRIPTOR_RESERVED_BYTES]; 
} can_tx_frame_t;

typedef struct {
    uint32_t timestamp_low;       
    uint32_t timestamp_high;      
} can_tx_schedule_time_t;

typedef struct {
    union {
        struct {
            uint32_t frame_type    :2;  
            uint32_t is_extended   :1;  
            uint32_t is_rtr        :1;  
            uint32_t status        :10; 
            uint32_t dlc           :11; 
            uint32_t id_0_6        :7;  
            uint32_t id_7_10       :4;  
            uint32_t ext_id        :18; 
            uint32_t reserved_53_55:3;  
            uint32_t crc_0_6       :7;  
            uint32_t crc_7_14      :8;  
            uint32_t rtr           :1;  
            uint32_t ide           :1;  
            uint32_t reserved_74_95:22; 
            uint32_t reserved_96_127;   
            uint32_t timestamp_low;      
            uint32_t timestamp_high;     
        };
    };
} can_rx_classic_header_t;

typedef struct {
    union {
        struct {
            uint32_t frame_type    :2;  
            uint32_t is_extended   :1;  
            uint32_t is_rtr        :1;  
            uint32_t status        :10; 
            uint32_t dlc           :11; 
            uint32_t id_0_6        :7;  
            uint32_t id_7_10       :4;  
            uint32_t ext_id        :18; 
            uint32_t reserved_53_55:3;  
            uint32_t crc_0_6       :7;  
            uint32_t crc_7_20      :14; 
            uint32_t sbc           :4;  
            uint32_t ide           :1;  
            uint32_t esi           :1;  
            uint32_t brs           :1;  
            uint32_t reserved_85_95:11; 
            uint32_t reserved_96_127;   
            uint32_t timestamp_low;      
            uint32_t timestamp_high;     
        };
    };
} can_rx_fd_header_t;

typedef struct {
    union {
        can_rx_classic_header_t classic; 
        can_rx_fd_header_t fd;          
        uint32_t raw[CAN_RX_HEADER_RAW_WORDS]; 
    } header;
    uint8_t data[CAN_MAX_DATA_LENGTH];  
    uint8_t reserved[CAN_RX_DESCRIPTOR_RESERVED_BYTES]; 
} can_rx_frame_t;

typedef struct {
    uint32_t mask;  
    uint32_t id;    
    uint32_t flags; 
} can_rx_filter_t;

typedef struct {
    uint32_t watchdog_timeout_us;          
    uint32_t ssp_delay;                    
    can_operating_mode_en mode;            
    bool self_ack_enabled;                 
    bool iso_fd_enabled;                   
    bool fd_disable_sbc;                   
    bool disable_ack_check;                
    uint8_t max_retransmissions;           
} can_hw_config_t;

typedef struct {
    uint32_t timestamp_resolution_ns;      
    uint32_t classic_bitrate;              
    uint32_t fd_bitrate;                   
    uint32_t classic_sample_point;         
    uint32_t fd_sample_point;              
    bool ecc_enabled;                      
    can_hw_config_t hw;                    
} can_config_t;

typedef void (*can_tx_handler_t)(void *user_data, can_transfer_status_en status);

typedef void (*can_rx_handler_t)(void *user_data, const can_rx_frame_t *frame);

typedef void (*can_timestamp_handler_t)(void *user_data, uint32_t timestamp_low, uint32_t timestamp_high);

 
/*******************************************************************************
*                             Function Prototypes
*******************************************************************************/
 
/*******************************************************************************
 *                          Function Name: can_init
 ******************************************************************************/
can_status_en can_init(can_instance_en id);
 
/*******************************************************************************
 *                          Function Name: can_configure
 ****************************************************************************/
can_status_en can_configure(can_instance_en id, const can_config_t *config);
 
/*******************************************************************************
 *                          Function Name: can_deinit
 ****************************************************************************/
can_status_en can_deinit(can_instance_en id);
 
/*******************************************************************************
 *                          Function Name: can_enable
 ****************************************************************************/
can_status_en can_enable(can_instance_en id);
 
/*******************************************************************************
 *                          Function Name: can_disable
 ****************************************************************************/
can_status_en can_disable(can_instance_en id);
 
/*******************************************************************************
 *                          Function Name: can_tx
 ****************************************************************************/
can_status_en can_tx(can_instance_en id, bool high_priority, const can_tx_frame_t *frame,
                     const can_tx_schedule_time_t *time, can_tx_handler_t callback,
                     void *callback_param);
 
/*******************************************************************************
 *                          Function Name: can_rx_subscribe
 ****************************************************************************/
can_status_en can_rx_subscribe(can_instance_en id, const can_rx_filter_t *filter,
                               can_rx_handler_t callback, void *callback_param,
                               int *subid);
 
/*******************************************************************************
 *                          Function Name: can_rx_unsubscribe
 ****************************************************************************/
can_status_en can_rx_unsubscribe(can_instance_en id, int sub_id);
 
/*******************************************************************************
 *                          Function Name: can_set_speed
 ****************************************************************************/
can_status_en can_set_speed(can_instance_en id, int cl, int fd, int cl_sample, int fd_sample);
 
/*******************************************************************************
 *                          Function Name: can_set_timestamp_sample_handler
 ****************************************************************************/
can_status_en can_set_timestamp_sample_handler(can_instance_en id, can_timestamp_handler_t callback, void *callback_param);
 
/*******************************************************************************
 *                          Function Name: can_get_timestamp
 ****************************************************************************/
can_status_en can_get_timestamp(can_instance_en id, uint32_t *ts_l, uint32_t *ts_h, uint32_t *ts_res_ns);
 
/*******************************************************************************
 *                          Function Name: can_set_driver_buffer
 ****************************************************************************/
can_status_en can_set_driver_buffer(can_instance_en id, void *buffer, size_t size);
 
/*******************************************************************************
 *                          Function Name: can_enable_interrupt
 ****************************************************************************/
can_status_en can_enable_interrupt(can_instance_en id, uint32_t mask);
 
/*******************************************************************************
 *                          Function Name: can_enable_all_interrupts
 ****************************************************************************/
can_status_en can_enable_all_interrupts(can_instance_en id);
 
/*******************************************************************************
 *                          Function Name: can_disable_interrupt
 ****************************************************************************/
can_status_en can_disable_interrupt(can_instance_en id, uint32_t mask);
 
/*******************************************************************************
 *                          Function Name: can_disable_all_interrupts
 ****************************************************************************/
can_status_en can_disable_all_interrupts(can_instance_en id);
 
/*******************************************************************************
 *                          Function Name: can_clear_interrupt
 ****************************************************************************/
can_status_en can_clear_interrupt(can_instance_en id, uint32_t mask);
 
/*******************************************************************************
 *                          Function Name: can_clear_all_interrupts
 ****************************************************************************/
can_status_en can_clear_all_interrupts(can_instance_en id);

 
#ifdef __cplusplus
}
#endif
 
#endif /* CAN_H */