RIOT/cpu/esp32/periph/rtt_hw_sys.c

/*
 * Copyright (C) 2020 Gunar Schorcht
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */

/**
 * @ingroup     cpu_esp32
 * @ingroup     drivers_periph_rtt
 * @{
 *
 * @file
 * @brief       Low-level RTT driver implementation for ESP32
 *
 * @author      Gunar Schorcht <gunar@schorcht.net>
 *
 * @}
 */

/* RIOT headers have to be included before ESP-IDF headers! */
#include "cpu.h"
#include "esp/common_macros.h"
#include "irq_arch.h"
#include "log.h"
#include "periph/rtt.h"
#include "rtt_arch.h"
#include "syscalls.h"
#include "timex.h"

/* ESP-IDF headers */
#include "esp_attr.h"
#include "esp_sleep.h"
#include "rom/ets_sys.h"
#include "soc/timer_group_struct.h"
#include "xtensa/xtensa_api.h"

#define ENABLE_DEBUG 0
#include "debug.h"

#define TIMER_SYSTEM_GROUP      TIMERG0
#define TIMER_SYSTEM_INT_MASK   BIT(0)
#define TIMER_SYSTEM_INT_SRC    ETS_TG0_T0_LEVEL_INTR_SOURCE

#define SYS_US_TO_TICKS(us)     ((((uint64_t)us) << 15) / US_PER_SEC)
#define SYS_TICKS_TO_US(cnt)    (((uint64_t)cnt * US_PER_SEC) >> 15)

typedef struct {
    uint32_t alarm_set;     /**< alarm set at interface */
    rtt_cb_t alarm_cb;      /**< alarm callback */
    void *alarm_arg;        /**< argument for alarm callback */
} _sys_alarm_t;

static _sys_alarm_t _sys_alarm;

/* variables used to save counters during sleep or reboot */
static uint64_t RTC_BSS_ATTR _rtc_counter_saved;
static uint64_t RTC_BSS_ATTR _sys_counter_saved;

/* the offset of the system time to the RTC time in microseconds */
static uint64_t _sys_counter_offset;

/* forward declarations of functions required from RTC counter */
extern uint64_t _rtc_get_counter(void);
extern uint64_t _rtc_counter_to_us(uint64_t raw);

static void IRAM _sys_isr(void *arg);

static void _sys_init(void)
{
}

static void _sys_poweron(void)
{
    /* route all interrupt sources to the same RTT level type interrupt */
    intr_matrix_set(PRO_CPU_NUM, TIMER_SYSTEM_INT_SRC, CPU_INUM_RTT);

    /* set interrupt handler and enable the CPU interrupt */
    xt_set_interrupt_handler(CPU_INUM_RTT, _sys_isr, NULL);
    xt_ints_on(BIT(CPU_INUM_RTT));
}

static void _sys_poweroff(void)
{
    /* reset interrupt handler and disable the CPU interrupt */
    xt_ints_off(BIT(CPU_INUM_RTT));
    xt_set_interrupt_handler(CPU_INUM_RTT, NULL, NULL);
}

static uint64_t _sys_get_counter(void)
{
    /* convert the 64-bit microsecond system time to 48-bit 32.768 kHz time */
    return SYS_US_TO_TICKS(system_get_time_64() + _sys_counter_offset) & RTT_HW_COUNTER_MAX;
}

static void _sys_set_alarm(uint32_t alarm, rtt_cb_t cb, void *arg)
{
    /* compute the time difference for 32.768 kHz as 32-bit value */
    uint32_t rtt_diff = alarm - _sys_get_counter();

    /*
     * convert the computed time difference for 32.768 kHz to a 64-bit
     * microsecond value and determine the alarm time for the 64-bit
     * microsecond system timer
     */
    uint64_t _sys_diff = SYS_TICKS_TO_US(rtt_diff);
    uint64_t _sys_time = system_get_time_64();
    uint64_t _sys_alarm_time = _sys_time + _sys_diff;

    DEBUG("%s alarm=%u rtt_diff=%u "
          "sys_diff=%llu sys_alarm=%llu @sys_time=%llu\n", __func__,
          alarm, rtt_diff, _sys_diff, _sys_alarm_time, _sys_time);

    /* save the alarm configuration for interrupt handling */
    _sys_alarm.alarm_set = alarm;
    _sys_alarm.alarm_cb = cb;
    _sys_alarm.alarm_arg = arg;

    /* set the timer value */
    TIMER_SYSTEM.alarm_high = (uint32_t)(_sys_alarm_time >> 32);
    TIMER_SYSTEM.alarm_low  = (uint32_t)(_sys_alarm_time & 0xffffffff);

    /* clear the bit in status and set the bit in interrupt enable */
    TIMER_SYSTEM_GROUP.int_clr_timers.val |= TIMER_SYSTEM_INT_MASK;
    TIMER_SYSTEM_GROUP.int_ena.val |= TIMER_SYSTEM_INT_MASK;

    /* enable the timer alarm */
    TIMER_SYSTEM.config.level_int_en = 1;
    TIMER_SYSTEM.config.alarm_en = 1;
}

static void _sys_clear_alarm(void)
{
    /* disable alarms first */
    TIMER_SYSTEM.config.level_int_en = 0;
    TIMER_SYSTEM.config.alarm_en = 0;

    /* clear the bit in interrupt enable and status register */
    TIMER_SYSTEM_GROUP.int_ena.val &= ~TIMER_SYSTEM_INT_MASK;
    TIMER_SYSTEM_GROUP.int_clr_timers.val |= TIMER_SYSTEM_INT_MASK;

    /* reset the alarm configuration for interrupt handling */
    _sys_alarm.alarm_set = 0;
    _sys_alarm.alarm_cb = NULL;
    _sys_alarm.alarm_arg = NULL;
}

static void _sys_save_counter(void)
{
    critical_enter();

    /* save counters for synchronization after wakeup or reboot */
    _rtc_counter_saved = _rtc_get_counter();
    _sys_counter_saved = system_get_time_64() + _sys_counter_offset;

    critical_exit();

    DEBUG("%s rtc_time_saved=%llu sys_time_saved=%llu\n", __func__,
          _rtc_counter_saved, _sys_counter_saved);
}

static void _sys_restore_counter(bool in_init)
{
    critical_enter();

    /* synchronize RTC counter and the 64-bit microsecond system timer */
    uint64_t _rtc_time_diff = _rtc_get_counter() - _rtc_counter_saved;
    _sys_counter_offset += _rtc_counter_to_us(_rtc_time_diff & RTT_HW_COUNTER_MAX);
    _sys_counter_offset += (in_init) ? _sys_counter_saved : 0;

    critical_exit();

    DEBUG("%s rtc_time_saved=%llu rtc_time_diff=%llu "
          "sys_time_saved=%llu sys_time_offset=%llu\n", __func__,
          _rtc_counter_saved, _rtc_time_diff,
          _sys_counter_saved, _sys_counter_offset);
}

static void IRAM _sys_isr(void *arg)
{
    if (!(TIMER_SYSTEM_GROUP.int_st_timers.val & TIMER_SYSTEM_INT_MASK)) {
        /* return in case of another timer interrupt */
        return;
    }

    /* disable alarms first */
    TIMER_SYSTEM.config.level_int_en = 0;
    TIMER_SYSTEM.config.alarm_en = 0;

    /* clear the bit in interrupt enable and status register */
    TIMER_SYSTEM_GROUP.int_ena.val &= ~TIMER_SYSTEM_INT_MASK;
    TIMER_SYSTEM_GROUP.int_clr_timers.val |= TIMER_SYSTEM_INT_MASK;

    /* save the lower 32 bit of the current counter value */
    uint32_t counter = _sys_get_counter();

    DEBUG("%s %u\n", __func__, counter);

    if (_sys_alarm.alarm_cb) {
        DEBUG("%s alarm %u\n", __func__, counter);

        rtt_cb_t alarm_cb = _sys_alarm.alarm_cb;
        void *alarm_arg = _sys_alarm.alarm_arg;

        /* clear the alarm first */
        _sys_alarm.alarm_cb = NULL;
        _sys_alarm.alarm_arg = NULL;

        /* call the alarm handler afterwards if callback was defined */
        alarm_cb(alarm_arg);
    }
}

const rtt_hw_driver_t _rtt_hw_sys_driver = {
        .init = _sys_init,
        .get_counter = _sys_get_counter,
        .set_alarm = _sys_set_alarm,
        .clear_alarm = _sys_clear_alarm,
        .poweron = _sys_poweron,
        .poweroff = _sys_poweroff,
        .save_counter = _sys_save_counter,
        .restore_counter = _sys_restore_counter,
};