dram: add temporarily banned DRAM execution

DRAM execution is banned in LL task context, but there are also time
intervals during which performance is important. Moreover, sometimes
such critical periods aren't certain until a later time. E.g. when
processing IPCs, only some of them are performance critical. And
those time-critical IPCs should be handled with maximum performance
from IPC-entry till IPC-exit, not only while handling that specific
IPC. Consider this pseudo-code:

void ipc_cmd()
{
	common_pre_processing();

	switch (cmd) {
	case NON_CRITICAL_CMD:
		handle_non_critical();
		break;
	case CRITICAL_CMD:
		handle_critical();
	}

	common_post_processing();
}

In this case ipc_cmd(), common_pre_processing(), handle_critical()
and common_post_processing() cannot be executed in DRAM, while
handle_non_critical() can be executed in DRAM. If we place
start-critical-debugging and stop-critical-debugging to cover all of
ipc_cmd(), we'll be forced to also place handle_non_critical() in
SRAM. OTOH if we only surround handle_critical() with those markers,
we will miss all the common code. To support such cases we use 3
markers:
mem_hot_path_start_watching()
mem_hot_path_stop_watching()
mem_hot_path_confirm()
Then we place start- and stop-watching in the beginning and end of
ipc_cmd(), and mem_hot_path_confirm() under the CRITICAL_CMD case.
Then if we made common_pre_processing() or common_post_processing()
__cold, the fact of them being called while watching will be recorded.
Then mem_hot_path_confirm() will set a confirmation flag. Then when
watching is stopped, we check if the flag was raised and a cold
function was called, in which case we issue an error.

Signed-off-by: Guennadi Liakhovetski <guennadi.liakhovetski@linux.intel.com>

Author: lyakh

posix/include/sof/lib/memory.h

@@ -19,5 +19,6 @@
 #endif
 
 #define assert_can_be_cold() do {} while (0)
+#define mem_hot_path_confirm() do {} while (0)
 
 #endif /* __SOF_LIB_MEMORY_H__ */

src/debug/CMakeLists.txt

@@ -12,6 +12,8 @@ if(it_is) ###  Zephyr ###
 add_subdirectory(debug_stream)
 add_subdirectory(telemetry)
 
+zephyr_library_sources_ifdef(CONFIG_COLD_STORE_EXECUTE_DEBUG dram.c)
+
 else() ###  Not Zephyr ###
 
 add_local_sources(sof panic.c)

src/debug/dram.c

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2025 Intel Corporation.
+
+#include <rtos/kernel.h>
+#include <rtos/symbol.h>
+#include <zephyr/logging/log.h>
+#include <zephyr/sys/__assert.h>
+
+LOG_MODULE_REGISTER(dram_debug, CONFIG_SOF_LOG_LEVEL);
+
+static struct k_spinlock hot_path_lock;
+static unsigned int hot_path_depth;
+static const char *cold_path_fn;
+static bool hot_path_confirmed;
+
+void mem_cold_path_enter(const char *fn)
+{
+	k_spinlock_key_t key = k_spin_lock(&hot_path_lock);
+
+	cold_path_fn = fn;
+
+	k_spin_unlock(&hot_path_lock, key);
+}
+EXPORT_SYMBOL(mem_cold_path_enter);
+
+void mem_hot_path_start_watching(void)
+{
+	k_spinlock_key_t key = k_spin_lock(&hot_path_lock);
+
+	if (!hot_path_depth++) {
+		cold_path_fn = NULL;
+		hot_path_confirmed = false;
+	}
+
+	k_spin_unlock(&hot_path_lock, key);
+}
+
+void mem_hot_path_confirm(void)
+{
+	k_spinlock_key_t key = k_spin_lock(&hot_path_lock);
+
+	hot_path_confirmed = true;
+
+	k_spin_unlock(&hot_path_lock, key);
+}
+
+void mem_hot_path_stop_watching(void)
+{
+	bool underrun, error;
+	k_spinlock_key_t key = k_spin_lock(&hot_path_lock);
+
+	if (hot_path_depth) {
+		underrun = false;
+		hot_path_depth--;
+		error = hot_path_confirmed && cold_path_fn;
+	} else {
+		error = underrun = true;
+	}
+
+	k_spin_unlock(&hot_path_lock, key);
+
+	if (underrun)
+		LOG_ERR("Hot path depth underrun!");
+	else
+		__ASSERT(!error, "Cold function %s() has run while on hot path!", cold_path_fn);
+}

src/idc/idc.c

@@ -425,7 +425,9 @@ void idc_cmd(struct idc_msg *msg)
 		notifier_notify_remote();
 		break;
 	case iTS(IDC_MSG_IPC):
+		mem_hot_path_start_watching();
 		idc_ipc();
+		mem_hot_path_stop_watching();
 		break;
 #if CONFIG_IPC_MAJOR_4
 	case iTS(IDC_MSG_BIND):

src/ipc/ipc-zephyr.c

@@ -217,6 +217,8 @@ enum task_state ipc_platform_do_cmd(struct ipc *ipc)
 {
 	struct ipc_cmd_hdr *hdr;
 
+	mem_hot_path_start_watching();
+
 	hdr = ipc_compact_read_msg();
 
 	/* perform command */
@@ -242,6 +244,8 @@ enum task_state ipc_platform_do_cmd(struct ipc *ipc)
 #endif /* CONFIG_PM  */
 	}
 
+	mem_hot_path_stop_watching();
+
 	return SOF_TASK_STATE_COMPLETED;
 }
 

src/ipc/ipc4/handler.c

@@ -477,6 +477,8 @@ int ipc4_pipeline_trigger(struct ipc_comp_dev *ppl_icd, uint32_t cmd, bool *dela
 		return IPC4_INVALID_REQUEST;
 	}
 
+	mem_hot_path_confirm();
+
 	/* trigger the component */
 	ret = pipeline_trigger(host->cd->pipeline, host->cd, cmd);
 	if (ret < 0) {

xtos/include/sof/lib/memory.h

@@ -19,5 +19,6 @@
 #endif
 
 #define assert_can_be_cold() do {} while (0)
+#define mem_hot_path_confirm() do {} while (0)
 
 #endif /* __SOF_LIB_MEMORY_H__ */

zephyr/include/sof/lib/memory.h

@@ -25,12 +25,22 @@ bool ll_sch_is_current(void);
 #define ll_sch_is_current() false
 #endif
 
+void mem_hot_path_start_watching(void);
+void mem_hot_path_stop_watching(void);
+void mem_hot_path_confirm(void);
+void mem_cold_path_enter(const char *fn);
+
 static inline void __assert_can_be_cold(const char *fn)
 {
 	__ASSERT(!ll_sch_is_current(), "%s() called from an LL thread!", fn);
+	mem_cold_path_enter(fn);
 }
 #define assert_can_be_cold() __assert_can_be_cold(__func__)
 #else
+#define mem_hot_path_start_watching() do {} while (0)
+#define mem_hot_path_stop_watching() do {} while (0)
+#define mem_hot_path_confirm() do {} while (0)
+#define mem_cold_path_enter() do {} while (0)
 #define assert_can_be_cold() do {} while (0)
 #endif