diff --git a/CODEOWNERS b/CODEOWNERS index 5082abdc0a1e..cd88bcaedd92 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -858,6 +858,7 @@ /tests/drivers/lpuart/ @nordic-krch @nrfconnect/ncs-low-level-test /tests/drivers/mspi/app_fault_timer/ @nrfconnect/ncs-low-level-test @nrfconnect/ncs-ll-ursus /tests/drivers/mspi/trap_handler/ @nrfconnect/ncs-low-level-test @nrfconnect/ncs-ll-ursus +/tests/drivers/nrf_wifi/ @sachinthegreen @krish2718 /tests/drivers/nrfx_integration_test/ @nrfconnect/ncs-co-drivers /tests/drivers/pwm/gpio_loopback/ @nrfconnect/ncs-low-level-test /tests/drivers/uart/ @nrfconnect/ncs-low-level-test diff --git a/boards/nordic/nrf7120pdk/nrf7120pdk_nrf7120_cpuapp.yaml b/boards/nordic/nrf7120pdk/nrf7120pdk_nrf7120_cpuapp.yaml index 3286d9842b8a..fb0ea403bebd 100644 --- a/boards/nordic/nrf7120pdk/nrf7120pdk_nrf7120_cpuapp.yaml +++ b/boards/nordic/nrf7120pdk/nrf7120pdk_nrf7120_cpuapp.yaml @@ -21,3 +21,4 @@ supported: - spi - watchdog - i2s + - wifi diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/CMakeLists.txt b/tests/drivers/nrf_wifi/raw_tx_rx/CMakeLists.txt new file mode 100644 index 000000000000..9a29839a95be --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/CMakeLists.txt @@ -0,0 +1,8 @@ +# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + +cmake_minimum_required(VERSION 3.20.0) +find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE}) +project(nrf_wifi_tx_rx) + +FILE(GLOB app_sources src/*.c) +target_sources(app PRIVATE ${app_sources}) diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/Kconfig b/tests/drivers/nrf_wifi/raw_tx_rx/Kconfig new file mode 100644 index 000000000000..c091387135af --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/Kconfig @@ -0,0 +1,58 @@ +# +# Copyright (c) 2025 Nordic Semiconductor ASA +# +# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause +# +source "Kconfig.zephyr" + +config NRF_WIFI_RAW_TX_PKT_SAMPLE_CHANNEL + int "Channel for non-connected Station mode" + range 1 233 + help + Specify the Wi-Fi channel for transmitting raw TX packets in non-connected Station mode. + The valid channel range is 1 to 233. + +config NRF_WIFI_RAW_RX_PKT_TIMEOUT_S + int "Wi-Fi raw RX packet timeout in seconds" + default 5000 + +config RAW_TX_PKT_SAMPLE_RATE_VALUE + int "MCS index or Data rate value" + default 0 + help + Specify the Wi-Fi data rate value for raw TX packet transmission. + The value represents either the data rate in Mbps or Modulation and coding (MCS) index. + Note: 5.5Mbps is treated specially as 55 to avoid floating point usage. + Legacy: 1, 2, 55, 11, 6, 9, 12, 18, 24, 36, 48, 54 + MCS index: 0-7 + +config RAW_TX_PKT_SAMPLE_RATE_FLAGS + int "Rate flag value" + range 0 4 + default 1 + help + Specify the rate flag value to be used for raw TX packet transmission. + Rate Flags: + 0 - Legacy + 1 - 11n format + 2 - VHT format + 3 - HE_SU + 4 - HE_ER_SU + +config RAW_TX_PKT_SAMPLE_QUEUE_NUM + int "Queue number" + default 0 + range 0 4 + help + Specify the transmission queue number for raw TX packets. + 0 - Background + 1 - Best effort + 2 - Video + 3 - Voice + 4 - Beacon. + +config RX_THREAD_STACK_SIZE + int "Thread Stack Size" + default 4096 + help + This option sets the stack size for the threads used in the sample. diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/ipc.overlay b/tests/drivers/nrf_wifi/raw_tx_rx/ipc.overlay new file mode 100644 index 000000000000..f63c964d54d3 --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/ipc.overlay @@ -0,0 +1,92 @@ +/ { + chosen { + zephyr,shell-uart = &uart20; + }; + + ipc_shm_area_cpuapp_cpuuma: memory@200C0000 { + compatible = "mmio-sram"; + reg = <0x200C0000 0x2000>; + ranges = <0x0 0x200C0000 0x2000>; + #address-cells = <1>; + #size-cells = <1>; + status = "okay"; + + ipc_shm_cpuapp_cpuuma_0: memory@0 { + reg = <0x0 DT_SIZE_K(2)>; + }; + + ipc_shm_cpuuma_cpuapp_0: memory@800 { + reg = <0x800 DT_SIZE_K(2)>; + }; + + ipc_shm_cpuapp_cpuuma_1: memory@1000 { + reg = <0x1000 DT_SIZE_K(2)>; + }; + + ipc_shm_cpuuma_cpuapp_1: memory@1800 { + reg = <0x1800 DT_SIZE_K(2)>; + }; + }; + + ipc { + ipc0: ipc0 { + compatible = "zephyr,ipc-icmsg"; + // TODO: Need shared memory between APP-WIFI + tx-region = <&ipc_shm_cpuapp_cpuuma_0>; + // TODO: Need shared memory between APP-WIFI + rx-region = <&ipc_shm_cpuuma_cpuapp_0>; + mboxes = <&wifi_bellboard 2>, + <&cpuapp_bellboard 0>; + mbox-names = "tx", "rx"; + status = "okay"; + }; + + ipc1: ipc1 { + compatible = "zephyr,ipc-icmsg"; + // TODO: Need shared memory between APP-WIFI + tx-region = <&ipc_shm_cpuapp_cpuuma_1>; + // TODO: Need shared memory between APP-WIFI + rx-region = <&ipc_shm_cpuuma_cpuapp_1>; + mboxes = <&wifi_bellboard 3>, + <&cpuapp_bellboard 1>; + mbox-names = "tx", "rx"; + status = "okay"; + }; + }; +}; + +&cpuapp_bellboard { + status = "okay"; +}; + +&wifi_bellboard { + status = "okay"; +}; + +&uart20 { + status = "okay"; +}; + +&grtc { + status = "okay"; +}; + +&systick { + status = "disabled"; +}; + +&psa_rng { + status = "okay"; +}; + +&uicr { + status = "disabled"; +}; + +&clock { + status = "disabled"; +}; + +&cpuapp_sram { + status = "okay"; +}; diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/overlay-nrf71-tlm.conf b/tests/drivers/nrf_wifi/raw_tx_rx/overlay-nrf71-tlm.conf new file mode 100644 index 000000000000..4a94f8438224 --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/overlay-nrf71-tlm.conf @@ -0,0 +1,5 @@ +# For nRF71 TLM +CONFIG_UART_CONSOLE=y +CONFIG_CONSOLE=y +CONFIG_SERIAL=y +CONFIG_DEBUG_OPTIMIZATIONS=y diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/prj.conf b/tests/drivers/nrf_wifi/raw_tx_rx/prj.conf new file mode 100644 index 000000000000..2a5729150682 --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/prj.conf @@ -0,0 +1,65 @@ +# Copyright (c) 2025 Nordic Semiconductor ASA +# +# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause +# +CONFIG_ZTEST=y +CONFIG_ENTROPY_GENERATOR=y +CONFIG_WIFI=y +CONFIG_TEST_RANDOM_GENERATOR=y +# Doesn't gel with Raw modes +CONFIG_NRF_WIFI_LOW_POWER=n +# Raw TX injection +CONFIG_NRF70_RAW_DATA_TX=y +# Enable raw data RX for nRF700x for monitor mode +CONFIG_NRF70_RAW_DATA_RX=y + +# WPA supplicant (primairly for driver build dependency) +CONFIG_WIFI_NM_WPA_SUPPLICANT=y + +# Networking +CONFIG_NETWORKING=y +CONFIG_NET_SOCKETS=y +CONFIG_NET_LOG=y +CONFIG_NET_IPV4=y +CONFIG_NET_UDP=y +CONFIG_NET_TCP=y + +CONFIG_NET_PKT_RX_COUNT=60 +CONFIG_NET_PKT_TX_COUNT=3 +# Below section is the primary contributor to SRAM and is currently +# tuned for performance, but this will be revisited in the future. +CONFIG_NET_BUF_RX_COUNT=60 +CONFIG_NET_BUF_TX_COUNT=6 +CONFIG_HEAP_MEM_POOL_SIZE=230000 +CONFIG_NET_TC_TX_COUNT=1 + +CONFIG_INIT_STACKS=y + +CONFIG_NET_L2_ETHERNET=y +CONFIG_NET_L2_ETHERNET_MGMT=y + +CONFIG_NET_SOCKETS_POLL_MAX=10 +# Memories +CONFIG_MAIN_STACK_SIZE=5400 +CONFIG_NET_TX_STACK_SIZE=4096 +CONFIG_NET_RX_STACK_SIZE=4096 + +# Logging +CONFIG_LOG=y +CONFIG_LOG_MODE_IMMEDIATE=y +CONFIG_POSIX_CLOCK=y +CONFIG_POSIX_API=y + +# printing of scan results puts pressure on queues in new locking +# design in net_mgmt. So, use a higher timeout for a crowded +# environment. +CONFIG_NET_MGMT_EVENT_QUEUE_TIMEOUT=5000 + +CONFIG_POSIX_API=y +CONFIG_NET_CONTEXT_RCVTIMEO=y +CONFIG_NET_MGMT=y +CONFIG_NET_MGMT_EVENT=y +CONFIG_IPC_SERVICE_BACKEND_ICMSG_WQ_ENABLE=y +CONFIG_IPC_SERVICE_BACKEND_ICMSG_WQ_STACK_SIZE=5600 +CONFIG_ZTEST_STACK_SIZE=5600 +CONFIG_NET_SOCKETS_LOG_LEVEL_DBG=y diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/src/main.c b/tests/drivers/nrf_wifi/raw_tx_rx/src/main.c new file mode 100644 index 000000000000..0c5f2e4a619d --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/src/main.c @@ -0,0 +1,323 @@ +/* main.c - Application main entry point */ + +/* + * Copyright (c) 2025 Nordic Semiconductor ASA + * + * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause + */ + +#define NET_LOG_LEVEL CONFIG_NET_L2_ETHERNET_LOG_LEVEL + +#include +LOG_MODULE_REGISTER(net_test, NET_LOG_LEVEL); + +#include +#include +#include +#include + +#include + +#define BEACON_PAYLOAD_LENGTH 256 +#define CONTINUOUS_MODE_TRANSMISSION 0 +#define FIXED_MODE_TRANSMISSION 1 + +#define IEEE80211_SEQ_CTRL_SEQ_NUM_MASK 0xFFF0 +#define IEEE80211_SEQ_NUMBER_INC BIT(4) /* 0-3 is fragment number */ +#define NRF_WIFI_MAGIC_NUM_RAWTX 0x12345678 + +int raw_socket_fd; + +#define RECV_BUFFER_SIZE 1024 +#define RAW_PKT_DATA_OFFSET 6 + +struct packet_data { + char recv_buffer[RECV_BUFFER_SIZE]; +}; + +struct packet_data test_packet; +#define STACK_SIZE CONFIG_RX_THREAD_STACK_SIZE +#define THREAD_PRIORITY K_PRIO_COOP(CONFIG_NUM_COOP_PRIORITIES - 1) +struct sockaddr_ll sa; + +static void rx_thread_oneshot(void); + +K_THREAD_DEFINE(receiver_thread_id, STACK_SIZE, rx_thread_oneshot, NULL, NULL, NULL, + THREAD_PRIORITY, 0, -1); + +struct beacon { + uint16_t frame_control; + uint16_t duration; + uint8_t da[6]; + uint8_t sa[6]; + uint8_t bssid[6]; + uint16_t seq_ctrl; + uint8_t payload[BEACON_PAYLOAD_LENGTH]; +} __packed; + +static struct beacon test_beacon_frame = { + .frame_control = htons(0X8000), + .duration = 0X0000, + .da = {0XFF, 0XFF, 0XFF, 0XFF, 0XFF, 0XFF}, + /* Transmitter Address: A0:69:60:E3:52:15 */ + .sa = {0XA0, 0X69, 0X60, 0XE3, 0X52, 0X15}, + .bssid = {0XA0, 0X69, 0X60, 0XE3, 0X52, 0X15}, + .seq_ctrl = 0X0001, + /* SSID: NRF_RAW_TX_PACKET_APP */ + .payload = { + 0X0C, 0XA2, 0X28, 0X00, 0X00, 0X00, 0X00, 0X00, 0X64, 0X00, 0X11, 0X04, 0X00, 0X15, + 0X4E, 0X52, 0X46, 0X5F, 0X52, 0X41, 0X57, 0X5F, 0X54, 0X58, 0X5F, 0X50, 0X41, 0X43, + 0X4B, 0X45, 0X54, 0X5F, 0X41, 0X50, 0X50, 0X01, 0X08, 0X82, 0X84, 0X8B, 0X96, 0X0C, + 0X12, 0X18, 0X24, 0X03, 0X01, 0X06, 0X05, 0X04, 0X00, 0X02, 0X00, 0X00, 0X2A, 0X01, + 0X04, 0X32, 0X04, 0X30, 0X48, 0X60, 0X6C, 0X30, 0X14, 0X01, 0X00, 0X00, 0X0F, 0XAC, + 0X04, 0X01, 0X00, 0X00, 0X0F, 0XAC, 0X04, 0X01, 0X00, 0X00, 0X0F, 0XAC, 0X02, 0X0C, + 0X00, 0X3B, 0X02, 0X51, 0X00, 0X2D, 0X1A, 0X0C, 0X00, 0X17, 0XFF, 0XFF, 0X00, 0X00, + 0X00, 0X00, 0X00, 0X00, 0X00, 0X2C, 0X01, 0X01, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, + 0X00, 0X00, 0X00, 0X3D, 0X16, 0X06, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, + 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X00, 0X7F, 0X08, 0X04, 0X00, + 0X00, 0X02, 0X00, 0X00, 0X00, 0X40, 0XFF, 0X1A, 0X23, 0X01, 0X78, 0X10, 0X1A, 0X00, + 0X00, 0X00, 0X20, 0X0E, 0X09, 0X00, 0X09, 0X80, 0X04, 0X01, 0XC4, 0X00, 0XFA, 0XFF, + 0XFA, 0XFF, 0X61, 0X1C, 0XC7, 0X71, 0XFF, 0X07, 0X24, 0XF0, 0X3F, 0X00, 0X81, 0XFC, + 0XFF, 0XDD, 0X18, 0X00, 0X50, 0XF2, 0X02, 0X01, 0X01, 0X01, 0X00, 0X03, 0XA4, 0X00, + 0X00, 0X27, 0XA4, 0X00, 0X00, 0X42, 0X43, 0X5E, 0X00, 0X62, 0X32, 0X2F, 0X00}}; + +/* TODO: Copied from nRF70 Wi-Fi driver, need to be moved to a common place */ +struct raw_tx_pkt_header { + unsigned int magic_num; + unsigned char data_rate; + unsigned short packet_length; + unsigned char tx_mode; + unsigned char queue; + unsigned char raw_tx_flag; +}; + +static void wifi_set_mode(int mode_val) +{ + int ret; + struct net_if *iface = NULL; + struct wifi_mode_info mode_info = {0}; + + mode_info.oper = WIFI_MGMT_SET; + + iface = net_if_get_first_wifi(); + if (iface == NULL) { + LOG_ERR("Failed to get Wi-Fi iface"); + return; + } + + mode_info.if_index = net_if_get_by_iface(iface); + mode_info.mode = mode_val; + + ret = net_mgmt(NET_REQUEST_WIFI_MODE, iface, &mode_info, sizeof(mode_info)); + if (ret) { + LOG_ERR("Mode setting failed %d", ret); + } +} + +static int wifi_set_tx_injection_mode(void) +{ + struct net_if *iface; + + iface = net_if_get_first_wifi(); + if (!iface) { + LOG_ERR("Failed to get Wi-Fi iface"); + return -1; + } + + if (net_eth_txinjection_mode(iface, true)) { + LOG_ERR("TX Injection mode enable failed"); + return -1; + } + + LOG_INF("TX Injection mode enabled"); + return 0; +} + +static int wifi_set_channel(void) +{ + struct net_if *iface; + struct wifi_channel_info channel_info = {0}; + int ret; + + channel_info.oper = WIFI_MGMT_SET; + + iface = net_if_get_first_wifi(); + if (iface == NULL) { + LOG_ERR("Failed to get Wi-Fi iface"); + return -1; + } + + channel_info.if_index = net_if_get_by_iface(iface); + channel_info.channel = CONFIG_NRF_WIFI_RAW_TX_PKT_SAMPLE_CHANNEL; + if ((channel_info.channel < WIFI_CHANNEL_MIN) || + (channel_info.channel > WIFI_CHANNEL_MAX)) { + LOG_ERR("Invalid channel number. Range is (1-233)"); + return -1; + } + + ret = net_mgmt(NET_REQUEST_WIFI_CHANNEL, iface, &channel_info, sizeof(channel_info)); + if (ret) { + LOG_ERR(" Channel setting failed %d\n", ret); + return -1; + } + + LOG_INF("Wi-Fi channel set to %d", channel_info.channel); + return 0; +} + +static int setup_raw_pkt_socket(struct sockaddr_ll *sa) +{ + struct net_if *iface = NULL; + int ret; + + raw_socket_fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); + if (raw_socket_fd < 0) { + LOG_ERR("Unable to create a socket %d", errno); + return -1; + } + + iface = net_if_get_first_wifi(); + if (!iface) { + LOG_ERR("Failed to get Wi-Fi interface"); + return -1; + } + + sa->sll_family = AF_PACKET; + sa->sll_ifindex = net_if_get_by_iface(iface); + + /* Bind the socket */ + ret = bind(raw_socket_fd, (struct sockaddr *)sa, sizeof(struct sockaddr_ll)); + if (ret < 0) { + LOG_ERR("Error: Unable to bind socket to the network interface:%s", + strerror(errno)); + return -1; + } + + return 0; +} + +static void fill_raw_tx_pkt_hdr(struct raw_tx_pkt_header *raw_tx_pkt) +{ + /* Raw Tx Packet header */ + raw_tx_pkt->magic_num = NRF_WIFI_MAGIC_NUM_RAWTX; + raw_tx_pkt->data_rate = CONFIG_RAW_TX_PKT_SAMPLE_RATE_VALUE; + raw_tx_pkt->packet_length = sizeof(test_beacon_frame); + raw_tx_pkt->tx_mode = CONFIG_RAW_TX_PKT_SAMPLE_RATE_FLAGS; + raw_tx_pkt->queue = CONFIG_RAW_TX_PKT_SAMPLE_QUEUE_NUM; + /* The byte is reserved and used by the driver */ + raw_tx_pkt->raw_tx_flag = 0; +} + +int wifi_send_raw_tx_pkt(int sockfd, char *test_frame, size_t buf_length, struct sockaddr_ll *sa) +{ + return sendto(sockfd, test_frame, buf_length, 0, (struct sockaddr *)sa, sizeof(*sa)); +} + +static int wifi_send_single_raw_tx_packet(int sockfd, char *test_frame, size_t buf_length, + struct sockaddr_ll *sa) +{ + int ret; + + memcpy(test_frame + sizeof(struct raw_tx_pkt_header), &test_beacon_frame, + sizeof(test_beacon_frame)); + ret = wifi_send_raw_tx_pkt(sockfd, test_frame, buf_length, sa); + if (ret < 0) { + LOG_ERR("Unable to send beacon frame: %s", strerror(errno)); + return -1; + } + + return 0; +} + +static int wifi_send_raw_tx_packets(unsigned int num_pkts) +{ + int ret; + struct raw_tx_pkt_header packet; + char *test_frame = NULL; + unsigned int buf_length; + + ARG_UNUSED(num_pkts); + + fill_raw_tx_pkt_hdr(&packet); + + test_frame = malloc(sizeof(struct raw_tx_pkt_header) + sizeof(test_beacon_frame)); + if (!test_frame) { + LOG_ERR("Malloc failed for send buffer %d", errno); + return -1; + } + + buf_length = sizeof(struct raw_tx_pkt_header) + sizeof(test_beacon_frame); + memcpy(test_frame, &packet, sizeof(struct raw_tx_pkt_header)); + + ret = wifi_send_single_raw_tx_packet(raw_socket_fd, test_frame, buf_length, &sa); + if (ret < 0) { + LOG_ERR("Failed to send raw tx packets"); + } + + free(test_frame); + return ret; +} + +static int process_single_rx_packet(struct packet_data *packet) +{ + int received; + + LOG_INF("Wi-Fi monitor mode RX thread started"); + + received = recv(raw_socket_fd, packet->recv_buffer, sizeof(packet->recv_buffer), 0); + if (received <= 0) { + if (errno == EAGAIN) { + return 0; + } + + if (received < 0) { + LOG_ERR("Monitor : recv error %s", strerror(errno)); + return -errno; + } + } + + return 0; +} + +/* handle incoming wifi packets in monitor mode */ +static void rx_thread_oneshot(void) +{ + int ret; + struct timeval timeo_optval = { + .tv_sec = 1, + .tv_usec = 0, + }; + + ret = setsockopt(raw_socket_fd, SOL_SOCKET, SO_RCVTIMEO, &timeo_optval, + sizeof(timeo_optval)); + if (ret < 0) { + LOG_ERR("Failed to set socket options : %s", strerror(errno)); + return; + } + + process_single_rx_packet(&test_packet); +} + +ZTEST(nrf_wifi, test_single_raw_tx_rx) +{ + /* MONITOR mode */ + int mode = BIT(1); + + wifi_set_mode(mode); + zassert_false(wifi_set_tx_injection_mode(), "Failed to set TX injection mode"); + zassert_equal(wifi_set_channel(), 0, "Failed to set channel"); + zassert_false(setup_raw_pkt_socket(&sa), "Setting socket for raw pkt transmission failed"); + k_thread_start(receiver_thread_id); + /* TODO: Wait for interface to be operationally UP */ + k_sleep(K_MSEC(50)); + zassert_false(wifi_send_raw_tx_packets(1), "Failed to send raw tx packets"); + zassert_not_equal( + k_thread_join(receiver_thread_id, K_SECONDS(CONFIG_NRF_WIFI_RAW_RX_PKT_TIMEOUT_S)), + 0, "Thread join failed/timedout"); + zassert_mem_equal(&test_beacon_frame, &test_packet.recv_buffer[RAW_PKT_DATA_OFFSET], + sizeof(test_beacon_frame), "Mismatch in sent and received data"); + + close(raw_socket_fd); +} + +ZTEST_SUITE(nrf_wifi, NULL, NULL, NULL, NULL, NULL); diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/sysbuild.conf b/tests/drivers/nrf_wifi/raw_tx_rx/sysbuild.conf new file mode 100644 index 000000000000..3e6d50cb0134 --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/sysbuild.conf @@ -0,0 +1,8 @@ +# +# Copyright (c) 2025 Nordic Semiconductor ASA +# +# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause +# + +SB_CONFIG_WIFI_NRF70=y +SB_CONFIG_WIFI_NRF70_SYSTEM_WITH_RAW_MODES=y diff --git a/tests/drivers/nrf_wifi/raw_tx_rx/testcase.yaml b/tests/drivers/nrf_wifi/raw_tx_rx/testcase.yaml new file mode 100644 index 000000000000..c3bffcc53070 --- /dev/null +++ b/tests/drivers/nrf_wifi/raw_tx_rx/testcase.yaml @@ -0,0 +1,17 @@ +common: + depends_on: wifi + tags: + - ci_build + - sysbuild + - drivers + - ci_tests_drivers_nrf_wifi +tests: + sample.nrf7120.raw_tx_rx_packet.tlm: + sysbuild: true + build_only: true + integration_platforms: + - nrf7120pdk/nrf7120/cpuapp + platform_allow: nrf7120pdk/nrf7120/cpuapp + extra_args: + - EXTRA_DTC_OVERLAY_FILE="ipc.overlay" + - EXTRA_CONF_FILE="overlay-nrf71-tlm.conf"