/*
|
* Copyright (c) 2019-2023 Beijing Hanwei Innovation Technology Ltd. Co. and
|
* its subsidiaries and affiliates (collectly called MKSEMI).
|
*
|
* All rights reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without
|
* modification, are permitted provided that the following conditions are met:
|
*
|
* 1. Redistributions of source code must retain the above copyright notice,
|
* this list of conditions and the following disclaimer.
|
*
|
* 2. Redistributions in binary form, except as embedded into an MKSEMI
|
* integrated circuit in a product or a software update for such product,
|
* must reproduce the above copyright notice, this list of conditions and
|
* the following disclaimer in the documentation and/or other materials
|
* provided with the distribution.
|
*
|
* 3. Neither the name of MKSEMI nor the names of its contributors may be used
|
* to endorse or promote products derived from this software without
|
* specific prior written permission.
|
*
|
* 4. This software, with or without modification, must only be used with a
|
* MKSEMI integrated circuit.
|
*
|
* 5. Any software provided in binary form under this license must not be
|
* reverse engineered, decompiled, modified and/or disassembled.
|
*
|
* THIS SOFTWARE IS PROVIDED BY MKSEMI "AS IS" AND ANY EXPRESS OR IMPLIED
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
* DISCLAIMED. IN NO EVENT SHALL MKSEMI OR CONTRIBUTORS BE LIABLE FOR ANY
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*/
|
|
#include "mk_rtc.h"
|
#include "mk_clock.h"
|
#include "mk_reset.h"
|
#include "mk_trace.h"
|
#include "mk_sleep_timer.h"
|
#include "mk_trace.h"
|
|
#if RTC_FREE_COUNTER_EN
|
|
static struct RTC_HANDLE_T rtc_handle[RTC_MAX_NUM] = {
|
{
|
.base = RTC,
|
.alarm_irq = RTC_ALARM_IRQn,
|
.rtc_open_flag = 0,
|
},
|
};
|
|
int rtc_open(enum RTC_DEV_T id)
|
{
|
if (id >= RTC_MAX_NUM)
|
{
|
return DRV_ERROR;
|
}
|
|
// RTC counter clock source
|
uint32_t val = REG_READ(0x40000234);
|
REG_WRITE(0x40000234, val | (1U << 10));
|
|
// enable RTC clock
|
clock_enable(CLOCK_RTC);
|
rtc_handle[id].rtc_open_flag = 1;
|
|
if ((rtc_handle[id].base->CTRL & RTC_CTRL_START_MSK) == 0)
|
{
|
rtc_handle[id].base->CTRL = RTC_CTRL_START_MSK;
|
}
|
|
return DRV_OK;
|
}
|
|
int rtc_close(enum RTC_DEV_T id)
|
{
|
if (id >= RTC_MAX_NUM)
|
{
|
return DRV_ERROR;
|
}
|
|
if (rtc_handle[id].base->CTRL & RTC_CTRL_START_MSK)
|
{
|
rtc_handle[id].base->CTRL = 0;
|
}
|
rtc_handle[id].rtc_open_flag = 0;
|
|
NVIC_DisableIRQ(rtc_handle[id].alarm_irq);
|
NVIC_ClearPendingIRQ(rtc_handle[id].alarm_irq);
|
|
// disable RTC clock
|
clock_disable(CLOCK_RTC);
|
return DRV_OK;
|
}
|
|
uint32_t rtc_get(enum RTC_DEV_T id)
|
{
|
return rtc_handle[id].base->DATA;
|
}
|
|
int rtc_set_alarm(enum RTC_DEV_T id, uint32_t target, drv_callback_t callback)
|
{
|
ASSERT(id < RTC_MAX_NUM, "RTC wrong parameter");
|
if ((rtc_handle[id].base->CTRL & RTC_CTRL_START_MSK) == 0)
|
{
|
return DRV_ERROR;
|
}
|
|
rtc_handle[id].alarm_callback = callback;
|
rtc_handle[id].base->MATCH = target;
|
rtc_handle[id].base->INTR_CLR = RTC_INTR_CLR_MSK;
|
rtc_handle[id].base->INTR_EN = RTC_INTR_EN_MSK;
|
|
NVIC_SetPriority(rtc_handle[id].alarm_irq, IRQ_PRIORITY_NORMAL);
|
NVIC_ClearPendingIRQ(rtc_handle[id].alarm_irq);
|
NVIC_EnableIRQ(rtc_handle[id].alarm_irq);
|
|
return DRV_OK;
|
}
|
|
void rtc_clear_alarm(enum RTC_DEV_T id)
|
{
|
ASSERT(id < RTC_MAX_NUM, "RTC wrong parameter");
|
rtc_handle[id].base->INTR_EN = 0;
|
rtc_handle[id].base->INTR_CLR = RTC_INTR_CLR_MSK;
|
}
|
|
void RTC_ALARM_IRQHandler(void)
|
{
|
enum RTC_DEV_T id = RTC_ID0;
|
|
if (rtc_handle[id].base->INTR_STATUS & RTC_INTR_STATUS_MSK)
|
{
|
rtc_handle[id].base->INTR_CLR = RTC_INTR_CLR_MSK;
|
|
if (rtc_handle[id].alarm_callback != NULL)
|
{
|
uint32_t value = rtc_handle[id].base->DATA;
|
rtc_handle[id].alarm_callback(&value, 0);
|
}
|
}
|
}
|
|
#else
|
|
static struct RTC_HANDLE_T rtc_handle[RTC_MAX_NUM] = {
|
{
|
.base = RTC,
|
.tick_irq = RTC_TICK_IRQn,
|
.alarm_irq = RTC_ALARM_IRQn,
|
.tick_int_en = true,
|
.rtc_open_flag = 0,
|
},
|
};
|
|
static const uint8_t rtc_days_in_month[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
|
#define LEAP_NUM(y) ((y) / 4 - (y) / 100 + (y) / 400)
|
|
static inline int is_leap_year(uint16_t year)
|
{
|
return (!(year % 4) && (year % 100)) || !(year % 400);
|
}
|
|
/*
|
* The number of days in the month.
|
*/
|
static uint8_t rtc_month_days(uint8_t month, uint16_t year)
|
{
|
return rtc_days_in_month[month - 1] + (is_leap_year(year) && month == 2);
|
}
|
|
/*
|
* Does the rtc_time represent a valid date-time?
|
*/
|
static int rtc_check_parameter(struct RTC_TIME_T *time)
|
{
|
if (time == 0)
|
{
|
return DRV_ERROR;
|
}
|
|
if (time->year < 1970 || time->month < 1 || time->month > 12 || time->day < 1 || time->day > rtc_month_days(time->month, time->year) || time->hour >= 24 ||
|
time->minute >= 60 || time->second >= 60)
|
{
|
return DRV_ERROR;
|
}
|
|
return DRV_OK;
|
}
|
|
/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
|
* Assumes input in normal date format, i.e. 1980-12-31 23:59:59
|
* => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
|
*
|
* [For the Julian calendar (which was used in Russia before 1917,
|
* Britain & colonies before 1752, anywhere else before 1582,
|
* and is still in use by some communities) leave out the
|
* -year/100+year/400 terms, and add 10.]
|
*
|
*/
|
|
static uint32_t mktime(const uint32_t year0, const uint32_t mon0, const uint32_t day, const uint32_t hour, const uint32_t min, const uint32_t sec)
|
{
|
uint32_t mon = mon0, year = year0;
|
|
/* 1..12 -> 11,12,1..10 */
|
if (0 >= (int)(mon -= 2))
|
{
|
mon += 12; /* Puts Feb last since it has leap day */
|
year -= 1;
|
}
|
|
uint32_t val = (LEAP_NUM(year) + 367 * mon / 12 + day) + year * 365 - 719499;
|
val = val * 24 + hour;
|
val = val * 60 + min;
|
val = val * 60 + sec;
|
|
return val;
|
}
|
|
/*
|
* Convert Gregorian date to seconds since 01-01-1970 00:00:00.
|
*/
|
static uint32_t rtc_time_to_second(struct RTC_TIME_T *time)
|
{
|
uint32_t val = mktime(time->year, time->month, time->day, time->hour, time->minute, time->second);
|
return val;
|
}
|
|
/*
|
* Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
|
*/
|
static void rtc_second_to_time(uint32_t second, struct RTC_TIME_T *time)
|
{
|
uint8_t month;
|
uint16_t year;
|
int days;
|
|
days = second / 86400;
|
second -= (uint32_t)days * 86400;
|
|
year = 1970 + (uint16_t)(days / 365);
|
days -= (year - 1970) * 365 + LEAP_NUM(year - 1) - LEAP_NUM(1970 - 1);
|
if (days < 0)
|
{
|
year -= 1;
|
days += 365 + is_leap_year(year);
|
}
|
time->year = year;
|
|
for (month = 1; month < 12; month++)
|
{
|
int newdays = days - rtc_month_days(month, year);
|
if (newdays < 0)
|
{
|
break;
|
}
|
days = newdays;
|
}
|
time->month = month;
|
time->day = (uint8_t)days + 1;
|
|
time->hour = (uint8_t)(second / 3600);
|
second -= time->hour * 3600;
|
time->minute = (uint8_t)(second / 60);
|
time->second = (uint8_t)(second - time->minute * 60);
|
}
|
|
int rtc_open(enum RTC_DEV_T id, drv_callback_t callback)
|
{
|
if (id >= RTC_MAX_NUM)
|
{
|
return DRV_ERROR;
|
}
|
|
// enable RTC clock
|
clock_enable(CLOCK_RTC);
|
rtc_handle[id].rtc_open_flag = 1;
|
|
if (rtc_handle[id].tick_int_en)
|
{
|
rtc_handle[id].tick_callback = callback;
|
NVIC_SetPriority(rtc_handle[id].tick_irq, IRQ_PRIORITY_NORMAL);
|
NVIC_ClearPendingIRQ(rtc_handle[id].tick_irq);
|
NVIC_EnableIRQ(rtc_handle[id].tick_irq);
|
rtc_handle[id].base->TICK_INTR = RTC_TICK_INTR_EN_MSK;
|
}
|
|
if ((rtc_handle[id].base->CTRL & RTC_CTRL_START_MSK) == 0)
|
{
|
rtc_handle[id].base->CTRL = RTC_CTRL_START_MSK;
|
}
|
|
return DRV_OK;
|
}
|
|
int rtc_close(enum RTC_DEV_T id)
|
{
|
if (id >= RTC_MAX_NUM)
|
{
|
return DRV_ERROR;
|
}
|
|
if (rtc_handle[id].base->CTRL & RTC_CTRL_START_MSK)
|
{
|
rtc_handle[id].base->CTRL = 0;
|
}
|
rtc_handle[id].rtc_open_flag = 0;
|
|
if (rtc_handle[id].tick_int_en)
|
{
|
rtc_handle[id].base->TICK_INTR = 0;
|
NVIC_DisableIRQ(rtc_handle[id].tick_irq);
|
NVIC_ClearPendingIRQ(rtc_handle[id].tick_irq);
|
}
|
NVIC_DisableIRQ(rtc_handle[id].alarm_irq);
|
NVIC_ClearPendingIRQ(rtc_handle[id].alarm_irq);
|
|
// disable RTC clock
|
clock_disable(CLOCK_RTC);
|
return DRV_OK;
|
}
|
|
int rtc_set(enum RTC_DEV_T id, struct RTC_TIME_T *time)
|
{
|
if (rtc_check_parameter(time))
|
{
|
return DRV_ERROR;
|
}
|
|
uint32_t val = rtc_time_to_second(time);
|
rtc_handle[id].base->LOAD = val;
|
|
return DRV_OK;
|
}
|
|
int rtc_get(enum RTC_DEV_T id, struct RTC_TIME_T *time)
|
{
|
if (time == NULL)
|
{
|
return DRV_ERROR;
|
}
|
|
uint32_t val = rtc_handle[id].base->DATA;
|
rtc_second_to_time(val, time);
|
|
return DRV_OK;
|
}
|
|
int rtc_set_alarm(enum RTC_DEV_T id, struct RTC_TIME_T *time, drv_callback_t callback)
|
{
|
if (rtc_check_parameter(time))
|
{
|
return DRV_ERROR;
|
}
|
|
rtc_handle[id].alarm_callback = callback;
|
uint32_t value = rtc_time_to_second(time);
|
rtc_handle[id].base->MATCH = value;
|
rtc_handle[id].base->INTR_CLR = RTC_INTR_CLR_MSK;
|
rtc_handle[id].base->INTR_EN = RTC_INTR_EN_MSK;
|
|
NVIC_SetPriority(rtc_handle[id].alarm_irq, IRQ_PRIORITY_NORMAL);
|
NVIC_ClearPendingIRQ(rtc_handle[id].alarm_irq);
|
NVIC_EnableIRQ(rtc_handle[id].alarm_irq);
|
|
return DRV_OK;
|
}
|
|
void rtc_clear_alarm(enum RTC_DEV_T id)
|
{
|
rtc_handle[id].base->INTR_EN = 0;
|
rtc_handle[id].base->INTR_CLR = RTC_INTR_CLR_MSK;
|
}
|
|
void RTC_TICK_IRQHandler(void)
|
{
|
enum RTC_DEV_T id = RTC_ID0;
|
struct RTC_TIME_T time;
|
if (rtc_handle[id].base->TICK_INTR & RTC_TICK_INTR_STATUS_MSK)
|
{
|
rtc_handle[id].base->TICK_INTR |= RTC_TICK_INTR_CLR_MSK;
|
|
if (rtc_handle[id].tick_callback != NULL)
|
{
|
uint32_t value = rtc_handle[id].base->DATA;
|
rtc_second_to_time(value, &time);
|
rtc_handle[id].tick_callback(&time, 0);
|
}
|
}
|
}
|
|
void RTC_ALARM_IRQHandler(void)
|
{
|
enum RTC_DEV_T id = RTC_ID0;
|
struct RTC_TIME_T time;
|
|
if (rtc_handle[id].base->INTR_STATUS & RTC_INTR_STATUS_MSK)
|
{
|
rtc_handle[id].base->INTR_CLR = RTC_INTR_CLR_MSK;
|
|
if (rtc_handle[id].alarm_callback != NULL)
|
{
|
uint32_t value = rtc_handle[id].base->DATA;
|
rtc_second_to_time(value, &time);
|
rtc_handle[id].alarm_callback(&time, 0);
|
}
|
}
|
}
|
#endif
|
|
void rco32k_clk_calibrate(enum RCO32_MEAS_TIME_T time)
|
{
|
enum RTC_DEV_T id = RTC_ID0;
|
if (rtc_handle[id].rtc_open_flag == 0)
|
{
|
// enable RTC clock
|
clock_enable(CLOCK_RTC);
|
rtc_handle[id].base->CTRL = RTC_CTRL_START_MSK;
|
}
|
|
NVIC_SetPriority(RCO32K_CAL_IRQn, IRQ_PRIORITY_NORMAL);
|
NVIC_ClearPendingIRQ(RCO32K_CAL_IRQn);
|
NVIC_EnableIRQ(RCO32K_CAL_IRQn);
|
|
rtc_handle[id].base->MEASURE = 0;
|
rtc_handle[id].base->MEASURE = RTC_MEASURE_TIME(time) | RTC_MEASURE_EN_MSK;
|
}
|
|
void RCO32K_CAL_IRQHandler(void)
|
{
|
enum RTC_DEV_T id = RTC_ID0;
|
if ((rtc_handle[id].base->MEASURE & RTC_MEASURE_DONE_MSK) == 0)
|
{
|
uint32_t measure_cycles = 8U << GET_BIT_FIELD(rtc_handle[id].base->MEASURE, RTC_MEASURE_TIME_MSK, RTC_MEASURE_TIME_POS);
|
uint32_t measure_cnt = rtc_handle[id].base->MEASURE & RTC_MEASURE_CNT_MSK;
|
uint32_t pclk = clock_get_frequency(CLOCK_APB_CLK);
|
|
uint32_t ppm_target_cnt = measure_cycles * pclk / 32768;
|
int32_t ppm = (int32_t)((int32_t)(ppm_target_cnt - measure_cnt) * 1000000 / (int32_t)ppm_target_cnt);
|
sleep_timer_ppm_set(ppm);
|
LOG_INFO(TRACE_MODULE_DRIVER, "RCO32K ppm %d\r\n", ppm);
|
|
if (rtc_handle[id].rtc_open_flag == 0)
|
{
|
rtc_handle[id].base->CTRL = 0;
|
// disable RTC clock
|
clock_disable(CLOCK_RTC);
|
}
|
else
|
{
|
// 1s target count
|
uint32_t target_32s = (32 * pclk / measure_cnt) * measure_cycles;
|
uint32_t target = target_32s / 32;
|
uint8_t int_pol, frac_pol, frac_adj;
|
uint32_t int_adj;
|
|
frac_adj = target_32s % 32;
|
if (frac_adj > 0xf)
|
{
|
frac_pol = 1;
|
frac_adj = 32 - frac_adj;
|
target += 1;
|
}
|
else
|
{
|
frac_pol = 0;
|
}
|
|
if (target >= 0x7fff)
|
{
|
int_pol = 0;
|
int_adj = target - 0x7fff;
|
}
|
else
|
{
|
int_pol = 1;
|
int_adj = 0x7fff - target;
|
}
|
|
rtc_handle[id].base->CALIB = RTC_CALIB_EN_MSK | RTC_CALIB_INTEGER_POL(int_pol) | RTC_CALIB_INTEGER_ADJ(int_adj) | RTC_CALIB_FRACTION_POL(frac_pol) |
|
RTC_CALIB_FRACTION_ADJ(frac_adj);
|
}
|
}
|
}
|
