cache.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 Wind River Systems, Inc.
 * Copyright (c) 2022 Carlo Caione <ccaione@baylibre.com>
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_CACHE_H_
#define ZEPHYR_INCLUDE_CACHE_H_

 
#include <zephyr/kernel.h>
#include <zephyr/arch/cpu.h>
#include <zephyr/debug/sparse.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#if defined(CONFIG_EXTERNAL_CACHE)
#include <zephyr/drivers/cache.h>
 
#elif defined(CONFIG_ARCH_CACHE)
#include <zephyr/arch/cache.h>
 
#elif defined(CONFIG_SOC_CACHE)
#include <soc_cache.h>
 
#endif


static ALWAYS_INLINE void sys_cache_data_enable(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        cache_data_enable();
#endif
}

static ALWAYS_INLINE void sys_cache_data_disable(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        cache_data_disable();
#endif
}

static ALWAYS_INLINE void sys_cache_instr_enable(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        cache_instr_enable();
#endif
}

static ALWAYS_INLINE void sys_cache_instr_disable(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        cache_instr_disable();
#endif
}

static ALWAYS_INLINE int sys_cache_data_flush_all(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        return cache_data_flush_all();
#endif
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_instr_flush_all(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        return cache_instr_flush_all();
#endif
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_data_invd_all(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        return cache_data_invd_all();
#endif
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_instr_invd_all(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        return cache_instr_invd_all();
#endif
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_data_flush_and_invd_all(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        return cache_data_flush_and_invd_all();
#endif
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_instr_flush_and_invd_all(void)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        return cache_instr_flush_and_invd_all();
#endif
        return -ENOTSUP;
}

__syscall_always_inline int sys_cache_data_flush_range(void *addr, size_t size);
 
static ALWAYS_INLINE int z_impl_sys_cache_data_flush_range(void *addr, size_t size)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        return cache_data_flush_range(addr, size);
#endif
        ARG_UNUSED(addr);
        ARG_UNUSED(size);
 
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_instr_flush_range(void *addr, size_t size)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        return cache_instr_flush_range(addr, size);
#endif
        ARG_UNUSED(addr);
        ARG_UNUSED(size);
 
        return -ENOTSUP;
}

__syscall_always_inline int sys_cache_data_invd_range(void *addr, size_t size);
 
static ALWAYS_INLINE int z_impl_sys_cache_data_invd_range(void *addr, size_t size)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        return cache_data_invd_range(addr, size);
#endif
        ARG_UNUSED(addr);
        ARG_UNUSED(size);
 
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_instr_invd_range(void *addr, size_t size)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        return cache_instr_invd_range(addr, size);
#endif
        ARG_UNUSED(addr);
        ARG_UNUSED(size);
 
        return -ENOTSUP;
}

__syscall_always_inline int sys_cache_data_flush_and_invd_range(void *addr, size_t size);
 
static ALWAYS_INLINE int z_impl_sys_cache_data_flush_and_invd_range(void *addr, size_t size)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_DCACHE)
        return cache_data_flush_and_invd_range(addr, size);
#endif
        ARG_UNUSED(addr);
        ARG_UNUSED(size);
 
        return -ENOTSUP;
}

static ALWAYS_INLINE int sys_cache_instr_flush_and_invd_range(void *addr, size_t size)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_ICACHE)
        return cache_instr_flush_and_invd_range(addr, size);
#endif
        ARG_UNUSED(addr);
        ARG_UNUSED(size);
 
        return -ENOTSUP;
}

static ALWAYS_INLINE size_t sys_cache_data_line_size_get(void)
{
#ifdef CONFIG_DCACHE_LINE_SIZE_DETECT
        size_t dcache_line_size = cache_data_line_size_get();
 
        __ASSERT(dcache_line_size > 0);
        __ASSERT(dcache_line_size == CONFIG_DCACHE_LINE_SIZE);
        return dcache_line_size;
#elif defined(CONFIG_DCACHE)
        return CONFIG_DCACHE_LINE_SIZE;
#else
        return 0;
#endif
}

static ALWAYS_INLINE size_t sys_cache_instr_line_size_get(void)
{
#ifdef CONFIG_ICACHE_LINE_SIZE_DETECT
        size_t icache_line_size = cache_instr_line_size_get();
 
        __ASSERT(icache_line_size > 0);
        __ASSERT(icache_line_size == CONFIG_ICACHE_LINE_SIZE);
        return icache_line_size;
#elif defined(CONFIG_ICACHE)
        return CONFIG_ICACHE_LINE_SIZE;
#else
        return 0;
#endif
}

static ALWAYS_INLINE bool sys_cache_is_ptr_cached(void *ptr)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_CACHE_HAS_MIRRORED_MEMORY_REGIONS)
        return cache_is_ptr_cached(ptr);
#else
        ARG_UNUSED(ptr);
 
        return false;
#endif
}

static ALWAYS_INLINE bool sys_cache_is_ptr_uncached(void *ptr)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_CACHE_HAS_MIRRORED_MEMORY_REGIONS)
        return cache_is_ptr_uncached(ptr);
#else
        ARG_UNUSED(ptr);
 
        return false;
#endif
}

static ALWAYS_INLINE void __sparse_cache *sys_cache_cached_ptr_get(void *ptr)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_CACHE_HAS_MIRRORED_MEMORY_REGIONS)
        return cache_cached_ptr(ptr);
#else
        return (__sparse_force void __sparse_cache *)ptr;
#endif
}

static ALWAYS_INLINE void *sys_cache_uncached_ptr_get(void __sparse_cache *ptr)
{
#if defined(CONFIG_CACHE_MANAGEMENT) && defined(CONFIG_CACHE_HAS_MIRRORED_MEMORY_REGIONS)
        return cache_uncached_ptr(ptr);
#else
        return (__sparse_force void *)ptr;
#endif
}
 
 
#ifdef CONFIG_LIBMETAL
static ALWAYS_INLINE void sys_cache_flush(void *addr, size_t size)
{
        sys_cache_data_flush_range(addr, size);
}
#endif
 
#if defined(CONFIG_CACHE_CAN_SAY_MEM_COHERENCE) || defined(__DOXYGEN__)
static ALWAYS_INLINE bool sys_cache_is_mem_coherent(void *ptr)
{
        return cache_is_mem_coherent(ptr);
}
#endif /* CONFIG_CACHE_CAN_SAY_MEM_COHERENCE */
 
#include <zephyr/syscalls/cache.h>
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_CACHE_H_ */