[nrf fromlist] drivers: debug: nrf_etr: Add support for RTT backend

Add option to output STM logging on RTT.

Upstream PR #: 100570

Signed-off-by: Krzysztof Chruściński <[email protected]>

Author: nordic-krch

drivers/debug/Kconfig.nrf

@@ -16,6 +16,53 @@ config DEBUG_NRF_ETR
 
 if DEBUG_NRF_ETR
 
+DT_CHOSEN_ZEPHYR_CONSOLE := zephyr,console
+
+config DEBUG_NRF_ETR_BACKEND_UART
+	default y if $(dt_chosen_enabled,$(DT_CHOSEN_ZEPHYR_CONSOLE))
+	bool "UART backend"
+
+config DEBUG_NRF_ETR_BACKEND_RTT
+	bool "RTT backend"
+	select USE_SEGGER_RTT
+	select SEGGER_RTT_CUSTOM_LOCKING
+
+if DEBUG_NRF_ETR_BACKEND_RTT
+
+config DEBUG_NRF_ETR_BACKEND_RTT_BUFFER
+	int "Buffer number used for logger output."
+	range 0 SEGGER_RTT_MAX_NUM_UP_BUFFERS
+	default 0
+	help
+	  Select index of up-buffer used for logger output, by default it uses
+	  terminal up-buffer and its settings.
+
+config DEBUG_NRF_ETR_BACKEND_RTT_BUFFER_SIZE
+	int "Size of reserved up-buffer for logger output."
+	default 1024
+	depends on DEBUG_NRF_ETR_BACKEND_RTT_BUFFER > 0
+	help
+	  Specify reserved size of up-buffer used for logger output.
+
+config DEBUG_NRF_ETR_BACKEND_RTT_RETRY_CNT
+	int "Number of retries"
+	default 4
+	help
+	  Number of TX retries before dropping the data and assuming that
+	  RTT session is inactive.
+
+config DEBUG_NRF_ETR_BACKEND_RTT_RETRY_DELAY_MS
+	int "Delay between TX retries in milliseconds"
+	default 5
+	help
+	  Sleep period between TX retry attempts. During RTT session, host pulls
+	  data periodically. Period starts from 1-2 milliseconds and can be
+	  increased if traffic on RTT increases (also from host to device). In
+	  case of heavy traffic data can be lost and it may be necessary to
+	  increase delay or number of retries.
+
+endif
+
 config DEBUG_NRF_ETR_DECODE
 	bool "Decode ETR content"
 	default y if LOG_FRONTEND_STMESP_FSC
@@ -80,6 +127,7 @@ config DEBUG_NRF_ETR_SHELL
 	select UART_ASYNC_RX_HELPER
 	select SHELL_LOG_BACKEND_CUSTOM
 	depends on DEBUG_NRF_ETR_DECODE
+	depends on DEBUG_NRF_ETR_BACKEND_UART
 	default y if SHELL
 	help
 	  Enable shell with Coresight STM logging support.

drivers/debug/debug_nrf_etr.c

@@ -22,6 +22,11 @@
 #include <dmm.h>
 #include <nrfx_tbm.h>
 #include <stdio.h>
+
+#ifdef CONFIG_DEBUG_NRF_ETR_BACKEND_RTT
+#include <SEGGER_RTT.h>
+#endif
+
 LOG_MODULE_REGISTER(cs_etr_tbm);
 
 #define UART_NODE DT_CHOSEN(zephyr_console)
@@ -79,7 +84,7 @@ static uint32_t etr_rd_idx;
 /* Counts number of new messages completed in the current formatter frame decoding. */
 static uint32_t new_msg_cnt;
 
-static bool volatile use_async_uart;
+static bool volatile use_blocking;
 
 static struct k_sem uart_sem;
 static const struct device *uart_dev = DEVICE_DT_GET(UART_NODE);
@@ -149,27 +154,101 @@ static shell_transport_handler_t shell_handler;
 static void *shell_context;
 #endif
 
+#ifdef CONFIG_DEBUG_NRF_ETR_BACKEND_RTT
+
+#define RTT_LOCK() \
+	COND_CODE_0(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER, (SEGGER_RTT_LOCK()), ())
+
+#define RTT_UNLOCK() \
+	COND_CODE_0(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER, (SEGGER_RTT_UNLOCK()), ())
+
+static uint8_t rtt_buf[COND_CODE_0(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER, (1),
+				(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER_SIZE))];
+
+static volatile bool rtt_host_present;
+
+static void rtt_on_failed_write(int retry_cnt, bool in_panic)
+{
+	if (retry_cnt == 0) {
+		rtt_host_present = false;
+	} else if (in_panic) {
+		k_busy_wait(USEC_PER_MSEC * CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_RETRY_DELAY_MS);
+	} else {
+		k_msleep(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_RETRY_DELAY_MS);
+	}
+}
+
+static void rtt_on_write(int retry_cnt, bool in_panic)
+{
+	rtt_host_present = true;
+	if (use_blocking) {
+		/* In panic mode block on each write until host reads it. This
+		 * way it is ensured that if system resets all messages are read
+		 * by the host. While pending on data being read by the host we
+		 * must also detect situation where host is disconnected.
+		 */
+		while (SEGGER_RTT_HasDataUp(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER)) {
+			rtt_on_failed_write(retry_cnt--, in_panic);
+		}
+	}
+
+}
+
+static void rtt_write(uint8_t *data, size_t length, bool in_panic)
+{
+	int ret = 0;
+	int retry_cnt = CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_RETRY_CNT;
+
+	do {
+		if (!in_panic) {
+			RTT_LOCK();
+			ret = SEGGER_RTT_WriteSkipNoLock(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER,
+							 data, length);
+			RTT_UNLOCK();
+		} else {
+			ret = SEGGER_RTT_WriteSkipNoLock(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER,
+							 data, length);
+		}
+
+		if (ret) {
+			rtt_on_write(retry_cnt, in_panic);
+		} else if (rtt_host_present) {
+			retry_cnt--;
+			rtt_on_failed_write(retry_cnt, in_panic);
+		} else {
+		}
+	} while ((ret == 0) && rtt_host_present);
+}
+#endif /* CONFIG_DEBUG_NRF_ETR_BACKEND_RTT */
+
 static int log_output_func(uint8_t *buf, size_t size, void *ctx)
 {
-	if (use_async_uart) {
-		int err;
-		static uint8_t *tx_buf = (uint8_t *)frame_buf0;
+	ARG_UNUSED(ctx);
 
-		err = k_sem_take(&uart_sem, K_FOREVER);
-		__ASSERT_NO_MSG(err >= 0);
+	if (IS_ENABLED(CONFIG_DEBUG_NRF_ETR_BACKEND_UART)) {
+		if (use_blocking) {
+			for (int i = 0; i < size; i++) {
+				uart_poll_out(uart_dev, buf[i]);
+			}
+		} else {
+			int err;
+			static uint8_t *tx_buf = (uint8_t *)frame_buf0;
 
-		memcpy(tx_buf, buf, size);
+			err = k_sem_take(&uart_sem, K_FOREVER);
+			__ASSERT_NO_MSG(err >= 0);
 
-		err = uart_tx(uart_dev, tx_buf, size, SYS_FOREVER_US);
-		__ASSERT_NO_MSG(err >= 0);
+			memcpy(tx_buf, buf, size);
 
-		tx_buf = (tx_buf == (uint8_t *)frame_buf0) ?
-			(uint8_t *)frame_buf1 : (uint8_t *)frame_buf0;
-	} else {
-		for (int i = 0; i < size; i++) {
-			uart_poll_out(uart_dev, buf[i]);
+			err = uart_tx(uart_dev, tx_buf, size, SYS_FOREVER_US);
+			__ASSERT_NO_MSG(err >= 0);
+
+			tx_buf = (tx_buf == (uint8_t *)frame_buf0) ?
+				(uint8_t *)frame_buf1 : (uint8_t *)frame_buf0;
 		}
 	}
+#ifdef CONFIG_DEBUG_NRF_ETR_BACKEND_RTT
+	rtt_write(buf, size, use_blocking);
+#endif
 
 	return size;
 }
@@ -528,16 +607,16 @@ static void dump_frame(uint8_t *buf)
 {
 	int err;
 
-	if (use_async_uart) {
+	if (use_blocking) {
+		for (int i = 0; i < CORESIGHT_TRACE_FRAME_SIZE; i++) {
+			uart_poll_out(uart_dev, buf[i]);
+		}
+	} else {
 		err = k_sem_take(&uart_sem, K_FOREVER);
 		__ASSERT_NO_MSG(err >= 0);
 
 		err = uart_tx(uart_dev, buf, CORESIGHT_TRACE_FRAME_SIZE, SYS_FOREVER_US);
 		__ASSERT_NO_MSG(err >= 0);
-	} else {
-		for (int i = 0; i < CORESIGHT_TRACE_FRAME_SIZE; i++) {
-			uart_poll_out(uart_dev, buf[i]);
-		}
 	}
 }
 
@@ -593,7 +672,7 @@ static void process(void)
 			}
 		} else {
 			dump_frame((uint8_t *)frame_buf);
-			frame_buf = (use_async_uart && (frame_buf == frame_buf0)) ?
+			frame_buf = (!use_blocking && (frame_buf == frame_buf0)) ?
 						frame_buf1 : frame_buf0;
 		}
 	}
@@ -649,7 +728,7 @@ void debug_nrf_etr_flush(void)
 	/* Set flag which forces uart to use blocking polling out instead of
 	 * asynchronous API.
 	 */
-	use_async_uart = false;
+	use_blocking = true;
 	uint32_t k = irq_lock();
 
 	/* Repeat arbitrary number of times to ensure that all that is flushed. */
@@ -754,17 +833,23 @@ static void tbm_event_handler(nrf_tbm_event_t event)
 
 int etr_process_init(void)
 {
+#ifdef CONFIG_DEBUG_NRF_ETR_BACKEND_RTT
+	if (CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER > 0) {
+		SEGGER_RTT_ConfigUpBuffer(CONFIG_DEBUG_NRF_ETR_BACKEND_RTT_BUFFER, "stm_logger",
+					  rtt_buf, sizeof(rtt_buf),
+					  SEGGER_RTT_MODE_NO_BLOCK_SKIP);
+	}
+#endif
 	int err;
 
-	k_sem_init(&uart_sem, 1, 1);
-
-	err = uart_callback_set(uart_dev, uart_event_handler, NULL);
-	use_async_uart = (err == 0);
-
+	if (IS_ENABLED(CONFIG_DEBUG_NRF_ETR_BACKEND_UART)) {
+		err = uart_callback_set(uart_dev, uart_event_handler, NULL);
+		use_blocking = (err != 0);
+		k_sem_init(&uart_sem, 1, 1);
+	}
 	static const nrfx_tbm_config_t config = {.size = wsize_mask};
 
 	nrfx_tbm_init(&config, tbm_event_handler);
-
 	IRQ_CONNECT(DT_IRQN(DT_NODELABEL(tbm)), DT_IRQ(DT_NODELABEL(tbm), priority),
 			    nrfx_isr, nrfx_tbm_irq_handler, 0);
 	irq_enable(DT_IRQN(DT_NODELABEL(tbm)));