sdrv_lin.h

Go to the documentation of this file.

 
#ifndef INCLUDE_DRV_SDRV_LIN_H
#define INCLUDE_DRV_SDRV_LIN_H
 
#include <compiler.h>
#if CONFIG_MAINFUNCTION_ENABLE
#include <mainfunction/mainfunction.h>
#endif
#include <sdrv_common.h>
#include <sdrv_uart.h>
#include <types.h>
 
#ifndef ASSEMBLY
 
__BEGIN_CDECLS
 
/* Lin module is half duplex */
#define SDRV_HALF_DUPLEX 1U
/* Lin module use software flow control */
#define SDRV_SOFTWARE_FC 1U
/* Lin data frame param */
#define SDRV_CHAR_8_BITS 0U
#define SDRV_STOP_1_BIT 0U
#define SDRV_NO_PARITY 0U
 
/* Lin break is detected as 13 bit time low level on RX/TX line */
#define SDRV_LIN_TXBREAK_LEN (13U)
#define SDRV_LIN_RXBREAK_LEN (10U)
#define SDRV_LIN_TXBREAK_BIT(bit) (((bit)-8U) + 1U)
#define SDRV_LIN_RXBREAK_BIT(bit) (((bit)-9U) + 1U)
 
/* Trigger a transfer by write 0xA53C to register */
#define SDRV_DOORBELL_TRIGGER 0xA53CU
/* Abort a transfer by write 0xA53C to register */
#define SDRV_DOORBELL_ABORT 0xA5C3U
 
/* Auto baud detect param */
#define ABR_PATTERN 0U
#define SDRV_LIN_ABR_PATTERN_CHAR 0x55U
 
/* Sleep/Wakeup frame id */
#define LIN_SLEEP_ID 0x3cU
#define LIN_WAKEUP_ID 0x3dU
 
/* The count of timeout */
#define WaitForever 0xFFFFFFFFU
#define NoWait 0x00U
#define SDRV_LIN_OPERATION_TIMEOUT 0x200000U
 
/* The mask of timeout value, PCR7-> PCMDTO. */
#define SDRV_LIN_PCR7_PCMDTO_MASK 0x0000001FU
/* The mask of id value, PSR4-> LINPID -> ID. */
#define SDRV_LIN_PSR4_LINPID_ID_MASK 0x0000003FU
 
#define SDRV_UART_INTR_TX_FOVF                                                 \
    (1U << 4) 
#define SDRV_UART_INTR_RX_FOVF                                                 \
    (1U << 5) 
#define SDRV_LIN_INTR_PARITYERR                                                \
    (1U << 8) 
#define SDRV_LIN_INTR_FRAMEERR                                                 \
    (1U << 9) 
#define SDRV_LIN_INTR_BAUDRATEERR                                              \
    (1U << 10) 
#define SDRV_LIN_INTR_NOISERERR                                                \
    (1U << 11) 
#define SDRV_LIN_INTR_ABRPASS                                                  \
    (1U << 18) 
#define SDRV_LIN_INTR_ABRFAIL                                                  \
    (1U << 19) 
#define SDRV_LIN_INTR_STARTBITERR                                              \
    (1U << 20) 
#define SDRV_LIN_INTR_APBCMDDONE                                               \
    (1U << 21) 
#define SDRV_LIN_INTR_APBCMDABORT                                              \
    (1U << 22) 
#define SDRV_LIN_INTR_PIDPASS (1U << 23)      
#define SDRV_LIN_INTR_PIDERR (1U << 24)       
#define SDRV_LIN_INTR_RXCHKSUMPASS (1U << 25) 
#define SDRV_LIN_INTR_RXCHKSUMERR (1U << 26)  
/* Sdrv lin frame and fifo error interrupt. */
#define SDEV_LIN_INTR_FRAME_FIFO_ERR                                           \
    (SDRV_UART_INTR_TX_FOVF | SDRV_UART_INTR_RX_FOVF |                         \
     SDRV_LIN_INTR_PARITYERR | SDRV_LIN_INTR_FRAMEERR |                        \
     SDRV_LIN_INTR_NOISERERR | SDRV_LIN_INTR_STARTBITERR)
 
/* Sdrv lin abr interrupt. */
#define SDRV_LIN_INTR_ABR (SDRV_LIN_INTR_ABRPASS | SDRV_LIN_INTR_ABRFAIL)
 
enum lin_interrupt_type {
    SDRV_LIN_NO_EVENT = 0U,         
    SDRV_LIN_ABR_PASS = 1U,         
    SDRV_LIN_ABR_FAIL = 2U,         
    SDRV_LIN_TX_COMPLETE = 3U,      
    SDRV_LIN_TX_TIMEOUT = 4U,       
    SDRV_LIN_TX_ERROR = 5U,         
    SDRV_LIN_RX_COMPLETE = 6U,      
    SDRV_LIN_RX_TIMEOUT = 7U,       
    SDRV_LIN_RX_ERROR = 8U,         
    SDRV_LIN_RX_CHECKSUM_ERR = 9U,  
    SDRV_LIN_RX_PIDPASS = 10U,      
    SDRV_LIN_RX_PIDERR = 11U,       
    SDRV_LIN_RX_STARTBIT_ERR = 12U, 
    SDRV_LIN_RX_PARITY_ERR = 13U,   
    SDRV_LIN_RX_FRAME_ERR = 14U,    
    SDRV_LIN_RX_BAUDRATE_ERR = 15U, 
    SDRV_LIN_RX_NOISE_ERR = 16U,    
    SDRV_LIN_RX_RXFOVF_ERR = 17U,   
    SDRV_LIN_TX_TXFOVF_ERR = 18U,   
};
 
typedef struct sdrv_lin sdrv_lin_t;
typedef enum lin_interrupt_type lin_interrupt_type_e;
 
/* lin callback function type */
typedef void (*lin_callback_t)(struct sdrv_lin *ctrl,
                               lin_interrupt_type_e linstate, void *userdata);
 
typedef enum lin_mode {
    LIN_MASTER = 1U, 
    LIN_SLAVE = 2U,  
} lin_mode_e;
 
typedef enum lin_cs_mode {
    LIN_CLASSIC_CS = 0U,  /* Classic checksum */
    LIN_ENHANCED_CS = 1U, /* Enhanced checksum */
} lin_cs_mode_e;
 
typedef enum lin_ch_status {
    LIN_CH_UNINITIAL_STATE = 0U,   
    LIN_CH_SLEEP_STATE = 1U,       
    LIN_CH_OPERATIONAL_STATE = 2U, 
} lin_ch_status_e;
 
typedef enum lin_ret_status {
    STATUS_SUCCESS = SDRV_STATUS_OK,      
    STATUS_FAIL = SDRV_STATUS_FAIL,       
    STATUS_TIMEOUT = SDRV_STATUS_TIMEOUT, 
    STATUS_BUSY = SDRV_STATUS_BUSY,       
    STATUS_INVALID_PARAM =
        SDRV_STATUS_INVALID_PARAM, /* The param is invalid. */
    STATUS_SLEEP = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_LIN, 0U),
    STATUS_UNINIT = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_LIN,
                                      1U), 
} lin_ret_status_e;
 
typedef enum lin_sub_status {
    SDRV_LIN_STATE_IDLE = 0U,      
    SDRV_LIN_STATE_BUSY = 1U,      
    SDRV_LIN_STATE_TX = 2U,        
    SDRV_LIN_STATE_TX_ERROR = 3U,  
    SDRV_LIN_STATE_RX = 4U,        
    SDRV_LIN_STATE_RX_ERROR = 5U,  
    SDRV_LIN_STATE_ABR_READY = 6U, 
    SDRV_LIN_STATE_ABR_BUSY = 7U,  
    SDRV_LIN_STATE_ABR_FAIL = 8U,  
} lin_sub_status_e;
 
struct sdrv_lin {
    /* Lin module information. */
    uint32_t base;     
    int irq;           
    uint32_t clk_freq; 
    /* Lin channel information. */
    uint32_t baud;               
    lin_mode_e mode;             
    lin_cs_mode_e checksum;      
    volatile uint8_t current_id; 
    volatile lin_interrupt_type_e current_event;
    volatile lin_ch_status_e channel_sta; 
    lin_callback_t callback;     
    void *userdata;              
    volatile uint32_t abr_state; 
    volatile bool
        rx_error_invalid; 
    /* Lin transfer information. */
    const uint8_t *tx_buff;     
    uint8_t tx_size;            
    volatile uint8_t tx_remain; 
    volatile uint32_t tx_state; 
    uint8_t *rx_buff;           
    uint8_t rx_size;            
    volatile uint8_t rx_remain; 
    volatile uint32_t rx_state; 
#if CONFIG_MAINFUNCTION_ENABLE
    /* Lin mainfunction information. */
    module_mainfunction_t
        *module_node; 
    volatile mainfunction_ret_status_t
        module_mainfunction_state; 
#endif
};
 
typedef struct sdrv_lin_config {
    uint32_t base;          
    int irq;                
    uint32_t baud;          
    uint32_t clk_freq;      
    lin_mode_e mode;        
    lin_cs_mode_e checksum; 
    /* Auto baudrate detect configurations, these configurations are optional.
     * Default configuration : Disable auto baudrate detect
     */
    uint8_t abr_en; 
    sdrv_abr_max_e
        match_num; 
    /* Transfer timeout configurations, these configurations are optional.
     * If user set transfer_timeout as true, should set timeout_value too.
     * The range of timeout_value is 0x00 ~ 0x1F.
     * timeout_value <-> timeout cycle(w_sclk_div) <-> timeout ms(clk 83MHz)
     *     0x00                2^35 cycle              1/83000000*(2^35) = 413s
     *     0x01                2^34 cycle                       206s
     *     ...                    ...                           ...
     *     0x1F                2^3  cycle                       0.1us
     *
     * Example/Recommand:
     * w_sclk_div is 83MHz, 1 cycle is 0.012us.
     *    Baud(bit)  <->      timeout_value        <-> timeout ms(clk 83MHz)
     *    1K ~ 2K            0x0B(2^24 cycle)                   202ms
     *    2K ~ 5K            0x0C(2^23 cycle)                   101ms
     *    5k ~ 10k           0x0D(2^22 cycle)                   50ms
     *    10k ~ 15k          0x0E(2^21 cycle)                   25ms
     *    15k ~ 20k          0x0F(2^20 cycle)                   12ms
     */
    bool transfer_timeout; 
    uint8_t timeout_value; 
    /* Use mainfunction polling mode to transmit/receive lin frame.
     * Default configuration is false.
     */
    bool mainfunction_polling; 
    uint32_t
        period_ms; 
} sdrv_lin_config_t;
 
typedef struct sdrv_lin_pdu {
    uint8_t id;             
    lin_cs_mode_e checksum; 
    uint8_t size;           
    uint8_t *data;          
} sdrv_lin_pdu_t;
 
lin_ret_status_e sdrv_lin_controller_init(sdrv_lin_t *ctrl,
                                          const sdrv_lin_config_t *cfg,
                                          lin_callback_t callback,
                                          void *userdata);
 
void sdrv_lin_deinit(sdrv_lin_t *ctrl);
 
lin_ret_status_e sdrv_lin_set_baudrate(sdrv_lin_t *ctrl, uint32_t baud);
 
uint8_t sdrv_lin_get_id(sdrv_lin_t *ctrl);
 
lin_ret_status_e sdrv_lin_transmitframe(sdrv_lin_t *ctrl,
                                        sdrv_lin_pdu_t *lin_pdu,
                                        uint32_t times);
 
lin_ret_status_e sdrv_lin_transmit_status_get(sdrv_lin_t *ctrl,
                                              uint8_t *bytes_remaining);
 
lin_ret_status_e sdrv_lin_get_fifodata(sdrv_lin_t *ctrl, uint8_t *data,
                                       size_t size, uint32_t times);
 
lin_ret_status_e sdrv_lin_receiveframe(sdrv_lin_t *ctrl,
                                       sdrv_lin_pdu_t *lin_pdu);
 
lin_ret_status_e sdrv_lin_receive_status_get(sdrv_lin_t *ctrl,
                                             uint8_t *bytes_remaining);
 
lin_sub_status_e sdrv_lin_get_transfer_status(sdrv_lin_t *ctrl);
 
void sdrv_lin_clear_transfer_status(sdrv_lin_t *ctrl);
 
lin_ch_status_e sdrv_lin_get_status(sdrv_lin_t *ctrl);
 
lin_ret_status_e sdrv_lin_goto_sleep(sdrv_lin_t *ctrl);
 
lin_ret_status_e sdrv_lin_goto_sleep_internal(sdrv_lin_t *ctrl);
 
lin_ret_status_e sdrv_lin_wakeup(sdrv_lin_t *ctrl);
 
lin_ret_status_e sdrv_lin_wakeup_internal(sdrv_lin_t *ctrl);
 
void sdrv_lin_intr_ctrl(sdrv_lin_t *ctrl, uint32_t mask, bool value);
 
uint32_t sdrv_lin_intr_get(sdrv_lin_t *ctrl);
 
uint32_t sdrv_lin_intr_status_get(sdrv_lin_t *ctrl);
 
void sdrv_lin_intr_status_clear(sdrv_lin_t *ctrl, uint32_t mask);
 
int sdrv_lin_irq_handler(uint32_t irq, void *ctrl);
 
#if CONFIG_MAINFUNCTION_ENABLE
void sdrv_lin_mainfunction_handler(void *ctrl);
#endif
 
__END_CDECLS
 
#endif
 
#endif