logging: add UART backend for dictionary based logging

This adds a new UART backend for dictionary based logging,
where this can output binary data in both binary and
hexidecimal strings.

Signed-off-by: Daniel Leung <[email protected]>

Author: dcpleung

subsys/logging/Kconfig.backends

@@ -10,13 +10,49 @@ config LOG_BACKEND_UART
 	help
 	  When enabled backend is using UART to output logs.
 
+if LOG_BACKEND_UART
+
+config LOG_BACKEND_UART_OUTPUT_DICTIONARY
+	bool
+	depends on LOG2
+	select LOG_DICTIONARY_SUPPORT
+	help
+	  UART backend is in dictionary-based logging output mode.
+
+choice
+	prompt "UART Backend Output Mode"
+	default LOG_BACKEND_UART_OUTPUT_TEXT
+
+config LOG_BACKEND_UART_OUTPUT_TEXT
+	bool "Text"
+	help
+	  Output in text.
+
 config LOG_BACKEND_UART_SYST_ENABLE
-	bool "Enable UART syst backend"
+	bool "MIPI SyS-T"
 	depends on LOG_BACKEND_UART
 	depends on LOG_MIPI_SYST_ENABLE
 	help
 	  When enabled backend is using UART to output syst format logs.
 
+config LOG_BACKEND_UART_OUTPUT_DICTIONARY_HEX
+	bool "Dictionary (hexadecimal)"
+	depends on LOG2
+	select LOG_BACKEND_UART_OUTPUT_DICTIONARY
+	help
+	  Dictionary-based logging output in hexadecimal.
+
+config LOG_BACKEND_UART_OUTPUT_DICTIONARY_BIN
+	bool "Dictionary (binary)"
+	depends on LOG2
+	select LOG_BACKEND_UART_OUTPUT_DICTIONARY
+	help
+	  Dictionary-based logging output in binary.
+
+endchoice
+
+endif # LOG_BACKEND_UART
+
 config LOG_BACKEND_SWO
 	bool "Enable Serial Wire Output (SWO) backend"
 	depends on HAS_SWO

subsys/logging/log_backend_uart.c

@@ -8,19 +8,40 @@
 #include <logging/log_core.h>
 #include <logging/log_msg.h>
 #include <logging/log_output.h>
+#include <logging/log_output_dict.h>
 #include <logging/log_backend_std.h>
 #include <device.h>
 #include <drivers/uart.h>
 #include <sys/__assert.h>
 
+/* Fixed size to avoid auto-added trailing '\0'.
+ * Used if CONFIG_LOG_BACKEND_UART_OUTPUT_DICTIONARY_HEX.
+ */
+static const char LOG_HEX_SEP[10] = "##ZLOGV1##";
+
 static const struct device *uart_dev;
 
 static int char_out(uint8_t *data, size_t length, void *ctx)
 {
 	ARG_UNUSED(ctx);
 
 	for (size_t i = 0; i < length; i++) {
+#if defined(CONFIG_LOG_BACKEND_UART_OUTPUT_DICTIONARY_HEX)
+		char c;
+		uint8_t x;
+
+		/* upper 8-bit */
+		x = data[i] >> 4;
+		(void)hex2char(x, &c);
+		uart_poll_out(uart_dev, c);
+
+		/* lower 8-bit */
+		x = data[i] & 0x0FU;
+		(void)hex2char(x, &c);
+		uart_poll_out(uart_dev, c);
+#else
 		uart_poll_out(uart_dev, data[i]);
+#endif
 	}
 
 	return length;
@@ -44,13 +65,29 @@ static void process(const struct log_backend *const backend,
 {
 	uint32_t flags = log_backend_std_get_flags();
 
-	log_output_msg2_process(&log_output_uart, &msg->log, flags);
+	if (IS_ENABLED(CONFIG_LOG_BACKEND_UART_OUTPUT_DICTIONARY)) {
+		log_dict_output_msg2_process(&log_output_uart,
+					     &msg->log, flags);
+	} else {
+		log_output_msg2_process(&log_output_uart, &msg->log, flags);
+	}
 }
 
 static void log_backend_uart_init(struct log_backend const *const backend)
 {
 	uart_dev = device_get_binding(CONFIG_UART_CONSOLE_ON_DEV_NAME);
 	__ASSERT_NO_MSG((void *)uart_dev);
+
+	if (IS_ENABLED(CONFIG_LOG_BACKEND_UART_OUTPUT_DICTIONARY_HEX)) {
+		/* Print a separator so the output can be fed into
+		 * log parser directly. This is useful when capturing
+		 * from UART directly where there might be other output
+		 * (e.g. bootloader).
+		 */
+		for (int i = 0; i < sizeof(LOG_HEX_SEP); i++) {
+			uart_poll_out(uart_dev, LOG_HEX_SEP[i]);
+		}
+	}
 }
 
 static void panic(struct log_backend const *const backend)
@@ -62,7 +99,11 @@ static void dropped(const struct log_backend *const backend, uint32_t cnt)
 {
 	ARG_UNUSED(backend);
 
-	log_backend_std_dropped(&log_output_uart, cnt);
+	if (IS_ENABLED(CONFIG_LOG_BACKEND_UART_OUTPUT_DICTIONARY)) {
+		log_dict_output_dropped_process(&log_output_uart, cnt);
+	} else {
+		log_backend_std_dropped(&log_output_uart, cnt);
+	}
 }
 
 static void sync_string(const struct log_backend *const backend,