core_feature_cache.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_CACHE_H__
#define __CORE_FEATURE_CACHE_H__
/*
 * Cache Feature Configuration Macro:
 * 1. __ICACHE_PRESENT:  Define whether I-Cache Unit is present or not.
 *   * 0: Not present
 *   * 1: Present
 * 2. __DCACHE_PRESENT:  Define whether D-Cache Unit is present or not.
 *   * 0: Not present
 *   * 1: Present
 * 3. __CCM_PRESENT:  Define whether Nuclei Cache Control and Maintainence(CCM) Unit is present or not.
 *   * 0: Not present
 *   * 1: Present
 * 4. __SMPCC_PRESENT:  Define whether SMP & Cluster Cache Unit is present or not.
 *   * 0: Not present
 *   * 1: Present
 * 5. __SMPCC_BASEADDR:  Base address of the SMP & Cluster Cache unit.
 */
#ifdef __cplusplus
 extern "C" {
#endif
 
#include "core_feature_base.h"
 
 
#if defined(__CCM_PRESENT) && (__CCM_PRESENT == 1)
 
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
typedef struct {
    __IM uint8_t RESERVED0[16];     
    __IOM uint32_t CC_CTRL;         
    __IOM uint32_t CC_mCMD;         
    __IM uint8_t RESERVED1[168];    
    __IOM uint32_t CC_sCMD;         
    __IOM uint32_t CC_uCMD;         
    __IM uint8_t RESERVED2[20];     
    __IOM uint32_t CC_INVALID_ALL;  
} SMPCC_CMD_Type;
 
#define SMPCC_CMD_CTRL_SUP_EN_Pos                   9U                                      
#define SMPCC_CMD_CTRL_SUP_EN_Msk                   (0x1UL << SMPCC_CMD_CTRL_SUP_EN_Pos)    
#define SMPCC_CMD_CTRL_SUP_EN_ENABLE                1U                                      
#define SMPCC_CMD_CTRL_SUP_EN_DISABLE               0U                                      
#define SMPCC_CMD_CTRL_USE_EN_Pos                   10U                                     
#define SMPCC_CMD_CTRL_USE_EN_Msk                   (0x1UL << SMPCC_CMD_CTRL_USE_EN_Pos)    
#define SMPCC_CMD_CTRL_USE_EN_ENABLE                1U                                      
#define SMPCC_CMD_CTRL_USE_EN_DISABLE               0U                                      
#define SMPCC_CMD_xCMD_CMD_Pos                      0U                                      
#define SMPCC_CMD_xCMD_CMD_Msk                      (0x1FUL << SMPCC_CMD_xCMD_CMD_Pos)      
#define SMPCC_CMD_xCMD_CMD_WB_ALL                   0x7U                                    
#define SMPCC_CMD_xCMD_CMD_WBINVAL_ALL              0x6U                                    
#define SMPCC_CMD_xCMD_STATUS_Pos                   23U                                     
#define SMPCC_CMD_xCMD_STATUS_Msk                   (0x7UL << SMPCC_CMD_xCMD_STATUS_Pos)    
#define SMPCC_CMD_xCMD_RESULT_Pos                   26U                                     
#define SMPCC_CMD_xCMD_RESULT_Msk                   (0x1FUL << SMPCC_CMD_xCMD_RESULT_Pos)   
#define SMPCC_CMD_xCMD_RESULT_SUCCESS               0x0U                                    
#define SMPCC_CMD_xCMD_RESULT_ENTRY_EXCEED_LIMIT    0x1U                                    
#define SMPCC_CMD_xCMD_RESULT_REFILL_BUS_ERROR      0x3U                                    
#define SMPCC_CMD_xCMD_RESULT_ECC_ERROR             0x4U                                    
#define SMPCC_CMD_xCMD_RESULT_CPBACK_BUS_ERROR      0x5U                                    
#define SMPCC_CMD_xCMD_COMPLETE_Pos                 31U                                     
#define SMPCC_CMD_xCMD_COMPLETE_Msk                 (0x1UL << SMPCC_CMD_xCMD_COMPLETE_Pos)  
#define SMPCC_CMD_INVALID_ALL_Pos                   0U                                      
#define SMPCC_CMD_INVALID_ALL_Msk                   (0x1UL << SMPCC_CMD_INVALID_ALL_Pos)    
#ifndef __SMPCC_BASEADDR
/* Base address of SMPCC(__SMPCC_BASEADDR) should be defined in <Device.h> */
#error "__SMPCC_BASEADDR is not defined, please check!"
#endif
 
/* SMPCC CMD registers Memory mapping of Device */
#define SMPCC_CMD_BASE          __SMPCC_BASEADDR                    
#define SMPCC_CMD               ((SMPCC_CMD_Type *)SMPCC_CMD_BASE)   /* End of Doxygen Group NMSIS_Core_CCache */
#endif /* #if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
 
/* ##########################  Cache functions  #################################### */
typedef enum CCM_OP_FINFO {
    CCM_OP_SUCCESS = 0x0,               
    CCM_OP_EXCEED_ERR = 0x1,            
    CCM_OP_PERM_CHECK_ERR = 0x2,        
    CCM_OP_REFILL_BUS_ERR = 0x3,        
    CCM_OP_ECC_ERR = 0x4                
} CCM_OP_FINFO_Type;
 
typedef enum CCM_CMD {
    CCM_DC_INVAL = 0x0,                 
    CCM_DC_WB = 0x1,                    
    CCM_DC_WBINVAL = 0x2,               
    CCM_DC_LOCK = 0x3,                  
    CCM_DC_UNLOCK = 0x4,                
    CCM_DC_WBINVAL_ALL = 0x6,           
    CCM_DC_WB_ALL = 0x7,                
    CCM_DC_INVAL_ALL = 0x17,            
    CCM_IC_INVAL = 0x8,                 
    CCM_IC_LOCK = 0xb,                  
    CCM_IC_UNLOCK = 0xc,                
    CCM_IC_INVAL_ALL = 0xd,             
    CCM_CC_LOCK = 0x13,                 
    CCM_CC_UNLOCK = 0x12,               
} CCM_CMD_Type;
 
typedef struct CacheInfo {
    uint32_t linesize;                  
    uint32_t ways;                      
    uint32_t setperway;                 
    uint32_t size;                      
} CacheInfo_Type;
 
#if __riscv_xlen == 32
#define CCM_SUEN_SUEN_Msk               (0xFFFFFFFFUL)              
#else
#define CCM_SUEN_SUEN_Msk               (0xFFFFFFFFFFFFFFFFUL)      
#endif
 
__STATIC_FORCEINLINE void EnableSUCCM(void)
{
    __RV_CSR_SET(CSR_CCM_SUEN, CCM_SUEN_SUEN_Msk);
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
    SMPCC_CMD->CC_CTRL |= _VAL2FLD(SMPCC_CMD_CTRL_SUP_EN, SMPCC_CMD_CTRL_SUP_EN_ENABLE) |
                          _VAL2FLD(SMPCC_CMD_CTRL_USE_EN, SMPCC_CMD_CTRL_USE_EN_ENABLE);
#endif /* #if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
}
 
__STATIC_FORCEINLINE void DisableSUCCM(void)
{
    __RV_CSR_CLEAR(CSR_CCM_SUEN, CCM_SUEN_SUEN_Msk);
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
    SMPCC_CMD->CC_CTRL &= ~(SMPCC_CMD_CTRL_SUP_EN_Msk | SMPCC_CMD_CTRL_USE_EN_Msk); /* Clear SUP_EN and USE_EN bits */
#endif /* #if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
}
 
__STATIC_FORCEINLINE void FlushPipeCCM(void)
{
    __RV_CSR_WRITE(CSR_CCM_FPIPE, 0x1);
} /* End of Doxygen Group NMSIS_Core_Cache */
 
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
__STATIC_INLINE unsigned long MLockCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_CC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_MDATA);
}
 
__STATIC_INLINE unsigned long MLockCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_CC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_MDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE unsigned long SLockCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_CC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_SDATA);
}
 
__STATIC_INLINE unsigned long SLockCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_CC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_SDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE unsigned long ULockCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_CC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_UDATA);
}
 
__STATIC_INLINE unsigned long ULockCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_CC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_UDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE void MUnlockCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_CC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MUnlockCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_CC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SUnlockCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_CC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SUnlockCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_CC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UUnlockCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_CC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UUnlockCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_CC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 /* End of Doxygen Group NMSIS_Core_CCache */
#endif /* defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
 
#endif /* defined(__CCM_PRESENT) && (__CCM_PRESENT == 1) */
 
#if defined(__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1)
 
__STATIC_INLINE int32_t ICachePresent(void)
{
    if (__RV_CSR_READ(CSR_MCFG_INFO) & MCFG_INFO_ICACHE) {
        return 1;
    }
    return 0;
}
 
__STATIC_FORCEINLINE void EnableICache(void)
{
    __RV_CSR_SET(CSR_MCACHE_CTL, MCACHE_CTL_IC_EN);
}
 
__STATIC_FORCEINLINE void DisableICache(void)
{
    __RV_CSR_CLEAR(CSR_MCACHE_CTL, MCACHE_CTL_IC_EN);
}
 
__STATIC_FORCEINLINE void EnableICacheECC(void)
{
    __RV_CSR_SET(CSR_MCACHE_CTL, MCACHE_CTL_IC_ECC_EN);
}
 
__STATIC_FORCEINLINE void DisableICacheECC(void)
{
    __RV_CSR_CLEAR(CSR_MCACHE_CTL, MCACHE_CTL_IC_ECC_EN);
}
 
#if defined(__CCM_PRESENT) && (__CCM_PRESENT == 1)
__STATIC_INLINE int32_t GetICacheInfo(CacheInfo_Type *info)
{
    if (info == NULL) {
        return -1;
    }
    CSR_MICFGINFO_Type csr_ccfg;
    csr_ccfg.d = __RV_CSR_READ(CSR_MICFG_INFO);
    info->setperway = (1UL << csr_ccfg.b.set) << 3;
    info->ways = (1 + csr_ccfg.b.way);
    if (csr_ccfg.b.lsize == 0) {
        info->linesize = 0;
    } else {
        info->linesize = (1UL << (csr_ccfg.b.lsize - 1)) << 3;
    }
    info->size = info->setperway * info->ways * info->linesize;
    return 0;
}
 
__STATIC_INLINE void MInvalICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MInvalICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SInvalICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SInvalICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UInvalICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UInvalICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
__STATIC_INLINE void MInvalICacheCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_INVAL);
    /* Trigger Cluster Cache invalidation by DC_INVAL */
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MInvalICacheCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_INVAL);
            /* Trigger Cluster Cache invalidation by DC_INVAL */
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SInvalICacheCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_INVAL);
    /* Trigger Cluster Cache invalidation by DC_INVAL */
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SInvalICacheCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_INVAL);
            /* Trigger Cluster Cache invalidation by DC_INVAL */
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UInvalICacheCCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_INVAL);
    /* Trigger Cluster Cache invalidation by DC_INVAL */
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UInvalICacheCCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_INVAL);
            /* Trigger Cluster Cache invalidation by DC_INVAL */
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
#endif /* #if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
 
__STATIC_INLINE unsigned long MLockICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_MDATA);
}
 
__STATIC_INLINE unsigned long MLockICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_MDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE unsigned long SLockICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_SDATA);
}
 
__STATIC_INLINE unsigned long SLockICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_SDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE unsigned long ULockICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_UDATA);
}
 
__STATIC_INLINE unsigned long ULockICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_UDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE void MUnlockICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MUnlockICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SUnlockICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SUnlockICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UUnlockICacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UUnlockICacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void MInvalICache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_INVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SInvalICache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_INVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UInvalICache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_INVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
__STATIC_INLINE void MInvalCCache(void)
{
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE void SInvalCCache(void)
{
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE void UInvalCCache(void)
{
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE void MInvalICacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_IC_INVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE void SInvalICacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_IC_INVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE void UInvalICacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_IC_INVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
#endif /* #if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
 
#endif /* defined(__CCM_PRESENT) && (__CCM_PRESENT == 1) */ /* End of Doxygen Group NMSIS_Core_ICache */
#endif /* defined(__ICACHE_PRESENT) && (__ICACHE_PRESENT == 1) */
 
#if defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1)
__STATIC_INLINE int32_t DCachePresent(void)
{
    if (__RV_CSR_READ(CSR_MCFG_INFO) & MCFG_INFO_DCACHE) {
        return 1;
    }
    return 0;
}
 
__STATIC_FORCEINLINE void EnableDCache(void)
{
    __RV_CSR_SET(CSR_MCACHE_CTL, MCACHE_CTL_DC_EN);
}
 
__STATIC_FORCEINLINE void DisableDCache(void)
{
    __RV_CSR_CLEAR(CSR_MCACHE_CTL, MCACHE_CTL_DC_EN);
}
 
__STATIC_FORCEINLINE void EnableDCacheECC(void)
{
    __RV_CSR_SET(CSR_MCACHE_CTL, MCACHE_CTL_DC_ECC_EN);
}
 
__STATIC_FORCEINLINE void DisableDCacheECC(void)
{
    __RV_CSR_CLEAR(CSR_MCACHE_CTL, MCACHE_CTL_DC_ECC_EN);
}
 
#if defined(__CCM_PRESENT) && (__CCM_PRESENT == 1)
__STATIC_INLINE int32_t GetDCacheInfo(CacheInfo_Type *info)
{
    if (info == NULL) {
        return -1;
    }
    CSR_MDCFGINFO_Type csr_ccfg;
    csr_ccfg.d = __RV_CSR_READ(CSR_MDCFG_INFO);
    info->setperway = (1UL << csr_ccfg.b.set) << 3;
    info->ways = (1 + csr_ccfg.b.way);
    if (csr_ccfg.b.lsize == 0) {
        info->linesize = 0;
    } else {
        info->linesize = (1UL << (csr_ccfg.b.lsize - 1)) << 3;
    }
    info->size = info->setperway * info->ways * info->linesize;
    return 0;
}
 
__STATIC_INLINE void MInvalDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MInvalDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SInvalDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SInvalDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UInvalDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_INVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UInvalDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_INVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void MFlushDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WB);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MFlushDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WB);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SFlushDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WB);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SFlushDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WB);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UFlushDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WB);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UFlushDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WB);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void MFlushInvalDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WBINVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MFlushInvalDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WBINVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SFlushInvalDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WBINVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SFlushInvalDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WBINVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UFlushInvalDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WBINVAL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UFlushInvalDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WBINVAL);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
#define MInvalDCacheCCacheLine(addr) MInvalDCacheLine(addr)
 
#define MInvalDCacheCCacheLines(addr, cnt) MInvalDCacheLines(addr, cnt)
 
#define SInvalDCacheCCacheLine(addr) SInvalDCacheLine(addr)
 
#define SInvalDCacheCCacheLines(addr, cnt) SInvalDCacheLines(addr, cnt)
 
#define UInvalDCacheCCacheLine(addr) UInvalDCacheLine(addr)
 
#define UInvalDCacheCCacheLines(addr, cnt) UInvalDCacheLines(addr, cnt)
#define MFlushDCacheCCacheLine(addr) MFlushDCacheLine(addr)
 
#define MFlushDCacheCCacheLines(addr, cnt) MFlushDCacheLines(addr, cnt)
 
#define SFlushDCacheCCacheLine(addr) SFlushDCacheLine(addr)
 
#define SFlushDCacheCCacheLines(addr, cnt) SFlushDCacheLines(addr, cnt)
 
#define UFlushDCacheCCacheLine(addr) UFlushDCacheLine(addr)
 
#define UFlushDCacheCCacheLines(addr, cnt) UFlushDCacheLines(addr, cnt)
#define MFlushInvalDCacheCCacheLine(addr) MFlushInvalDCacheLine(addr)
 
#define MFlushInvalDCacheCCacheLines(addr, cnt) MFlushInvalDCacheLines(addr, cnt)
 
#define SFlushInvalDCacheCCacheLine(addr) SFlushInvalDCacheLine(addr)
 
#define SFlushInvalDCacheCCacheLines(addr, cnt) SFlushInvalDCacheLines(addr, cnt)
 
#define UFlushInvalDCacheCCacheLine(addr) UFlushInvalDCacheLine(addr)
 
#define UFlushInvalDCacheCCacheLines(addr, cnt) UFlushInvalDCacheLines(addr, cnt)
#endif /* #if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
 
__STATIC_INLINE unsigned long MLockDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_MDATA);
}
 
__STATIC_INLINE unsigned long MLockDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_MDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE unsigned long SLockDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_SDATA);
}
 
__STATIC_INLINE unsigned long SLockDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_SDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE unsigned long ULockDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_LOCK);
    FlushPipeCCM();
    __RWMB();
    return __RV_CSR_READ(CSR_CCM_UDATA);
}
 
__STATIC_INLINE unsigned long ULockDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        unsigned long fail_info = CCM_OP_SUCCESS;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_LOCK);
            FlushPipeCCM();
            __RWMB();
            fail_info = __RV_CSR_READ(CSR_CCM_UDATA);
            if (CCM_OP_SUCCESS != fail_info) {
                return fail_info;
            }
        }
    }
    return CCM_OP_SUCCESS;
}
 
__STATIC_INLINE void MUnlockDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MUnlockDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_MBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void SUnlockDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SUnlockDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_SBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void UUnlockDCacheLine(unsigned long addr)
{
    __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_UNLOCK);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UUnlockDCacheLines(unsigned long addr, unsigned long cnt)
{
    if (cnt > 0) {
        unsigned long i;
        __RV_CSR_WRITE(CSR_CCM_UBEGINADDR, addr);
        for (i = 0; i < cnt; i++) {
            __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_UNLOCK);
        }
        FlushPipeCCM();
        __RWMB();
    }
}
 
__STATIC_INLINE void MInvalDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_INVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SInvalDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_INVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UInvalDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_INVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MFlushDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WB_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SFlushDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WB_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UFlushDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WB_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void MFlushInvalDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WBINVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void SFlushInvalDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WBINVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
__STATIC_INLINE void UFlushInvalDCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WBINVAL_ALL);
    FlushPipeCCM();
    __RWMB();
}
 
#if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1)
__STATIC_INLINE int32_t MFlushCCache(void)
{
    /* Clear pending error status before issuing the Cluster Cache command.
     * RESC/FESC/BESC are write-1-to-clear bits, so read the status and write it back. */
    SMPCC_CMD->CC_mCMD = (SMPCC_CMD->CC_mCMD & SMPCC_CMD_xCMD_STATUS_Msk);
    SMPCC_CMD->CC_mCMD = (SMPCC_CMD->CC_mCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WB_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_mCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_mCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t SFlushCCache(void)
{
    /* Clear pending error status before issuing the Cluster Cache command.
     * RESC/FESC/BESC are write-1-to-clear bits, so read the status and write it back. */
    SMPCC_CMD->CC_sCMD = (SMPCC_CMD->CC_sCMD & SMPCC_CMD_xCMD_STATUS_Msk);
    SMPCC_CMD->CC_sCMD = (SMPCC_CMD->CC_sCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WB_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_sCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_sCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t UFlushCCache(void)
{
    /* Clear pending error status before issuing the Cluster Cache command.
     * RESC/FESC/BESC are write-1-to-clear bits, so read the status and write it back. */
    SMPCC_CMD->CC_uCMD = (SMPCC_CMD->CC_uCMD & SMPCC_CMD_xCMD_STATUS_Msk);
    SMPCC_CMD->CC_uCMD = (SMPCC_CMD->CC_uCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WB_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_uCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_uCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t MFlushInvalCCache(void)
{
    SMPCC_CMD->CC_mCMD = (SMPCC_CMD->CC_mCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WBINVAL_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_mCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_mCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t SFlushInvalCCache(void)
{
    SMPCC_CMD->CC_sCMD = (SMPCC_CMD->CC_sCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WBINVAL_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_sCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_sCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t UFlushInvalCCache(void)
{
    SMPCC_CMD->CC_uCMD = (SMPCC_CMD->CC_uCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WBINVAL_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_uCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_uCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE void MInvalDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_INVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE void SInvalDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_INVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE void UInvalDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_INVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_INVALID_ALL = _VAL2FLD(SMPCC_CMD_INVALID_ALL, 1);
    while(_FLD2VAL(SMPCC_CMD_INVALID_ALL, SMPCC_CMD->CC_INVALID_ALL));
    __RWMB();
}
 
__STATIC_INLINE int32_t MFlushDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WB_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_mCMD = (SMPCC_CMD->CC_mCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WB_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_mCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_mCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t SFlushDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WB_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_sCMD = (SMPCC_CMD->CC_sCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WB_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_sCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_sCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t UFlushDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WB_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_uCMD = (SMPCC_CMD->CC_uCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WB_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_uCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_uCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t MFlushInvalDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_MCOMMAND, CCM_DC_WBINVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_mCMD = (SMPCC_CMD->CC_mCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WBINVAL_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_mCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_mCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t SFlushInvalDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_SCOMMAND, CCM_DC_WBINVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_sCMD = (SMPCC_CMD->CC_sCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WBINVAL_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_sCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_sCMD);
    __RWMB();
    return res;
}
 
__STATIC_INLINE int32_t UFlushInvalDCacheCCache(void)
{
    __RV_CSR_WRITE(CSR_CCM_UCOMMAND, CCM_DC_WBINVAL_ALL);
    FlushPipeCCM();
    SMPCC_CMD->CC_uCMD = (SMPCC_CMD->CC_uCMD & ~SMPCC_CMD_xCMD_CMD_Msk) |
                         _VAL2FLD(SMPCC_CMD_xCMD_CMD, SMPCC_CMD_xCMD_CMD_WBINVAL_ALL);
    while(_FLD2VAL(SMPCC_CMD_xCMD_COMPLETE, SMPCC_CMD->CC_uCMD) == 0);
    int32_t res = _FLD2VAL(SMPCC_CMD_xCMD_RESULT, SMPCC_CMD->CC_uCMD);
    __RWMB();
    return res;
}
#endif /* #if defined(__SMPCC_PRESENT) && (__SMPCC_PRESENT == 1) */
 
#endif /* defined(__CCM_PRESENT) && (__CCM_PRESENT == 1) */
 /* End of Doxygen Group NMSIS_Core_DCache */
#endif /* defined(__DCACHE_PRESENT) && (__DCACHE_PRESENT == 1) */
 
#ifdef __cplusplus
}
#endif
#endif /* __CORE_FEATURE_CACHE_H__ */