diff --git a/posix/include/zephyr/logging/log.h b/posix/include/zephyr/logging/log.h
new file mode 100644
index 000000000000..20ca6371bd63
--- /dev/null
+++ b/posix/include/zephyr/logging/log.h
@@ -0,0 +1,33 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright(c) 2026 Intel Corporation. All rights reserved.
+ *
+ * Stub for <zephyr/logging/log.h> used by testbench / posix builds.
+ */
+
+#ifndef __POSIX_ZEPHYR_LOGGING_LOG_H__
+#define __POSIX_ZEPHYR_LOGGING_LOG_H__
+
+#include <stdio.h>
+
+#ifndef LOG_ERR
+#define LOG_ERR(fmt, ...)	fprintf(stderr, "ERR: " fmt "\n", ##__VA_ARGS__)
+#endif
+#ifndef LOG_WRN
+#define LOG_WRN(fmt, ...)	fprintf(stderr, "WRN: " fmt "\n", ##__VA_ARGS__)
+#endif
+#ifndef LOG_INF
+#define LOG_INF(fmt, ...)	printf("INF: " fmt "\n", ##__VA_ARGS__)
+#endif
+#ifndef LOG_DBG
+#define LOG_DBG(fmt, ...)	do { } while (0)
+#endif
+
+#ifndef LOG_MODULE_REGISTER
+#define LOG_MODULE_REGISTER(ctx, level)
+#endif
+#ifndef LOG_MODULE_DECLARE
+#define LOG_MODULE_DECLARE(ctx, level)
+#endif
+
+#endif /* __POSIX_ZEPHYR_LOGGING_LOG_H__ */
diff --git a/posix/include/zephyr/sys/util.h b/posix/include/zephyr/sys/util.h
new file mode 100644
index 000000000000..027b2ef15a6d
--- /dev/null
+++ b/posix/include/zephyr/sys/util.h
@@ -0,0 +1,21 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright(c) 2026 Intel Corporation. All rights reserved.
+ *
+ * Stub for <zephyr/sys/util.h> used by testbench / posix builds.
+ */
+
+#ifndef __POSIX_ZEPHYR_SYS_UTIL_H__
+#define __POSIX_ZEPHYR_SYS_UTIL_H__
+
+#include <stddef.h>
+
+#ifndef KB
+#define KB(x) (((size_t)(x)) << 10)
+#endif
+
+#ifndef MB
+#define MB(x) (KB(x) << 10)
+#endif
+
+#endif /* __POSIX_ZEPHYR_SYS_UTIL_H__ */
diff --git a/src/audio/module_adapter/Kconfig b/src/audio/module_adapter/Kconfig
index a9f88dd1f2ad..ee0110af6451 100644
--- a/src/audio/module_adapter/Kconfig
+++ b/src/audio/module_adapter/Kconfig
@@ -13,16 +13,15 @@ menu "Processing modules"
 		  containers to allocate at once is selected by this
 		  config option.
 
-	config MODULE_MEMORY_API_DEBUG
-		bool "Turn on memory API thread safety checks"
-		default y if DEBUG
-		help
-		  The Module Memory API structures are not protected
-		  by locks. This is because the initialization,
-		  allocation, and freeing of resources should always
-		  be done in the same thread. This option adds an
-		  assert to make sure no other thread makes such
-		  operations.
+	config SOF_USERSPACE_DP_DEFAULT_HEAP_SIZE
+		int "Default heap size for DP userspace threads"
+		default 20480
+		help
+		  Defines the default heap size for userspace DP processing
+		  threads. The value can be overridden with IPC module init
+		  ext_init module payload. The default is derived from what is
+		  required for SRC module to produce all supported conversions.
+		  (This is a dummy Kconfig option to help testbench to build.)
 
 	config CADENCE_CODEC
 		bool "Cadence codec"
diff --git a/src/audio/module_adapter/module/generic.c b/src/audio/module_adapter/module/generic.c
index 95a5bb000d6a..ee1b2df92829 100644
--- a/src/audio/module_adapter/module/generic.c
+++ b/src/audio/module_adapter/module/generic.c
@@ -12,6 +12,7 @@
  */
 
 #include <rtos/symbol.h>
+#include <rtos/mutex.h>
 #include <sof/compiler_attributes.h>
 #include <sof/objpool.h>
 #include <sof/audio/module_adapter/module/generic.h>
@@ -25,16 +26,6 @@
 #include <ipc4/pipeline.h>
 #endif
 
-/* The __ZEPHYR__ condition is to keep cmocka tests working */
-#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
-#define MEM_API_CHECK_THREAD(res) do { \
-	if ((res)->rsrc_mngr != k_current_get()) \
-		LOG_WRN("mngr %p != cur %p", (res)->rsrc_mngr, k_current_get()); \
-} while (0)
-#else
-#define MEM_API_CHECK_THREAD(res)
-#endif
-
 LOG_MODULE_DECLARE(module_adapter, CONFIG_SOF_LOG_LEVEL);
 
 int module_load_config(struct comp_dev *dev, const void *cfg, size_t size)
@@ -88,6 +79,7 @@ void mod_resource_init(struct processing_module *mod)
 	struct module_resources *res = &mod->priv.resources;
 
 	/* Init memory list */
+	k_mutex_init(&res->lock);
 	list_init(&res->objpool.list);
 	res->objpool.heap = res->alloc->heap;
 	res->objpool.vreg = res->alloc->vreg;
@@ -122,9 +114,6 @@ int module_init(struct processing_module *mod)
 		return -EIO;
 	}
 
-#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
-	mod->priv.resources.rsrc_mngr = k_current_get();
-#endif
 	/* Now we can proceed with module specific initialization */
 #if CONFIG_SOF_USERSPACE_APPLICATION
 	if (mod->dev->ipc_config.proc_domain == COMP_PROCESSING_DOMAIN_DP)
@@ -185,20 +174,23 @@ void mod_heap_info(struct processing_module *mod, size_t *size, uintptr_t *start
  * unloaded. The back-end, rballoc(), always aligns the memory to
  * PLATFORM_DCACHE_ALIGN at the minimum.
  */
-void *mod_balloc_align(struct processing_module *mod, size_t size, size_t alignment)
+void *z_impl_mod_balloc_align(struct processing_module *mod, size_t size, size_t alignment)
 {
 	struct module_resources *res = &mod->priv.resources;
 	struct module_resource *container;
 
-	MEM_API_CHECK_THREAD(res);
+	k_mutex_lock(&res->lock, K_FOREVER);
 
 	container = container_get(mod);
-	if (!container)
+	if (!container) {
+		k_mutex_unlock(&res->lock);
 		return NULL;
+	}
 
 	if (!size) {
 		comp_err(mod->dev, "requested allocation of 0 bytes.");
 		container_put(mod, container);
+		k_mutex_unlock(&res->lock);
 		return NULL;
 	}
 
@@ -210,6 +202,7 @@ void *mod_balloc_align(struct processing_module *mod, size_t size, size_t alignm
 		comp_err(mod->dev, "Failed to alloc %zu bytes %zu alignment for comp %#x.",
 			 size, alignment, dev_comp_id(mod->dev));
 		container_put(mod, container);
+		k_mutex_unlock(&res->lock);
 		return NULL;
 	}
 	/* Store reference to allocated memory */
@@ -221,9 +214,10 @@ void *mod_balloc_align(struct processing_module *mod, size_t size, size_t alignm
 	if (res->heap_usage > res->heap_high_water_mark)
 		res->heap_high_water_mark = res->heap_usage;
 
+	k_mutex_unlock(&res->lock);
 	return ptr;
 }
-EXPORT_SYMBOL(mod_balloc_align);
+EXPORT_SYMBOL(z_impl_mod_balloc_align);
 
 /**
  * Allocates aligned memory block with flags for module.
@@ -241,15 +235,18 @@ void *z_impl_mod_alloc_ext(struct processing_module *mod, uint32_t flags, size_t
 	struct module_resources *res = &mod->priv.resources;
 	struct module_resource *container;
 
-	MEM_API_CHECK_THREAD(res);
+	k_mutex_lock(&res->lock, K_FOREVER);
 
 	container = container_get(mod);
-	if (!container)
+	if (!container) {
+		k_mutex_unlock(&res->lock);
 		return NULL;
+	}
 
 	if (!size) {
 		comp_err(mod->dev, "requested allocation of 0 bytes.");
 		container_put(mod, container);
+		k_mutex_unlock(&res->lock);
 		return NULL;
 	}
 
@@ -260,6 +257,7 @@ void *z_impl_mod_alloc_ext(struct processing_module *mod, uint32_t flags, size_t
 		comp_err(mod->dev, "Failed to alloc %zu bytes %zu alignment for comp %#x.",
 			 size, alignment, dev_comp_id(mod->dev));
 		container_put(mod, container);
+		k_mutex_unlock(&res->lock);
 		return NULL;
 	}
 	/* Store reference to allocated memory */
@@ -271,6 +269,7 @@ void *z_impl_mod_alloc_ext(struct processing_module *mod, uint32_t flags, size_t
 	if (res->heap_usage > res->heap_high_water_mark)
 		res->heap_high_water_mark = res->heap_usage;
 
+	k_mutex_unlock(&res->lock);
 	return ptr;
 }
 EXPORT_SYMBOL(z_impl_mod_alloc_ext);
@@ -283,21 +282,24 @@ EXPORT_SYMBOL(z_impl_mod_alloc_ext);
  * Like comp_data_blob_handler_new() but the handler is automatically freed.
  */
 #if CONFIG_COMP_BLOB
-struct comp_data_blob_handler *mod_data_blob_handler_new(struct processing_module *mod)
+struct comp_data_blob_handler *z_impl_mod_data_blob_handler_new(struct processing_module *mod)
 {
-	struct module_resources * __maybe_unused res = &mod->priv.resources;
+	struct module_resources *res = &mod->priv.resources;
 	struct comp_data_blob_handler *bhp;
 	struct module_resource *container;
 
-	MEM_API_CHECK_THREAD(res);
+	k_mutex_lock(&res->lock, K_FOREVER);
 
 	container = container_get(mod);
-	if (!container)
+	if (!container) {
+		k_mutex_unlock(&res->lock);
 		return NULL;
+	}
 
 	bhp = comp_data_blob_handler_new_ext(mod->dev, false, NULL, NULL);
 	if (!bhp) {
 		container_put(mod, container);
+		k_mutex_unlock(&res->lock);
 		return NULL;
 	}
 
@@ -305,9 +307,10 @@ struct comp_data_blob_handler *mod_data_blob_handler_new(struct processing_modul
 	container->size = 0;
 	container->type = MOD_RES_BLOB_HANDLER;
 
+	k_mutex_unlock(&res->lock);
 	return bhp;
 }
-EXPORT_SYMBOL(mod_data_blob_handler_new);
+EXPORT_SYMBOL(z_impl_mod_data_blob_handler_new);
 #endif
 
 /**
@@ -325,15 +328,18 @@ const void *z_impl_mod_fast_get(struct processing_module *mod, const void * cons
 	struct module_resource *container;
 	const void *ptr;
 
-	MEM_API_CHECK_THREAD(res);
+	k_mutex_lock(&res->lock, K_FOREVER);
 
 	container = container_get(mod);
-	if (!container)
+	if (!container) {
+		k_mutex_unlock(&res->lock);
 		return NULL;
+	}
 
 	ptr = fast_get(res->alloc, dram_ptr, size);
 	if (!ptr) {
 		container_put(mod, container);
+		k_mutex_unlock(&res->lock);
 		return NULL;
 	}
 
@@ -341,6 +347,7 @@ const void *z_impl_mod_fast_get(struct processing_module *mod, const void * cons
 	container->size = 0;
 	container->type = MOD_RES_FAST_GET;
 
+	k_mutex_unlock(&res->lock);
 	return ptr;
 }
 EXPORT_SYMBOL(z_impl_mod_fast_get);
@@ -412,14 +419,17 @@ int z_impl_mod_free(struct processing_module *mod, const void *ptr)
 {
 	struct module_resources *res = &mod->priv.resources;
 
-	MEM_API_CHECK_THREAD(res);
 	if (!ptr)
 		return 0;
 
 	/* Find which container holds this memory */
 	struct mod_res_cb_arg cb_arg = {mod, ptr};
+
+	k_mutex_lock(&res->lock, K_FOREVER);
 	int ret = objpool_iterate(&res->objpool, mod_res_free, &cb_arg);
 
+	k_mutex_unlock(&res->lock);
+
 	if (ret < 0)
 		comp_err(mod->dev, "error: could not find memory pointed by %p", ptr);
 
@@ -463,6 +473,20 @@ void *z_vrfy_mod_alloc_ext(struct processing_module *mod, uint32_t flags, size_t
 }
 #include <zephyr/syscalls/mod_alloc_ext_mrsh.c>
 
+void *z_vrfy_mod_balloc_align(struct processing_module *mod, size_t size, size_t alignment)
+{
+	size_t h_size = 0;
+	uintptr_t h_start;
+
+	K_OOPS(K_SYSCALL_MEMORY_WRITE(mod, sizeof(*mod)));
+	mod_heap_info(mod, &h_size, &h_start);
+	if (h_size)
+		K_OOPS(K_SYSCALL_MEMORY_WRITE(h_start, h_size));
+
+	return z_impl_mod_balloc_align(mod, size, alignment);
+}
+#include <zephyr/syscalls/mod_balloc_align_mrsh.c>
+
 int z_vrfy_mod_free(struct processing_module *mod, const void *ptr)
 {
 	size_t h_size = 0;
@@ -476,6 +500,22 @@ int z_vrfy_mod_free(struct processing_module *mod, const void *ptr)
 	return z_impl_mod_free(mod, ptr);
 }
 #include <zephyr/syscalls/mod_free_mrsh.c>
+
+#if CONFIG_COMP_BLOB
+struct comp_data_blob_handler *z_vrfy_mod_data_blob_handler_new(struct processing_module *mod)
+{
+	size_t h_size = 0;
+	uintptr_t h_start;
+
+	K_OOPS(K_SYSCALL_MEMORY_WRITE(mod, sizeof(*mod)));
+	mod_heap_info(mod, &h_size, &h_start);
+	if (h_size)
+		K_OOPS(K_SYSCALL_MEMORY_WRITE(h_start, h_size));
+
+	return z_impl_mod_data_blob_handler_new(mod);
+}
+#include <zephyr/syscalls/mod_data_blob_handler_new_mrsh.c>
+#endif
 #endif
 
 #if CONFIG_COMP_BLOB
@@ -698,13 +738,13 @@ void mod_free_all(struct processing_module *mod)
 {
 	struct module_resources *res = &mod->priv.resources;
 
-	MEM_API_CHECK_THREAD(res);
-
 	/* Free all contents found in used containers */
 	struct mod_res_cb_arg cb_arg = {mod, NULL};
 
+	k_mutex_lock(&res->lock, K_FOREVER);
 	objpool_iterate(&res->objpool, mod_res_free, &cb_arg);
 	objpool_prune(&res->objpool);
+	k_mutex_unlock(&res->lock);
 
 	/* Make sure resource lists and accounting are reset */
 	mod_resource_init(mod);
diff --git a/src/audio/module_adapter/module_adapter.c b/src/audio/module_adapter/module_adapter.c
index 3da4079d757e..3f66ab585cd5 100644
--- a/src/audio/module_adapter/module_adapter.c
+++ b/src/audio/module_adapter/module_adapter.c
@@ -59,17 +59,39 @@ struct comp_dev *module_adapter_new(const struct comp_driver *drv,
 #endif
 
 static struct vregion *module_adapter_dp_heap_new(const struct comp_ipc_config *config,
-						  size_t *heap_size)
+						  const struct module_ext_init_data *ext_init)
 {
 	/* src-lite with 8 channels has been seen allocating 14k in one go */
-	/* FIXME: the size will be derived from configuration */
-	const size_t buf_size = 28 * 1024;
+	size_t buf_size = CONFIG_SOF_USERSPACE_DP_DEFAULT_HEAP_SIZE;
 
+#if CONFIG_IPC_MAJOR_4
+	if (config->ipc_extended_init && ext_init && ext_init->dp_data &&
+	    ext_init->dp_data->heap_bytes > 0) {
+		if (ext_init->dp_data->heap_bytes > MB(64)) {
+			LOG_ERR("Bad heap size %u bytes for %#x",
+				ext_init->dp_data->heap_bytes, config->id);
+			return NULL;
+		}
+
+		buf_size = ext_init->dp_data->heap_bytes;
+
+		LOG_INF("%zu byte heap size requested in IPC for %#x", buf_size, config->id);
+	}
+#endif
+	/*
+	 * A 1-to-1 replacement of the original heap implementation would be to
+	 * have "lifetime size" equal to 0. But (1) this is invalid for
+	 * vregion_create() and (2) we gradually move objects, that are simple
+	 * to move to the lifetime buffer. Make it 4k for the beginning.
+	 */
 	return vregion_create(buf_size);
 }
 
-static struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv,
-							  const struct comp_ipc_config *config)
+static
+struct processing_module *module_adapter_mem_alloc(const struct comp_driver *drv,
+						   const struct comp_ipc_config *config,
+						   const struct module_ext_init_data *ext_init,
+						   struct mod_alloc_ctx *ppl_alloc)
 {
 	struct k_heap *mod_heap;
 	struct vregion *mod_vreg;
@@ -84,16 +106,20 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 	 */
 	uint32_t flags = config->proc_domain == COMP_PROCESSING_DOMAIN_DP ?
 		SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT : SOF_MEM_FLAG_USER;
-	size_t heap_size;
+	bool use_ppl_alloc = ppl_alloc &&
+			     config->proc_domain == COMP_PROCESSING_DOMAIN_LL;
 
 	if (config->proc_domain == COMP_PROCESSING_DOMAIN_DP && IS_ENABLED(CONFIG_SOF_VREGIONS) &&
 	    IS_ENABLED(CONFIG_USERSPACE) && !IS_ENABLED(CONFIG_SOF_USERSPACE_USE_DRIVER_HEAP)) {
-		mod_vreg = module_adapter_dp_heap_new(config, &heap_size);
+		mod_vreg = module_adapter_dp_heap_new(config, ext_init);
 		if (!mod_vreg) {
 			comp_cl_err(drv, "Failed to allocate DP module heap / vregion");
 			return NULL;
 		}
 		mod_heap = NULL;
+	} else if (use_ppl_alloc) {
+		mod_vreg = ppl_alloc->vreg ? vregion_get(ppl_alloc->vreg) : NULL;
+		mod_heap = ppl_alloc->heap;
 	} else {
 #ifdef CONFIG_SOF_USERSPACE_LL
 		mod_heap = sof_sys_user_heap_get();
@@ -101,30 +127,41 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 #else
 		mod_heap = drv->user_heap;
 #endif
-		heap_size = 0;
 		mod_vreg = NULL;
 	}
 
-	if (!mod_vreg)
+	if (use_ppl_alloc) {
+		/* LL modules use the pipeline's alloc context */
+		mod = sof_ctx_alloc(ppl_alloc, flags, sizeof(*mod), 0);
+	} else if (!mod_vreg) {
 		mod = sof_heap_alloc(mod_heap, flags, sizeof(*mod), 0);
-	else if (flags & SOF_MEM_FLAG_COHERENT)
+	} else if (flags & SOF_MEM_FLAG_COHERENT) {
 		mod = vregion_alloc_coherent(mod_vreg, sizeof(*mod));
-	else
+	} else {
 		mod = vregion_alloc(mod_vreg, sizeof(*mod));
+	}
 
 	if (!mod) {
 		comp_cl_err(drv, "failed to allocate memory for module");
 		goto emod;
 	}
 
-	struct mod_alloc_ctx *alloc = sof_heap_alloc(mod_heap, flags, sizeof(*alloc), 0);
+	struct mod_alloc_ctx *alloc;
 
-	if (!alloc)
-		goto ealloc;
+	if (use_ppl_alloc) {
+		/* LL modules share the pipeline's alloc context */
+		alloc = ppl_alloc;
+	} else {
+		alloc = sof_heap_alloc(mod_heap, flags, sizeof(*alloc), 0);
+		if (!alloc)
+			goto ealloc;
+
+		memset(alloc, 0, sizeof(*alloc));
+		alloc->heap = mod_heap;
+		alloc->vreg = mod_vreg;
+	}
 
 	memset(mod, 0, sizeof(*mod));
-	alloc->heap = mod_heap;
-	alloc->vreg = mod_vreg;
 	mod->priv.resources.alloc = alloc;
 	mod_resource_init(mod);
 
@@ -134,7 +171,9 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 	 * then it can be cached. Effectively it can be only cached in
 	 * single-core configurations.
 	 */
-	if (mod_vreg)
+	if (use_ppl_alloc)
+		dev = sof_ctx_alloc(ppl_alloc, SOF_MEM_FLAG_COHERENT, sizeof(*dev), 0);
+	else if (mod_vreg)
 		dev = vregion_alloc_coherent(mod_vreg, sizeof(*dev));
 	else
 		dev = sof_heap_alloc(mod_heap, SOF_MEM_FLAG_COHERENT, sizeof(*dev), 0);
@@ -153,14 +192,20 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 	return mod;
 
 edev:
-	sof_heap_free(mod_heap, alloc);
+	if (!use_ppl_alloc)
+		sof_heap_free(mod_heap, alloc);
 ealloc:
-	if (mod_vreg)
+	if (use_ppl_alloc)
+		sof_ctx_free(ppl_alloc, mod);
+	else if (mod_vreg)
 		vregion_free(mod_vreg, mod);
 	else
 		sof_heap_free(mod_heap, mod);
 emod:
-	vregion_put(mod_vreg);
+	if (use_ppl_alloc)
+		vregion_put(ppl_alloc->vreg);
+	else
+		vregion_put(mod_vreg);
 
 	return NULL;
 }
@@ -168,26 +213,27 @@ static struct processing_module *module_adapter_mem_alloc(const struct comp_driv
 static void module_adapter_mem_free(struct processing_module *mod)
 {
 	struct mod_alloc_ctx *alloc = mod->priv.resources.alloc;
-	struct k_heap *mod_heap = alloc->heap;
+	bool ppl_alloc = mod->dev->ipc_config.proc_domain == COMP_PROCESSING_DOMAIN_LL &&
+			 mod->dev->pipeline && mod->dev->pipeline->alloc == alloc;
 
 	/*
 	 * In principle it shouldn't even be needed to free individual objects
 	 * on the module heap since we're freeing the heap itself too
 	 */
 #if CONFIG_IPC_MAJOR_4
-	sof_heap_free(mod_heap, mod->priv.cfg.input_pins);
+	sof_heap_free(alloc->heap, mod->priv.cfg.input_pins);
 #endif
-	if (alloc->vreg) {
-		struct vregion *mod_vreg = alloc->vreg;
-
-		vregion_free(mod_vreg, mod->dev);
-		vregion_free(mod_vreg, mod);
-		if (!vregion_put(mod_vreg))
-			sof_heap_free(alloc->heap, alloc);
+	sof_ctx_free(alloc, mod->dev);
+	sof_ctx_free(alloc, mod);
+
+	if (ppl_alloc) {
+		/* alloc belongs to pipeline, just release vregion reference */
+		vregion_put(alloc->vreg);
+	} else if (alloc->vreg) {
+		if (!vregion_put(alloc->vreg))
+			rfree(alloc);
 	} else {
-		sof_heap_free(mod_heap, mod->dev);
-		sof_heap_free(mod_heap, mod);
-		sof_heap_free(mod_heap, alloc);
+		rfree(alloc);
 	}
 }
 
@@ -230,8 +276,32 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 			return NULL;
 	}
 #endif
+	const struct module_ext_init_data *ext_init =
+#if CONFIG_IPC_MAJOR_4
+		&ext_data;
+#else
+		NULL;
+#endif
 
-	struct processing_module *mod = module_adapter_mem_alloc(drv, config);
+#if CONFIG_IPC_MAJOR_4
+	struct ipc_comp_dev *ipc_pipe;
+	struct ipc *ipc = ipc_get();
+	struct mod_alloc_ctx *ppl_alloc = NULL;
+
+	/* resolve the pipeline pointer early to pass its alloc to mem_alloc */
+	ipc_pipe = ipc_get_comp_by_ppl_id(ipc, COMP_TYPE_PIPELINE, config->pipeline_id,
+					  IPC_COMP_IGNORE_REMOTE);
+	if (ipc_pipe && ipc_pipe->pipeline)
+		ppl_alloc = ipc_pipe->pipeline->alloc;
+#endif
+
+	struct processing_module *mod = module_adapter_mem_alloc(drv, config, ext_init,
+#if CONFIG_IPC_MAJOR_4
+								 ppl_alloc
+#else
+								 NULL
+#endif
+								 );
 
 	if (!mod)
 		return NULL;
@@ -244,6 +314,18 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 
 	struct comp_dev *dev = mod->dev;
 
+	dst = &mod->priv.cfg;
+	/*
+	 * NOTE: dst->ext_data points to stack variable and contains
+	 *       pointers to IPC payload mailbox, so its only valid in
+	 *       functions that are called from this function. This is
+	 *       why the pointer is set to NULL before this function
+	 *       exits.
+	 */
+#if CONFIG_IPC_MAJOR_4
+	dst->ext_data = &ext_data;
+#endif
+
 #if CONFIG_ZEPHYR_DP_SCHEDULER
 	/* create a task for DP processing */
 	if (config->proc_domain == COMP_PROCESSING_DOMAIN_DP) {
@@ -256,16 +338,6 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 	}
 #endif /* CONFIG_ZEPHYR_DP_SCHEDULER */
 
-	dst = &mod->priv.cfg;
-	/*
-	 * NOTE: dst->ext_data points to stack variable and contains
-	 *       pointers to IPC payload mailbox, so its only valid in
-	 *       functions that called from this function. This why
-	 *       the pointer is set NULL before this function exits.
-	 */
-#if CONFIG_IPC_MAJOR_4
-	dst->ext_data = &ext_data;
-#endif
 	ret = module_adapter_init_data(dev, dst, config, &spec);
 	if (ret) {
 		comp_err(dev, "%d: module init data failed",
@@ -288,12 +360,7 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 		goto err;
 
 #if CONFIG_IPC_MAJOR_4
-	struct ipc_comp_dev *ipc_pipe;
-	struct ipc *ipc = ipc_get();
-
 	/* set the pipeline pointer if ipc_pipe is valid */
-	ipc_pipe = ipc_get_comp_by_ppl_id(ipc, COMP_TYPE_PIPELINE, config->pipeline_id,
-					  IPC_COMP_IGNORE_REMOTE);
 	if (ipc_pipe) {
 		dev->pipeline = ipc_pipe->pipeline;
 
diff --git a/src/audio/pipeline/pipeline-graph.c b/src/audio/pipeline/pipeline-graph.c
index 915987051275..9b834b31b18f 100644
--- a/src/audio/pipeline/pipeline-graph.c
+++ b/src/audio/pipeline/pipeline-graph.c
@@ -25,6 +25,7 @@
 #include <ipc/stream.h>
 #include <ipc/topology.h>
 #include <ipc4/module.h>
+#include <ipc4/pipeline.h>
 #include <errno.h>
 #include <stdbool.h>
 #include <stddef.h>
@@ -114,6 +115,7 @@ void pipeline_posn_init(struct sof *sof)
 struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_t priority,
 			      uint32_t comp_id, struct create_pipeline_params *pparams)
 {
+	struct mod_alloc_ctx *alloc;
 	struct sof_ipc_stream_posn posn;
 	struct pipeline *p;
 	int ret;
@@ -124,17 +126,33 @@ struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_
 	/* show heap status */
 	heap_trace_all(0);
 
-	/* allocate new pipeline */
-	p = sof_heap_alloc(heap, SOF_MEM_FLAG_USER, sizeof(*p), 0);
-	if (!p) {
-		pipe_cl_err("Out of Memory");
+	alloc = rzalloc(SOF_MEM_FLAG_USER, sizeof(*alloc));
+	if (!alloc) {
+		pipe_cl_err("Failed to allocate pipeline alloc context");
 		return NULL;
 	}
 
-	memset(p, 0, sizeof(*p));
+	alloc->heap = heap;
+
+	/* Create vregion for pipeline and its modules if size info is available */
+	if (IS_ENABLED(CONFIG_SOF_VREGIONS) &&
+	    pparams && pparams->mem_data && pparams->mem_data->heap_bytes) {
+		alloc->vreg = vregion_create(pparams->mem_data->heap_bytes);
+		if (!alloc->vreg)
+			pipe_cl_err("Failed to create pipeline vregion of %zu bytes, using heap",
+				    pparams->mem_data->heap_bytes);
+	}
+
+	p = sof_ctx_zalloc(alloc, SOF_MEM_FLAG_USER, sizeof(*p), 0);
+	if (!p) {
+		pipe_cl_err("Out of Memory");
+		goto free_alloc;
+	}
 
 	/* init pipeline */
 	p->heap = heap;
+	p->alloc = alloc;
+
 	p->comp_id = comp_id;
 	p->priority = priority;
 	p->pipeline_id = pipeline_id;
@@ -167,7 +185,10 @@ struct pipeline *pipeline_new(struct k_heap *heap, uint32_t pipeline_id, uint32_
 
 	return p;
 free:
-	sof_heap_free(heap, p);
+	sof_ctx_free(alloc, p);
+free_alloc:
+	vregion_put(alloc->vreg);
+	rfree(alloc);
 	return NULL;
 }
 
@@ -247,6 +268,8 @@ void pipeline_disconnect(struct comp_dev *comp, struct comp_buffer *buffer, int
 /* pipelines must be inactive */
 int pipeline_free(struct pipeline *p)
 {
+	struct mod_alloc_ctx *alloc = p->alloc;
+
 	pipe_dbg(p, "entry");
 
 	/*
@@ -267,7 +290,12 @@ int pipeline_free(struct pipeline *p)
 	pipeline_posn_offset_put(p->posn_offset);
 
 	/* now free the pipeline */
-	sof_heap_free(p->heap, p);
+	sof_ctx_free(alloc, p);
+
+	/* free alloc context and vregion */
+	if (vregion_put(alloc->vreg))
+		pipe_cl_warn("pipeline vregion still in use");
+	rfree(alloc);
 
 	/* show heap status */
 	heap_trace_all(0);
@@ -344,6 +372,10 @@ int pipeline_complete(struct pipeline *p, struct comp_dev *source,
 
 	p->source_comp = source;
 	p->sink_comp = sink;
+
+	if (p->alloc && p->alloc->vreg)
+		vregion_set_interim(p->alloc->vreg);
+
 	p->status = COMP_STATE_READY;
 
 	/* show heap status */
diff --git a/src/audio/pipeline/pipeline-schedule.c b/src/audio/pipeline/pipeline-schedule.c
index cb4ec8fd3c62..70ae1186b2a2 100644
--- a/src/audio/pipeline/pipeline-schedule.c
+++ b/src/audio/pipeline/pipeline-schedule.c
@@ -398,6 +398,7 @@ int pipeline_comp_dp_task_init(struct comp_dev *comp)
 {
 	/* DP tasks are guaranteed to have a module_adapter */
 	struct processing_module *mod = comp_mod(comp);
+	size_t stack_size = TASK_DP_STACK_SIZE;
 	struct task_ops ops  = {
 		.run		= dp_task_run,
 		.get_deadline	= NULL,
@@ -413,8 +414,17 @@ int pipeline_comp_dp_task_init(struct comp_dev *comp)
 	unsigned int flags = IS_ENABLED(CONFIG_USERSPACE) ? K_USER : 0;
 #endif
 
+	if (mod->priv.cfg.ext_data && mod->priv.cfg.ext_data->dp_data &&
+	    mod->priv.cfg.ext_data->dp_data->stack_bytes > 0) {
+		stack_size = MAX(mod->priv.cfg.ext_data->dp_data->stack_bytes,
+				 CONFIG_ZEPHYR_DP_SCHEDULER_MIN_STACK_SIZE);
+		comp_info(comp, "stack size set to %zu, %zu requested, min allowed %zu",
+			  stack_size, mod->priv.cfg.ext_data->dp_data->stack_bytes,
+			  CONFIG_ZEPHYR_DP_SCHEDULER_MIN_STACK_SIZE);
+	}
+
 	return scheduler_dp_task_init(&comp->task, SOF_UUID(dp_task_uuid), &ops, mod,
-				      comp->ipc_config.core, TASK_DP_STACK_SIZE, flags);
+				      comp->ipc_config.core, stack_size, flags);
 }
 #endif /* CONFIG_ZEPHYR_DP_SCHEDULER */
 
diff --git a/src/audio/src/src.c b/src/audio/src/src.c
index 9870ad911ca8..b75ff5a4cce7 100644
--- a/src/audio/src/src.c
+++ b/src/audio/src/src.c
@@ -34,19 +34,16 @@
 
 LOG_MODULE_DECLARE(src, CONFIG_SOF_LOG_LEVEL);
 
-static int src_prepare(struct processing_module *mod,
-		       struct sof_source **sources, int num_of_sources,
-		       struct sof_sink **sinks, int num_of_sinks)
+/* Set rate table pointers, compute rate indices, and copy filter stages.
+ * Must be in src.c because src_table1/2, src_in_fs, etc. come from
+ * the coefficient headers included by this file.
+ */
+static int src_setup_stages(struct processing_module *mod)
 {
 	struct comp_data *cd = module_get_private_data(mod);
 	struct src_param *a = &cd->param;
 	int ret;
 
-	comp_info(mod->dev, "entry");
-
-	if (num_of_sources != 1 || num_of_sinks != 1)
-		return -EINVAL;
-
 	a->in_fs = src_in_fs;
 	a->out_fs = src_out_fs;
 	a->num_in_fs = NUM_IN_FS;
@@ -54,27 +51,46 @@ static int src_prepare(struct processing_module *mod,
 	a->max_fir_delay_size_xnch = (PLATFORM_MAX_CHANNELS * MAX_FIR_DELAY_SIZE);
 	a->max_out_delay_size_xnch = (PLATFORM_MAX_CHANNELS * MAX_OUT_DELAY_SIZE);
 
-	src_get_source_sink_params(mod->dev, sources[0], sinks[0]);
-
 	ret = src_param_set(mod->dev, cd);
 	if (ret < 0)
 		return ret;
 
-	ret = src_allocate_copy_stages(mod, a,
-				       src_table1[a->idx_out][a->idx_in],
-				       src_table2[a->idx_out][a->idx_in]);
-	if (ret < 0)
-		return ret;
+	return src_allocate_copy_stages(mod, a,
+					src_table1[a->idx_out][a->idx_in],
+					src_table2[a->idx_out][a->idx_in]);
+}
 
-	ret = src_params_general(mod, sources[0], sinks[0]);
+static int src_do_init(struct processing_module *mod)
+{
+	struct comp_data *cd;
+	int ret;
+
+	ret = src_init(mod);
 	if (ret < 0)
 		return ret;
 
-	return src_prepare_general(mod, sources[0], sinks[0]);
+	cd = module_get_private_data(mod);
+	cd->setup_stages = src_setup_stages;
+
+	return src_init_stages(mod);
+}
+
+static int src_prepare(struct processing_module *mod,
+		       struct sof_source **sources, int num_of_sources,
+		       struct sof_sink **sinks, int num_of_sinks)
+{
+	comp_info(mod->dev, "entry");
+
+	if (num_of_sources != 1 || num_of_sinks != 1)
+		return -EINVAL;
+
+	src_get_source_sink_params(mod->dev, sources[0], sinks[0]);
+
+	return src_prepare_do(mod, sources[0], sinks[0]);
 }
 
 static const struct module_interface src_interface = {
-	.init = src_init,
+	.init = src_do_init,
 	.prepare = src_prepare,
 	.process = src_process,
 	.is_ready_to_process = src_is_ready_to_process,
diff --git a/src/audio/src/src_common.c b/src/audio/src/src_common.c
index 3a9c7dac280f..e4ccf76ae3ba 100644
--- a/src/audio/src/src_common.c
+++ b/src/audio/src/src_common.c
@@ -574,6 +574,86 @@ int src_params_general(struct processing_module *mod,
 	return 0;
 }
 
+/* Allocate delay lines and initialize the polyphase SRC filter.
+ * Assumes that cd->param rate table pointers (in_fs, out_fs, etc.)
+ * and stage pointers (stage1, stage2) are already set up via
+ * cd->setup_stages().
+ */
+int src_allocate_delay_lines(struct processing_module *mod)
+{
+	struct comp_data *cd = module_get_private_data(mod);
+	struct comp_dev *dev = mod->dev;
+	size_t delay_lines_size;
+	int32_t *buffer_start;
+	int n;
+	int ret;
+
+	/* For LL modules dev->period is already set from the pipeline.
+	 * Compute dev->frames so buffer sizing works.
+	 */
+	if (!dev->frames)
+		component_set_nearest_period_frames(dev, cd->sink_rate);
+
+	if (!cd->sink_rate) {
+		comp_err(dev, "zero sink rate");
+		return -EINVAL;
+	}
+
+	cd->source_frames = dev->frames * cd->source_rate / cd->sink_rate;
+	cd->sink_frames = dev->frames;
+
+	/* Allocate needed memory for delay lines */
+	ret = src_buffer_lengths(dev, cd, cd->channels_count);
+	if (ret < 0) {
+		comp_err(dev, "src_buffer_lengths() failed");
+		return ret;
+	}
+
+	delay_lines_size = ALIGN_UP(sizeof(int32_t) * cd->param.total, 8);
+	if (delay_lines_size == 0) {
+		comp_err(dev, "delay_lines_size = 0");
+		return -EINVAL;
+	}
+
+	mod_free(mod, cd->delay_lines);
+
+	cd->delay_lines = mod_alloc(mod, delay_lines_size);
+	if (!cd->delay_lines) {
+		comp_err(dev, "failed to alloc cd->delay_lines, delay_lines_size = %zu",
+			 delay_lines_size);
+		return -ENOMEM;
+	}
+
+	memset(cd->delay_lines, 0, delay_lines_size);
+	buffer_start = cd->delay_lines + ALIGN_UP(cd->param.sbuf_length, 2);
+
+	/* Initialize SRC for actual sample rate */
+	n = src_polyphase_init(&cd->src, &cd->param, buffer_start);
+
+	/* Reset stage buffer */
+	cd->sbuf_r_ptr = cd->delay_lines;
+	cd->sbuf_w_ptr = cd->delay_lines;
+	cd->sbuf_avail = 0;
+
+	switch (n) {
+	case 0:
+		cd->src_func = src_copy_sxx;
+		break;
+	case 1:
+		cd->src_func = src_1s;
+		break;
+	case 2:
+		cd->src_func = src_2s;
+		break;
+	default:
+		comp_info(dev, "missing coefficients for requested rates combination");
+		cd->src_func = src_fallback;
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
 int src_param_set(struct comp_dev *dev, struct comp_data *cd)
 {
 	struct src_param *a = &cd->param;
diff --git a/src/audio/src/src_common.h b/src/audio/src/src_common.h
index 98f29a263131..126b112737d3 100644
--- a/src/audio/src/src_common.h
+++ b/src/audio/src/src_common.h
@@ -167,6 +167,7 @@ struct comp_data {
 	int (*src_func)(struct comp_data *cd, struct sof_source *source,
 			struct sof_sink *sink);
 	void (*polyphase_func)(struct src_stage_prm *s);
+	int (*setup_stages)(struct processing_module *mod);
 };
 
 #if CONFIG_IPC_MAJOR_4
@@ -218,6 +219,7 @@ static inline int src_fallback(struct comp_data *cd,
 int src_allocate_copy_stages(struct processing_module *mod, struct src_param *prm,
 			     const struct src_stage *stage_src1,
 			     const struct src_stage *stage_src2);
+int src_allocate_delay_lines(struct processing_module *mod);
 int src_rate_check(const void *spec);
 int src_set_params(struct processing_module *mod, struct sof_sink *sink);
 
@@ -227,6 +229,9 @@ int src_prepare_general(struct processing_module *mod,
 			struct sof_source *source,
 			struct sof_sink *sink);
 int src_init(struct processing_module *mod);
+int src_init_stages(struct processing_module *mod);
+int src_prepare_do(struct processing_module *mod,
+		   struct sof_source *source, struct sof_sink *sink);
 
 int src_copy_sxx(struct comp_data *cd, struct sof_source *source,
 		 struct sof_sink *sink);
diff --git a/src/audio/src/src_ipc3.c b/src/audio/src/src_ipc3.c
index 541efcdb24be..636c50bfdcea 100644
--- a/src/audio/src/src_ipc3.c
+++ b/src/audio/src/src_ipc3.c
@@ -195,3 +195,27 @@ int src_init(struct processing_module *mod)
 	return 0;
 }
 
+/* IPC3: No filter allocation at init, change ipc3 behavior as little as possible */
+int src_init_stages(struct processing_module *mod)
+{
+	return 0;
+}
+
+/* IPC3: Full filter setup at prepare time */
+int src_prepare_do(struct processing_module *mod,
+		   struct sof_source *source, struct sof_sink *sink)
+{
+	struct comp_data *cd = module_get_private_data(mod);
+	int ret;
+
+	ret = cd->setup_stages(mod);
+	if (ret < 0)
+		return ret;
+
+	ret = src_params_general(mod, source, sink);
+	if (ret < 0)
+		return ret;
+
+	return src_prepare_general(mod, source, sink);
+}
+
diff --git a/src/audio/src/src_ipc4.c b/src/audio/src/src_ipc4.c
index 91f286347a5f..6e6f3c51b7be 100644
--- a/src/audio/src/src_ipc4.c
+++ b/src/audio/src/src_ipc4.c
@@ -246,3 +246,67 @@ __cold int src_init(struct processing_module *mod)
 	return 0;
 }
 
+/* Called after src_init() and setup_stages callback is set.
+ * Allocate filter stages and delay lines at init time.
+ */
+int src_init_stages(struct processing_module *mod)
+{
+	struct comp_data *cd = module_get_private_data(mod);
+	struct comp_dev *dev = mod->dev;
+	int ret;
+
+	ret = cd->setup_stages(mod);
+	if (ret < 0)
+		return ret;
+
+	/* For DP modules, dev->period is not yet set at init time (it's
+	 * computed in src_set_params at prepare). Derive it here from the
+	 * IPC config's output buffer size so that delay line allocation
+	 * uses correct buffer sizes.
+	 */
+	if (dev->ipc_config.proc_domain == COMP_PROCESSING_DOMAIN_DP && !dev->frames) {
+		uint32_t frame_bytes = cd->channels_count * cd->sample_container_bytes;
+
+		if (frame_bytes && cd->sink_rate) {
+			dev->period = 1000000ULL *
+				(cd->ipc_config.base.obs / frame_bytes) /
+				cd->sink_rate;
+			dev->period /= LL_TIMER_PERIOD_US;
+			dev->period *= LL_TIMER_PERIOD_US;
+			component_set_nearest_period_frames(dev, cd->sink_rate);
+		}
+	}
+
+	return src_allocate_delay_lines(mod);
+}
+
+/* At prepare time just verify rates and set downstream params */
+int src_prepare_do(struct processing_module *mod,
+		   struct sof_source *source, struct sof_sink *sink)
+{
+	struct comp_data *cd = module_get_private_data(mod);
+	struct comp_dev *dev = mod->dev;
+	int ret;
+
+	if (cd->source_rate != cd->ipc_config.base.audio_fmt.sampling_frequency ||
+	    cd->sink_rate != cd->ipc_config.sink_rate) {
+		comp_err(mod->dev, "rate mismatch: source %u/%u sink %u/%u",
+			 cd->source_rate,
+			 cd->ipc_config.base.audio_fmt.sampling_frequency,
+			 cd->sink_rate, cd->ipc_config.sink_rate);
+		return -EINVAL;
+	}
+
+	ret = src_set_params(mod, sink);
+	if (ret < 0) {
+		comp_err(mod->dev, "set params failed.");
+		return ret;
+	}
+
+	/* Update frame counts with final dev->frames from src_set_params */
+	cd->source_frames = dev->frames * cd->source_rate / cd->sink_rate;
+	cd->sink_frames = dev->frames;
+
+	return src_prepare_general(mod, source, sink);
+}
+
diff --git a/src/audio/src/src_lite.c b/src/audio/src/src_lite.c
index 9d5593ff34ca..89d205fc7b85 100644
--- a/src/audio/src/src_lite.c
+++ b/src/audio/src/src_lite.c
@@ -14,24 +14,16 @@
 
 LOG_MODULE_REGISTER(src_lite, CONFIG_SOF_LOG_LEVEL);
 
-/*
- * This function is 100% identical to src_prepare(), but it's
- * assigning different coefficient arrays because it's including
- * different headers.
+/* Set rate table pointers, compute rate indices, and copy filter stages.
+ * Must be in src_lite.c because src_table1/2, src_in_fs, etc. come from
+ * the coefficient headers included by this file.
  */
-static int src_lite_prepare(struct processing_module *mod,
-			    struct sof_source **sources, int num_of_sources,
-			    struct sof_sink **sinks, int num_of_sinks)
+static int src_lite_setup_stages(struct processing_module *mod)
 {
 	struct comp_data *cd = module_get_private_data(mod);
 	struct src_param *a = &cd->param;
 	int ret;
 
-	comp_info(mod->dev, "entry");
-
-	if (num_of_sources != 1 || num_of_sinks != 1)
-		return -EINVAL;
-
 	a->in_fs = src_in_fs;
 	a->out_fs = src_out_fs;
 	a->num_in_fs = NUM_IN_FS;
@@ -43,21 +35,42 @@ static int src_lite_prepare(struct processing_module *mod,
 	if (ret < 0)
 		return ret;
 
-	ret = src_allocate_copy_stages(mod, a,
-				       src_table1[a->idx_out][a->idx_in],
-				       src_table2[a->idx_out][a->idx_in]);
-	if (ret < 0)
-		return ret;
+	return src_allocate_copy_stages(mod, a,
+					src_table1[a->idx_out][a->idx_in],
+					src_table2[a->idx_out][a->idx_in]);
+}
+
+static int src_lite_do_init(struct processing_module *mod)
+{
+	struct comp_data *cd;
+	int ret;
 
-	ret = src_params_general(mod, sources[0], sinks[0]);
+	ret = src_init(mod);
 	if (ret < 0)
 		return ret;
 
-	return src_prepare_general(mod, sources[0], sinks[0]);
+	cd = module_get_private_data(mod);
+	cd->setup_stages = src_lite_setup_stages;
+
+	return src_init_stages(mod);
+}
+
+static int src_lite_prepare(struct processing_module *mod,
+			    struct sof_source **sources, int num_of_sources,
+			    struct sof_sink **sinks, int num_of_sinks)
+{
+	comp_info(mod->dev, "entry");
+
+	if (num_of_sources != 1 || num_of_sinks != 1)
+		return -EINVAL;
+
+	src_get_source_sink_params(mod->dev, sources[0], sinks[0]);
+
+	return src_prepare_do(mod, sources[0], sinks[0]);
 }
 
 const struct module_interface src_lite_interface = {
-	.init = src_init,
+	.init = src_lite_do_init,
 	.prepare = src_lite_prepare,
 	.process = src_process,
 	.is_ready_to_process = src_is_ready_to_process,
diff --git a/src/include/sof/audio/module_adapter/module/generic.h b/src/include/sof/audio/module_adapter/module/generic.h
index 94827d86cd9f..c44b7a5a6c18 100644
--- a/src/include/sof/audio/module_adapter/module/generic.h
+++ b/src/include/sof/audio/module_adapter/module/generic.h
@@ -13,6 +13,7 @@
 #ifndef __SOF_AUDIO_MODULE_GENERIC__
 #define __SOF_AUDIO_MODULE_GENERIC__
 
+#include <rtos/mutex.h>
 #include <sof/objpool.h>
 #include <sof/ut.h>
 #include <sof/audio/component.h>
@@ -20,10 +21,6 @@
 #include <sof/audio/source_api.h>
 #include "module_interface.h"
 
-/* The __ZEPHYR__ condition is to keep cmocka tests working */
-#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
-#include <zephyr/kernel/thread.h>
-#endif
 #include <sof/compiler_attributes.h>
 
 /*
@@ -129,13 +126,11 @@ struct module_param {
  * when the module unloads.
  */
 struct module_resources {
+	struct k_mutex lock;
 	struct objpool_head objpool;
 	size_t heap_usage;
 	size_t heap_high_water_mark;
 	struct mod_alloc_ctx *alloc;
-#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
-	k_tid_t rsrc_mngr;
-#endif
 };
 
 enum mod_resource_type {
@@ -191,7 +186,12 @@ struct module_processing_data {
 /*****************************************************************************/
 int module_load_config(struct comp_dev *dev, const void *cfg, size_t size);
 int module_init(struct processing_module *mod);
-void *mod_balloc_align(struct processing_module *mod, size_t size, size_t alignment);
+#if defined(__ZEPHYR__) && defined(CONFIG_SOF_FULL_ZEPHYR_APPLICATION)
+__syscall void *mod_balloc_align(struct processing_module *mod, size_t size, size_t alignment);
+#else
+void *z_impl_mod_balloc_align(struct processing_module *mod, size_t size, size_t alignment);
+#define mod_balloc_align z_impl_mod_balloc_align
+#endif
 void mod_resource_init(struct processing_module *mod);
 void mod_heap_info(struct processing_module *mod, size_t *size, uintptr_t *start);
 #if defined(__ZEPHYR__) && defined(CONFIG_SOF_FULL_ZEPHYR_APPLICATION)
@@ -241,7 +241,12 @@ static inline void *mod_zalloc(struct processing_module *mod, size_t size)
 }
 
 #if CONFIG_COMP_BLOB
-struct comp_data_blob_handler *mod_data_blob_handler_new(struct processing_module *mod);
+#if defined(__ZEPHYR__) && defined(CONFIG_SOF_FULL_ZEPHYR_APPLICATION)
+__syscall struct comp_data_blob_handler *mod_data_blob_handler_new(struct processing_module *mod);
+#else
+struct comp_data_blob_handler *z_impl_mod_data_blob_handler_new(struct processing_module *mod);
+#define mod_data_blob_handler_new z_impl_mod_data_blob_handler_new
+#endif
 void mod_data_blob_handler_free(struct processing_module *mod, struct comp_data_blob_handler *dbh);
 #endif
 #if CONFIG_FAST_GET
diff --git a/src/include/sof/audio/pipeline.h b/src/include/sof/audio/pipeline.h
index 913a569c208c..3bd9d039a00d 100644
--- a/src/include/sof/audio/pipeline.h
+++ b/src/include/sof/audio/pipeline.h
@@ -26,6 +26,7 @@ struct comp_dev;
 struct ipc;
 struct ipc_msg;
 struct k_heap;
+struct mod_alloc_ctx;
 
 /*
  * Pipeline status to stop execution of current path, but to keep the
@@ -54,6 +55,7 @@ struct k_heap;
  */
 struct pipeline {
 	struct k_heap *heap;	/**< heap used for allocating this pipeline */
+	struct mod_alloc_ctx *alloc;	/**< shared alloc context for pipeline modules */
 	uint32_t comp_id;	/**< component id for pipeline */
 	uint32_t pipeline_id;	/**< pipeline id */
 	uint32_t sched_id;	/**< Scheduling component id */
diff --git a/src/include/sof/common.h b/src/include/sof/common.h
index d7aa9a7989cb..bb193310e97f 100644
--- a/src/include/sof/common.h
+++ b/src/include/sof/common.h
@@ -14,9 +14,7 @@
 /* callers must check/use the return value */
 #define __must_check __attribute__((warn_unused_result))
 
-#ifdef __ZEPHYR__
 #include <zephyr/sys/util.h>
-#endif
 
 /* Align the number to the nearest alignment value */
 #ifndef IS_ALIGNED
diff --git a/src/include/sof/trace/trace.h b/src/include/sof/trace/trace.h
index fc3aa324f847..bd6a56d87da0 100644
--- a/src/include/sof/trace/trace.h
+++ b/src/include/sof/trace/trace.h
@@ -23,8 +23,8 @@
 
 #ifdef __ZEPHYR__
 #include <zephyr/kernel.h>
-#include <zephyr/logging/log.h>
 #endif
+#include <zephyr/logging/log.h>
 
 #if !CONFIG_LIBRARY
 #include <platform/trace/trace.h>
@@ -155,12 +155,4 @@ struct tr_ctx {
 		.level = default_log_level,			\
 	}
 
-/* Only define these two macros for XTOS to avoid the collision with
- * zephyr/include/zephyr/logging/log.h
- */
-#ifndef __ZEPHYR__
-#define LOG_MODULE_REGISTER(ctx, level)
-#define LOG_MODULE_DECLARE(ctx, level)
-#endif
-
 #endif /* __SOF_TRACE_TRACE_H__ */
diff --git a/tools/logger/CMakeLists.txt b/tools/logger/CMakeLists.txt
index ac83f5687454..8c15dd125739 100644
--- a/tools/logger/CMakeLists.txt
+++ b/tools/logger/CMakeLists.txt
@@ -38,6 +38,7 @@ target_compile_options(sof-logger PRIVATE
 
 target_include_directories(sof-logger PRIVATE
 	"${SOF_ROOT_SOURCE_DIRECTORY}/src/include"
+	"${SOF_ROOT_SOURCE_DIRECTORY}/posix/include"
 	"${SOF_ROOT_SOURCE_DIRECTORY}/tools/rimage/src/include"
 	"${SOF_ROOT_SOURCE_DIRECTORY}"
 )
diff --git a/zephyr/Kconfig b/zephyr/Kconfig
index 27f37d829b4e..603e52aafebd 100644
--- a/zephyr/Kconfig
+++ b/zephyr/Kconfig
@@ -69,6 +69,15 @@ config SOF_ZEPHYR_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_USERSPACE_DP_DEFAULT_HEAP_SIZE
+       int "Default heap size for DP userspace threads"
+       default 20480
+       help
+         Defines the default heap size for userspace DP processing
+         threads. The value can be overridden with IPC module init
+         ext_init module payload. The default is derived from what is
+         required for SRC module to produce all supported conversions.
+
 config SOF_USERSPACE_USE_SHARED_HEAP
 	bool "Use shared heap for SOF userspace modules"
 	depends on USERSPACE
@@ -232,6 +241,15 @@ config ZEPHYR_DP_SCHEDULER
 	  DP modules can be located in dieffrent cores than LL pipeline modules, may have
 	  different tick (i.e. 300ms for speech reccognition, etc.)
 
+config ZEPHYR_DP_SCHEDULER_MIN_STACK_SIZE
+       int "Minimum stack size for DP processing thread"
+       default 512
+       help
+         Defines the minimum stack size allowed for DP processing
+         threads despite what is requested in the module init IPC
+         ext_init payload. If the stack size requested in the IPC is
+         smaller than this, then the value defined here takes over.
+
 config CROSS_CORE_STREAM
 	bool "Enable cross-core connected pipelines"
 	default y if IPC_MAJOR_4
diff --git a/zephyr/lib/fast-get.c b/zephyr/lib/fast-get.c
index cb0a2cfb07c7..f60efe48120c 100644
--- a/zephyr/lib/fast-get.c
+++ b/zephyr/lib/fast-get.c
@@ -19,14 +19,7 @@
 #include <rtos/symbol.h>
 #include <ipc/topology.h>
 
-#ifdef __ZEPHYR__
 #include <zephyr/logging/log.h>
-#else
-#define LOG_DBG(...) do {} while (0)
-#define LOG_INF(...) do {} while (0)
-#define LOG_WRN(...) do {} while (0)
-#define LOG_ERR(...) do {} while (0)
-#endif
 
 struct sof_fast_get_entry {
 	const void *dram_ptr;
@@ -154,7 +147,7 @@ const void *fast_get(struct mod_alloc_ctx *alloc, const void *dram_ptr, size_t s
 
 	if (entry->sram_ptr) {
 		if (entry->size != size || entry->dram_ptr != dram_ptr) {
-			LOG_ERR("size %u != %u or ptr %p != %p mismatch",
+			LOG_ERR("size %zu != %zu or ptr %p != %p mismatch",
 				entry->size, size, entry->dram_ptr, dram_ptr);
 			ret = NULL;
 			goto out;