serial: uart_native_pty: ASYNC RX support

Add support for transmitting using the asynchronous API. The
asynchronous portion is simulated through a dedicated polling thread.

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

Author: JordanYates

drivers/serial/uart_native_pty.c

@@ -56,6 +56,11 @@ struct native_pty_status {
 		void *user_data;
 		const uint8_t *tx_buf;
 		size_t tx_len;
+		uint8_t *rx_buf;
+		size_t rx_len;
+		/* Instance-specific RX thread. */
+		struct k_thread rx_thread;
+		K_KERNEL_STACK_MEMBER(rx_stack, CONFIG_ARCH_POSIX_RECOMMENDED_STACK_SIZE);
 	} async;
 #endif /* CONFIG_UART_ASYNC_API */
 };
@@ -65,11 +70,16 @@ static int np_uart_poll_in(const struct device *dev, unsigned char *p_char);
 static int np_uart_init(const struct device *dev);
 
 #ifdef CONFIG_UART_ASYNC_API
+void native_pty_uart_async_poll_function(void *arg1, void *arg2, void *arg3);
+
 static void np_uart_tx_done_work(struct k_work *work);
 static int np_uart_callback_set(const struct device *dev, uart_callback_t callback,
 				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);
 #endif /* CONFIG_UART_ASYNC_API */
 
 static DEVICE_API(uart, np_uart_driver_api) = {
@@ -79,6 +89,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 */
 };
 
@@ -294,6 +307,82 @@ static int np_uart_tx_abort(const struct device *dev)
 	return k_work_cancel_delayable_sync(&data->async.tx_done, &sync) ? 0 : -EFAULT;
 }
 
+/*
+ * Emulate async interrupts using a polling thread
+ */
+void native_pty_uart_async_poll_function(void *arg1, void *arg2, void *arg3)
+{
+	const struct device *dev = arg1;
+	struct native_pty_status *data = dev->data;
+	struct uart_event evt;
+	int rc;
+
+	ARG_UNUSED(arg2);
+	ARG_UNUSED(arg3);
+
+	while (data->async.rx_len) {
+		if (data->async.rx_len > 0) {
+			rc = np_uart_stdin_poll_in_bottom(data->in_fd, data->async.rx_buf, data->async.rx_len);
+			if (rc > 0) {
+				/* Data received */
+				evt.type = UART_RX_RDY;
+				evt.data.rx.buf = data->async.rx_buf;
+				evt.data.rx.offset = 0;
+				evt.data.rx.len = rc;
+				/* User callback */
+				data->async.user_callback(data->async.dev, &evt, data->async.user_data);
+			}
+		}
+		if ((data->async.rx_len == 0) || (rc < 0)) {
+			/* Sleep if RX disabled or last read didn't result in any data */
+			k_sleep(K_MSEC(10));
+		}
+	}
+}
+
+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);
+
+	if (data->async.rx_buf != NULL) {
+		return -EBUSY;
+	}
+
+	data->async.rx_buf = buf;
+	data->async.rx_len = len;
+
+	/* Create a thread which will wait for data - replacement for IRQ */
+	k_thread_create(&data->async.rx_thread, data->async.rx_stack, K_KERNEL_STACK_SIZEOF(data->async.rx_stack),
+			native_pty_uart_async_poll_function,
+			(void *)dev, NULL, NULL,
+			K_HIGHEST_THREAD_PRIO, 0, K_NO_WAIT);
+	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_len = 0;
+	data->async.rx_buf = NULL;
+
+	/* Wait for RX thread to terminate */
+	return k_thread_join(&data->async.rx_thread, K_FOREVER);
+}
+
 #endif /* CONFIG_UART_ASYNC_API */