logging: probe: Add buffer to collect logs before probes DMA is up

Allocate a 4kb buffer to collect the logs arriving before probes DMA
is up. Send the contents of the buffer when the callback indicating
that DMA is running is set and free the buffer. Busy wait the DMA
progress in case the buffer does not fit into the DMA buffer at once.

Signed-off-by: Jyri Sarha <jyri.sarha@linux.intel.com>

Author: Jyri Sarha

src/logging/log_backend_probe.c

@@ -14,6 +14,10 @@
 #include <sof/lib/notifier.h>
 #include <sof/probe/probe.h>
 
+#ifdef PROBE_LOG_DEBUG
+#include <stdio.h>
+#endif
+
 /*
  * A lock is needed as log_process() and log_panic() have no internal locks
  * to prevent concurrency. Meaning if log_process is called after
@@ -33,10 +37,81 @@ static uint8_t log_buf[LOG_BUF_SIZE];
 
 static probe_logging_hook_t probe_hook;
 
+static void log_push(uint8_t *data, size_t length)
+{
+	int pos = 0;
+
+	do {
+		int ret = probe_hook(data + pos, length - pos);
+
+		if (ret < 0)
+			break;
+		pos += ret;
+	} while (pos < length);
+}
+
+#define PRE_BUFFER_SIZE 4096
+static struct probe_pre_buffer {
+	uint8_t *buf;
+	uint32_t wpos;
+	uint32_t len;
+} prebuf;
+
+static void pre_buffer_drain(void)
+{
+#ifdef PROBE_LOG_DEBUG
+	/* NOTE: The debug code only works with ascii/text log output */
+	uint64_t stamp = sof_cycle_get_64();
+	char msg[80];
+	int mlen;
+
+	mlen = snprintf(msg, sizeof(msg), "[Drain %u bytes of pre buffered logs]\n", prebuf.wpos);
+	if (prebuf.len > prebuf.wpos)
+		mlen += snprintf(&msg[mlen], sizeof(msg) - mlen, "[%u bytes dropped]\n",
+			      prebuf.len - prebuf.wpos);
+	log_push(msg, mlen);
+#endif
+
+	log_push(prebuf.buf, prebuf.wpos);
+	rfree(prebuf.buf);
+	prebuf.buf = NULL;
+	prebuf.len = 0;
+	prebuf.wpos = 0;
+
+#ifdef PROBE_LOG_DEBUG
+	mlen = snprintf(msg, sizeof(msg), "[Buffer drained in %llu us]\n",
+			k_cyc_to_us_near64(sof_cycle_get_64() - stamp));
+
+	log_push(msg, mlen);
+#endif
+}
+
+static void pre_buffer(uint8_t *data, size_t length)
+{
+	int ret;
+
+	prebuf.len += length;
+	if (!prebuf.buf) {
+		prebuf.buf = rzalloc(SOF_MEM_ZONE_RUNTIME, 0, SOF_MEM_CAPS_RAM, PRE_BUFFER_SIZE);
+		if (!prebuf.buf)
+			return;
+	}
+	/* Protection against buffer over flow relies on memcpy_s() */
+	ret = memcpy_s(&prebuf.buf[prebuf.wpos], PRE_BUFFER_SIZE - prebuf.wpos, data, length);
+	if (!ret)
+		prebuf.wpos += length;
+}
+
 static int probe_char_out(uint8_t *data, size_t length, void *ctx)
 {
-	if (probe_hook)
-		probe_hook(data, length);
+	if (!probe_hook) {
+		pre_buffer(data, length);
+	} else {
+		if (prebuf.wpos)
+			pre_buffer_drain();
+
+		log_push(data, length);
+	}
 
 	return length;
 }