userspace: prepare DP task to handle all the module methods (part 3 of #10287)

src/audio/buffers/ring_buffer.c

@@ -7,6 +7,7 @@
 #include <sof/trace/trace.h>
 #include <sof/lib/uuid.h>
 
+#include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/ring_buffer.h>
 #include <sof/audio/component.h>
 
@@ -93,11 +94,11 @@ static void ring_buffer_free(struct sof_audio_buffer *audio_buffer)
 	if (!audio_buffer)
 		return;
 
-	struct ring_buffer *ring_buffer =
-			container_of(audio_buffer, struct ring_buffer, audio_buffer);
+	struct ring_buffer *ring_buffer = container_of(audio_buffer,
+						       struct ring_buffer, audio_buffer);
 
-	rfree((__sparse_force void *)ring_buffer->_data_buffer);
-	rfree(ring_buffer);
+	sof_heap_free(audio_buffer->heap, (__sparse_force void *)ring_buffer->_data_buffer);
+	sof_heap_free(audio_buffer->heap, ring_buffer);
 }
 
 static void ring_buffer_reset(struct sof_audio_buffer *audio_buffer)
@@ -286,14 +287,17 @@ struct ring_buffer *ring_buffer_create(struct comp_dev *dev, size_t min_availabl
 				       uint32_t id)
 {
 	struct ring_buffer *ring_buffer;
+	struct k_heap *heap = dev->mod->priv.resources.heap;
 	int memory_flags = (is_shared ? SOF_MEM_FLAG_COHERENT : 0) |
 			   user_get_buffer_memory_region(dev->drv);
 
 	/* allocate ring_buffer structure */
-	ring_buffer = rzalloc(memory_flags, sizeof(*ring_buffer));
+	ring_buffer = sof_heap_alloc(heap, memory_flags, sizeof(*ring_buffer), 0);
 	if (!ring_buffer)
 		return NULL;
 
+	memset(ring_buffer, 0, sizeof(*ring_buffer));
+
 	/* init base structure. The audio_stream_params is NULL because ring_buffer
 	 * is currently used as a secondary buffer for DP only
 	 *
@@ -303,6 +307,7 @@ struct ring_buffer *ring_buffer_create(struct comp_dev *dev, size_t min_availabl
 	audio_buffer_init(&ring_buffer->audio_buffer, BUFFER_TYPE_RING_BUFFER,
 			  is_shared, &ring_buffer_source_ops, &ring_buffer_sink_ops,
 			  &audio_buffer_ops, NULL);
+	ring_buffer->audio_buffer.heap = heap;
 
 	/* set obs/ibs in sink/source interfaces */
 	sink_set_min_free_space(audio_buffer_get_sink(&ring_buffer->audio_buffer),
@@ -357,12 +362,11 @@ struct ring_buffer *ring_buffer_create(struct comp_dev *dev, size_t min_availabl
 	ring_buffer->data_buffer_size = 3 * max_ibs_obs;
 
 	/* allocate data buffer - always in cached memory alias */
-	ring_buffer->data_buffer_size =
-			ALIGN_UP(ring_buffer->data_buffer_size, PLATFORM_DCACHE_ALIGN);
-	ring_buffer->_data_buffer = (__sparse_force __sparse_cache void *)
-			rballoc_align(user_get_buffer_memory_region(dev->drv),
-				      ring_buffer->data_buffer_size,
-				      PLATFORM_DCACHE_ALIGN);
+	ring_buffer->data_buffer_size = ALIGN_UP(ring_buffer->data_buffer_size,
+						 PLATFORM_DCACHE_ALIGN);
+	ring_buffer->_data_buffer = (__sparse_force __sparse_cache void *)sof_heap_alloc(heap,
+					user_get_buffer_memory_region(dev->drv),
+					ring_buffer->data_buffer_size, PLATFORM_DCACHE_ALIGN);
 	if (!ring_buffer->_data_buffer)
 		goto err;
 
@@ -374,6 +378,6 @@ struct ring_buffer *ring_buffer_create(struct comp_dev *dev, size_t min_availabl
 	return ring_buffer;
 err:
 	tr_err(&ring_buffer_tr, "Ring buffer creation failure");
-	rfree(ring_buffer);
+	sof_heap_free(heap, ring_buffer);
 	return NULL;
 }

src/audio/module_adapter/module/generic.c

@@ -326,7 +326,7 @@ const void *mod_fast_get(struct processing_module *mod, const void * const dram_
 	if (!container)
 		return NULL;
 
-	ptr = fast_get(dram_ptr, size);
+	ptr = fast_get(res->heap, dram_ptr, size);
 	if (!ptr) {
 		container_put(mod, container);
 		return NULL;
@@ -358,7 +358,7 @@ static int free_contents(struct processing_module *mod, struct module_resource *
 #endif
 #if CONFIG_FAST_GET
 	case MOD_RES_FAST_GET:
-		fast_put(container->sram_ptr);
+		fast_put(res->heap, container->sram_ptr);
 		return 0;
 #endif
 	default:

src/audio/module_adapter/module_adapter.c

@@ -183,15 +183,22 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 	if (!mod)
 		return NULL;
 
+	struct comp_dev *dev = mod->dev;
+
+#if CONFIG_ZEPHYR_DP_SCHEDULER
+	/* create a task for DP processing */
+	if (config->proc_domain == COMP_PROCESSING_DOMAIN_DP) {
+		/* All data allocated, create a thread */
+		pipeline_comp_dp_task_init(dev);
+	}
+#endif /* CONFIG_ZEPHYR_DP_SCHEDULER */
 
 	module_set_private_data(mod, mod_priv);
 	list_init(&mod->raw_data_buffers_list);
 #if CONFIG_USERSPACE
 	mod->user_ctx = user_ctx;
 #endif /* CONFIG_USERSPACE */
 
-	struct comp_dev *dev = mod->dev;
-
 	dst = &mod->priv.cfg;
 	ret = module_adapter_init_data(dev, dst, config, spec);
 	if (ret) {
@@ -238,12 +245,6 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 		goto err;
 	}
 
-#if CONFIG_ZEPHYR_DP_SCHEDULER
-	/* create a task for DP processing */
-	if (config->proc_domain == COMP_PROCESSING_DOMAIN_DP)
-		pipeline_comp_dp_task_init(dev);
-#endif /* CONFIG_ZEPHYR_DP_SCHEDULER */
-
 	module_adapter_reset_data(dst);
 
 	dev->state = COMP_STATE_READY;
@@ -269,6 +270,10 @@ struct comp_dev *module_adapter_new_ext(const struct comp_driver *drv,
 	return dev;
 
 err:
+#if CONFIG_ZEPHYR_DP_SCHEDULER
+	if (dev->task)
+		schedule_task_free(dev->task);
+#endif
 	module_adapter_mem_free(mod);
 
 	return NULL;
@@ -1349,6 +1354,9 @@ void module_adapter_free(struct comp_dev *dev)
 
 	comp_dbg(dev, "start");
 
+	if (dev->task)
+		schedule_task_cancel(dev->task);
+
 	ret = module_free(mod);
 	if (ret)
 		comp_err(dev, "failed with error: %d", ret);

src/audio/src/src.c

@@ -78,8 +78,6 @@ static const struct module_interface src_interface = {
 	.prepare = src_prepare,
 	.process = src_process,
 	.is_ready_to_process = src_is_ready_to_process,
-	.set_configuration = src_set_config,
-	.get_configuration = src_get_config,
 	.reset = src_reset,
 	.free = src_free,
 };

src/audio/src/src_common.c

@@ -669,24 +669,6 @@ int src_process(struct processing_module *mod,
 	return cd->src_func(cd, sources[0], sinks[0]);
 }
 
-__cold int src_set_config(struct processing_module *mod, uint32_t config_id,
-			  enum module_cfg_fragment_position pos, uint32_t data_offset_size,
-			  const uint8_t *fragment, size_t fragment_size, uint8_t *response,
-			  size_t response_size)
-{
-	assert_can_be_cold();
-
-	return -EINVAL;
-}
-
-__cold int src_get_config(struct processing_module *mod, uint32_t config_id,
-			  uint32_t *data_offset_size, uint8_t *fragment, size_t fragment_size)
-{
-	assert_can_be_cold();
-
-	return -EINVAL;
-}
-
 int src_reset(struct processing_module *mod)
 {
 	struct comp_data *cd = module_get_private_data(mod);

src/audio/src/src_common.h

@@ -242,12 +242,6 @@ int src_process(struct processing_module *mod,
 		struct sof_source **sources, int num_of_sources,
 		struct sof_sink **sinks, int num_of_sinks);
 
-int src_set_config(struct processing_module *mod, uint32_t config_id,
-		   enum module_cfg_fragment_position pos, uint32_t data_offset_size,
-		   const uint8_t *fragment, size_t fragment_size, uint8_t *response,
-		   size_t response_size);
-int src_get_config(struct processing_module *mod, uint32_t config_id,
-		   uint32_t *data_offset_size, uint8_t *fragment, size_t fragment_size);
 int src_free(struct processing_module *mod);
 int src_reset(struct processing_module *mod);
 extern struct tr_ctx src_tr;

src/audio/src/src_lite.c

@@ -61,8 +61,6 @@ const struct module_interface src_lite_interface = {
 	.prepare = src_lite_prepare,
 	.process = src_process,
 	.is_ready_to_process = src_is_ready_to_process,
-	.set_configuration = src_set_config,
-	.get_configuration = src_get_config,
 	.reset = src_reset,
 	.free = src_free,
 };

src/include/sof/audio/audio_buffer.h

@@ -110,6 +110,8 @@ struct sof_audio_buffer {
 	 * should not be in struct sof_audio_buffer at all, kept for pipeline2.0 transition
 	 */
 	bool walking;		/**< indicates if the buffer is being walked */
+
+	struct k_heap *heap;
 };
 
 #if CONFIG_PIPELINE_2_0

src/include/sof/audio/component_ext.h

@@ -164,7 +164,6 @@ static inline int comp_trigger_local(struct comp_dev *dev, int cmd)
 		case COMP_TRIGGER_XRUN:
 		case COMP_TRIGGER_PAUSE:
 		case COMP_TRIGGER_STOP:
-			schedule_task_cancel(dev->task);
 			break;
 		}
 	}

src/include/sof/lib/fast-get.h

@@ -10,7 +10,19 @@
 
 #include <stddef.h>
 
-const void *fast_get(const void * const dram_ptr, size_t size);
-void fast_put(const void *sram_ptr);
+struct k_heap;
+
+#if defined(__ZEPHYR__) && defined(CONFIG_SOF)
+#include <zephyr/toolchain.h>
+
+__syscall const void *fast_get(struct k_heap *heap, const void * const dram_ptr, size_t size);
+__syscall void fast_put(struct k_heap *heap, const void *sram_ptr);
+#include <zephyr/syscalls/fast-get.h>
+#else
+const void *z_impl_fast_get(struct k_heap *heap, const void * const dram_ptr, size_t size);
+void z_impl_fast_put(struct k_heap *heap, const void *sram_ptr);
+#define fast_get z_impl_fast_get
+#define fast_put z_impl_fast_put
+#endif /* __ZEPHYR__ */
 
 #endif /* __SOF_LIB_FAST_GET_H__ */

src/include/sof/llext_manager.h

@@ -15,6 +15,7 @@
 struct comp_dev;
 struct comp_driver;
 struct comp_ipc_config;
+struct k_mem_domain;
 
 static inline bool module_is_llext(const struct sof_man_module *mod)
 {
@@ -29,12 +30,15 @@ int llext_manager_free_module(const uint32_t component_id);
 
 int llext_manager_add_library(uint32_t module_id);
 
+int llext_manager_add_domain(const uint32_t component_id, struct k_mem_domain *domain);
+
 bool comp_is_llext(struct comp_dev *comp);
 #else
 #define module_is_llext(mod) false
 #define llext_manager_allocate_module(ipc_config, ipc_specific_config) 0
 #define llext_manager_free_module(component_id) 0
 #define llext_manager_add_library(module_id) 0
+#define llext_manager_add_domain(component_id, domain) 0
 #define comp_is_llext(comp) false
 #endif
 

src/library_manager/llext_manager.c

@@ -25,6 +25,7 @@
 #include <sof/audio/module_adapter/module/modules.h>
 
 #include <zephyr/cache.h>
+#include <zephyr/app_memory/mem_domain.h>
 #include <zephyr/drivers/mm/system_mm.h>
 #include <zephyr/llext/buf_loader.h>
 #include <zephyr/llext/loader.h>
@@ -716,6 +717,66 @@ uintptr_t llext_manager_allocate_module(const struct comp_ipc_config *ipc_config
 	return mod_manifest->module.entry_point;
 }
 
+#ifdef CONFIG_USERSPACE
+static int llext_manager_add_partition(struct k_mem_domain *domain,
+				       uintptr_t addr, size_t size,
+				       k_mem_partition_attr_t attr)
+{
+	size_t pre_pad_size = addr & (PAGE_SZ - 1);
+	struct k_mem_partition part = {
+		.start = addr - pre_pad_size,
+		.size = ALIGN_UP(pre_pad_size + size, PAGE_SZ),
+		.attr = attr,
+	};
+
+	tr_dbg(&lib_manager_tr, "add %#zx @ %lx partition", part.size, part.start);
+	return k_mem_domain_add_partition(domain, &part);
+}
+
+int llext_manager_add_domain(const uint32_t component_id, struct k_mem_domain *domain)
+{
+	const uint32_t module_id = IPC4_MOD_ID(component_id);
+	struct lib_manager_mod_ctx *ctx = lib_manager_get_mod_ctx(module_id);
+	const uint32_t entry_index = LIB_MANAGER_GET_MODULE_INDEX(module_id);
+	const unsigned int mod_idx = llext_manager_mod_find(ctx, entry_index);
+	struct lib_manager_module *mctx = ctx->mod + mod_idx;
+	int ret;
+
+	/* Executable code (.text) */
+	uintptr_t va_base_text = mctx->segment[LIB_MANAGER_TEXT].addr;
+	size_t text_size = mctx->segment[LIB_MANAGER_TEXT].size;
+
+	/* Read-only data (.rodata and others) */
+	uintptr_t va_base_rodata = mctx->segment[LIB_MANAGER_RODATA].addr;
+	size_t rodata_size = mctx->segment[LIB_MANAGER_RODATA].size;
+
+	/* Writable data (.data, .bss and others) */
+	uintptr_t va_base_data = mctx->segment[LIB_MANAGER_DATA].addr;
+	size_t data_size = mctx->segment[LIB_MANAGER_DATA].size;
+
+	ret = llext_manager_add_partition(domain, va_base_text, text_size,
+					  K_MEM_PARTITION_P_RX_U_RX);
+	if (ret < 0)
+		return ret;
+
+	if (rodata_size) {
+		ret = llext_manager_add_partition(domain, va_base_rodata, rodata_size,
+						  K_MEM_PARTITION_P_RO_U_RO);
+		if (ret < 0)
+			return ret;
+	}
+
+	if (data_size) {
+		ret = llext_manager_add_partition(domain, va_base_data, data_size,
+						  K_MEM_PARTITION_P_RW_U_RW);
+		if (ret < 0)
+			return ret;
+	}
+
+	return 0;
+}
+#endif
+
 int llext_manager_free_module(const uint32_t component_id)
 {
 	const uint32_t module_id = IPC4_MOD_ID(component_id);