mcu_hi3321_watch/tjd/driver/rtc/rtc_port.c

/*----------------------------------------------------------------------------
 * Copyright (c) TJD Technologies Co., Ltd. 2024. All rights reserved.
 *
 * Description: rtc_port.c
 *
 * Author: luziquan@ss-tjd.com
 *
 * Create: 2024-07-12
 *--------------------------------------------------------------------------*/

#include "rtc_port.h"
#include "rtc.h"
#include "rtc_api.h"
#include "sql_setting.h"
#include "stdint.h"
#include "sys/time.h"
#include "sys_config.h"
#include "time.h"
#include <stdbool.h>

#define ENABLE_PRINT_INFO 1
#if ENABLE_PRINT_INFO
#define static_print_info(...) sys_rtc_log_i(__VA_ARGS__)  // 一般信息打印宏控制
#define static_print_warn(...) sys_rtc_log_w(__VA_ARGS__)  // 警告信息打印一般常开
#define static_print_error(...) sys_rtc_log_e(__VA_ARGS__) // 错误信息打印一般常开
#else
#define static_print_info(...)
#define static_print_warn(...)
#define static_print_error(...)
#endif

static bool rtc_init_flag = false;

uint32_t rtc_host_peripheral_init(uint64_t *timestamp)
{
    rtc_init_flag = true;

    sql_setting_get_system_time(timestamp);

    return RTC_SUCC;
}

uint32_t rtc_host_peripheral_deinit(void)
{
    static_print_info("rtc_host_peripheral_deinit success");

    rtc_init_flag = false;

    return RTC_SUCC;
}

uint32_t rtc_set_timestamp(const uint64_t timestamp)
{
    uint32_t ret = RTC_SUCC;
    struct timeval tv = {0};
    struct timezone tz = {0};

    if (rtc_init_flag == false) {
        static_print_error("rtc_host_peripheral_init failed");
        return RTC_FAIL;
    }

    tv.tv_sec = timestamp;
    tz.tz_minuteswest = sql_setting_get_zone();
    ret = settimeofday(&tv, &tz);
    if (ret != RTC_SUCC) {
        static_print_error("settimeofday failed, ret = %x", ret);
        return ret;
    }

    return RTC_SUCC;
}

uint32_t rtc_set_ms_timestamp(const uint64_t timestamp_ms)
{
    uint32_t ret = RTC_SUCC;
    struct timeval tv = {0};
    struct timezone tz = {0};

    if (rtc_init_flag == false) {
        static_print_error("rtc_host_peripheral_init failed");
        return RTC_FAIL;
    }

    tv.tv_sec = timestamp_ms / 1000;
    tv.tv_usec = timestamp_ms % 1000;
    tz.tz_minuteswest = sql_setting_get_zone();
    ret = settimeofday(&tv, &tz);
    if (ret != RTC_SUCC) {
        static_print_error("settimeofday failed, ret = %x", ret);
        return ret;
    }

    return RTC_SUCC;
}

uint32_t rtc_get_timestamp(uint64_t *timestamp)
{
    uint32_t ret = RTC_SUCC;
    struct timeval tv = {0};

    if (rtc_init_flag == false) {
        static_print_error("rtc_host_peripheral_init failed");
        return RTC_FAIL;
    }

    ret = gettimeofday(&tv, NULL);
    if (ret != RTC_SUCC) {
        *timestamp = 0;
        static_print_error("gettimeofday failed, ret = %x", ret);
        return ret;
    }
    *timestamp = tv.tv_sec + rtc_get_diff();

    return RTC_SUCC;
}

uint32_t rtc_get_ms_timestamp(uint64_t *timestamp_ms)
{
    uint32_t ret = RTC_SUCC;
    struct timeval tv = {0};

    if (rtc_init_flag == false) {
        static_print_error("rtc_host_peripheral_init failed");
        return RTC_FAIL;
    }

    ret = gettimeofday(&tv, NULL);
    if (ret != RTC_SUCC) {
        *timestamp_ms = 0;
        static_print_error("gettimeofday failed, ret = %x", ret);
        return ret;
    }

    *timestamp_ms = ((uint64_t)tv.tv_sec + rtc_get_diff()) * 1000 + (uint64_t)tv.tv_usec / 1000;

    return RTC_SUCC;
}

uint32_t rtc_set_diff_time_of_sec(const int64_t secs)
{
    sql_setting_set_time_diff(secs);

    return RTC_SUCC;
}

int32_t rtc_get_diff(void)
{
    return sql_setting_get_time_diff();
}

uint32_t rtc_save_time_of_sql(uint64_t timestamp)
{
    sql_setting_set_system_time(timestamp);
    return RTC_SUCC;
}

#if ALARM_ENABLE
static rtc_handle_t g_rtc_handle;
static rtc_alarm_callback g_rtc_callback = NULL;
static uint64_t alarm_time = 0;

uint32_t rtc_alarm_init(void)
{
    uint32_t ret = RTC_SUCC;

    ret = uapi_rtc_init();
    if (ret != RTC_SUCC) {
        static_print_error("uapi_rtc_init failed, ret = %x", ret);
        return ret;
    }

    ret = uapi_rtc_adapter(RTC_0, 3, 3);
    if (ret != RTC_SUCC) {
        static_print_error("Tuapi_rtc_adapter fail 0x%x", ret);
        return ret;
    }

    ret = uapi_rtc_create(RTC_0, &g_rtc_handle);
    if (ret != RTC_SUCC) {
        static_print_error("uapi_rtc_create 0x%x", ret);
        return ret;
    }

    return RTC_SUCC;
}

uint32_t rtc_alarm_deinit(void)
{
    uint32_t ret = RTC_SUCC;

    return RTC_SUCC;
}

uint32_t register_rtc_alarm_callback(rtc_alarm_callback callback)
{
    g_rtc_callback = callback;
    return RTC_SUCC;
}

uint32_t set_alarm_time(struct tm *time)
{
    uint32_t ret = RTC_SUCC;
    uint64_t timestamp = 0;
    struct timeval tv = {0};

    if (rtc_init_flag == false) {
        static_print_error("rtc_host_peripheral_init failed");
        return RTC_FAIL;
    }

    ret = rtc_time_valid(time);
    if (ret != RTC_SUCC) {
        static_print_error("rtc_time_valid failed, ret = %x", ret);
        return ret;
    }

    return ret;
}

static void rtc_callback_handle(uintptr_t data)
{
    unused(data);
    uapi_rtc_start(g_rtc_handle, 1000, rtc_callback_handle, NULL);
}

uint32_t ret_alarm_start(void)
{
    uint32_t ret = RTC_SUCC;

    if (g_rtc_handle == NULL) {
        static_print_error("g_rtc_handle is NULL");
        return RTC_FAIL;
    }

    ret = uapi_rtc_start(g_rtc_handle, 1000, rtc_callback_handle, NULL);
    if (ret != RTC_SUCC) {
        static_print_error("uapi_rtc_start failed, ret = %x", ret);
        return ret;
    }

    return RTC_SUCC;
}
#endif