From 55c1e4cacd5134aea33c214d9b53cebfddfc21fa Mon Sep 17 00:00:00 2001 From: Jyri Sarha Date: Wed, 1 Apr 2026 16:27:54 +0300 Subject: [PATCH 1/6] debug_stream: thread_info: Remove cache alingment from per cpu table Remove cache alingment from "previous" per cpu table. Static data is currently placed in .bss and its ATM uncached so the ds_cpu table elements do not need to be cache aligned, but if this changes we need __aligned(CONFIG_DCACHE_LINE_SIZE) here. Signed-off-by: Jyri Sarha --- src/debug/debug_stream/debug_stream_thread_info.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/debug/debug_stream/debug_stream_thread_info.c b/src/debug/debug_stream/debug_stream_thread_info.c index 5564c0d2dbb4..ac547d44f6e6 100644 --- a/src/debug/debug_stream/debug_stream_thread_info.c +++ b/src/debug/debug_stream/debug_stream_thread_info.c @@ -22,6 +22,9 @@ LOG_MODULE_REGISTER(thread_info); /* Data structure to store the cycle counter values from the previous * round. The numbers are used to calculate what the load was on this * round. + * Static data is currently placed in .bss and its ATM uncached so the + * ds_cpu table elements do not need to be cache aligned, but if this + * changes we need __aligned(CONFIG_DCACHE_LINE_SIZE) here. */ static struct previous_counters { /* Cached data from previous round */ uint64_t active; /* All execution cycles */ @@ -30,7 +33,7 @@ static struct previous_counters { /* Cached data from previous round */ void *tid; /* thread ID (the thread struct ptr) */ uint64_t cycles; /* cycle counter value */ } threads[THREAD_INFO_MAX_THREADS]; /* The max amount of threads we follow */ -} __aligned(CONFIG_DCACHE_LINE_SIZE) previous[CONFIG_MP_MAX_NUM_CPUS]; +} previous[CONFIG_MP_MAX_NUM_CPUS]; #endif /* From 643f6b07a5bc7d695f23e9d1a4afed36087010b7 Mon Sep 17 00:00:00 2001 From: Jyri Sarha Date: Thu, 19 Mar 2026 21:27:39 +0200 Subject: [PATCH 2/6] debug_stream: text_msg: Add CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS The CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS option limit the number of debug stream slot section to lower number than the actual number of cores. In some situations a high number of cpu sections shrinks the circular buffer size so much that it limit debugging. With this option its possible to use fewer sections. The downside is that the cpus above the number of sections can not send any debug stream messages. Signed-off-by: Jyri Sarha --- src/debug/debug_stream/Kconfig | 11 ++++++++ src/debug/debug_stream/debug_stream_slot.c | 27 ++++++++++++------- .../debug_stream/debug_stream_text_msg.c | 6 ++--- .../debug_stream/debug_stream_thread_info.c | 7 ++--- 4 files changed, 35 insertions(+), 16 deletions(-) diff --git a/src/debug/debug_stream/Kconfig b/src/debug/debug_stream/Kconfig index 839ba4b6f215..b0dfaf1af03b 100644 --- a/src/debug/debug_stream/Kconfig +++ b/src/debug/debug_stream/Kconfig @@ -54,6 +54,17 @@ config SOF_DEBUG_STREAM_THREAD_INFO_TOTAL_CPU_LOAD_TO_LOG print the total CPU load (sum of all threads) to the logging system. +config SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS + int "Number of cpu sections slot is divided to" + default CORE_COUNT + range 1 MP_MAX_NUM_CPUS + help + In some situations a high number of cpu sections shrinks the + circular buffer size so much that it limit debugging. With + this option its possible to use fewer sections. The downside + is that the cpus above the number of sections can not send + any debug stream messages. + config SOF_DEBUG_STREAM_TEXT_MSG bool "Enable text message sending through Debug-Stream" help diff --git a/src/debug/debug_stream/debug_stream_slot.c b/src/debug/debug_stream/debug_stream_slot.c index d75c8248a45c..82816a6788f3 100644 --- a/src/debug/debug_stream/debug_stream_slot.c +++ b/src/debug/debug_stream/debug_stream_slot.c @@ -19,7 +19,7 @@ struct cpu_mutex { } __aligned(CONFIG_DCACHE_LINE_SIZE); /* CPU specific mutexes for each circular buffer */ -static struct cpu_mutex cpu_mutex[CONFIG_MP_MAX_NUM_CPUS]; +static struct cpu_mutex cpu_mutex[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; #ifdef CONFIG_INTEL_ADSP_DEBUG_SLOT_MANAGER static struct debug_stream_slot_hdr *dbg_stream_slot; @@ -54,6 +54,12 @@ debug_stream_get_circular_buffer(struct debug_stream_section_descriptor *desc, u return NULL; } + if (core >= CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS) { + LOG_DBG("No section for cpu %u >= %u ", core, + CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS); + return NULL; + } + *desc = hdr->section_desc[core]; LOG_DBG("Section %u (desc %u %u %u)", core, desc->core_id, desc->buf_words, desc->offset); @@ -116,18 +122,19 @@ int debug_stream_slot_send_record(struct debug_stream_record *rec) static int debug_stream_slot_init(void) { struct debug_stream_slot_hdr *hdr = debug_stream_get_slot(); - size_t hdr_size = ALIGN_UP(offsetof(struct debug_stream_slot_hdr, - section_desc[CONFIG_MP_MAX_NUM_CPUS]), - CONFIG_DCACHE_LINE_SIZE); + size_t hdr_size = ALIGN_UP( + offsetof(struct debug_stream_slot_hdr, + section_desc[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]), + CONFIG_DCACHE_LINE_SIZE); size_t section_area_size = ADSP_DW_SLOT_SIZE - hdr_size; size_t section_size = ALIGN_DOWN(section_area_size / - CONFIG_MP_MAX_NUM_CPUS, + CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS, CONFIG_DCACHE_LINE_SIZE); size_t offset = hdr_size; int i; LOG_INF("%u sections of %u bytes, hdr %u, section area %u", - CONFIG_MP_MAX_NUM_CPUS, section_size, hdr_size, + CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS, section_size, hdr_size, section_area_size); #ifdef CONFIG_INTEL_ADSP_DEBUG_SLOT_MANAGER @@ -142,9 +149,9 @@ static int debug_stream_slot_init(void) hdr->hdr.magic = DEBUG_STREAM_IDENTIFIER; hdr->hdr.hdr_size = hdr_size; - hdr->total_size = hdr_size + CONFIG_MP_MAX_NUM_CPUS * section_size; - hdr->num_sections = CONFIG_MP_MAX_NUM_CPUS; - for (i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) { + hdr->total_size = hdr_size + CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS * section_size; + hdr->num_sections = CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS; + for (i = 0; i < CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS; i++) { hdr->section_desc[i].core_id = i; hdr->section_desc[i].buf_words = (section_size - offsetof(struct debug_stream_circular_buf, data[0])) / @@ -153,7 +160,7 @@ static int debug_stream_slot_init(void) LOG_DBG("sections %u, size %u, offset %u", i, section_size, offset); offset += section_size; } - for (i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) { + for (i = 0; i < CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS; i++) { struct debug_stream_section_descriptor desc = { 0 }; struct debug_stream_circular_buf *buf = debug_stream_get_circular_buffer(&desc, i); diff --git a/src/debug/debug_stream/debug_stream_text_msg.c b/src/debug/debug_stream/debug_stream_text_msg.c index 8bb3925a1550..e27ff1cd0213 100644 --- a/src/debug/debug_stream/debug_stream_text_msg.c +++ b/src/debug/debug_stream/debug_stream_text_msg.c @@ -52,9 +52,9 @@ void ds_msg(const char *format, ...) static struct { struct debug_stream_text_msg msg; char text[640]; -} __packed ds_buf[CONFIG_MP_MAX_NUM_CPUS]; -static int reports_sent_cpu[CONFIG_MP_MAX_NUM_CPUS]; -static size_t ds_pos[CONFIG_MP_MAX_NUM_CPUS]; +} __packed ds_buf[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; +static int reports_sent_cpu[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; +static size_t ds_pos[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; static void ds_exception_drain(bool flush) { diff --git a/src/debug/debug_stream/debug_stream_thread_info.c b/src/debug/debug_stream/debug_stream_thread_info.c index ac547d44f6e6..5e00b697caa9 100644 --- a/src/debug/debug_stream/debug_stream_thread_info.c +++ b/src/debug/debug_stream/debug_stream_thread_info.c @@ -33,7 +33,7 @@ static struct previous_counters { /* Cached data from previous round */ void *tid; /* thread ID (the thread struct ptr) */ uint64_t cycles; /* cycle counter value */ } threads[THREAD_INFO_MAX_THREADS]; /* The max amount of threads we follow */ -} previous[CONFIG_MP_MAX_NUM_CPUS]; +} previous[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; #endif /* @@ -344,9 +344,10 @@ static void thread_info_run(void *cnum, void *a, void *b) } #define THREAD_STACK_SIZE (2048) -static K_THREAD_STACK_ARRAY_DEFINE(info_thread_stacks, CONFIG_MP_MAX_NUM_CPUS, +static K_THREAD_STACK_ARRAY_DEFINE(info_thread_stacks, + CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS, THREAD_STACK_SIZE); -static struct k_thread info_thread[CONFIG_MP_MAX_NUM_CPUS]; +static struct k_thread info_thread[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; static int thread_info_start(void) { From 58bdc8429df052612e93755475b555b7f360ee8c Mon Sep 17 00:00:00 2001 From: Jyri Sarha Date: Thu, 26 Mar 2026 18:31:47 +0200 Subject: [PATCH 3/6] debug_stream: text_msg: collect per-CPU state into cacheline-aligned struct Replace separate per-CPU arrays (ds_buf[], reports_sent_cpu[], ds_pos[]) with a single struct ds_cpu_state table aligned to CONFIG_DCACHE_LINE_SIZE to avoid false sharing between cores. Also remove the reports_sent reset in the flush path, so that once an exception dump has been sent, the sent-flag stays set and suppresses further output. Signed-off-by: Jyri Sarha --- .../debug_stream/debug_stream_text_msg.c | 60 +++++++++++-------- 1 file changed, 35 insertions(+), 25 deletions(-) diff --git a/src/debug/debug_stream/debug_stream_text_msg.c b/src/debug/debug_stream/debug_stream_text_msg.c index e27ff1cd0213..1ae4c9eab3ce 100644 --- a/src/debug/debug_stream/debug_stream_text_msg.c +++ b/src/debug/debug_stream/debug_stream_text_msg.c @@ -49,39 +49,48 @@ void ds_msg(const char *format, ...) * in bursts, and sending more than one record in short time makes the * host-side decoder lose track of things. */ -static struct { - struct debug_stream_text_msg msg; - char text[640]; -} __packed ds_buf[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; -static int reports_sent_cpu[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; -static size_t ds_pos[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; + +/* Per-CPU state for exception dump and assert_print(). Static data is + * currently placed in .bss and its ATM uncached so the ds_cpu table + * elements do not need to be cache aligned, but if this changes we + * need __aligned(CONFIG_DCACHE_LINE_SIZE) here. + */ +static struct ds_cpu_state { + struct { + struct debug_stream_text_msg msg; + char text[640]; + } __packed buf; + int reports_sent; + size_t pos; +} ds_cpu[CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS]; static void ds_exception_drain(bool flush) { unsigned int cpu = arch_proc_id(); + struct ds_cpu_state *cs = &ds_cpu[cpu]; if (flush) { - ds_pos[cpu] = 0; - reports_sent_cpu[cpu] = 0; + cs->pos = 0; return; } - if (ds_pos[cpu] == 0) + if (cs->pos == 0) return; - if (reports_sent_cpu[cpu] > 0) + if (cs->reports_sent > 0) return; - ds_buf[cpu].msg.hdr.id = DEBUG_STREAM_RECORD_ID_TEXT_MSG; - ds_buf[cpu].msg.hdr.size_words = - SOF_DIV_ROUND_UP(sizeof(ds_buf[cpu].msg) + ds_pos[cpu], - sizeof(ds_buf[cpu].msg.hdr.data[0])); + cs->buf.msg.hdr.id = DEBUG_STREAM_RECORD_ID_TEXT_MSG; + cs->buf.msg.hdr.size_words = + SOF_DIV_ROUND_UP(sizeof(cs->buf.msg) + cs->pos, + sizeof(cs->buf.msg.hdr.data[0])); + /* Make sure the possible up to 3 extra bytes at end of msg are '\0' */ - memset(ds_buf[cpu].text + ds_pos[cpu], 0, - ds_buf[cpu].msg.hdr.size_words * sizeof(ds_buf[cpu].msg.hdr.data[0]) - ds_pos[cpu]); - debug_stream_slot_send_record(&ds_buf[cpu].msg.hdr); - reports_sent_cpu[cpu] = 1; - ds_pos[cpu] = 0; + memset(cs->buf.text + cs->pos, 0, + cs->buf.msg.hdr.size_words * sizeof(cs->buf.msg.hdr.data[0]) - cs->pos); + debug_stream_slot_send_record(&cs->buf.msg.hdr); + cs->reports_sent = 1; + cs->pos = 0; } static void ds_exception_dump(const char *format, va_list args) @@ -90,11 +99,12 @@ static void ds_exception_dump(const char *format, va_list args) size_t avail; size_t written; unsigned int cpu = arch_proc_id(); + struct ds_cpu_state *cs = &ds_cpu[cpu]; - if (reports_sent_cpu[cpu] > 0) + if (cs->reports_sent > 0) return; - avail = sizeof(ds_buf[cpu].text) - ds_pos[cpu]; + avail = sizeof(cs->buf.text) - cs->pos; if (avail == 0) { ds_exception_drain(false); return; @@ -108,9 +118,9 @@ static void ds_exception_dump(const char *format, va_list args) format[0] == ' ' && format[1] == '*' && format[2] == '*' && format[3] == ' ') format += 4; - len = vsnprintf(ds_buf[cpu].text + ds_pos[cpu], avail, format, args); + len = vsnprintf(cs->buf.text + cs->pos, avail, format, args); if (len < 0) { - ds_pos[cpu] = 0; + cs->pos = 0; return; } @@ -122,9 +132,9 @@ static void ds_exception_dump(const char *format, va_list args) else written = (size_t)len; - ds_pos[cpu] += written; + cs->pos += written; - if (ds_pos[cpu] >= sizeof(ds_buf[cpu].text)) + if (cs->pos >= sizeof(cs->buf.text)) ds_exception_drain(false); } From c9c2d832f7263002c02692bf2ce57d46e58353c8 Mon Sep 17 00:00:00 2001 From: Jyri Sarha Date: Thu, 12 Mar 2026 19:17:29 +0200 Subject: [PATCH 4/6] debug_stream: text_msg: add va_list-based logging helper Add ds_vamsg(const char *format, va_list ap) to the debug stream text message API and implementation. Refactor ds_msg() to forward to ds_vamsg() so formatting and record emission are handled in one shared path. This enables callers that already operate on va_list to emit debug stream text messages without rebuilding variadic arguments, and keeps the message construction logic centralized. Signed-off-by: Jyri Sarha --- src/debug/debug_stream/debug_stream_text_msg.c | 14 ++++++++++---- src/include/user/debug_stream_text_msg.h | 2 ++ 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/debug/debug_stream/debug_stream_text_msg.c b/src/debug/debug_stream/debug_stream_text_msg.c index 1ae4c9eab3ce..b86642cfbd85 100644 --- a/src/debug/debug_stream/debug_stream_text_msg.c +++ b/src/debug/debug_stream/debug_stream_text_msg.c @@ -15,18 +15,15 @@ LOG_MODULE_REGISTER(debug_stream_text_msg); -void ds_msg(const char *format, ...) +void ds_vamsg(const char *format, va_list args) { - va_list args; struct { struct debug_stream_text_msg msg; char text[128]; } __packed buf = { 0 }; ssize_t len; - va_start(args, format); len = vsnprintf(buf.text, sizeof(buf.text), format, args); - va_end(args); if (len < 0) return; @@ -38,6 +35,15 @@ void ds_msg(const char *format, ...) debug_stream_slot_send_record(&buf.msg.hdr); } +void ds_msg(const char *format, ...) +{ + va_list args; + + va_start(args, format); + ds_vamsg(format, args); + va_end(args); +} + #if defined(CONFIG_EXCEPTION_DUMP_HOOK) /* The debug stream debug window slot is 4k, and when it is split * between the cores and the header/other overhead is removed, with 5 diff --git a/src/include/user/debug_stream_text_msg.h b/src/include/user/debug_stream_text_msg.h index 3d246e305fc3..debfaad7042e 100644 --- a/src/include/user/debug_stream_text_msg.h +++ b/src/include/user/debug_stream_text_msg.h @@ -7,6 +7,7 @@ #define __SOC_DEBUG_STREAM_TEXT_MSG_H__ #include +#include /* * Debug Stream text message. @@ -21,5 +22,6 @@ struct debug_stream_text_msg { * CONFIG_SOF_DEBUG_STREAM_TEXT_MSG to enable this function. */ void ds_msg(const char *format, ...); +void ds_vamsg(const char *format, va_list ap); #endif /* __SOC_DEBUG_STREAM_TEXT_MSG_H__ */ From d0f555fab5747834f1ba08b631c754971df0bdc5 Mon Sep 17 00:00:00 2001 From: Jyri Sarha Date: Tue, 17 Mar 2026 19:51:11 +0200 Subject: [PATCH 5/6] debug_stream: text_msg: add optional assert_print() forwarding Add optional support to route assert output through debug stream text messages. Introduce Kconfig option SOF_DEBUG_STREAM_TEXT_MSG_ASSERT_PRINT (depends on EXCEPTION_DUMP_HOOK and ASSERT/ASSERT_VERBOSE). Implement assert_print(const char *fmt, ...) to emit via ds_vamsg(), and mirror to vprintk() when CONFIG_EXCEPTION_DUMP_HOOK_ONLY is not set. Avoid duplicate post-fault prints by skipping assert output after an exception report has already been sent on the current CPU. Export assert_print for use by assert paths. Signed-off-by: Jyri Sarha --- src/debug/debug_stream/Kconfig | 10 +++++++ .../debug_stream/debug_stream_text_msg.c | 28 +++++++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/src/debug/debug_stream/Kconfig b/src/debug/debug_stream/Kconfig index b0dfaf1af03b..6ac6280c611c 100644 --- a/src/debug/debug_stream/Kconfig +++ b/src/debug/debug_stream/Kconfig @@ -74,4 +74,14 @@ config SOF_DEBUG_STREAM_TEXT_MSG ds_msg(). See include/user/debug_stream_text_msg.h for prototype. +config SOF_DEBUG_STREAM_TEXT_MSG_ASSERT_PRINT + bool "Enable assert print sending through Debug-Stream" + depends on EXCEPTION_DUMP_HOOK && (ASSERT || ASSERT_VERBOSE) + select SOF_DEBUG_STREAM_TEXT_MSG + help + Enable assert print sending over debug stream as text + message. This feature is also sensitive to Zephyr option + CONFIG_EXCEPTION_DUMP_HOOK_ONLY. If that is set then the + asserts are not printed through printk interface. + endif diff --git a/src/debug/debug_stream/debug_stream_text_msg.c b/src/debug/debug_stream/debug_stream_text_msg.c index b86642cfbd85..97db0fd29330 100644 --- a/src/debug/debug_stream/debug_stream_text_msg.c +++ b/src/debug/debug_stream/debug_stream_text_msg.c @@ -152,4 +152,32 @@ static int init_exception_dump_hook(void) } SYS_INIT(init_exception_dump_hook, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT); + +#if defined(CONFIG_SOF_DEBUG_STREAM_TEXT_MSG_ASSERT_PRINT) +void assert_print(const char *fmt, ...) +{ + va_list ap; + + /* Do not print assert after exception has been dumped */ + if (ds_cpu[arch_proc_id()].reports_sent > 0) + return; + + va_start(ap, fmt); +#if !defined(CONFIG_EXCEPTION_DUMP_HOOK_ONLY) + { + va_list ap2; + + va_copy(ap2, ap); +#endif + ds_vamsg(fmt, ap); +#if !defined(CONFIG_EXCEPTION_DUMP_HOOK_ONLY) + vprintk(fmt, ap2); + va_end(ap2); + } +#endif + ds_vamsg(fmt, ap); + va_end(ap); +} +EXPORT_SYMBOL(assert_print); +#endif #endif From fc1352cea5152f5ccdee257e04e154e77a94636f Mon Sep 17 00:00:00 2001 From: Jyri Sarha Date: Thu, 26 Mar 2026 00:06:32 +0200 Subject: [PATCH 6/6] app: debug_stream_overlay.conf: Add new debug_stream Kconfig options There is two new options, CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS and CONFIG_SOF_DEBUG_STREAM_TEXT_MSG_ASSERT_PRINT. CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS limits the amount of debug_stream support to a lower number of cores than what is available. As the number of supported cores shrink, the available circular buffer size increases. This means increased bandwidth. This is particularly useful, when debugging a problem on core 0. By defaut this option is commented out. CONFIG_SOF_DEBUG_STREAM_TEXT_MSG_ASSERT_PRINT adds optional support to route assert output through debug stream text messages. This option obeys CONFIG_EXCEPTION_DUMP_HOOK_ONLY. If it is selected the assert print is sent only to debug stream. Without it the assert prints are printed with vprintk too, Signed-off-by: Jyri Sarha --- app/debug_stream_overlay.conf | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/app/debug_stream_overlay.conf b/app/debug_stream_overlay.conf index cd310b9a7fa8..7edd6bf6709c 100644 --- a/app/debug_stream_overlay.conf +++ b/app/debug_stream_overlay.conf @@ -8,6 +8,17 @@ CONFIG_SOF_DEBUG_STREAM_THREAD_INFO=y CONFIG_THREAD_NAME=y # For Zephyr to compile with thread names on PTL we need to increase THREAD_BYTES CONFIG_MAX_THREAD_BYTES=4 +# Shrink number of CPU sections +# As the number of supported cores shrink, the available circular +# buffer size increases. This means increased bandwidth. This is +# particularly useful, when debugging a problem on core 0. +#CONFIG_SOF_DEBUG_STREAM_SLOT_FORCE_MAX_CPUS=1 + +# Direct the assert prints to debug stream +# This option obeys CONFIG_EXCEPTION_DUMP_HOOK_ONLY. If it is selected +# the assert print is sent only to debug stream. Without it the assert +# prints are printed with vprintk too, +CONFIG_SOF_DEBUG_STREAM_TEXT_MSG_ASSERT_PRINT=y # Debug window slot configuration 1 # The CONFIG_SOF_TELEMETRY uses slot 2, but with performance and IO-performance