thesofproject · jsarha · Mar 23, 2026 · Mar 23, 2026 · Mar 27, 2026 · Feb 10, 2026
@@ -0,0 +1,29 @@
+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
+
+CONFIG_HOST_DMA_IPC_POSITION_UPDATES=y
@@ -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
@@ -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__ */
@@ -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

@@ -15,7 +15,9 @@
 #include <ipc/dai.h>
 #include <ipc4/gateway.h>
 #include <sof/schedule/ll_schedule.h>
+#include <sof/schedule/ll_schedule_domain.h>
 #include <sof/schedule/schedule.h>
+#include <rtos/alloc.h>
 #include <rtos/task.h>
 #include <sof/lib/dma.h>
 #include <sof/lib/memory.h>
@@ -59,6 +61,15 @@ struct chain_dma_data {
 	bool xrun_notification_sent;
 #endif
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	/** Kernel workqueue scheduling for chain DMA in userspace builds.
+	 *  Chain DMA needs kernel context for DMA operations, so it cannot
+	 *  run on the user-space LL timer thread.
+	 */
+	struct k_work_delayable dma_work;
+	bool stopped;
+#endif
+
 	/* local host DMA config */
 	struct sof_dma *dma_host;
 	struct dma_chan_data *chan_host;
@@ -268,6 +279,25 @@ static enum task_state chain_task_run(void *data)
 	return SOF_TASK_STATE_RESCHEDULE;
 }
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+/** Kernel workqueue handler for chain DMA periodic task.
+ *  Runs chain_task_run() in kernel context and reschedules if needed.
+ */
+static void chain_dma_work_handler(struct k_work *work)
+{
+	struct k_work_delayable *dwork = k_work_delayable_from_work(work);
+	struct chain_dma_data *cd = CONTAINER_OF(dwork, struct chain_dma_data, dma_work);
+	enum task_state state;
+
+	if (cd->stopped)
+		return;
+
+	state = chain_task_run(cd);
+	if (state == SOF_TASK_STATE_RESCHEDULE && !cd->stopped)
+		k_work_reschedule(dwork, K_USEC(LL_TIMER_PERIOD_US));
+}
+#endif
+
 static int chain_task_start(struct comp_dev *dev)
 {
 	struct chain_dma_data *cd = comp_get_drvdata(dev);
@@ -309,6 +339,12 @@ static int chain_task_start(struct comp_dev *dev)
 		}
 	}
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	cd->stopped = false;
+	k_work_init_delayable(&cd->dma_work, chain_dma_work_handler);
+	k_work_reschedule(&cd->dma_work, K_NO_WAIT);
+	cd->chain_task.state = SOF_TASK_STATE_QUEUED;
+#else
 	ret = schedule_task_init_ll(&cd->chain_task, SOF_UUID(chain_dma_uuid),
 				    SOF_SCHEDULE_LL_TIMER, SOF_TASK_PRI_HIGH,
 				    chain_task_run, cd, 0, 0);
@@ -323,27 +359,38 @@ static int chain_task_start(struct comp_dev *dev)
 		schedule_task_free(&cd->chain_task);
 		goto error_task;
 	}
+#endif
 
 	pm_policy_state_lock_get(PM_STATE_RUNTIME_IDLE, PM_ALL_SUBSTATES);
 
 	return 0;
 
+#ifndef CONFIG_SOF_USERSPACE_LL
 error_task:
 	chain_host_stop(dev);
 	chain_link_stop(dev);
 
 	return ret;
+#endif
 }
 
 static int chain_task_pause(struct comp_dev *dev)
 {
 	struct chain_dma_data *cd = comp_get_drvdata(dev);
 	int ret, ret2;
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	if (cd->chain_task.state == SOF_TASK_STATE_FREE)
+		return 0;
+
+	cd->stopped = true;
+	cd->first_data_received = false;
+#else
 	if (cd->chain_task.state == SOF_TASK_STATE_FREE)
 		return 0;
 
 	cd->first_data_received = false;
+#endif
 	if (cd->stream_direction == SOF_IPC_STREAM_PLAYBACK) {
 		ret = chain_host_stop(dev);
 		ret2 = chain_link_stop(dev);
@@ -354,7 +401,12 @@ static int chain_task_pause(struct comp_dev *dev)
 	if (!ret)
 		ret = ret2;
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	k_work_cancel_delayable_sync(&cd->dma_work, &(struct k_work_sync){});
+	cd->chain_task.state = SOF_TASK_STATE_FREE;
+#else
 	schedule_task_free(&cd->chain_task);
+#endif
 	pm_policy_state_lock_put(PM_STATE_RUNTIME_IDLE, PM_ALL_SUBSTATES);
 
 	return ret;
@@ -503,6 +555,7 @@ __cold static int chain_task_init(struct comp_dev *dev, uint8_t host_dma_id, uin
 				  uint32_t fifo_size)
 {
 	struct chain_dma_data *cd = comp_get_drvdata(dev);
+	struct mod_alloc_ctx *alloc_ctx = NULL;
 	uint32_t addr_align;
 	size_t buff_size;
 	void *buff_addr;
@@ -581,8 +634,14 @@ __cold static int chain_task_init(struct comp_dev *dev, uint8_t host_dma_id, uin
 	}
 
 	fifo_size = ALIGN_UP_INTERNAL(fifo_size, addr_align);
+
+#ifdef CONFIG_SOF_USERSPACE_LL
+	alloc_ctx = ipc_get()->ll_alloc;
+#endif
+
 	/* allocate not shared buffer */
-	cd->dma_buffer = buffer_alloc(NULL, fifo_size, SOF_MEM_FLAG_USER | SOF_MEM_FLAG_DMA,
+	cd->dma_buffer = buffer_alloc(alloc_ctx, fifo_size,
+				      SOF_MEM_FLAG_USER | SOF_MEM_FLAG_DMA,
 				      addr_align, BUFFER_USAGE_NOT_SHARED);
 
 	if (!cd->dma_buffer) {
@@ -642,14 +701,31 @@ __cold static struct comp_dev *chain_task_create(const struct comp_driver *drv,
 	if (host_dma_id >= max_chain_number)
 		return NULL;
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	dev = sof_heap_alloc(sof_sys_user_heap_get(),
+			     SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT,
+			     sizeof(*dev), 0);
+	if (!dev)
+		return NULL;
+
+	memset(dev, 0, sizeof(*dev));
+	comp_init(drv, dev, sizeof(*dev));
+#else
 	dev = comp_alloc(drv, sizeof(*dev));
 	if (!dev)
 		return NULL;
+#endif
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	cd = sof_heap_alloc(sof_sys_user_heap_get(), SOF_MEM_FLAG_USER, sizeof(*cd), 0);
+#else
 	cd = rzalloc(SOF_MEM_FLAG_USER, sizeof(*cd));
+#endif
 	if (!cd)
 		goto error;
 
+	memset(cd, 0, sizeof(*cd));
+
 	cd->first_data_received = false;
 	cd->cs = scs ? 2 : 4;
 	cd->chain_task.state = SOF_TASK_STATE_INIT;
@@ -660,9 +736,17 @@ __cold static struct comp_dev *chain_task_create(const struct comp_driver *drv,
 	if (!ret)
 		return dev;
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+	sof_heap_free(sof_sys_user_heap_get(), cd);
+#else
 	rfree(cd);
+#endif
 error:
+#ifdef CONFIG_SOF_USERSPACE_LL
+	sof_heap_free(sof_sys_user_heap_get(), dev);
+#else
 	comp_free_device(dev);
+#endif
 	return NULL;
 }
 
@@ -673,8 +757,16 @@ __cold static void chain_task_free(struct comp_dev *dev)
 	assert_can_be_cold();
 
 	chain_release(dev);
+#ifdef CONFIG_SOF_USERSPACE_LL
+	sof_heap_free(sof_sys_user_heap_get(), cd);
+#else
 	rfree(cd);
+#endif
+#ifdef CONFIG_SOF_USERSPACE_LL
+	sof_heap_free(sof_sys_user_heap_get(), dev);
+#else
 	comp_free_device(dev);
+#endif
 }
 
 static const struct comp_driver comp_chain_dma = {

@@ -36,7 +36,15 @@
 
 LOG_MODULE_REGISTER(component, CONFIG_SOF_LOG_LEVEL);
 
-static SHARED_DATA struct comp_driver_list cd;
+static APP_SYSUSER_BSS SHARED_DATA struct comp_driver_list cd;
+
+#ifdef CONFIG_SOF_USERSPACE_LL
+struct comp_driver_list *comp_drivers_get(void)
+{
+	return platform_shared_get(&cd, sizeof(cd));
+}
+EXPORT_SYMBOL(comp_drivers_get);
+#endif
 
 SOF_DEFINE_REG_UUID(component);