alloc.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2022 Intel Corporation. All rights reserved.
 */
 
#ifndef __ZEPHYR_RTOS_ALLOC_H__
#define __ZEPHYR_RTOS_ALLOC_H__
 
#include <rtos/bit.h>
#include <rtos/string.h>
#include <sof/lib/memory.h> /* PLATFORM_DCACHE_ALIGN */
#include <sof/trace/trace.h>
#include <user/trace.h>
 
#include <stddef.h>
#include <stdint.h>

 
/*
 * for compatibility with the initial `flags` meaning
 * SOF_MEM_FLAG_ should start at BIT(2)
 * the first two positions are reserved for SOF_BUF_ flags
 */


#define SOF_MEM_FLAG_DMA        BIT(2)
#define SOF_MEM_FLAG_NO_COPY        BIT(3)
#define SOF_MEM_FLAG_COHERENT       BIT(4)
#define SOF_MEM_FLAG_L3         BIT(5)
#define SOF_MEM_FLAG_LOW_POWER      BIT(6)
#define SOF_MEM_FLAG_KERNEL     BIT(7)
#define SOF_MEM_FLAG_USER       BIT(8)
#define SOF_MEM_FLAG_USER_SHARED_BUFFER BIT(9)
#define SOF_MEM_FLAG_LARGE_BUFFER   BIT(10)


void *rmalloc_align(uint32_t flags, size_t bytes, uint32_t alignment);

void *rmalloc(uint32_t flags, size_t bytes);

void *rzalloc(uint32_t flags, size_t bytes);

void *rballoc_align(uint32_t flags, size_t bytes,
            uint32_t alignment);

static inline void *rballoc(uint32_t flags, size_t bytes)
{
    return rballoc_align(flags, bytes, PLATFORM_DCACHE_ALIGN);
}

void rfree(void *ptr);

void l3_heap_save(void);
 
/*
 * This is ugly to define the signatures twice, but this
 * is required to support userspace builds that do not export alloc.
 */
#ifdef CONFIG_SOF_USERSPACE_INTERFACE_ALLOC
__syscall void *sof_heap_alloc(struct k_heap *heap, uint32_t flags, size_t bytes,
                   size_t alignment);
__syscall void sof_heap_free(struct k_heap *heap, void *addr);
#include <zephyr/syscalls/alloc.h>
#else
void *sof_heap_alloc(struct k_heap *heap, uint32_t flags, size_t bytes,
             size_t alignment);
void sof_heap_free(struct k_heap *heap, void *addr);
#endif
 
#if CONFIG_SOF_FULL_ZEPHYR_APPLICATION
struct k_heap *sof_sys_heap_get(void);
#else
/* for unit-testing */
static inline struct k_heap *sof_sys_heap_get(void)
{
    return NULL;
}
#endif

struct k_heap *sof_sys_user_heap_get(void);
 
/* TODO: remove - debug only - only needed for linking */
static inline void heap_trace_all(int force) {}

 
#if CONFIG_SOF_USERSPACE_USE_SHARED_HEAP
uintptr_t get_shared_buffer_heap_start(void);

size_t get_shared_buffer_heap_size(void);
 
#endif
 
#include <sof/lib/vregion.h>
 
struct mod_alloc_ctx {
    struct k_heap *heap;
    struct vregion *vreg;
};

static inline void *sof_ctx_alloc(struct mod_alloc_ctx *ctx, uint32_t flags,
                  size_t size, size_t alignment)
{
    if (!ctx || !ctx->vreg)
        return sof_heap_alloc(ctx ? ctx->heap : NULL, flags, size, alignment);
 
    if (flags & SOF_MEM_FLAG_COHERENT)
        return vregion_alloc_coherent_align(ctx->vreg, size, alignment);
 
    return vregion_alloc_align(ctx->vreg, size, alignment);
}

static inline void *sof_ctx_zalloc(struct mod_alloc_ctx *ctx, uint32_t flags,
                   size_t size, size_t alignment)
{
    void *ptr = sof_ctx_alloc(ctx, flags, size, alignment);
 
    if (ptr)
        memset(ptr, 0, size);
 
    return ptr;
}

static inline void sof_ctx_free(struct mod_alloc_ctx *ctx, void *ptr)
{
    if (!ptr)
        return;
 
    if (ctx && ctx->vreg)
        vregion_free(ctx->vreg, ptr);
    else
        sof_heap_free(ctx ? ctx->heap : NULL, ptr);
}
 
#endif /* __ZEPHYR_RTOS_ALLOC_H__ */