diff --git a/lmdk/cmake/ldscripts/common_rodata_linker_script.txt b/lmdk/cmake/ldscripts/common_rodata_linker_script.txt
index 2f3e4bfad4d9..343107e7d37d 100644
--- a/lmdk/cmake/ldscripts/common_rodata_linker_script.txt
+++ b/lmdk/cmake/ldscripts/common_rodata_linker_script.txt
@@ -1,7 +1,4 @@
-
-PHDRS {
-    rodata_phdr PT_LOAD;
-}
+/* The .rodata PHDR is already defined in data_linker_script.txt */
 
 SECTIONS {
     .common.rodata : ALIGN(4096) {
diff --git a/lmdk/cmake/ldscripts/common_text_linker_script.txt b/lmdk/cmake/ldscripts/common_text_linker_script.txt
index 10468dc4bf3a..ecdd39d738c4 100644
--- a/lmdk/cmake/ldscripts/common_text_linker_script.txt
+++ b/lmdk/cmake/ldscripts/common_text_linker_script.txt
@@ -1,7 +1,4 @@
-
-PHDRS {
-    text_phdr PT_LOAD;
-}
+/* The .text PHDR is already defined in text_linker_script.txt */
 
 SECTIONS {
     .common.text : ALIGN(4096){
diff --git a/lmdk/cmake/ldscripts/data_linker_script.txt b/lmdk/cmake/ldscripts/data_linker_script.txt
index cbdf8001c0be..63eed21cb07a 100644
--- a/lmdk/cmake/ldscripts/data_linker_script.txt
+++ b/lmdk/cmake/ldscripts/data_linker_script.txt
@@ -15,7 +15,7 @@ SECTIONS {
         _data_end = ABSOLUTE(.);
     } >HPSRAM_seg : data_phdr
 
-    .rodata : {
+    .rodata : ALIGN(4096) {
         _rodata_start = ABSOLUTE(.);
         *(.gnu.linkonce.r.*)
         *(.rodata)
diff --git a/lmdk/libraries/smart_amp_test/CMakeLists.txt b/lmdk/libraries/smart_amp_test/CMakeLists.txt
new file mode 100644
index 000000000000..0282a83bbf90
--- /dev/null
+++ b/lmdk/libraries/smart_amp_test/CMakeLists.txt
@@ -0,0 +1,25 @@
+cmake_minimum_required(VERSION 3.20)
+set(CMAKE_TOOLCHAIN_FILE "${CMAKE_CURRENT_LIST_DIR}/../../cmake/xtensa-toolchain.cmake")
+
+project(smart_amp_test)
+
+macro(is_zephyr ret)
+        if(CONFIG_ZEPHYR_SOF_MODULE)
+                set(${ret} TRUE)
+        else()
+                set(${ret} FALSE)
+        endif()
+endmacro()
+
+# list of modules to be built and included into this loadable library
+set(MODULES_LIST smart_amp_test)
+
+# toml file for rimage to generate manifets
+set(TOML "${CMAKE_CURRENT_LIST_DIR}/smart_amp_test.toml")
+
+# TODO: Move it somewhere???
+add_definitions(-DMAJOR_IADSP_API_VERSION=5)
+add_definitions(-DMIDDLE_IADSP_API_VERSION=0)
+add_definitions(-DMINOR_IADSP_API_VERSION=0)
+
+include(../../cmake/build.cmake)
diff --git a/lmdk/libraries/smart_amp_test/smart_amp_test.toml b/lmdk/libraries/smart_amp_test/smart_amp_test.toml
new file mode 100644
index 000000000000..34f3463343dd
--- /dev/null
+++ b/lmdk/libraries/smart_amp_test/smart_amp_test.toml
@@ -0,0 +1,79 @@
+version = [3, 0]
+
+[adsp]
+name = "mtl"
+image_size = "0x2C0000" # (22) bank * 128KB
+alias_mask = "0xE0000000"
+
+[[adsp.mem_zone]]
+type = "ROM"
+base = "0x1FF80000"
+size = "0x400"
+[[adsp.mem_zone]]
+type = "IMR"
+base = "0xA104A000"
+size = "0x2000"
+[[adsp.mem_zone]]
+type = "SRAM"
+base = "0xa00f0000"
+size = "0x100000"
+
+[[adsp.mem_alias]]
+type = "uncached"
+base = "0x40000000"
+[[adsp.mem_alias]]
+type = "cached"
+base = "0xA0000000"
+
+[cse]
+partition_name = "ADSP"
+[[cse.entry]]
+name = "ADSP.man"
+offset = "0x5c"
+length = "0x464"
+[[cse.entry]]
+name = "ADSP.met"
+offset = "0x4c0"
+length = "0x70"
+[[cse.entry]]
+name = "ADSP"
+offset = "0x540"
+length = "0x0"  # calculated by rimage
+
+[css]
+
+[signed_pkg]
+name = "ADSP"
+[[signed_pkg.module]]
+name = "ADSP.met"
+
+[adsp_file]
+[[adsp_file.comp]]
+base_offset = "0x2000"
+
+[fw_desc.header]
+name = "ADSPFW"
+load_offset = "0x40000"
+
+[module]
+count = 1
+
+	[[module.entry]]
+		name = "SMATEST"
+		uuid = "167A961E-8AE4-11EA-89F1-000C29CE1635"
+		affinity_mask = "0x1"
+		instance_count = "1"
+		domain_types = "0"
+		load_type = "0"
+		init_config = "1"
+		module_type = "0xD"
+		auto_start = "0"
+		sched_caps = [1, 0x00008000]
+
+		# pin = [dir, type, sample rate, size, container, channel-cfg]
+		pin = [0, 0, 0xfeef, 0xf, 0xa, 0x45ff,
+				0, 0, 0xfeef, 0xf, 0xa, 0x45ff,
+				1, 0, 0xfeef, 0xf, 0xa, 0x45ff]
+
+		# mod_cfg [PAR_0 PAR_1 PAR_2 PAR_3 IS_BYTES CPS IBS OBS MOD_FLAGS CPC OBLS]
+		mod_cfg = [0, 0, 0, 0, 4096, 1000000, 128, 128, 0, 0, 0]
diff --git a/lmdk/modules/smart_amp_test/CMakeLists.txt b/lmdk/modules/smart_amp_test/CMakeLists.txt
new file mode 100644
index 000000000000..37fcdb87108b
--- /dev/null
+++ b/lmdk/modules/smart_amp_test/CMakeLists.txt
@@ -0,0 +1,13 @@
+target_sources(smart_amp_test PRIVATE ${SOF_BASE}/src/samples/audio/smart_amp_test_ipc4.c)
+
+set_target_properties(smart_amp_test PROPERTIES
+	HPSRAM_ADDR "0xa06c1000"
+)
+
+target_compile_definitions(smart_amp_test PRIVATE
+	__SOF_MODULE_SERVICE_BUILD__=1
+	CONFIG_XTENSA=1
+	CONFIG_IPC_MAJOR_4=1
+)
+
+target_include_directories(smart_amp_test PRIVATE "${SOF_BASE}/src/include")
diff --git a/src/audio/module_adapter/module/generic.c b/src/audio/module_adapter/module/generic.c
index 3ab9f991feb9..565209af6951 100644
--- a/src/audio/module_adapter/module/generic.c
+++ b/src/audio/module_adapter/module/generic.c
@@ -98,7 +98,7 @@ int module_init(struct processing_module *mod, const struct module_interface *in
 	/* check interface, there must be one and only one of processing procedure */
 	if (!interface->init ||
 	    (!!interface->process + !!interface->process_audio_stream +
-	     !!interface->process_raw_data != 1)) {
+	     !!interface->process_raw_data < 1)) {
 		comp_err(dev, "module_init(): comp %d is missing mandatory interfaces",
 			 dev_comp_id(dev));
 		return -EIO;
@@ -258,10 +258,10 @@ int module_process_legacy(struct processing_module *mod,
 	/* set state to processing */
 	md->state = MODULE_PROCESSING;
 #endif
-	if (md->ops->process_audio_stream)
+	if (IS_PROCESSING_MODE_AUDIO_STREAM(mod))
 		ret = md->ops->process_audio_stream(mod, input_buffers, num_input_buffers,
 						    output_buffers, num_output_buffers);
-	else if (md->ops->process_raw_data)
+	else if (IS_PROCESSING_MODE_RAW_DATA(mod))
 		ret = md->ops->process_raw_data(mod, input_buffers, num_input_buffers,
 						output_buffers, num_output_buffers);
 	else
diff --git a/src/audio/module_adapter/module/modules.c b/src/audio/module_adapter/module/modules.c
index 1f7ee82b6a42..61bcd7b02421 100644
--- a/src/audio/module_adapter/module/modules.c
+++ b/src/audio/module_adapter/module/modules.c
@@ -142,10 +142,22 @@ static int modules_init(struct processing_module *mod)
 		struct module_interface *mod_in =
 					(struct module_interface *)md->module_adapter;
 
+		/* The order of preference */
+		if (mod_in->process)
+			mod->proc_type = MODULE_PROCESS_TYPE_SOURCE_SINK;
+		else if (mod_in->process_audio_stream)
+			mod->proc_type = MODULE_PROCESS_TYPE_STREAM;
+		else if (mod_in->process_raw_data)
+			mod->proc_type = MODULE_PROCESS_TYPE_RAW;
+		else
+			return -EINVAL;
+
 		ret = mod_in->init(mod);
 	} else {
+		mod->proc_type = MODULE_PROCESS_TYPE_RAW;
 		ret = iadk_wrapper_init(md->module_adapter);
 	}
+
 	return ret;
 }
 
@@ -174,7 +186,7 @@ static int modules_prepare(struct processing_module *mod,
 		struct module_interface *mod_in =
 					(struct module_interface *)mod->priv.module_adapter;
 
-		ret = mod_in->prepare(mod, NULL, 0, NULL, 0);
+		ret = mod_in->prepare(mod, sources, num_of_sources, sinks, num_of_sinks);
 	} else {
 		ret = iadk_wrapper_prepare(mod->priv.module_adapter);
 	}
@@ -195,18 +207,45 @@ static int modules_init_process(struct processing_module *mod)
 	return 0;
 }
 
+static int modules_process(struct processing_module *mod,
+			   struct sof_source **sources, int num_of_sources,
+			   struct sof_sink **sinks, int num_of_sinks)
+{
+	if (!mod->is_native_sof)
+		return -EOPNOTSUPP;
+
+	struct module_interface *mod_in = (struct module_interface *)mod->priv.module_adapter;
+
+	return mod_in->process(mod, sources, num_of_sources, sinks, num_of_sinks);
+}
+
+static int modules_process_audio_stream(struct processing_module *mod,
+					struct input_stream_buffer *input_buffers,
+					int num_input_buffers,
+					struct output_stream_buffer *output_buffers,
+					int num_output_buffers)
+{
+	if (!mod->is_native_sof)
+		return -EOPNOTSUPP;
+
+	struct module_interface *mod_in = (struct module_interface *)mod->priv.module_adapter;
+
+	return mod_in->process_audio_stream(mod, input_buffers, num_input_buffers,
+					    output_buffers, num_output_buffers);
+}
+
 /*
- * \brief modules_process.
+ * \brief modules_process_raw.
  * \param[in] mod - processing module pointer.
  *
  * \return: zero on success
  *          error code on failure
  */
-static int modules_process(struct processing_module *mod,
-			   struct input_stream_buffer *input_buffers,
-			   int num_input_buffers,
-			   struct output_stream_buffer *output_buffers,
-			   int num_output_buffers)
+static int modules_process_raw(struct processing_module *mod,
+			       struct input_stream_buffer *input_buffers,
+			       int num_input_buffers,
+			       struct output_stream_buffer *output_buffers,
+			       int num_output_buffers)
 {
 	struct comp_dev *dev = mod->dev;
 	struct module_data *md = &mod->priv;
@@ -384,7 +423,9 @@ static int modules_reset(struct processing_module *mod)
 static const struct module_interface interface = {
 	.init = modules_init,
 	.prepare = modules_prepare,
-	.process_raw_data = modules_process,
+	.process_raw_data = modules_process_raw,
+	.process = modules_process,
+	.process_audio_stream = modules_process_audio_stream,
 	.set_processing_mode = modules_set_processing_mode,
 	.get_processing_mode = modules_get_processing_mode,
 	.set_configuration = modules_set_configuration,
diff --git a/src/audio/module_adapter/module_adapter.c b/src/audio/module_adapter/module_adapter.c
index e30c6cbc51cb..3a8fff55c0f5 100644
--- a/src/audio/module_adapter/module_adapter.c
+++ b/src/audio/module_adapter/module_adapter.c
@@ -93,6 +93,16 @@ struct comp_dev *module_adapter_new(const struct comp_driver *drv,
 	mod->max_sources = 1;
 	mod->max_sinks = 1;
 
+	/* The order of preference */
+	if (interface->process)
+		mod->proc_type = MODULE_PROCESS_TYPE_SOURCE_SINK;
+	else if (interface->process_audio_stream)
+		mod->proc_type = MODULE_PROCESS_TYPE_STREAM;
+	else if (interface->process_raw_data)
+		mod->proc_type = MODULE_PROCESS_TYPE_RAW;
+	else
+		goto err;
+
 	/* Init processing module */
 	ret = module_init(mod, interface);
 	if (ret) {
diff --git a/src/include/ipc4/base-config.h b/src/include/ipc4/base-config.h
index b95ecbd3e1f9..07a35a47e9aa 100644
--- a/src/include/ipc4/base-config.h
+++ b/src/include/ipc4/base-config.h
@@ -23,8 +23,9 @@
 
 #ifndef __SOF_IPC4_BASE_CONFIG_H__
 #define __SOF_IPC4_BASE_CONFIG_H__
-
+#ifndef __SOF_MODULE_SERVICE_BUILD__
 #include <sof/compiler_attributes.h>
+#endif
 #include <module/ipc4/base-config.h>
 
 struct sof_ipc_stream_params;
diff --git a/src/include/module/module/base.h b/src/include/module/module/base.h
index 56964162467f..ea951412c653 100644
--- a/src/include/module/module/base.h
+++ b/src/include/module/module/base.h
@@ -60,6 +60,12 @@ struct module_data {
 #endif /* SOF_MODULE_PRIVATE */
 };
 
+enum module_processing_type {
+	MODULE_PROCESS_TYPE_SOURCE_SINK,
+	MODULE_PROCESS_TYPE_STREAM,
+	MODULE_PROCESS_TYPE_RAW,
+};
+
 /*
  * A pointer to this structure is passed to module API functions (from struct module_interface).
  * This structure should contain only fields that should be available to a module.
@@ -153,6 +159,8 @@ struct processing_module {
 	/* max source/sinks supported by the module */
 	uint32_t max_sources;
 	uint32_t max_sinks;
+
+	enum module_processing_type proc_type;
 #endif /* SOF_MODULE_PRIVATE */
 };
 
diff --git a/src/include/sof/audio/module_adapter/module/generic.h b/src/include/sof/audio/module_adapter/module/generic.h
index 1ab2485fe348..a108b81f1404 100644
--- a/src/include/sof/audio/module_adapter/module/generic.h
+++ b/src/include/sof/audio/module_adapter/module/generic.h
@@ -25,14 +25,9 @@
  * helpers to determine processing type
  * Needed till all the modules use PROCESSING_MODE_SINK_SOURCE
  */
-#define IS_PROCESSING_MODE_AUDIO_STREAM(mod) \
-		(!!((struct module_data *)&(mod)->priv)->ops->process_audio_stream)
-
-#define IS_PROCESSING_MODE_RAW_DATA(mod) \
-		(!!((struct module_data *)&(mod)->priv)->ops->process_raw_data)
-
-#define IS_PROCESSING_MODE_SINK_SOURCE(mod) \
-		(!!((struct module_data *)&(mod)->priv)->ops->process)
+#define IS_PROCESSING_MODE_AUDIO_STREAM(mod) ((mod)->proc_type == MODULE_PROCESS_TYPE_STREAM)
+#define IS_PROCESSING_MODE_RAW_DATA(mod) ((mod)->proc_type == MODULE_PROCESS_TYPE_RAW)
+#define IS_PROCESSING_MODE_SINK_SOURCE(mod) ((mod)->proc_type == MODULE_PROCESS_TYPE_SOURCE_SINK)
 
 #define MAX_BLOB_SIZE 8192
 #define MODULE_MAX_SOURCES 8
diff --git a/src/include/sof/samples/audio/smart_amp_test.h b/src/include/sof/samples/audio/smart_amp_test.h
index 3feda5005125..c5ddd8032d99 100644
--- a/src/include/sof/samples/audio/smart_amp_test.h
+++ b/src/include/sof/samples/audio/smart_amp_test.h
@@ -8,8 +8,10 @@
 #ifndef __SOF_AUDIO_SMART_AMP_H__
 #define __SOF_AUDIO_SMART_AMP_H__
 
+#ifndef __SOF_MODULE_SERVICE_BUILD__
 #include <sof/audio/component.h>
 #include <sof/audio/data_blob.h>
+#endif
 
 #if CONFIG_IPC_MAJOR_4
 #include <ipc4/base-config.h>
@@ -19,10 +21,20 @@
 
 #define SMART_AMP_MAX_STREAM_CHAN   8
 
+/* Max channels for all intel platforms are 8 */
+#define MAX_CHANNELS	8
+
 /** IPC blob types */
 #define SOF_SMART_AMP_CONFIG	0
 #define SOF_SMART_AMP_MODEL	1
 
+#ifdef __SOF_MODULE_SERVICE_BUILD__
+#define LOG_ERR(...)
+#define LOG_WRN(...)
+#define LOG_DBG(...)
+#define LOG_INF(...)
+#endif
+
 struct smart_amp_model_data {
 	uint32_t data_size;
 	void *data;
@@ -83,8 +95,8 @@ struct smart_amp_model_data {
 struct sof_smart_amp_config {
 	uint32_t size;
 	uint32_t feedback_channels;
-	int8_t source_ch_map[PLATFORM_MAX_CHANNELS];
-	int8_t feedback_ch_map[PLATFORM_MAX_CHANNELS];
+	int8_t source_ch_map[MAX_CHANNELS];
+	int8_t feedback_ch_map[MAX_CHANNELS];
 };
 
 #if CONFIG_IPC_MAJOR_4
diff --git a/src/samples/audio/smart_amp_test_ipc4.c b/src/samples/audio/smart_amp_test_ipc4.c
index d09a8f9a9720..f6ffd6dae115 100644
--- a/src/samples/audio/smart_amp_test_ipc4.c
+++ b/src/samples/audio/smart_amp_test_ipc4.c
@@ -3,8 +3,9 @@
 // Copyright(c) 2020 Intel Corporation. All rights reserved.
 //
 // Author: Bartosz Kokoszko <bartoszx.kokoszko@linux.intel.com>
+
+#ifndef __SOF_MODULE_SERVICE_BUILD__
 #include <sof/compiler_attributes.h>
-#include <sof/samples/audio/smart_amp_test.h>
 #include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/ipc-config.h>
 #include <sof/trace/trace.h>
@@ -18,6 +19,7 @@
 #include <ipc4/module.h>
 
 LOG_MODULE_REGISTER(smart_amp_test, CONFIG_SOF_LOG_LEVEL);
+#include <zephyr/logging/log.h>
 
 /* 167a961e-8ae4-11ea-89f1-000c29ce1635 */
 DECLARE_SOF_RT_UUID("smart_amp-test", smart_amp_test_comp_uuid, 0x167a961e, 0x8ae4,
@@ -25,110 +27,104 @@ DECLARE_SOF_RT_UUID("smart_amp-test", smart_amp_test_comp_uuid, 0x167a961e, 0x8a
 
 DECLARE_TR_CTX(smart_amp_test_comp_tr, SOF_UUID(smart_amp_test_comp_uuid),
 	       LOG_LEVEL_INFO);
-typedef int(*smart_amp_proc)(struct processing_module *mod,
-			     struct input_stream_buffer *bsource,
-			     struct output_stream_buffer *bsink, uint32_t frames,
-			     int8_t *chan_map);
+#else
+#include <string.h>
+#include <stdint.h>
+#include <stddef.h>
+
+#include <module/base.h>
+#include <module/api_ver.h>
+#include <module/interface.h>
+#include <iadk/adsp_error_code.h>
+#include <rimage/sof/user/manifest.h>
+#include <audio/source_api.h>
+#include <audio/sink_api.h>
+#include <ipc4/module.h>
+#include <sof/math/numbers.h>
+#endif
+#include <sof/samples/audio/smart_amp_test.h>
+
+typedef void (*smart_amp_proc)(int8_t const *src_ptr,
+			       int8_t const *src_begin,
+			       int8_t const *src_end,
+			       int8_t *dst_ptr,
+			       int8_t const *dst_begin,
+			       int8_t const *dst_end,
+			       uint32_t size);
+
 struct smart_amp_data {
 	struct sof_smart_amp_ipc4_config ipc4_cfg;
 	struct sof_smart_amp_config config;
-	struct comp_data_blob_handler *model_handler;
-	void *data_blob;
-	size_t data_blob_size;
 	smart_amp_proc process;
 	uint32_t out_channels;
 };
 
+#ifdef __SOF_MODULE_SERVICE_BUILD__
+static struct smart_amp_data smart_amp_priv;
+#endif
+
 static int smart_amp_init(struct processing_module *mod)
 {
 	struct smart_amp_data *sad;
-	struct comp_dev *dev = mod->dev;
 	struct module_data *mod_data = &mod->priv;
-	const size_t in_size = sizeof(struct ipc4_input_pin_format) * SMART_AMP_NUM_IN_PINS;
-	const size_t out_size = sizeof(struct ipc4_output_pin_format) * SMART_AMP_NUM_OUT_PINS;
 	int ret;
 	const struct ipc4_base_module_extended_cfg *base_cfg = mod_data->cfg.init_data;
 
-	comp_dbg(dev, "smart_amp_init()");
+	LOG_DBG("smart_amp_init()");
+
+#ifndef __SOF_MODULE_SERVICE_BUILD__
 	sad = rzalloc(SOF_MEM_ZONE_RUNTIME, 0, SOF_MEM_CAPS_RAM, sizeof(*sad));
 	if (!sad)
 		return -ENOMEM;
-
+#else
+	sad = &smart_amp_priv;
+#endif
 	mod_data->private = sad;
 
-	/* component model data handler */
-	sad->model_handler = comp_data_blob_handler_new(dev);
-	if (!sad->model_handler) {
-		ret = -ENOMEM;
-		goto sad_fail;
-	}
-
 	if (base_cfg->base_cfg_ext.nb_input_pins != SMART_AMP_NUM_IN_PINS ||
 	    base_cfg->base_cfg_ext.nb_output_pins != SMART_AMP_NUM_OUT_PINS) {
-		comp_err(dev, "smart_amp_init(): Invalid pin configuration");
 		ret = -EINVAL;
 		goto sad_fail;
 	}
 
 	/* Copy the pin formats */
-	memcpy_s(sad->ipc4_cfg.input_pins, in_size,
-		 base_cfg->base_cfg_ext.pin_formats, in_size);
-	memcpy_s(&sad->ipc4_cfg.output_pin, out_size,
-		 &base_cfg->base_cfg_ext.pin_formats[in_size], out_size);
-
-	mod->max_sources = SMART_AMP_NUM_IN_PINS;
+	sad->ipc4_cfg.input_pins[0] =
+		*((struct ipc4_input_pin_format *)base_cfg->base_cfg_ext.pin_formats);
+	sad->ipc4_cfg.input_pins[1] =
+		*((struct ipc4_input_pin_format *)base_cfg->base_cfg_ext.pin_formats + 1);
+	sad->ipc4_cfg.output_pin =
+		*(struct ipc4_output_pin_format *)(base_cfg->base_cfg_ext.pin_formats
+			+ sizeof(sad->ipc4_cfg.input_pins));
 
 	return 0;
 
 sad_fail:
-	comp_data_blob_handler_free(sad->model_handler);
+#ifndef __SOF_MODULE_SERVICE_BUILD__
 	rfree(sad);
+#endif
 	return ret;
 }
 
-static void smart_amp_set_params(struct processing_module *mod)
-{
-	struct sof_ipc_stream_params *params = mod->stream_params;
-	struct comp_dev *dev = mod->dev;
-	struct smart_amp_data *sad = module_get_private_data(mod);
-	struct comp_buffer *sink;
-
-	ipc4_base_module_cfg_to_stream_params(&mod->priv.cfg.base_cfg, params);
-
-	/* update sink format */
-	if (!list_is_empty(&dev->bsink_list)) {
-		struct ipc4_output_pin_format *sink_fmt = &sad->ipc4_cfg.output_pin;
-		struct ipc4_audio_format out_fmt = sink_fmt->audio_fmt;
-
-		sink = list_first_item(&dev->bsink_list, struct comp_buffer, source_list);
-
-		ipc4_update_buffer_format(sink, &out_fmt);
-		params->frame_fmt = audio_stream_get_frm_fmt(&sink->stream);
-	}
-}
-
 static int smart_amp_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)
 {
-	struct comp_dev *dev = mod->dev;
 	struct smart_amp_data *sad = module_get_private_data(mod);
 
-	comp_dbg(dev, "smart_amp_set_config()");
+	LOG_DBG("smart_amp_set_config()");
 
 	switch (config_id) {
 	case SMART_AMP_SET_MODEL:
-		return comp_data_blob_set(sad->model_handler, pos,
-					 data_offset_size, fragment, fragment_size);
+		return 0;
 	case SMART_AMP_SET_CONFIG:
 		if (fragment_size != sizeof(sad->config)) {
-			comp_err(dev, "smart_amp_set_config(): invalid config size %u, expect %u",
-				 fragment_size, sizeof(struct sof_smart_amp_config));
+			LOG_ERR("smart_amp_set_config(): invalid config size %u, expect %u",
+				fragment_size, sizeof(struct sof_smart_amp_config));
 			return -EINVAL;
 		}
-		comp_dbg(dev, "smart_amp_set_config(): config size = %u", fragment_size);
-		memcpy_s(&sad->config, sizeof(sad->config), fragment, fragment_size);
+		LOG_DBG("smart_amp_set_config(): config size = %u", fragment_size);
+		sad->config = *(struct sof_smart_amp_config *)fragment;
 		return 0;
 	default:
 		return -EINVAL;
@@ -140,19 +136,12 @@ static inline int smart_amp_get_config(struct processing_module *mod,
 				       uint8_t *fragment, size_t fragment_size)
 {
 	struct smart_amp_data *sad = module_get_private_data(mod);
-	struct comp_dev *dev = mod->dev;
-	int ret;
 
-	comp_dbg(dev, "smart_amp_get_config()");
+	LOG_DBG("smart_amp_get_config()");
 
 	switch (config_id) {
 	case SMART_AMP_GET_CONFIG:
-		ret = memcpy_s(fragment, fragment_size, &sad->config, sizeof(sad->config));
-		if (ret) {
-			comp_err(dev, "smart_amp_get_config(): wrong config size %d",
-				 fragment_size);
-			return ret;
-		}
+		 *(struct sof_smart_amp_config *)fragment = sad->config;
 		*data_offset_size = sizeof(sad->config);
 		return 0;
 	default:
@@ -162,234 +151,241 @@ static inline int smart_amp_get_config(struct processing_module *mod,
 
 static int smart_amp_free(struct processing_module *mod)
 {
+	LOG_DBG("smart_amp_free()");
+
+#ifndef __SOF_MODULE_SERVICE_BUILD__
 	struct smart_amp_data *sad = module_get_private_data(mod);
-	struct comp_dev *dev = mod->dev;
 
-	comp_dbg(dev, "smart_amp_free()");
-	comp_data_blob_handler_free(sad->model_handler);
 	rfree(sad);
+#endif
+
 	return 0;
 }
 
-static int smart_amp_params(struct processing_module *mod)
+static void process_s16(int8_t const *src_ptr,
+			int8_t const *src_begin,
+			int8_t const *src_end,
+			int8_t *dst_ptr,
+			int8_t const *dst_begin,
+			int8_t const *dst_end,
+			uint32_t size)
 {
-	struct sof_ipc_stream_params *params = mod->stream_params;
-	struct comp_dev *dev = mod->dev;
-	int ret;
+	int16_t const *src_addr = (int16_t const *)src_ptr;
+	int16_t *dst_addr = (int16_t *)dst_ptr;
+	int count = size >> 1;
+	int i;
 
-	comp_dbg(dev, "smart_amp_params()");
-	smart_amp_set_params(mod);
-	ret = comp_verify_params(dev, BUFF_PARAMS_CHANNELS, params);
-	if (ret < 0) {
-		comp_err(dev, "smart_amp_params(): pcm params verification failed.");
-		return -EINVAL;
+	for (i = 0; i < count; i++) {
+		if (src_addr >= (int16_t const *)src_end)
+			src_addr = (int16_t const *)src_begin;
+
+		if (dst_addr >= (int16_t *)dst_end)
+			dst_addr = (int16_t *)dst_begin;
+
+		*dst_addr = *src_addr;
+		src_addr++;
+		dst_addr++;
 	}
-	return 0;
 }
 
-static int smart_amp_process_s16(struct processing_module *mod,
-				 struct input_stream_buffer *bsource,
-				 struct output_stream_buffer *bsink,
-				 uint32_t frames, int8_t *chan_map)
+static void process_s32(int8_t const *src_ptr,
+			int8_t const *src_begin,
+			int8_t const *src_end,
+			int8_t *dst_ptr,
+			int8_t const *dst_begin,
+			int8_t const *dst_end,
+			uint32_t size)
 {
-	struct smart_amp_data *sad = module_get_private_data(mod);
-	struct audio_stream *source = bsource->data;
-	struct audio_stream *sink = bsink->data;
-	int16_t *src;
-	int16_t *dest;
-	uint32_t in_frag = 0;
-	uint32_t out_frag = 0;
+	int32_t const *src_addr = (int32_t const *)src_ptr;
+	int32_t *dst_addr = (int32_t *)dst_ptr;
+	int count = size >> 2;
 	int i;
-	int j;
-
-	bsource->consumed += frames * audio_stream_get_channels(source) * sizeof(int16_t);
-	for (i = 0; i < frames; i++) {
-		for (j = 0 ; j < sad->out_channels; j++) {
-			if (chan_map[j] != -1) {
-				src = audio_stream_read_frag_s16(source,
-								 in_frag +
-								 chan_map[j]);
-				dest = audio_stream_write_frag_s16(sink,
-								   out_frag);
-				*dest = *src;
-			}
-			out_frag++;
-		}
-		in_frag += audio_stream_get_channels(source);
+
+	for (i = 0; i < count; i++) {
+		if (src_addr >= (int32_t const *)src_end)
+			src_addr = (int32_t const *)src_begin;
+
+		if (dst_addr >= (int32_t *)dst_end)
+			dst_addr = (int32_t *)dst_begin;
+
+		*dst_addr = *src_addr;
+		src_addr++;
+		dst_addr++;
 	}
-	return 0;
 }
 
-static int smart_amp_process_s32(struct processing_module *mod,
-				 struct input_stream_buffer *bsource,
-				 struct output_stream_buffer *bsink,
-				 uint32_t frames, int8_t *chan_map)
+static int smart_amp_process_data(struct processing_module *mod,
+				  struct sof_source *source,
+				  struct sof_source *feedback,
+				  struct sof_sink *sink,
+				  size_t size)
 {
 	struct smart_amp_data *sad = module_get_private_data(mod);
-	struct audio_stream *source = bsource->data;
-	struct audio_stream *sink = bsink->data;
-	int32_t *src;
-	int32_t *dest;
-	uint32_t in_frag = 0;
-	uint32_t out_frag = 0;
-	int i;
-	int j;
-
-	bsource->consumed += frames * audio_stream_get_channels(source) * sizeof(int32_t);
-	for (i = 0; i < frames; i++) {
-		for (j = 0 ; j < sad->out_channels; j++) {
-			if (chan_map[j] != -1) {
-				src = audio_stream_read_frag_s32(source,
-								 in_frag +
-								 chan_map[j]);
-				dest = audio_stream_write_frag_s32(sink,
-								   out_frag);
-				*dest = *src;
-			}
-			out_frag++;
-		}
-		in_frag += audio_stream_get_channels(source);
-	}
+	int8_t const *src_ptr;
+	int8_t const *src_begin;
+	int8_t const *src_end;
+	int8_t *dst_ptr;
+	int8_t const *dst_begin;
+	int8_t const *dst_end;
+	size_t src_size;
+	size_t dst_size;
+	int ret;
 
-	return 0;
-}
+	ret = sink_get_buffer(sink, size,
+			      (void **)&dst_ptr,
+			      (void **)&dst_begin,
+			      &dst_size);
+	if (ret)
+		return ret;
 
-static smart_amp_proc get_smart_amp_process(struct comp_dev *dev,
-					    struct comp_buffer *buf)
-{
-	switch (audio_stream_get_frm_fmt(&buf->stream)) {
-	case SOF_IPC_FRAME_S16_LE:
-		return smart_amp_process_s16;
-	case SOF_IPC_FRAME_S24_4LE:
-	case SOF_IPC_FRAME_S32_LE:
-		return smart_amp_process_s32;
-	default:
-		comp_err(dev, "smart_amp_process() error: not supported frame format");
-		return NULL;
+	if (!feedback || !source_get_data_available(feedback))
+		goto source;
+
+	ret = source_get_data(feedback, size,
+			      (void const **)&src_ptr,
+			      (void const **)&src_begin,
+			      &src_size);
+	if (ret) {
+		if (ret == -EBUSY)
+			return 0;
+		else
+			return ret;
 	}
+
+	src_end = src_begin + src_size;
+	dst_end = dst_begin + dst_size;
+	sad->process(src_ptr, src_begin, src_end, dst_ptr, dst_begin, dst_end, size);
+	source_release_data(feedback, size);
+
+source:
+	ret = source_get_data(source, size,
+			      (void const **)&src_ptr,
+			      (void const **)&src_begin,
+			      &src_size);
+	if (ret)
+		return ret;
+
+	src_end = src_begin + src_size;
+	dst_end = dst_begin + dst_size;
+	sad->process(src_ptr, src_begin, src_end, dst_ptr, dst_begin, dst_end, size);
+	source_release_data(source, size);
+	sink_commit_buffer(sink, size);
+	return 0;
 }
 
 static int smart_amp_process(struct processing_module *mod,
-			     struct input_stream_buffer *input_buffers, int num_input_buffers,
-			     struct output_stream_buffer *output_buffers, int num_output_buffers)
+			     struct sof_source **sources, int num_of_sources,
+			     struct sof_sink **sinks, int num_of_sinks)
 {
-	struct smart_amp_data *sad = module_get_private_data(mod);
-	struct comp_dev *dev = mod->dev;
-	struct comp_buffer *fb_buf_c;
-	struct comp_buffer *buf;
-	struct input_stream_buffer *fb_input = NULL;
+	struct sof_source *fb_input = NULL;
 	/* if there is only one input stream, it should be the source input */
-	struct input_stream_buffer *src_input = &input_buffers[0];
-	uint32_t avail_passthrough_frames;
-	uint32_t avail_frames = 0;
-	uint32_t sink_bytes;
+	struct sof_source *src_input = sources[0];
+	uint32_t avail_passthrough;
+	uint32_t avail = 0;
 	uint32_t i;
+	int ret;
 
-	if (num_input_buffers == SMART_AMP_NUM_IN_PINS)
-		for (i = 0; i < num_input_buffers; i++) {
-			buf = container_of(input_buffers[i].data, struct comp_buffer, stream);
-
-			if (IPC4_SINK_QUEUE_ID(buf_get_id(buf)) ==
-					SOF_SMART_AMP_FEEDBACK_QUEUE_ID) {
-				fb_input = &input_buffers[i];
-				fb_buf_c = buf;
+	if (num_of_sources == SMART_AMP_NUM_IN_PINS) {
+		for (i = 0; i < num_of_sources; i++) {
+			if (IPC4_SINK_QUEUE_ID(source_get_id(sources[i])) ==
+			    SOF_SMART_AMP_FEEDBACK_QUEUE_ID) {
+				fb_input = sources[i];
 			} else {
-				src_input = &input_buffers[i];
+				src_input = sources[i];
 			}
 		}
-
-	avail_passthrough_frames = src_input->size;
-
-	if (fb_input) {
-		if (fb_buf_c->source && comp_get_state(dev, fb_buf_c->source) == dev->state) {
-			/* feedback */
-			avail_frames = MIN(avail_passthrough_frames,
-					   fb_input->size);
-
-			sad->process(mod, fb_input, &output_buffers[0],
-				     avail_frames, sad->config.feedback_ch_map);
-		}
 	}
 
-	if (!avail_frames)
-		avail_frames = avail_passthrough_frames;
+	avail_passthrough = source_get_data_available(src_input);
 
-	/* bytes calculation */
-	sink_bytes = avail_frames *
-		audio_stream_frame_bytes(output_buffers[0].data);
+	if (fb_input && source_get_data_available(fb_input)) {
+		/* feedback */
+		avail = MIN(avail_passthrough, source_get_data_available(fb_input));
+		avail = MIN(avail, sink_get_free_size(sinks[0]));
+	} else {
+		avail = MIN(avail_passthrough, sink_get_free_size(sinks[0]));
+	}
 
 	/* process data */
-	sad->process(mod, src_input, &output_buffers[0],
-		     avail_frames, sad->config.source_ch_map);
-
-	output_buffers[0].size = sink_bytes;
+	ret = smart_amp_process_data(mod, src_input, fb_input, sinks[0], avail);
 
-	return 0;
+	return ret;
 }
 
 static int smart_amp_reset(struct processing_module *mod)
 {
-	struct comp_dev *dev = mod->dev;
-
-	comp_dbg(dev, "smart_amp_reset()");
+	LOG_DBG("smart_amp_reset()");
 
 	return 0;
 }
 
+static smart_amp_proc get_smart_amp_process(struct sof_sink *sink)
+{
+	switch (sink_get_frm_fmt(sink)) {
+	case SOF_IPC_FRAME_S16_LE:
+		return process_s16;
+	case SOF_IPC_FRAME_S24_4LE:
+	case SOF_IPC_FRAME_S32_LE:
+		return process_s32;
+	default:
+		LOG_ERR("smart_amp_process() error: not supported frame format");
+		return NULL;
+	}
+}
+
 static int smart_amp_prepare(struct processing_module *mod,
 			     struct sof_source **sources, int num_of_sources,
 			     struct sof_sink **sinks, int num_of_sinks)
 {
 	struct smart_amp_data *sad = module_get_private_data(mod);
-	struct comp_dev *dev = mod->dev;
-	struct comp_buffer *source_buffer;
-	struct comp_buffer *sink_buffer;
-	struct list_item *blist;
-	int ret;
-
-	ret = smart_amp_params(mod);
-	if (ret < 0)
-		return ret;
-
-	comp_dbg(dev, "smart_amp_prepare()");
-	/* searching for stream and feedback source buffers */
-	list_for_item(blist, &dev->bsource_list) {
-		source_buffer = container_of(blist, struct comp_buffer,
-					     sink_list);
-		audio_stream_init_alignment_constants(1, 1, &source_buffer->stream);
-		if (IPC4_SINK_QUEUE_ID(buf_get_id(source_buffer)) ==
-				SOF_SMART_AMP_FEEDBACK_QUEUE_ID) {
-			audio_stream_set_channels(&source_buffer->stream,
-						  sad->config.feedback_channels);
-			audio_stream_set_rate(&source_buffer->stream,
-					      mod->priv.cfg.base_cfg.audio_fmt.sampling_frequency);
-		}
-	}
 
-	sink_buffer = list_first_item(&dev->bsink_list, struct comp_buffer, source_list);
-	sad->out_channels = audio_stream_get_channels(&sink_buffer->stream);
-	audio_stream_init_alignment_constants(1, 1, &sink_buffer->stream);
-	sad->process = get_smart_amp_process(dev, sink_buffer);
+	LOG_DBG("smart_amp_prepare()");
 
+	sad->process = get_smart_amp_process(sinks[0]);
 	if (!sad->process) {
-		comp_err(dev, "smart_amp_prepare(): get_smart_amp_process failed");
-		ret = -EINVAL;
+		LOG_ERR("smart_amp_prepare(): get_smart_amp_process failed");
+		return -EINVAL;
 	}
-	return ret;
+
+	return 0;
 }
 
 static const struct module_interface smart_amp_test_interface = {
 	.init = smart_amp_init,
 	.prepare = smart_amp_prepare,
-	.process_audio_stream = smart_amp_process,
+	.process = smart_amp_process,
 	.set_configuration = smart_amp_set_config,
 	.get_configuration = smart_amp_get_config,
 	.reset = smart_amp_reset,
 	.free = smart_amp_free
 };
 
+#ifndef __SOF_MODULE_SERVICE_BUILD__
 DECLARE_MODULE_ADAPTER(smart_amp_test_interface, smart_amp_test_comp_uuid, smart_amp_test_comp_tr);
 /* DECLARE_MODULE_ADAPTER() creates
  * "sys_comp_module_<smart_amp_test_interface>_init()" (and a lot more)
  */
 SOF_MODULE_INIT(smart_amp_test, sys_comp_module_smart_amp_test_interface_init);
+#else
+static const struct module_interface *loadable_module_main(void *mod_cfg,
+							   void *parent_ppl,
+							   void **mod_ptr)
+{
+	return &smart_amp_test_interface;
+}
+
+DECLARE_LOADABLE_MODULE_API_VERSION(smart_amp_test);
+
+__attribute__((section(".module")))
+const struct sof_man_module_manifest main_manifest = {
+	.module = {
+		.name = "SMATEST",
+		.uuid = {0x1E, 0x96, 0x7A, 0x16, 0xE4, 0x8A, 0xEA, 0x11,
+			 0x89, 0xF1, 0x00, 0x0C, 0x29, 0xCE, 0x16, 0x35},
+		.entry_point = (uint32_t)loadable_module_main,
+		.type = { .load_type = SOF_MAN_MOD_TYPE_MODULE,
+		.domain_ll = 1 },
+		.affinity_mask = 1,
+	}
+};
+#endif