mm.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_KERNEL_INTERNAL_MM_H
#define ZEPHYR_INCLUDE_KERNEL_INTERNAL_MM_H
 
#include <zephyr/sys/util.h>
#include <zephyr/toolchain.h>
#include <zephyr/devicetree.h>


#ifdef CONFIG_MMU
#define K_MEM_VIRT_OFFSET       ((CONFIG_KERNEL_VM_BASE + CONFIG_KERNEL_VM_OFFSET) - \
                                 (DT_CHOSEN_SRAM_ADDR + CONFIG_SRAM_OFFSET))
#else
#define K_MEM_VIRT_OFFSET       0
#endif /* CONFIG_MMU */
 
#if DT_CHOSEN_SRAM_ADDR != 0
#define IS_SRAM_ADDRESS_LOWER(ADDR)  ((ADDR) >= DT_CHOSEN_SRAM_ADDR)
#else
#define IS_SRAM_ADDRESS_LOWER(ADDR)  true
#endif /* DT_CHOSEN_SRAM_ADDR != 0 */
 
#if (DT_CHOSEN_SRAM_ADDR + DT_CHOSEN_SRAM_SIZE) != 0
#define IS_SRAM_ADDRESS_UPPER(ADDR)              \
        ((ADDR) < (DT_CHOSEN_SRAM_ADDR + DT_CHOSEN_SRAM_SIZE))
#else
#define IS_SRAM_ADDRESS_UPPER(ADDR)  false
#endif
 
#define IS_SRAM_ADDRESS(ADDR)            \
        (IS_SRAM_ADDRESS_LOWER(ADDR) &&  \
         IS_SRAM_ADDRESS_UPPER(ADDR))

#define K_MEM_PHYS_ADDR(virt)   ((virt) - K_MEM_VIRT_OFFSET)

#define K_MEM_VIRT_ADDR(phys)   ((phys) + K_MEM_VIRT_OFFSET)
 
#if K_MEM_VIRT_OFFSET != 0
#define K_MEM_IS_VM_KERNEL 1
#ifdef CONFIG_XIP
#error "XIP and a virtual memory kernel are not allowed"
#endif
#endif
 
#ifndef _ASMLANGUAGE
#include <stdint.h>
#include <stddef.h>
#include <inttypes.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/mem_manage.h>

static inline uintptr_t k_mem_phys_addr(void *virt)
{
        uintptr_t addr = (uintptr_t)virt;
 
#if defined(CONFIG_KERNEL_VM_USE_CUSTOM_MEM_RANGE_CHECK)
        __ASSERT(sys_mm_is_virt_addr_in_range(virt),
                 "address %p not in permanent mappings", virt);
#elif defined(CONFIG_MMU)
#if CONFIG_KERNEL_VM_BASE != 0
        /* Skipped when the VM base is 0, where the comparison is always true and
         * some compilers warn about it (-Wtype-limits).
         */
        __ASSERT(addr >= (uintptr_t)CONFIG_KERNEL_VM_BASE, "address %p below VM base", virt);
#endif /* CONFIG_KERNEL_VM_BASE != 0 */
        __ASSERT((addr - (uintptr_t)CONFIG_KERNEL_VM_BASE) < (uintptr_t)CONFIG_KERNEL_VM_SIZE,
                 "address %p above VM limit", virt);
#else
        /* Should be identity-mapped */
        __ASSERT(IS_SRAM_ADDRESS(addr),
                 "physical address 0x%lx not in RAM",
                 (unsigned long)addr);
#endif /* CONFIG_MMU */
 
        /* TODO add assertion that this page is pinned to boot mapping,
         * the above checks won't be sufficient with demand paging
         */
 
        return K_MEM_PHYS_ADDR(addr);
}

static inline void *k_mem_virt_addr(uintptr_t phys)
{
#if defined(CONFIG_KERNEL_VM_USE_CUSTOM_MEM_RANGE_CHECK)
        __ASSERT(sys_mm_is_phys_addr_in_range(phys),
                "physical address 0x%lx not in RAM", (unsigned long)phys);
#else
        __ASSERT(IS_SRAM_ADDRESS(phys),
                 "physical address 0x%lx not in RAM", (unsigned long)phys);
#endif /* CONFIG_KERNEL_VM_USE_CUSTOM_MEM_RANGE_CHECK */
 
        /* TODO add assertion that this page frame is pinned to boot mapping,
         * the above check won't be sufficient with demand paging
         */
 
        return (void *)K_MEM_VIRT_ADDR(phys);
}
 
#ifdef __cplusplus
extern "C" {
#endif

void k_mem_map_phys_bare(uint8_t **virt_ptr, uintptr_t phys, size_t size,
                         uint32_t flags);

void k_mem_unmap_phys_bare(uint8_t *virt, size_t size);

void *k_mem_map_phys_guard(uintptr_t phys, size_t size, uint32_t flags, bool is_anon);

void k_mem_unmap_phys_guard(void *addr, size_t size, bool is_anon);
 
#ifdef __cplusplus
}
#endif

 
#endif /* !_ASMLANGUAGE */
#endif /* ZEPHYR_INCLUDE_KERNEL_INTERNAL_MM_H */