hw_rtc.h

Go to the documentation of this file.

 
#ifndef HW_RTC_H_
#define HW_RTC_H_
 
 
#if dg_configUSE_HW_RTC
 
#include <stdbool.h>
#include <stdint.h>
#include "sdk_defs.h"
 
#define HW_RTC_REG_GETF(reg, field) \
        ((RTC->reg & (RTC_##reg##_##field##_Msk)) >> (RTC_##reg##_##field##_Pos))
 
#define HW_RTC_REG_SETF(reg, field, val) \
        RTC->reg = ((RTC->reg & ~(RTC_##reg##_##field##_Msk)) | \
        ((RTC_##reg##_##field##_Msk) & ((val) << (RTC_##reg##_##field##_Pos))))
 
 
#define RTC_PDC_EVENT_PERIOD_MAX_VAL   0x1fff
 
#define RTC_ALL_STATUS_VALID   0xf
 
#define RTC_TIME_CLDR_STATUS_VALID   0x3
 
#define RTC_ALARM_TIME_CLDR_STATUS_VALID   0xc
 
typedef enum {
        RTC_LP_CLK_RC32K,
        RTC_LP_CLK_XTAL32K,
        RTC_LP_CLK_RCX,
} HW_RTC_LP_CLK;
 
typedef enum {
        RTC_24H_CLK = 0,        
        RTC_12H_CLK,            
} HW_RTC_HOUR_MODE;
 
typedef enum {
        RTC_DIV_DENOM_1000 = 0x0,    
        RTC_DIV_DENOM_1024 = 0x1,    
}HW_RTC_DIV_DENOM;
 
typedef enum {
 
        HW_RTC_INT_ALRM = RTC_RTC_INTERRUPT_MASK_REG_RTC_ALRM_INT_MSK_Msk,     
        HW_RTC_INT_MONTH = RTC_RTC_INTERRUPT_MASK_REG_RTC_MNTH_INT_MSK_Msk,    
        HW_RTC_INT_MDAY = RTC_RTC_INTERRUPT_MASK_REG_RTC_DATE_INT_MSK_Msk,     
        HW_RTC_INT_HOUR = RTC_RTC_INTERRUPT_MASK_REG_RTC_HOUR_INT_MSK_Msk,     
        HW_RTC_INT_MIN = RTC_RTC_INTERRUPT_MASK_REG_RTC_MIN_INT_MSK_Msk,       
        HW_RTC_INT_SEC = RTC_RTC_INTERRUPT_MASK_REG_RTC_SEC_INT_MSK_Msk,       
        HW_RTC_INT_HSEC = RTC_RTC_INTERRUPT_MASK_REG_RTC_HOS_INT_MSK_Msk,      
} HW_RTC_INTR;
 
typedef enum {
        HW_RTC_EVENT_ALRM = RTC_RTC_EVENT_FLAGS_REG_RTC_EVENT_ALRM_Msk,     
        HW_RTC_EVENT_MONTH = RTC_RTC_EVENT_FLAGS_REG_RTC_EVENT_MNTH_Msk,    
        HW_RTC_EVENT_MDAY = RTC_RTC_EVENT_FLAGS_REG_RTC_EVENT_DATE_Msk,     
        HW_RTC_EVENT_HOUR = RTC_RTC_EVENT_FLAGS_REG_RTC_EVENT_HOUR_Msk,     
        HW_RTC_EVENT_MIN = RTC_RTC_EVENT_FLAGS_REG_RTC_EVENT_MIN_Msk,       
        HW_RTC_EVENT_SEC = RTC_RTC_EVENT_FLAGS_REG_RTC_EVENT_SEC_Msk,       
        HW_RTC_EVENT_HSEC = RTC_RTC_EVENT_FLAGS_REG_RTC_EVENT_HOS_Msk,      
} HW_RTC_EVENT;
 
 
typedef enum {
        HW_RTC_ALARM_MONTH = RTC_RTC_ALARM_ENABLE_REG_RTC_ALARM_MNTH_EN_Msk,    
        HW_RTC_ALARM_MDAY = RTC_RTC_ALARM_ENABLE_REG_RTC_ALARM_DATE_EN_Msk,     
        HW_RTC_ALARM_HOUR = RTC_RTC_ALARM_ENABLE_REG_RTC_ALARM_HOUR_EN_Msk,     
        HW_RTC_ALARM_MIN = RTC_RTC_ALARM_ENABLE_REG_RTC_ALARM_MIN_EN_Msk,       
        HW_RTC_ALARM_SEC = RTC_RTC_ALARM_ENABLE_REG_RTC_ALARM_SEC_EN_Msk,       
        HW_RTC_ALARM_HSEC = RTC_RTC_ALARM_ENABLE_REG_RTC_ALARM_HOS_EN_Msk,      
} HW_RTC_ALARM_EN;
 
typedef enum {
        HW_RTC_VALID_CLNDR_ALM = RTC_RTC_STATUS_REG_RTC_VALID_CAL_ALM_Msk,     
        HW_RTC_VALID_TIME_ALM = RTC_RTC_STATUS_REG_RTC_VALID_TIME_ALM_Msk,    
        HW_RTC_VALID_CLNDR = RTC_RTC_STATUS_REG_RTC_VALID_CAL_Msk,     
        HW_RTC_VALID_TIME = RTC_RTC_STATUS_REG_RTC_VALID_TIME_Msk,     
} HW_RTC_STATUS;
 
typedef enum {
        HW_RTC_VALID_ENTRY = 0x1,        
        HW_RTC_INVALID_TIME_HOUR_MODE_ALM = 0x3,  
        HW_RTC_INVALID_CLNDR_ALM = 0x7,  
        HW_RTC_INVALID_TIME_ALM = 0xB,   
        HW_RTC_INVALID_CLNDR = 0xD,      
        HW_RTC_INVALID_TIME = 0xE,       
        HW_RTC_INVALID_TIME_CLNDR = 0xC, 
} HW_RTC_SET_REG_STATUS;
 
typedef void (*hw_rtc_interrupt_cb)(uint8_t event);
 
typedef struct {
        uint16_t year;   
        uint8_t month;   
        uint8_t mday;    
        uint8_t wday;    
} hw_rtc_calendar_t;
 
typedef struct {
        uint8_t month;   
        uint8_t mday;    
} hw_rtc_alarm_calendar_t;
 
typedef struct {
        uint8_t hour_mode;     
        bool pm_flag;          
        uint8_t hour;          
        uint8_t minute;        
        uint8_t sec;           
        uint8_t hsec;          
} hw_rtc_time_t;
 
typedef struct {
        bool      pdc_evt_en;      
        uint16_t  pdc_evt_period;  
} hw_rtc_config_pdc_evt_t;
 
 
void hw_rtc_config_RTC_to_PDC_evt(const hw_rtc_config_pdc_evt_t *cfg);
 
void hw_rtc_register_intr(hw_rtc_interrupt_cb handler, uint8_t mask);
 
 
void hw_rtc_unregister_intr(void);
 
HW_RTC_SET_REG_STATUS hw_rtc_set_time_clndr(const hw_rtc_time_t *time, const hw_rtc_calendar_t *clndr);
 
__STATIC_INLINE void hw_rtc_set_time_bcd(uint32_t time_bcd)
{
        RTC->RTC_TIME_REG = time_bcd;
}
 
__STATIC_INLINE void hw_rtc_set_clndr_bcd(uint32_t clndr_bcd)
{
        RTC->RTC_CALENDAR_REG = clndr_bcd;
}
 
void hw_rtc_get_time_clndr(hw_rtc_time_t *time, hw_rtc_calendar_t *clndr);
 
__STATIC_INLINE uint32_t hw_rtc_get_time_bcd(void)
{
        return RTC->RTC_TIME_REG;
}
 
__STATIC_INLINE uint32_t hw_rtc_get_clndr_bcd(void)
{
        return RTC->RTC_CALENDAR_REG;
}
 
__STATIC_INLINE void hw_rtc_time_start(void)
{
        HW_RTC_REG_SETF(RTC_CONTROL_REG, RTC_TIME_DISABLE, 0);
}
 
__STATIC_INLINE void hw_rtc_time_stop(void)
{
        HW_RTC_REG_SETF(RTC_CONTROL_REG, RTC_TIME_DISABLE, 1);
}
 
__STATIC_INLINE void hw_rtc_clndr_start(void)
{
        HW_RTC_REG_SETF(RTC_CONTROL_REG, RTC_CAL_DISABLE, 0);
}
 
__STATIC_INLINE void hw_rtc_clndr_stop(void)
{
        HW_RTC_REG_SETF(RTC_CONTROL_REG, RTC_CAL_DISABLE, 1);
}
 
__STATIC_INLINE void hw_rtc_start(void)
{
        RTC->RTC_CONTROL_REG = 0x0;
}
 
__STATIC_INLINE void hw_rtc_stop(void)
{
        RTC->RTC_CONTROL_REG = 0x3;
}
 
HW_RTC_SET_REG_STATUS hw_rtc_set_alarm(const hw_rtc_time_t *time, const hw_rtc_alarm_calendar_t *clndr, const uint8_t mask);
 
__STATIC_INLINE void hw_rtc_set_alarm_time_bcd(uint32_t time_bcd)
{
        RTC->RTC_TIME_ALARM_REG = time_bcd;
}
 
__STATIC_INLINE void hw_rtc_set_alarm_clndr_bcd(uint32_t clndr_bcd)
{
        RTC->RTC_CALENDAR_ALARM_REG = clndr_bcd;
}
 
void hw_rtc_get_alarm(hw_rtc_time_t *time, hw_rtc_alarm_calendar_t *clndr, uint8_t *mask);
 
__STATIC_INLINE uint32_t hw_rtc_get_alarm_time_bcd(void)
{
        return RTC->RTC_TIME_ALARM_REG;
}
 
__STATIC_INLINE uint32_t hw_rtc_get_alarm_clndr_bcd(void)
{
        return RTC->RTC_CALENDAR_ALARM_REG;
}
 
 
__STATIC_INLINE void hw_rtc_alarm_enable(const uint8_t mask)
{
        RTC->RTC_ALARM_ENABLE_REG = mask;
}
 
__STATIC_INLINE uint8_t hw_rtc_get_alarm_enable_msk(void)
{
        return RTC->RTC_ALARM_ENABLE_REG;
}
 
__STATIC_INLINE void hw_rtc_interrupt_enable(const uint8_t mask)
{
        RTC->RTC_INTERRUPT_ENABLE_REG = mask;
}
 
__STATIC_INLINE void hw_rtc_interrupt_disable(const uint8_t mask)
{
        RTC->RTC_INTERRUPT_DISABLE_REG = mask;
}
 
__STATIC_INLINE uint8_t hw_rtc_get_event_flags(void)
{
        return RTC->RTC_EVENT_FLAGS_REG;
}
 
__STATIC_INLINE uint8_t hw_rtc_get_interrupt_mask(void)
{
        return RTC->RTC_INTERRUPT_MASK_REG;
}
 
__STATIC_INLINE void hw_rtc_set_hour_clk_mode(HW_RTC_HOUR_MODE mode)
{
        ASSERT_WARNING(mode == RTC_24H_CLK || mode == RTC_12H_CLK);
        RTC->RTC_HOUR_MODE_REG = (mode == RTC_12H_CLK) ? 1 : 0;
}
 
__STATIC_INLINE HW_RTC_HOUR_MODE hw_rtc_get_hour_clk_mode(void)
{
        return ((HW_RTC_HOUR_MODE)RTC->RTC_HOUR_MODE_REG);
}
 
__STATIC_INLINE uint8_t hw_rtc_get_status(void)
{
        return RTC->RTC_STATUS_REG;
}
 
__STATIC_INLINE void hw_rtc_set_keep_reg_on_reset(bool keep)
{
        RTC->RTC_KEEP_RTC_REG = keep;
}
 
__STATIC_INLINE bool hw_rtc_get_keep_reg_on_reset(void)
{
        return RTC->RTC_KEEP_RTC_REG;
}
 
__STATIC_INLINE void hw_rtc_pdc_event_enable(void)
{
        HW_RTC_REG_SETF(RTC_EVENT_CTRL_REG, RTC_PDC_EVENT_EN, 1);
}
 
__STATIC_INLINE void hw_rtc_pdc_event_disable(void)
{
        HW_RTC_REG_SETF(RTC_EVENT_CTRL_REG, RTC_PDC_EVENT_EN, 0);
}
 
__STATIC_INLINE bool hw_rtc_get_pdc_event_cntrl(void)
{
        return HW_RTC_REG_GETF(RTC_EVENT_CTRL_REG, RTC_PDC_EVENT_EN);
}
 
 
__STATIC_INLINE void hw_rtc_set_pdc_event_period(uint16_t period)
{
        ASSERT_WARNING(RTC_PDC_EVENT_PERIOD_MAX_VAL >= period);
        RTC->RTC_PDC_EVENT_PERIOD_REG = period;
}
 
__STATIC_INLINE uint16_t hw_rtc_get_pdc_event_period(void)
{
        return RTC->RTC_PDC_EVENT_PERIOD_REG;
}
 
__STATIC_INLINE bool hw_rtc_pdc_event_clear(void)
{
        return RTC->RTC_PDC_EVENT_CLEAR_REG;
}
 
 
__STATIC_INLINE uint16_t hw_rtc_get_pdc_event_cnt(void)
{
        return RTC->RTC_PDC_EVENT_CNT_REG;
}
 
__STATIC_INLINE void hw_rtc_reset(void)
{
        uint8_t temp_reg;
        temp_reg = RTC->RTC_INTERRUPT_MASK_REG;
        RTC->RTC_INTERRUPT_DISABLE_REG = 0xff;  // Mask all interrupts to avoid trigger due to reset
        REG_SETF(CRG_TOP, CLK_RTCDIV_REG, RTC_RESET_REQ, 1);
        REG_SETF(CRG_TOP, CLK_RTCDIV_REG, RTC_RESET_REQ, 0);
        RTC->RTC_INTERRUPT_ENABLE_REG = ~temp_reg & 0x7f;  // restore interrupt mask
}
 
__STATIC_INLINE void hw_rtc_reset_set(void)
{
        REG_SETF(CRG_TOP, CLK_RTCDIV_REG, RTC_RESET_REQ, 1);
}
 
__STATIC_INLINE void hw_rtc_reset_clear(void)
{
        REG_SETF(CRG_TOP, CLK_RTCDIV_REG, RTC_RESET_REQ, 0);
}
 
__STATIC_INLINE void hw_rtc_clk_config(HW_RTC_DIV_DENOM div_denom, uint16_t div_int, uint16_t div_frac)
{
        uint32_t tmp = CRG_TOP->CLK_RTCDIV_REG;
 
        REG_SET_FIELD(CRG_TOP, CLK_RTCDIV_REG, RTC_DIV_DENOM, tmp, div_denom);
        REG_SET_FIELD(CRG_TOP, CLK_RTCDIV_REG, RTC_DIV_INT, tmp, div_int);
        REG_SET_FIELD(CRG_TOP, CLK_RTCDIV_REG, RTC_DIV_FRAC, tmp, div_frac);
 
        CRG_TOP->CLK_RTCDIV_REG = tmp;
}
 
__STATIC_INLINE void hw_rtc_clock_enable(void)
{
        REG_SETF(CRG_TOP, CLK_RTCDIV_REG, RTC_DIV_ENABLE, 1);
}
 
#endif /* dg_configUSE_HW_RTC */
#endif /* HW_RTC_H_ */