sdrv_rtc.h

Go to the documentation of this file.

 
#ifndef _SDRV_RTC_H_
#define _SDRV_RTC_H_
 
#include <stdint.h>
#include <types.h>
#include <sdrv_common.h>
#include <reg.h>
#include <regs_base.h>
 
#define SDRV_RTC_REG_PARITY_ERR_ENABLE() \
    sdrv_rtc_reg_parity_err_int_enable(APB_RTC1_BASE); \
    sdrv_rtc_reg_parity_err_int_enable(APB_RTC2_BASE);
 
#define SDRV_RTC_REG_PARITY_ERR_DISABLE() \
    sdrv_rtc_reg_parity_err_int_disable(APB_RTC1_BASE); \
    sdrv_rtc_reg_parity_err_int_disable(APB_RTC2_BASE);
 
typedef int (*rtc_cb_t)(uint32_t irq, void *arg);
 
struct rtc_time {
    uint32_t tm_subsec;/* subseconds, unit millisecond, 0~999 */
    uint32_t tm_sec;   /* seconds, 0~61 */
    uint32_t tm_min;   /* minutes, 0~59 */
    uint32_t tm_hour;  /* hour, 0~23 */
    uint32_t tm_mday;  /* day, 1~31 */
    uint32_t tm_mon;   /* month, 0~11 */
    uint32_t tm_year;  /* years since 1900 */
    uint32_t tm_wday;  /* day since Sunday, 0~6 */
    uint32_t tm_yday;  /* days since Jan. 1, 0~365 */
    uint32_t tm_isdst; /* daylight saving time flag */
};
 
typedef enum sdrv_rtc_violation_enum {
    SDRV_RTC_VIO_NONE      = 0, /* rtc no violation */
    SDRV_RTC_VIO_OVERFLOW  = 1, /* rtc violation disable */
    SDRV_RTC_VIO_DISABLE   = 2, /* rtc violation overflow */
    SDRV_RTC_VIO_ALL       = 3, /* rtc violation overflow & disable */
} sdrv_rtc_violation_e;
 
typedef struct sdrv_rtc {
    paddr_t base;
    uint32_t wakeup_intr;    
    uint32_t periodic_intr;  
    uint32_t violation_intr; 
    rtc_cb_t cb;             
    sdrv_rtc_violation_e vio_mask; 
} sdrv_rtc_t;
 
struct rtc_wkalrm {
    unsigned char enable;
    unsigned char pending;
    struct rtc_time tm;
};
 
/* Define RTC WakeUp Enable Type */
typedef enum sdrv_rtc_wakeup_enable_type {
    SDRV_WKUP_ENABLE      = 0, /* Only enable wakeup */
    SDRV_WKUP_ENABLE_IRQ  = 1, /* Enable wakeup and IRQ */
    SDRV_WKUP_ENABLE_REQ  = 2, /* Enable wakeup and pmu requst */
    SDRV_WKUP_ENABLE_ALL  = 3, /* Enable wakeup, IRQ and pmu requst */
} sdrv_rtc_wakeup_enable_type_e;
 
typedef enum sdrv_general_purpose {
    SDRV_RTC_GP0, /* RTC general purpose register 0 */
    SDRV_RTC_GP1, /* RTC general purpose register 1 */
    SDRV_RTC_GP2, /* RTC general purpose register 2 */
    SDRV_RTC_GP3, /* RTC general purpose register 3 */
} sdrv_general_purpose_e;
 
enum sdrv_rtc_error {
    SDRV_RTC_STATUS_INVALID_RTC_TIME = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_RTC, 1), /* Invalid RTC Time */
    SDRV_RTC_STATUS_LOCK = SDRV_ERROR_STATUS(SDRV_STATUS_GROUP_RTC, 2),             /* RTC lock error */
};
 
static inline void sdrv_rtc_reg_parity_err_int_enable(uint32_t base)
{
    RMWREG32(base + 0x68U, 0, 1, 1);
}
 
static inline void sdrv_rtc_reg_parity_err_int_disable(uint32_t base)
{
    RMWREG32(base + 0x68U, 0, 1, 0);
}
 
static inline bool is_leap_year(uint32_t year)
{
    return (!(year % 4) && (year % 100)) || !(year % 400);
}
 
uint64_t rtc_to_epoch(struct rtc_time *tm);
 
status_t epoch_to_rtc(struct rtc_time *tm, uint64_t epoch_sec);
 
uint64_t rtc_to_epoch_ms(struct rtc_time *tm);
 
status_t epoch_ms_to_rtc(struct rtc_time *tm, uint64_t epoch_millisec);
 
status_t sdrv_rtc_enable(sdrv_rtc_t *dev, bool enable);
 
status_t sdrv_rtc_wakeup_enable(sdrv_rtc_t *dev,
                                sdrv_rtc_wakeup_enable_type_e type, bool enable);
 
bool sdrv_rtc_get_wakeup_status(sdrv_rtc_t *dev);
 
status_t sdrv_rtc_clear_wakeup_status(sdrv_rtc_t *dev);
 
sdrv_rtc_violation_e sdrv_rtc_get_violation_status(sdrv_rtc_t *dev);
 
status_t sdrv_rtc_clear_violation_status(sdrv_rtc_t *dev,
        sdrv_rtc_violation_e vio);
 
status_t sdrv_rtc_violation_intr_enable(sdrv_rtc_t *dev,
        sdrv_rtc_violation_e vio, bool en);
 
status_t sdrv_rtc_get_time(sdrv_rtc_t *dev, struct rtc_time *tm);
 
status_t sdrv_rtc_set_time(sdrv_rtc_t *dev, struct rtc_time *tm);
 
status_t sdrv_rtc_get_alarm(sdrv_rtc_t *dev, struct rtc_wkalrm *alrm);
 
status_t sdrv_rtc_set_alarm(sdrv_rtc_t *dev, struct rtc_wkalrm *alrm);
 
status_t sdrv_rtc_enable_alarm(sdrv_rtc_t *dev, bool enable);
 
status_t sdrv_rtc_enable_it(uint32_t source, void *arg, rtc_cb_t cb);
 
status_t sdrv_rtc_disable_it(uint32_t source);
 
uint32_t sdrv_rtc_read_general_purpose_reg(sdrv_rtc_t *dev, sdrv_general_purpose_e gp_num);
 
status_t sdrv_rtc_write_general_purpose_reg(sdrv_rtc_t *dev, sdrv_general_purpose_e gp_num, uint32_t value);
 
status_t sdrv_rtc_lock(sdrv_rtc_t *dev);
#endif /*_SDRV_RTC_H_*/