diff --git a/tests/drivers/uart/uart_mixed_modes/CMakeLists.txt b/tests/drivers/uart/uart_mixed_modes/CMakeLists.txt new file mode 100644 index 000000000000..9a3c36f04a4f --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/CMakeLists.txt @@ -0,0 +1,19 @@ +# +# Copyright (c) 2025 Nordic Semiconductor ASA +# +# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause +# + +cmake_minimum_required(VERSION 3.20.0) + +find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) + +project(uart_mode_to_mode) + +if(CONFIG_ASYNC_AND_INT) + target_sources(app PRIVATE src/common.c src/async_int.c) +elseif(CONFIG_ASYNC_AND_POLL) + target_sources(app PRIVATE src/common.c src/async_poll.c) +else() + target_sources(app PRIVATE src/common.c src/int_poll.c) +endif() diff --git a/tests/drivers/uart/uart_mixed_modes/Kconfig b/tests/drivers/uart/uart_mixed_modes/Kconfig new file mode 100644 index 000000000000..fc3419adf926 --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/Kconfig @@ -0,0 +1,16 @@ +# +# Copyright (c) 2025 Nordic Semiconductor ASA +# +# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause +# + +source "Kconfig.zephyr" + +config ASYNC_AND_INT + bool "Async and int mode uart transmission test" + +config ASYNC_AND_POLL + bool "Async and poll mode uart transmission test" + +config INT_AND_POLL + bool "Int and poll mode uart transmission test" diff --git a/tests/drivers/uart/uart_mixed_modes/boards/nrf54h20dk_nrf54h20_cpuapp.overlay b/tests/drivers/uart/uart_mixed_modes/boards/nrf54h20dk_nrf54h20_cpuapp.overlay new file mode 100644 index 000000000000..684ca4af5a6c --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/boards/nrf54h20dk_nrf54h20_cpuapp.overlay @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +/* + * Required loopbacks: + * P0.08 <-> P0.09 + * P0.06 <-> P0.07 + */ + +&pinctrl { + uart134_default_test: uart134_default_test { + group1 { + psels = ; + bias-pull-up; + }; + + group2 { + psels = ; + }; + }; + + uart134_sleep_test: uart134_sleep_test { + group1 { + psels = , + ; + low-power-enable; + }; + }; + + uart131_default_test: uart131_default_test { + group1 { + psels = ; + bias-pull-up; + }; + + group2 { + psels = ; + }; + }; + + uart131_sleep_test: uart131_sleep_test { + group1 { + psels = , + ; + low-power-enable; + }; + }; +}; + +&cpuapp_dma_region { + status = "okay"; +}; + +dut_uart_a: &uart134 { + compatible = "nordic,nrf-uarte"; + current-speed = <115200>; + status = "okay"; + memory-regions = <&cpuapp_dma_region>; + pinctrl-0 = <&uart134_default_test>; + pinctrl-1 = <&uart134_sleep_test>; + pinctrl-names = "default", "sleep"; + /delete-property/ hw-flow-control; +}; + +dut_uart_b: &uart131 { + compatible = "nordic,nrf-uarte"; + current-speed = <115200>; + status = "okay"; + memory-regions = <&cpuapp_dma_region>; + pinctrl-0 = <&uart131_default_test>; + pinctrl-1 = <&uart131_sleep_test>; + pinctrl-names = "default", "sleep"; + /delete-property/ hw-flow-control; +}; diff --git a/tests/drivers/uart/uart_mixed_modes/boards/nrf54l15dk_nrf54l15_cpuapp.overlay b/tests/drivers/uart/uart_mixed_modes/boards/nrf54l15dk_nrf54l15_cpuapp.overlay new file mode 100644 index 000000000000..2b32338a0aff --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/boards/nrf54l15dk_nrf54l15_cpuapp.overlay @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +/* + * Required loopbacks: + * P1.08 <-> P1.09 + * P1.10 <-> P1.11 + */ + +&pinctrl { + uart21_default: uart21_default { + group1 { + psels = , + ; + bias-pull-up; + }; + }; + + uart21_sleep: uart21_sleep { + group1 { + psels = , + ; + low-power-enable; + }; + }; + + uart22_default: uart22_default { + group1 { + psels = , + ; + bias-pull-up; + }; + }; + + uart22_sleep: uart22_sleep { + group1 { + psels = , + ; + low-power-enable; + }; + }; +}; + +dut_uart_a: &uart21 { + status = "okay"; + current-speed = <115200>; + pinctrl-0 = <&uart21_default>; + pinctrl-1 = <&uart21_sleep>; + pinctrl-names = "default", "sleep"; +}; + +dut_uart_b: &uart22 { + status = "okay"; + current-speed = <115200>; + pinctrl-0 = <&uart22_default>; + pinctrl-1 = <&uart22_sleep>; + pinctrl-names = "default", "sleep"; +}; diff --git a/tests/drivers/uart/uart_mixed_modes/boards/nrf54lm20dk_nrf54lm20a_cpuapp.overlay b/tests/drivers/uart/uart_mixed_modes/boards/nrf54lm20dk_nrf54lm20a_cpuapp.overlay new file mode 100644 index 000000000000..6106a1260381 --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/boards/nrf54lm20dk_nrf54lm20a_cpuapp.overlay @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +/* + * Required loopbacks: + * P1.13 <-> P1.14 + * P1.23 <-> P1.24 + */ + +&pinctrl { + uart21_default: uart21_default { + group1 { + psels = , + ; + bias-pull-up; + }; + }; + + uart21_sleep: uart21_sleep { + group1 { + psels = , + ; + low-power-enable; + }; + }; + + uart22_default: uart22_default { + group1 { + psels = , + ; + bias-pull-up; + }; + }; + + uart22_sleep: uart22_sleep { + group1 { + psels = , + ; + low-power-enable; + }; + }; +}; + +dut_uart_a: &uart21 { + status = "okay"; + current-speed = <115200>; + pinctrl-0 = <&uart21_default>; + pinctrl-1 = <&uart21_sleep>; + pinctrl-names = "default", "sleep"; +}; + +dut_uart_b: &uart22 { + status = "okay"; + current-speed = <115200>; + pinctrl-0 = <&uart22_default>; + pinctrl-1 = <&uart22_sleep>; + pinctrl-names = "default", "sleep"; +}; diff --git a/tests/drivers/uart/uart_mixed_modes/prj.conf b/tests/drivers/uart/uart_mixed_modes/prj.conf new file mode 100644 index 000000000000..6a3ee4d6fe40 --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/prj.conf @@ -0,0 +1,4 @@ +CONFIG_SERIAL=y +CONFIG_UART_USE_RUNTIME_CONFIGURE=y + +CONFIG_ZTEST=y diff --git a/tests/drivers/uart/uart_mixed_modes/src/async_int.c b/tests/drivers/uart/uart_mixed_modes/src/async_int.c new file mode 100644 index 000000000000..ee521c557604 --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/src/async_int.c @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +#include "common.h" + +const struct device *const uart_dev_async_mode = DEVICE_DT_GET(UART_NODE_MODE_A); +const struct device *const uart_dev_int_mode = DEVICE_DT_GET(UART_NODE_MODE_B); + +extern struct k_sem uart_async_mode_rx_ready_sem; +extern struct k_sem uart_interrupt_mode_rx_done_sem; + +extern uint8_t uart_a_tx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_a_rx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_b_tx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_b_rx_test_buffer[BUFFER_SIZE]; + +extern volatile uint32_t tx_byte_offset; +extern volatile uint32_t rx_byte_offset; + +ZTEST(uart_async_int, test_uart_async_int_transmission) +{ + int err, rx_done_async_sem_take_result, rx_done_int_sem_take_result; + uint32_t sleep_time_ms = 0; + uart_test_data uart_async_test_data; + uart_test_data uart_int_test_data; + + tx_byte_offset = 0; + rx_byte_offset = 0; + + uart_async_test_data.tx_buffer = uart_a_tx_test_buffer; + uart_async_test_data.rx_buffer = uart_a_rx_test_buffer; + uart_async_test_data.buffer_size = BUFFER_SIZE; + + uart_int_test_data.tx_buffer = uart_b_tx_test_buffer; + uart_int_test_data.rx_buffer = uart_b_rx_test_buffer; + uart_int_test_data.buffer_size = BUFFER_SIZE; + + set_test_pattern(&uart_async_test_data); + set_test_pattern(&uart_int_test_data); + + TC_PRINT("UART full duplex transmission test: UART (ASYNC) <-> UART (INT)\n"); + + err = uart_callback_set(uart_dev_async_mode, async_uart_callback, NULL); + zassert_equal(err, 0, "ASYNC UART callback setup failed"); + + err = uart_irq_callback_set(uart_dev_int_mode, uart_isr_handler); + zassert_equal(err, 0, "Unexpected error when setting callback for INT UART: %d", err); + err = uart_irq_callback_user_data_set(uart_dev_int_mode, uart_isr_handler, + (void *)&uart_int_test_data); + zassert_equal(err, 0, + "Unexpected error when setting user data for callback for INT UART: %d", err); + + TC_PRINT("Starting transmission\n"); + enable_uart_rx(uart_dev_async_mode, &uart_async_test_data); + uart_irq_rx_enable(uart_dev_int_mode); + + uart_irq_tx_enable(uart_dev_int_mode); + err = uart_tx(uart_dev_async_mode, uart_async_test_data.tx_buffer, BUFFER_SIZE, + UART_TIMEOUT_US); + + TC_PRINT("Waiting for transmission to finish\n"); + while (1) { + rx_done_async_sem_take_result = + k_sem_take(&uart_async_mode_rx_ready_sem, K_NO_WAIT); + rx_done_int_sem_take_result = + k_sem_take(&uart_interrupt_mode_rx_done_sem, K_NO_WAIT); + if ((rx_done_async_sem_take_result + rx_done_int_sem_take_result) == 0) { + TC_PRINT("Full duplex transmission completed\n"); + break; + } + k_msleep(SEM_CHECK_DEAD_TIME_MS); + sleep_time_ms += SEM_CHECK_DEAD_TIME_MS; + zassert_true(sleep_time_ms < TRANSMISSION_TIMEOUT_MS, "Transmission timed out\n"); + } + uart_rx_disable(uart_dev_async_mode); + uart_irq_rx_disable(uart_dev_int_mode); + uart_irq_tx_disable(uart_dev_int_mode); + zassert_mem_equal(uart_async_test_data.rx_buffer, uart_int_test_data.rx_buffer, BUFFER_SIZE, + "UART (ASYNC) RX buffer != UART (INT) RX buffer\n"); +} + +void *test_setup(void) +{ + zassert_true(device_is_ready(uart_dev_async_mode), "UART in ASYNC mode is not ready"); + zassert_true(device_is_ready(uart_dev_int_mode), "UART in INTERRUPT mode is not ready"); + + return NULL; +} + +ZTEST_SUITE(uart_async_int, NULL, test_setup, NULL, NULL, NULL); diff --git a/tests/drivers/uart/uart_mixed_modes/src/async_poll.c b/tests/drivers/uart/uart_mixed_modes/src/async_poll.c new file mode 100644 index 000000000000..8abb0b99647b --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/src/async_poll.c @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +#include "common.h" + +const struct device *const uart_dev_async_mode = DEVICE_DT_GET(UART_NODE_MODE_A); +const struct device *const uart_dev_poll_mode = DEVICE_DT_GET(UART_NODE_MODE_B); + +extern struct k_sem uart_async_mode_rx_ready_sem; + +extern uint8_t uart_a_tx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_a_rx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_b_tx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_b_rx_test_buffer[BUFFER_SIZE]; + +ZTEST(uart_async_poll, test_uart_async_poll_transmission) +{ + int err; + uint32_t sleep_time_ms = 0; + uart_test_data uart_async_test_data; + uart_test_data uart_poll_test_data; + + uart_async_test_data.tx_buffer = uart_a_tx_test_buffer; + uart_async_test_data.rx_buffer = uart_a_rx_test_buffer; + uart_async_test_data.buffer_size = BUFFER_SIZE; + + uart_poll_test_data.tx_buffer = uart_b_tx_test_buffer; + uart_poll_test_data.rx_buffer = uart_b_rx_test_buffer; + uart_poll_test_data.buffer_size = BUFFER_SIZE; + + set_test_pattern(&uart_async_test_data); + set_test_pattern(&uart_poll_test_data); + + TC_PRINT("UART full duplex transmission test: UART (ASYNC) <-> UART (POLL)\n"); + + err = uart_callback_set(uart_dev_async_mode, async_uart_callback, NULL); + zassert_equal(err, 0, "ASYNC UART callback setup failed"); + + TC_PRINT("Starting transmission\n"); + err = uart_tx(uart_dev_async_mode, uart_async_test_data.tx_buffer, BUFFER_SIZE, + UART_TIMEOUT_US); + enable_uart_rx(uart_dev_async_mode, &uart_async_test_data); + + for (uint32_t counter = 0; counter < BUFFER_SIZE; counter++) { + uart_poll_out(uart_dev_poll_mode, uart_poll_test_data.tx_buffer[counter]); + while (uart_poll_in(uart_dev_poll_mode, &uart_poll_test_data.rx_buffer[counter]) == + -1) { + }; + uart_poll_in(uart_dev_poll_mode, &uart_poll_test_data.rx_buffer[counter]); + } + + TC_PRINT("Waiting for transmission to finish\n"); + while (1) { + if (k_sem_take(&uart_async_mode_rx_ready_sem, K_NO_WAIT) == 0) { + break; + } + k_msleep(SEM_CHECK_DEAD_TIME_MS); + sleep_time_ms += SEM_CHECK_DEAD_TIME_MS; + zassert_true(sleep_time_ms < TRANSMISSION_TIMEOUT_MS, "Transmission timed out\n"); + } + + TC_PRINT("Full duplex transmission completed\n"); + uart_rx_disable(uart_dev_async_mode); + zassert_mem_equal(uart_async_test_data.rx_buffer, uart_poll_test_data.rx_buffer, + BUFFER_SIZE, "UART (ASYNC) RX buffer != UART (POLL) RX buffer\n"); +} + +void *test_setup(void) +{ + zassert_true(device_is_ready(uart_dev_async_mode), "UART in ASYNC mode is not ready"); + zassert_true(device_is_ready(uart_dev_poll_mode), "UART in POLLING mode is not ready"); + + return NULL; +} + +ZTEST_SUITE(uart_async_poll, NULL, test_setup, NULL, NULL, NULL); diff --git a/tests/drivers/uart/uart_mixed_modes/src/common.c b/tests/drivers/uart/uart_mixed_modes/src/common.c new file mode 100644 index 000000000000..c28bde33b2ff --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/src/common.c @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +#include "common.h" + +K_SEM_DEFINE(uart_async_mode_rx_ready_sem, 0, 1); +K_SEM_DEFINE(uart_interrupt_mode_rx_done_sem, 0, 1); + +uint8_t uart_a_tx_test_buffer[BUFFER_SIZE]; +uint8_t uart_a_rx_test_buffer[BUFFER_SIZE]; +uint8_t uart_b_tx_test_buffer[BUFFER_SIZE]; +uint8_t uart_b_rx_test_buffer[BUFFER_SIZE]; + +volatile uint32_t tx_byte_offset; +volatile uint32_t rx_byte_offset; + +void set_test_pattern(uart_test_data *test_data) +{ + for (uint32_t counter = 0; counter < test_data->buffer_size; counter++) { + test_data->tx_buffer[counter] = (uint8_t)(counter & 0xFF); + test_data->rx_buffer[counter] = 0xFF; + } +} + +void async_uart_callback(const struct device *dev, struct uart_event *evt, void *user_data) +{ + switch (evt->type) { + case UART_TX_DONE: + k_sem_give(&uart_async_mode_rx_ready_sem); + break; + case UART_TX_ABORTED: + break; + case UART_RX_RDY: + break; + case UART_RX_BUF_RELEASED: + break; + case UART_RX_BUF_REQUEST: + break; + case UART_RX_DISABLED: + break; + default: + break; + } +} + +void enable_uart_rx(const struct device *const uart_dev, uart_test_data *test_data) +{ + int err; + + do { + err = uart_rx_enable(uart_dev, test_data->rx_buffer, test_data->buffer_size, + UART_TIMEOUT_US); + } while (err == -EBUSY); + zassert_equal(err, 0, "Unexpected error when enabling UART RX: %d"); +} + +void uart_tx_interrupt_service(const struct device *dev, uint8_t *test_pattern, size_t buffer_size, + volatile uint32_t *tx_byte_offset) +{ + uint8_t bytes_sent = 0; + uint8_t *tx_data_pointer = (uint8_t *)(test_pattern + *tx_byte_offset); + + if (*tx_byte_offset < buffer_size) { + bytes_sent = uart_fifo_fill(dev, tx_data_pointer, 1); + *tx_byte_offset += bytes_sent; + } else { + *tx_byte_offset = 0; + uart_irq_tx_disable(dev); + } +} + +void uart_rx_interrupt_service(const struct device *dev, uint8_t *receive_buffer_pointer, + size_t buffer_size, volatile uint32_t *rx_byte_offset) +{ + int rx_data_length = 0; + + do { + rx_data_length = + uart_fifo_read(dev, receive_buffer_pointer + *rx_byte_offset, buffer_size); + *rx_byte_offset += rx_data_length; + } while (rx_data_length); + if (*rx_byte_offset >= buffer_size) { + *rx_byte_offset = 0; + k_sem_give(&uart_interrupt_mode_rx_done_sem); + uart_irq_rx_disable(dev); + } +} + +void uart_isr_handler(const struct device *dev, void *user_data) +{ + uart_test_data *test_data = (uart_test_data *)user_data; + + uart_irq_update(dev); + while (uart_irq_is_pending(dev)) { + if (uart_irq_rx_ready(dev)) { + uart_rx_interrupt_service(dev, test_data->rx_buffer, test_data->buffer_size, + &rx_byte_offset); + } + if (uart_irq_tx_ready(dev)) { + uart_tx_interrupt_service(dev, test_data->tx_buffer, test_data->buffer_size, + &tx_byte_offset); + } + } +} diff --git a/tests/drivers/uart/uart_mixed_modes/src/common.h b/tests/drivers/uart/uart_mixed_modes/src/common.h new file mode 100644 index 000000000000..939418bc5138 --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/src/common.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +#include +#include +#include + +#define UART_NODE_MODE_A DT_NODELABEL(dut_uart_a) +#define UART_NODE_MODE_B DT_NODELABEL(dut_uart_b) + +#define BUFFER_SIZE 256 +#define UART_TIMEOUT_US 1000000 +#define SEM_CHECK_DEAD_TIME_MS 10 +#define TRANSMISSION_TIMEOUT_MS 2000 + +typedef struct { + uint8_t *tx_buffer; + uint8_t *rx_buffer; + size_t buffer_size; + +} uart_test_data; + +void set_test_pattern(uart_test_data *test_data); + +void async_uart_callback(const struct device *dev, struct uart_event *evt, void *user_data); + +void enable_uart_rx(const struct device *const uart_dev, uart_test_data *test_data); + +void uart_tx_interrupt_service(const struct device *dev, uint8_t *test_pattern, size_t buffer_size, + volatile uint32_t *tx_byte_offset); + +void uart_rx_interrupt_service(const struct device *dev, uint8_t *receive_buffer_pointer, + size_t buffer_size, volatile uint32_t *rx_byte_offset); + +void uart_isr_handler(const struct device *dev, void *user_data); diff --git a/tests/drivers/uart/uart_mixed_modes/src/int_poll.c b/tests/drivers/uart/uart_mixed_modes/src/int_poll.c new file mode 100644 index 000000000000..f720fa229b6e --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/src/int_poll.c @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +#include "common.h" + +const struct device *const uart_dev_int_mode = DEVICE_DT_GET(UART_NODE_MODE_A); +const struct device *const uart_dev_poll_mode = DEVICE_DT_GET(UART_NODE_MODE_B); + +extern struct k_sem uart_interrupt_mode_rx_done_sem; + +extern uint8_t uart_a_tx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_a_rx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_b_tx_test_buffer[BUFFER_SIZE]; +extern uint8_t uart_b_rx_test_buffer[BUFFER_SIZE]; + +extern volatile uint32_t tx_byte_offset; +extern volatile uint32_t rx_byte_offset; + +ZTEST(uart_int_poll, test_uart_int_poll_transmission) +{ + int err; + uint32_t sleep_time_ms = 0; + uart_test_data uart_int_test_data; + uart_test_data uart_poll_test_data; + + tx_byte_offset = 0; + rx_byte_offset = 0; + + uart_int_test_data.tx_buffer = uart_a_tx_test_buffer; + uart_int_test_data.rx_buffer = uart_a_rx_test_buffer; + uart_int_test_data.buffer_size = BUFFER_SIZE; + + uart_poll_test_data.tx_buffer = uart_b_tx_test_buffer; + uart_poll_test_data.rx_buffer = uart_b_rx_test_buffer; + uart_poll_test_data.buffer_size = BUFFER_SIZE; + + set_test_pattern(&uart_int_test_data); + set_test_pattern(&uart_poll_test_data); + + TC_PRINT("UART full duplex transmission test: UART (INT) <-> UART (POLL)\n"); + + err = uart_irq_callback_set(uart_dev_int_mode, uart_isr_handler); + zassert_equal(err, 0, "Unexpected error when setting callback for INT UART: %d", err); + err = uart_irq_callback_user_data_set(uart_dev_int_mode, uart_isr_handler, + (void *)&uart_int_test_data); + zassert_equal(err, 0, + "Unexpected error when setting user data for callback for INT UART: %d", err); + + TC_PRINT("Starting transmission\n"); + uart_irq_rx_enable(uart_dev_int_mode); + uart_irq_tx_enable(uart_dev_int_mode); + + for (uint32_t counter = 0; counter < BUFFER_SIZE; counter++) { + uart_poll_out(uart_dev_poll_mode, uart_poll_test_data.tx_buffer[counter]); + while (uart_poll_in(uart_dev_poll_mode, &uart_poll_test_data.rx_buffer[counter]) == + -1) { + }; + uart_poll_in(uart_dev_poll_mode, &uart_poll_test_data.rx_buffer[counter]); + } + + TC_PRINT("Waiting for transmission to finish\n"); + while (1) { + if (k_sem_take(&uart_interrupt_mode_rx_done_sem, K_NO_WAIT) == 0) { + break; + } + k_msleep(SEM_CHECK_DEAD_TIME_MS); + sleep_time_ms += SEM_CHECK_DEAD_TIME_MS; + zassert_true(sleep_time_ms < TRANSMISSION_TIMEOUT_MS, "Transmission timed out\n"); + } + + TC_PRINT("Full duplex transmission completed\n"); + uart_irq_rx_disable(uart_dev_int_mode); + uart_irq_tx_disable(uart_dev_int_mode); + zassert_mem_equal(uart_int_test_data.rx_buffer, uart_poll_test_data.rx_buffer, BUFFER_SIZE, + "UART (INT) RX buffer != UART (POLL) RX buffer\n"); +} + +void *test_setup(void) +{ + zassert_true(device_is_ready(uart_dev_int_mode), "UART in INTERRUPT mode is not ready"); + zassert_true(device_is_ready(uart_dev_poll_mode), "UART in POLLING mode is not ready"); + + return NULL; +} + +ZTEST_SUITE(uart_int_poll, NULL, test_setup, NULL, NULL, NULL); diff --git a/tests/drivers/uart/uart_mixed_modes/testcase.yaml b/tests/drivers/uart/uart_mixed_modes/testcase.yaml new file mode 100644 index 000000000000..6d66abb94b3c --- /dev/null +++ b/tests/drivers/uart/uart_mixed_modes/testcase.yaml @@ -0,0 +1,92 @@ +common: + sysbuild: true + depends_on: gpio + tags: + - drivers + - uart + - ci_tests_drivers_uart + harness_config: + fixture: gpio_loopback + +tests: + drivers.uart.async_int.nrf54h: + platform_allow: + - nrf54h20dk/nrf54h20/cpuapp + integration_platforms: + - nrf54h20dk/nrf54h20/cpuapp + extra_args: + - CONFIG_ASYNC_AND_INT=y + - CONFIG_UART_ASYNC_API=y + - CONFIG_UART_INTERRUPT_DRIVEN=y + - CONFIG_UART_134_INTERRUPT_DRIVEN=n + - CONFIG_UART_134_ASYNC=y + - CONFIG_UART_131_INTERRUPT_DRIVEN=y + - CONFIG_UART_131_ASYNC=n + + drivers.uart.async_poll.nrf54h: + platform_allow: + - nrf54h20dk/nrf54h20/cpuapp + integration_platforms: + - nrf54h20dk/nrf54h20/cpuapp + extra_args: + - CONFIG_ASYNC_AND_POLL=y + - CONFIG_UART_ASYNC_API=y + - CONFIG_UART_INTERRUPT_DRIVEN=n + - CONFIG_UART_134_ASYNC=y + - CONFIG_UART_131_ASYNC=n + + drivers.uart.int_poll.nrf54h: + platform_allow: + - nrf54h20dk/nrf54h20/cpuapp + integration_platforms: + - nrf54h20dk/nrf54h20/cpuapp + extra_args: + - CONFIG_INT_AND_POLL=y + - CONFIG_UART_ASYNC_API=n + - CONFIG_UART_INTERRUPT_DRIVEN=y + - CONFIG_UART_134_INTERRUPT_DRIVEN=y + - CONFIG_UART_131_INTERRUPT_DRIVEN=n + + drivers.uart.async_int.nrf54l: + platform_allow: + - nrf54l15dk/nrf54l15/cpuapp + - nrf54lm20dk/nrf54lm20a/cpuapp + integration_platforms: + - nrf54l15dk/nrf54l15/cpuapp + - nrf54lm20dk/nrf54lm20a/cpuapp + extra_args: + - CONFIG_ASYNC_AND_INT=y + - CONFIG_UART_ASYNC_API=y + - CONFIG_UART_INTERRUPT_DRIVEN=y + - CONFIG_UART_21_INTERRUPT_DRIVEN=n + - CONFIG_UART_21_ASYNC=y + - CONFIG_UART_22_INTERRUPT_DRIVEN=y + - CONFIG_UART_22_ASYNC=n + + drivers.uart.async_poll.nrf54l: + platform_allow: + - nrf54l15dk/nrf54l15/cpuapp + - nrf54lm20dk/nrf54lm20a/cpuapp + integration_platforms: + - nrf54l15dk/nrf54l15/cpuapp + - nrf54lm20dk/nrf54lm20a/cpuapp + extra_args: + - CONFIG_ASYNC_AND_POLL=y + - CONFIG_UART_ASYNC_API=y + - CONFIG_UART_INTERRUPT_DRIVEN=n + - CONFIG_UART_21_ASYNC=y + - CONFIG_UART_22_ASYNC=n + + drivers.uart.int_poll.nrf54l: + platform_allow: + - nrf54l15dk/nrf54l15/cpuapp + - nrf54lm20dk/nrf54lm20a/cpuapp + integration_platforms: + - nrf54l15dk/nrf54l15/cpuapp + - nrf54lm20dk/nrf54lm20a/cpuapp + extra_args: + - CONFIG_INT_AND_POLL=y + - CONFIG_UART_ASYNC_API=n + - CONFIG_UART_INTERRUPT_DRIVEN=y + - CONFIG_UART_21_INTERRUPT_DRIVEN=y + - CONFIG_UART_22_INTERRUPT_DRIVEN=n