userspace: add a userspace heap

Add a userspace heap, memory type and associated helper APIs.

Signed-off-by: Liam Girdwood <liam.r.girdwood@linux.intel.com>

Author: lrgirdwo

src/include/ipc/topology.h

@@ -89,6 +89,7 @@ struct sof_ipc_comp {
 #define SOF_MEM_CAPS_L3			BIT(8) /**< L3 memory */
 /* Don't forget to update when adding a new bit to the ABI. */
 #define SOF_MEM_CAPS_LOWEST_INVALID	BIT(9) /**< Used for input validation */
+#define SOF_MEM_CAPS_MMU_SHD	BIT(10) /**< MMU shared memory */
 
 /*
  * overrun will cause ring buffer overwrite, instead of XRUN.

zephyr/Kconfig

@@ -51,6 +51,18 @@ config SOF_ZEPHYR_VIRTUAL_HEAP_SIZE
 	 NOTE: Keep in mind that the heap size should not be greater than the physical
 	 memory size of the system defined in DT (and this includes baseFW text/data).
 
+config SOF_ZEPHYR_USER_HEAP_SIZE
+	hex "Size of the Zephyr userspace heap for SOF"
+	depends on SOF_STAGING
+	depends on SOF_USERSPACE
+	default 0x20000 if SOC_INTEL_ACE30
+	default 0x0
+	help
+	 Support scaling of the userspace address heap size for different platforms.
+	 NOTE: Keep in mind that the heap size should not be greater than the physical
+	 memory size of the system defined in DT (and this includes baseFW text/data
+	 alongside the default SOF heap size).
+
 config ZEPHYR_NATIVE_DRIVERS
 	bool "Use Zephyr native drivers"
 	default n

zephyr/include/rtos/alloc.h

@@ -139,6 +139,46 @@ void rfree(void *ptr);
 /* TODO: remove - debug only - only needed for linking */
 static inline void heap_trace_all(int force) {}
 
+#if CONFIG_SOF_USERSPACE
+
+/**
+ * Returns whether pointer is in userspace heap.
+ * @return True is userspace pointer.
+ */
+bool s_heap_user_is_pointer(void *ptr);
+
+/**
+ * Returns the start of user memory heap.
+ * @return Pointer to the user memory heap start address.
+ */
+uintptr_t s_heap_user_get_start(void);
+
+/**
+ * Returns the size of user memory heap.
+ * @return Size of the user memory region which can be used for user heap.
+ */
+static inline size_t s_get_heap_get_user_size(void)
+{
+	return ROUND_DOWN(CONFIG_SOF_ZEPHYR_USER_HEAP_SIZE, CONFIG_MMU_PAGE_SIZE);
+}
+#else
+
+static inline bool s_heap_user_is_pointer(void *ptr)
+{
+	return false;
+}
+
+static inline uintptr_t s_heap_user_get_start(void)
+{
+	return 0;
+}
+
+static inline size_t s_get_heap_get_user_size(void)
+{
+	return 0;
+}
+#endif
+
 /** @}*/
 
 #endif /* __ZEPHYR_RTOS_ALLOC_H__ */

zephyr/lib/alloc.c

@@ -98,7 +98,13 @@ static uint8_t __aligned(PLATFORM_DCACHE_ALIGN) heapmem[HEAPMEM_SIZE];
  * to allow memory management driver to control unused
  * memory pages.
  */
-__section(".heap_mem") static uint8_t __aligned(PLATFORM_DCACHE_ALIGN) heapmem[HEAPMEM_SIZE];
+
+__section(".heap_mem") static uint8_t __aligned(HOST_PAGE_SIZE) heapmem[HEAPMEM_SIZE];
+
+#if CONFIG_SOF_USERSPACE
+#define USER_HEAP_MEM_SIZE CONFIG_SOF_ZEPHYR_USER_HEAP_SIZE
+__section(".heap_mem") static uint8_t __aligned(HOST_PAGE_SIZE) user_heapmem[USER_HEAP_MEM_SIZE];
+#endif
 
 #elif defined(CONFIG_ARCH_POSIX)
 
@@ -125,6 +131,35 @@ extern char _end[], _heap_sentry[];
 
 static struct k_heap sof_heap;
 
+#if CONFIG_SOF_USERSPACE
+static struct k_heap sof_user_heap;
+
+/**
+ * Returns the start of user memory heap.
+ * @return Pointer to the user memory heap start address.
+ */
+bool s_heap_user_is_pointer(void *ptr)
+{
+	if (is_cached(ptr))
+		ptr = sys_cache_uncached_ptr_get((__sparse_force void __sparse_cache *)ptr);
+
+	if ((POINTER_TO_UINT(ptr) >= (uintptr_t)&user_heapmem[0]) &&
+	    (POINTER_TO_UINT(ptr) < (uintptr_t)&user_heapmem[CONFIG_SOF_ZEPHYR_USER_HEAP_SIZE]))
+		return true;
+
+	return false;
+}
+
+/**
+ * Returns the start of user memory heap.
+ * @return Pointer to the user memory heap start address.
+ */
+uintptr_t s_heap_user_get_start(void)
+{
+	return (uintptr_t)ROUND_UP(&user_heapmem[0], CONFIG_MMU_PAGE_SIZE);
+}
+#endif
+
 #if CONFIG_L3_HEAP
 static struct k_heap l3_heap;
 
@@ -401,6 +436,10 @@ void *rmalloc(enum mem_zone zone, uint32_t flags, uint32_t caps, size_t bytes)
 		return ptr;
 #else
 		k_panic();
+#endif
+#if CONFIG_USERSPACE
+	} else if (caps & SOF_MEM_CAPS_MMU_SHD) {
+		heap = &sof_user_heap;
 #endif
 	} else {
 		heap = &sof_heap;
@@ -504,6 +543,11 @@ void *rballoc_align(uint32_t flags, uint32_t caps, size_t bytes,
 		return virtual_heap_alloc(virtual_buffers_heap, flags, caps, bytes, align);
 #endif /* CONFIG_VIRTUAL_HEAP */
 
+#if CONFIG_SOF_USERSPACE
+	if (caps & SOF_MEM_CAPS_MMU_SHD)
+		heap = &sof_user_heap;
+#endif
+
 	if (flags & SOF_MEM_FLAG_COHERENT)
 		return heap_alloc_aligned(heap, align, bytes);
 
@@ -541,6 +585,9 @@ static int heap_init(void)
 {
 	sys_heap_init(&sof_heap.heap, heapmem, HEAPMEM_SIZE);
 
+#if CONFIG_SOF_USERSPACE
+	sys_heap_init(&sof_user_heap.heap, user_heapmem, USER_HEAP_MEM_SIZE);
+#endif
 #if CONFIG_L3_HEAP
 	sys_heap_init(&l3_heap.heap, UINT_TO_POINTER(get_l3_heap_start()), get_l3_heap_size());
 #endif