[DRAFT] userspace LL/audio test PR

app/overlays/ptl/ll_userspace_overlay.conf

@@ -0,0 +1,27 @@
+CONFIG_SOF_USERSPACE_LL=y
+
+# Problem with DSP panics due to illegal instruction hit in user-space if cold
+# store execution is enabled. Disable it for now until rootcause is found.
+CONFIG_COLD_STORE_EXECUTE_DRAM=n
+
+# temporary (but for now mandatory) settings
+CONFIG_SOF_ZEPHYR_USERSPACE_MODULE_HEAP_SIZE=16384
+CONFIG_SOF_ZEPHYR_LL_USER_HEAP_SIZE=0x1f000
+
+# make the drivers work in user-space
+CONFIG_SOF_USERSPACE_INTERFACE_DMA=y
+CONFIG_DAI_USERSPACE=y
+
+# disable features that don't work in user-space (at least yet)
+CONFIG_COLD_STORE_EXECUTE_DEBUG=n
+CONFIG_CROSS_CORE_STREAM=n
+CONFIG_INTEL_ADSP_MIC_PRIVACY=n
+CONFIG_XRUN_NOTIFICATIONS_ENABLE=n
+CONFIG_SOF_BOOT_TEST_ALLOWED=n
+CONFIG_SOF_TELEMETRY_PERFORMANCE_MEASUREMENTS=n
+CONFIG_SOF_TELEMETRY_IO_PERFORMANCE_MEASUREMENTS=n
+
+# disable llext (hits privilege issues in user-space now)
+CONFIG_LLEXT_STORAGE_WRITABLE=n
+CONFIG_LLEXT_EXPERIMENTAL=n
+CONFIG_MODULES=n

posix/include/rtos/alloc.h

@@ -97,29 +97,6 @@ static inline void *rballoc(uint32_t flags, size_t bytes)
 	return rballoc_align(flags, bytes, PLATFORM_DCACHE_ALIGN);
 }
 
-/**
- * Changes size of the memory block allocated.
- * @param ptr Address of the block to resize.
- * @param flags Flags, see SOF_MEM_FLAG_...
- * @param bytes New size in bytes.
- * @param old_bytes Old size in bytes.
- * @param alignment Alignment in bytes.
- * @return Pointer to the resized memory of NULL if failed.
- */
-void *rbrealloc_align(void *ptr, uint32_t flags, size_t bytes,
-		      size_t old_bytes, uint32_t alignment);
-
-/**
- * Similar to rballoc_align(), returns resized buffer aligned to
- * PLATFORM_DCACHE_ALIGN.
- */
-static inline void *rbrealloc(void *ptr, uint32_t flags,
-			      size_t bytes, size_t old_bytes)
-{
-	return rbrealloc_align(ptr, flags, bytes, old_bytes,
-			       PLATFORM_DCACHE_ALIGN);
-}
-
 /**
  * Frees the memory block.
  * @param ptr Pointer to the memory block.

posix/include/rtos/mutex.h

@@ -62,4 +62,52 @@ static inline int sys_mutex_unlock(struct sys_mutex *mutex)
 	return 0;
 }
 
+/* provide a no-op implementation for zephyr/sys/sem.h */
+
+struct sys_sem {
+};
+
+static inline int sys_sem_init(struct sys_sem *sem, unsigned int initial_count,
+			       unsigned int limit)
+{
+	return 0;
+}
+
+static inline int sys_sem_give(struct sys_sem *sem)
+{
+	return 0;
+}
+
+static inline int sys_sem_take(struct sys_sem *sem, k_timeout_t timeout)
+{
+	return 0;
+}
+
+/**
+ * @brief User-space accessible mutex stub for host/testbench builds.
+ */
+struct sof_umutex {
+	struct k_mutex mutex;  /**< Inline k_mutex for POSIX (no dynamic alloc needed) */
+};
+
+static inline int sof_umutex_init(struct sof_umutex *umutex)
+{
+	return k_mutex_init(&umutex->mutex);
+}
+
+static inline int sof_umutex_lock(struct sof_umutex *umutex, k_timeout_t timeout)
+{
+	return k_mutex_lock(&umutex->mutex, timeout);
+}
+
+static inline int sof_umutex_unlock(struct sof_umutex *umutex)
+{
+	return k_mutex_unlock(&umutex->mutex);
+}
+
+static inline void sof_umutex_free(struct sof_umutex *umutex)
+{
+	/* No-op on POSIX — no kernel objects to free */
+}
+
 #endif

posix/include/rtos/umutex.h

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2026 Intel Corporation.
+//
+
+#ifndef __POSIX_RTOS_UMUTEX_H__
+#define __POSIX_RTOS_UMUTEX_H__
+
+#include <rtos/mutex.h>
+
+/* sof_umutex type and operations are defined in rtos/mutex.h for POSIX */
+
+#endif /* __POSIX_RTOS_UMUTEX_H__ */

posix/include/sof/lib/dma.h

@@ -35,6 +35,7 @@
 
 struct comp_buffer;
 struct comp_dev;
+struct k_heap;
 
 /** \addtogroup sof_dma_drivers DMA Drivers
  *  DMA Drivers API specification.
@@ -511,13 +512,14 @@ static inline void dma_sg_init(struct dma_sg_elem_array *ea)
 	ea->elems = NULL;
 }
 
-int dma_sg_alloc(struct dma_sg_elem_array *ea,
+int dma_sg_alloc(struct k_heap *heap,
+		 struct dma_sg_elem_array *ea,
 		 uint32_t flags,
 		 uint32_t direction,
 		 uint32_t buffer_count, uint32_t buffer_bytes,
 		 uintptr_t dma_buffer_addr, uintptr_t external_addr);
 
-void dma_sg_free(struct dma_sg_elem_array *ea);
+void dma_sg_free(struct k_heap *heap, struct dma_sg_elem_array *ea);
 
 /**
  * \brief Get the total size of SG buffer

src/audio/Kconfig

@@ -42,6 +42,14 @@ config HOST_DMA_STREAM_SYNCHRONIZATION
 	  for each group, different than the default one determined by the system tick frequency.
 	  This feature will allow host lower power consumption in scenarios with deep buffering.
 
+config HOST_DMA_IPC_POSITION_UPDATES
+	bool "Support for stream position updates via IPC messages"
+	default y if IPC_MAJOR_3
+	help
+	  Support firmware functionality to report stream position updates
+	  by sending a IPC message whenever one period of audio is transfferred.
+	  Most platforms provide more efficient ways to query the DMA status.
+
 config COMP_CHAIN_DMA
 	  bool "Chain DMA component"
 	  depends on IPC_MAJOR_4

src/audio/buffers/comp_buffer.c

@@ -156,7 +156,16 @@ static void comp_buffer_free(struct sof_audio_buffer *audio_buffer)
 
 	struct mod_alloc_ctx *alloc = buffer->audio_buffer.alloc;
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	assert(alloc);
+	if (alloc->vreg)
+		vregion_free(alloc->vreg, buffer->stream.addr);
+	else
+		sof_heap_free(alloc->heap, buffer->stream.addr);
+#else
 	rfree(buffer->stream.addr);
+#endif
+
 	if (alloc && alloc->vreg) {
 		vregion_free(alloc->vreg, buffer);
 		if (!vregion_put(alloc->vreg))
@@ -254,7 +263,15 @@ struct comp_buffer *buffer_alloc(struct mod_alloc_ctx *alloc, size_t size, uint3
 		return NULL;
 	}
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	assert(alloc);
+	if (alloc->vreg)
+		stream_addr = vregion_alloc_align(alloc->vreg, VREGION_MEM_TYPE_INTERIM, size, align);
+	else
+		stream_addr = sof_heap_alloc(alloc->heap, flags, size, align);
+#else
 	stream_addr = rballoc_align(flags, size, align);
+#endif
 	if (!stream_addr) {
 		tr_err(&buffer_tr, "could not alloc size = %zu bytes of flags = 0x%x",
 		       size, flags);
@@ -264,7 +281,15 @@ struct comp_buffer *buffer_alloc(struct mod_alloc_ctx *alloc, size_t size, uint3
 	buffer = buffer_alloc_struct(alloc, stream_addr, size, flags, is_shared);
 	if (!buffer) {
 		tr_err(&buffer_tr, "could not alloc buffer structure");
+#ifdef CONFIG_SOF_USERSPACE_LL
+		assert(alloc);
+		if (alloc->vreg)
+			vregion_free(alloc->vreg, stream_addr);
+		else
+			sof_heap_free(alloc->heap, stream_addr);
+#else
 		rfree(stream_addr);
+#endif
 	}
 
 	return buffer;
@@ -292,7 +317,15 @@ struct comp_buffer *buffer_alloc_range(struct mod_alloc_ctx *alloc, size_t prefe
 		preferred_size += minimum_size - preferred_size % minimum_size;
 
 	for (size = preferred_size; size >= minimum_size; size -= minimum_size) {
+#ifdef CONFIG_SOF_USERSPACE_LL
+		assert(alloc);
+		if (alloc->vreg)
+			stream_addr = vregion_alloc_align(alloc->vreg, VREGION_MEM_TYPE_INTERIM, size, align);
+		else
+			stream_addr = sof_heap_alloc(alloc->heap, flags, size, align);
+#else
 		stream_addr = rballoc_align(flags, size, align);
+#endif
 		if (stream_addr)
 			break;
 	}
@@ -308,7 +341,15 @@ struct comp_buffer *buffer_alloc_range(struct mod_alloc_ctx *alloc, size_t prefe
 	buffer = buffer_alloc_struct(alloc, stream_addr, size, flags, is_shared);
 	if (!buffer) {
 		tr_err(&buffer_tr, "could not alloc buffer structure");
+#ifdef CONFIG_SOF_USERSPACE_LL
+		assert(alloc);
+		if (alloc->vreg)
+			vregion_free(alloc->vreg, stream_addr);
+		else
+			sof_heap_free(alloc->heap, stream_addr);
+#else
 		rfree(stream_addr);
+#endif
 	}
 
 	return buffer;
@@ -329,6 +370,7 @@ void buffer_zero(struct comp_buffer *buffer)
 int buffer_set_size(struct comp_buffer *buffer, uint32_t size, uint32_t alignment)
 {
 	void *new_ptr = NULL;
+	struct mod_alloc_ctx *alloc = buffer->audio_buffer.alloc;
 
 	CORE_CHECK_STRUCT(&buffer->audio_buffer);
 
@@ -341,14 +383,16 @@ int buffer_set_size(struct comp_buffer *buffer, uint32_t size, uint32_t alignmen
 	if (size == audio_stream_get_size(&buffer->stream))
 		return 0;
 
-	if (!alignment)
-		new_ptr = rbrealloc(audio_stream_get_addr(&buffer->stream),
-				    buffer->flags | SOF_MEM_FLAG_NO_COPY,
-				    size, audio_stream_get_size(&buffer->stream));
+#ifdef CONFIG_SOF_USERSPACE_LL
+	assert(alloc);
+	if (alloc->vreg)
+		new_ptr = vregion_alloc_align(alloc->vreg, VREGION_MEM_TYPE_INTERIM, size, alignment);
 	else
-		new_ptr = rbrealloc_align(audio_stream_get_addr(&buffer->stream),
-					  buffer->flags | SOF_MEM_FLAG_NO_COPY, size,
-					  audio_stream_get_size(&buffer->stream), alignment);
+		new_ptr = sof_heap_alloc(alloc->heap, buffer->flags, size, alignment);
+#else
+	new_ptr = rballoc_align(buffer->flags, size, alignment);
+#endif
+
 	/* we couldn't allocate bigger chunk */
 	if (!new_ptr && size > audio_stream_get_size(&buffer->stream)) {
 		buf_err(buffer, "resize can't alloc %u bytes of flags 0x%x",
@@ -357,8 +401,18 @@ int buffer_set_size(struct comp_buffer *buffer, uint32_t size, uint32_t alignmen
 	}
 
 	/* use bigger chunk, else just use the old chunk but set smaller */
-	if (new_ptr)
-		buffer->stream.addr = new_ptr;
+	if (new_ptr) {
+#ifdef CONFIG_SOF_USERSPACE_LL
+		assert(alloc);
+		if (alloc->vreg)
+			vregion_free(alloc->vreg, audio_stream_get_addr(&buffer->stream));
+		else
+			sof_heap_free(alloc->heap, audio_stream_get_addr(&buffer->stream));
+#else
+		rfree(audio_stream_get_addr(&buffer->stream));
+#endif
+		audio_stream_set_addr(&buffer->stream, new_ptr);
+	}
 
 	buffer_init_stream(buffer, size);
 
@@ -368,10 +422,10 @@ int buffer_set_size(struct comp_buffer *buffer, uint32_t size, uint32_t alignmen
 int buffer_set_size_range(struct comp_buffer *buffer, size_t preferred_size, size_t minimum_size,
 			  uint32_t alignment)
 {
-	void *ptr = audio_stream_get_addr(&buffer->stream);
 	const size_t actual_size = audio_stream_get_size(&buffer->stream);
 	void *new_ptr = NULL;
 	size_t new_size;
+	struct mod_alloc_ctx *alloc = buffer->audio_buffer.alloc;
 
 	CORE_CHECK_STRUCT(&buffer->audio_buffer);
 
@@ -389,22 +443,19 @@ int buffer_set_size_range(struct comp_buffer *buffer, size_t preferred_size, siz
 	if (preferred_size == actual_size)
 		return 0;
 
-	if (!alignment) {
-		for (new_size = preferred_size; new_size >= minimum_size;
-		     new_size -= minimum_size) {
-			new_ptr = rbrealloc(ptr, buffer->flags | SOF_MEM_FLAG_NO_COPY,
-					    new_size, actual_size);
-			if (new_ptr)
-				break;
-		}
-	} else {
-		for (new_size = preferred_size; new_size >= minimum_size;
-		     new_size -= minimum_size) {
-			new_ptr = rbrealloc_align(ptr, buffer->flags | SOF_MEM_FLAG_NO_COPY,
-						  new_size, actual_size, alignment);
-			if (new_ptr)
-				break;
-		}
+	for (new_size = preferred_size; new_size >= minimum_size;
+	     new_size -= minimum_size) {
+#ifdef CONFIG_SOF_USERSPACE_LL
+		assert(alloc);
+		if (alloc->vreg)
+			new_ptr = vregion_alloc_align(alloc->vreg, VREGION_MEM_TYPE_INTERIM, new_size, alignment);
+		else
+			new_ptr = sof_heap_alloc(alloc->heap, buffer->flags, new_size, alignment);
+#else
+		new_ptr = rballoc_align(buffer->flags, new_size, alignment);
+#endif
+		if (new_ptr)
+			break;
 	}
 
 	/* we couldn't allocate bigger chunk */
@@ -415,8 +466,18 @@ int buffer_set_size_range(struct comp_buffer *buffer, size_t preferred_size, siz
 	}
 
 	/* use bigger chunk, else just use the old chunk but set smaller */
-	if (new_ptr)
-		buffer->stream.addr = new_ptr;
+	if (new_ptr) {
+#ifdef CONFIG_SOF_USERSPACE_LL
+		assert(alloc);
+		if (alloc->vreg)
+			vregion_free(alloc->vreg, audio_stream_get_addr(&buffer->stream));
+		else
+			sof_heap_free(alloc->heap, audio_stream_get_addr(&buffer->stream));
+#else
+		rfree(audio_stream_get_addr(&buffer->stream));
+#endif
+		audio_stream_set_addr(&buffer->stream, new_ptr);
+	}
 
 	buffer_init_stream(buffer, new_size);