sdrv_sent.h

Go to the documentation of this file.

 
#ifndef SDRV_SENT_DRV_H_
#define SDRV_SENT_DRV_H_
 
#include <compiler.h>
#include <sdrv_common.h>
#include <types.h>
 
/* Single Secure Sensor Message Format include 6 data nibbles(24-bit). */
#define SENT_SECURE_SENSOR_DATA_NIBBLE 6U
/* High Speed Message Format include 4 data nibbles(12-bit). */
#define SENT_HIGH_SPEED_DATA_NIBBLE 4U
 
enum sdrv_sent_chanid {
    SDRV_SENT_HW_CPT_A = 0U, 
    SDRV_SENT_HW_CPT_B = 1U, 
    SDRV_SENT_HW_CPT_C = 2U, 
    SDRV_SENT_HW_CPT_D = 3U, 
    SDRV_SENT_CHAN_NUM = 4U, 
};
 
/* Sdrv sent struct. */
typedef struct sdrv_sent sdrv_sent_t;
typedef enum sdrv_sent_chanid sdrv_sent_chanid_e;
/* Recv frame over callback function. */
typedef void (*sdrv_sent_recv_cb_t)(sdrv_sent_t *ctrl,
                                    sdrv_sent_chanid_e sent_chan_id,
                                    void *userdata);
 
typedef enum {
    SDRV_SENT_HF_CLK = 0U, 
    SDRV_SENT_AHF_CLK =
        1U, 
    SDRV_SENT_EXT_CLK = 2U, 
    SDRV_SENT_LP_CLK =
        3U, 
} sdrv_sent_clk_src_e;
 
typedef enum {
    SENT_DATA_WIDTH_4_BIT = 1U,  
    SENT_DATA_WIDTH_8_BIT = 2U,  
    SENT_DATA_WIDTH_12_BIT = 3U, //**< Sent frame data width is 12bits. */
    SENT_DATA_WIDTH_16_BIT = 4U, 
    SENT_DATA_WIDTH_20_BIT = 5U, 
    SENT_DATA_WIDTH_24_BIT = 6U, 
} sdrv_sent_bitnum_e;
 
typedef enum {
    SENT_STATUS_UNINIT = 0U, 
    SENT_STATUS_INITED = 1U, 
} sdrv_sent_sta_e;
 
typedef enum {
    SENT_STANDARD_FORMAT = 0U, 
    SENT_SINGLE_SECURE_FORMAT =
        1U, 
    SENT_HIGH_SPEED_FORMAT = 2U, 
} sdrv_sent_fastchan_e;
 
typedef enum sdrv_frame_err {
    SENT_OK = 0U,                
    SENT_SYNC_ERR = (1U << 0),   
    SENT_STATUS_ERR = (1U << 1), 
    SENT_DATA_ERR = (1U << 2),   
    SENT_CRC_ERR = (1U << 3),    
    SENT_LOW_PULSE_ERR = (1U << 4),    
    SENT_MSB_NOT_ZERO = (1U << 5),     
    SENT_INV_MSN_ERR = (1U << 6),      
    SENT_CONUNTER_VAL_ERR = (1U << 7), 
    SENT_TICK_FREQ_ERR = (1U << 8),    
    SENT_NOT_OK = (1U << 31),          
} sdrv_frame_err_e;
 
typedef enum sent_frame_state {
    SENT_IDLE = 0U, 
    SENT_SYNC = 1U, 
    SENT_STATUS = 2U, 
    SENT_DATA = 3U,   
    SENT_CRC = 4U,    
    SENT_PAUSE = 5U,  
} sdrv_sent_frame_state_e;
 
typedef enum sent_chan_state {
    CHAN_STATUS_UNINIT = 0U,  
    CHAN_STATUS_INITED = 1U,  
    CHAN_STATUS_RUNNING = 2U, 
    CHAN_STATUS_STOPPED = 3U, 
} sent_chan_state_e;
 
/* Sent frame information. */
typedef struct sent_chan_frame {
    sdrv_sent_fastchan_e frame_format;          
    volatile sdrv_sent_frame_state_e cur_state; 
    volatile uint8_t rxframe[6];                
    uint8_t frame_dl;            
    volatile uint8_t rx_index;   
    volatile uint8_t frame_sta;  
    volatile uint8_t frame_crc;  
    volatile uint32_t frame_err; 
    volatile bool frame_valid;   
} sent_chan_frame_t;
 
typedef struct sdrv_sent_chan {
    sdrv_sent_chanid_e chan_id;          
    volatile sent_chan_state_e chan_sta; 
    sdrv_sent_recv_cb_t frameover_cb; 
    void *userdata; 
    uint8_t lowpulse_width; 
    bool pause_pulse;       
    uint32_t tickfreq;      
    uint8_t fifowml;        
    bool filter_en;         
    uint8_t
        filter_bandwidth; 
    uint8_t
        sample_interval; 
    uint32_t expect_scaler;          
    volatile uint32_t actual_scaler; 
    sent_chan_frame_t frame_info; 
} sdrv_sent_chan_t;
 
struct sdrv_sent {
    uint32_t base; 
    int32_t irq;   
    sdrv_sent_clk_src_e clk_sel; 
    uint16_t clk_div;            
    uint32_t clk_freq;           
    volatile sdrv_sent_sta_e sent_sta; 
    uint8_t chan_num; 
    sdrv_sent_chan_t
        chan[SDRV_SENT_CHAN_NUM]; 
};
 
typedef struct sdrv_sent_chan_config {
    sdrv_sent_chanid_e chan_id; 
    uint32_t tickfreq; 
    sdrv_sent_fastchan_e
        fast_chan; 
    sdrv_sent_bitnum_e
        data_bitnum;        
    uint8_t lowpulse_width; 
    uint8_t fifowml;        
    bool pause_pulse; 
    bool filter_en;   
    uint8_t
        filter_bandwidth; 
    uint8_t
        sample_interval; 
} sdrv_sent_chan_config_t;
 
typedef struct sdrv_sent_config {
    uint32_t base; 
    uint32_t irq;  
    sdrv_sent_clk_src_e clk_sel; 
    uint16_t clk_div;            
    uint32_t clk_freq;           
    uint8_t
        chan_cfg_num; 
    sdrv_sent_chan_config_t
        chan_cfg[SDRV_SENT_CHAN_NUM]; 
} sdrv_sent_config_t;
 
status_t sdrv_sent_init(sdrv_sent_t *ctrl, sdrv_sent_config_t *cfg);
 
status_t sdrv_sent_deinit(sdrv_sent_t *ctrl);
 
status_t sdrv_sent_set_callback(sdrv_sent_t *ctrl,
                                sdrv_sent_chanid_e sdrv_sent_chanid,
                                sdrv_sent_recv_cb_t callback, void *userdata);
 
status_t sdrv_sent_recv_start(sdrv_sent_t *ctrl,
                              sdrv_sent_chanid_e sent_chan_id);
 
status_t sdrv_sent_recv_stop(sdrv_sent_t *ctrl,
                             sdrv_sent_chanid_e sent_chan_id);
 
status_t sdrv_sent_parse_msg(sdrv_sent_t *ctrl,
                             sdrv_sent_chanid_e sent_chan_id);
 
status_t sdrv_sent_get_frame(sdrv_sent_t *ctrl, sdrv_sent_chanid_e sent_chan_id,
                             uint32_t *frame_err, sent_chan_frame_t *frame);
int sdrv_sent_irq_handle(uint32_t irq, void *ctrl);
#endif /* SDRV_SENT_H_ */