serial: uart_native_pty: ASYNC RX support

Add support for receiving using the asynchronous API. This is achieved
through registering a handler for the SIGIO signal, and polling data
off the file descriptors inside the event.

Signed-off-by: Jordan Yates <[email protected]>

Author: JordanYates

drivers/serial/uart_native_pty.c

@@ -14,6 +14,7 @@
 #endif
 
 #include <stdbool.h>
+#include <signal.h>
 #include <zephyr/drivers/uart.h>
 #include <zephyr/kernel.h>
 #include <cmdline.h> /* native_sim command line options header */
@@ -56,6 +57,8 @@ struct native_pty_status {
 		void *user_data;
 		const uint8_t *tx_buf;
 		size_t tx_len;
+		uint8_t *rx_buf;
+		size_t rx_len;
 	} async;
 #endif /* CONFIG_UART_ASYNC_API */
 };
@@ -70,6 +73,10 @@ static int np_uart_callback_set(const struct device *dev, uart_callback_t callba
 				void *user_data);
 static int np_uart_tx(const struct device *dev, const uint8_t *buf, size_t len, int32_t timeout);
 static int np_uart_tx_abort(const struct device *dev);
+static int np_uart_rx_buf_rsp(const struct device *dev, uint8_t *buf, size_t len);
+static int np_uart_rx_enable(const struct device *dev, uint8_t *buf, size_t len, int32_t timeout);
+static int np_uart_rx_disable(const struct device *dev);
+static void sigio_handler(int status);
 #endif /* CONFIG_UART_ASYNC_API */
 
 static DEVICE_API(uart, np_uart_driver_api) = {
@@ -79,6 +86,9 @@ static DEVICE_API(uart, np_uart_driver_api) = {
 	.callback_set = np_uart_callback_set,
 	.tx = np_uart_tx,
 	.tx_abort = np_uart_tx_abort,
+	.rx_buf_rsp = np_uart_rx_buf_rsp,
+	.rx_enable = np_uart_rx_enable,
+	.rx_disable = np_uart_rx_disable,
 #endif /* CONFIG_UART_ASYNC_API */
 };
 
@@ -143,7 +153,16 @@ static int np_uart_init(const struct device *dev)
 	}
 
 #ifdef CONFIG_UART_ASYNC_API
+	static bool handler_installed;
+
+	if (!handler_installed) {
+		/* Install global SIGIO handler */
+		nsi_signal_handler_install(SIGIO, sigio_handler);
+		handler_installed = true;
+	}
 	k_work_init_delayable(&d->async.tx_done, np_uart_tx_done_work);
+	/* Mark the file descriptor as async */
+	nsi_fd_async(d->in_fd);
 #endif
 
 	return 0;
@@ -296,6 +315,88 @@ static int np_uart_tx_abort(const struct device *dev)
 	return k_work_cancel_delayable_sync(&data->async.tx_done, &sync) ? 0 : -EFAULT;
 }
 
+static void sigio_handler_dev(const struct device *dev)
+{
+	struct native_pty_status *data = dev->data;
+	unsigned char fallback[8];
+	struct uart_event event;
+	unsigned char *buf;
+	long read;
+	int len;
+
+	/* Read data from the file even if it is disabled.
+	 * This prevents data that was received while disabled from
+	 * appearing at the output if it is enabled later.
+	 */
+	if (data->async.rx_len == 0) {
+		buf = fallback;
+		len = sizeof(fallback);
+	} else {
+		buf = data->async.rx_buf;
+		len = data->async.rx_len;
+	}
+
+	/* Loop until there is no more data to be read */
+	while (1) {
+		read = np_uart_stdin_poll_in_bottom(data->in_fd, buf, len);
+		if (read <= 0) {
+			break;
+		}
+		if (data->async.rx_len == 0) {
+			/* RX disabled, drop data */
+			continue;
+		}
+
+		event.type = UART_RX_RDY;
+		event.data.rx.buf = buf;
+		event.data.rx.len =  len;
+		event.data.rx.offset = 0;
+
+		data->async.user_callback(data->async.dev, &event, data->async.user_data);
+	}
+}
+
+#define NATIVE_PTY_SIGIO_HANDLER(inst)                                        \
+	sigio_handler_dev(DEVICE_DT_GET(DT_DRV_INST(inst)));
+
+static void sigio_handler(int status)
+{
+DT_INST_FOREACH_STATUS_OKAY(NATIVE_PTY_SIGIO_HANDLER)
+}
+
+static int np_uart_rx_buf_rsp(const struct device *dev, uint8_t *buf, size_t len)
+{
+	/* Driver never requests additional buffers */
+	return -ENOTSUP;
+}
+
+static int np_uart_rx_enable(const struct device *dev, uint8_t *buf, size_t len,
+			     int32_t timeout)
+{
+	struct native_pty_status *data = dev->data;
+
+	ARG_UNUSED(timeout);
+
+	data->async.rx_buf = buf;
+	data->async.rx_len = len;
+
+	return 0;
+}
+
+static int np_uart_rx_disable(const struct device *dev)
+{
+	struct native_pty_status *data = dev->data;
+
+	if (data->async.rx_buf == NULL) {
+		return -EFAULT;
+	}
+
+	data->async.rx_buf = NULL;
+	data->async.rx_len = 0;
+
+	return 0;
+}
+
 #endif /* CONFIG_UART_ASYNC_API */
 
 

scripts/native_simulator/common/src/include/nsi_host_trampolines.h

@@ -37,6 +37,8 @@ void *nsi_host_realloc(void *ptr, unsigned long size);
 void nsi_host_srandom(unsigned int seed);
 char *nsi_host_strdup(const char *s);
 long nsi_host_write(int fd, const void *buffer, unsigned long size);
+void nsi_signal_handler_install(int signal, void (*handler)(int status));
+void nsi_fd_async(int fd);
 
 #ifdef __cplusplus
 }

scripts/native_simulator/common/src/nsi_host_trampolines.c

@@ -10,6 +10,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 #include <string.h>
+#include <signal.h>
 
 void *nsi_host_calloc(unsigned long nmemb, unsigned long size)
 {
@@ -75,3 +76,22 @@ long nsi_host_write(int fd, const void *buffer, unsigned long size)
 {
 	return write(fd, buffer, size);
 }
+
+void nsi_signal_handler_install(int signal, void (*handler)(int status))
+{
+	struct sigaction saio;
+
+	/* Install the signal handler */
+	saio.sa_handler = handler;
+	saio.sa_flags = 0;
+	saio.sa_restorer = NULL;
+	sigaction(signal, &saio, NULL);
+}
+
+void nsi_fd_async(int fd)
+{
+	/* Set the file descriptor owner so we can receive events */
+	fcntl(fd, F_SETOWN, getpid());
+	/* Make the file descriptor asynchronous */
+	fcntl(fd, F_SETFL, O_ASYNC);
+}