diff --git a/src/audio/aria/aria.c b/src/audio/aria/aria.c
index 2f558eb2d6d9..006edf9533dd 100644
--- a/src/audio/aria/aria.c
+++ b/src/audio/aria/aria.c
@@ -9,7 +9,6 @@
 #include <sof/audio/pipeline.h>
 #include <rtos/panic.h>
 #include <sof/ipc/msg.h>
-#include <rtos/alloc.h>
 #include <rtos/cache.h>
 #include <rtos/init.h>
 #include <sof/lib/notifier.h>
@@ -126,7 +125,7 @@ static int aria_init(struct processing_module *mod)
 	list_init(&dev->bsource_list);
 	list_init(&dev->bsink_list);
 
-	cd = rzalloc(SOF_MEM_FLAG_USER, sizeof(*cd));
+	cd = mod_zalloc(mod, sizeof(*cd));
 	if (!cd) {
 		return -ENOMEM;
 	}
@@ -145,10 +144,9 @@ static int aria_init(struct processing_module *mod)
 	}
 	mod_data->private = cd;
 
-	buf = rballoc(SOF_MEM_FLAG_USER, req_mem);
+	buf = mod_alloc(mod, req_mem);
 
 	if (!buf) {
-		rfree(cd);
 		comp_err(dev, "allocation failed for size %d", req_mem);
 		return -ENOMEM;
 	}
@@ -158,10 +156,6 @@ static int aria_init(struct processing_module *mod)
 
 static int aria_free(struct processing_module *mod)
 {
-	struct aria_data *cd = module_get_private_data(mod);
-
-	rfree(cd->data_addr);
-	rfree(cd);
 	return 0;
 }
 
diff --git a/src/audio/asrc/asrc.c b/src/audio/asrc/asrc.c
index 2d77a04c380f..7a7e2c24400b 100644
--- a/src/audio/asrc/asrc.c
+++ b/src/audio/asrc/asrc.c
@@ -11,7 +11,6 @@
 #include <sof/audio/ipc-config.h>
 #include <rtos/panic.h>
 #include <sof/ipc/msg.h>
-#include <rtos/alloc.h>
 #include <rtos/init.h>
 #include <sof/lib/uuid.h>
 #include <sof/math/numbers.h>
@@ -217,7 +216,7 @@ static int asrc_init(struct processing_module *mod)
 		return -EINVAL;
 	}
 
-	cd = rzalloc(SOF_MEM_FLAG_USER, sizeof(*cd));
+	cd = mod_alloc(mod, sizeof(*cd));
 	if (!cd)
 		return -ENOMEM;
 
@@ -242,7 +241,7 @@ static int asrc_init(struct processing_module *mod)
 	return 0;
 }
 
-static int asrc_initialize_buffers(struct asrc_farrow *src_obj)
+static int asrc_initialize_buffers(struct processing_module *mod, struct asrc_farrow *src_obj)
 {
 	int32_t *buf_32;
 	int16_t *buf_16;
@@ -261,7 +260,7 @@ static int asrc_initialize_buffers(struct asrc_farrow *src_obj)
 		buffer_size = src_obj->buffer_length * sizeof(int32_t);
 
 		for (ch = 0; ch < src_obj->num_channels; ch++) {
-			buf_32 = rzalloc(SOF_MEM_FLAG_USER, buffer_size);
+			buf_32 = mod_zalloc(mod, buffer_size);
 
 			if (!buf_32)
 				return -ENOMEM;
@@ -272,7 +271,7 @@ static int asrc_initialize_buffers(struct asrc_farrow *src_obj)
 		buffer_size = src_obj->buffer_length * sizeof(int16_t);
 
 		for (ch = 0; ch < src_obj->num_channels; ch++) {
-			buf_16 = rzalloc(SOF_MEM_FLAG_USER, buffer_size);
+			buf_16 = mod_zalloc(mod, buffer_size);
 
 			if (!buf_16)
 				return -ENOMEM;
@@ -284,7 +283,7 @@ static int asrc_initialize_buffers(struct asrc_farrow *src_obj)
 	return 0;
 }
 
-static void asrc_release_buffers(struct asrc_farrow *src_obj)
+static void asrc_release_buffers(struct processing_module *mod, struct asrc_farrow *src_obj)
 {
 	int32_t *buf_32;
 	int16_t *buf_16;
@@ -299,7 +298,7 @@ static void asrc_release_buffers(struct asrc_farrow *src_obj)
 
 			if (buf_32) {
 				src_obj->ring_buffers32[ch] = NULL;
-				rfree(buf_32);
+				mod_free(mod, buf_32);
 			}
 		}
 	else
@@ -308,23 +307,17 @@ static void asrc_release_buffers(struct asrc_farrow *src_obj)
 
 			if (buf_16) {
 				src_obj->ring_buffers16[ch] = NULL;
-				rfree(buf_16);
+				mod_free(mod, buf_16);
 			}
 		}
 }
 
 static int asrc_free(struct processing_module *mod)
 {
-	struct comp_data *cd = module_get_private_data(mod);
 	struct comp_dev *dev = mod->dev;
 
 	comp_dbg(dev, "asrc_free()");
 
-	rfree(cd->buf);
-	asrc_release_buffers(cd->asrc_obj);
-	asrc_free_polyphase_filter(cd->asrc_obj);
-	rfree(cd->asrc_obj);
-	rfree(cd);
 	return 0;
 }
 
@@ -614,8 +607,7 @@ static int asrc_prepare(struct processing_module *mod,
 	cd->buf_size = (cd->source_frames_max + cd->sink_frames_max) *
 		frame_bytes;
 
-	cd->buf = rzalloc(SOF_MEM_FLAG_USER,
-			  cd->buf_size);
+	cd->buf = mod_zalloc(mod, cd->buf_size);
 	if (!cd->buf) {
 		cd->buf_size = 0;
 		comp_err(dev, "asrc_prepare(), allocation fail for size %d",
@@ -632,7 +624,7 @@ static int asrc_prepare(struct processing_module *mod,
 
 	/* Get required size and allocate memory for ASRC */
 	sample_bits = sample_bytes * 8;
-	ret = asrc_get_required_size(dev, &cd->asrc_size,
+	ret = asrc_get_required_size(mod, &cd->asrc_size,
 				     audio_stream_get_channels(&sourceb->stream),
 				     sample_bits);
 	if (ret) {
@@ -640,8 +632,7 @@ static int asrc_prepare(struct processing_module *mod,
 		goto err_free_buf;
 	}
 
-	cd->asrc_obj = rzalloc(SOF_MEM_FLAG_USER,
-			       cd->asrc_size);
+	cd->asrc_obj = mod_zalloc(mod, cd->asrc_size);
 	if (!cd->asrc_obj) {
 		comp_err(dev, "asrc_prepare(), allocation fail for size %d",
 			 cd->asrc_size);
@@ -659,7 +650,7 @@ static int asrc_prepare(struct processing_module *mod,
 		fs_sec = cd->source_rate;
 	}
 
-	ret = asrc_initialise(dev, cd->asrc_obj, audio_stream_get_channels(&sourceb->stream),
+	ret = asrc_initialise(mod, cd->asrc_obj, audio_stream_get_channels(&sourceb->stream),
 			      fs_prim, fs_sec,
 			      ASRC_IOF_INTERLEAVED, ASRC_IOF_INTERLEAVED,
 			      ASRC_BM_LINEAR, cd->frames, sample_bits,
@@ -670,7 +661,7 @@ static int asrc_prepare(struct processing_module *mod,
 	}
 
 	/* Allocate ring buffers */
-	ret = asrc_initialize_buffers(cd->asrc_obj);
+	ret = asrc_initialize_buffers(mod, cd->asrc_obj);
 
 	/* check for errors */
 	if (ret) {
@@ -698,12 +689,12 @@ static int asrc_prepare(struct processing_module *mod,
 	return 0;
 
 err_free_asrc:
-	asrc_release_buffers(cd->asrc_obj);
-	rfree(cd->asrc_obj);
+	asrc_release_buffers(mod, cd->asrc_obj);
+	mod_free(mod, cd->asrc_obj);
 	cd->asrc_obj = NULL;
 
 err_free_buf:
-	rfree(cd->buf);
+	mod_free(mod, cd->buf);
 	cd->buf = NULL;
 
 err:
@@ -865,10 +856,10 @@ static int asrc_reset(struct processing_module *mod)
 		asrc_dai_stop_timestamp(cd);
 
 	/* Free the allocations those were done in prepare() */
-	asrc_release_buffers(cd->asrc_obj);
-	asrc_free_polyphase_filter(cd->asrc_obj);
-	rfree(cd->asrc_obj);
-	rfree(cd->buf);
+	asrc_release_buffers(mod, cd->asrc_obj);
+	asrc_free_polyphase_filter(mod, cd->asrc_obj);
+	mod_free(mod, cd->asrc_obj);
+	mod_free(mod, cd->buf);
 	cd->asrc_obj = NULL;
 	cd->buf = NULL;
 
diff --git a/src/audio/asrc/asrc_farrow.c b/src/audio/asrc/asrc_farrow.c
index 987a11408af0..e840a8082a3b 100644
--- a/src/audio/asrc/asrc_farrow.c
+++ b/src/audio/asrc/asrc_farrow.c
@@ -11,9 +11,9 @@
 #include <rtos/string.h>
 #include <sof/trace/trace.h>
 #include <sof/audio/format.h>
-#include <sof/lib/fast-get.h>
 #include <sof/lib/memory.h>
 #include <user/trace.h>
+#include <sof/audio/module_adapter/module/generic.h>
 #include "asrc_farrow.h"
 
 LOG_MODULE_DECLARE(asrc, CONFIG_SOF_LOG_LEVEL);
@@ -243,7 +243,7 @@ static const struct asrc_filter_params c_filter_params[CR_NUM] = {
  * Initialise the pointers to the filters, set the number of filters
  * and their length
  */
-static enum asrc_error_code initialise_filter(struct comp_dev *dev,
+static enum asrc_error_code initialise_filter(struct processing_module *mod,
 					      struct asrc_farrow *src_obj);
 
 /*
@@ -268,11 +268,12 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
  * Pointers to each channels data. Buffers are allocated externally.
  */
 
-enum asrc_error_code asrc_get_required_size(struct comp_dev *dev,
+enum asrc_error_code asrc_get_required_size(struct processing_module *mod,
 					    int *required_size,
 					    int num_channels,
 					    int bit_depth)
 {
+	struct comp_dev *dev = mod->dev;
 	int size;
 
 	/* check for parameter errors */
@@ -318,7 +319,7 @@ enum asrc_error_code asrc_get_required_size(struct comp_dev *dev,
 	return ASRC_EC_OK;
 }
 
-enum asrc_error_code asrc_initialise(struct comp_dev *dev,
+enum asrc_error_code asrc_initialise(struct processing_module *mod,
 				     struct asrc_farrow *src_obj,
 				     int num_channels,
 				     int32_t fs_prim,
@@ -331,6 +332,7 @@ enum asrc_error_code asrc_initialise(struct comp_dev *dev,
 				     enum asrc_control_mode control_mode,
 				     enum asrc_operation_mode operation_mode)
 {
+	struct comp_dev *dev = mod->dev;
 	enum asrc_error_code error_code;
 
 	/* check for parameter errors */
@@ -410,7 +412,7 @@ enum asrc_error_code asrc_initialise(struct comp_dev *dev,
 	 * also sets the pointer to the corresponding
 	 * calc_impulse_response_nX function.
 	 */
-	error_code = initialise_filter(dev, src_obj);
+	error_code = initialise_filter(mod, src_obj);
 
 	/* check for errors */
 	if (error_code != ASRC_EC_OK) {
@@ -438,10 +440,12 @@ enum asrc_error_code asrc_initialise(struct comp_dev *dev,
 	return ASRC_EC_OK;
 }
 
-enum asrc_error_code asrc_set_fs_ratio(struct comp_dev *dev,
+enum asrc_error_code asrc_set_fs_ratio(struct processing_module *mod,
 				       struct asrc_farrow *src_obj,
 				       int32_t fs_prim, int32_t fs_sec)
 {
+	struct comp_dev *dev = mod->dev;
+
 	/* Check for parameter errors */
 	if (!src_obj) {
 		comp_err(dev, "asrc_set_fs_ratio(), null src_obj");
@@ -490,7 +494,7 @@ enum asrc_error_code asrc_set_fs_ratio(struct comp_dev *dev,
 	/* See initialise_asrc(...) for further information
 	 * Update the filters accordingly
 	 */
-	enum asrc_error_code error_code = initialise_filter(dev, src_obj);
+	enum asrc_error_code error_code = initialise_filter(mod, src_obj);
 	/* check for errors */
 	if (error_code != ASRC_EC_OK) {
 		comp_err(dev, "asrc_set_fs_ratio(), failed filter initialise");
@@ -554,28 +558,29 @@ enum asrc_error_code asrc_set_output_format(struct comp_dev *dev,
 	return ASRC_EC_OK;
 }
 
-static const int32_t *__get_polyphase_filter(const int32_t *filter, size_t size)
+static const int32_t *__get_polyphase_filter(struct processing_module *mod,
+					     const int32_t *filter, size_t size)
 {
 #if CONFIG_FAST_GET
-	return fast_get(filter, size);
+	return mod_fast_get(mod, filter, size);
 #else
 	return filter;
 #endif
 }
 
-#define get_polyphase_filter(f) __get_polyphase_filter(f, sizeof(f))
+#define get_polyphase_filter(m, f) __get_polyphase_filter(m, f, sizeof(f))
 
-static void put_polyphase_filter(const int32_t *filter)
+static void put_polyphase_filter(struct processing_module *mod, const int32_t *filter)
 {
 #if CONFIG_FAST_GET
-	fast_put(filter);
+	mod_fast_put(mod, filter);
 #endif
 }
 
-void asrc_free_polyphase_filter(struct asrc_farrow *src_obj)
+void asrc_free_polyphase_filter(struct processing_module *mod, struct asrc_farrow *src_obj)
 {
 	if (src_obj && src_obj->polyphase_filters) {
-		put_polyphase_filter(src_obj->polyphase_filters);
+		put_polyphase_filter(mod, src_obj->polyphase_filters);
 		src_obj->polyphase_filters = NULL;
 	}
 }
@@ -583,9 +588,10 @@ void asrc_free_polyphase_filter(struct asrc_farrow *src_obj)
 /*
  * FILTER FUNCTIONS
  */
-static enum asrc_error_code initialise_filter(struct comp_dev *dev,
+static enum asrc_error_code initialise_filter(struct processing_module *mod,
 					      struct asrc_farrow *src_obj)
 {
+	struct comp_dev *dev = mod->dev;
 	int fs_in;
 	int fs_out;
 
@@ -606,7 +612,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 	/* Reset coefficients for possible exit with error. */
 	src_obj->filter_length = 0;
 	src_obj->num_filters = 0;
-	asrc_free_polyphase_filter(src_obj);
+	asrc_free_polyphase_filter(mod, src_obj);
 
 	if (fs_in == 0 || fs_out == 0) {
 		/* Avoid possible divisions by zero. */
@@ -622,7 +628,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 			c_filter_params[CR_48000TO48000].filter_length;
 		src_obj->num_filters =
 			c_filter_params[CR_48000TO48000].num_filters;
-		src_obj->polyphase_filters = get_polyphase_filter(coeff48000to48000);
+		src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to48000);
 	} else if (fs_in <= fs_out) {
 		/* All upsampling use cases can share the same set of
 		 * filter coefficients.
@@ -631,7 +637,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 			c_filter_params[CR_44100TO48000].filter_length;
 		src_obj->num_filters =
 			c_filter_params[CR_44100TO48000].num_filters;
-		src_obj->polyphase_filters = get_polyphase_filter(coeff44100to48000);
+		src_obj->polyphase_filters = get_polyphase_filter(mod, coeff44100to48000);
 	} else if (fs_in == 48000) {
 		switch (fs_out) {
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_08000)
@@ -640,7 +646,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO08000].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO08000].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to08000);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to08000);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_11025)
@@ -649,7 +655,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO11025].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO11025].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to11025);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to11025);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_12000)
@@ -658,7 +664,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO12000].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO12000].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to12000);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to12000);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_16000)
@@ -667,7 +673,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO16000].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO16000].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to16000);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to16000);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_22050)
@@ -676,7 +682,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO22050].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO22050].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to22050);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to22050);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_24000)
@@ -685,7 +691,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO24000].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO24000].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to24000);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to24000);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_32000)
@@ -694,7 +700,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO32000].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO32000].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to32000);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to32000);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_48000_TO_44100)
@@ -703,7 +709,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_48000TO44100].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_48000TO44100].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff48000to44100);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff48000to44100);
 			break;
 #endif
 		default:
@@ -719,7 +725,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_24000TO08000].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_24000TO08000].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff24000to08000);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff24000to08000);
 			break;
 #endif
 #if (CONFIG_ASRC_SUPPORT_CONVERSION_24000_TO_16000)
@@ -728,7 +734,7 @@ static enum asrc_error_code initialise_filter(struct comp_dev *dev,
 				c_filter_params[CR_24000TO16000].filter_length;
 			src_obj->num_filters =
 				c_filter_params[CR_24000TO16000].num_filters;
-			src_obj->polyphase_filters = get_polyphase_filter(coeff24000to16000);
+			src_obj->polyphase_filters = get_polyphase_filter(mod, coeff24000to16000);
 			break;
 #endif
 		default:
diff --git a/src/audio/asrc/asrc_farrow.h b/src/audio/asrc/asrc_farrow.h
index 766ead172d58..48e564c2d1e1 100644
--- a/src/audio/asrc/asrc_farrow.h
+++ b/src/audio/asrc/asrc_farrow.h
@@ -231,7 +231,7 @@ struct asrc_farrow {
  * @param[in]  bit_depth     The wordlength that will be used for representing
  *                           the PCM samples, must be 16 or 32.
  */
-enum asrc_error_code asrc_get_required_size(struct comp_dev *dev,
+enum asrc_error_code asrc_get_required_size(struct processing_module *mod,
 					    int *required_size,
 					    int num_channels,
 					    int bit_depth);
@@ -268,7 +268,7 @@ enum asrc_error_code asrc_get_required_size(struct comp_dev *dev,
  * @param[in] operation_mode Choose 'push' or 'pull', depending on the mode
  *                           you want your ASRC to operate in.
  */
-enum asrc_error_code asrc_initialise(struct comp_dev *dev,
+enum asrc_error_code asrc_initialise(struct processing_module *mod,
 				     struct asrc_farrow *src_obj,
 				     int num_channels,
 				     int32_t fs_prim,
@@ -286,7 +286,7 @@ enum asrc_error_code asrc_initialise(struct comp_dev *dev,
  *
  * @param[in] src_obj        Pointer to the ias_src_farrow.
  */
-void asrc_free_polyphase_filter(struct asrc_farrow *src_obj);
+void asrc_free_polyphase_filter(struct processing_module *mod, struct asrc_farrow *src_obj);
 
 /*
  * @brief Process the sample rate converter for one frame; the frame
@@ -591,7 +591,7 @@ enum asrc_error_code asrc_update_fs_ratio(struct comp_dev *dev,
  * @param[in] fs_prim  Primary sampling rate.
  * @param[in] fs_sec   Secondary sampling rate.
  */
-enum asrc_error_code asrc_set_fs_ratio(struct comp_dev *dev,
+enum asrc_error_code asrc_set_fs_ratio(struct processing_module *mod,
 				       struct asrc_farrow *src_obj,
 				       int32_t fs_prim, int32_t fs_sec);
 
diff --git a/src/audio/asrc/asrc_ipc3.c b/src/audio/asrc/asrc_ipc3.c
index 30dfbecddc6b..ca917318d7e5 100644
--- a/src/audio/asrc/asrc_ipc3.c
+++ b/src/audio/asrc/asrc_ipc3.c
@@ -4,7 +4,6 @@
 
 #include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/ipc-config.h>
-#include <rtos/alloc.h>
 #include <rtos/init.h>
 #include <sof/lib/uuid.h>
 #include <sof/trace/trace.h>
diff --git a/src/audio/asrc/asrc_ipc4.c b/src/audio/asrc/asrc_ipc4.c
index 3e5d8bf7818f..1047799f207b 100644
--- a/src/audio/asrc/asrc_ipc4.c
+++ b/src/audio/asrc/asrc_ipc4.c
@@ -4,7 +4,6 @@
 
 #include <sof/audio/module_adapter/module/generic.h>
 #include <sof/audio/ipc-config.h>
-#include <rtos/alloc.h>
 #include <rtos/init.h>
 #include <sof/lib/uuid.h>
 #include <sof/trace/trace.h>
diff --git a/src/audio/module_adapter/Kconfig b/src/audio/module_adapter/Kconfig
index bb9081812271..3c762c73f7f8 100644
--- a/src/audio/module_adapter/Kconfig
+++ b/src/audio/module_adapter/Kconfig
@@ -3,6 +3,27 @@
 menu "Processing modules"
 	visible if COMP_MODULE_ADAPTER
 
+	config MODULE_MEMORY_API_CONTAINER_CHUNK_SIZE
+		int "Number of memory containers to allocate at once"
+		default 16
+		help
+		  The per module resource containers are allocated in
+		  chunks. The unused containers are kept in free
+		  list. When the free list is empty the amount of
+		  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 CADENCE_CODEC
 		bool "Cadence codec"
 		default n
diff --git a/src/audio/module_adapter/module/generic.c b/src/audio/module_adapter/module/generic.c
index 03a345552f71..cb4ea2e3d5ae 100644
--- a/src/audio/module_adapter/module/generic.c
+++ b/src/audio/module_adapter/module/generic.c
@@ -14,6 +14,16 @@
 #include <rtos/symbol.h>
 
 #include <sof/audio/module_adapter/module/generic.h>
+#include <sof/audio/data_blob.h>
+#include <sof/lib/fast-get.h>
+
+/* The __ZEPHYR__ condition is to keep cmocka tests working */
+#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
+#define MEM_API_CHECK_THREAD(res) __ASSERT((res)->rsrc_mngr == k_current_get(), \
+		"Module memory API operation from wrong thread")
+#else
+#define MEM_API_CHECK_THREAD(res)
+#endif
 
 LOG_MODULE_DECLARE(module_adapter, CONFIG_SOF_LOG_LEVEL);
 
@@ -92,8 +102,14 @@ int module_init(struct processing_module *mod)
 	}
 
 	/* Init memory list */
-	list_init(&md->memory.mem_list);
-
+	list_init(&md->resources.res_list);
+	list_init(&md->resources.free_cont_list);
+	list_init(&md->resources.cont_chunk_list);
+	md->resources.heap_usage = 0;
+	md->resources.heap_high_water_mark = 0;
+#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
+	md->resources.rsrc_mngr = k_current_get();
+#endif
 	/* Now we can proceed with module specific initialization */
 	ret = interface->init(mod);
 	if (ret) {
@@ -110,6 +126,42 @@ int module_init(struct processing_module *mod)
 	return 0;
 }
 
+struct container_chunk {
+	struct list_item chunk_list;
+	struct module_resource containers[CONFIG_MODULE_MEMORY_API_CONTAINER_CHUNK_SIZE];
+};
+
+static struct module_resource *container_get(struct processing_module *mod)
+{
+	struct module_resources *res = &mod->priv.resources;
+	struct module_resource *container;
+
+	if (list_is_empty(&res->free_cont_list)) {
+		struct container_chunk *chunk = rzalloc(SOF_MEM_FLAG_USER, sizeof(*chunk));
+		int i;
+
+		if (!chunk) {
+			comp_err(mod->dev, "allocating more containers failed");
+			return NULL;
+		}
+
+		list_item_append(&chunk->chunk_list, &res->cont_chunk_list);
+		for (i = 0; i < ARRAY_SIZE(chunk->containers); i++)
+			list_item_append(&chunk->containers[i].list, &res->free_cont_list);
+	}
+
+	container = list_first_item(&res->free_cont_list, struct module_resource, list);
+	list_item_del(&container->list);
+	return container;
+}
+
+static void container_put(struct processing_module *mod, struct module_resource *container)
+{
+	struct module_resources *res = &mod->priv.resources;
+
+	list_item_append(&container->list, &res->free_cont_list);
+}
+
 /**
  * Allocates aligned memory block for module.
  * @param mod		Pointer to the module this memory block is allocatd for.
@@ -121,20 +173,17 @@ int module_init(struct processing_module *mod)
  */
 void *mod_alloc_align(struct processing_module *mod, uint32_t size, uint32_t alignment)
 {
-	struct comp_dev *dev = mod->dev;
-	struct module_memory *container;
+	struct module_resource *container = container_get(mod);
+	struct module_resources *res = &mod->priv.resources;
 	void *ptr;
 
-	if (!size) {
-		comp_err(dev, "mod_alloc: requested allocation of 0 bytes.");
+	MEM_API_CHECK_THREAD(res);
+	if (!container)
 		return NULL;
-	}
 
-	/* Allocate memory container */
-	container = rzalloc(SOF_MEM_FLAG_USER,
-			    sizeof(struct module_memory));
-	if (!container) {
-		comp_err(dev, "mod_alloc: failed to allocate memory container.");
+	if (!size) {
+		comp_err(mod->dev, "mod_alloc: requested allocation of 0 bytes.");
+		container_put(mod, container);
 		return NULL;
 	}
 
@@ -145,15 +194,20 @@ void *mod_alloc_align(struct processing_module *mod, uint32_t size, uint32_t ali
 		ptr = rballoc(SOF_MEM_FLAG_USER, size);
 
 	if (!ptr) {
-		comp_err(dev, "mod_alloc: failed to allocate memory for comp %x.",
-			 dev_comp_id(dev));
-		rfree(container);
+		comp_err(mod->dev, "mod_alloc: failed to allocate memory for comp %x.",
+			 dev_comp_id(mod->dev));
+		container_put(mod, container);
 		return NULL;
 	}
 	/* Store reference to allocated memory */
 	container->ptr = ptr;
 	container->size = size;
-	list_item_prepend(&container->mem_list, &mod->priv.memory.mem_list);
+	container->type = MOD_RES_HEAP;
+	list_item_prepend(&container->list, &res->res_list);
+
+	res->heap_usage += size;
+	if (res->heap_usage > res->heap_high_water_mark)
+		res->heap_high_water_mark = res->heap_usage;
 
 	return ptr;
 }
@@ -193,28 +247,124 @@ void *mod_zalloc(struct processing_module *mod, uint32_t size)
 }
 EXPORT_SYMBOL(mod_zalloc);
 
+/**
+ * Creates a blob handler and releases it when the module is unloaded
+ * @param mod	Pointer to module this memory block is allocated for.
+ * @return Pointer to the created data blob handler
+ *
+ * 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 module_resources *res = &mod->priv.resources;
+	struct module_resource *container = container_get(mod);
+	struct comp_data_blob_handler *bhp;
+
+	MEM_API_CHECK_THREAD(res);
+	if (!container)
+		return NULL;
+
+	bhp = comp_data_blob_handler_new_ext(mod->dev, false, NULL, NULL);
+	if (!bhp) {
+		container_put(mod, container);
+		return NULL;
+	}
+
+	container->bhp = bhp;
+	container->size = 0;
+	container->type = MOD_RES_BLOB_HANDLER;
+	list_item_prepend(&container->list, &res->res_list);
+
+	return bhp;
+}
+EXPORT_SYMBOL(mod_data_blob_handler_new);
+#endif
+
+/**
+ * Make a module associated shared SRAM copy of DRAM read-only data.
+ * @param mod	Pointer to module this copy is allocated for.
+ * @return Pointer to the SRAM copy.
+ *
+ * Like fast_get() but the handler is automatically freed.
+ */
+#if CONFIG_FAST_GET
+const void *mod_fast_get(struct processing_module *mod, const void * const dram_ptr, size_t size)
+{
+	struct module_resources *res = &mod->priv.resources;
+	struct module_resource *container = container_get(mod);
+	const void *ptr;
+
+	MEM_API_CHECK_THREAD(res);
+	if (!container)
+		return NULL;
+
+	ptr = fast_get(dram_ptr, size);
+	if (!ptr) {
+		container_put(mod, container);
+		return NULL;
+	}
+
+	container->sram_ptr = ptr;
+	container->size = 0;
+	container->type = MOD_RES_FAST_GET;
+	list_item_prepend(&container->list, &res->res_list);
+
+	return ptr;
+}
+EXPORT_SYMBOL(mod_fast_get);
+#endif
+
+static int free_contents(struct processing_module *mod, struct module_resource *container)
+{
+	struct module_resources *res = &mod->priv.resources;
+
+	switch (container->type) {
+	case MOD_RES_HEAP:
+		rfree(container->ptr);
+		res->heap_usage -= container->size;
+		return 0;
+#if CONFIG_COMP_BLOB
+	case MOD_RES_BLOB_HANDLER:
+		comp_data_blob_handler_free(container->bhp);
+		return 0;
+#endif
+#if CONFIG_FAST_GET
+	case MOD_RES_FAST_GET:
+		fast_put(container->sram_ptr);
+		return 0;
+#endif
+	default:
+		comp_err(mod->dev, "Unknown resource type: %d", container->type);
+	}
+	return -EINVAL;
+}
+
 /**
  * Frees the memory block removes it from module's book keeping.
  * @param mod	Pointer to module this memory block was allocated for.
  * @param ptr	Pointer to the memory block.
  */
-int mod_free(struct processing_module *mod, void *ptr)
+int mod_free(struct processing_module *mod, const void *ptr)
 {
-	struct module_memory *mem;
-	struct list_item *mem_list;
-	struct list_item *_mem_list;
+	struct module_resources *res = &mod->priv.resources;
+	struct module_resource *container;
+	struct list_item *res_list;
 
+	MEM_API_CHECK_THREAD(res);
 	if (!ptr)
 		return 0;
 
 	/* Find which container keeps this memory */
-	list_for_item_safe(mem_list, _mem_list, &mod->priv.memory.mem_list) {
-		mem = container_of(mem_list, struct module_memory, mem_list);
-		if (mem->ptr == ptr) {
-			rfree(mem->ptr);
-			list_item_del(&mem->mem_list);
-			rfree(mem);
-			return 0;
+	list_for_item(res_list, &res->res_list) {
+		container = container_of(res_list, struct module_resource, list);
+		if (container->ptr == ptr) {
+			int ret = free_contents(mod, container);
+
+			list_item_del(&container->list);
+			container_put(mod, container);
+			return ret;
 		}
 	}
 
@@ -225,6 +375,22 @@ int mod_free(struct processing_module *mod, void *ptr)
 }
 EXPORT_SYMBOL(mod_free);
 
+#if CONFIG_COMP_BLOB
+void mod_data_blob_handler_free(struct processing_module *mod, struct comp_data_blob_handler *dbh)
+{
+	mod_free(mod, (void *)dbh);
+}
+EXPORT_SYMBOL(mod_data_blob_handler_free);
+#endif
+
+#if CONFIG_FAST_GET
+void mod_fast_put(struct processing_module *mod, const void *sram_ptr)
+{
+	mod_free(mod, sram_ptr);
+}
+EXPORT_SYMBOL(mod_fast_put);
+#endif
+
 int module_prepare(struct processing_module *mod,
 		   struct sof_source **sources, int num_of_sources,
 		   struct sof_sink **sinks, int num_of_sinks)
@@ -396,23 +562,33 @@ int module_reset(struct processing_module *mod)
 }
 
 /**
- * Frees all the memory allocated for this module
- * @param mod	Pointer to module this memory block was allocated for.
+ * Frees all the resources registered for this module
+ * @param mod	Pointer to module that should have its resource freed.
  *
  * This function is called automatically when the module is unloaded.
  */
 void mod_free_all(struct processing_module *mod)
 {
-	struct module_memory *mem;
-	struct list_item *mem_list;
-	struct list_item *_mem_list;
+	struct module_resources *res = &mod->priv.resources;
+	struct list_item *list;
+	struct list_item *_list;
 
+	MEM_API_CHECK_THREAD(res);
 	/* Find which container keeps this memory */
-	list_for_item_safe(mem_list, _mem_list, &mod->priv.memory.mem_list) {
-		mem = container_of(mem_list, struct module_memory, mem_list);
-		rfree(mem->ptr);
-		list_item_del(&mem->mem_list);
-		rfree(mem);
+	list_for_item_safe(list, _list, &res->res_list) {
+		struct module_resource *container =
+			container_of(list, struct module_resource, list);
+
+		free_contents(mod, container);
+		list_item_del(&container->list);
+	}
+
+	list_for_item_safe(list, _list, &res->cont_chunk_list) {
+		struct container_chunk *chunk =
+			container_of(list, struct container_chunk, chunk_list);
+
+		list_item_del(&chunk->chunk_list);
+		rfree(chunk);
 	}
 }
 EXPORT_SYMBOL(mod_free_all);
diff --git a/src/audio/module_adapter/module_adapter.c b/src/audio/module_adapter/module_adapter.c
index da0353d892ab..10f722fd9bbd 100644
--- a/src/audio/module_adapter/module_adapter.c
+++ b/src/audio/module_adapter/module_adapter.c
@@ -1289,18 +1289,14 @@ void module_adapter_free(struct comp_dev *dev)
 }
 EXPORT_SYMBOL(module_adapter_free);
 
-size_t module_adapter_heap_usage(struct processing_module *mod)
+size_t module_adapter_heap_usage(struct processing_module *mod, size_t *hwm)
 {
-	struct list_item *mem_list, *_mem_list;
-	size_t size = 0;
+	struct module_resources *res = &mod->priv.resources;
 
-	list_for_item_safe(mem_list, _mem_list, &mod->priv.memory.mem_list) {
-		struct module_memory *mem = container_of(mem_list, struct module_memory, mem_list);
+	if (hwm)
+		*hwm = res->heap_high_water_mark;
 
-		size += mem->size;
-	}
-
-	return size;
+	return res->heap_usage;
 }
 EXPORT_SYMBOL(module_adapter_heap_usage);
 
diff --git a/src/audio/src/src_common.c b/src/audio/src/src_common.c
index f96b3bc6e358..6331a6b9180e 100644
--- a/src/audio/src/src_common.c
+++ b/src/audio/src/src_common.c
@@ -627,12 +627,11 @@ int src_allocate_copy_stages(struct processing_module *mod, struct src_param *pr
 		return -EINVAL;
 	}
 
-	stage_dst[0].coefs = fast_get(stage_src1->coefs, coef_size[0]);
-	stage_dst[1].coefs = fast_get(stage_src2->coefs, coef_size[1]);
+	stage_dst[0].coefs = mod_fast_get(mod, stage_src1->coefs, coef_size[0]);
+	stage_dst[1].coefs = mod_fast_get(mod, stage_src2->coefs, coef_size[1]);
 
 	if (!stage_dst[0].coefs || !stage_dst[1].coefs)  {
 		comp_err(mod->dev, "failed to allocate coefficients");
-		fast_put(stage_dst[0].coefs);
 		return -ENOMEM;
 	}
 
@@ -708,12 +707,5 @@ __cold int src_free(struct processing_module *mod)
 
 	comp_info(mod->dev, "src_free()");
 
-#if CONFIG_FAST_GET
-	struct comp_data *cd = module_get_private_data(mod);
-	if (cd->param.stage1) {
-		fast_put(cd->param.stage1->coefs);
-		fast_put(cd->param.stage2->coefs);
-	}
-#endif
 	return 0;
 }
diff --git a/src/include/module/module/base.h b/src/include/module/module/base.h
index 2371d77124f5..881e74a2d108 100644
--- a/src/include/module/module/base.h
+++ b/src/include/module/module/base.h
@@ -59,7 +59,7 @@ struct module_data {
 	enum module_state state;
 	size_t new_cfg_size; /**< size of new module config data */
 	void *runtime_params;
-	struct module_memory memory; /**< memory allocated by module */
+	struct module_resources resources; /**< resources allocated by module */
 	struct module_processing_data mpd; /**< shared data comp <-> module */
 #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 1001c4ba450c..ced9fc710b11 100644
--- a/src/include/sof/audio/module_adapter/module/generic.h
+++ b/src/include/sof/audio/module_adapter/module/generic.h
@@ -19,6 +19,11 @@
 #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
+
 /*
  * helpers to determine processing type
  * Needed till all the modules use PROCESSING_MODE_SINK_SOURCE
@@ -116,13 +121,42 @@ struct module_param {
 };
 
 /**
- * \struct module_memory
- * \brief module memory block - used for every memory allocated by module
+ * \struct module_resources
+ * \brief module resources block - used for module allocation records
+ * The allocations are recorded so that they can be automatically freed
+ * when the module unloads.
  */
-struct module_memory {
-	void *ptr; /**< A pointr to particular memory block */
-	struct list_item mem_list; /**< list of memory allocated by module */
-	size_t size;
+struct module_resources {
+	struct list_item res_list;		/**< Allocad resource containers */
+	struct list_item free_cont_list;	/**< Unused memory containers */
+	struct list_item cont_chunk_list;	/**< Memory container chunks */
+	size_t heap_usage;
+	size_t heap_high_water_mark;
+#if CONFIG_MODULE_MEMORY_API_DEBUG && defined(__ZEPHYR__)
+	k_tid_t rsrc_mngr;
+#endif
+};
+
+enum mod_resource_type {
+	MOD_RES_UNINITIALIZED = 0,
+	MOD_RES_HEAP,
+	MOD_RES_BLOB_HANDLER,
+	MOD_RES_FAST_GET,
+};
+
+/**
+ * \struct module_resource
+ * \brief module memory container - used for every memory allocated by module
+ */
+struct module_resource {
+	union {
+		void *ptr; /**< Pointer to heap allocated memory */
+		struct comp_data_blob_handler *bhp; /**< Blob handler ptr */
+		const void *sram_ptr; /**< SRAM ptr from fast_get() */
+	};
+	struct list_item list; /**< list element */
+	size_t size; /**< Size of allocated heap memory, 0 if not from heap */
+	enum mod_resource_type type; /**< Resource type */
 };
 
 /**
@@ -157,7 +191,15 @@ int module_init(struct processing_module *mod);
 void *mod_alloc_align(struct processing_module *mod, uint32_t size, uint32_t alignment);
 void *mod_alloc(struct processing_module *mod, uint32_t size);
 void *mod_zalloc(struct processing_module *mod, uint32_t size);
-int mod_free(struct processing_module *mod, void *ptr);
+int mod_free(struct processing_module *mod, const void *ptr);
+#if CONFIG_COMP_BLOB
+struct comp_data_blob_handler *mod_data_blob_handler_new(struct processing_module *mod);
+void mod_data_blob_handler_free(struct processing_module *mod, struct comp_data_blob_handler *dbh);
+#endif
+#if CONFIG_FAST_GET
+const void *mod_fast_get(struct processing_module *mod, const void * const dram_ptr, size_t size);
+void mod_fast_put(struct processing_module *mod, const void *sram_ptr);
+#endif
 void mod_free_all(struct processing_module *mod);
 int module_prepare(struct processing_module *mod,
 		   struct sof_source **sources, int num_of_sources,
@@ -223,7 +265,7 @@ int module_adapter_trigger(struct comp_dev *dev, int cmd);
 void module_adapter_free(struct comp_dev *dev);
 int module_adapter_reset(struct comp_dev *dev);
 
-size_t module_adapter_heap_usage(struct processing_module *mod);
+size_t module_adapter_heap_usage(struct processing_module *mod, size_t *hwm);
 
 #if CONFIG_IPC_MAJOR_3
 static inline
diff --git a/test/cmocka/src/audio/mixer/CMakeLists.txt b/test/cmocka/src/audio/mixer/CMakeLists.txt
index 723cb091ff61..ea8cad0bd79e 100644
--- a/test/cmocka/src/audio/mixer/CMakeLists.txt
+++ b/test/cmocka/src/audio/mixer/CMakeLists.txt
@@ -25,6 +25,7 @@ cmocka_test(mixer
 	${PROJECT_SOURCE_DIR}/src/audio/pipeline/pipeline-schedule.c
 	${PROJECT_SOURCE_DIR}/src/audio/pipeline/pipeline-stream.c
 	${PROJECT_SOURCE_DIR}/src/audio/pipeline/pipeline-xrun.c
+	${PROJECT_SOURCE_DIR}/src/audio/data_blob.c
 	${PROJECT_SOURCE_DIR}/src/module/audio/source_api.c
 	${PROJECT_SOURCE_DIR}/src/module/audio/sink_api.c
 	${PROJECT_SOURCE_DIR}/src/math/numbers.c
diff --git a/zephyr/sof_shell.c b/zephyr/sof_shell.c
index 60785c4eb5c4..f10a2c9275b5 100644
--- a/zephyr/sof_shell.c
+++ b/zephyr/sof_shell.c
@@ -55,13 +55,15 @@ static int cmd_sof_module_heap_usage(const struct shell *sh,
 	}
 
 	list_for_item_safe(clist, _clist, &ipc->comp_list) {
+		size_t usage, hwm;
+
 		icd = container_of(clist, struct ipc_comp_dev, list);
 		if (icd->type != COMP_TYPE_COMPONENT)
 			continue;
 
-		shell_print(sh, "comp id 0x%08x\t%8zu bytes\t(%zu max)", icd->id,
-			    module_adapter_heap_usage(comp_mod(icd->cd)),
-			    comp_mod(icd->cd)->priv.cfg.heap_bytes);
+		usage = module_adapter_heap_usage(comp_mod(icd->cd), &hwm);
+		shell_print(sh, "comp id 0x%08x%9zu usage%9zu hwm %9zu max\tbytes",
+			    icd->id, usage, hwm, comp_mod(icd->cd)->priv.cfg.heap_bytes);
 	}
 	return 0;
 }