core_feature_timer.h

/*
 * Copyright (c) 2019 Nuclei Limited. All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the License); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef __CORE_FEATURE_TIMER_H__
#define __CORE_FEATURE_TIMER_H__
/*
 * System Timer Feature Configuration Macro:
 * 1. __SYSTIMER_PRESENT: Must, Define whether Private System Timer is present or not.
 *   * 0: Not present
 *   * 1: Present
 * 2. __SYSTIMER_BASEADDR: Must, Define the base address of the System Timer.
 * 3. __SYSTIMER_HARTID:  Optional, Define the system timer hart index of the cpu, important for case when cpu hartid and cpu hart index are different, only set it if your cpu is single core.
 */
#ifdef __cplusplus
extern "C" {
#endif
 
#include "core_feature_base.h"
 
#if defined(__SYSTIMER_PRESENT) && (__SYSTIMER_PRESENT == 1)
typedef struct {
    __IOM uint64_t MTIMER;                  
    __IOM uint64_t MTIMERCMP;               
    __IOM uint32_t RESERVED0[0x3F7];        
    __IOM uint32_t MTIME_SRW_CTRL;          
    __IOM uint32_t MSFTRST;                 
    __IOM uint32_t SSIP;                    
    __IOM uint32_t MTIMECTL;                
    __IOM uint32_t MSIP;                    
} SysTimer_Type;
 
/* Timer Control / Status Register Definitions */
#define SysTimer_MTIMECTL_TIMESTOP_Pos      0U                                          
#define SysTimer_MTIMECTL_TIMESTOP_Msk      (1UL << SysTimer_MTIMECTL_TIMESTOP_Pos)     
#define SysTimer_MTIMECTL_CMPCLREN_Pos      1U                                          
#define SysTimer_MTIMECTL_CMPCLREN_Msk      (1UL << SysTimer_MTIMECTL_CMPCLREN_Pos)     
#define SysTimer_MTIMECTL_CLKSRC_Pos        2U                                          
#define SysTimer_MTIMECTL_CLKSRC_Msk        (1UL << SysTimer_MTIMECTL_CLKSRC_Pos)       
#define SysTimer_MTIMECTL_HDBG_Pos          4U                                          
#define SysTimer_MTIMECTL_HDBG_Msk          (1UL << SysTimer_MTIMECTL_HDBG_Pos)         
#define SysTimer_MSIP_MSIP_Pos              0U                                          
#define SysTimer_MSIP_MSIP_Msk              (1UL << SysTimer_MSIP_MSIP_Pos)             
#define SysTimer_SSIP_SSIP_Pos              0U                                          
#define SysTimer_SSIP_SSIP_Msk              (1UL << SysTimer_SSIP_SSIP_Pos)             
#define SysTimer_MTIMER_Msk                 (0xFFFFFFFFFFFFFFFFULL)                     
#define SysTimer_MTIMERCMP_Msk              (0xFFFFFFFFFFFFFFFFULL)                     
#define SysTimer_MTIMECTL_Msk               (0xFFFFFFFFUL)                              
#define SysTimer_MSIP_Msk                   (0xFFFFFFFFUL)                              
#define SysTimer_MSFTRST_Msk                (0xFFFFFFFFUL)                              
#define SysTimer_MSFRST_KEY                 (0x80000A5FUL)                              
#define SysTimer_CLINT_MSIP_OFS             (0x1000UL)                                  
#define SysTimer_CLINT_MTIMECMP_OFS         (0x5000UL)                                  
#define SysTimer_CLINT_MTIME_OFS            (0xCFF8UL)                                  
#define SysTimer_CLINT_SSIP_OFS             (0xD000UL)                                  
#ifndef __SYSTIMER_BASEADDR
/* Base address of SYSTIMER(__SYSTIMER_BASEADDR) should be defined in <Device.h> */
#error "__SYSTIMER_BASEADDR is not defined, please check!"
#endif
/* System Timer Memory mapping of Device  */
#define SysTimer_BASE                       __SYSTIMER_BASEADDR                         
#define SysTimer                            ((SysTimer_Type *) SysTimer_BASE)           
/* System Timer Clint register base */
#define SysTimer_CLINT_MSIP_BASE(hartid)        (unsigned long)((SysTimer_BASE) + (SysTimer_CLINT_MSIP_OFS) + ((hartid) << 2))
#define SysTimer_CLINT_MTIMECMP_BASE(hartid)    (unsigned long)((SysTimer_BASE) + (SysTimer_CLINT_MTIMECMP_OFS) + ((hartid) << 3))
#define SysTimer_CLINT_MTIME_BASE               (unsigned long)((SysTimer_BASE) + (SysTimer_CLINT_MTIME_OFS))
#define SysTimer_CLINT_SSIP_BASE(hartid)        (unsigned long)((SysTimer_BASE) + (SysTimer_CLINT_SSIP_OFS) + ((hartid) << 2))
 /* end of group NMSIS_Core_SysTimer_Registers */
 
/* ##################################    SysTimer function  ############################################ */
#ifndef __SYSTIMER_HARTID
#define SysTimer_GetHartID()                    (__get_hart_index())
#else
#define SysTimer_GetHartID()                    (__SYSTIMER_HARTID)
#endif
 
#if defined(__SSTC_PRESENT) && (__SSTC_PRESENT == 1)
#ifndef __SYSTIMER_HARTID
#define SysTimer_GetHartID_S()                  (__get_hart_index_s())
#else
#define SysTimer_GetHartID_S()                  (__SYSTIMER_HARTID)
#endif
#endif
 
__STATIC_FORCEINLINE void SysTimer_SetLoadValue(uint64_t value)
{
#if __RISCV_XLEN == 32
    uint8_t *addr;
    addr = (uint8_t *)(&(SysTimer->MTIMER));
    __SW(addr, 0);      // prevent carry
    __SW(addr + 4, (uint32_t)(value >> 32));
    __SW(addr, (uint32_t)(value));
#else
    SysTimer->MTIMER = value;
#endif
}
 
__STATIC_FORCEINLINE uint64_t SysTimer_GetLoadValue(void)
{
#if __RISCV_XLEN == 32
    volatile uint32_t high0, low, high;
    uint64_t full;
    uint8_t *addr;
 
    addr = (uint8_t *)(&(SysTimer->MTIMER));
 
    high0 = __LW(addr + 4);
    low = __LW(addr);
    high = __LW(addr + 4);
    if (high0 != high) {
        low = __LW(addr);
    }
    full = (((uint64_t)high) << 32) | low;
    return full;
#else
    return SysTimer->MTIMER;
#endif
}
 
__STATIC_FORCEINLINE void SysTimer_SetHartCompareValue(uint64_t value, unsigned long hartid)
{
    if (hartid == 0) {
#if __RISCV_XLEN == 32
        uint8_t *addr;
        addr = (uint8_t *)(&(SysTimer->MTIMERCMP));
        __SW(addr, -1U);      // prevent load > timecmp
        __SW(addr + 4, (uint32_t)(value >> 32));
        __SW(addr, (uint32_t)(value));
#else
        SysTimer->MTIMERCMP = value;
#endif
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MTIMECMP_BASE(hartid));
#if __RISCV_XLEN == 32
        __SW(addr, -1U);      // prevent load > timecmp
        __SW(addr + 4, (uint32_t)(value >> 32));
        __SW(addr, (uint32_t)value);
#else
        __SD(addr, value);
#endif
    }
}
 
__STATIC_FORCEINLINE void SysTimer_SetCompareValue(uint64_t value)
{
    unsigned long hartid = SysTimer_GetHartID();
    SysTimer_SetHartCompareValue(value, hartid);
}
 
__STATIC_FORCEINLINE uint64_t SysTimer_GetHartCompareValue(unsigned long hartid)
{
    if (hartid == 0) {
        return SysTimer->MTIMERCMP;
    } else {
        uint64_t full;
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MTIMECMP_BASE(hartid));
#if __RISCV_XLEN == 32
        // MTIMECMP didn't increase
        uint32_t high, low;
 
        high = __LW(addr + 4);
        low = __LW(addr);
        full = (((uint64_t)high) << 32) | low;
#else
        full = __LD(addr);
#endif
        return full;
    }
}
 
__STATIC_FORCEINLINE uint64_t SysTimer_GetCompareValue(void)
{
    unsigned long hartid = SysTimer_GetHartID();
    return SysTimer_GetHartCompareValue(hartid);
}
 
__STATIC_FORCEINLINE void SysTimer_Start(void)
{
    SysTimer->MTIMECTL &= ~(SysTimer_MTIMECTL_TIMESTOP_Msk);
}
 
__STATIC_FORCEINLINE void SysTimer_Stop(void)
{
    SysTimer->MTIMECTL |= SysTimer_MTIMECTL_TIMESTOP_Msk;
}
 
__STATIC_FORCEINLINE void SysTimer_SetControlValue(uint32_t mctl)
{
    SysTimer->MTIMECTL = (mctl & SysTimer_MTIMECTL_Msk);
}
 
__STATIC_FORCEINLINE uint32_t SysTimer_GetControlValue(void)
{
    return (SysTimer->MTIMECTL & SysTimer_MTIMECTL_Msk);
}
 
__STATIC_FORCEINLINE void SysTimer_SetHartSWIRQ(unsigned long hartid)
{
    if (hartid == 0) {
        SysTimer->MSIP |= SysTimer_MSIP_MSIP_Msk;
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MSIP_BASE(hartid));
        __SW(addr, SysTimer_MSIP_MSIP_Msk);
    }
}
 
__STATIC_FORCEINLINE void SysTimer_SetSWIRQ(void)
{
    unsigned long hartid = SysTimer_GetHartID();
    SysTimer_SetHartSWIRQ(hartid);
}
 
__STATIC_FORCEINLINE void SysTimer_ClearHartSWIRQ(unsigned long hartid)
{
    if (hartid == 0) {
        SysTimer->MSIP &= ~SysTimer_MSIP_MSIP_Msk;
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MSIP_BASE(hartid));
        __SW(addr, 0);
    }
}
 
__STATIC_FORCEINLINE void SysTimer_ClearSWIRQ(void)
{
    unsigned long hartid = SysTimer_GetHartID();
    SysTimer_ClearHartSWIRQ(hartid);
}
 
__STATIC_FORCEINLINE uint32_t SysTimer_GetHartMsipValue(unsigned long hartid)
{
    if (hartid == 0) {
        return (uint32_t)(SysTimer->MSIP);
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MSIP_BASE(hartid));
        return __LW(addr);
    }
}
 
__STATIC_FORCEINLINE uint32_t SysTimer_GetMsipValue(void)
{
    unsigned long hartid = SysTimer_GetHartID();
    return SysTimer_GetHartMsipValue(hartid);
}
 
__STATIC_FORCEINLINE void SysTimer_SetHartMsipValue(uint32_t msip, unsigned long hartid)
{
    if (hartid == 0) {
        SysTimer->MSIP = (msip);
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MSIP_BASE(hartid));
        __SW(addr, msip);
    }
}
 
__STATIC_FORCEINLINE void SysTimer_SetMsipValue(uint32_t msip)
{
    unsigned long hartid = SysTimer_GetHartID();
    SysTimer_SetHartMsipValue(msip, hartid);
}
 
#if defined(__SSTC_PRESENT) && (__SSTC_PRESENT == 1)
__STATIC_FORCEINLINE void SysTimer_SetCompareValue_S(uint64_t value)
{
#if __RISCV_XLEN == 32
    __RV_CSR_WRITE(CSR_STIMECMP, -1U);      // prevent load > timecmp
    __RV_CSR_WRITE(CSR_STIMECMPH, (uint32_t)(value >> 32));
    __RV_CSR_WRITE(CSR_STIMECMP, (uint32_t)value);
#else
    __RV_CSR_WRITE(CSR_STIMECMP, value);
#endif
}
 
__STATIC_FORCEINLINE uint64_t SysTimer_GetCompareValue_S(void)
{
    uint64_t full;
#if __RISCV_XLEN == 32
    uint32_t high, low;
 
    high = __RV_CSR_READ(CSR_STIMECMPH);
    low = __RV_CSR_READ(CSR_STIMECMP);
    full = (((uint64_t)high) << 32) | low;
#else
    full = __RV_CSR_READ(CSR_STIMECMP);
#endif
    return full;
}
 
__STATIC_FORCEINLINE void SysTimer_SetHartSWIRQ_S(unsigned long hartid)
{
    if (hartid == 0) {
        SysTimer->SSIP |= SysTimer_SSIP_SSIP_Msk;
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_SSIP_BASE(hartid));
        __SW(addr, SysTimer_SSIP_SSIP_Msk);
    }
}
 
__STATIC_FORCEINLINE void SysTimer_SetSWIRQ_S(void)
{
    unsigned long hartid = SysTimer_GetHartID_S();
    SysTimer_SetHartSWIRQ_S(hartid);
}
 
__STATIC_FORCEINLINE void SysTimer_ClearHartSWIRQ_S(unsigned long hartid)
{
    if (hartid == 0) {
        SysTimer->SSIP &= ~SysTimer_SSIP_SSIP_Msk;
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_SSIP_BASE(hartid));
        __SW(addr, 0);
    }
}
 
__STATIC_FORCEINLINE void SysTimer_ClearSWIRQ_S(void)
{
    unsigned long hartid = SysTimer_GetHartID_S();
    SysTimer_ClearHartSWIRQ_S(hartid);
}
 
__STATIC_FORCEINLINE uint32_t SysTimer_GetHartSsipValue(unsigned long hartid)
{
    if (hartid == 0) {
        return (uint32_t)(SysTimer->SSIP);
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_SSIP_BASE(hartid));
        return __LW(addr);
    }
}
 
__STATIC_FORCEINLINE uint32_t SysTimer_GetSsipValue(void)
{
    unsigned long hartid = SysTimer_GetHartID_S();
    return SysTimer_GetHartSsipValue(hartid);
}
 
__STATIC_FORCEINLINE void SysTimer_SetHartSsipValue(uint32_t ssip, unsigned long hartid)
{
    if (hartid == 0) {
        SysTimer->SSIP = (ssip);
    } else {
        uint8_t *addr = (uint8_t *)(SysTimer_CLINT_SSIP_BASE(hartid));
        __SW(addr, ssip);
    }
}
 
__STATIC_FORCEINLINE void SysTimer_SetSsipValue(uint32_t ssip)
{
    unsigned long hartid = SysTimer_GetHartID();
    SysTimer_SetHartSsipValue(ssip, hartid);
}
 
__STATIC_FORCEINLINE void SysTimer_SendIPI_S(unsigned long hartid)
{
    uint8_t *addr = (uint8_t *)(SysTimer_CLINT_SSIP_BASE(hartid));
    __SW(addr, 1);
}
 
__STATIC_FORCEINLINE void SysTimer_ClearIPI_S(unsigned long hartid)
{
    uint8_t *addr = (uint8_t *)(SysTimer_CLINT_SSIP_BASE(hartid));
    __SW(addr, 0);
}
 
__STATIC_FORCEINLINE void SysTimer_EnableSSTC(void)
{
    __RV_CSR_SET(CSR_MCOUNTEREN, MCOUNTEREN_TIME);
#if __RISCV_XLEN == 32
    __RV_CSR_SET(CSR_MENVCFGH, MENVCFGH_STCE);
#else
    __RV_CSR_SET(CSR_MENVCFG, MENVCFG_STCE);
#endif
}
 
__STATIC_FORCEINLINE void SysTimer_DisableSSTC(void)
{
    __RV_CSR_CLEAR(CSR_MCOUNTEREN, MCOUNTEREN_TIME);
#if __RISCV_XLEN == 32
    __RV_CSR_CLEAR(CSR_MENVCFGH, MENVCFGH_STCE);
#else
    __RV_CSR_CLEAR(CSR_MENVCFG, MENVCFG_STCE);
#endif
}
#endif
 
__STATIC_FORCEINLINE void SysTimer_SoftwareReset(void)
{
    SysTimer->MSFTRST = SysTimer_MSFRST_KEY;
    // will reset cpu, never return
    while (1);
}
 
__STATIC_FORCEINLINE void SysTimer_SendIPI(unsigned long hartid)
{
    uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MSIP_BASE(hartid));
    __SW(addr, 1);
}
 
__STATIC_FORCEINLINE void SysTimer_ClearIPI(unsigned long hartid)
{
    uint8_t *addr = (uint8_t *)(SysTimer_CLINT_MSIP_BASE(hartid));
    __SW(addr, 0);
}
 
__STATIC_FORCEINLINE void SysTimer_EnableSAccess(void)
{
    SysTimer->MTIME_SRW_CTRL = 0;
}
 
__STATIC_FORCEINLINE void SysTimer_DisableSAccess(void)
{
    SysTimer->MTIME_SRW_CTRL = 1;
}
 
#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
 
__STATIC_INLINE uint32_t SysTick_Config(uint64_t ticks)
{
    uint64_t loadticks = SysTimer_GetLoadValue();
    SysTimer_SetCompareValue(ticks + loadticks);
 
#if defined(__ECLIC_PRESENT) && (__ECLIC_PRESENT == 1)
    ECLIC_SetShvIRQ(SysTimer_IRQn, ECLIC_NON_VECTOR_INTERRUPT);
    ECLIC_SetLevelIRQ(SysTimer_IRQn, 0);
    ECLIC_EnableIRQ(SysTimer_IRQn);
#endif
    return (0UL);
}
 
__STATIC_INLINE uint32_t SysTick_HartConfig(uint64_t ticks, unsigned long hartid)
{
    uint64_t loadticks = SysTimer_GetLoadValue();
    SysTimer_SetHartCompareValue(ticks + loadticks, hartid);
 
#if defined(__ECLIC_PRESENT) && (__ECLIC_PRESENT == 1)
    ECLIC_SetShvIRQ(SysTimer_IRQn, ECLIC_NON_VECTOR_INTERRUPT);
    ECLIC_SetLevelIRQ(SysTimer_IRQn, 0);
    ECLIC_EnableIRQ(SysTimer_IRQn);
#endif
    return (0UL);
}
 
__STATIC_FORCEINLINE uint32_t SysTick_Reload(uint64_t ticks)
{
    uint64_t cur_ticks = SysTimer_GetLoadValue();
 
    uint64_t reload_ticks = ticks + cur_ticks;
 
    SysTimer_SetCompareValue(reload_ticks);
 
    return (0UL);
}
 
__STATIC_FORCEINLINE uint32_t SysTick_HartReload(uint64_t ticks, unsigned long hartid)
{
    uint64_t cur_ticks = SysTimer_GetLoadValue();
    uint64_t reload_ticks = ticks + cur_ticks;
 
    SysTimer_SetHartCompareValue(reload_ticks, hartid);
 
    return (0UL);
}
 
#if defined(__SSTC_PRESENT) && (__SSTC_PRESENT == 1)
__STATIC_INLINE uint32_t SysTick_Config_S(uint64_t ticks)
{
    uint64_t loadticks = __get_rv_time();
    SysTimer_SetCompareValue_S(ticks + loadticks);
 
#if defined(__ECLIC_PRESENT) && (__ECLIC_PRESENT == 1)
#if defined(__TEE_PRESENT) && (__TEE_PRESENT == 1)
    ECLIC_SetShvIRQ_S(SysTimer_S_IRQn, ECLIC_NON_VECTOR_INTERRUPT);
    ECLIC_SetLevelIRQ_S(SysTimer_S_IRQn, 0);
    ECLIC_EnableIRQ_S(SysTimer_S_IRQn);
#endif
#endif
    return (0UL);
}
 
__STATIC_FORCEINLINE uint32_t SysTick_Reload_S(uint64_t ticks)
{
    uint64_t cur_ticks = __get_rv_time();
 
    uint64_t reload_ticks = ticks + cur_ticks;
 
    SysTimer_SetCompareValue_S(reload_ticks);
 
    return (0UL);
}
#endif
 
#endif /* defined(__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U) */ /* End of Doxygen Group NMSIS_Core_SysTimer */
 
#endif /* defined(__SYSTIMER_PRESENT) && (__SYSTIMER_PRESENT == 1) */
 
#ifdef __cplusplus
}
#endif
#endif /* __CORE_FEATURE_TIMER_H__ */