hpm_sdm_drv.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef HPM_SDM_DRV_H
#define HPM_SDM_DRV_H
 
#include "hpm_common.h"
#include "hpm_sdm_regs.h"
#include "hpm_soc_ip_feature.h"
 
/* defined channel mask macro */
#define SAMPLING_MODE_MASK (0x7U)
#define CHN_SAMPLING_MODE_SHIFT(ch) ((ch) * 3U + SDM_CTRL_CHMD_SHIFT)
#define CHN_SAMPLING_MODE_MASK(ch) (SAMPLING_MODE_MASK << CHN_SAMPLING_MODE_SHIFT(ch))
 
#define CH0_EN_MASK (0x1U << SDM_CTRL_CH_EN_SHIFT)
#define CHN_EN_MASK(ch) (CH0_EN_MASK << (ch))
 
#define CHN_ERR_MASK(ch) (SDM_INT_EN_CH0ERR_MASK << (ch))
#define CHN_DRY_MASK(ch) (SDM_INT_EN_CH0DRY_MASK << (ch))
 
typedef enum {
   sdm_sampling_rising_clk_edge = 0,
   sdm_sampling_every_clk_edge = 1,
   sdm_sampling_manchester_mode = 2,
   sdm_sampling_falling_clk_edge = 3,
   sdm_sampling_rising_two_clk_edge = 4,
   sdm_sampling_falling_two_clk_edge = 5
} sdm_sampling_mode_t;
 
typedef enum {
    sdm_filter_sinc1 = 0,
    sdm_filter_sinc2 = 1,
    sdm_filter_sinc3 = 2,
    sdm_filter_fast_sinc2 = 3
} sdm_filter_type_t;
 
typedef struct {
    uint8_t clk_signal_sync; /* clk sync for channel */
    uint8_t data_signal_sync; /* data sync for channel */
    bool interrupt_en;
} sdm_control_t;
 
typedef struct {
    uint8_t sampling_mode;
    bool enable_err_interrupt;
    bool enable_data_ready_interrupt;
} sdm_channel_common_config_t;
 
/* amplitude detect config */
typedef struct {
    uint16_t high_threshold;             
    uint16_t zero_cross_threshold;       
    uint16_t low_threshold;              
    bool en_zero_cross_threshold_int;    
    bool en_clock_invalid_int;           
    bool en_high_threshold_int;          
    bool en_low_threshold_int;           
    uint8_t filter_type;                 
    uint8_t oversampling_rate;           
    uint8_t ignore_invalid_samples;      
    bool enable;                         
} sdm_comparator_config_t;
 
/* sample data config */
typedef struct {
    uint8_t fifo_threshold;           
    bool en_fifo_threshold_int;       
    uint8_t manchester_threshold  :8; 
    uint8_t wdg_threshold         :8; 
    uint8_t en_af_int             :1; 
    uint8_t en_data_overflow_int  :1; 
    uint8_t en_cic_data_saturation_int  :1; 
    uint8_t en_data_ready_int           :1; 
    uint8_t sync_source                 :6; 
    uint8_t fifo_clean_on_sync          :1; 
    uint8_t wtsynaclr                   :1; 
    uint8_t wtsynmclr                   :1; 
    uint8_t wtsyncen                    :1; 
    uint8_t output_32bit                :1; 
    uint8_t data_ready_flag_by_fifo     :1; 
    uint8_t enable                      :1; 
    uint8_t filter_type;                 
    bool pwm_signal_sync;                
    uint8_t output_offset;               
    uint16_t oversampling_rate;          
    uint8_t ignore_invalid_samples;      
} sdm_filter_config_t;
 
#if defined(HPM_IP_FEATURE_SDM_GATE_FUNC) && (HPM_IP_FEATURE_SDM_GATE_FUNC)
typedef struct {
    bool enable;                    /* enable gate function */
    bool start_on_rising_edge;      /* start from gate signal rising edge */
    bool stop_sample_by_gate_count; /* true: gate_count decide stop sample time; false: stop sample time related to gate signal timing */
    uint16_t gate_count;            /* gate sample count */
    uint16_t gate_source;           /* gate signal source from trgmmux */
} sdm_filter_gate_config_t;
#endif
 
#if defined(HPM_IP_FEATURE_SDM_TIMESTAMP_FUNC) && (HPM_IP_FEATURE_SDM_TIMESTAMP_FUNC)
typedef struct {
    bool enable_fifo_output_timestamp;     /* enable SDATA register output timestamp */
    bool enable_register_output_timestamp; /*  enable SDFIFO output timestamp */
    bool timestamp_output_subtract_delay;  /* false: calculation results output time; true: calculation results output time - the delay of filter time */
} sdm_filter_timestamp_config_t;
#endif
 
typedef struct {
    uint32_t count;
    uint8_t *buff;
    uint8_t data_len_in_bytes; /* 16bit-2   32bit-4 */
    bool using_fifo;
} sdm_output_config_t;
 
typedef enum {
    sdm_comparator_no_event = 0,
    sdm_comparator_event_out_high_threshold = SDM_CH_SCST_CMPH_MASK,
    sdm_comparator_event_out_low_threshold = SDM_CH_SCST_CMPL_MASK,
    sdm_comparator_event_hz = SDM_CH_SCST_HZ_MASK,
    sdm_comparator_event_invalid_clk = SDM_CH_SCST_MF_MASK
} sdm_comparator_event_t;
 
typedef enum {
    sdm_chn0_error_mask = SDM_INT_EN_CH0ERR_MASK,
    sdm_chn1_error_mask = SDM_INT_EN_CH1ERR_MASK,
    sdm_chn2_error_mask = SDM_INT_EN_CH2ERR_MASK,
    sdm_chn3_error_mask = SDM_INT_EN_CH3ERR_MASK,
    sdm_chn0_data_ready_mask = SDM_INT_EN_CH0DRY_MASK,
    sdm_chn1_data_ready_mask = SDM_INT_EN_CH1DRY_MASK,
    sdm_chn2_data_ready_mask = SDM_INT_EN_CH2DRY_MASK,
    sdm_chn3_data_ready_mask = SDM_INT_EN_CH3DRY_MASK
} sdm_channel_int_status_mask_t;
 
typedef enum {
    sdm_chn0_enable_mask = 1U << SDM_CTRL_CH_EN_SHIFT,
    sdm_chn1_enable_mask = 1U << (SDM_CTRL_CH_EN_SHIFT + 1U),
    sdm_chn2_enable_mask = 1U << (SDM_CTRL_CH_EN_SHIFT + 2U),
    sdm_chn3_enable_mask = 1U << (SDM_CTRL_CH_EN_SHIFT + 3U)
} sdm_channel_enable_mask_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
static inline void sdm_enable_module_interrupt(SDM_Type *ptr, bool enable)
{
    if (enable) {
        ptr->CTRL |= SDM_CTRL_IE_MASK;
    } else {
        ptr->CTRL &= ~SDM_CTRL_IE_MASK;
    }
}
 
static inline void sdm_enable_channel(SDM_Type *ptr, uint8_t ch_index, bool enable)
{
    if (enable) {
        ptr->CTRL |= CHN_EN_MASK(ch_index);
    } else {
        ptr->CTRL &= ~CHN_EN_MASK(ch_index);
    }
}
 
static inline void sdm_enable_channel_filter(SDM_Type *ptr, uint8_t ch_index, bool enable)
{
    if (enable) {
        ptr->CH[ch_index].SDCTRLP |= SDM_CH_SDCTRLP_EN_MASK;
    } else {
        ptr->CH[ch_index].SDCTRLP &= ~SDM_CH_SDCTRLP_EN_MASK;
    }
}
 
static inline void sdm_enable_channel_comparator(SDM_Type *ptr, uint8_t ch_index, bool enable)
{
    if (enable) {
        ptr->CH[ch_index].SCCTRL |= SDM_CH_SCCTRL_EN_MASK;
    } else {
        ptr->CH[ch_index].SCCTRL &= ~SDM_CH_SCCTRL_EN_MASK;
    }
}
 
static inline void sdm_enable_channel_by_mask(SDM_Type *ptr, uint32_t ch_mask)
{
    ptr->CTRL = (ptr->CTRL & (~SDM_CTRL_CH_EN_MASK)) | ch_mask;
}
 
static inline void sdm_set_channel_sampling_mode(SDM_Type *ptr, uint8_t ch_index, sdm_sampling_mode_t mode)
{
    ptr->CTRL &= ~CHN_SAMPLING_MODE_MASK(ch_index);
    ptr->CTRL |= mode << (SDM_CTRL_CHMD_SHIFT + ch_index);
}
 
static inline void sdm_enable_channel_interrupt(SDM_Type *ptr, uint32_t mask)
{
    ptr->INT_EN |= mask;
}
 
static inline uint32_t sdm_get_status(SDM_Type *ptr)
{
    return ptr->STATUS;
}
 
static inline bool sdm_get_channel_data_ready_status(SDM_Type *ptr, uint8_t ch)
{
    return (((ptr->STATUS) & CHN_DRY_MASK(ch)) == CHN_DRY_MASK(ch));
}
 
static inline bool sdm_get_channel_data_error_status(SDM_Type *ptr, uint8_t ch)
{
    return (((ptr->STATUS) & CHN_ERR_MASK(ch)) == CHN_ERR_MASK(ch));
}
 
static inline void sdm_set_ch_fifo_threshold(SDM_Type *ptr, uint8_t ch, uint8_t threshold)
{
    ptr->CH[ch].SDFIFOCTRL = SDM_CH_SDFIFOCTRL_THRSH_SET(threshold);
}
 
static inline uint8_t sdm_get_ch_fifo_threshold(SDM_Type *ptr, uint8_t ch)
{
    return (uint8_t)(SDM_CH_SDFIFOCTRL_THRSH_GET(ptr->CH[ch].SDFIFOCTRL));
}
 
static inline uint32_t sdm_get_channel_filter_status(SDM_Type *ptr, uint8_t ch)
{
    return ptr->CH[ch].SDST;
}
 
#if defined(HPM_IP_FEATURE_SDM_TIMESTAMP_FUNC) && (HPM_IP_FEATURE_SDM_TIMESTAMP_FUNC)
static inline bool sdm_channel_filter_fifo_is_data(SDM_Type *ptr, uint8_t ch)
{
    return (bool)(SDM_CH_SDST_SDFIFO_D0_T1_GET(ptr->CH[ch].SDST));
}
 
static inline bool sdm_channel_filter_register_is_data(SDM_Type *ptr, uint8_t ch)
{
    return (bool)(SDM_CH_SDST_SDATA_D0_T1_GET(ptr->CH[ch].SDST));
}
#endif
 
static inline void sdm_clean_channel_filter_status(SDM_Type *ptr, uint8_t ch, uint32_t mask)
{
    ptr->CH[ch].SDST = mask;
}
 
static inline uint8_t sdm_get_channel_fifo_data_count(SDM_Type *ptr, uint8_t ch)
{
    return (uint8_t)(SDM_CH_SDST_FILL_GET(ptr->CH[ch].SDST));
}
 
static inline int32_t sdm_get_channel_fifo_data(SDM_Type *ptr, uint8_t ch)
{
    return ptr->CH[ch].SDFIFO;
}
 
static inline uint8_t sdm_get_channel_clock_cycle_count(SDM_Type *ptr, uint8_t ch)
{
    return (uint8_t)(SDM_CH_SDST_PERIOD_MCLK_GET(ptr->CH[ch].SDST));
}
 
static inline uint16_t sdm_get_channel_comparator_data(SDM_Type *ptr, uint8_t ch)
{
    return (uint16_t)(ptr->CH[ch].SCAMP);
}
 
static inline void sdm_set_channel_comparator_high_threshold(SDM_Type *ptr, uint8_t ch, uint16_t value)
{
    ptr->CH[ch].SCHTL = value;
}
 
static inline void sdm_set_channel_comparator_zero_crossing_threshold(SDM_Type *ptr, uint8_t ch, uint16_t value)
{
    ptr->CH[ch].SCHTLZ = value;
}
 
static inline void sdm_set_channel_comparator_low_threshold(SDM_Type *ptr, uint8_t ch, uint16_t value)
{
    ptr->CH[ch].SCLLT = value;
}
 
static inline uint32_t sdm_get_channel_comparator_status(SDM_Type *ptr, uint8_t ch)
{
    return ptr->CH[ch].SCST;
}
 
static inline void sdm_clean_channel_comparator_status(SDM_Type *ptr, uint8_t ch, uint32_t mask)
{
    ptr->CH[ch].SCST = mask;
}
 
void sdm_get_default_module_control(SDM_Type *ptr, sdm_control_t *control);
 
void sdm_init_module(SDM_Type *ptr, sdm_control_t *control);
 
void sdm_get_channel_common_setting(SDM_Type *ptr, sdm_channel_common_config_t *config);
 
void sdm_config_channel_common_setting(SDM_Type *ptr, uint8_t ch_index, sdm_channel_common_config_t *config);
 
void sdm_get_channel_default_filter_config(SDM_Type *ptr, sdm_filter_config_t *filter_config);
 
void sdm_config_channel_filter(SDM_Type *ptr, uint8_t ch_index, sdm_filter_config_t *filter_config);
 
void sdm_get_channel_default_comparator_config(SDM_Type *ptr, sdm_comparator_config_t *cmp_config);
 
void sdm_config_channel_comparator(SDM_Type *ptr,  uint8_t ch_index, sdm_comparator_config_t *cmp_config);
 
hpm_stat_t sdm_receive_one_filter_data(SDM_Type *ptr, uint8_t ch_index, bool using_fifo, int8_t *data, uint8_t data_len_in_bytes);
 
hpm_stat_t sdm_receive_filter_data(SDM_Type *ptr, uint8_t ch_index, bool using_fifo, int8_t *data, uint32_t count, uint8_t data_len_in_bytes);
 
#if defined(HPM_IP_FEATURE_SDM_GATE_FUNC) && (HPM_IP_FEATURE_SDM_GATE_FUNC)
hpm_stat_t sdm_config_channel_filter_gate(SDM_Type *ptr, uint8_t ch_index, sdm_filter_gate_config_t *gate_config);
#endif
 
#if defined(HPM_IP_FEATURE_SDM_TIMESTAMP_FUNC) && (HPM_IP_FEATURE_SDM_TIMESTAMP_FUNC)
void sdm_config_channel_filter_timestamp(SDM_Type *ptr, uint8_t ch_index, sdm_filter_timestamp_config_t *timestamp_config);
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* HPM_SDM_DRV_H */