loadable libraries and smart-amp-test as an example

app/overlays/mtl/module_overlay.conf

@@ -0,0 +1 @@
+CONFIG_SAMPLE_SMART_AMP=m

app/prj.conf

@@ -53,3 +53,7 @@ CONFIG_SCHED_CPU_MASK_PIN_ONLY=y
 CONFIG_SYS_CLOCK_TICKS_PER_SEC=15000
 CONFIG_DAI=y
 CONFIG_HEAP_MEM_POOL_SIZE=2048
+
+CONFIG_LLEXT=y
+CONFIG_LLEXT_STORAGE_WRITABLE=y
+CONFIG_MODULES=y

scripts/llext_link_helper.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: BSD-3-Clause
+
+# We need to calculate ELF section addresses of an LLEXT module and use them to
+# run the linker. We could just use Python to calculate addresses and pass them
+# back to cmake to have it call the linker. However, there doesn't seem to be a
+# portable way to do that. Therefore we pass the linker path and all the command
+# line parameters to this script and call the linker directly.
+
+import argparse
+import subprocess
+from elftools.elf.elffile import ELFFile
+
+args = None
+def parse_args():
+	global args
+
+	parser = argparse.ArgumentParser(description='Helper utility to run a linker command '
+                                         'with calculated ELF section addresses')
+
+	parser.add_argument('command', type=str, help='Linker command to execute')
+	parser.add_argument('params', nargs='+', help='Additional linker parameters')
+	parser.add_argument("-f", "--file", required=True, type=str,
+						help='Object file name')
+	parser.add_argument("-t", "--text-addr", required=True, type=str,
+						help='.text section address')
+
+	args = parser.parse_args()
+
+def main():
+	parse_args()
+
+	elf = ELFFile(open(args.file, 'rb'))
+
+	text_addr = int(args.text_addr, 0)
+
+	text_offset = elf.get_section_by_name('.text').header.sh_offset
+	rodata_offset = elf.get_section_by_name('.rodata').header.sh_offset
+	data_offset = elf.get_section_by_name('.data').header.sh_offset
+
+	upper = rodata_offset - text_offset + text_addr + 0xfff
+	rodata_addr = upper - (upper % 0x1000)
+
+	upper = data_offset - rodata_offset + rodata_addr + 0xf
+	data_addr = upper - (upper % 0x10)
+
+	command = [args.command,
+		   f'-Wl,-Ttext=0x{text_addr:x}',
+		   f'-Wl,--section-start=.rodata=0x{rodata_addr:x}',
+		   f'-Wl,-Tdata=0x{data_addr:x}']
+	command.extend(args.params)
+
+	subprocess.run(command)
+
+if __name__ == "__main__":
+	main()

src/audio/module_adapter/module/modules.c

@@ -14,6 +14,7 @@
 #include <sof/lib_manager.h>
 #include <sof/audio/module_adapter/module/module_interface.h>
 #include <module/module/api_ver.h>
+#include <zephyr/llext/llext.h>
 
 /* Intel module adapter is an extension to SOF module adapter component that allows to integrate
  * modules developed under IADK (Intel Audio Development Kit) Framework. IADK modules uses uniform
@@ -49,6 +50,67 @@ DECLARE_SOF_RT_UUID("modules", intel_uuid, 0xee2585f2, 0xe7d8, 0x43dc,
 		    0x90, 0xab, 0x42, 0x24, 0xe0, 0x0c, 0x3e, 0x84);
 DECLARE_TR_CTX(intel_codec_tr, SOF_UUID(intel_uuid), LOG_LEVEL_INFO);
 
+static const struct module_interface interface;
+
+static int modules_new(struct processing_module *mod, const void *buildinfo,
+		       uintptr_t module_entry_point)
+{
+	struct module_data *md = &mod->priv;
+	struct comp_dev *dev = mod->dev;
+	uint32_t module_id = IPC4_MOD_ID(dev->ipc_config.id);
+	uint32_t instance_id = IPC4_INST_ID(dev->ipc_config.id);
+	uint32_t log_handle = (uint32_t) dev->drv->tctx;
+	/* Connect loadable module interfaces with module adapter entity. */
+	/* Check if native Zephyr lib is loaded */
+	struct sof_man_fw_desc *desc = lib_manager_get_library_module_desc(module_id);
+
+	if (!desc) {
+		comp_err(dev, "modules_init(): Failed to load manifest");
+		return -ENOMEM;
+	}
+
+	const struct sof_module_api_build_info *mod_buildinfo;
+
+	if (buildinfo) {
+		mod_buildinfo = buildinfo;
+	} else {
+		struct sof_man_module *module_entry =
+			(struct sof_man_module *)((char *)desc + SOF_MAN_MODULE_OFFSET(0));
+
+		mod_buildinfo =
+			(struct sof_module_api_build_info *)
+			(module_entry->segment[SOF_MAN_SEGMENT_TEXT].v_base_addr);
+	}
+
+	byte_array_t mod_cfg = {
+		.data = (uint8_t *)md->cfg.init_data,
+		/* Intel modules expects DW size here */
+		.size = md->cfg.size >> 2,
+	};
+
+	/* Check if module is FDK */
+	if (mod_buildinfo->format == IADK_MODULE_API_BUILD_INFO_FORMAT &&
+	    mod_buildinfo->api_version_number.full == IADK_MODULE_API_CURRENT_VERSION) {
+		md->module_adapter = (void *)system_agent_start(module_entry_point,
+								module_id, instance_id,
+								0, log_handle, &mod_cfg);
+	} else if (mod_buildinfo->format == SOF_MODULE_API_BUILD_INFO_FORMAT &&
+		   mod_buildinfo->api_version_number.full == SOF_MODULE_API_CURRENT_VERSION) {
+		/* The module is native: start agent for sof loadable */
+		mod->is_native_sof = true;
+		md->ops = native_system_agent_start(mod->sys_service, module_entry_point,
+						    module_id, instance_id,
+						    0, log_handle, &mod_cfg);
+	} else {
+		return -ENOEXEC;
+	}
+
+	md->module_entry_point = module_entry_point;
+	md->private = mod;
+
+	return 0;
+}
+
 /**
  * \brief modules_init.
  * \param[in] mod - processing module pointer.
@@ -58,64 +120,28 @@ DECLARE_TR_CTX(intel_codec_tr, SOF_UUID(intel_uuid), LOG_LEVEL_INFO);
  */
 static int modules_init(struct processing_module *mod)
 {
-	uint32_t module_entry_point;
 	struct module_data *md = &mod->priv;
 	struct comp_dev *dev = mod->dev;
 	const struct ipc4_base_module_cfg *src_cfg = &md->cfg.base_cfg;
-	byte_array_t mod_cfg;
-
-	mod_cfg.data = (uint8_t *)md->cfg.init_data;
-	/* Intel modules expects DW size here */
-	mod_cfg.size = md->cfg.size >> 2;
-	md->private = mod;
-
 	struct comp_ipc_config *config = &(dev->ipc_config);
-
 	/* At this point module resources are allocated and it is moved to L2 memory. */
-	module_entry_point = lib_manager_allocate_module(dev->drv, config, src_cfg);
+	const void *buildinfo = NULL;
+	int ret;
+	uintptr_t module_entry_point = lib_manager_allocate_module(mod, config, src_cfg,
+								   &buildinfo);
+
 	if (module_entry_point == 0) {
 		comp_err(dev, "modules_init(), lib_manager_allocate_module() failed!");
 		return -EINVAL;
 	}
-	md->module_entry_point = module_entry_point;
 	comp_info(dev, "modules_init() start");
 
-	uint32_t module_id = IPC4_MOD_ID(dev->ipc_config.id);
-	uint32_t instance_id = IPC4_INST_ID(dev->ipc_config.id);
-	uint32_t log_handle = (uint32_t) dev->drv->tctx;
-	/* Connect loadable module interfaces with module adapter entity. */
-	/* Check if native Zephyr lib is loaded */
-	struct sof_man_fw_desc *desc;
-
-	desc = lib_manager_get_library_module_desc(module_id);
-	if (!desc) {
-		comp_err(dev, "modules_init(): Failed to load manifest");
-		return -ENOMEM;
+	if (!md->module_adapter && md->ops == &interface) {
+		/* First load */
+		ret = modules_new(mod, buildinfo, module_entry_point);
+		if (ret < 0)
+			return ret;
 	}
-	struct sof_man_module *module_entry =
-		    (struct sof_man_module *)((char *)desc + SOF_MAN_MODULE_OFFSET(0));
-
-	struct sof_module_api_build_info *mod_buildinfo =
-		(struct sof_module_api_build_info *)
-		(module_entry->segment[SOF_MAN_SEGMENT_TEXT].v_base_addr);
-
-	/* Check if module is FDK */
-	if (mod_buildinfo->format == IADK_MODULE_API_BUILD_INFO_FORMAT &&
-	    mod_buildinfo->api_version_number.full == IADK_MODULE_API_CURRENT_VERSION) {
-		md->module_adapter = (void *)system_agent_start(md->module_entry_point, module_id,
-								instance_id, 0, log_handle,
-								&mod_cfg);
-	} else
-	/* Check if module is native */
-	if (mod_buildinfo->format == SOF_MODULE_API_BUILD_INFO_FORMAT &&
-	    mod_buildinfo->api_version_number.full == SOF_MODULE_API_CURRENT_VERSION) {
-		/* If start agent for sof loadable */
-		mod->is_native_sof = true;
-		md->ops = native_system_agent_start(mod->sys_service, md->module_entry_point,
-						    module_id, instance_id, 0, log_handle,
-						    &mod_cfg);
-	} else
-		return -ENOEXEC;
 
 	/* Allocate module buffers */
 	md->mpd.in_buff = rballoc(0, SOF_MEM_CAPS_RAM, src_cfg->ibs);
@@ -133,8 +159,6 @@ static int modules_init(struct processing_module *mod)
 	}
 	md->mpd.out_buff_size = src_cfg->obs;
 
-	int ret;
-
 	/* Call module specific init function if exists. */
 	if (mod->is_native_sof) {
 		const struct module_interface *mod_in = md->ops;
@@ -271,7 +295,7 @@ static int modules_free(struct processing_module *mod)
 	struct comp_dev *dev = mod->dev;
 	struct module_data *md = &mod->priv;
 	struct comp_ipc_config *config = &(mod->dev->ipc_config);
-	int ret = 0;
+	int ret;
 
 	comp_info(dev, "modules_free()");
 	if (mod->is_native_sof) {
@@ -281,13 +305,19 @@ static int modules_free(struct processing_module *mod)
 	} else {
 		ret = iadk_wrapper_free(mod->priv.module_adapter);
 	}
+
+	if (ret < 0)
+		comp_err(dev, "Failed to free a module: %d", ret);
+
 	rfree(md->mpd.in_buff);
 	rfree(md->mpd.out_buff);
 
-	/* Free module resources allocated in L2 memory. */
-	ret = lib_manager_free_module(dev->drv, config);
-	if (ret < 0)
-		comp_err(dev, "modules_free(), lib_manager_free_module() failed!");
+	if (!md->llext || !llext_unload(&md->llext)) {
+		/* Free module resources allocated in L2 memory. */
+		ret = lib_manager_free_module(mod, config);
+		if (ret < 0)
+			comp_err(dev, "modules_free(), lib_manager_free_module() failed!");
+	}
 
 	return ret;
 }

src/include/module/module/base.h

@@ -37,6 +37,8 @@ struct module_config {
 #endif
 };
 
+struct llext;
+
 /*
  * A structure containing a module's private data, intended for its exclusive use.
  *
@@ -60,7 +62,8 @@ struct module_data {
 	struct module_memory memory; /**< memory allocated by module */
 	struct module_processing_data mpd; /**< shared data comp <-> module */
 	void *module_adapter; /**<loadable module interface handle */
-	uint32_t module_entry_point; /**<loadable module entry point address */
+	uintptr_t module_entry_point; /**<loadable module entry point address */
+	struct llext *llext; /**< Zephyr loadable extension context */
 #endif /* SOF_MODULE_PRIVATE */
 };
 

src/include/sof/lib_manager.h

@@ -82,7 +82,7 @@ struct ipc_lib_msg {
 };
 
 struct lib_manager_mod_ctx {
-	struct sof_man_fw_desc *desc;
+	void *base_addr;
 	size_t segment_size[3];
 };
 
@@ -144,6 +144,7 @@ int lib_manager_register_module(struct sof_man_fw_desc *desc, int module_id);
  */
 struct sof_man_fw_desc *lib_manager_get_library_module_desc(int module_id);
 
+struct processing_module;
 /*
  * \brief Allocate module
  *
@@ -154,9 +155,9 @@ struct sof_man_fw_desc *lib_manager_get_library_module_desc(int module_id);
  * Function is responsible to allocate module in available free memory and assigning proper address.
  * (WIP) These feature will contain module validation and proper memory management.
  */
-uint32_t lib_manager_allocate_module(const struct comp_driver *drv,
-				     struct comp_ipc_config *ipc_config,
-				     const void *ipc_specific_config);
+uintptr_t lib_manager_allocate_module(struct processing_module *proc,
+				      struct comp_ipc_config *ipc_config,
+				      const void *ipc_specific_config, const void **buildinfo);
 
 /*
  * \brief Free module
@@ -167,7 +168,7 @@ uint32_t lib_manager_allocate_module(const struct comp_driver *drv,
  *
  * Function is responsible to free module resources in HP memory.
  */
-int lib_manager_free_module(const struct comp_driver *drv,
+int lib_manager_free_module(struct processing_module *proc,
 			    struct comp_ipc_config *ipc_config);
 /*
  * \brief Load library

src/include/sof/llext_manager.h

@@ -11,10 +11,10 @@
 struct comp_driver;
 struct comp_ipc_config;
 
-uint32_t llext_manager_allocate_module(const struct comp_driver *drv,
-				       struct comp_ipc_config *ipc_config,
-				       const void *ipc_specific_config);
-int llext_manager_free_module(const struct comp_driver *drv,
+uintptr_t llext_manager_allocate_module(struct processing_module *proc,
+					struct comp_ipc_config *ipc_config,
+					const void *ipc_specific_config, const void **buildinfo);
+int llext_manager_free_module(struct processing_module *proc,
 			      struct comp_ipc_config *ipc_config);
 
 #endif