drivers/serial/uart_rtt.c

/*
 * Copyright (c) 2019 omSquare s.r.o.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/drivers/uart.h>
#include <SEGGER_RTT.h>

#define DT_DRV_COMPAT segger_rtt_uart

extern struct k_mutex rtt_term_mutex;

struct uart_rtt_config {
	void *up_buffer;
	size_t up_size;
	void *down_buffer;
	size_t down_size;
	uint8_t channel;
};

struct uart_rtt_data {
#ifdef CONFIG_UART_ASYNC_API
	uart_callback_t callback;
	void *user_data;
#endif /* CONFIG_UART_ASYNC_API */
};

static int uart_rtt_init(const struct device *dev)
{
	/*
	 * Channel 0 is initialized at compile-time, Kconfig ensures that
	 * it is configured in correct, non-blocking mode. Other channels
	 * need to be configured at run-time.
	 */
	if (dev->config) {
		const struct uart_rtt_config *cfg = dev->config;

		SEGGER_RTT_ConfigUpBuffer(cfg->channel, dev->name,
					  cfg->up_buffer, cfg->up_size,
					  SEGGER_RTT_MODE_NO_BLOCK_SKIP);
		SEGGER_RTT_ConfigDownBuffer(cfg->channel, dev->name,
					    cfg->down_buffer, cfg->down_size,
					    SEGGER_RTT_MODE_NO_BLOCK_SKIP);
	}
	return 0;
}

/**
 * @brief Poll the device for input.
 *
 * @param dev UART device struct
 * @param c Pointer to character
 *
 * @return 0 if a character arrived, -1 if the input buffer if empty.
 */

static int uart_rtt_poll_in(const struct device *dev, unsigned char *c)
{
	const struct uart_rtt_config *config = dev->config;
	unsigned int ch = config ? config->channel : 0;
	unsigned int ret = SEGGER_RTT_Read(ch, c, 1);

	return ret ? 0 : -1;
}

/**
 * @brief Output a character in polled mode.
 *
 * @param dev UART device struct
 * @param c Character to send
 */
static void uart_rtt_poll_out(const struct device *dev, unsigned char c)
{
	const struct uart_rtt_config *config = dev->config;
	unsigned int ch = config ? config->channel : 0;

	SEGGER_RTT_Write(ch, &c, 1);
}

#ifdef CONFIG_UART_ASYNC_API

static int uart_rtt_callback_set(const struct device *dev,
				 uart_callback_t callback, void *user_data)
{
	struct uart_rtt_data *data = dev->data;

	data->callback = callback;
	data->user_data = user_data;
	return 0;
}

static int uart_rtt_tx(const struct device *dev,
		       const uint8_t *buf, size_t len, int32_t timeout)
{
	const struct uart_rtt_config *cfg = dev->config;
	struct uart_rtt_data *data = dev->data;
	unsigned int ch = cfg ? cfg->channel : 0;

	ARG_UNUSED(timeout);

	/* RTT mutex cannot be claimed in ISRs */
	if (k_is_in_isr()) {
		return -ENOTSUP;
	}

	/* Claim the RTT lock */
	if (k_mutex_lock(&rtt_term_mutex, K_NO_WAIT) != 0) {
		return -EBUSY;
	}

	/* Output the buffer */
	SEGGER_RTT_WriteNoLock(ch, buf, len);

	/* Return RTT lock */
	SEGGER_RTT_UNLOCK();

	/* Send the TX complete callback */
	if (data->callback) {
		struct uart_event evt = {
			.type = UART_TX_DONE,
			.data.tx.buf = buf,
			.data.tx.len = len
		};
		data->callback(dev, &evt, data->user_data);
	}

	return 0;
}

static int uart_rtt_tx_abort(const struct device *dev)
{
	/* RTT TX is a memcpy, there is never a transmission to abort */
	ARG_UNUSED(dev);

	return -EFAULT;
}

static int uart_rtt_rx_enable(const struct device *dev,
			      uint8_t *buf, size_t len, int32_t timeout)
{
	/* SEGGER RTT reception is implemented as a direct memory write to RAM
	 * by a connected debugger. As such there is no hardware interrupt
	 * or other mechanism to know when the debugger has added data to be
	 * read. Asynchronous RX does not make sense in such a context, and is
	 * therefore not supported.
	 */
	ARG_UNUSED(dev);
	ARG_UNUSED(buf);
	ARG_UNUSED(len);
	ARG_UNUSED(timeout);

	return -ENOTSUP;
}

static int uart_rtt_rx_disable(const struct device *dev)
{
	/* Asynchronous RX not supported, see uart_rtt_rx_enable */
	ARG_UNUSED(dev);

	return -EFAULT;
}

static int uart_rtt_rx_buf_rsp(const struct device *dev,
			       uint8_t *buf, size_t len)
{
	/* Asynchronous RX not supported, see uart_rtt_rx_enable */
	ARG_UNUSED(dev);
	ARG_UNUSED(buf);
	ARG_UNUSED(len);

	return -ENOTSUP;
}

#endif /* CONFIG_UART_ASYNC_API */

static const struct uart_driver_api uart_rtt_driver_api = {
	.poll_in = uart_rtt_poll_in,
	.poll_out = uart_rtt_poll_out,
#ifdef CONFIG_UART_ASYNC_API
	.callback_set = uart_rtt_callback_set,
	.tx = uart_rtt_tx,
	.tx_abort = uart_rtt_tx_abort,
	.rx_enable = uart_rtt_rx_enable,
	.rx_buf_rsp = uart_rtt_rx_buf_rsp,
	.rx_disable = uart_rtt_rx_disable,
#endif /* CONFIG_UART_ASYNC_API */
};

#define UART_RTT(idx)                   DT_NODELABEL(rtt##idx)
#define UART_RTT_PROP(idx, prop)        DT_PROP(UART_RTT(idx), prop)
#define UART_RTT_CONFIG_NAME(idx)       uart_rtt##idx##_config

#define UART_RTT_CONFIG(idx)						    \
	static								    \
	uint8_t uart_rtt##idx##_tx_buf[UART_RTT_PROP(idx, tx_buffer_size)]; \
	static								    \
	uint8_t uart_rtt##idx##_rx_buf[UART_RTT_PROP(idx, rx_buffer_size)]; \
									    \
	static const struct uart_rtt_config UART_RTT_CONFIG_NAME(idx) = {   \
		.up_buffer = uart_rtt##idx##_tx_buf,			    \
		.up_size = sizeof(uart_rtt##idx##_tx_buf),		    \
		.down_buffer = uart_rtt##idx##_rx_buf,			    \
		.down_size = sizeof(uart_rtt##idx##_rx_buf),		    \
	}

#define UART_RTT_INIT(idx, config)					      \
	struct uart_rtt_data uart_rtt##idx##_data;			      \
									      \
	DEVICE_DT_DEFINE(UART_RTT(idx), uart_rtt_init, NULL, \
			    &uart_rtt##idx##_data, config,		      \
			    PRE_KERNEL_2, CONFIG_SERIAL_INIT_PRIORITY,	      \
			    &uart_rtt_driver_api)

#ifdef CONFIG_UART_RTT_0
UART_RTT_INIT(0, NULL);
#endif

#ifdef CONFIG_UART_RTT_1
UART_RTT_CONFIG(1);
UART_RTT_INIT(1, &UART_RTT_CONFIG_NAME(1));
#endif

#ifdef CONFIG_UART_RTT_2
UART_RTT_CONFIG(2);
UART_RTT_INIT(2, &UART_RTT_CONFIG_NAME(2));
#endif

#ifdef CONFIG_UART_RTT_3
UART_RTT_CONFIG(3);
UART_RTT_INIT(3, &UART_RTT_CONFIG_NAME(3));
#endif