From d377706d6d7ca548047be56159238b3ee3b66541 Mon Sep 17 00:00:00 2001
From: Chaitanya Tata <Chaitanya.Tata@nordicsemi.no>
Date: Mon, 2 Dec 2024 22:03:54 +0530
Subject: [PATCH] samples: wifi: radio_test: Add a single domain combo radio
 test

With the introduction of 54L15 SoC where the complete BLE stack runs on
the CPUAPP itself, reorg the radio test directories based on domains.
Single domain radio test is primarily for 54L15 (and other similar
SoCs) which basically combines Wi-Fi and Peripheral radio test samples
in to one.

Signed-off-by: Chaitanya Tata <Chaitanya.Tata@nordicsemi.no>
---
 .../{ => multi_domain}/CMakeLists.txt         |    0
 .../{ => multi_domain}/Kconfig.sysbuild       |    0
 .../radio_test/{ => multi_domain}/README.rst  |    0
 .../boards/thingy91x_nrf9151_ns.overlay       |    0
 .../radio_test/{ => multi_domain}/ficr.rst    |    0
 .../inc/nrf_wifi_radio_test_shell.h           |    0
 .../radio_test/{ => multi_domain}/prj.conf    |    0
 .../radio_test_subcommands.rst                |    0
 .../radio_test/{ => multi_domain}/sample.yaml |    4 +-
 .../{ => multi_domain}/sample_description.rst |    0
 .../{ => multi_domain}/src/ficr_prog.c        |    0
 .../{ => multi_domain}/src/ficr_prog.h        |    0
 .../src/nrf_wifi_radio_ficr_shell.c           |    0
 .../src/nrf_wifi_radio_test_main.c            |    0
 .../src/nrf_wifi_radio_test_shell.c           |    0
 .../{ => multi_domain}/sysbuild.conf          |    0
 .../radio_test/single_domain/CMakeLists.txt   |   23 +
 samples/wifi/radio_test/single_domain/Kconfig |   27 +
 .../wifi/radio_test/single_domain/README.rst  |   20 +
 .../boards/nrf54l15dk_nrf54l15_cpuapp.conf    |   12 +
 .../boards/nrf54l15pdk_nrf54l15_cpuapp.conf   |   12 +
 .../wifi/radio_test/single_domain/ficr.rst    |  104 +
 .../inc/nrf_wifi_radio_test_shell.h           |   24 +
 .../single_domain/peripheral_radio_test.rst   |  305 ++
 .../wifi/radio_test/single_domain/prj.conf    |   52 +
 .../single_domain/radio_test_subcommands.rst  |  287 ++
 .../wifi/radio_test/single_domain/sample.yaml |   15 +
 .../single_domain/sample_description.rst      |  657 +++++
 .../radio_test/single_domain/src/ficr_prog.c  |  380 +++
 .../radio_test/single_domain/src/ficr_prog.h  |   23 +
 .../wifi/radio_test/single_domain/src/main.c  |  105 +
 .../src/nrf_wifi_radio_ficr_shell.c           |  528 ++++
 .../src/nrf_wifi_radio_test_shell.c           | 2535 +++++++++++++++++
 .../radio_test/single_domain/src/radio_cmd.c  | 1497 ++++++++++
 .../radio_test/single_domain/src/radio_test.c | 1180 ++++++++
 .../radio_test/single_domain/src/radio_test.h |  235 ++
 .../radio_test/single_domain/sysbuild.conf    |    8 +
 37 files changed, 8031 insertions(+), 2 deletions(-)
 rename samples/wifi/radio_test/{ => multi_domain}/CMakeLists.txt (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/Kconfig.sysbuild (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/README.rst (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/boards/thingy91x_nrf9151_ns.overlay (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/ficr.rst (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/inc/nrf_wifi_radio_test_shell.h (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/prj.conf (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/radio_test_subcommands.rst (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/sample.yaml (96%)
 rename samples/wifi/radio_test/{ => multi_domain}/sample_description.rst (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/src/ficr_prog.c (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/src/ficr_prog.h (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/src/nrf_wifi_radio_ficr_shell.c (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/src/nrf_wifi_radio_test_main.c (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/src/nrf_wifi_radio_test_shell.c (100%)
 rename samples/wifi/radio_test/{ => multi_domain}/sysbuild.conf (100%)
 create mode 100644 samples/wifi/radio_test/single_domain/CMakeLists.txt
 create mode 100644 samples/wifi/radio_test/single_domain/Kconfig
 create mode 100644 samples/wifi/radio_test/single_domain/README.rst
 create mode 100644 samples/wifi/radio_test/single_domain/boards/nrf54l15dk_nrf54l15_cpuapp.conf
 create mode 100644 samples/wifi/radio_test/single_domain/boards/nrf54l15pdk_nrf54l15_cpuapp.conf
 create mode 100644 samples/wifi/radio_test/single_domain/ficr.rst
 create mode 100644 samples/wifi/radio_test/single_domain/inc/nrf_wifi_radio_test_shell.h
 create mode 100644 samples/wifi/radio_test/single_domain/peripheral_radio_test.rst
 create mode 100644 samples/wifi/radio_test/single_domain/prj.conf
 create mode 100644 samples/wifi/radio_test/single_domain/radio_test_subcommands.rst
 create mode 100644 samples/wifi/radio_test/single_domain/sample.yaml
 create mode 100644 samples/wifi/radio_test/single_domain/sample_description.rst
 create mode 100644 samples/wifi/radio_test/single_domain/src/ficr_prog.c
 create mode 100644 samples/wifi/radio_test/single_domain/src/ficr_prog.h
 create mode 100644 samples/wifi/radio_test/single_domain/src/main.c
 create mode 100644 samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_ficr_shell.c
 create mode 100644 samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_test_shell.c
 create mode 100644 samples/wifi/radio_test/single_domain/src/radio_cmd.c
 create mode 100644 samples/wifi/radio_test/single_domain/src/radio_test.c
 create mode 100644 samples/wifi/radio_test/single_domain/src/radio_test.h
 create mode 100644 samples/wifi/radio_test/single_domain/sysbuild.conf

diff --git a/samples/wifi/radio_test/CMakeLists.txt b/samples/wifi/radio_test/multi_domain/CMakeLists.txt
similarity index 100%
rename from samples/wifi/radio_test/CMakeLists.txt
rename to samples/wifi/radio_test/multi_domain/CMakeLists.txt
diff --git a/samples/wifi/radio_test/Kconfig.sysbuild b/samples/wifi/radio_test/multi_domain/Kconfig.sysbuild
similarity index 100%
rename from samples/wifi/radio_test/Kconfig.sysbuild
rename to samples/wifi/radio_test/multi_domain/Kconfig.sysbuild
diff --git a/samples/wifi/radio_test/README.rst b/samples/wifi/radio_test/multi_domain/README.rst
similarity index 100%
rename from samples/wifi/radio_test/README.rst
rename to samples/wifi/radio_test/multi_domain/README.rst
diff --git a/samples/wifi/radio_test/boards/thingy91x_nrf9151_ns.overlay b/samples/wifi/radio_test/multi_domain/boards/thingy91x_nrf9151_ns.overlay
similarity index 100%
rename from samples/wifi/radio_test/boards/thingy91x_nrf9151_ns.overlay
rename to samples/wifi/radio_test/multi_domain/boards/thingy91x_nrf9151_ns.overlay
diff --git a/samples/wifi/radio_test/ficr.rst b/samples/wifi/radio_test/multi_domain/ficr.rst
similarity index 100%
rename from samples/wifi/radio_test/ficr.rst
rename to samples/wifi/radio_test/multi_domain/ficr.rst
diff --git a/samples/wifi/radio_test/inc/nrf_wifi_radio_test_shell.h b/samples/wifi/radio_test/multi_domain/inc/nrf_wifi_radio_test_shell.h
similarity index 100%
rename from samples/wifi/radio_test/inc/nrf_wifi_radio_test_shell.h
rename to samples/wifi/radio_test/multi_domain/inc/nrf_wifi_radio_test_shell.h
diff --git a/samples/wifi/radio_test/prj.conf b/samples/wifi/radio_test/multi_domain/prj.conf
similarity index 100%
rename from samples/wifi/radio_test/prj.conf
rename to samples/wifi/radio_test/multi_domain/prj.conf
diff --git a/samples/wifi/radio_test/radio_test_subcommands.rst b/samples/wifi/radio_test/multi_domain/radio_test_subcommands.rst
similarity index 100%
rename from samples/wifi/radio_test/radio_test_subcommands.rst
rename to samples/wifi/radio_test/multi_domain/radio_test_subcommands.rst
diff --git a/samples/wifi/radio_test/sample.yaml b/samples/wifi/radio_test/multi_domain/sample.yaml
similarity index 96%
rename from samples/wifi/radio_test/sample.yaml
rename to samples/wifi/radio_test/multi_domain/sample.yaml
index d8285a70f996..76c1843c9c2a 100644
--- a/samples/wifi/radio_test/sample.yaml
+++ b/samples/wifi/radio_test/multi_domain/sample.yaml
@@ -63,7 +63,7 @@ tests:
   sample.nrf7002_eb.thingy53.radio_test:
     sysbuild: true
     build_only: true
-    extra_args: radio_test_SHIELD=nrf7002eb
+    extra_args: multi_domain_SHIELD=nrf7002eb
     integration_platforms:
       - thingy53/nrf5340/cpuapp
     platform_allow: thingy53/nrf5340/cpuapp
@@ -78,7 +78,7 @@ tests:
     build_only: true
     extra_args:
       - FILE_SUFFIX=wifi_combo
-      - radio_test_SHIELD="nrf7002eb_interposer_p1;nrf7002eb"
+      - multi_domain_SHIELD="nrf7002eb_interposer_p1;nrf7002eb"
       - SNIPPET=nrf70-wifi
     integration_platforms:
       - nrf54h20dk/nrf54h20/cpuapp
diff --git a/samples/wifi/radio_test/sample_description.rst b/samples/wifi/radio_test/multi_domain/sample_description.rst
similarity index 100%
rename from samples/wifi/radio_test/sample_description.rst
rename to samples/wifi/radio_test/multi_domain/sample_description.rst
diff --git a/samples/wifi/radio_test/src/ficr_prog.c b/samples/wifi/radio_test/multi_domain/src/ficr_prog.c
similarity index 100%
rename from samples/wifi/radio_test/src/ficr_prog.c
rename to samples/wifi/radio_test/multi_domain/src/ficr_prog.c
diff --git a/samples/wifi/radio_test/src/ficr_prog.h b/samples/wifi/radio_test/multi_domain/src/ficr_prog.h
similarity index 100%
rename from samples/wifi/radio_test/src/ficr_prog.h
rename to samples/wifi/radio_test/multi_domain/src/ficr_prog.h
diff --git a/samples/wifi/radio_test/src/nrf_wifi_radio_ficr_shell.c b/samples/wifi/radio_test/multi_domain/src/nrf_wifi_radio_ficr_shell.c
similarity index 100%
rename from samples/wifi/radio_test/src/nrf_wifi_radio_ficr_shell.c
rename to samples/wifi/radio_test/multi_domain/src/nrf_wifi_radio_ficr_shell.c
diff --git a/samples/wifi/radio_test/src/nrf_wifi_radio_test_main.c b/samples/wifi/radio_test/multi_domain/src/nrf_wifi_radio_test_main.c
similarity index 100%
rename from samples/wifi/radio_test/src/nrf_wifi_radio_test_main.c
rename to samples/wifi/radio_test/multi_domain/src/nrf_wifi_radio_test_main.c
diff --git a/samples/wifi/radio_test/src/nrf_wifi_radio_test_shell.c b/samples/wifi/radio_test/multi_domain/src/nrf_wifi_radio_test_shell.c
similarity index 100%
rename from samples/wifi/radio_test/src/nrf_wifi_radio_test_shell.c
rename to samples/wifi/radio_test/multi_domain/src/nrf_wifi_radio_test_shell.c
diff --git a/samples/wifi/radio_test/sysbuild.conf b/samples/wifi/radio_test/multi_domain/sysbuild.conf
similarity index 100%
rename from samples/wifi/radio_test/sysbuild.conf
rename to samples/wifi/radio_test/multi_domain/sysbuild.conf
diff --git a/samples/wifi/radio_test/single_domain/CMakeLists.txt b/samples/wifi/radio_test/single_domain/CMakeLists.txt
new file mode 100644
index 000000000000..6c5f0c01e025
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/CMakeLists.txt
@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2022 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(wifi_ble_radio_test)
+
+target_include_directories(app PRIVATE
+	inc
+)
+
+# Application sources
+FILE(GLOB app_sources src/*.c)
+
+# NORDIC SDK APP START
+target_sources(app PRIVATE
+	${app_sources}
+)
+# NORDIC SDK APP END
diff --git a/samples/wifi/radio_test/single_domain/Kconfig b/samples/wifi/radio_test/single_domain/Kconfig
new file mode 100644
index 000000000000..599b714ae1db
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/Kconfig
@@ -0,0 +1,27 @@
+#
+# Copyright (c) 2020 Nordic Semiconductor
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+mainmenu "Nordic Wi-Fi BLE Radio test sample"
+
+config RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC
+	bool "Automatic power control"
+	depends on FEM
+	default y
+	help
+	  Set SoC output power and front-end module gain to achieve Tx output power requested
+	  by user. If the exact value cannot be achieved, power is set to closest value which does
+	  not exceed the limits. If this option is disabled, user has to set SoC output power and
+	  fem gain with separate commands.
+
+config RADIO_TEST_SD_RX_TIMEOUT
+	int "RX packet reception timeout"
+	default 10
+	help
+	  Specifies the time in seconds that the application waits for the first packet to be
+	  received in RX mode when a specified number of packets are set to be received.
+	  If the timeout is reached before the first packet is received, the radio will be disabled.
+
+source "Kconfig.zephyr"
diff --git a/samples/wifi/radio_test/single_domain/README.rst b/samples/wifi/radio_test/single_domain/README.rst
new file mode 100644
index 000000000000..abdcd90c994b
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/README.rst
@@ -0,0 +1,20 @@
+.. _wifi_radio_test_sd:
+
+Wi-Fi BLE Radio Test Sample
+###########################
+
+The Wi-Fi BLE Radio Test sample demonstrates how to use the radio test for both Wi-Fi and BLE protocols using a single domain image i.e., both running on the same core.
+The sample demonstrates how to use the radio test subcommands to configure the radio test parameters and run the radio test.
+
+The Wi-Fi Radio test also supports programming the Factory Information Configuration Registers (FICR) fields defined in the nRF7002 one-time programmable (OTP) memory.
+
+See the subpages for detailed documentation on the sample and its features.
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Subpages:
+
+   sample_description.rst
+   peripheral_radio_test.rst
+   radio_test_subcommands.rst
+   ficr.rst
diff --git a/samples/wifi/radio_test/single_domain/boards/nrf54l15dk_nrf54l15_cpuapp.conf b/samples/wifi/radio_test/single_domain/boards/nrf54l15dk_nrf54l15_cpuapp.conf
new file mode 100644
index 000000000000..e029d65ce7bf
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/boards/nrf54l15dk_nrf54l15_cpuapp.conf
@@ -0,0 +1,12 @@
+#
+# Copyright (c) 2024 Nordic Semiconductor
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+# Disable the unsupported driver
+CONFIG_NRFX_TIMER0=n
+
+# Enable the necessary drivers
+CONFIG_NRFX_TIMER10=y
+CONFIG_NRFX_GPPI=y
diff --git a/samples/wifi/radio_test/single_domain/boards/nrf54l15pdk_nrf54l15_cpuapp.conf b/samples/wifi/radio_test/single_domain/boards/nrf54l15pdk_nrf54l15_cpuapp.conf
new file mode 100644
index 000000000000..482eca1189d6
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/boards/nrf54l15pdk_nrf54l15_cpuapp.conf
@@ -0,0 +1,12 @@
+#
+# Copyright (c) 2023 Nordic Semiconductor
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+# Disable the unsupported driver
+CONFIG_NRFX_TIMER0=n
+
+# Enable the necessary drivers
+CONFIG_NRFX_TIMER10=y
+CONFIG_NRFX_GPPI=y
diff --git a/samples/wifi/radio_test/single_domain/ficr.rst b/samples/wifi/radio_test/single_domain/ficr.rst
new file mode 100644
index 000000000000..aa3b80857716
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/ficr.rst
@@ -0,0 +1,104 @@
+.. _wifi_ficr_prog:
+
+FICR programming subcommands
+############################
+
+.. contents::
+   :local:
+   :depth: 2
+
+``wifi_radio_ficr_prog`` is the Wi-Fi® radio FICR programming command and it supports the following subcommands.
+
+.. _wifi_radio_ficr_prog_subcmds:
+
+Wi-Fi radio FICR subcommands
+****************************
+
+.. list-table:: Wi-Fi radio FICR subcommands
+   :widths: 15 15 10 30 70
+   :header-rows: 1
+
+   * - Subcommand
+     - Register
+     - Offset
+     - Argument(s)
+     - Description
+   * - otp_get_status
+     - N/A
+     - N/A
+     - N/A
+     - Reads out the OTP status of user region and status of each field (programmed or not).
+   * - otp_read_params
+     - N/A
+     - N/A
+     - N/A
+     - Reads out all the OTP parameters (excluding QSPI_KEY which cannot be read).
+   * - otp_read_retrim_version
+     - PRODRETEST.PROGVERSION
+     - N/A
+     - N/A
+     - Reads out program version of Retrim parameters.
+   * - otp_read_retrim_params
+     - PRODRETEST.TRIM[n]
+     - N/A
+     - N/A
+     - Reads out all the Retrim parameters.
+   * - otp_write_params
+     - REGION_PROTECT
+     - 0x100
+     - arg
+     - | arg = 0x50FA50FA : Enable R/W permission
+       | arg = 0x00000000 : Lock Region from Writing
+       | arg = Others : Invalid
+       | All four REGION_PROTECT registers are written with this 32-bit argument.
+   * - otp_write_params
+     - QSPI_KEY
+     - 0x110
+     - arg1 arg2 arg3 arg4
+     - | All four key arguments are 32-bit values forming the required 128-bit (Q)SPI key for encryption.
+       | For example, if QSPI key is "112233445566778899aabbccddeeff00" then arg1=0x44332211 arg2=0x88776655 arg3=0xccbbaa99 arg4=0x00ffeedd
+   * - otp_write_params
+     - MAC_ADDRESS0
+     - 0x120
+     - arg1 arg2
+     - If MAC address is AA:BB:CC:DD:EE:FF, then arg1=0xDDCCBBAA and arg2=0xFFEE.
+   * - otp_write_params
+     - MAC_ADDRESS1
+     - 0x128
+     - arg1 arg2
+     - If MAC address is AA:BB:CC:DD:EE:FF, then arg1=0xDDCCBBAA and arg2=0xFFEE.
+   * - otp_write_params
+     - CALIB_XO
+     - 0x130
+     - arg
+     - arg is 7-bit unsigned XO value. Bits [31:7] unused. Adjusts capacitor bank, 0 : Lowest capacitance (Highest frequency), 127 : Highest capacitance (Lowest frequency).
+   * - otp_write_params
+     - REGION_DEFAULTS
+     - 0x154
+     - arg
+     - | Register default enable control.
+       | arg is 32-bit value where a specific bit is set to ``0`` implies that the corresponding OTP field is programmed. The following list shows the bit and field mapping:
+       |
+       | bit 0  : QSPI_KEY
+       | bit 1  : MAC0 Address
+       | bit 2  : MAC1 Address
+       | bit 3  : CALIB_XO
+       | bit 4  : Reserved
+       | bit 5  : Reserved
+       | bit 6  : Reserved
+       | bit 7  : Reserved
+       | bit 8  : Reserved
+       | bit 9  : Reserved
+       | bit 10 : Reserved
+       | bit 11 : Reserved
+       | bit 12-31 : Reserved
+   * - otp_write_retrim_version
+     - PRODRETEST.PROGVERSION
+     - N/A
+     - arg
+     - arg is 32-bit data.
+   * - otp_write_retrim_params
+     - PRODRETEST.TRIM[n]
+     - index between (0-14)
+     - arg
+     - arg is 32-bit data. When index = 5, PRODRETEST.TRIM[5] is written with 32-bit argument.
diff --git a/samples/wifi/radio_test/single_domain/inc/nrf_wifi_radio_test_shell.h b/samples/wifi/radio_test/single_domain/inc/nrf_wifi_radio_test_shell.h
new file mode 100644
index 000000000000..6105c91cf456
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/inc/nrf_wifi_radio_test_shell.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+/* @file
+ * @brief nRF Wi-Fi radio-test mode shell module
+ */
+
+#include <zephyr/kernel.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <zephyr/shell/shell.h>
+#include <zephyr/init.h>
+#include <ctype.h>
+#include <host_rpu_sys_if.h>
+#include <fmac_structs.h>
+#include <zephyr/drivers/wifi/nrf_wifi/bus/rpu_hw_if.h>
+
+struct nrf_wifi_ctx_zep_rt {
+	struct nrf_wifi_fmac_priv *fmac_priv;
+	struct rpu_conf_params conf_params;
+};
diff --git a/samples/wifi/radio_test/single_domain/peripheral_radio_test.rst b/samples/wifi/radio_test/single_domain/peripheral_radio_test.rst
new file mode 100644
index 000000000000..127f19170ca8
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/peripheral_radio_test.rst
@@ -0,0 +1,305 @@
+.. _radio_test_sd:
+
+Radio test (short-range)
+########################
+
+.. contents::
+   :local:
+   :depth: 2
+
+The Radio test sample demonstrates how to configure the 2.4 GHz short-range radio (Bluetooth® LE, IEEE 802.15.4 and proprietary) in a specific mode and then test its performance.
+The sample provides a set of predefined commands that allow you to configure the radio in three modes:
+
+* Constant RX or TX carrier
+* Modulated TX carrier
+* RX or TX sweep
+
+Requirements
+************
+
+The sample supports the following development kits:
+
+.. table-from-sample-yaml::
+
+You can use any one of the development kits listed above.
+
+.. note::
+   On nRF5340 DK and nRF7002 DK, the sample is designed to run on the network core and requires the :ref:`nrf5340_remote_shell` running on the application core.
+   This sample uses the :ref:`shell_ipc_readme` library to forward shell data through the physical UART interface of the application core.
+
+The sample also requires one of the following testing devices:
+
+  * Another development kit with the same sample.
+    See :ref:`radio_test_testing_board`.
+  * Another development kit connected to a PC with the `RSSI Viewer app`_ (available in the `nRF Connect for Desktop`_).
+    See :ref:`radio_test_testing_rssi`.
+
+.. note::
+   You can perform the radio test also using a spectrum analyzer.
+   This method of testing is not covered by this documentation.
+
+nRF21540 front-end module
+=========================
+
+.. include:: /includes/sample_dtm_radio_test_fem.txt
+
+You can configure the nRF21540 front-end module (FEM) transmitted power control, antenna output and activation delay using the main shell commands of the :ref:`radio_test_ui`.
+
+Skyworks front-end module
+=========================
+
+.. include:: /includes/sample_dtm_radio_test_skyworks.txt
+
+You can configure the Skyworks front-end module (FEM) antenna output and activation delay using the main shell commands of the :ref:`radio_test_ui`.
+
+Overview
+********
+
+To run the tests, connect to the development kit through the serial port and send shell commands.
+Zephyr's :ref:`zephyr:shell_api` module is used to handle the commands.
+At any time during the tests, you can dynamically set the radio parameters, such as output power, bit rate, and channel.
+In sweep mode, you can set the time for which the radio scans each channel from one millisecond to 99 milliseconds, in steps of one millisecond.
+The sample also allows you to send a data pattern to another development kit.
+
+The sample first enables the high frequency crystal oscillator and configures the shell.
+You can then start running commands to set up and control the radio.
+See :ref:`radio_test_ui` for a list of available commands.
+
+.. note::
+   For the IEEE 802.15.4 mode, the start channel and the end channel must be within the channel range of 11 to 26.
+   Use the ``start_channel`` and ``end_channel`` commands to control this setting.
+
+
+.. _radio_test_ui:
+
+User interface
+**************
+.. list-table:: Main shell commands (in alphabetical order)
+   :header-rows: 1
+
+   * - Command
+     - Argument
+     - Description
+   * - cancel
+     -
+     - Cancel the sweep or the carrier.
+   * - data_rate
+     - <sub_cmd>
+     - Set the data rate.
+   * - end_channel
+     - <channel>
+     - End channel for the sweep (in MHz, as difference from 2400 MHz).
+   * - fem
+     - <sub_cmd>
+     - Set front-end module (FEM) parameters.
+   * - output_power
+     - <sub_cmd>
+     - Output power set.
+       If a front-end module is attached and the :ref:`CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC <CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC>` Kconfig option is enabled, it has the same effect as the ``total_output_power`` command.
+   * - parameters_print
+     -
+     - Print current delay, channel, and other parameters.
+   * - print_rx
+     -
+     - Print the received RX payload.
+   * - start_channel
+     - <channel>
+     - Start channel for the sweep or the channel for the constant carrier (in MHz, as difference from 2400 MHz).
+   * - start_duty_cycle_modulated_tx
+     - <duty_cycle>
+     - Duty cycle in percent (two decimal digits, between 01 and 90).
+   * - start_rx
+     - <packet_num>
+     - Start RX (continuous RX mode is used if no argument is provided).
+   * - start_rx_sweep
+     -
+     - Start the RX sweep.
+   * - start_tx_carrier
+     -
+     - Start the TX carrier.
+   * - start_tx_modulated_carrier
+     - <packet_num>
+     - Start the modulated TX carrier (continuous TX mode is used if no argument is provided).
+   * - start_tx_sweep
+     -
+     - Start the TX sweep.
+   * - time_on_channel
+     - <time>
+     - Time on each channel in ms (between 1 and 99).
+   * - toggle_dcdc_state
+     - <state>
+     - Toggle DC/DC converter state.
+   * - transmit_pattern
+     - <sub_cmd>
+     - Set transmission pattern.
+   * - total_output_power
+     - <tx output power>
+     - Set total output power in dBm.
+       This value includes SoC output power and front-end module gain.
+
+TX output power
+===============
+
+This sample has a few commands that you can use to test the device output power.
+The behavior of the commands vary depending on the hardware configuration and Kconfig options as follows:
+
+* Radio Test without front-end module support:
+
+  * The ``output_power`` command sets the SoC output command with a subcommand set.
+    The output power is set directly in the radio peripheral.
+
+* Radio Test with front-end module support in default configuration (the :ref:`CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC <CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC>` Kconfig option is enabled):
+
+  * The ``output_power`` command sets the total output power, including front-end module gain.
+  * The ``total_output_power`` command sets the total output power, including front-end module gain with a value in dBm unit provided by user.
+  * For these commands, the radio peripheral and FEM transmit power control is calculated and set automatically to meet your requirements.
+  * If an exact output power value cannot be set, a lower value is used.
+
+* Radio Test with front-end module support and manual TX output power control (the :ref:`CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC <CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC>` Kconfig option is disabled):
+
+  * The ``output_power`` command sets the SoC output command with a subcommands set.
+  * The ``fem`` command with the ``tx_power_control`` subcommand sets the front-end module transmit power control to a value for given specific front-end module.
+  * You can use this configuration to perform tests on your hardware design.
+
+Configuration
+*************
+
+|config|
+
+Configuration options
+=====================
+
+Check and configure the following Kconfig options:
+
+.. _CONFIG_RADIO_TEST_USB:
+
+CONFIG_RADIO_TEST_USB
+   Selects USB instead of UART as the Radio Test shell transport.
+   For nRF5340 the USB from application core is used as the communication interface.
+
+.. _CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC:
+
+CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC
+   Sets the SoC output power and front-end module gain to achieve the requested TX output power.
+   If the exact value cannot be achieved, power is set to closest value that does not exceed the limits.
+   If this option is disabled, set the SoC output power and FEM gain with separate commands.
+
+Building and running
+********************
+
+.. |sample path| replace:: :file:`samples/peripheral/radio_test`
+
+.. include:: /includes/build_and_run.txt
+
+.. include:: /includes/nRF54H20_erase_UICR.txt
+
+.. note::
+   |54H_engb_2_8|
+
+.. note::
+   On the nRF5340 or nRF7002 development kit, the Radio Test sample requires the :ref:`nrf5340_remote_shell` sample on the application core.
+   The Remote IPC shell sample is built and programmed automatically by default.
+   If you want to program your custom solution for the application core, unset the :kconfig:option:`CONFIG_NCS_SAMPLE_REMOTE_SHELL_CHILD_IMAGE` Kconfig option.
+
+Remote USB CDC ACM Shell variant
+================================
+
+This sample can run the remote IPC Service Shell through the USB on the nRF5340 DK application core.
+For example, when building on the command line, use the following command:
+
+.. code-block:: console
+
+   west build samples/peripheral/radio_test -b nrf5340dk/nrf5340/cpunet -- -DFILE_SUFFIX=usb
+
+You can also build this sample with the remote IPC Service Shell and support for the front-end module.
+You can use the following command:
+
+.. code-block:: console
+
+   west build samples/peripheral/radio_test -b nrf5340dk/nrf5340/cpunet -- -DSHIELD=nrf21540ek -DFILE_SUFFIX=usb
+
+.. include:: /includes/nRF54H20_erase_UICR.txt
+
+.. note::
+   You can also build the sample with the remote IPC Service Shell for the |nRF7002DKnoref| using the ``nrf7002dk/nrf5340/cpunet`` board target in the commands.
+
+.. _radio_test_testing:
+
+Testing
+=======
+
+After programming the sample to your development kit, complete the following steps to test it in one of the following two ways:
+
+.. note::
+   For the |nRF5340DKnoref| or |nRF7002DKnoref|, see :ref:`logging_cpunet` for information about the COM terminals on which the logging output is available.
+
+.. _radio_test_testing_board:
+
+Testing with another development kit
+------------------------------------
+
+Complete the following steps:
+
+1. Connect both development kits to the computer using a USB cable.
+   The kits are assigned a COM port (Windows) or ttyACM device (Linux), which is visible in the Device Manager.
+#. |connect_terminal_both_ANSI|
+#. Run the following commands on one of the kits:
+
+   a. Set the data rate with the ``data_rate`` command to ``ble_2Mbit``.
+   #. Set the transmission pattern with the ``transmit_pattern`` command to ``pattern_11110000``.
+   #. Set the radio channel with the ``start_channel`` command to 40.
+
+#. Repeat all steps for the second kit.
+#. On both kits, run the ``parameters_print`` command to confirm that the radio configuration is the same on both kits.
+#. Set one kit in the Modulated TX Carrier mode using the ``start_tx_modulated_carrier`` command.
+#. Set the other kit in the RX Carrier mode using the ``start_rx`` command.
+#. Print the received data with the ``print_rx`` command and confirm that they match the transmission pattern (0xF0).
+
+.. _radio_test_testing_rssi:
+
+Testing with the RSSI Viewer app
+--------------------------------
+
+Complete the following steps:
+
+1. Connect the kit to the computer using a USB cable.
+   The kit is assigned a COM port (Windows) or ttyACM device (Linux), which is visible in the Device Manager.
+#. |connect_terminal_ANSI|
+#. Set the start channel with the ``start_channel`` command to 20.
+#. Set the end channel with the ``end_channel`` command to 60.
+#. Set the time on channel with the ``time_on_channel`` command to 50 ms.
+#. Set the kit in the TX sweep mode using the ``start_tx_sweep`` command.
+#. Start the `RSSI Viewer app`_ and select the kit to communicate with.
+#. On the application chart, observe the TX sweep in the form of a wave that starts at 2420 MHz frequency and ends with 2480 MHz.
+
+Dependencies
+************
+
+This sample uses the following |NCS| libraries:
+
+  * :ref:`shell_ipc_readme`
+  * :ref:`fem_al_lib`
+
+This sample has the following nrfx dependencies:
+
+  * :file:`nrfx/drivers/include/nrfx_timer.h`
+  * :file:`nrfx/hal/nrf_power.h`
+  * :file:`nrfx/hal/nrf_radio.h`
+
+The sample also has the following nrfxlib dependency:
+
+  * :ref:`nrfxlib:mpsl_fem`
+
+In addition, it uses the following Zephyr libraries:
+
+* :ref:`zephyr:device_model_api`:
+
+   * :file:`drivers/clock_control.h`
+
+* :ref:`zephyr:kernel_api`:
+
+  * :file:`include/init.h`
+
+* :ref:`zephyr:shell_api`:
+
+  * :file:`include/shell/shell.h`
diff --git a/samples/wifi/radio_test/single_domain/prj.conf b/samples/wifi/radio_test/single_domain/prj.conf
new file mode 100644
index 000000000000..0a74f343e738
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/prj.conf
@@ -0,0 +1,52 @@
+#
+# Copyright (c) 2022 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+CONFIG_WIFI=y
+CONFIG_WIFI_NRF70=y
+CONFIG_NRF70_RADIO_TEST=y
+
+#CONFIG_INIT_STACKS=y
+
+# Memories
+CONFIG_MAIN_STACK_SIZE=5200
+CONFIG_SHELL_STACK_SIZE=5200
+#64K memory needed for IQ sample captures.
+CONFIG_HEAP_MEM_POOL_SIZE=98304
+CONFIG_HEAP_MEM_POOL_IGNORE_MIN=y
+
+
+# Debugging
+CONFIG_STACK_SENTINEL=y
+CONFIG_DEBUG_COREDUMP=y
+CONFIG_DEBUG_COREDUMP_BACKEND_LOGGING=y
+CONFIG_DEBUG_COREDUMP_MEMORY_DUMP_MIN=y
+CONFIG_SHELL_CMDS_RESIZE=n
+#CONFIG_DEBUG=y
+
+# Logging
+CONFIG_LOG=y
+CONFIG_PRINTK=y
+CONFIG_SHELL=y
+CONFIG_SHELL_GETOPT=y
+CONFIG_DEVICE_SHELL=y
+CONFIG_POSIX_CLOCK=y
+CONFIG_DATE_SHELL=y
+CONFIG_LOG_BUFFER_SIZE=4096
+CONFIG_SHELL_BACKEND_SERIAL_RX_RING_BUFFER_SIZE=1024
+
+# Peripheral radio test configuration
+CONFIG_CONSOLE_HANDLER=y
+CONFIG_SHELL=y
+
+CONFIG_DYNAMIC_INTERRUPTS=y
+
+CONFIG_NRFX_TIMER0=y
+CONFIG_CLOCK_CONTROL=y
+
+CONFIG_ENTROPY_GENERATOR=y
+CONFIG_NRF_SECURITY=y
+
+CONFIG_FEM_AL_LIB=y
+CONFIG_PICOLIBC_IO_FLOAT=y
diff --git a/samples/wifi/radio_test/single_domain/radio_test_subcommands.rst b/samples/wifi/radio_test/single_domain/radio_test_subcommands.rst
new file mode 100644
index 000000000000..e7cb0dcb1439
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/radio_test_subcommands.rst
@@ -0,0 +1,287 @@
+.. _wifi_radio_subcommands_sd:
+
+Radio test subcommands
+######################
+
+.. contents::
+   :local:
+   :depth: 2
+
+``wifi_radio_test`` is the Wi-Fi® radio test command and it supports the following subcommands.
+
+.. _wifi_radio_test_subcmds:
+
+Wi-Fi radio test subcommands
+****************************
+
+.. list-table:: Wi-Fi radio test subcommands
+   :header-rows: 1
+
+   * - Subcommand
+     - Argument
+     - Default value
+     - Type
+     - Description
+   * - set_defaults
+     - N/A
+     - N/A
+     - Configuration
+     - Reset all configuration parameters to their default values.
+   * - phy_calib_rxdc
+     - | 0 - Disable
+       | 1 - Enable
+     - 1
+     - Configuration
+     - Enable/Disable RX DC calibration.
+   * - phy_calib_txdc
+     - | 0 - Disable
+       | 1 - Enable
+     - 1
+     - Configuration
+     - Enable/Disable TX DC calibration.
+   * - phy_calib_txpow
+     - | 0 - Disable
+       | 1 - Enable
+     - 0
+     - Configuration
+     - Enable/Disable TX power calibration.
+   * - phy_calib_rxiq
+     - | 0 - Disable
+       | 1 - Enable
+     - 1
+     - Configuration
+     - Enable/Disable RX IQ calibration.
+   * - phy_calib_txiq
+     - | 0 - Disable
+       | 1 - Enable
+     - 1
+     - Configuration
+     - Enable/Disable TX IQ calibration.
+   * - he_ltf
+     - | 0 - 1x HE LTF
+       | 1 - 2x HE LTF
+       | 2 - 4x HE LTF
+     - 2
+     - Configuration
+     - Configure HE long training field (LTF) value while transmitting the packet.
+   * - he_gi
+     - | 0 - 0.8 µs
+       | 1 - 1.6 µs
+       | 2 - 3.2 µs
+     - 2
+     - Configuration
+     - Configure HE guard interval (GI) while transmitting the packet.
+   * - tx_pkt_tput_mode
+     - | 0 - Legacy
+       | 1 - HT mode
+       | 2 - VHT mode
+       | 3 - HE (SU) mode
+       | 4 - HE (ERSU) mode
+       | 5 - HE (TB) mode
+     - 0
+     - Configuration
+     - Throughput mode to be used for transmitting the packet.
+   * - tx_pkt_sgi
+     - | 0 - Disable
+       | 1 - Enable
+     - 0
+     - Configuration
+     - Enable/Disable Short guard interval (GI) while transmitting the packet.
+   * - tx_pkt_preamble
+     - | 0 - Long Preamble
+       | 1 - Short Preamble
+       | 2 - Mixed Preamble
+     - 0
+     - Configuration
+     - Type of preamble to be used for each packet. Short/Long Preamble are applicable only when tx_pkt_tput_mode is set to Legacy and Mixed Preamble is applicable only when tx_pkt_tput_mode is set to HT/VHT.
+   * - tx_pkt_mcs
+     - | -1 - Not being used
+       | <val> - MCS index to be used
+     - 0
+     - Configuration
+     - MCS index at which TX packet will be transmitted. Mutually exclusive with tx_pkt_rate.
+   * - tx_pkt_rate
+     - | -1 - Not being used
+       | <val> - Legacy rate to be used (1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54)
+     - 6
+     - Configuration
+     - Legacy rate at which packets will be transmitted. Mutually exclusive with tx_pkt_mcs.
+   * - tx_pkt_gap
+     - <val> - (Min: 0, Max: 200000)
+     - 0
+     - Configuration
+     - Interval between TX packets in microseconds.
+   * - tx_pkt_num
+     - | -1 - Transmit infinite packets
+       | <val> - Number of packets to transmit
+     - -1
+     - Configuration
+     - Number of packets to transmit before stopping.
+   * - tx_pkt_len
+     - <val> - Desired packet length
+     - 1400
+     - Configuration
+     - Packet data length to be used for the TX stream.
+   * - tx_power
+     - <val> - Transmit power in dBm (Min: 0, Max: 24)
+     - 0
+     - Configuration
+     - Transmit power for frame transmission.
+   * - ru_tone
+     - <val> - Desired resource unit (RU) size (26, 52, 106 or 242).
+     - 26
+     - Configuration
+     - Configure the resource unit (RU) size.
+   * - ru_index
+     - | <val> - Valid values:
+       | For 26 ru_tone: 1 to 9
+       | For 52 ru_tone: 1 to 4
+       | For 106 ru_tone: 1 to 2
+       | For 242 ru_tone: 1
+     - 1
+     - Configuration
+     - Configure the location of resource unit (RU) in 20 MHz spectrum.
+   * - rx_capture_length
+     - | <val> Number of ADC samples (Min: 0, Max: 16383)
+     - 0
+     - Configuration
+     - Number of RX samples to be captured.
+   * - rx_capture_timeout
+     - | <val> Timeout period in seconds (Min: 0, Max: 600)
+     - 0
+     - Configuration
+     - Duration of packet detection. If no packets are detected, the command will timeout.
+   * - rx_lna_gain
+     - | 0 = 24 dB
+       | 1 = 18 dB
+       | 2 = 12 dB
+       | 3 = 0 dB
+       | 4 = -12 dB
+     - 0
+     - Configuration
+     - LNA gain to be configured.
+   * - rx_bb_gain
+     - | <val>
+       | 5 bit value. Supports 64 dB range in steps of 2 dB
+     - 0
+     - Configuration
+     - Baseband gain to be configured.
+   * - tx_tone_freq
+     - | <val> (Min: -10, Max: 10)
+     - 0
+     - Configuration
+     - Transmit tone frequency in the range of -10 MHz to 10 MHz.
+   * - dpd
+     - | 0 - DPD bypass
+       | 1 - Enable DPD
+     - 0
+     - Configuration
+     - Enable or bypass DPD.
+   * - set_xo_val
+     - | <val> - XO value (Min:0, Max: 127)
+     - 42 or value programmed in OTP
+     - Configuration
+     - Set XO value.
+   * - show_config
+     - N/A
+     - N/A
+     - Configuration
+     - Display the current configuration values.
+   * - init
+     - <val> - Primary channel number
+     - 1
+     - Action
+     - Initialize the radio to a default state with the configured channel. This will also reset all other configuration parameters to their default values.
+   * - tx
+     - | 0 - Disable
+       | 1 - Enable
+     - 0
+     - Action
+     - Enable/Disable packet transmission. Transmits configured number of packets (tx_pkt_num) of packet length (tx_pkt_len).
+   * - rx
+     - | 0 - Disable
+       | 1 - Enable
+     - 0
+     - Action
+     - Enable/Disable packet reception.
+   * - rx_cap
+     - | 0 = ADC capture
+       | 1 = Filtered ADC capture
+       | 2 = Packet capture
+     - N/A
+     - Action
+     - Capture ADC samples at 40 MHz sampling rate, capture filtered ADC samples at 20 MHz sampling rate, or capture packets at 20 MHz sampling rate after valid packet detection.
+   * - tx_tone
+     - | 0: Disable tone
+       | 1: Enable tone
+     - 0
+     - Action
+     - Enable/Disable transmit tone.
+   * - get_temperature
+     - | No arguments required
+     - N/A
+     - Action
+     - Get temperature.
+   * - get_rf_rssi
+     - | No arguments required
+     - N/A
+     - Action
+     - Get RF RSSI.
+   * - compute_optimal_xo_val
+     - N/A
+     - N/A
+     - Action
+     - Compute optimal XO trim value.
+   * - get_stats
+     - N/A
+     - N/A
+     - Action
+     - Display statistics.
+   * - tx_pkt_cw
+     - <val> - Contention window value to be used (0, 3, 7, 15, 31, 63, 127, 255, 511, 1023).
+     - 15
+     - Configuration
+     - Contention window for transmitted packets.
+   * - reg_domain
+     - <country code> - Desired country code(for example: NO, US, GB, IN).
+     - 00 (world regulatory)
+     - Action
+     - Configure WLAN regulatory domain country code.
+   * - bypass_reg_domain
+     - | 0: Use reg_domain
+       | 1: Do not use reg_domain
+     - 0
+     - Configuration
+     - Configure WLAN to bypass current regulatory domain in TX test.
+   * - set_ant_gain
+     - <val> - Antenna gain in dB (Min: 0, Max: 6)
+     - 0
+     - Configuration
+     - <val> is subtracted from the transmit power.
+   * - set_edge_bo
+     - <val> - Edge backoff in dB (Min: 0, Max: 10)
+     - 0
+     - Configuration
+     - If the channel is an edge channel, the value of <val> is subtracted from the transmit power.
+
+
+.. _wifi_radio_test_stats:
+
+Wi-Fi radio test statistics
+***************************
+
+.. list-table:: Wi-Fi radio test statistics
+   :header-rows: 1
+
+   * - Statistic
+     - Description
+   * - rssi_avg
+     - Average RSSI value in dBm.
+   * - ofdm_crc32_pass_cnt
+     - Number of OFDM frames whose CRC32 check passed.
+   * - ofdm_crc32_fail_cnt
+     - Number of OFDM frames whose CRC32 check failed.
+   * - dsss_crc32_pass_cnt
+     - Number of DSSS frames whose CRC32 check passed.
+   * - dsss_crc32_fail_cnt
+     - Number of DSSS frames whose CRC32 check failed.
diff --git a/samples/wifi/radio_test/single_domain/sample.yaml b/samples/wifi/radio_test/single_domain/sample.yaml
new file mode 100644
index 000000000000..647872f8480f
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/sample.yaml
@@ -0,0 +1,15 @@
+sample:
+  description: Wi-Fi BLE radio test sample single domain
+  name: Wi-Fi BLE radio test Single Domain
+tests:
+  sample.nrf70.wifi_ble_radio_test_sd:
+    sysbuild: true
+    build_only: true
+    extra_args:
+      - single_domain_SHIELD="nrf7002eb_interposer_p1;nrf7002eb"
+      - single_domain_SNIPPET=nrf70-wifi
+    integration_platforms:
+      - nrf54l15dk/nrf54l15/cpuapp
+    platform_allow:
+      - nrf54l15dk/nrf54l15/cpuapp
+    tags: ci_build sysbuild ci_samples_wifi
diff --git a/samples/wifi/radio_test/single_domain/sample_description.rst b/samples/wifi/radio_test/single_domain/sample_description.rst
new file mode 100644
index 000000000000..5dae60bc53c9
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/sample_description.rst
@@ -0,0 +1,657 @@
+.. _wifi_radio_sample_desc_sd:
+
+Sample description
+##################
+
+.. contents::
+   :local:
+   :depth: 2
+
+The Wi-Fi Radio test sample demonstrates how to configure the Wi-Fi® radio in a specific mode and then test its performance.
+The sample provides a set of predefined commands that allow you to configure the radio in the following modes:
+
+* Modulated carrier TX
+* Modulated carrier RX
+* Tone transmission
+* IQ sample capture at ADC output
+
+The sample also shows how to program the user region of FICR parameters on the development kit using a set of predefined commands.
+
+Requirements
+************
+
+The sample supports the following development kits:
+
+.. table-from-sample-yaml::
+
+Overview
+********
+
+To run the tests, connect to the development kit through the serial port and send shell commands.
+Zephyr's :ref:`zephyr:shell_api` module is used to handle the commands.
+
+You can start running ``wifi_radio_test`` subcommands to set up and control the radio.
+See :ref:`wifi_radio_test_subcmds` for a list of available subcommands.
+
+In the Modulated carrier RX mode, you can use the ``get_stats`` subcommand to display the statistics.
+See :ref:`wifi_radio_test_stats` for a list of available statistics.
+
+You can use ``wifi_radio_ficr_prog`` subcommands to read or write OTP registers.
+See :ref:`wifi_radio_ficr_prog_subcmds` for a list of available subcommands.
+
+.. note::
+
+   All the FICR registers are stored in the one-time programmable (OTP) memory.
+   Consequently, the write commands are destructive. Once written, the contents of the OTP registers cannot be reprogrammed.
+
+Building and running
+********************
+
+.. |sample path| replace:: :file:`samples/wifi/radio_test`
+
+.. include:: /includes/build_and_run.txt
+
+Currently, the following configurations are supported:
+
+* nRF7002 DK + QSPI
+* nRF7002 EK + SPIM
+
+
+To build for the nRF7002 DK, use the ``nrf7002dk/nrf5340/cpuapp`` board target.
+The following is an example of the CLI command:
+
+.. code-block:: console
+
+   west build -b nrf7002dk/nrf5340/cpuapp
+
+To build for the nRF7002 EK and nRF5340 DK, use the ``nrf5340dk/nrf5340/cpuapp`` board target with the ``SHIELD`` CMake option set to ``nrf7002ek``.
+The following is an example of the CLI command:
+
+.. code-block:: console
+
+   west build -b nrf5340dk/nrf5340/cpuapp -- -DSHIELD=nrf7002ek
+
+See also :ref:`cmake_options` for instructions on how to provide CMake options.
+
+.. note::
+   |54H_engb_2_8|
+
+
+Testing
+=======
+
+|test_sample|
+
+#. |connect_kit|
+#. |connect_terminal|
+#. Test the sample either by configuring the Wi-Fi radio or by programming the FICR parameters:
+
+   .. tabs::
+
+      .. group-tab:: Configuring the Wi-Fi radio
+
+         * To display the current configuration, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test show_config
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              ************* Configured Parameters ***********
+
+              tx_pkt_tput_mode = 0
+              tx_pkt_sgi = 0
+              tx_pkt_preamble = 0
+              tx_pkt_mcs = 0
+              tx_pkt_rate = 6
+              tx_pkt_gap = 0
+              phy_calib_rxdc = 1
+              phy_calib_txdc = 1
+              phy_calib_txpow = 0
+              phy_calib_rxiq = 1
+              phy_calib_txiq = 1
+              tx_pkt_num = -1
+              tx_pkt_len = 1400
+              tx_power = 30
+              he_ltf = 2
+              he_gi = 2
+              xo_val = 42
+              init = 1
+              tx = 0
+              rx = 0
+              tx_tone_freq = 0
+              rx_lna_gain = 0
+              rx_bb_gain = 0
+              rx_capture_length = 0
+              wlan_ant_switch_ctrl = 0
+              tx_pkt_cw = 15
+              reg_domain = 00
+              bypass_reg_domain = 0
+              ru_tone = 26
+              ru_index = 1
+
+         * To run a continuous Orthogonal frequency-division multiplexing (OFDM) TX traffic sequence with the following configuration:
+
+           * Channel: 11
+           * Frame duration: 2708 µs
+           * Inter-frame gap: 4200 µs
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 11
+              wifi_radio_test tx_pkt_rate 12
+              wifi_radio_test tx_pkt_len 4000
+              wifi_radio_test tx_power 4
+              wifi_radio_test tx_pkt_gap 4200
+              wifi_radio_test tx 1
+
+
+         * To run a continuous OFDM TX traffic sequence with the following configuration:
+
+           * Channel: 1
+           * Frame duration: 2708 µs
+           * Inter-frame gap: 4200 µs
+           * Edge backoff: 3 dB
+           * Antenna gain: 2 dB
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 1
+              wifi_radio_test tx_pkt_rate 12
+              wifi_radio_test tx_pkt_len 4000
+              wifi_radio_test tx_power 10
+              wifi_radio_test tx_pkt_gap 4200
+              wifi_radio_test set_edge_bo 3
+              wifi_radio_test set_ant_gain 2
+              wifi_radio_test tx 1
+
+         .. note::
+
+            Edge backoff and antenna gain are configured in the Kconfig file.
+            To overwrite these backoffs with user-specified backoffs, use the ``set_edge_bo`` and ``set_ant_gain`` commands.
+            These backoffs are applied only when the ``bypass_reg_domain`` is set to ``0``.
+
+
+
+         * To run a continuous Direct-sequence spread spectrum (DSSS) TX traffic sequence with the following configuration:
+
+           * Channel: 14
+           * Frame duration: 8500 µs
+           * Inter-frame gap: 8600 µs
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 14
+              wifi_radio_test tx_pkt_preamble 0
+              wifi_radio_test tx_pkt_rate 1
+              wifi_radio_test tx_pkt_len 1024
+              wifi_radio_test tx_power 10
+              wifi_radio_test tx_pkt_gap 8600
+              wifi_radio_test tx 1
+
+         See :ref:`wifi_radio_test_subcmds` for a list of available subcommands.
+
+         .. note::
+
+            * For regulatory certification, it is advisable to run the TX streams in Legacy OFDM or DSSS modes only (``wifi_radio_test tx_pkt_tput_mode 0``).
+            * The frame duration can be calculated using the formula:
+
+              .. math::
+
+                 D = ((L * 8) / R ) + P
+
+              where the following parameters are used:
+
+              * ``D`` - Frame duration (µs)
+              * ``L`` - Frame length (bytes)
+              * ``R`` - Data rate (Mbps)
+              * ``P`` - PHY overhead duration (µs) (values: 20 µs - Legacy OFDM, 192 µs - DSSS)
+
+         * To run a RX test with the following configuration:
+
+           * Channel: 11
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 11
+              wifi_radio_test rx 1
+
+         .. note::
+
+            After executing the above command sequence, start sending packets from a signal generator.
+
+
+         * To stop receiving packets, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test rx 0
+
+         .. note::
+
+            The above command should be executed only after the signal generator has completed transmitting packets.
+
+
+         * To get rx stats, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test get_stats
+
+           The sample below shows the output obtained after feeding 1000 DSSS packets:
+
+           .. code-block:: console
+
+              ************* PHY STATS ***********
+              rssi_avg = -45 dBm
+              ofdm_crc32_pass_cnt=0
+              ofdm_crc32_fail_cnt=0
+              dsss_crc32_pass_cnt=1000
+              dsss_crc32_fail_cnt=0
+
+           The sample below shows the output obtained after feeding 1000 OFDM packets:
+
+           .. code-block:: console
+
+              ************* PHY STATS ***********
+              rssi_avg = -47 dBm
+              ofdm_crc32_pass_cnt=1000
+              ofdm_crc32_fail_cnt=0
+              dsss_crc32_pass_cnt=0
+              dsss_crc32_fail_cnt=0
+
+
+         * To transmit a continuous tone with the following configuration:
+
+           * Channel: 144
+           * TX power: 10 dBm
+           * Tone frequency: 2 MHz
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 144
+              wifi_radio_test tx_power 10
+              wifi_radio_test tx_tone_freq 2
+              wifi_radio_test tx_tone 1
+
+
+
+         * To stop ongoing transmission of a continuous tone, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test tx_tone 0
+
+           .. note::
+
+              Use ``wifi_radio_test tx_tone 0`` only if the command issued before this is ``wifi_radio_test tx_tone 1``.
+
+
+         * To enable DPD hardware block, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test dpd 1
+
+
+         * To disable DPD hardware block, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test dpd 0
+
+         .. note::
+
+            DPD command can be used only during tone transmission.
+            For TX packet transmission, control of DPD hardware is taken care by firmware.
+
+
+         * To read chip temperature in degree Celsius, execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test get_temperature
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+               wifi_nrf: Temperature reading success:
+               wifi_nrf: The temperature is = 21 degree Celsius
+
+         * To measure RF RSSI status with the following configuration:
+
+           * Channel: 144
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 144
+              wifi_radio_test get_rf_rssi
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              wifi_nrf: RF RSSI value is = 0
+
+         .. note::
+
+            RF RSSI Status is a 3-bit indicator.
+            The higher the value of RF RSSI is, the higher is the level of saturation (non-linearity) at the LNA output.
+
+
+         * To compute the optimal XO value with the following configuration:
+
+           * Channel: 64
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 64
+              wifi_radio_test compute_optimal_xo_val
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              wifi_nrf: Best XO value is = 43
+
+         .. note::
+
+            * This test requires a DUT to be connected with VSG using cabled setup.
+              VSG should be continuously generating 0.5 MHz tone.
+            * For channel 64, set the VSG frequency to 5320.5 MHz.
+              Set the signal power level between -40 dBm and -50 dBm.
+
+
+
+         * To capture ADC samples with fixed RX gain with the following configuration:
+
+           * Channel: 144
+           * LNA gain: 2
+           * BB gain: 10
+           * Capture length: 64
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 144
+              wifi_radio_test rx_lna_gain 2
+              wifi_radio_test rx_bb_gain 10
+              wifi_radio_test rx_capture_length 64
+              wifi_radio_test rx_cap 0
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              ************* RX capture data ***********
+              E84FE4
+              EC4F74
+              F34F24
+              FBCF04
+              ......
+              ......
+              ......
+              F6C1B4
+              EEC178
+              E94114
+
+
+         .. note::
+
+            * This test requires a DUT to be connected with VSG using cabled setup.
+              VSG should be continuously transmitting a tone or packets.
+            * Set the signal power level between -35 dBm and -45 dBm to get non saturated samples.
+              In the example, capture is taken for 64 samples.
+              Each complex sample is of 24 bits.
+            * The captured samples will vary from run to run.
+
+
+         * To capture baseband samples with fixed RX gain with the following configuration:
+
+           * Channel: 144
+           * LNA gain: 2
+           * BB gain: 10
+           * Capture length: 64
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 144
+              wifi_radio_test rx_lna_gain 2
+              wifi_radio_test rx_bb_gain 10
+              wifi_radio_test rx_capture_length 64
+              wifi_radio_test rx_cap 1
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              ************* RX capture data ***********
+              E940F0
+              E8EFE7
+              F3FF29
+              03CF27
+              ......
+              ......
+              ......
+              0DAF9B
+              115097
+              08A178
+
+
+         .. note::
+
+            * This test requires a DUT to be connected with VSG using cabled setup.
+              VSG should be continuously transmitting a tone or packets.
+            * Set the signal power level between -35 dBm and -45 dBm to get non saturated samples.
+            *  In the example, capture is taken for 64 samples.
+               Each complex sample is of 24 bits.
+            * The captured samples will vary from run to run.
+
+
+
+         * To capture AGC adjusted baseband samples after WLAN packet detection with the following configuration:
+
+           * Channel: 144
+           * Capture length: 64
+
+           Execute the following sequence of commands:
+
+           .. code-block:: console
+
+              wifi_radio_test init 144
+              wifi_radio_test rx_capture_length 64
+              wifi_radio_test rx_capture_timeout 10
+              wifi_radio_test rx_cap 2
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              ************* RX capture data ***********
+              062058
+              F8A31F
+              E9A05D
+              E800B9
+              ......
+              ......
+              ......
+              EA5FE4
+              FDDF45
+              07CF3D
+
+           Packet detection does not take place in a clean RF environment, producing the following output:
+
+           .. code-block:: console
+
+              ************* Packet detection failed ***********
+
+         .. note::
+
+            * This test requires a DUT to be connected with VSG using cabled setup.
+              VSG should be continuously transmitting WLAN packets.
+            * Set the desired signal power.
+            * The capture is taken for 64 samples.
+              Each complex sample is of 24 bits.
+              The captured samples will vary from run to run.
+            * The capture is taken after WLAN packet detection, so it will not have the first few samples in the first WLAN packet.
+            * Smaller packets should be used so that multiple packets can be seen in the capture.
+            * Packet detection does not take place in a clean RF environment.
+            * The command will timeout if no packets are detected within set timeout period.
+
+         * To set a regulatory domain with the following configuration:
+
+           * Regulatory domain: US
+
+           Execute the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test reg_domain US
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              wifi_radio_test show_config
+              reg_domain = US
+
+         .. note::
+
+            The default regulatory domain is ``00`` (world regulatory).
+
+         * To bypass regulatory domain, set ``bypass_reg_domain`` to ``1`` using the following command:
+
+           .. code-block:: console
+
+              wifi_radio_test bypass_reg_domain 1
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+               wifi_radio_test show_config
+               reg_domain = US
+               bypass_reg_domain = 1
+
+         .. note::
+
+            Bypass regulatory domain is false by default.
+
+            If ``bypass_reg_domain`` is ``0``, then TX power of the channel will be configured to the minimum value of the user configured TX power value and maximum power supported in the configured regulatory domain.
+
+            If ``bypass_reg_domain`` is ``1``, then user configured TX power value will be set overriding current configured regulatory domain maximum TX power for the channel.
+
+      .. group-tab:: FICR/OTP programming
+
+         * Use the following reference command interface to read or write the OTP params:
+
+           .. code-block:: console
+
+              wifi_radio_ficr_prog <subcommand> [Offset] [arg1] [arg2] .. [argN]
+
+         * To display all the current FICR values, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_ficr_prog otp_read_params
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              OTP Region is open for R/W
+
+              REGION_PROTECT0 = 0x50fa50fa
+              REGION_PROTECT1 = 0x50fa50fa
+              REGION_PROTECT2 = 0x50fa50fa
+              REGION_PROTECT3 = 0x50fa50fa
+
+              MAC0: Reg0 = 0x0036cef0
+              MAC0: Reg1 = 0x00004a00
+              MAC0 Addr  = f0:ce:36:00:00:4a
+
+              MAC1 : Reg0 = 0x0036cef0
+              MAC1 : Reg1 = 0x00004b00
+              MAC1 Addr   = f0:ce:36:00:00:4b
+
+              CALIB_XO = 0x2c
+
+              CALIB_MAXPOW2G4 = 0xffffffff
+
+              CALIB_MAXPOW5G0MCS7 = 0xffffffff
+
+              CALIB_MAXPOW5G0MCS0 = 0xffffffff
+
+              REGION_DEFAULTS = 0xfffffff1
+
+         * To read the status of OTP region, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_ficr_prog otp_get_status
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              Checking OTP PROTECT Region......
+              OTP Region is open for R/W
+
+              QSPI Keys are not programmed in OTP
+              MAC0 Address is programmed in OTP
+              MAC1 Address is programmed in OTP
+              CALIB_XO is programmed in OTP
+              CALIB_MAXPOW2G4 is not programmed in OTP
+              CALIB_MAXPOW5G0MCS7 is not programmed in OTP
+              CALIB_MAXPOW5G0MCS0 is not programmed in OTP
+
+         * To write different locations of the OTP and to program MAC0 address to F0:CE:36:00:00:4A, use the following command:
+
+           .. code-block:: console
+
+              wifi_radio_ficr_prog otp_write_params 0x120 0x0036CEF0 0x4A00
+
+           The sample shows the following output:
+
+           .. code-block:: console
+
+              [00:24:25.200,622] <inf> otp_prog: OTP Region is open for R/W
+              [00:24:25.200,653] <inf> otp_prog:
+              [00:24:25.202,575] <inf> otp_prog: Written MAC address 1
+              [00:24:25.202,575] <inf> otp_prog: mac addr 0 : Reg1 (0x128) = 0x36cef0
+              [00:24:25.202,575] <inf> otp_prog: mac addr 0 : Reg2 (0x12c) = 0x4a00
+              [00:24:25.202,606] <inf> otp_prog: Written REGION_DEFAULTS (0x154) : 0xfffffffb
+              [00:24:25.203,002] <inf> otp_prog: Finished Writing OTP params
+
+         See :ref:`wifi_radio_ficr_prog_subcmds` for a list of available subcommands.
+
+
+Dependencies
+************
+
+This sample uses the following Zephyr library:
+
+* :ref:`zephyr:shell_api`:
+
+  * :file:`include/shell/shell.h`
diff --git a/samples/wifi/radio_test/single_domain/src/ficr_prog.c b/samples/wifi/radio_test/single_domain/src/ficr_prog.c
new file mode 100644
index 000000000000..58fd4dcf0cb4
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/ficr_prog.c
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2024 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+/* @file
+ * @brief NRF Wi-Fi radio FICR programming functions
+ */
+
+#include <zephyr/logging/log.h>
+#include <zephyr/kernel.h>
+#include <zephyr/drivers/wifi/nrf_wifi/bus/rpu_hw_if.h>
+
+#include "rpu_if.h"
+#include "ficr_prog.h"
+
+
+LOG_MODULE_DECLARE(otp_prog, CONFIG_WIFI_LOG_LEVEL);
+
+static void write_word(unsigned int addr, unsigned int data)
+{
+	rpu_write(addr, &data, 4);
+}
+
+static void read_word(unsigned int addr, unsigned int *data)
+{
+	rpu_read(addr, data, 4);
+}
+
+unsigned int check_protection(unsigned int *buff, unsigned int off1, unsigned int off2,
+		    unsigned int off3, unsigned int off4)
+{
+	if ((buff[off1] == OTP_PROGRAMMED) &&
+		(buff[off2] == OTP_PROGRAMMED)  &&
+		(buff[off3] == OTP_PROGRAMMED) &&
+		(buff[off4] == OTP_PROGRAMMED))
+		return OTP_PROGRAMMED;
+	else if ((buff[off1] == OTP_FRESH_FROM_FAB) &&
+		(buff[off2] == OTP_FRESH_FROM_FAB) &&
+		(buff[off3] == OTP_FRESH_FROM_FAB) &&
+		(buff[off4] == OTP_FRESH_FROM_FAB))
+		return OTP_FRESH_FROM_FAB;
+	else if ((buff[off1] == OTP_ENABLE_PATTERN) &&
+		(buff[off2] == OTP_ENABLE_PATTERN) &&
+		(buff[off3] == OTP_ENABLE_PATTERN) &&
+		(buff[off4] == OTP_ENABLE_PATTERN))
+		return OTP_ENABLE_PATTERN;
+	else
+		return OTP_INVALID;
+}
+
+
+static void set_otp_timing_reg_40mhz(void)
+{
+	write_word(OTP_TIMING_REG1_ADDR, OTP_TIMING_REG1_VAL);
+	write_word(OTP_TIMING_REG2_ADDR, OTP_TIMING_REG2_VAL);
+}
+
+static int poll_otp_ready(void)
+{
+	int otp_mem_status = 0;
+	int poll = 0;
+
+	while (poll != 100) {
+		read_word(OTP_POLL_ADDR, &otp_mem_status);
+
+		if ((otp_mem_status & OTP_READY) == OTP_READY) {
+			return 0;
+		}
+		poll++;
+	}
+	LOG_ERR("OTP is not ready");
+	return -ENOEXEC;
+}
+
+
+static int req_otp_standby_mode(void)
+{
+	write_word(OTP_RWSBMODE_ADDR, 0x0);
+	return poll_otp_ready();
+}
+
+
+static int otp_wr_voltage_2V5(void)
+{
+	int err;
+
+	err = req_otp_standby_mode();
+
+	if (err) {
+		LOG_ERR("Failed Setting OTP voltage IOVDD to 2.5V");
+		return -ENOEXEC;
+	}
+	write_word(OTP_VOLTCTRL_ADDR, OTP_VOLTCTRL_2V5);
+	return 0;
+}
+
+static int poll_otp_read_valid(void)
+{
+	int otp_mem_status = 0;
+	int poll = 0;
+
+	while (poll < 100) {
+		read_word(OTP_POLL_ADDR, &otp_mem_status);
+
+		if ((otp_mem_status & OTP_READ_VALID) == OTP_READ_VALID) {
+			return 0;
+		}
+		poll++;
+	}
+	LOG_ERR("%s: OTP read failed", __func__);
+	return -ENOEXEC;
+}
+
+static int poll_otp_wrdone(void)
+{
+	int otp_mem_status = 0;
+	int poll = 0;
+
+	while (poll < 100) {
+		read_word(OTP_POLL_ADDR, &otp_mem_status);
+
+		if ((otp_mem_status & OTP_WR_DONE) == OTP_WR_DONE) {
+			return 0;
+		}
+		poll++;
+	}
+	LOG_ERR("%s: OTP write done failed", __func__);
+	return -ENOEXEC;
+}
+
+static int req_otp_read_mode(void)
+{
+	write_word(OTP_RWSBMODE_ADDR, OTP_READ_MODE);
+	return poll_otp_ready();
+}
+
+
+static int req_otp_byte_write_mode(void)
+{
+	write_word(OTP_RWSBMODE_ADDR, OTP_BYTE_WRITE_MODE);
+	return poll_otp_ready();
+}
+
+static unsigned int read_otp_location(unsigned int offset, unsigned int *read_val)
+{
+	int err;
+
+	write_word(OTP_RDENABLE_ADDR,  offset);
+	err = poll_otp_read_valid();
+	if (err) {
+		LOG_ERR("OTP read failed");
+		return err;
+	}
+	read_word(OTP_READREG_ADDR, read_val);
+
+	return 0;
+}
+
+static int  write_otp_location(unsigned int otp_location_offset, unsigned int otp_data)
+{
+	write_word(OTP_WRENABLE_ADDR,  otp_location_offset);
+	write_word(OTP_WRITEREG_ADDR,  otp_data);
+
+	return poll_otp_wrdone();
+}
+
+
+static int otp_rd_voltage_1V8(void)
+{
+	int err;
+
+	err = req_otp_standby_mode();
+	if (err) {
+		LOG_ERR("error in %s", __func__);
+		return err;
+	}
+	write_word(OTP_VOLTCTRL_ADDR, OTP_VOLTCTRL_1V8);
+
+	return 0;
+}
+
+static int update_mac_addr(unsigned int index, unsigned int *write_val)
+{
+	int ret = 0;
+
+	for (int i = 0; i < 2; i++) {
+		ret = write_otp_location(MAC0_ADDR + 2 * index + i, write_val[i]);
+		if (ret == -ENOEXEC) {
+			LOG_ERR("FICR: Failed to update MAC ADDR%d", index);
+			break;
+		}
+		LOG_INF("mac addr %d : Reg%d (0x%x) = 0x%04x",
+					index, (i+1), (MAC0_ADDR + i) << 2, write_val[i]);
+	}
+	return ret;
+}
+
+int write_otp_memory(unsigned int otp_addr, unsigned int *write_val)
+{
+	int err = 0;
+	int	mask_val;
+	int ret = 0;
+	int retrim_loc = 0;
+
+	err = poll_otp_ready();
+	if (err) {
+		LOG_ERR("err in otp ready poll");
+		return err;
+	}
+
+	set_otp_timing_reg_40mhz();
+
+	err = otp_wr_voltage_2V5();
+	if (err) {
+		LOG_ERR("error in write_voltage 2V5");
+		goto _exit_otp_write;
+	}
+
+	err = req_otp_byte_write_mode();
+	if (err) {
+		LOG_ERR("error in OTP byte write mode");
+		goto _exit_otp_write;
+	}
+
+	switch (otp_addr) {
+	case REGION_PROTECT:
+		write_otp_location(REGION_PROTECT, write_val[0]);
+		write_otp_location(REGION_PROTECT+1, write_val[0]);
+		write_otp_location(REGION_PROTECT+2, write_val[0]);
+		write_otp_location(REGION_PROTECT+3, write_val[0]);
+
+		LOG_INF("Written REGION_PROTECT0 (0x%x) : 0x%04x",
+						(REGION_PROTECT << 2), write_val[0]);
+		LOG_INF("Written REGION_PROTECT1 (0x%x) : 0x%04x",
+						(REGION_PROTECT+1) << 2, write_val[0]);
+		LOG_INF("Written REGION_PROTECT2 (0x%x) : 0x%04x",
+						(REGION_PROTECT+2) << 2, write_val[0]);
+		LOG_INF("Written REGION_PROTECT3 (0x%x) : 0x%04x",
+						(REGION_PROTECT+3) << 2, write_val[0]);
+		break;
+	case QSPI_KEY:
+		mask_val = QSPI_KEY_FLAG_MASK;
+		for (int i = 0; i < QSPI_KEY_LENGTH_BYTES / 4; i++) {
+			ret = write_otp_location(QSPI_KEY + i, write_val[i]);
+			if (ret == -ENOEXEC) {
+				LOG_ERR("FICR: Failed to write QSPI key offset-%d", QSPI_KEY + i);
+				goto _exit_otp_write;
+			}
+			LOG_INF("Written QSPI_KEY0 (0x%x) : 0x%04x",
+						(QSPI_KEY + i) << 2, write_val[i]);
+		}
+		write_otp_location(REGION_DEFAULTS, mask_val);
+		LOG_INF("Written REGION_DEFAULTS (0x%x) : 0x%04x",
+						(REGION_DEFAULTS) << 2, mask_val);
+		break;
+	case MAC0_ADDR:
+		mask_val = MAC0_ADDR_FLAG_MASK;
+		ret = update_mac_addr(0, write_val);
+		if (ret == -ENOEXEC) {
+			goto _exit_otp_write;
+		}
+
+		write_otp_location(REGION_DEFAULTS, mask_val);
+		LOG_INF("Written MAC address 0");
+		LOG_INF("Written REGION_DEFAULTS (0x%x) : 0x%04x",
+						(REGION_DEFAULTS) << 2, mask_val);
+		break;
+	case MAC1_ADDR:
+		mask_val = MAC1_ADDR_FLAG_MASK;
+		ret = update_mac_addr(1, write_val);
+		if (ret == -ENOEXEC) {
+			goto _exit_otp_write;
+		}
+		write_otp_location(REGION_DEFAULTS, mask_val);
+		LOG_INF("Written MAC address 1");
+		LOG_INF("Written REGION_DEFAULTS (0x%x) : 0x%04x",
+						(REGION_DEFAULTS) << 2, mask_val);
+		break;
+	case CALIB_XO:
+		mask_val = CALIB_XO_FLAG_MASK;
+		ret = write_otp_location(CALIB_XO, write_val[0]);
+
+		if (ret == -ENOEXEC) {
+			LOG_ERR("XO_Update Exception");
+			goto _exit_otp_write;
+		} else {
+			write_otp_location(REGION_DEFAULTS, mask_val);
+
+			LOG_INF("Written CALIB_XO (0x%x) to 0x%04x",
+						CALIB_XO << 2, write_val[0]);
+			LOG_INF("Written REGION_DEFAULTS (0x%x) : 0x%04x",
+						(REGION_DEFAULTS) << 2, mask_val);
+		}
+		break;
+	case PRODRETEST_PROGVERSION:
+		ret = write_otp_location(PRODRETEST_PROGVERSION, *write_val);
+
+		if (ret == -ENOEXEC) {
+			LOG_ERR("PRODRETEST.PROGVERSION_Update Exception");
+			goto _exit_otp_write;
+		} else {
+			LOG_INF("Written PRODRETEST.PROGVERSION 0x%04x", *write_val);
+		}
+		break;
+	case PRODRETEST_TRIM0:
+	case PRODRETEST_TRIM1:
+	case PRODRETEST_TRIM2:
+	case PRODRETEST_TRIM3:
+	case PRODRETEST_TRIM4:
+	case PRODRETEST_TRIM5:
+	case PRODRETEST_TRIM6:
+	case PRODRETEST_TRIM7:
+	case PRODRETEST_TRIM8:
+	case PRODRETEST_TRIM9:
+	case PRODRETEST_TRIM10:
+	case PRODRETEST_TRIM11:
+	case PRODRETEST_TRIM12:
+	case PRODRETEST_TRIM13:
+	case PRODRETEST_TRIM14:
+		retrim_loc = otp_addr - PRODRETEST_TRIM0;
+		ret = write_otp_location(otp_addr, *write_val);
+
+		if (ret == -ENOEXEC) {
+			LOG_ERR("PRODRETEST.TRIM_Update Exception");
+			goto _exit_otp_write;
+		} else {
+			LOG_INF("Written PRODRETEST.TRIM%d 0x%04x",
+						retrim_loc, *write_val);
+		}
+		break;
+	case REGION_DEFAULTS:
+		write_otp_location(REGION_DEFAULTS, write_val[0]);
+
+		LOG_INF("Written REGION_DEFAULTS (0x%x) to 0x%04x",
+						REGION_DEFAULTS << 2, write_val[0]);
+		break;
+	default:
+		LOG_ERR("unknown field received: %d", otp_addr);
+
+	}
+	return ret;
+
+_exit_otp_write:
+	err  = req_otp_standby_mode();
+	err |= otp_rd_voltage_1V8();
+	return err;
+}
+
+int read_otp_memory(unsigned int otp_addr, unsigned int *read_val, int len)
+{
+	int	err;
+
+	err = poll_otp_ready();
+	if (err) {
+		LOG_ERR("err in otp ready poll");
+		return -ENOEXEC;
+	}
+
+	set_otp_timing_reg_40mhz();
+
+	err = otp_rd_voltage_1V8();
+	if (err) {
+		LOG_ERR("error in read_voltage 1V8");
+		return -ENOEXEC;
+	}
+
+	err = req_otp_read_mode();
+	if (err) {
+		LOG_ERR("error in req_otp_read_mode()");
+		return -ENOEXEC;
+	}
+
+	for (int i = 0; i < len; i++) {
+		read_otp_location(otp_addr + i, &read_val[i]);
+	}
+
+	return req_otp_standby_mode();
+}
diff --git a/samples/wifi/radio_test/single_domain/src/ficr_prog.h b/samples/wifi/radio_test/single_domain/src/ficr_prog.h
new file mode 100644
index 000000000000..a9c3eb424841
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/ficr_prog.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2024 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+/**
+ * @brief Header containing address/offets and functions for writing
+ * the FICR fields of the OTP memory on nRF7002 device
+ */
+
+#ifndef __OTP_PROG_H_
+#define __OTP_PROG_H_
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int write_otp_memory(unsigned int otp_addr, unsigned int *write_val);
+int read_otp_memory(unsigned int otp_addr, unsigned int *read_val, int len);
+unsigned int check_protection(unsigned int *buff, unsigned int off1, unsigned int off2,
+					unsigned int off3, unsigned int off4);
+
+#endif /* __OTP_PROG_H_ */
diff --git a/samples/wifi/radio_test/single_domain/src/main.c b/samples/wifi/radio_test/single_domain/src/main.c
new file mode 100644
index 000000000000..c5a498383692
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/main.c
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2020 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include <zephyr/sys/printk.h>
+#include <zephyr/drivers/clock_control.h>
+#include <zephyr/drivers/clock_control/nrf_clock_control.h>
+#if defined(NRF54L15_XXAA)
+#include <hal/nrf_clock.h>
+#endif /* defined(NRF54L15_XXAA) */
+#if defined(CONFIG_CLOCK_CONTROL_NRF2)
+#include <hal/nrf_lrcconf.h>
+#endif
+
+#if defined(CONFIG_CLOCK_CONTROL_NRF)
+static void clock_init(void)
+{
+	int err;
+	int res;
+	struct onoff_manager *clk_mgr;
+	struct onoff_client clk_cli;
+
+	clk_mgr = z_nrf_clock_control_get_onoff(CLOCK_CONTROL_NRF_SUBSYS_HF);
+	if (!clk_mgr) {
+		printk("Unable to get the Clock manager\n");
+		return;
+	}
+
+	sys_notify_init_spinwait(&clk_cli.notify);
+
+	err = onoff_request(clk_mgr, &clk_cli);
+	if (err < 0) {
+		printk("Clock request failed: %d\n", err);
+		return;
+	}
+
+	do {
+		err = sys_notify_fetch_result(&clk_cli.notify, &res);
+		if (!err && res) {
+			printk("Clock could not be started: %d\n", res);
+			return;
+		}
+	} while (err);
+
+#if defined(NRF54L15_XXAA)
+	/* MLTPAN-20 */
+	nrf_clock_task_trigger(NRF_CLOCK, NRF_CLOCK_TASK_PLLSTART);
+#endif /* defined(NRF54L15_XXAA) */
+
+	printk("Clock has started\n");
+}
+
+#elif defined(CONFIG_CLOCK_CONTROL_NRF2)
+
+static void clock_init(void)
+{
+	int err;
+	int res;
+	const struct device *radio_clk_dev =
+		DEVICE_DT_GET_OR_NULL(DT_CLOCKS_CTLR(DT_NODELABEL(radio)));
+	struct onoff_client radio_cli;
+
+	/** Keep radio domain powered all the time to reduce latency. */
+	nrf_lrcconf_poweron_force_set(NRF_LRCCONF010, NRF_LRCCONF_POWER_DOMAIN_1, true);
+
+	sys_notify_init_spinwait(&radio_cli.notify);
+
+	err = nrf_clock_control_request(radio_clk_dev, NULL, &radio_cli);
+
+	do {
+		err = sys_notify_fetch_result(&radio_cli.notify, &res);
+		if (!err && res) {
+			printk("Clock could not be started: %d\n", res);
+			return;
+		}
+	} while (err == -EAGAIN);
+
+#if defined(NRF54L15_XXAA)
+	/* MLTPAN-20 */
+	nrf_clock_task_trigger(NRF_CLOCK, NRF_CLOCK_TASK_PLLSTART);
+#endif /* defined(NRF54L15_XXAA) */
+
+	printk("Clock has started\n");
+}
+
+#else
+BUILD_ASSERT(false, "No Clock Control driver");
+#endif /* defined(CONFIG_CLOCK_CONTROL_NRF) */
+
+int main(void)
+{
+	printk("Starting Radio Test example\n");
+
+	clock_init();
+
+#if defined(CONFIG_SOC_SERIES_NRF54HX)
+	/* Apply HMPAN-102 workaround for nRF54H series */
+	*(volatile uint32_t *)0x5302C7E4 =
+				(((*((volatile uint32_t *)0x5302C7E4)) & 0xFF000FFF) | 0x0012C000);
+#endif
+
+	return 0;
+}
diff --git a/samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_ficr_shell.c b/samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_ficr_shell.c
new file mode 100644
index 000000000000..6581718ecff7
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_ficr_shell.c
@@ -0,0 +1,528 @@
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+/* @file
+ * @brief NRF Wi-Fi radio test shell module
+ */
+
+#include <zephyr/logging/log.h>
+#include <fmac_main.h>
+#include <util.h>
+#include <nrf_wifi_radio_test_shell.h>
+#include "ficr_prog.h"
+
+#include "fmac_api_common.h"
+
+extern struct nrf_wifi_drv_priv_zep rpu_drv_priv_zep;
+static struct nrf_wifi_ctx_zep *ctx = &rpu_drv_priv_zep.rpu_ctx_zep;
+
+LOG_MODULE_REGISTER(otp_prog, CONFIG_WIFI_LOG_LEVEL);
+
+static void disp_location_status(const struct shell *shell, char *region, unsigned int ret)
+{
+	switch (ret) {
+
+	case OTP_PROGRAMMED:
+		shell_fprintf(shell, SHELL_INFO, "%s Region is locked!!!\n", region);
+		break;
+	case OTP_ENABLE_PATTERN:
+		shell_fprintf(shell, SHELL_INFO, "%s Region is open for R/W\n", region);
+		break;
+	case OTP_FRESH_FROM_FAB:
+		shell_fprintf(shell, SHELL_INFO,
+				"%s Region is unprogrammed - program to enable R/W\n", region);
+		break;
+	default:
+		shell_fprintf(shell, SHELL_ERROR, "%s Region is in invalid state\n", region);
+		break;
+	}
+	shell_fprintf(shell, SHELL_INFO, "\n");
+}
+
+static void disp_fields_status(const struct shell *shell, unsigned int flags)
+{
+	if (flags & (~QSPI_KEY_FLAG_MASK)) {
+		shell_fprintf(shell, SHELL_INFO, "QSPI Keys are not programmed in OTP\n");
+	} else {
+		shell_fprintf(shell, SHELL_INFO, "QSPI Keys are programmed in OTP\n");
+	}
+
+	if (flags & (~MAC0_ADDR_FLAG_MASK)) {
+		shell_fprintf(shell, SHELL_INFO, "MAC0 Address are not programmed in OTP\n");
+	} else {
+		shell_fprintf(shell, SHELL_INFO, "MAC0 Address is programmed in OTP\n");
+	}
+
+	if (flags & (~MAC1_ADDR_FLAG_MASK)) {
+		shell_fprintf(shell, SHELL_INFO, "MAC1 Address are not programmed in OTP\n");
+	} else {
+		shell_fprintf(shell, SHELL_INFO, "MAC1 Address is programmed in OTP\n");
+	}
+
+	if (flags & (~CALIB_XO_FLAG_MASK)) {
+		shell_fprintf(shell, SHELL_INFO, "CALIB_XO is not programmed in OTP\n");
+	} else {
+		shell_fprintf(shell, SHELL_INFO, "CALIB_XO is programmed in OTP\n");
+	}
+}
+
+
+static int nrf_wifi_radio_test_otp_get_status(const struct shell *shell,
+					size_t argc,
+					char  *argv[])
+{
+	unsigned int ret, err;
+	unsigned int val[OTP_MAX_WORD_LEN];
+
+	/* read all the OTP memory */
+	err = read_otp_memory(0, &val[0], OTP_MAX_WORD_LEN);
+	if (err) {
+		shell_fprintf(shell, SHELL_ERROR, "FAILED reading otp memory......\n");
+		return -ENOEXEC;
+	}
+
+	shell_fprintf(shell, SHELL_INFO, "Checking OTP PROTECT Region......\n");
+	ret = check_protection(&val[0], REGION_PROTECT, REGION_PROTECT + 1,
+							REGION_PROTECT + 2, REGION_PROTECT + 3);
+
+	disp_location_status(shell, "OTP", ret);
+	disp_fields_status(shell, val[REGION_DEFAULTS]);
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_otp_read_params(const struct shell *shell,
+					size_t argc,
+					char  *argv[])
+{
+	unsigned int val[OTP_MAX_WORD_LEN];
+	unsigned int ret, err;
+
+	err = read_otp_memory(0, &val[0], OTP_MAX_WORD_LEN);
+	if (err) {
+		shell_fprintf(shell, SHELL_ERROR, "FAILED reading otp memory......\n");
+		return -ENOEXEC;
+	}
+
+	ret = check_protection(&val[0], REGION_PROTECT + 0, REGION_PROTECT + 1,
+							REGION_PROTECT + 2, REGION_PROTECT + 3);
+	disp_location_status(shell, "OTP", ret);
+
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.FT.PROGVERSION = 0x%08x\n",
+		val[PRODTEST_FT_PROGVERSION]);
+	shell_fprintf(shell, SHELL_INFO, "\n");
+
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM0 = 0x%08x\n", val[PRODTEST_TRIM0]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM1 = 0x%08x\n", val[PRODTEST_TRIM1]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM2 = 0x%08x\n", val[PRODTEST_TRIM2]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM3 = 0x%08x\n", val[PRODTEST_TRIM3]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM4 = 0x%08x\n", val[PRODTEST_TRIM4]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM5 = 0x%08x\n", val[PRODTEST_TRIM5]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM6 = 0x%08x\n", val[PRODTEST_TRIM6]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM7 = 0x%08x\n", val[PRODTEST_TRIM7]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM8 = 0x%08x\n", val[PRODTEST_TRIM8]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM9 = 0x%08x\n", val[PRODTEST_TRIM9]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM10 = 0x%08x\n",
+		val[PRODTEST_TRIM10]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM11 = 0x%08x\n",
+		val[PRODTEST_TRIM11]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM12 = 0x%08x\n",
+		val[PRODTEST_TRIM12]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM13 = 0x%08x\n",
+		val[PRODTEST_TRIM13]);
+	shell_fprintf(shell, SHELL_INFO, "PRODTEST.TRIM14 = 0x%08x\n",
+		val[PRODTEST_TRIM14]);
+	shell_fprintf(shell, SHELL_INFO, "\n");
+
+	shell_fprintf(shell, SHELL_INFO, "INFO.PART = 0x%08x\n", val[INFO_PART]);
+	shell_fprintf(shell, SHELL_INFO, "INFO.VARIANT = 0x%08x\n", val[INFO_VARIANT]);
+	shell_fprintf(shell, SHELL_INFO, "\n");
+
+	shell_fprintf(shell, SHELL_INFO, "INFO.UUID0 = 0x%08x\n", val[INFO_UUID + 0]);
+	shell_fprintf(shell, SHELL_INFO, "INFO.UUID1 = 0x%08x\n", val[INFO_UUID + 1]);
+	shell_fprintf(shell, SHELL_INFO, "INFO.UUID2 = 0x%08x\n", val[INFO_UUID + 2]);
+	shell_fprintf(shell, SHELL_INFO, "INFO.UUID3 = 0x%08x\n", val[INFO_UUID + 3]);
+	shell_fprintf(shell, SHELL_INFO, "\n");
+
+	shell_fprintf(shell, SHELL_INFO, "REGION.PROTECT0 = 0x%08x\n", val[REGION_PROTECT + 0]);
+	shell_fprintf(shell, SHELL_INFO, "REGION.PROTECT1 = 0x%08x\n", val[REGION_PROTECT + 1]);
+	shell_fprintf(shell, SHELL_INFO, "REGION.PROTECT2 = 0x%08x\n", val[REGION_PROTECT + 2]);
+	shell_fprintf(shell, SHELL_INFO, "REGION.PROTECT3 = 0x%08x\n", val[REGION_PROTECT + 3]);
+	shell_fprintf(shell, SHELL_INFO, "\n");
+
+	if (val[REGION_PROTECT + 0] != OTP_FRESH_FROM_FAB) {
+		shell_fprintf(shell, SHELL_INFO, "MAC0.ADDRESS0 = 0x%08x\n", val[MAC0_ADDR]);
+		shell_fprintf(shell, SHELL_INFO, "MAC0.ADDRESS1 = 0x%08x\n", val[MAC0_ADDR + 1]);
+		shell_fprintf(shell, SHELL_INFO, "MAC0.ADDRESS = %02x:%02x:%02x:%02x:%02x:%02x\n",
+			(uint8_t)(val[MAC0_ADDR]), (uint8_t)(val[MAC0_ADDR] >> 8),
+			(uint8_t)(val[MAC0_ADDR] >> 16), (uint8_t)(val[MAC0_ADDR] >> 24),
+			(uint8_t)(val[MAC0_ADDR + 1]), (uint8_t)(val[MAC0_ADDR + 1] >> 8));
+		shell_fprintf(shell, SHELL_INFO, "\n");
+
+		shell_fprintf(shell, SHELL_INFO, "MAC1.ADDRESS0 = 0x%08x\n", val[MAC1_ADDR]);
+		shell_fprintf(shell, SHELL_INFO, "MAC1.ADDRESS1 = 0x%08x\n", val[MAC1_ADDR + 1]);
+		shell_fprintf(shell, SHELL_INFO, "MAC1.ADDRESS = %02x:%02x:%02x:%02x:%02x:%02x\n",
+			(uint8_t)(val[MAC1_ADDR]), (uint8_t)(val[MAC1_ADDR] >> 8),
+			(uint8_t)(val[MAC1_ADDR] >> 16), (uint8_t)(val[MAC1_ADDR] >> 24),
+			(uint8_t)(val[MAC1_ADDR + 1]), (uint8_t)(val[MAC1_ADDR + 1] >> 8));
+		shell_fprintf(shell, SHELL_INFO, "\n");
+
+		shell_fprintf(shell, SHELL_INFO, "CALIB.XO = 0x%02x\n", val[CALIB_XO] & 0xFF);
+
+		shell_fprintf(shell, SHELL_INFO, "REGION_DEFAULTS = 0x%08x\n",
+			val[REGION_DEFAULTS]);
+		shell_fprintf(shell, SHELL_INFO, "\n");
+	}
+	return 0;
+}
+
+static int nrf_wifi_radio_test_otp_read_retrim_version(const struct shell *shell,
+					size_t argc,
+					char  *argv[])
+{
+	unsigned int val[1];
+	unsigned int err;
+
+	err = read_otp_memory(REGION_PROTECT, &val[0], 1);
+	if (err) {
+		shell_fprintf(shell, SHELL_ERROR, "FAILED reading otp memory......\n");
+		return -ENOEXEC;
+	}
+
+	if (val[0] == OTP_FRESH_FROM_FAB) {
+		shell_fprintf(shell, SHELL_ERROR,
+				"Region is unprogrammed - program to enable R/W\n");
+	} else {
+		err = read_otp_memory(PRODRETEST_PROGVERSION, &val[0], 1);
+		shell_fprintf(shell, SHELL_INFO, "\nPRODRETEST.PROGVERSION = 0x%08x\n",
+		val[0]);
+		shell_fprintf(shell, SHELL_INFO, "\n");
+	}
+	return 0;
+}
+
+static int nrf_wifi_radio_test_otp_read_retrim_params(const struct shell *shell,
+					size_t argc,
+					char  *argv[])
+{
+	unsigned int val[RETRIM_LEN];
+	unsigned int err;
+
+	err = read_otp_memory(REGION_PROTECT, val, 1);
+	if (err) {
+		shell_fprintf(shell, SHELL_ERROR, "FAILED reading otp memory......\n");
+		return -ENOEXEC;
+	}
+
+	if (val[0] == OTP_FRESH_FROM_FAB) {
+		shell_fprintf(shell, SHELL_ERROR,
+				"Region is unprogrammed - program to enable R/W\n");
+	} else {
+		shell_fprintf(shell, SHELL_INFO, "\n");
+		err = read_otp_memory(PRODRETEST_TRIM0, val, RETRIM_LEN);
+		for (int i = 0; i < RETRIM_LEN; i++) {
+			shell_fprintf(shell, SHELL_INFO, "PRODRETEST.TRIM%d = 0x%08x\n", i, val[i]);
+		}
+		shell_fprintf(shell, SHELL_INFO, "\n");
+	}
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_otp_write_params(const struct shell *shell,
+					size_t argc,
+					char  *argv[])
+{
+	unsigned int field;
+	unsigned int write_val[20];
+	unsigned int val[OTP_MAX_WORD_LEN];
+	unsigned int ret, err;
+	int status = 0;
+
+	if (argc < 2) {
+		shell_fprintf(shell, SHELL_ERROR, "invalid # of args : %d\n", argc);
+		return -ENOEXEC;
+	}
+
+	field  = strtoul(argv[1], NULL, 0);
+	/* Align to 32-bit word address */
+	field >>= 2;
+
+	if (field < REGION_PROTECT) {
+		shell_fprintf(shell, SHELL_ERROR, "INVALID Address 0x%x......\n", field << 2);
+		return -ENOEXEC;
+	}
+
+	if ((field >= PRODRETEST_PROGVERSION) && (field <= PRODRETEST_TRIM14)) {
+		shell_fprintf(shell, SHELL_ERROR, "INVALID Address 0x%x......\n", field << 2);
+		return -ENOEXEC;
+	}
+
+	err = read_otp_memory(REGION_PROTECT, &val[REGION_PROTECT], 4);
+	if (err) {
+		shell_fprintf(shell, SHELL_ERROR, "FAILED reading otp memory......\n");
+		return -ENOEXEC;
+	}
+
+	ret = check_protection(&val[0], REGION_PROTECT, REGION_PROTECT + 1,
+						REGION_PROTECT + 2, REGION_PROTECT + 3);
+	disp_location_status(shell, "OTP", ret);
+	if (ret != OTP_ENABLE_PATTERN && ret != OTP_FRESH_FROM_FAB) {
+		shell_fprintf(shell, SHELL_ERROR, "USER Region is not Writeable\n");
+		return -ENOEXEC;
+	}
+
+	switch (field) {
+	case REGION_PROTECT:
+		if (argc != 3) {
+			shell_fprintf(shell, SHELL_ERROR,
+					"invalid # of args for REGION_PROTECT (expected 3) : %d\n",
+					argc);
+			return -ENOEXEC;
+		}
+		write_val[0]  = strtoul(argv[2], NULL, 0);
+		/* All consecutive 4 words of the REGION_PROTECT are written */
+		write_otp_memory(REGION_PROTECT, &write_val[0]);
+		break;
+	case MAC0_ADDR:
+	case MAC1_ADDR:
+		struct nrf_wifi_fmac_dev_ctx *fmac_dev_ctx = ctx->rpu_ctx;
+
+		if (!fmac_dev_ctx) {
+			shell_fprintf(shell, SHELL_ERROR, "Driver not initialized\n");
+			return -ENOEXEC;
+		}
+
+		if (argc != 4) {
+			shell_fprintf(shell, SHELL_ERROR,
+				   "invalid # of args for MAC ADDR write (expected 4) : %d\n",
+					argc);
+			return -ENOEXEC;
+		}
+		write_val[0] = strtoul(argv[2], NULL, 0);
+		write_val[1] = strtoul(argv[3], NULL, 0) & 0xFFFF;
+
+		if (!nrf_wifi_utils_is_mac_addr_valid((const char *)&write_val[0])) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid MAC address. MAC address cannot be all 0's, broadcast or multicast address\n");
+			return -ENOEXEC;
+		}
+
+		status = write_otp_memory(field, &write_val[0]);
+		break;
+	case CALIB_XO:
+	case REGION_DEFAULTS:
+		if (argc != 3) {
+			shell_fprintf(shell, SHELL_ERROR,
+			  "invalid # of args for field %d (expected 3) : %d\n", field, argc);
+			return -ENOEXEC;
+		}
+		write_val[0]  = strtoul(argv[2], NULL, 0);
+		status = write_otp_memory(field, &write_val[0]);
+		break;
+	case QSPI_KEY:
+		if (argc != 6) {
+			shell_fprintf(shell, SHELL_ERROR,
+					"invalid # of args for QSPI_KEY (expected 6) : %d\n", argc);
+			return -ENOEXEC;
+		}
+		write_val[0]  = strtoul(argv[2], NULL, 0);
+		write_val[1]  = strtoul(argv[3], NULL, 0);
+		write_val[2]  = strtoul(argv[4], NULL, 0);
+		write_val[3]  = strtoul(argv[5], NULL, 0);
+		/* All consecutive 4 words of the qspi keys are written now */
+		status = write_otp_memory(QSPI_KEY, &write_val[0]);
+		break;
+	default:
+		shell_fprintf(shell, SHELL_ERROR, "unsupported field %d\n", field);
+		return -ENOEXEC;
+	}
+
+	if (!status) {
+		shell_fprintf(shell, SHELL_INFO, "Finished Writing OTP params\n");
+	}
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_otp_write_retrim_version(const struct shell *shell,
+					size_t argc,
+					char  *argv[])
+{
+	unsigned int field;
+	unsigned int write_val;
+	unsigned int val[OTP_MAX_WORD_LEN];
+	unsigned int ret, err;
+	int status = 0;
+
+	field = PRODRETEST_PROGVERSION;
+
+	if (argc != 2) {
+		shell_fprintf(shell, SHELL_ERROR,
+		  "invalid # of args for field %d (expected 2) : %d\n", field, argc);
+		return -ENOEXEC;
+	}
+
+	err = read_otp_memory(REGION_PROTECT, &val[REGION_PROTECT], 4);
+	if (err) {
+		shell_fprintf(shell, SHELL_ERROR, "FAILED reading otp memory......\n");
+		return -ENOEXEC;
+	}
+
+	ret = check_protection(&val[0], REGION_PROTECT, REGION_PROTECT + 1,
+						REGION_PROTECT + 2, REGION_PROTECT + 3);
+	disp_location_status(shell, "OTP", ret);
+	if (ret != OTP_ENABLE_PATTERN && ret != OTP_FRESH_FROM_FAB) {
+		shell_fprintf(shell, SHELL_ERROR, "USER Region is not Writeable\n");
+		return -ENOEXEC;
+	}
+
+	write_val  = strtoul(argv[1], NULL, 0);
+	status = write_otp_memory(field, &write_val);
+
+	if (!status) {
+		shell_fprintf(shell, SHELL_INFO, "Finished Writing Retrim version\n");
+	}
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_otp_write_retrim_params(const struct shell *shell,
+					size_t argc,
+					char  *argv[])
+{
+	unsigned int index;
+	unsigned int field;
+	unsigned int write_val;
+	unsigned int val[OTP_MAX_WORD_LEN];
+	unsigned int ret, err;
+	int status = 0;
+
+	index = strtoul(argv[1], NULL, 0);
+	field = index+PRODRETEST_TRIM0;
+
+	if ((field < PRODRETEST_TRIM0) || (field > PRODRETEST_TRIM14)) {
+		shell_fprintf(shell, SHELL_ERROR, "INVALID Index %d......\n", index);
+		return -ENOEXEC;
+	}
+
+	err = read_otp_memory(REGION_PROTECT, &val[REGION_PROTECT], 4);
+	if (err) {
+		shell_fprintf(shell, SHELL_ERROR, "FAILED reading otp memory......\n");
+		return -ENOEXEC;
+	}
+
+	ret = check_protection(&val[0], REGION_PROTECT, REGION_PROTECT + 1,
+						REGION_PROTECT + 2, REGION_PROTECT + 3);
+	disp_location_status(shell, "OTP", ret);
+	if (ret != OTP_ENABLE_PATTERN && ret != OTP_FRESH_FROM_FAB) {
+		shell_fprintf(shell, SHELL_ERROR, "USER Region is not Writeable\n");
+		return -ENOEXEC;
+	}
+
+	switch (field) {
+	case PRODRETEST_TRIM0:
+	case PRODRETEST_TRIM1:
+	case PRODRETEST_TRIM2:
+	case PRODRETEST_TRIM3:
+	case PRODRETEST_TRIM4:
+	case PRODRETEST_TRIM5:
+	case PRODRETEST_TRIM6:
+	case PRODRETEST_TRIM7:
+	case PRODRETEST_TRIM8:
+	case PRODRETEST_TRIM9:
+	case PRODRETEST_TRIM10:
+	case PRODRETEST_TRIM11:
+	case PRODRETEST_TRIM12:
+	case PRODRETEST_TRIM13:
+	case PRODRETEST_TRIM14:
+		if (argc != 3) {
+			shell_fprintf(shell, SHELL_ERROR,
+				"invalid # of args for field %d (expected 3) : %d\n", field, argc);
+			return -ENOEXEC;
+		}
+		write_val  = strtoul(argv[2], NULL, 0);
+		status = write_otp_memory(field, &write_val);
+		break;
+	default:
+		shell_fprintf(shell, SHELL_ERROR, "unsupported field %d\n", field);
+		return -ENOEXEC;
+	}
+
+	if (!status) {
+		shell_fprintf(shell, SHELL_INFO, "Finished Writing Retrim param\n");
+	}
+
+	return 0;
+}
+
+SHELL_STATIC_SUBCMD_SET_CREATE(
+	nrf_wifi_radio_otp_subcmds,
+	SHELL_CMD_ARG(otp_get_status,
+			  NULL,
+			  "Read OTP status",
+			  nrf_wifi_radio_test_otp_get_status,
+			  1,
+			  0),
+	SHELL_CMD_ARG(otp_read_params,
+			  NULL,
+			  "Read User region status and information on programmed fields",
+			  nrf_wifi_radio_test_otp_read_params,
+			  1,
+			  0),
+	SHELL_CMD_ARG(otp_read_retrim_version,
+			  NULL,
+			  "Read Retrim Version",
+			  nrf_wifi_radio_test_otp_read_retrim_version,
+			  1,
+			  0),
+	SHELL_CMD_ARG(otp_read_retrim_params,
+			  NULL,
+			  "Read Retrim Params",
+			  nrf_wifi_radio_test_otp_read_retrim_params,
+			  1,
+			  0),
+	SHELL_CMD_ARG(otp_write_params,
+			  NULL,
+			  "Write OTP Params\n"
+			  "otp_write_params <addr offset> [arg1] [arg2]...[argN]",
+			  nrf_wifi_radio_test_otp_write_params,
+			  2,
+			  16),
+	SHELL_CMD_ARG(otp_write_retrim_version,
+			  NULL,
+			  "Write OTP Retrim Version\n"
+			  "otp_write_retrim_version <retrim version>",
+			  nrf_wifi_radio_test_otp_write_retrim_version,
+			  2,
+			  0),
+	SHELL_CMD_ARG(otp_write_retrim_params,
+			  NULL,
+			  "Write OTP Retrim Params\n"
+			  "otp_write_params <retrim index> [retrim data]",
+			  nrf_wifi_radio_test_otp_write_retrim_params,
+			  3,
+			  0),
+	SHELL_SUBCMD_SET_END);
+
+
+SHELL_CMD_REGISTER(wifi_radio_ficr_prog,
+		   &nrf_wifi_radio_otp_subcmds,
+		   "nRF Wi-Fi radio FICR commands",
+		   NULL);
+
+
+static int nrf_wifi_radio_otp_shell_init(void)
+{
+
+	return 0;
+}
+
+
+SYS_INIT(nrf_wifi_radio_otp_shell_init,
+	 APPLICATION,
+	 CONFIG_APPLICATION_INIT_PRIORITY);
diff --git a/samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_test_shell.c b/samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_test_shell.c
new file mode 100644
index 000000000000..70a8e51520fc
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/nrf_wifi_radio_test_shell.c
@@ -0,0 +1,2535 @@
+/*
+ * Copyright (c) 2022 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+/* @file
+ * @brief NRF Wi-Fi radio test shell module
+ */
+
+#include <fmac_main.h>
+#include <nrf_wifi_radio_test_shell.h>
+#include <util.h>
+#include "fmac_api_common.h"
+
+extern struct nrf_wifi_drv_priv_zep rpu_drv_priv_zep;
+struct nrf_wifi_ctx_zep *ctx = &rpu_drv_priv_zep.rpu_ctx_zep;
+
+#define NRF_WIFI_RADIO_TEST_INIT_TIMEOUT_MS 5000
+
+static bool check_test_in_prog(const struct shell *shell)
+{
+	if (ctx->conf_params.rx) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Disable RX\n");
+		return false;
+	}
+
+	if (ctx->conf_params.tx) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Disable TX\n");
+		return false;
+	}
+
+	if (ctx->rf_test_run) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Disable RF Test (%d)\n",
+			      ctx->rf_test);
+		return false;
+	}
+	return true;
+}
+
+
+static bool check_valid_data_rate(const struct shell *shell,
+				  unsigned char tput_mode,
+				  unsigned int nss,
+				  int dr)
+{
+	bool is_mcs = dr & 0x80;
+	bool ret = false;
+
+	if (dr == -1)
+		return true;
+
+	if (is_mcs) {
+		dr = dr & 0x7F;
+
+		if (tput_mode & RPU_TPUT_MODE_HT) {
+			if (nss == 2) {
+				if ((dr >= 8) && (dr <= 15)) {
+					ret = true;
+				} else {
+					shell_fprintf(shell,
+						      SHELL_ERROR,
+						      "Invalid MIMO HT MCS: %d\n",
+						       dr);
+				}
+			}
+
+			if (nss == 1) {
+				if ((dr >= 0) && (dr <= 7)) {
+					ret = true;
+				} else {
+					shell_fprintf(shell,
+						      SHELL_ERROR,
+						      "Invalid SISO HT MCS: %d\n",
+						      dr);
+				}
+			}
+
+		} else if (tput_mode == RPU_TPUT_MODE_VHT) {
+			if ((dr >= 0 && dr <= 9)) {
+				ret = true;
+			} else {
+				shell_fprintf(shell,
+					      SHELL_ERROR,
+					      "Invalid VHT MCS value: %d\n",
+					      dr);
+			}
+		} else if (tput_mode == RPU_TPUT_MODE_HE_SU) {
+			if ((dr >= 0 && dr <= 7)) {
+				ret = true;
+			} else {
+				shell_fprintf(shell,
+					      SHELL_ERROR,
+					      "Invalid HE_SU MCS value: %d\n",
+					      dr);
+			}
+		} else if (tput_mode == RPU_TPUT_MODE_HE_ER_SU) {
+			if ((dr >= 0 && dr <= 2)) {
+				ret = true;
+			} else {
+				shell_fprintf(shell,
+					      SHELL_ERROR,
+					      "Invalid HE_ER_SU MCS value: %d\n",
+					      dr);
+			}
+		} else {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "%s: Invalid throughput mode: %d\n", __func__,
+				      dr);
+		}
+	} else {
+		if (tput_mode != RPU_TPUT_MODE_LEGACY) {
+			ret = false;
+
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid rate_flags for legacy: %d\n",
+				      dr);
+		}
+
+		if ((dr == 1) ||
+		    (dr == 2) ||
+		    (dr == 55) ||
+		    (dr == 11) ||
+		    (dr == 6) ||
+		    (dr == 9) ||
+		    (dr == 12) ||
+		    (dr == 18) ||
+		    (dr == 24) ||
+		    (dr == 36) ||
+		    (dr == 48) ||
+		    (dr == 54) ||
+		    (dr == -1)) {
+			ret = true;
+		} else {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid Legacy Rate value: %d\n",
+				      dr);
+		}
+	}
+
+	return ret;
+}
+
+
+static bool check_valid_chan_2g(unsigned char chan_num)
+{
+	if ((chan_num >= 1) && (chan_num <= 14)) {
+		return true;
+	}
+
+	return false;
+}
+
+
+#ifndef CONFIG_NRF70_2_4G_ONLY
+static bool check_valid_chan_5g(unsigned char chan_num)
+{
+	if ((chan_num == 32) ||
+	    (chan_num == 36) ||
+	    (chan_num == 40) ||
+	    (chan_num == 44) ||
+	    (chan_num == 48) ||
+	    (chan_num == 52) ||
+	    (chan_num == 56) ||
+	    (chan_num == 60) ||
+	    (chan_num == 64) ||
+	    (chan_num == 68) ||
+	    (chan_num == 96) ||
+	    (chan_num == 100) ||
+	    (chan_num == 104) ||
+	    (chan_num == 108) ||
+	    (chan_num == 112) ||
+	    (chan_num == 116) ||
+	    (chan_num == 120) ||
+	    (chan_num == 124) ||
+	    (chan_num == 128) ||
+	    (chan_num == 132) ||
+	    (chan_num == 136) ||
+	    (chan_num == 140) ||
+	    (chan_num == 144) ||
+	    (chan_num == 149) ||
+	    (chan_num == 153) ||
+	    (chan_num == 157) ||
+	    (chan_num == 159) ||
+	    (chan_num == 161) ||
+	    (chan_num == 163) ||
+	    (chan_num == 165) ||
+	    (chan_num == 167) ||
+	    (chan_num == 169) ||
+	    (chan_num == 171) ||
+	    (chan_num == 173) ||
+	    (chan_num == 175) ||
+	    (chan_num == 177)) {
+		return true;
+	}
+
+	return false;
+}
+#endif /* CONFIG_NRF70_2_4G_ONLY */
+
+
+static bool check_valid_channel(unsigned char chan_num)
+{
+	bool ret = false;
+
+	ret = check_valid_chan_2g(chan_num);
+
+	if (ret) {
+		goto out;
+	}
+
+#ifndef CONFIG_NRF70_2_4G_ONLY
+	ret = check_valid_chan_5g(chan_num);
+#endif /* CONFIG_NRF70_2_4G_ONLY */
+
+out:
+	return ret;
+}
+
+
+static int check_channel_settings(const struct shell *shell,
+				  unsigned char tput_mode,
+				  struct chan_params *chan)
+{
+	if (tput_mode == RPU_TPUT_MODE_LEGACY) {
+		if (chan->bw != RPU_CH_BW_20) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid bandwidth setting for legacy channel = %d\n",
+				      chan->primary_num);
+			return -1;
+		}
+	} else if (tput_mode == RPU_TPUT_MODE_HT) {
+		if (chan->bw != RPU_CH_BW_20) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid bandwidth setting for HT channel = %d\n",
+				      chan->primary_num);
+			return -1;
+		}
+	} else if (tput_mode == RPU_TPUT_MODE_VHT) {
+		if ((chan->primary_num >= 1) &&
+		    (chan->primary_num <= 14)) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "VHT setting not allowed in 2.4GHz band\n");
+			return -1;
+		}
+
+		if (chan->bw != RPU_CH_BW_20) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid bandwidth setting for VHT channel = %d\n",
+				      chan->primary_num);
+			return -1;
+		}
+	} else if ((tput_mode == RPU_TPUT_MODE_HE_SU) ||
+		   (tput_mode == RPU_TPUT_MODE_HE_TB) ||
+		   (tput_mode == RPU_TPUT_MODE_HE_ER_SU)) {
+		if (chan->bw != RPU_CH_BW_20) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid bandwidth setting for HE channel = %d\n",
+				      chan->primary_num);
+			return -1;
+		}
+	} else {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid throughput mode = %d\n",
+			      tput_mode);
+		return -1;
+	}
+
+	return 0;
+}
+
+
+enum nrf_wifi_status nrf_wifi_radio_test_conf_init(struct rpu_conf_params *conf_params)
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	unsigned char country_code[NRF_WIFI_COUNTRY_CODE_LEN] = {0};
+
+	/* Check and save regulatory country code currently set */
+	if (strlen(conf_params->country_code)) {
+		memcpy(country_code,
+		       conf_params->country_code,
+		       NRF_WIFI_COUNTRY_CODE_LEN);
+	}
+
+	memset(conf_params,
+	       0,
+	       sizeof(*conf_params));
+
+	/* Initialize values which are other than 0 */
+	conf_params->op_mode = RPU_OP_MODE_RADIO_TEST;
+
+	status = nrf_wifi_fmac_rf_params_get(
+			ctx->rpu_ctx,
+			(struct nrf_wifi_phy_rf_params *)conf_params->rf_params);
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		goto out;
+	}
+
+	conf_params->tx_pkt_nss = 1;
+	conf_params->tx_pkt_gap_us = 0;
+
+	conf_params->tx_power = MAX_TX_PWR_SYS_TEST;
+
+	conf_params->chan.primary_num = 1;
+	conf_params->tx_mode = 1;
+	conf_params->tx_pkt_num = -1;
+	conf_params->tx_pkt_len = 1400;
+	conf_params->tx_pkt_preamble = 0;
+	conf_params->tx_pkt_rate = 6;
+	conf_params->he_ltf = 2;
+	conf_params->he_gi = 2;
+	conf_params->aux_adc_input_chain_id = 1;
+	conf_params->ru_tone = 26;
+	conf_params->ru_index = 1;
+	conf_params->tx_pkt_cw = 15;
+	conf_params->phy_calib = NRF_WIFI_DEF_PHY_CALIB;
+
+	/* Store back the currently set country code */
+	if (strlen(country_code)) {
+		memcpy(conf_params->country_code,
+		       country_code,
+		       NRF_WIFI_COUNTRY_CODE_LEN);
+	} else {
+		memcpy(conf_params->country_code,
+		       "00",
+		       NRF_WIFI_COUNTRY_CODE_LEN);
+	}
+out:
+	return status;
+}
+
+
+static int nrf_wifi_radio_test_set_defaults(const struct shell *shell,
+					    size_t argc,
+					    const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	status = nrf_wifi_radio_test_conf_init(&ctx->conf_params);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Configuration init failed\n");
+		return -ENOEXEC;
+	}
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_phy_calib_rxdc(const struct shell *shell,
+						  size_t argc,
+						  const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long phy_calib_rxdc = 0;
+
+	phy_calib_rxdc = strtoul(argv[1], &ptr, 10);
+
+	if (phy_calib_rxdc > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid PHY RX DC calibration value(%lu).\n",
+			      phy_calib_rxdc);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (phy_calib_rxdc)
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib |
+					     NRF_WIFI_PHY_CALIB_FLAG_RXDC);
+	else
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib &
+					     ~(NRF_WIFI_PHY_CALIB_FLAG_RXDC));
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_phy_calib_txdc(const struct shell *shell,
+						  size_t argc,
+						  const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long phy_calib_txdc = 0;
+
+	phy_calib_txdc = strtoul(argv[1], &ptr, 10);
+
+	if (phy_calib_txdc > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid PHY TX DC calibration value(%lu).\n",
+			      phy_calib_txdc);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (phy_calib_txdc)
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib |
+					     NRF_WIFI_PHY_CALIB_FLAG_TXDC);
+	else
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib &
+					     ~(NRF_WIFI_PHY_CALIB_FLAG_TXDC));
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_phy_calib_txpow(const struct shell *shell,
+						   size_t argc,
+						   const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long phy_calib_txpow = 0;
+
+	phy_calib_txpow = strtoul(argv[1], &ptr, 10);
+
+	if (phy_calib_txpow > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid PHY TX power calibration value(%lu).\n",
+			      phy_calib_txpow);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (phy_calib_txpow)
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib |
+					     NRF_WIFI_PHY_CALIB_FLAG_TXPOW);
+	else
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib &
+					     ~(NRF_WIFI_PHY_CALIB_FLAG_TXPOW));
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_phy_calib_rxiq(const struct shell *shell,
+						  size_t argc,
+						  const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long phy_calib_rxiq = 0;
+
+	phy_calib_rxiq = strtoul(argv[1], &ptr, 10);
+
+	if (phy_calib_rxiq > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid PHY RX IQ calibration value(%lu).\n",
+			      phy_calib_rxiq);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (phy_calib_rxiq)
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib |
+					     NRF_WIFI_PHY_CALIB_FLAG_RXIQ);
+	else
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib &
+					     ~(NRF_WIFI_PHY_CALIB_FLAG_RXIQ));
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_phy_calib_txiq(const struct shell *shell,
+						  size_t argc,
+						  const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long phy_calib_txiq = 0;
+
+	phy_calib_txiq = strtoul(argv[1], &ptr, 10);
+
+	if (phy_calib_txiq > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid PHY TX IQ calibration value(%lu).\n",
+			      phy_calib_txiq);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (phy_calib_txiq)
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib |
+					     NRF_WIFI_PHY_CALIB_FLAG_TXIQ);
+	else
+		ctx->conf_params.phy_calib = (ctx->conf_params.phy_calib &
+					     ~(NRF_WIFI_PHY_CALIB_FLAG_TXIQ));
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_he_ltf(const struct shell *shell,
+					  size_t argc,
+					  const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long he_ltf = 0;
+
+	he_ltf = strtoul(argv[1], &ptr, 10);
+
+	if (he_ltf > 2) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid HE LTF value(%lu).\n",
+			      he_ltf);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.he_ltf = he_ltf;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_he_gi(const struct shell *shell,
+					 size_t argc,
+					 const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long he_gi = 0;
+
+	he_gi = strtoul(argv[1], &ptr, 10);
+
+	if (he_gi > 2) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid HE GI value(%lu).\n",
+			      he_gi);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.he_gi = he_gi;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_pkt_tput_mode(const struct shell *shell,
+						    size_t argc,
+						    const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val >= RPU_TPUT_MODE_MAX) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_tput_mode = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_pkt_sgi(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_sgi = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_pkt_preamble(const struct shell *shell,
+						   size_t argc,
+						   const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val >= RPU_PKT_PREAMBLE_MAX) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (ctx->conf_params.tx_pkt_tput_mode == 0) {
+		if ((val != RPU_PKT_PREAMBLE_SHORT) &&
+		    (val != RPU_PKT_PREAMBLE_LONG)) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid value %lu for legacy mode\n",
+				      val);
+			return -ENOEXEC;
+		}
+	} else {
+		if (val != RPU_PKT_PREAMBLE_MIXED) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Only mixed preamble mode supported in HT, VHT and HE modes\n");
+			return -ENOEXEC;
+		}
+	}
+
+	ctx->conf_params.tx_pkt_preamble = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_pkt_mcs(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	long val = -1;
+
+	val = strtol(argv[1], &ptr, 10);
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (!(check_valid_data_rate(shell,
+				    ctx->conf_params.tx_pkt_tput_mode,
+				    ctx->conf_params.tx_pkt_nss,
+				    (val | 0x80)))) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_mcs = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_pkt_rate(const struct shell *shell,
+					       size_t argc,
+					       const char *argv[])
+{
+	char *ptr = NULL;
+	long val = -1;
+
+	val = strtol(argv[1], &ptr, 10);
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	if (!(check_valid_data_rate(shell,
+				    ctx->conf_params.tx_pkt_tput_mode,
+				    ctx->conf_params.tx_pkt_nss,
+				    val))) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_rate = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_pkt_gap(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 200000) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_gap_us = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_pkt_num(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	long val = 0;
+
+	val = strtol(argv[1], &ptr, 10);
+
+	if ((val < -1) || (val == 0)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_num = val;
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_set_tx_pkt_len(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val == 0) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (ctx->conf_params.tx_pkt_tput_mode == RPU_TPUT_MODE_MAX) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Throughput mode not set\n");
+		return -ENOEXEC;
+	}
+
+	if (ctx->conf_params.tx_pkt_tput_mode == RPU_TPUT_MODE_LEGACY) {
+		if (val > 4000) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "max 'tx_pkt_len' size for legacy is 4000 bytes\n");
+			return -ENOEXEC;
+		}
+	} else if (ctx->conf_params.tx_pkt_tput_mode == RPU_TPUT_MODE_HE_TB) {
+		if (ctx->conf_params.ru_tone == 26) {
+			if (val >= 350) {
+				shell_fprintf(shell,
+					      SHELL_ERROR,
+					      "'tx_pkt_len' has to be less than 350 bytes\n");
+				return -ENOEXEC;
+			}
+		} else if (ctx->conf_params.ru_tone == 52) {
+			if (val >= 800) {
+				shell_fprintf(shell,
+					      SHELL_ERROR,
+					      "'tx_pkt_len' has to be less than 800 bytes\n");
+				return -ENOEXEC;
+			}
+		} else if (ctx->conf_params.ru_tone == 106) {
+			if (val >= 1800) {
+				shell_fprintf(shell,
+					      SHELL_ERROR,
+					      "'tx_pkt_len' has to be less than 1800 bytes\n");
+				return -ENOEXEC;
+			}
+		} else if (ctx->conf_params.ru_tone == 242) {
+			if (val >= 4000) {
+				shell_fprintf(shell,
+					      SHELL_ERROR,
+					      "'tx_pkt_len' has to be less than 4000 bytes\n");
+				return -ENOEXEC;
+			}
+		} else {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "'ru_tone' not set\n");
+			return -ENOEXEC;
+		}
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_len = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_power(const struct shell *shell,
+					    size_t argc,
+					    const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (((val > MAX_TX_PWR_RADIO_TEST) && (val != MAX_TX_PWR_SYS_TEST))) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid TX power setting\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_power = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_tx_tone_freq(const struct shell *shell,
+						size_t argc,
+						const char *argv[])
+{
+	char *ptr = NULL;
+	signed char val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if ((val > 10) || (val < -10)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "'tx_tone_freq' has to be in between -10 to +10\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_tone_freq = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_rx_lna_gain(const struct shell *shell,
+					       size_t argc,
+					       const char *argv[])
+{
+	char *ptr = NULL;
+	signed char val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if ((val > 4) || (val < 0)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "'lna_gain' has to be in between 0 to 4\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.lna_gain = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_rx_bb_gain(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	signed char val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if ((val > 31) || (val < 0)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "'bb_gain' has to be in between 0 to 31\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.bb_gain = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_rx_capture_length(const struct shell *shell,
+						     size_t argc,
+						     const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned short int val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if ((val > MAX_CAPTURE_LEN)  || (val < MIN_CAPTURE_LEN)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "'capture_length' has to be non-zero and less than 16384\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.capture_length = val;
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_set_rx_capture_timeout(const struct shell *shell, size_t argc,
+						      const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned short int val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > CAPTURE_DURATION_IN_SEC) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "'capture_timeout' has to be less than 600 seconds\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.capture_timeout = val;
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_set_ru_tone(const struct shell *shell,
+					   size_t argc,
+					   const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if ((val != 26) &&
+	    (val != 52) &&
+	    (val != 106) &&
+	    (val != 242)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.ru_tone = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_ru_index(const struct shell *shell,
+					    size_t argc,
+					    const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (ctx->conf_params.ru_tone == 26) {
+		if ((val < 1) || (val > 9)) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid value %lu\n",
+				      val);
+			shell_help(shell);
+			return -ENOEXEC;
+		}
+	} else if (ctx->conf_params.ru_tone == 52) {
+		if ((val < 1) || (val > 4)) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid value %lu\n",
+				      val);
+			shell_help(shell);
+			return -ENOEXEC;
+		}
+	} else if (ctx->conf_params.ru_tone == 106) {
+		if ((val < 1) || (val > 2)) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid value %lu\n",
+				      val);
+			shell_help(shell);
+			return -ENOEXEC;
+		}
+	} else if (ctx->conf_params.ru_tone == 242) {
+		if ((val != 1)) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid value %lu\n",
+				      val);
+			shell_help(shell);
+			return -ENOEXEC;
+		}
+	} else {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "RU tone not set\n");
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.ru_index = val;
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_init(const struct shell *shell,
+				    size_t argc,
+				    const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (!(check_valid_channel(val))) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		return -ENOEXEC;
+	}
+
+	if (ctx->conf_params.rx) {
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "Disabling ongoing RX test\n");
+
+		ctx->conf_params.rx = 0;
+
+		status = nrf_wifi_fmac_radio_test_prog_rx(ctx->rpu_ctx,
+							  &ctx->conf_params);
+
+		if (status != NRF_WIFI_STATUS_SUCCESS) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Disabling RX failed\n");
+			return -ENOEXEC;
+		}
+	}
+
+	if (ctx->conf_params.tx) {
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "Disabling ongoing TX test\n");
+
+		ctx->conf_params.tx = 0;
+
+		status = nrf_wifi_fmac_radio_test_prog_tx(ctx->rpu_ctx,
+							  &ctx->conf_params);
+
+		if (status != NRF_WIFI_STATUS_SUCCESS) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Disabling TX failed\n");
+			return -ENOEXEC;
+		}
+	}
+
+	if (ctx->rf_test_run) {
+		if (ctx->rf_test != NRF_WIFI_RF_TEST_TX_TONE) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Unexpected: RF Test (%d) running\n",
+				      ctx->rf_test);
+
+			return -ENOEXEC;
+		}
+
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "Disabling ongoing TX tone test\n");
+
+		status = nrf_wifi_fmac_rf_test_tx_tone(ctx->rpu_ctx,
+						       0,
+						       ctx->conf_params.tx_tone_freq,
+						       ctx->conf_params.tx_power);
+
+		if (status != NRF_WIFI_STATUS_SUCCESS) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Disabling TX tone test failed\n");
+			return -ENOEXEC;
+		}
+
+		ctx->rf_test_run = false;
+		ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+
+	}
+
+	status = nrf_wifi_radio_test_conf_init(&ctx->conf_params);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Configuration init failed\n");
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.chan.primary_num = val;
+
+	status = nrf_wifi_fmac_radio_test_init(ctx->rpu_ctx,
+					       &ctx->conf_params);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Programming init failed\n");
+		return -ENOEXEC;
+	}
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_set_tx_pkt_cw(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	long val = 0;
+
+	val = strtol(argv[1], &ptr, 10);
+
+	if (!((val == 0) ||
+		  (val == 3) ||
+		  (val == 7) ||
+		  (val == 15) ||
+		  (val == 31) ||
+		  (val == 63) ||
+		  (val == 127) ||
+		  (val == 255) ||
+		  (val == 511) ||
+		  (val == 1023))) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.tx_pkt_cw = val;
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_set_tx(const struct shell *shell,
+				      size_t argc,
+				      const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (val == 1) {
+		if (!check_test_in_prog(shell)) {
+			return -ENOEXEC;
+		}
+
+		if (check_channel_settings(shell,
+					   ctx->conf_params.tx_pkt_tput_mode,
+					   &ctx->conf_params.chan) != 0) {
+			shell_fprintf(shell,
+				      SHELL_ERROR,
+				      "Invalid channel settings\n");
+			return -ENOEXEC;
+		}
+
+		/** Max TX power values differ based on the test being performed.
+		 * For TX EVM Vs Power, Max TX power required is
+		 * "MAX_TX_PWR_RADIO_TEST" (24dB) whereas for testing the
+		 * Max TX power for which both EVM and spectrum mask are passing
+		 * for specific band and MCS/rate, TX power values will be read from
+		 * RF params string.
+		 */
+		if (ctx->conf_params.tx_power != MAX_TX_PWR_SYS_TEST) {
+			/** Max TX power is represented in 0.25dB resolution
+			 * So,multiply 4 to MAX_TX_PWR_RADIO_TEST and
+			 * configure the RF params corresponding to Max TX power.
+			 */
+			memset(&ctx->conf_params.rf_params[NRF_WIFI_TX_PWR_CEIL_BYTE_OFFSET],
+			(MAX_TX_PWR_RADIO_TEST << 2),
+			sizeof(struct nrf_wifi_tx_pwr_ceil));
+		}
+	}
+
+	ctx->conf_params.tx = val;
+
+	status = nrf_wifi_fmac_radio_test_prog_tx(ctx->rpu_ctx,
+						  &ctx->conf_params);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Programming TX failed\n");
+		return -ENOEXEC;
+	}
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_rx(const struct shell *shell,
+				      size_t argc,
+				      const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (val == 1) {
+		if (!check_test_in_prog(shell)) {
+			return -ENOEXEC;
+		}
+	}
+
+	ctx->conf_params.rx = val;
+
+	status = nrf_wifi_fmac_radio_test_prog_rx(ctx->rpu_ctx,
+						  &ctx->conf_params);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Programming RX failed\n");
+		return -ENOEXEC;
+	}
+
+	return 0;
+}
+
+#ifdef CONFIG_NRF70_SR_COEX_RF_SWITCH
+static int nrf_wifi_radio_test_sr_ant_switch_ctrl(const struct shell *shell,
+					     size_t argc,
+					     const char *argv[])
+{
+	unsigned int val;
+
+	if (argc < 2) {
+		shell_fprintf(shell, SHELL_ERROR, "invalid # of args : %d\n", argc);
+		return -ENOEXEC;
+	}
+
+	val  = strtoul(argv[1], NULL, 0);
+
+	ctx->conf_params.sr_ant_switch_ctrl = val;
+
+	return sr_ant_switch(val);
+}
+#endif /* CONFIG_NRF70_SR_COEX_RF_SWITCH */
+
+static int nrf_wifi_radio_test_rx_cap(const struct shell *shell,
+				      size_t argc,
+				      const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	unsigned long rx_cap_type = 0;
+	unsigned char *rx_cap_buf = NULL;
+	unsigned char capture_status = 0;
+	char *ptr = NULL;
+	unsigned int i = 0;
+	int ret = -ENOEXEC;
+
+	rx_cap_type = strtoul(argv[1], &ptr, 10);
+
+	if ((rx_cap_type !=  NRF_WIFI_RF_TEST_RX_ADC_CAP) &&
+	    (rx_cap_type != NRF_WIFI_RF_TEST_RX_STAT_PKT_CAP) &&
+	    (rx_cap_type != NRF_WIFI_RF_TEST_RX_DYN_PKT_CAP)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      rx_cap_type);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!ctx->conf_params.capture_length) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "%s: Invalid rx_capture_length %d\n",
+			      __func__,
+			      ctx->conf_params.capture_length);
+		goto out;
+	}
+
+	if (rx_cap_type == NRF_WIFI_RF_TEST_RX_DYN_PKT_CAP) {
+		if (!ctx->conf_params.capture_timeout) {
+			shell_fprintf(shell,
+				SHELL_ERROR,
+				"%s: Invalid rx_capture_timeout %d\n",
+				__func__,
+				ctx->conf_params.capture_timeout);
+			goto out;
+		}
+	}
+
+	if (!check_test_in_prog(shell)) {
+		goto out;
+	}
+
+	rx_cap_buf = k_calloc((ctx->conf_params.capture_length * 3),
+			      sizeof(char));
+
+	if (!rx_cap_buf) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "%s: Unable to allocate (%d) bytes for RX capture\n",
+			      __func__,
+			      (ctx->conf_params.capture_length * 3));
+		goto out;
+	}
+
+	ctx->rf_test_run = true;
+	ctx->rf_test = NRF_WIFI_RF_TEST_RX_ADC_CAP;
+
+	status = nrf_wifi_fmac_rf_test_rx_cap(ctx->rpu_ctx,
+					      rx_cap_type,
+					      rx_cap_buf,
+					      ctx->conf_params.capture_length,
+					      ctx->conf_params.capture_timeout,
+					      ctx->conf_params.lna_gain,
+					      ctx->conf_params.bb_gain,
+					      &capture_status);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "RX ADC capture programming failed\n");
+		goto out;
+	}
+
+	if (capture_status == 0) {
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "\n************* RX capture data ***********\n");
+
+		for (i = 0; i < (ctx->conf_params.capture_length); i++) {
+			shell_fprintf(shell,
+				      SHELL_INFO,
+				      "%02X%02X%02X\n",
+				       rx_cap_buf[i*3 + 2],
+				       rx_cap_buf[i*3 + 1],
+				       rx_cap_buf[i*3 + 0]);
+		}
+	} else if (capture_status == 1) {
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "\n************* Capture failed ***********\n");
+	} else {
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "\n************* Packet detection failed ***********\n");
+	}
+
+	ret = 0;
+out:
+	if (rx_cap_buf)
+		k_free(rx_cap_buf);
+
+	ctx->rf_test_run = false;
+	ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+
+	return ret;
+}
+
+
+static int nrf_wifi_radio_test_tx_tone(const struct shell *shell,
+				       size_t argc,
+				       const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	char *ptr = NULL;
+	unsigned long val = 0;
+	int ret = -ENOEXEC;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		goto out;
+
+	}
+
+	if (val == 1) {
+		if (!check_test_in_prog(shell)) {
+			goto out;
+		}
+
+	}
+
+	status = nrf_wifi_fmac_rf_test_tx_tone(ctx->rpu_ctx,
+					       (unsigned char)val,
+					       ctx->conf_params.tx_tone_freq,
+					       ctx->conf_params.tx_power);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "TX tone programming failed\n");
+		goto out;
+	}
+
+	if (val == 1) {
+		ctx->rf_test_run = true;
+		ctx->rf_test = NRF_WIFI_RF_TEST_TX_TONE;
+	} else {
+		ctx->rf_test_run = false;
+		ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+	}
+
+	ret = 0;
+out:
+	return ret;
+}
+
+
+static int nrf_wifi_radio_set_dpd(const struct shell *shell,
+				  size_t argc,
+				  const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	char *ptr = NULL;
+	unsigned long val = 0;
+	int ret = -ENOEXEC;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		goto out;
+	}
+
+	if (val == 1) {
+		if (!check_test_in_prog(shell)) {
+			goto out;
+		}
+	}
+
+	ctx->rf_test_run = true;
+	ctx->rf_test = NRF_WIFI_RF_TEST_DPD;
+
+	status = nrf_wifi_fmac_rf_test_dpd(ctx->rpu_ctx,
+					   val);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "DPD programming failed\n");
+		goto out;
+	}
+
+	ret = 0;
+out:
+	ctx->rf_test_run = false;
+	ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+
+	return ret;
+}
+
+static int nrf_wifi_radio_get_temperature(const struct shell *shell,
+					  size_t argc,
+					  const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	int ret = -ENOEXEC;
+
+	if (!check_test_in_prog(shell)) {
+		goto out;
+	}
+
+	ctx->rf_test_run = true;
+	ctx->rf_test = NRF_WIFI_RF_TEST_GET_TEMPERATURE;
+
+	status = nrf_wifi_fmac_rf_get_temp(ctx->rpu_ctx);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "DPD programming failed\n");
+		goto out;
+	}
+
+	ret = 0;
+out:
+	ctx->rf_test_run = false;
+	ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+
+	return ret;
+}
+
+
+static int nrf_wifi_radio_get_rf_rssi(const struct shell *shell,
+				      size_t argc,
+				      const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	int ret = -ENOEXEC;
+
+	if (!check_test_in_prog(shell)) {
+		goto out;
+	}
+
+	ctx->rf_test_run = true;
+	ctx->rf_test = NRF_WIFI_RF_TEST_RF_RSSI;
+
+	status = nrf_wifi_fmac_rf_get_rf_rssi(ctx->rpu_ctx);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "RF RSSI get failed\n");
+		goto out;
+	}
+
+	ret = 0;
+out:
+	ctx->rf_test_run = false;
+	ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+
+	return ret;
+}
+
+
+static int nrf_wifi_radio_set_xo_val(const struct shell *shell,
+				     size_t argc,
+				     const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	char *ptr = NULL;
+	unsigned long val = 0;
+	int ret = -ENOEXEC;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 0x7f) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value XO value should be <= 0x7f\n");
+		shell_help(shell);
+		goto out;
+	}
+
+	if (val < 0) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value XO value should be >= 0\n");
+		shell_help(shell);
+		goto out;
+	}
+
+	if (val == 1) {
+		if (!check_test_in_prog(shell)) {
+			goto out;
+		}
+	}
+
+	ctx->rf_test_run = true;
+	ctx->rf_test = NRF_WIFI_RF_TEST_XO_CALIB;
+
+	status = nrf_wifi_fmac_set_xo_val(ctx->rpu_ctx,
+					       (unsigned char)val);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "XO value programming failed\n");
+		goto out;
+	}
+
+	ctx->conf_params.rf_params[NRF_WIFI_XO_FREQ_BYTE_OFFSET] = val;
+
+	ret = 0;
+out:
+	ctx->rf_test_run = false;
+	ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+
+	return ret;
+}
+
+static int nrf_wifi_radio_comp_opt_xo_val(const struct shell *shell,
+					  size_t argc,
+					  const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+
+	int ret = -ENOEXEC;
+
+	if (!check_test_in_prog(shell)) {
+		goto out;
+	}
+
+	ctx->rf_test_run = true;
+	ctx->rf_test = NRF_WIFI_RF_TEST_XO_TUNE;
+
+	status = nrf_wifi_fmac_rf_test_compute_xo(ctx->rpu_ctx);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "XO value computation failed\n");
+		goto out;
+	}
+
+	ret = 0;
+out:
+	ctx->rf_test_run = false;
+	ctx->rf_test = NRF_WIFI_RF_TEST_MAX;
+
+	return ret;
+}
+
+static int nrf_wifi_radio_test_set_ant_gain(const struct shell *shell,
+					    size_t argc,
+					    const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long ant_gain = 0;
+
+	ant_gain = strtoul(argv[1], &ptr, 10);
+
+	if ((ant_gain < 0) || (ant_gain > 6)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid antenna gain setting\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	memset(&ctx->conf_params.rf_params[ANT_GAIN_2G_OFST],
+	       ant_gain,
+	       NUM_ANT_GAIN);
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_set_edge_bo(const struct shell *shell,
+					   size_t argc,
+					   const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long edge_bo = 0;
+
+	edge_bo = strtoul(argv[1], &ptr, 10);
+
+	if ((edge_bo < 0) || (edge_bo > 10)) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid edge backoff setting\n");
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	memset(&ctx->conf_params.rf_params[BAND_2G_LW_ED_BKF_DSSS_OFST],
+	       edge_bo,
+	       NUM_EDGE_BACKOFF);
+
+	return 0;
+}
+
+static int nrf_wifi_radio_test_show_cfg(const struct shell *shell,
+					size_t argc,
+					const char *argv[])
+{
+	struct rpu_conf_params *conf_params = NULL;
+
+	conf_params = &ctx->conf_params;
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "************* Configured Parameters ***********\n");
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "\n");
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_tput_mode = %d\n",
+		      conf_params->tx_pkt_tput_mode);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_sgi = %d\n",
+		      conf_params->tx_pkt_sgi);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_preamble = %d\n",
+		      conf_params->tx_pkt_preamble);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_mcs = %d\n",
+		      conf_params->tx_pkt_mcs);
+
+	if (conf_params->tx_pkt_rate == 5)
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "tx_pkt_rate = 5.5\n");
+	else
+		shell_fprintf(shell,
+			      SHELL_INFO,
+			      "tx_pkt_rate = %d\n",
+			      conf_params->tx_pkt_rate);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_gap = %d\n",
+		      conf_params->tx_pkt_gap_us);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "phy_calib_rxdc = %d\n",
+		      (conf_params->phy_calib &
+		       NRF_WIFI_PHY_CALIB_FLAG_RXDC) ? 1:0);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "phy_calib_txdc = %d\n",
+		      (conf_params->phy_calib &
+		       NRF_WIFI_PHY_CALIB_FLAG_TXDC) ? 1:0);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "phy_calib_txpow = %d\n",
+		      (conf_params->phy_calib &
+		       NRF_WIFI_PHY_CALIB_FLAG_TXPOW) ? 1:0);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "phy_calib_rxiq = %d\n",
+		      (conf_params->phy_calib &
+		       NRF_WIFI_PHY_CALIB_FLAG_RXIQ) ? 1:0);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "phy_calib_txiq = %d\n",
+		      (conf_params->phy_calib &
+		       NRF_WIFI_PHY_CALIB_FLAG_TXIQ) ? 1:0);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_num = %d\n",
+		      conf_params->tx_pkt_num);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_len = %d\n",
+		      conf_params->tx_pkt_len);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_power = %d\n",
+		      conf_params->tx_power);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "he_ltf = %d\n",
+		      conf_params->he_ltf);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "he_gi = %d\n",
+		      conf_params->he_gi);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "xo_val = %d\n",
+		      conf_params->rf_params[NRF_WIFI_XO_FREQ_BYTE_OFFSET]);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "init = %d\n",
+		      conf_params->chan.primary_num);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx = %d\n",
+		      conf_params->tx);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "rx = %d\n",
+		      conf_params->rx);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_tone_freq = %d\n",
+		      conf_params->tx_tone_freq);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "rx_lna_gain = %d\n",
+		      conf_params->lna_gain);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "rx_bb_gain = %d\n",
+		      conf_params->bb_gain);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "rx_capture_length = %d\n",
+		      conf_params->capture_length);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "rx_capture_timeout = %d\n",
+		      conf_params->capture_timeout);
+
+#if defined(CONFIG_BOARD_NRF7002DK_NRF7001_NRF5340_CPUAPP) || \
+	defined(CONFIG_BOARD_NRF7002DK_NRF5340_CPUAPP)
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "sr_ant_switch_ctrl = %d\n",
+		      conf_params->sr_ant_switch_ctrl);
+#endif /* CONFIG_BOARD_NRF700XDK_NRF5340 */
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "wlan_ant_switch_ctrl = %d\n",
+		      conf_params->wlan_ant_switch_ctrl);
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "tx_pkt_cw = %d\n",
+		      conf_params->tx_pkt_cw);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "reg_domain = %c%c\n",
+		      conf_params->country_code[0],
+		      conf_params->country_code[1]);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "bypass_reg_domain = %d\n",
+		      conf_params->bypass_regulatory);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "ru_tone = %d\n",
+		      conf_params->ru_tone);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "ru_index = %d\n",
+		      conf_params->ru_index);
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_get_stats(const struct shell *shell,
+					 size_t argc,
+					 const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	struct rpu_op_stats stats;
+
+	memset(&stats,
+	       0,
+	       sizeof(stats));
+
+	status = nrf_wifi_fmac_stats_get(ctx->rpu_ctx,
+					 ctx->conf_params.op_mode,
+					 &stats);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "nrf_wifi_fmac_stats_get failed\n");
+		return -ENOEXEC;
+	}
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "************* PHY STATS ***********\n");
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "rssi_avg = %d dBm\n",
+		      stats.fw.phy.rssi_avg);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "ofdm_crc32_pass_cnt=%d\n",
+		      stats.fw.phy.ofdm_crc32_pass_cnt);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "ofdm_crc32_fail_cnt=%d\n",
+		      stats.fw.phy.ofdm_crc32_fail_cnt);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "dsss_crc32_pass_cnt=%d\n",
+		      stats.fw.phy.dsss_crc32_pass_cnt);
+
+	shell_fprintf(shell,
+		      SHELL_INFO,
+		      "dsss_crc32_fail_cnt=%d\n",
+		      stats.fw.phy.dsss_crc32_fail_cnt);
+
+	return 0;
+}
+
+/* See enum CD2CM_MSG_ID_T in RPU Coexistence Manager API */
+#define CD2CM_UPDATE_SWITCH_CONFIG 0x7
+static int nrf_wifi_radio_test_wlan_switch_ctrl(const struct shell *shell,
+						size_t argc,
+						const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	char *ptr = NULL;
+	struct coex_wlan_switch_ctrl params = { 0 };
+
+	if (argc < 2) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid number of parameters\n");
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	params.rpu_msg_id = CD2CM_UPDATE_SWITCH_CONFIG;
+	params.switch_A = strtoul(argv[1], &ptr, 10);
+
+	if (params.switch_A > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid WLAN switch config (%d)\n",
+			      params.switch_A);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.wlan_ant_switch_ctrl = params.switch_A;
+
+	status = nrf_wifi_fmac_conf_srcoex(ctx->rpu_ctx,
+					   &params, sizeof(params));
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "WLAN switch configuration failed\n");
+		return -ENOEXEC;
+	}
+
+	return 0;
+}
+
+
+static int nrf_wifi_radio_test_set_reg_domain(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	int ret = -ENOEXEC;
+	struct nrf_wifi_fmac_reg_info reg_domain_info = {0};
+
+	if (strlen(argv[1]) != 2) {
+		shell_fprintf(shell, SHELL_WARNING,
+			"Invalid reg domain: Length should be two letters/digits\n");
+			goto out;
+	}
+
+	/* Two letter country code with special case of 00 for WORLD */
+	if (((argv[1][0] < 'A' || argv[1][0] > 'Z') ||
+	     (argv[1][1] < 'A' || argv[1][1] > 'Z')) &&
+	     (argv[1][0] != '0' || argv[1][1] != '0')) {
+		shell_fprintf(shell, SHELL_WARNING, "Invalid reg domain %c%c\n", argv[1][0],
+			      argv[2][1]);
+		goto out;
+	}
+
+	ctx->conf_params.country_code[0] = argv[1][0];
+	ctx->conf_params.country_code[1] = argv[1][1];
+
+	if (!check_test_in_prog(shell)) {
+		goto out;
+	}
+
+	memcpy(reg_domain_info.alpha2, ctx->conf_params.country_code,
+			NRF_WIFI_COUNTRY_CODE_LEN);
+
+	status = nrf_wifi_fmac_set_reg(ctx->rpu_ctx, &reg_domain_info);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Regulatory programming failed\n");
+		goto out;
+	}
+
+	ret = 0;
+out:
+	return ret;
+}
+
+
+static int nrf_wifi_radio_test_set_bypass_reg(const struct shell *shell,
+					      size_t argc,
+					      const char *argv[])
+{
+	char *ptr = NULL;
+	unsigned long val = 0;
+
+	val = strtoul(argv[1], &ptr, 10);
+
+	if (val > 1) {
+		shell_fprintf(shell,
+			      SHELL_ERROR,
+			      "Invalid value %lu\n",
+			      val);
+		shell_help(shell);
+		return -ENOEXEC;
+	}
+
+	if (!check_test_in_prog(shell)) {
+		return -ENOEXEC;
+	}
+
+	ctx->conf_params.bypass_regulatory = val;
+
+	return 0;
+}
+
+
+SHELL_STATIC_SUBCMD_SET_CREATE(
+	nrf_wifi_radio_test_subcmds,
+	SHELL_CMD_ARG(set_defaults,
+		      NULL,
+		      "Reset configuration parameter to their default values",
+		      nrf_wifi_radio_test_set_defaults,
+		      1,
+		      0),
+	SHELL_CMD_ARG(phy_calib_rxdc,
+		      NULL,
+		      "0 - Disable RX DC calibration\n"
+		      "1 - Enable RX DC calibration",
+		      nrf_wifi_radio_test_set_phy_calib_rxdc,
+		      2,
+		      0),
+	SHELL_CMD_ARG(phy_calib_txdc,
+		      NULL,
+		      "0 - Disable TX DC calibration\n"
+		      "1 - Enable TX DC calibration",
+		      nrf_wifi_radio_test_set_phy_calib_txdc,
+		      2,
+		      0),
+	SHELL_CMD_ARG(phy_calib_txpow,
+		      NULL,
+		      "0 - Disable TX power calibration\n"
+		      "1 - Enable TX power calibration",
+		      nrf_wifi_radio_test_set_phy_calib_txpow,
+		      2,
+		      0),
+	SHELL_CMD_ARG(phy_calib_rxiq,
+		      NULL,
+		      "0 - Disable RX IQ calibration\n"
+		      "1 - Enable RX IQ calibration",
+		      nrf_wifi_radio_test_set_phy_calib_rxiq,
+		      2,
+		      0),
+	SHELL_CMD_ARG(phy_calib_txiq,
+		      NULL,
+		      "0 - Disable TX IQ calibration\n"
+		      "1 - Enable TX IQ calibration",
+		      nrf_wifi_radio_test_set_phy_calib_txiq,
+		      2,
+		      0),
+	SHELL_CMD_ARG(he_ltf,
+		      NULL,
+		      "0 - 1x HE LTF\n"
+		      "1 - 2x HE LTF\n"
+		      "2 - 4x HE LTF                                        ",
+		      nrf_wifi_radio_test_set_he_ltf,
+		      2,
+		      0),
+	SHELL_CMD_ARG(he_gi,
+		      NULL,
+		      "0 - 0.8 us\n"
+		      "1 - 1.6 us\n"
+		      "2 - 3.2 us                                           ",
+		      nrf_wifi_radio_test_set_he_gi,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_tput_mode,
+		      NULL,
+		      "0 - Legacy mode\n"
+		      "1 - HT mode\n"
+#ifndef CONFIG_NRF70_2_4G_ONLY
+		      "2 - VHT mode\n"
+#endif /* CONFIG_NRF70_2_4G_ONLY */
+		      "3 - HE(SU) mode\n"
+		      "4 - HE(ER SU) mode\n"
+		      "5 - HE (TB) mode                                   ",
+		      nrf_wifi_radio_test_set_tx_pkt_tput_mode,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_sgi,
+		      NULL,
+		      "0 - Disable\n"
+		      "1 - Enable",
+		      nrf_wifi_radio_test_set_tx_pkt_sgi,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_preamble,
+		      NULL,
+		      "0 - Long preamble\n"
+		      "1 - Short preamble\n"
+		      "2 - Mixed preamble                                   ",
+		      nrf_wifi_radio_test_set_tx_pkt_preamble,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_mcs,
+		      NULL,
+		      "-1    - Not being used\n"
+		      "<val> - MCS index to be used",
+		      nrf_wifi_radio_test_set_tx_pkt_mcs,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_rate,
+		      NULL,
+		      "-1    - Not being used\n"
+		      "<val> - Legacy rate to be used in Mbps (1, 2, 5.5, 11, 6, 9, 12, 18, 24, 36, 48, 54)",
+		      nrf_wifi_radio_test_set_tx_pkt_rate,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_gap,
+		      NULL,
+		      "<val> - Interval between TX packets in us (Min: 200, Max: 200000, Default: 200)",
+		      nrf_wifi_radio_test_set_tx_pkt_gap,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_num,
+		      NULL,
+		      "-1    - Transmit infinite packets\n"
+		      "<val> - Number of packets to transmit",
+		      nrf_wifi_radio_test_set_tx_pkt_num,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_len,
+		      NULL,
+		      "<val> - Length of the packet (in bytes) to be transmitted (Default: 1400)",
+		      nrf_wifi_radio_test_set_tx_pkt_len,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_power,
+		      NULL,
+		      "<val> - Value in dBm",
+		      nrf_wifi_radio_test_set_tx_power,
+		      2,
+		      0),
+	SHELL_CMD_ARG(ru_tone,
+		      NULL,
+		      "<val> - Resource unit (RU) size (26,52,106 or 242)",
+		      nrf_wifi_radio_test_set_ru_tone,
+		      2,
+		      0),
+	SHELL_CMD_ARG(ru_index,
+		      NULL,
+		      "<val> - Location of resource unit (RU) in 20 MHz spectrum\n"
+		      "        Valid Values:\n"
+		      "           For 26 ru_tone: 1 to 9\n"
+		      "           For 52 ru_tone:  1 to 4\n"
+		      "           For 106 ru_tone:  1 to 2\n"
+		      "           For 242 ru_tone:  1",
+		      nrf_wifi_radio_test_set_ru_index,
+		      2,
+		      0),
+	SHELL_CMD_ARG(init,
+		      NULL,
+		      "<val> - Primary channel number",
+		      nrf_wifi_radio_test_init,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx,
+		      NULL,
+		      "0 - Disable TX\n"
+		      "1 - Enable TX",
+		      nrf_wifi_radio_test_set_tx,
+		      2,
+		      0),
+	SHELL_CMD_ARG(rx,
+		      NULL,
+		      "0 - Disable RX\n"
+		      "1 - Enable RX",
+		      nrf_wifi_radio_test_set_rx,
+		      2,
+		      0),
+#ifdef CONFIG_NRF70_SR_COEX_RF_SWITCH
+	SHELL_CMD_ARG(sr_ant_switch_ctrl,
+		      NULL,
+		      "0 - Switch set to use the BLE antenna\n"
+		      "1 - Switch set to use the shared Wi-Fi antenna",
+		      nrf_wifi_radio_test_sr_ant_switch_ctrl,
+		      2,
+		      0),
+#endif /* CONFIG_NRF70_SR_COEX_RF_SWITCH */
+	SHELL_CMD_ARG(rx_lna_gain,
+		      NULL,
+		      "<val> - LNA gain to be configured.\n"
+			  "0 = 24 dB\n"
+			  "1 = 18 dB\n"
+			  "2 = 12 dB\n"
+			  "3 = 0 dB\n"
+			  "4 = -12 dB                         ",
+		      nrf_wifi_radio_test_set_rx_lna_gain,
+		      2,
+		      0),
+	SHELL_CMD_ARG(rx_bb_gain,
+		      NULL,
+		      "<val> - Baseband gain to be configured\n"
+			  "It is a 5 bit value. Supports 64dB range in steps of 2dB",
+		      nrf_wifi_radio_test_set_rx_bb_gain,
+		      2,
+		      0),
+	SHELL_CMD_ARG(rx_capture_length,
+		      NULL,
+		      "<val> - Number of RX samples to be captured\n"
+		      "Max allowed length is 16384 complex samples",
+		      nrf_wifi_radio_test_set_rx_capture_length,
+		      2,
+		      0),
+	SHELL_CMD_ARG(rx_capture_timeout,
+		      NULL,
+		      "<val> - Wait time allowed in seconds\n"
+		      "Max timeout allowed is 600 seconds",
+		      nrf_wifi_radio_test_set_rx_capture_timeout,
+		      2,
+		      0),
+	SHELL_CMD_ARG(rx_cap,
+		      NULL,
+		      "0 = ADC capture\n"
+		      "1 = Filtered ADC capture\n"
+		      "2 = Dynamic packet capture              ",
+		      nrf_wifi_radio_test_rx_cap,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_tone_freq,
+		      NULL,
+		      "<val> - Frequency in the range of -10MHz to 10MHz",
+		      nrf_wifi_radio_test_set_tx_tone_freq,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_tone,
+		      NULL,
+		      "<TONE CONTROL>\n"
+		      "0: Disable tone\n"
+		      "1: Enable tone                                       ",
+		      nrf_wifi_radio_test_tx_tone,
+		      2,
+		      0),
+	SHELL_CMD_ARG(dpd,
+		      NULL,
+		      "0 - Bypass DPD\n"
+		      "1 - Enable DPD",
+		      nrf_wifi_radio_set_dpd,
+		      2,
+		      0),
+	SHELL_CMD_ARG(get_temperature,
+		      NULL,
+		      "No arguments required",
+		      nrf_wifi_radio_get_temperature,
+		      1,
+		      0),
+	SHELL_CMD_ARG(get_rf_rssi,
+		      NULL,
+		      "No arguments required",
+		      nrf_wifi_radio_get_rf_rssi,
+		      1,
+		      0),
+	SHELL_CMD_ARG(set_xo_val,
+		      NULL,
+		      "<val> - XO value in the range 0 to 127",
+		      nrf_wifi_radio_set_xo_val,
+		      2,
+		      0),
+	SHELL_CMD_ARG(compute_optimal_xo_val,
+		      NULL,
+		      "Compute optimal XO trim value",
+		      nrf_wifi_radio_comp_opt_xo_val,
+		      1,
+		      0),
+	SHELL_CMD_ARG(show_config,
+		      NULL,
+		      "Display the current configuration values",
+		      nrf_wifi_radio_test_show_cfg,
+		      1,
+		      0),
+	SHELL_CMD_ARG(get_stats,
+		      NULL,
+		      "Display statistics",
+		      nrf_wifi_radio_test_get_stats,
+		      1,
+		      0),
+	SHELL_CMD_ARG(wlan_ant_switch_ctrl,
+		      NULL,
+		      "Configure WLAN antenna switch (0-separate/1-shared)",
+		      nrf_wifi_radio_test_wlan_switch_ctrl,
+		      2,
+		      0),
+	SHELL_CMD_ARG(tx_pkt_cw,
+		      NULL,
+		      "<val> - Contention window value to be configured (0, 3, 7, 15, 31, 63, 127, 255, 511, 1023)",
+		      nrf_wifi_radio_test_set_tx_pkt_cw,
+		      2,
+		      0),
+	SHELL_CMD_ARG(reg_domain,
+		      NULL,
+		      "Configure WLAN regulatory domain country code",
+		      nrf_wifi_radio_test_set_reg_domain,
+		      2,
+		      0),
+	SHELL_CMD_ARG(bypass_reg_domain,
+		      NULL,
+		      "Configure WLAN to bypass regulatory\n"
+		      "0 - TX power of the channel will be set to "
+			   "minimum between user configured TX power & "
+			   "maximum TX power of channel in the configured regulatory domain.\n"
+		      "1 - Configured TX power value will be used for the channel.				",
+		      nrf_wifi_radio_test_set_bypass_reg,
+		      2,
+		      0),
+	SHELL_CMD_ARG(set_ant_gain,
+		      NULL,
+		      "<val> - Antenna gain in dB (Min: 0, Max: 6)",
+		      nrf_wifi_radio_test_set_ant_gain,
+		      2,
+		      0),
+	SHELL_CMD_ARG(set_edge_bo,
+		      NULL,
+		      "<val> - Edge backoff in dB (Min: 0, Max: 10)",
+		      nrf_wifi_radio_test_set_edge_bo,
+		      2,
+		      0),
+	SHELL_SUBCMD_SET_END);
+
+
+SHELL_CMD_REGISTER(wifi_radio_test,
+		   &nrf_wifi_radio_test_subcmds,
+		   "nRF Wi-Fi radio test commands",
+		   NULL);
+
+
+static int nrf_wifi_radio_test_shell_init(void)
+{
+	enum nrf_wifi_status status = NRF_WIFI_STATUS_FAIL;
+	unsigned int timeout = 0;
+
+	while (!ctx->rpu_ctx && timeout < NRF_WIFI_RADIO_TEST_INIT_TIMEOUT_MS) {
+		k_sleep(K_MSEC(100));
+		timeout += 100;
+	}
+
+	if (!ctx->rpu_ctx) {
+		printf("nRF Wi-Fi radio test shell init timedout waiting for driver: %d\n",
+		       NRF_WIFI_RADIO_TEST_INIT_TIMEOUT_MS);
+		return -ENOEXEC;
+	}
+
+	status = nrf_wifi_radio_test_conf_init(&ctx->conf_params);
+
+	if (status != NRF_WIFI_STATUS_SUCCESS) {
+		return -ENOEXEC;
+	}
+
+	return 0;
+}
+
+
+SYS_INIT(nrf_wifi_radio_test_shell_init,
+	 APPLICATION,
+	 CONFIG_APPLICATION_INIT_PRIORITY);
diff --git a/samples/wifi/radio_test/single_domain/src/radio_cmd.c b/samples/wifi/radio_test/single_domain/src/radio_cmd.c
new file mode 100644
index 000000000000..07eeb32ddf14
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/radio_cmd.c
@@ -0,0 +1,1497 @@
+/*
+ * Copyright (c) 2020 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include <stdlib.h>
+
+#include <errno.h>
+#include <zephyr/init.h>
+#include <zephyr/shell/shell.h>
+#include <zephyr/types.h>
+#if !defined(CONFIG_SOC_SERIES_NRF54HX)
+#include <hal/nrf_power.h>
+#endif /* !defined(CONFIG_SOC_SERIES_NRF54HX) */
+
+#if CONFIG_FEM
+#include "fem_al/fem_al.h"
+#endif /* CONFIG_FEM */
+
+#include "radio_test.h"
+
+#if NRF_POWER_HAS_DCDCEN_VDDH
+	#define TOGGLE_DCDC_HELP			\
+	"Toggle DCDC state <state>, "			\
+	"if state = 1 then toggle DC/DC state, or "	\
+	"if state = 0 then toggle DC/DC VDDH state"
+#elif NRF_POWER_HAS_DCDCEN
+	#define TOGGLE_DCDC_HELP			\
+	"Toggle DCDC state <state>, "			\
+	"Toggle DC/DC state regardless of state value"
+#endif
+
+
+/* Radio parameter configuration. */
+static struct radio_param_config {
+	/** Radio transmission pattern. */
+	enum transmit_pattern tx_pattern;
+
+	/** Radio mode. Data rate and modulation. */
+	nrf_radio_mode_t mode;
+
+	/** Radio output power. */
+	int8_t txpower;
+
+	/** Radio start channel (frequency). */
+	uint8_t channel_start;
+
+	/** Radio end channel (frequency). */
+	uint8_t channel_end;
+
+	/** Delay time in milliseconds. */
+	uint32_t delay_ms;
+
+	/** Duty cycle. */
+	uint32_t duty_cycle;
+
+	/**
+	 * Number of packets to be received.
+	 * Set to zero for continuous RX.
+	 */
+	uint32_t rx_packets_num;
+
+#if CONFIG_FEM
+	/* Front-end module (FEM) configuration. */
+	struct radio_test_fem fem;
+#endif /* CONFIG_FEM */
+} config = {
+	.tx_pattern = TRANSMIT_PATTERN_RANDOM,
+	.mode = NRF_RADIO_MODE_BLE_1MBIT,
+	.txpower = 0,
+	.channel_start = 0,
+	.channel_end = 80,
+	.delay_ms = 10,
+	.duty_cycle = 50,
+#if CONFIG_FEM
+	.fem.tx_power_control = FEM_USE_DEFAULT_TX_POWER_CONTROL
+#endif /* CONFIG_FEM */
+};
+
+/* Radio test configuration. */
+static struct radio_test_config test_config;
+
+/* If true, RX sweep, TX sweep or duty cycle test is performed. */
+static bool test_in_progress;
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+static void ieee_channel_check(const struct shell *shell, uint8_t channel)
+{
+	if (config.mode == NRF_RADIO_MODE_IEEE802154_250KBIT) {
+		if ((channel < IEEE_MIN_CHANNEL) ||
+		    (channel > IEEE_MAX_CHANNEL)) {
+			shell_print(shell,
+				"For %s config.mode channel must be between %d and %d",
+				STRINGIFY(NRF_RADIO_MODE_IEEE802154_250KBIT),
+				IEEE_MIN_CHANNEL,
+				IEEE_MAX_CHANNEL);
+
+			shell_print(shell, "Channel set to %d",
+				    IEEE_MIN_CHANNEL);
+		}
+
+	}
+}
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+static int cmd_start_channel_set(const struct shell *shell, size_t argc,
+				 char **argv)
+{
+	uint32_t channel;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	channel = atoi(argv[1]);
+
+	if (channel > 80) {
+		shell_error(shell, "Channel must be between 0 and 80");
+		return -EINVAL;
+	}
+
+	config.channel_start = (uint8_t) channel;
+
+	shell_print(shell, "Start channel set to: %d", channel);
+	return 0;
+}
+
+static int cmd_end_channel_set(const struct shell *shell, size_t argc,
+			       char **argv)
+{
+	uint32_t channel;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	channel = atoi(argv[1]);
+
+	if (channel > 80) {
+		shell_error(shell, "Channel must be between 0 and 80");
+		return -EINVAL;
+	}
+
+	config.channel_end = (uint8_t) channel;
+
+	shell_print(shell, "End channel set to: %d", channel);
+	return 0;
+}
+
+static int cmd_time_set(const struct shell *shell, size_t argc, char **argv)
+{
+	uint32_t time;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	time = atoi(argv[1]);
+
+	if (time > 99) {
+		shell_error(shell, "Delay time must be between 0 and 99 ms");
+		return -EINVAL;
+	}
+
+	config.delay_ms = time;
+
+	shell_print(shell, "Delay time set to: %d", time);
+	return 0;
+}
+
+static int cmd_cancel(const struct shell *shell, size_t argc, char **argv)
+{
+	radio_test_cancel();
+	return 0;
+}
+
+static int cmd_data_rate_set(const struct shell *shell, size_t argc,
+			     char **argv)
+{
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	if (argc == 2) {
+		shell_error(shell, "Uknown argument: %s", argv[1]);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int cmd_tx_carrier_start(const struct shell *shell, size_t argc,
+				char **argv)
+{
+	if (test_in_progress) {
+		radio_test_cancel();
+		test_in_progress = false;
+	}
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	ieee_channel_check(shell, config.channel_start);
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	memset(&test_config, 0, sizeof(test_config));
+	test_config.type = UNMODULATED_TX;
+	test_config.mode = config.mode;
+	test_config.params.unmodulated_tx.txpower = config.txpower;
+	test_config.params.unmodulated_tx.channel = config.channel_start;
+#if CONFIG_FEM
+	test_config.fem = config.fem;
+#endif /* CONFIG_FEM */
+	radio_test_start(&test_config);
+
+	shell_print(shell, "Start the TX carrier");
+	return 0;
+}
+
+static void tx_modulated_carrier_end(void)
+{
+	printk("The modulated TX has finished\n");
+}
+
+static void rx_end(void)
+{
+	uint32_t recv_pkt, req_pkt;
+	float error_rate;
+
+	struct radio_rx_stats rx_stats;
+
+	memset(&rx_stats, 0, sizeof(rx_stats));
+
+	radio_rx_stats_get(&rx_stats);
+
+	recv_pkt = rx_stats.packet_cnt;
+	req_pkt = config.rx_packets_num;
+
+	if (req_pkt == 0 || req_pkt < recv_pkt) {
+		printk("Error receiving packets\n");
+		return;
+	}
+
+	error_rate = ((float)(req_pkt - recv_pkt) / req_pkt) * 100.0f;
+
+	printk("\n");
+	printk("Received number of packets: %d\n", recv_pkt);
+	printk("Required number of packages: %d\n", req_pkt);
+	printk("Error rate: %.2f%%\n", (double)error_rate);
+
+	if (error_rate >= 10) {
+		printk("\033[91mWarning: High error rate! \033[0m\n");
+	}
+}
+
+static int cmd_tx_modulated_carrier_start(const struct shell *shell,
+					  size_t argc,
+					  char **argv)
+{
+	if (test_in_progress) {
+		radio_test_cancel();
+		test_in_progress = false;
+	}
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	ieee_channel_check(shell, config.channel_start);
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count.", argv[0]);
+		return -EINVAL;
+	}
+
+	memset(&test_config, 0, sizeof(test_config));
+	test_config.type = MODULATED_TX;
+	test_config.mode = config.mode;
+	test_config.params.modulated_tx.txpower = config.txpower;
+	test_config.params.modulated_tx.channel = config.channel_start;
+	test_config.params.modulated_tx.pattern = config.tx_pattern;
+#if CONFIG_FEM
+	test_config.fem = config.fem;
+#endif /* CONFIG_FEM */
+
+	if (argc == 2) {
+		test_config.params.modulated_tx.packets_num = atoi(argv[1]);
+		test_config.params.modulated_tx.cb = tx_modulated_carrier_end;
+	}
+
+	radio_test_start(&test_config);
+
+	shell_print(shell, "Start the modulated TX carrier");
+	return 0;
+}
+
+static int cmd_duty_cycle_set(const struct shell *shell, size_t argc,
+			      char **argv)
+{
+	uint32_t duty_cycle;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count.", argv[0]);
+		return -EINVAL;
+	}
+
+	duty_cycle = atoi(argv[1]);
+
+	if (duty_cycle > 90) {
+		shell_error(shell, "Duty cycle must be between 1 and 90.");
+		return -EINVAL;
+	}
+
+	config.duty_cycle = duty_cycle;
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	ieee_channel_check(shell, config.channel_start);
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	memset(&test_config, 0, sizeof(test_config));
+	test_config.type = MODULATED_TX_DUTY_CYCLE;
+	test_config.mode = config.mode;
+	test_config.params.modulated_tx_duty_cycle.txpower = config.txpower;
+	test_config.params.modulated_tx_duty_cycle.pattern = config.tx_pattern;
+	test_config.params.modulated_tx_duty_cycle.channel =
+		config.channel_start;
+	test_config.params.modulated_tx_duty_cycle.duty_cycle =
+		config.duty_cycle;
+#if CONFIG_FEM
+	test_config.fem = config.fem;
+#endif /* CONFIG_FEM */
+
+	radio_test_start(&test_config);
+	test_in_progress = true;
+
+	return 0;
+}
+
+#if defined(TOGGLE_DCDC_HELP)
+static int cmd_toggle_dc(const struct shell *shell, size_t argc, char **argv)
+{
+	uint32_t state;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	state = atoi(argv[1]);
+	if (state > 1) {
+		shell_error(shell, "Invalid DCDC value provided");
+		return -EINVAL;
+	}
+
+	toggle_dcdc_state((uint8_t) state);
+
+#if NRF_POWER_HAS_DCDCEN_VDDH
+	shell_print(shell,
+		"DCDC VDDH state %d\n"
+		"Write '0' to toggle state of DCDC REG0\n"
+		"Write '1' to toggle state of DCDC REG1",
+		nrf_power_dcdcen_vddh_get(NRF_POWER));
+#endif /* NRF_POWER_HAS_DCDCEN_VDDH */
+
+#if NRF_POWER_HAS_DCDCEN
+	shell_print(shell,
+		"DCDC state %d\n"
+		"Write '1' or '0' to toggle",
+		nrf_power_dcdcen_get(NRF_POWER));
+#endif /* NRF_POWER_HAS_DCDCEN */
+
+	return 0;
+}
+#endif
+
+static int cmd_output_power_set(const struct shell *shell, size_t argc,
+				char **argv)
+{
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count.", argv[0]);
+		return -EINVAL;
+	}
+
+	if (argc == 2) {
+		shell_error(shell, "Uknown argument: %s", argv[1]);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int cmd_transmit_pattern_set(const struct shell *shell, size_t argc,
+				    char **argv)
+{
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count.", argv[0]);
+		return -EINVAL;
+	}
+
+	if (argc == 2) {
+		shell_error(shell, "Uknown argument: %s.", argv[1]);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int cmd_print(const struct shell *shell, size_t argc, char **argv)
+{
+	shell_print(shell, "Parameters:");
+
+	switch (config.mode) {
+#if defined(RADIO_MODE_MODE_Nrf_250Kbit)
+	case NRF_RADIO_MODE_NRF_250KBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_NRF_250KBIT));
+		break;
+
+#endif /* defined(RADIO_MODE_MODE_Nrf_250Kbit) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_5)
+	case NRF_RADIO_MODE_NRF_4MBIT_H_0_5:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_H_0_5));
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_5) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_25)
+	case NRF_RADIO_MODE_NRF_4MBIT_H_0_25:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_H_0_25));
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_25) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6)
+	case NRF_RADIO_MODE_NRF_4MBIT_BT_0_6:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_BT_0_6));
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4)
+	case NRF_RADIO_MODE_NRF_4MBIT_BT_0_4:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_BT_0_4));
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4) */
+
+	case NRF_RADIO_MODE_NRF_1MBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_NRF_1MBIT));
+		break;
+
+	case NRF_RADIO_MODE_NRF_2MBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_NRF_2MBIT));
+		break;
+
+	case NRF_RADIO_MODE_BLE_1MBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_BLE_1MBIT));
+		break;
+
+	case NRF_RADIO_MODE_BLE_2MBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_BLE_2MBIT));
+		break;
+
+#if CONFIG_HAS_HW_NRF_RADIO_BLE_CODED
+	case NRF_RADIO_MODE_BLE_LR125KBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_BLE_LR125KBIT));
+		break;
+
+	case NRF_RADIO_MODE_BLE_LR500KBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_BLE_LR500KBIT));
+		break;
+#endif /* CONFIG_HAS_HW_NRF_RADIO_BLE_CODED */
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	case NRF_RADIO_MODE_IEEE802154_250KBIT:
+		shell_print(shell,
+			    "Data rate: %s",
+			    STRINGIFY(NRF_RADIO_MODE_IEEE802154_250KBIT));
+		break;
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	default:
+		shell_print(shell,
+			    "Data rate unknown or deprecated: %d\n\r",
+			    config.mode);
+		break;
+	}
+
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+
+	switch (config.tx_pattern) {
+	case TRANSMIT_PATTERN_RANDOM:
+		shell_print(shell,
+			    "Transmission pattern: %s",
+			    STRINGIFY(TRANSMIT_PATTERN_RANDOM));
+		break;
+
+	case TRANSMIT_PATTERN_11110000:
+		shell_print(shell,
+			    "Transmission pattern: %s",
+			    STRINGIFY(TRANSMIT_PATTERN_11110000));
+		break;
+
+	case TRANSMIT_PATTERN_11001100:
+		shell_print(shell,
+			    "Transmission pattern: %s",
+			    STRINGIFY(TRANSMIT_PATTERN_11001100));
+		break;
+
+	default:
+		shell_print(shell,
+			    "Transmission pattern unknown: %d",
+			    config.tx_pattern);
+		break;
+	}
+
+	shell_print(shell,
+		"Start Channel: %hhu\n"
+		"End Channel: %hhu\n"
+		"Time on each channel: %u ms\n"
+		"Duty cycle: %u percent\n",
+		config.channel_start,
+		config.channel_end,
+		config.delay_ms,
+		config.duty_cycle);
+
+	return 0;
+}
+
+static int cmd_rx_sweep_start(const struct shell *shell, size_t argc,
+			      char **argv)
+{
+	memset(&test_config, 0, sizeof(test_config));
+	test_config.type = RX_SWEEP;
+	test_config.mode = config.mode;
+	test_config.params.rx_sweep.channel_start = config.channel_start;
+	test_config.params.rx_sweep.channel_end = config.channel_end;
+	test_config.params.rx_sweep.delay_ms = config.delay_ms;
+#if CONFIG_FEM
+	test_config.fem = config.fem;
+#endif /* CONFIG_FEM */
+
+	radio_test_start(&test_config);
+
+	test_in_progress = true;
+
+	shell_print(shell, "RX sweep");
+	return 0;
+}
+
+static int cmd_tx_sweep_start(const struct shell *shell, size_t argc,
+			      char **argv)
+{
+	memset(&test_config, 0, sizeof(test_config));
+	test_config.type = TX_SWEEP;
+	test_config.mode = config.mode;
+	test_config.params.tx_sweep.channel_start = config.channel_start;
+	test_config.params.tx_sweep.channel_end = config.channel_end;
+	test_config.params.tx_sweep.delay_ms = config.delay_ms;
+	test_config.params.tx_sweep.txpower = config.txpower;
+#if CONFIG_FEM
+	test_config.fem = config.fem;
+#endif /* CONFIG_FEM */
+
+	radio_test_start(&test_config);
+
+	test_in_progress = true;
+
+	shell_print(shell, "TX sweep");
+	return 0;
+}
+
+static int cmd_rx_start(const struct shell *shell, size_t argc, char **argv)
+{
+	if (test_in_progress) {
+		radio_test_cancel();
+		test_in_progress = false;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: too many arguments", argv[0]);
+		return -EINVAL;
+	}
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	ieee_channel_check(shell, config.channel_start);
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	memset(&test_config, 0, sizeof(test_config));
+	test_config.type = RX;
+	test_config.mode = config.mode;
+	test_config.params.rx.channel = config.channel_start;
+	test_config.params.rx.pattern = config.tx_pattern;
+#if CONFIG_FEM
+	test_config.fem = config.fem;
+#endif /* CONFIG_FEM */
+
+	if (argc == 2) {
+		config.rx_packets_num = atoi(argv[1]);
+		test_config.params.rx.packets_num = config.rx_packets_num;
+		test_config.params.rx.cb = rx_end;
+
+		if (config.rx_packets_num == 0) {
+			shell_error(shell,
+				   "The number of packets to receive must be greater than zero.");
+			return -EINVAL;
+		}
+	}
+
+	radio_test_start(&test_config);
+
+	return 0;
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos10dBm)
+static void cmd_pos10dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 10;
+	shell_print(shell, "TX power: %d", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos10dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos9dBm)
+static void cmd_pos9dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 9;
+	shell_print(shell, "TX power: %d", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos9dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos8dBm)
+static void cmd_pos8dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 8;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos8dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos7dBm)
+static void cmd_pos7dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 7;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos7dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos6dBm)
+static void cmd_pos6dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 6;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos6dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos5dBm)
+static void cmd_pos5dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 5;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos5dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos4dBm)
+static void cmd_pos4dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 4;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos4dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos3dBm)
+static void cmd_pos3dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 3;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos3dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos2dBm)
+static void cmd_pos2dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 2;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos2dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos1dBm)
+static void cmd_pos1dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 1;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos1dBm) */
+
+static void cmd_pos0dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = 0;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg1dBm)
+static void cmd_neg1dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -1;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg1dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg2dBm)
+static void cmd_neg2dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -2;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg2dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg3dBm)
+static void cmd_neg3dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -3;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg3dBm) */
+
+static void cmd_neg4dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -4;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg5dBm)
+static void cmd_neg5dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -5;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg5dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg6dBm)
+static void cmd_neg6dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -6;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg6dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg7dBm)
+static void cmd_neg7dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -7;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg7dBm) */
+
+static void cmd_neg8dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -8;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg9dBm)
+static void cmd_neg9dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -9;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg9dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg10dBm)
+static void cmd_neg10dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -10;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg10dBm) */
+
+static void cmd_neg12dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -12;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg14dBm)
+static void cmd_neg14dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -14;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg14dBm) */
+
+static void cmd_neg16dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -16;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg18dBm)
+static void cmd_neg18dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -18;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg18dBm) */
+
+static void cmd_neg20dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -20;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg22dBm)
+static void cmd_neg22dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -22;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg22dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg28dBm)
+static void cmd_neg28dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -28;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg28dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg30dBm)
+static void cmd_neg30dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -30;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg30dBm) */
+
+static void cmd_neg40dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -40;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg46dBm)
+static void cmd_neg46dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -46;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg46dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg70dBm)
+static void cmd_neg70dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -70;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg70dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg100dBm)
+static void cmd_neg100dbm(const struct shell *shell, size_t argc, char **argv)
+{
+	config.txpower = -100;
+	shell_print(shell, "TX power : %d dBm", config.txpower);
+}
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg100dBm) */
+
+static int cmd_nrf_1mbit(const struct shell *shell, size_t argc, char **argv)
+{
+	config.mode = NRF_RADIO_MODE_NRF_1MBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_NRF_1MBIT));
+
+	return 0;
+}
+
+static int cmd_nrf_2mbit(const struct shell *shell, size_t argc, char **argv)
+{
+	config.mode = NRF_RADIO_MODE_NRF_2MBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_NRF_2MBIT));
+
+	return 0;
+}
+
+#if defined(RADIO_MODE_MODE_Nrf_250Kbit)
+static int cmd_nrf_250kbit(const struct shell *shell, size_t argc,
+			   char **argv)
+{
+	config.mode = NRF_RADIO_MODE_NRF_250KBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_NRF_250KBIT));
+
+	return 0;
+}
+#endif /* defined(RADIO_MODE_MODE_Nrf_250Kbit) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_5)
+static int cmd_nrf_4mbit_h_0_5(const struct shell *shell, size_t argc,
+			       char **argv)
+{
+	config.mode = NRF_RADIO_MODE_NRF_4MBIT_H_0_5;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_H_0_5));
+
+	return 0;
+}
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_5) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_25)
+static int cmd_nrf_4mbit_h_0_25(const struct shell *shell, size_t argc,
+				char **argv)
+{
+	config.mode = NRF_RADIO_MODE_NRF_4MBIT_H_0_25;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_H_0_25));
+
+	return 0;
+}
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_25) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6)
+static int cmd_nrf_4mbit_bt_0_6(const struct shell *shell, size_t argc,
+				char **argv)
+{
+	config.mode = NRF_RADIO_MODE_NRF_4MBIT_BT_0_6;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_BT_0_6));
+
+	return 0;
+}
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4)
+static int cmd_nrf_4mbit_bt_0_4(const struct shell *shell, size_t argc,
+				char **argv)
+{
+	config.mode = NRF_RADIO_MODE_NRF_4MBIT_BT_0_4;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_NRF_4MBIT_BT_0_4));
+
+	return 0;
+}
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4) */
+
+static int cmd_ble_1mbit(const struct shell *shell, size_t argc, char **argv)
+{
+	config.mode = NRF_RADIO_MODE_BLE_1MBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_BLE_1MBIT));
+
+	return 0;
+}
+
+static int cmd_ble_2mbit(const struct shell *shell, size_t argc, char **argv)
+{
+	config.mode = NRF_RADIO_MODE_BLE_2MBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_BLE_2MBIT));
+
+	return 0;
+}
+
+#if CONFIG_HAS_HW_NRF_RADIO_BLE_CODED
+static int cmd_ble_lr125kbit(const struct shell *shell, size_t argc,
+			     char **argv)
+{
+	config.mode = NRF_RADIO_MODE_BLE_LR125KBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_BLE_LR125KBIT));
+
+	return 0;
+}
+
+static int cmd_ble_lr500kbit(const struct shell *shell, size_t argc,
+			     char **argv)
+{
+	config.mode = NRF_RADIO_MODE_BLE_LR500KBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_BLE_LR500KBIT));
+
+	return 0;
+}
+#endif /* CONFIG_HAS_HW_NRF_RADIO_BLE_CODED */
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+static int cmd_ble_ieee(const struct shell *shell, size_t argc, char **argv)
+{
+	config.mode = NRF_RADIO_MODE_IEEE802154_250KBIT;
+	shell_print(shell, "Data rate: %s",
+		    STRINGIFY(NRF_RADIO_MODE_IEEE802154_250KBIT));
+
+	return 0;
+}
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+static int cmd_pattern_random(const struct shell *shell, size_t argc,
+			      char **argv)
+{
+	config.tx_pattern = TRANSMIT_PATTERN_RANDOM;
+	shell_print(shell,
+		    "Transmission pattern: %s",
+		    STRINGIFY(TRANSMIT_PATTERN_RANDOM));
+
+	return 0;
+}
+
+static int cmd_pattern_11110000(const struct shell *shell, size_t argc,
+				char **argv)
+{
+	config.tx_pattern = TRANSMIT_PATTERN_11110000;
+	shell_print(shell,
+		    "Transmission pattern: %s",
+		    STRINGIFY(TRANSMIT_PATTERN_11110000));
+
+	return 0;
+}
+
+static int cmd_pattern_11001100(const struct shell *shell, size_t argc,
+				char **argv)
+{
+	config.tx_pattern = TRANSMIT_PATTERN_11001100;
+	shell_print(shell,
+		    "Transmission pattern: %s",
+		    STRINGIFY(TRANSMIT_PATTERN_11001100));
+
+	return 0;
+}
+
+SHELL_STATIC_SUBCMD_SET_CREATE(sub_data_rate,
+	SHELL_CMD(nrf_1Mbit, NULL, "1 Mbit/s Nordic proprietary radio mode",
+		  cmd_nrf_1mbit),
+	SHELL_CMD(nrf_2Mbit, NULL, "2 Mbit/s Nordic proprietary radio mode",
+		  cmd_nrf_2mbit),
+
+#if defined(RADIO_MODE_MODE_Nrf_250Kbit)
+	SHELL_CMD(nrf_250Kbit, NULL,
+		  "250 kbit/s Nordic proprietary radio mode",
+		  cmd_nrf_250kbit),
+#endif /* defined(RADIO_MODE_MODE_Nrf_250Kbit) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_5)
+	SHELL_CMD(nrf_4Mbit0_5, NULL,
+		  "4 Mbit/s Nordic proprietary radio mode (BT=0.5/h=0.5)",
+		  cmd_nrf_4mbit_h_0_5),
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_5) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_25)
+	SHELL_CMD(nrf_4Mbit0_25, NULL,
+		  "4 Mbit/s Nordic proprietary radio mode (BT=0.5/h=0.25)",
+		  cmd_nrf_4mbit_h_0_25),
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_25) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6)
+	SHELL_CMD(nrf_4Mbit_BT06, NULL,
+		  "4 Mbps Nordic proprietary radio mode (BT=0.6/h=0.5)",
+		  cmd_nrf_4mbit_bt_0_6),
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4)
+	SHELL_CMD(nrf_4Mbit_BT04, NULL,
+		  "4 Mbps Nordic proprietary radio mode (BT=0.4/h=0.5)",
+		  cmd_nrf_4mbit_bt_0_4),
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4) */
+
+	SHELL_CMD(ble_1Mbit, NULL, "1 Mbit/s Bluetooth Low Energy",
+		  cmd_ble_1mbit),
+	SHELL_CMD(ble_2Mbit, NULL, "2 Mbit/s Bluetooth Low Energy",
+		  cmd_ble_2mbit),
+
+#if CONFIG_HAS_HW_NRF_RADIO_BLE_CODED
+	SHELL_CMD(ble_lr125Kbit, NULL,
+		  "Long range 125 kbit/s TX, 125 kbit/s and 500 kbit/s RX",
+		  cmd_ble_lr125kbit),
+
+	SHELL_CMD(ble_lr500Kbit, NULL,
+		  "Long range 500 kbit/s TX, 125 kbit/s and 500 kbit/s RX",
+		  cmd_ble_lr500kbit),
+#endif /* CONFIG_HAS_HW_NRF_RADIO_BLE_CODED */
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	SHELL_CMD(ieee802154_250Kbit, NULL, "IEEE 802.15.4-2006 250 kbit/s",
+		  cmd_ble_ieee),
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	SHELL_SUBCMD_SET_END
+);
+
+static int cmd_print_payload(const struct shell *shell, size_t argc,
+			     char **argv)
+{
+	struct radio_rx_stats rx_stats;
+
+	memset(&rx_stats, 0, sizeof(rx_stats));
+
+	radio_rx_stats_get(&rx_stats);
+
+	shell_print(shell, "Received payload:");
+	shell_hexdump(shell, rx_stats.last_packet.buf,
+		      rx_stats.last_packet.len);
+	shell_print(shell, "Number of packets: %d", rx_stats.packet_cnt);
+
+	return 0;
+}
+
+#if CONFIG_FEM
+static int cmd_fem(const struct shell *shell, size_t argc, char **argv)
+{
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count.", argv[0]);
+		return -EINVAL;
+	}
+
+	if (argc == 2) {
+		shell_error(shell, "Uknown argument: %s.", argv[1]);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+#if !CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC
+static int cmd_fem_tx_power_control_set(const struct shell *shell, size_t argc,
+			    char **argv)
+{
+	uint32_t tx_power_control;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	tx_power_control = atoi(argv[1]);
+
+	config.fem.tx_power_control = tx_power_control;
+
+	shell_print(shell, "Front-end module (FEM) Tx power control set to %u", tx_power_control);
+
+	return 0;
+}
+#endif /* !CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC */
+
+static int cmd_fem_antenna_select(const struct shell *shell, size_t argc,
+				  char **argv)
+{
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count.", argv[0]);
+		return -EINVAL;
+	}
+
+	if (argc == 2) {
+		shell_error(shell, "Uknown argument: %s.", argv[1]);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int cmd_fem_antenna_1(const struct shell *shell, size_t argc,
+			     char **argv)
+{
+	shell_print(shell, "ANT1 enabled, ANT2 disabled");
+
+	return fem_antenna_select(FEM_ANTENNA_1);
+}
+
+static int cmd_fem_antenna_2(const struct shell *shell, size_t argc,
+			     char **argv)
+{
+	shell_print(shell, "ANT1 disabled, ANT2 enabled");
+
+	return fem_antenna_select(FEM_ANTENNA_2);
+}
+
+static int cmd_fem_ramp_up_set(const struct shell *shell, size_t argc, char **argv)
+{
+	uint32_t ramp_up_time;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	ramp_up_time = atoi(argv[1]);
+
+	config.fem.ramp_up_time = ramp_up_time;
+
+	shell_print(shell, "Front-end module (FEM) radio rump-up time set to %d us", ramp_up_time);
+
+	return 0;
+}
+#endif /* CONFIG_FEM */
+
+SHELL_STATIC_SUBCMD_SET_CREATE(sub_output_power,
+#if defined(RADIO_TXPOWER_TXPOWER_Pos10dBm)
+	SHELL_CMD(pos10dBm, NULL, "TX power: +10 dBm", cmd_pos10dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos10dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos9dBm)
+	SHELL_CMD(pos9dBm, NULL, "TX power: +9 dBm", cmd_pos9dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos9dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos8dBm)
+	SHELL_CMD(pos8dBm, NULL, "TX power: +8 dBm", cmd_pos8dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos8dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos7dBm)
+	SHELL_CMD(pos7dBm, NULL, "TX power: +7 dBm", cmd_pos7dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos7dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos6dBm)
+	SHELL_CMD(pos6dBm, NULL, "TX power: +6 dBm", cmd_pos6dbm),
+#endif/* defined(RADIO_TXPOWER_TXPOWER_Pos6dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos5dBm)
+	SHELL_CMD(pos5dBm, NULL, "TX power: +5 dBm", cmd_pos5dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos5dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos4dBm)
+	SHELL_CMD(pos4dBm, NULL, "TX power: +4 dBm", cmd_pos4dbm),
+#endif /* RADIO_TXPOWER_TXPOWER_Pos4dBm */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos3dBm)
+	SHELL_CMD(pos3dBm, NULL, "TX power: +3 dBm", cmd_pos3dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos3dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos2dBm)
+	SHELL_CMD(pos2dBm, NULL, "TX power: +2 dBm", cmd_pos2dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos2dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Pos1dBm)
+	SHELL_CMD(pos1dBm, NULL, "TX power: +1 dBm", cmd_pos1dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos1dBm) */
+	SHELL_CMD(pos0dBm, NULL, "TX power: 0 dBm", cmd_pos0dbm),
+#if defined(RADIO_TXPOWER_TXPOWER_Neg1dBm)
+	SHELL_CMD(neg1dBm, NULL, "TX power: -1 dBm", cmd_neg1dbm),
+#endif /* RADIO_TXPOWER_TXPOWER_Neg1dBm */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg2dBm)
+	SHELL_CMD(neg2dBm, NULL, "TX power: -2 dBm", cmd_neg2dbm),
+#endif /* RADIO_TXPOWER_TXPOWER_Neg2dBm */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg3dBm)
+	SHELL_CMD(neg3dBm, NULL, "TX power: -3 dBm", cmd_neg3dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg3dBm) */
+	SHELL_CMD(neg4dBm, NULL, "TX power: -4 dBm", cmd_neg4dbm),
+#if defined(RADIO_TXPOWER_TXPOWER_Neg5dBm)
+	SHELL_CMD(neg5dBm, NULL, "TX power: -5 dBm", cmd_neg5dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg5dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg6dBm)
+	SHELL_CMD(neg6dBm, NULL, "TX power: -6 dBm", cmd_neg6dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg6dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg7dBm)
+	SHELL_CMD(neg7dBm, NULL, "TX power: -7 dBm", cmd_neg7dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg7dBm) */
+	SHELL_CMD(neg8dBm, NULL, "TX power: -8 dBm", cmd_neg8dbm),
+#if defined(RADIO_TXPOWER_TXPOWER_Neg9dBm)
+	SHELL_CMD(neg9dBm, NULL, "TX power: -9 dBm", cmd_neg9dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg9dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg10dBm)
+	SHELL_CMD(neg10dBm, NULL, "TX power: -10 dBm", cmd_neg10dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg10dBm) */
+	SHELL_CMD(neg12dBm, NULL, "TX power: -12 dBm", cmd_neg12dbm),
+#if defined(RADIO_TXPOWER_TXPOWER_Neg14dBm)
+	SHELL_CMD(neg14dBm, NULL, "TX power: -14 dBm", cmd_neg14dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg14dBm) */
+	SHELL_CMD(neg16dBm, NULL, "TX power: -16 dBm", cmd_neg16dbm),
+#if defined(RADIO_TXPOWER_TXPOWER_Neg18dBm)
+	SHELL_CMD(neg18dBm, NULL, "TX power: -18 dBm", cmd_neg18dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg18dBm) */
+	SHELL_CMD(neg20dBm, NULL, "TX power: -20 dBm", cmd_neg20dbm),
+#if defined(RADIO_TXPOWER_TXPOWER_Neg22dBm)
+	SHELL_CMD(neg22dBm, NULL, "TX power: -22 dBm", cmd_neg22dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg22dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg28dBm)
+	SHELL_CMD(neg28dBm, NULL, "TX power: -28 dBm", cmd_neg28dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg28dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg30dBm)
+	SHELL_CMD(neg30dBm, NULL, "TX power: -30 dBm", cmd_neg30dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg30dBm) */
+	SHELL_CMD(neg40dBm, NULL, "TX power: -40 dBm", cmd_neg40dbm),
+#if defined(RADIO_TXPOWER_TXPOWER_Neg46dBm)
+	SHELL_CMD(neg46dBm, NULL, "TX power: -46 dBm", cmd_neg46dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg46dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg70dBm)
+	SHELL_CMD(neg70dBm, NULL, "TX power: -70 dBm", cmd_neg70dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg70dBm) */
+#if defined(RADIO_TXPOWER_TXPOWER_Neg100dBm)
+	SHELL_CMD(neg100dBm, NULL, "TX power: -100 dBm", cmd_neg100dbm),
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg100dBm) */
+	SHELL_SUBCMD_SET_END
+);
+
+SHELL_STATIC_SUBCMD_SET_CREATE(sub_transmit_pattern,
+	SHELL_CMD(pattern_random, NULL,
+		  "Set the transmission pattern to random.",
+		  cmd_pattern_random),
+	SHELL_CMD(pattern_11110000, NULL,
+		  "Set the transmission pattern to 11110000.",
+		  cmd_pattern_11110000),
+	SHELL_CMD(pattern_11001100, NULL,
+		  "Set the transmission pattern to 10101010.",
+		  cmd_pattern_11001100),
+	SHELL_SUBCMD_SET_END
+);
+
+#if CONFIG_FEM
+SHELL_STATIC_SUBCMD_SET_CREATE(sub_fem_antenna,
+	SHELL_CMD(ant_1, NULL,
+		  "ANT1 enabled, ANT2 disabled.",
+		  cmd_fem_antenna_1),
+	SHELL_CMD(ant_2, NULL,
+		  "ANT1 disabled, ANT2 enabled",
+		  cmd_fem_antenna_2),
+	SHELL_SUBCMD_SET_END
+);
+
+SHELL_STATIC_SUBCMD_SET_CREATE(sub_fem,
+#if !CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC
+	SHELL_CMD(tx_power_control, NULL,
+		  "Set the front-end module (FEM) Tx power control specific to the FEM in use <tx_power_control>.",
+		  cmd_fem_tx_power_control_set),
+#endif /* !CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC */
+	SHELL_CMD(antenna, &sub_fem_antenna,
+		  "Select the front-end module (FEM) antenna <sub_cmd>",
+		  cmd_fem_antenna_select),
+	SHELL_CMD(ramp_up_time, NULL,
+		  "Set the front-end module (FEM) radio ramp-up time <time us>",
+		  cmd_fem_ramp_up_set),
+	SHELL_SUBCMD_SET_END
+);
+#endif /* CONFIG_FEM */
+
+#if CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC
+static int cmd_total_output_power_set(const struct shell *shell, size_t argc, char **argv)
+{
+	int power;
+
+	if (argc == 1) {
+		shell_help(shell);
+		return SHELL_CMD_HELP_PRINTED;
+	}
+
+	if (argc > 2) {
+		shell_error(shell, "%s: bad parameters count", argv[0]);
+		return -EINVAL;
+	}
+
+	power = atoi(argv[1]);
+
+	if ((power > INT8_MAX) || (power < INT8_MIN)) {
+		shell_error(shell, "%s: Out of range power value", argv[0]);
+		return -EINVAL;
+	}
+
+	config.txpower = (int8_t)power;
+
+	return 0;
+}
+#endif /* CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC */
+
+SHELL_CMD_REGISTER(start_channel, NULL,
+		   "Start channel for the sweep or the channel for"
+		   " the constant carrier (in MHz as difference from 2400 MHz) <channel>",
+		    cmd_start_channel_set);
+SHELL_CMD_REGISTER(end_channel, NULL,
+		   "End channel for the sweep (in MHz as difference from 2400 MHz) <channel>",
+		   cmd_end_channel_set);
+SHELL_CMD_REGISTER(time_on_channel, NULL,
+		   "Time on each channel in ms (between 1 and 99) <time>",
+		   cmd_time_set);
+SHELL_CMD_REGISTER(cancel, NULL, "Cancel the sweep or the carrier",
+		   cmd_cancel);
+SHELL_CMD_REGISTER(data_rate, &sub_data_rate, "Set data rate <sub_cmd>",
+		   cmd_data_rate_set);
+SHELL_CMD_REGISTER(start_tx_carrier, NULL, "Start the TX carrier",
+		   cmd_tx_carrier_start);
+SHELL_CMD_REGISTER(start_tx_modulated_carrier, NULL,
+		   "Start the modulated TX carrier",
+		   cmd_tx_modulated_carrier_start);
+SHELL_CMD_REGISTER(output_power,
+		   &sub_output_power,
+		   "Output power set <sub_cmd>"
+		   "If front-end module is attached and automatic power control is enabled, "
+		   "this commands sets the total output power including fem gain",
+		   cmd_output_power_set);
+
+#if CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC
+SHELL_CMD_REGISTER(total_output_power, NULL,
+		  "Total output power in dBm, including gain of the attached front-end module. "
+		  "<tx power> dBm",
+		  cmd_total_output_power_set);
+#endif /* CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC */
+
+SHELL_CMD_REGISTER(transmit_pattern,
+		   &sub_transmit_pattern,
+		   "Set the transmission pattern",
+		   cmd_transmit_pattern_set);
+SHELL_CMD_REGISTER(start_duty_cycle_modulated_tx, NULL,
+		   "Duty cycle in percent (two decimal digits, between 01 and "
+		   "90) <duty_cycle>", cmd_duty_cycle_set);
+SHELL_CMD_REGISTER(parameters_print, NULL,
+		   "Print current delay, channel and so on",
+		   cmd_print);
+SHELL_CMD_REGISTER(start_rx_sweep, NULL, "Start RX sweep", cmd_rx_sweep_start);
+SHELL_CMD_REGISTER(start_tx_sweep, NULL, "Start TX sweep", cmd_tx_sweep_start);
+SHELL_CMD_REGISTER(start_rx, NULL, "Start RX", cmd_rx_start);
+SHELL_CMD_REGISTER(print_rx, NULL, "Print RX payload", cmd_print_payload);
+#if defined(TOGGLE_DCDC_HELP)
+SHELL_CMD_REGISTER(toggle_dcdc_state, NULL, TOGGLE_DCDC_HELP, cmd_toggle_dc);
+#endif
+#if CONFIG_FEM
+SHELL_CMD_REGISTER(fem,
+		   &sub_fem,
+		   "Set the front-end module (FEM) parameters <sub_cmd>",
+		   cmd_fem);
+#endif /* CONFIG_FEM */
+
+static int radio_cmd_init(void)
+{
+
+#if CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC
+	/* When front-end module is used, set output power to the front-end module
+	 * default output power.
+	 */
+	config.txpower = fem_default_tx_output_power_get();
+#endif /* CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC */
+
+	return radio_test_init(&test_config);
+}
+
+SYS_INIT(radio_cmd_init, APPLICATION, CONFIG_KERNEL_INIT_PRIORITY_DEVICE);
diff --git a/samples/wifi/radio_test/single_domain/src/radio_test.c b/samples/wifi/radio_test/single_domain/src/radio_test.c
new file mode 100644
index 000000000000..65205f06d77a
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/radio_test.c
@@ -0,0 +1,1180 @@
+/*
+ * Copyright (c) 2020 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include "radio_test.h"
+
+#include <string.h>
+#include <inttypes.h>
+
+#if !(defined(CONFIG_SOC_SERIES_NRF54HX) || defined(CONFIG_SOC_SERIES_NRF54LX))
+#include <hal/nrf_power.h>
+#endif /* !(defined(CONFIG_SOC_SERIES_NRF54HX) || defined(CONFIG_SOC_SERIES_NRF54LX)) */
+
+#ifdef NRF53_SERIES
+#include <hal/nrf_vreqctrl.h>
+#endif /* NRF53_SERIES */
+
+#include <nrfx_timer.h>
+#include <zephyr/kernel.h>
+#include <zephyr/random/random.h>
+
+#include <hal/nrf_egu.h>
+#include <helpers/nrfx_gppi.h>
+
+#if CONFIG_FEM
+#include "fem_al/fem_al.h"
+#endif /* CONFIG_FEM */
+
+/* IEEE 802.15.4 default frequency. */
+#define IEEE_DEFAULT_FREQ         (5)
+/* Length on air of the LENGTH field. */
+#define RADIO_LENGTH_LENGTH_FIELD (8UL)
+
+#define RADIO_TEST_EGU_EVENT NRF_EGU_EVENT_TRIGGERED0
+#define RADIO_TEST_EGU_TASK  NRF_EGU_TASK_TRIGGER0
+
+/* Frequency calculation for a given channel in the IEEE 802.15.4 radio
+ * mode.
+ */
+#define IEEE_FREQ_CALC(_channel) (IEEE_DEFAULT_FREQ + \
+				 (IEEE_DEFAULT_FREQ * \
+				 ((_channel) - IEEE_MIN_CHANNEL)))
+/* Frequency calculation for a given channel. */
+#define CHAN_TO_FREQ(_channel) (2400 + _channel)
+
+#if defined(CONFIG_SOC_SERIES_NRF54HX)
+	#define RADIO_TEST_EGU                     NRF_EGU020
+	#define RADIO_TEST_TIMER_INSTANCE          020
+	#define RADIO_TEST_TIMER_IRQn              TIMER020_IRQn
+	#define RADIO_TEST_RADIO_IRQn              RADIO_0_IRQn
+	#define RADIO_TEST_SHORT_END_DISABLE_MASK  NRF_RADIO_SHORT_PHYEND_DISABLE_MASK
+	#define RADIO_TEST_SHORT_END_START_MASK    NRF_RADIO_SHORT_PHYEND_START_MASK
+#elif defined(CONFIG_SOC_SERIES_NRF54LX)
+	#define RADIO_TEST_EGU                     NRF_EGU10
+	#define RADIO_TEST_TIMER_INSTANCE          10
+	#define RADIO_TEST_TIMER_IRQn              TIMER10_IRQn
+	#define RADIO_TEST_RADIO_IRQn              RADIO_0_IRQn
+	#define RADIO_TEST_SHORT_END_DISABLE_MASK  NRF_RADIO_SHORT_PHYEND_DISABLE_MASK
+	#define RADIO_TEST_SHORT_END_START_MASK    NRF_RADIO_SHORT_PHYEND_START_MASK
+#else
+	#define RADIO_TEST_EGU                     NRF_EGU0
+	#define RADIO_TEST_TIMER_INSTANCE          0
+	#define RADIO_TEST_TIMER_IRQn              TIMER0_IRQn
+	#define RADIO_TEST_RADIO_IRQn              RADIO_IRQn
+	#define RADIO_TEST_SHORT_END_DISABLE_MASK  NRF_RADIO_SHORT_END_DISABLE_MASK
+	#define RADIO_TEST_SHORT_END_START_MASK    NRF_RADIO_SHORT_END_START_MASK
+#endif /* defined(CONFIG_SOC_SERIES_NRF54HX) */
+
+#define RADIO_TEST_TIMER_IRQ_HANDLER  NRFX_CONCAT_3(nrfx_timer_,	    \
+						 RADIO_TEST_TIMER_INSTANCE, \
+						 _irq_handler)
+
+#define ENDPOINT_EGU_RADIO_TX    BIT(1)
+#define ENDPOINT_EGU_RADIO_RX    BIT(2)
+#define ENDPOINT_TIMER_RADIO_TX  BIT(3)
+#define ENDPOINT_FORK_EGU_TIMER  BIT(4)
+
+/* RX timeout counted from the last packet received. */
+#define RX_PACKET_TIMEOUT_MS 100
+
+/* Buffer for the radio TX packet */
+static uint8_t tx_packet[RADIO_MAX_PAYLOAD_LEN];
+/* Buffer for the radio RX packet. */
+static uint8_t rx_packet[RADIO_MAX_PAYLOAD_LEN];
+/* Number of transmitted packets. */
+static uint32_t tx_packet_cnt;
+/* Number of received packets with valid CRC. */
+static uint32_t rx_packet_cnt;
+
+/* Radio current channel (frequency). */
+static uint8_t current_channel;
+
+/* Timer used for channel sweeps and tx with duty cycle. */
+static const nrfx_timer_t timer = NRFX_TIMER_INSTANCE(RADIO_TEST_TIMER_INSTANCE);
+
+static bool sweep_processing;
+
+/* Total payload size */
+static uint16_t total_payload_size;
+
+/* PPI channel for starting radio */
+static uint8_t ppi_radio_start;
+
+/* PPI endpoint status.*/
+static atomic_t endpoint_state;
+
+/*  Work element used to handle the end of packet reception. */
+static void rx_timeout_work_handler(struct k_work *work);
+K_WORK_DELAYABLE_DEFINE(rx_timeout_work, rx_timeout_work_handler);
+
+/* Pointer to rx timeout callback function. */
+static void (**rx_timeout_cb)(void);
+
+#if CONFIG_FEM
+static struct radio_test_fem fem;
+#endif /* CONFIG_FEM */
+
+static uint16_t channel_to_frequency(nrf_radio_mode_t mode, uint8_t channel)
+{
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	if (mode == NRF_RADIO_MODE_IEEE802154_250KBIT) {
+		if ((channel >= IEEE_MIN_CHANNEL) &&
+			(channel <= IEEE_MAX_CHANNEL)) {
+			return CHAN_TO_FREQ(IEEE_FREQ_CALC(channel));
+		} else {
+			return CHAN_TO_FREQ(IEEE_DEFAULT_FREQ);
+		}
+	} else {
+		return CHAN_TO_FREQ(channel);
+	}
+#else
+	return CHAN_TO_FREQ(channel);
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+}
+
+static nrf_radio_txpower_t dbm_to_nrf_radio_txpower(int8_t tx_power)
+{
+	switch (tx_power) {
+#if defined(RADIO_TXPOWER_TXPOWER_Neg100dBm)
+	case -100:
+		return RADIO_TXPOWER_TXPOWER_Neg100dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg100dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg70dBm)
+	case -70:
+		return RADIO_TXPOWER_TXPOWER_Neg70dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg70dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg46dBm)
+	case -46:
+		return RADIO_TXPOWER_TXPOWER_Neg46dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg46dBm) */
+
+	case -40:
+		return RADIO_TXPOWER_TXPOWER_Neg40dBm;
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg30dBm)
+	case -30:
+		return RADIO_TXPOWER_TXPOWER_Neg30dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg30dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg28dBm)
+	case -28:
+		return RADIO_TXPOWER_TXPOWER_Neg28dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg28dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg22dBm)
+	case -22:
+		return RADIO_TXPOWER_TXPOWER_Neg22dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg22dBm) */
+
+	case -20:
+		return RADIO_TXPOWER_TXPOWER_Neg20dBm;
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg18dBm)
+	case -18:
+		return RADIO_TXPOWER_TXPOWER_Neg18dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg18dBm) */
+
+	case -16:
+		return RADIO_TXPOWER_TXPOWER_Neg16dBm;
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg14dBm)
+	case -14:
+		return RADIO_TXPOWER_TXPOWER_Neg14dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg14dBm) */
+
+	case -12:
+		return RADIO_TXPOWER_TXPOWER_Neg12dBm;
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg10dBm)
+	case -10:
+		return RADIO_TXPOWER_TXPOWER_Neg10dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg10dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg9dBm)
+	case -9:
+		return RADIO_TXPOWER_TXPOWER_Neg9dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg9dBm) */
+
+	case -8:
+		return RADIO_TXPOWER_TXPOWER_Neg8dBm;
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg7dBm)
+	case -7:
+		return RADIO_TXPOWER_TXPOWER_Neg7dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg7dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg6dBm)
+	case -6:
+		return RADIO_TXPOWER_TXPOWER_Neg6dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg6dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg5dBm)
+	case -5:
+		return RADIO_TXPOWER_TXPOWER_Neg5dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Neg5dBm) */
+
+	case -4:
+		return RADIO_TXPOWER_TXPOWER_Neg4dBm;
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg3dBm)
+	case -3:
+		return RADIO_TXPOWER_TXPOWER_Neg3dBm;
+#endif /* defined (RADIO_TXPOWER_TXPOWER_Neg3dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg2dBm)
+	case -2:
+		return RADIO_TXPOWER_TXPOWER_Neg2dBm;
+#endif /* defined (RADIO_TXPOWER_TXPOWER_Neg2dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Neg1dBm)
+	case -1:
+		return RADIO_TXPOWER_TXPOWER_Neg1dBm;
+#endif /* defined (RADIO_TXPOWER_TXPOWER_Neg1dBm) */
+
+	case 0:
+		return RADIO_TXPOWER_TXPOWER_0dBm;
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos1dBm)
+	case 1:
+		return RADIO_TXPOWER_TXPOWER_Pos1dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos1dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos2dBm)
+	case 2:
+		return RADIO_TXPOWER_TXPOWER_Pos2dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos2dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos3dBm)
+	case 3:
+		return RADIO_TXPOWER_TXPOWER_Pos3dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos3dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos4dBm)
+	case 4:
+		return RADIO_TXPOWER_TXPOWER_Pos4dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos4dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos5dBm)
+	case 5:
+		return RADIO_TXPOWER_TXPOWER_Pos5dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos5dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos6dBm)
+	case 6:
+		return RADIO_TXPOWER_TXPOWER_Pos6dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos6dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos7dBm)
+	case 7:
+		return RADIO_TXPOWER_TXPOWER_Pos7dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos7dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos8dBm)
+	case 8:
+		return RADIO_TXPOWER_TXPOWER_Pos8dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos8dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos9dBm)
+	case 9:
+		return RADIO_TXPOWER_TXPOWER_Pos9dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos9dBm) */
+
+#if defined(RADIO_TXPOWER_TXPOWER_Pos10dBm)
+	case 10:
+		return RADIO_TXPOWER_TXPOWER_Pos10dBm;
+#endif /* defined(RADIO_TXPOWER_TXPOWER_Pos10dBm) */
+
+	default:
+		printk("TX power to enumerator conversion failed, defaulting to 0 dBm\n");
+		return RADIO_TXPOWER_TXPOWER_0dBm;
+	}
+}
+
+static void radio_power_set(nrf_radio_mode_t mode, uint8_t channel, int8_t power)
+{
+	int8_t output_power = power;
+	int8_t radio_power = power;
+
+#if CONFIG_FEM
+	uint16_t frequency;
+
+	if (IS_ENABLED(CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC)) {
+		frequency = channel_to_frequency(mode, channel);
+		output_power = fem_tx_output_power_prepare(power, &radio_power, frequency);
+	}
+#else
+	ARG_UNUSED(mode);
+	ARG_UNUSED(channel);
+#endif /* CONFIG_FEM */
+
+#ifdef NRF53_SERIES
+	bool high_voltage_enable = false;
+
+	if (radio_power > 0) {
+		high_voltage_enable = true;
+
+		/* High voltage increases radio output power by 3 dBm. */
+		radio_power -= 3;
+	}
+
+	nrf_vreqctrl_radio_high_voltage_set(NRF_VREQCTRL, high_voltage_enable);
+#endif /* NRF53_SERIES */
+
+	nrf_radio_txpower_set(NRF_RADIO, dbm_to_nrf_radio_txpower(radio_power));
+
+	if (!sweep_processing) {
+		printk("Requested tx output power: %" PRIi8 " dBm\n", power);
+		printk("Tx output power set to: %" PRIi8 " dBm\n", output_power);
+	}
+}
+
+static void endpoints_clear(void)
+{
+	if (atomic_test_and_clear_bit(&endpoint_state, ENDPOINT_FORK_EGU_TIMER)) {
+		nrfx_gppi_fork_endpoint_clear(ppi_radio_start,
+			nrf_timer_task_address_get(timer.p_reg, NRF_TIMER_TASK_START));
+	}
+	if (atomic_test_and_clear_bit(&endpoint_state, ENDPOINT_EGU_RADIO_TX)) {
+		nrfx_gppi_channel_endpoints_clear(ppi_radio_start,
+			nrf_egu_event_address_get(RADIO_TEST_EGU, RADIO_TEST_EGU_EVENT),
+			nrf_radio_task_address_get(NRF_RADIO, NRF_RADIO_TASK_TXEN));
+	}
+	if (atomic_test_and_clear_bit(&endpoint_state, ENDPOINT_EGU_RADIO_RX)) {
+		nrfx_gppi_channel_endpoints_clear(ppi_radio_start,
+			nrf_egu_event_address_get(RADIO_TEST_EGU, RADIO_TEST_EGU_EVENT),
+			nrf_radio_task_address_get(NRF_RADIO, NRF_RADIO_TASK_RXEN));
+	}
+	if (atomic_test_and_clear_bit(&endpoint_state, ENDPOINT_TIMER_RADIO_TX)) {
+		nrfx_gppi_channel_endpoints_clear(ppi_radio_start,
+			nrf_timer_event_address_get(timer.p_reg, NRF_TIMER_EVENT_COMPARE0),
+			nrf_radio_task_address_get(NRF_RADIO, NRF_RADIO_TASK_TXEN));
+	}
+}
+
+static void radio_ppi_config(bool rx)
+{
+	endpoints_clear();
+
+	nrfx_gppi_channel_endpoints_setup(ppi_radio_start,
+			nrf_egu_event_address_get(RADIO_TEST_EGU, RADIO_TEST_EGU_EVENT),
+			nrf_radio_task_address_get(NRF_RADIO,
+						   rx ? NRF_RADIO_TASK_RXEN : NRF_RADIO_TASK_TXEN));
+	atomic_set_bit(&endpoint_state, (rx ? ENDPOINT_EGU_RADIO_RX : ENDPOINT_EGU_RADIO_TX));
+
+	nrfx_gppi_fork_endpoint_setup(ppi_radio_start,
+			nrf_timer_task_address_get(timer.p_reg, NRF_TIMER_TASK_START));
+	atomic_set_bit(&endpoint_state, ENDPOINT_FORK_EGU_TIMER);
+
+	nrfx_gppi_channels_enable(BIT(ppi_radio_start));
+}
+
+static void radio_ppi_tx_reconfigure(void)
+{
+	if (nrfx_gppi_channel_check(ppi_radio_start)) {
+		nrfx_gppi_channels_disable(BIT(ppi_radio_start));
+	}
+
+	endpoints_clear();
+
+	nrfx_gppi_channel_endpoints_setup(ppi_radio_start,
+		nrf_timer_event_address_get(timer.p_reg, NRF_TIMER_EVENT_COMPARE1),
+		nrf_radio_task_address_get(NRF_RADIO, NRF_RADIO_TASK_TXEN));
+	atomic_set_bit(&endpoint_state, ENDPOINT_TIMER_RADIO_TX);
+
+	nrfx_gppi_channels_enable(BIT(ppi_radio_start));
+}
+
+#if CONFIG_FEM
+static int fem_configure(bool rx, nrf_radio_mode_t mode,
+			 struct radio_test_fem *fem)
+{
+	int err;
+
+	/* FEM is kept powered during sweeping */
+	if (!sweep_processing) {
+		err = fem_power_up();
+		if (err) {
+			return err;
+		}
+	}
+
+	if (fem->ramp_up_time == 0) {
+		fem->ramp_up_time =
+			fem_default_ramp_up_time_get(false, mode);
+	}
+
+	if (!sweep_processing) {
+		nrf_timer_shorts_enable(timer.p_reg,
+			(NRF_TIMER_SHORT_COMPARE2_STOP_MASK | NRF_TIMER_SHORT_COMPARE2_CLEAR_MASK));
+	}
+
+	radio_ppi_config(rx);
+
+	if (rx) {
+		err = fem_rx_configure(fem->ramp_up_time);
+		if (err) {
+			printk("Failed to configure LNA.\n");
+		}
+
+		return err;
+	}
+
+	if ((!IS_ENABLED(CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC)) &&
+	    (fem->tx_power_control != FEM_USE_DEFAULT_TX_POWER_CONTROL) &&
+	    !sweep_processing) {
+		err = fem_tx_power_control_set(fem->tx_power_control);
+		if (err) {
+			printk("%u: out of range FEM Tx power control value or setting Tx power control is not supported\n",
+				fem->tx_power_control);
+			return err;
+		}
+	}
+
+	err = fem_tx_configure(fem->ramp_up_time);
+	if (err) {
+		printk("Failed to configure PA.\n");
+	}
+
+	fem_errata_25X(mode);
+
+	return err;
+}
+#endif /* CONFIG_FEM */
+
+static void radio_start(bool rx, bool force_egu)
+{
+	if (IS_ENABLED(CONFIG_FEM) || force_egu) {
+		nrf_egu_task_trigger(RADIO_TEST_EGU, RADIO_TEST_EGU_TASK);
+	} else {
+		nrf_radio_task_trigger(NRF_RADIO, rx ? NRF_RADIO_TASK_RXEN : NRF_RADIO_TASK_TXEN);
+	}
+}
+
+static void radio_channel_set(nrf_radio_mode_t mode, uint8_t channel)
+{
+	uint16_t frequency;
+
+	frequency = channel_to_frequency(mode, channel);
+	nrf_radio_frequency_set(NRF_RADIO, frequency);
+}
+
+static void radio_config(nrf_radio_mode_t mode, enum transmit_pattern pattern)
+{
+	nrf_radio_packet_conf_t packet_conf;
+
+	/* Set fast ramp-up time. */
+#if defined(CONFIG_SOC_SERIES_NRF54HX) || defined(CONFIG_SOC_SERIES_NRF54LX)
+	nrf_radio_fast_ramp_up_enable_set(NRF_RADIO, true);
+#else
+	nrf_radio_modecnf0_set(NRF_RADIO, true, RADIO_MODECNF0_DTX_Center);
+#endif /* defined(CONFIG_SOC_SERIES_NRF54HX) || defined(CONFIG_SOC_SERIES_NRF54LX) */
+
+	/* Disable CRC. */
+	nrf_radio_crc_configure(NRF_RADIO, RADIO_CRCCNF_LEN_Disabled,
+				NRF_RADIO_CRC_ADDR_INCLUDE, 0);
+
+	/* Set the device address 0 to use when transmitting. */
+	nrf_radio_txaddress_set(NRF_RADIO, 0);
+	/* Enable the device address 0 to use to select which addresses to
+	 * receive
+	 */
+	nrf_radio_rxaddresses_set(NRF_RADIO, 1);
+
+	/* Set the address according to the transmission pattern. */
+	switch (pattern) {
+	case TRANSMIT_PATTERN_RANDOM:
+		nrf_radio_prefix0_set(NRF_RADIO, 0xAB);
+		nrf_radio_base0_set(NRF_RADIO, 0xABABABAB);
+		break;
+
+	case TRANSMIT_PATTERN_11001100:
+		nrf_radio_prefix0_set(NRF_RADIO, 0xCC);
+		nrf_radio_base0_set(NRF_RADIO, 0xCCCCCCCC);
+		break;
+
+	case TRANSMIT_PATTERN_11110000:
+		nrf_radio_prefix0_set(NRF_RADIO, 0x6A);
+		nrf_radio_base0_set(NRF_RADIO, 0x58FE811B);
+		break;
+
+	default:
+		return;
+	}
+
+	/* Packet configuration:
+	 * payload length size = 8 bits,
+	 * 0-byte static length, max 255-byte payload,
+	 * 4-byte base address length (5-byte full address length),
+	 * Bit 24: 1 Big endian,
+	 * Bit 25: 1 Whitening enabled.
+	 */
+	memset(&packet_conf, 0, sizeof(packet_conf));
+	packet_conf.lflen = RADIO_LENGTH_LENGTH_FIELD;
+	packet_conf.maxlen = (sizeof(tx_packet) - 1);
+	packet_conf.statlen = 0;
+	packet_conf.balen = 4;
+	packet_conf.big_endian = true;
+	packet_conf.whiteen = true;
+
+	switch (mode) {
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	case NRF_RADIO_MODE_IEEE802154_250KBIT:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 32-bit preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_32BIT_ZERO;
+		packet_conf.maxlen = IEEE_MAX_PAYLOAD_LEN;
+		packet_conf.balen = 0;
+		packet_conf.big_endian = false;
+		packet_conf.whiteen = false;
+
+		/* preamble, address (BALEN + PREFIX), lflen and payload */
+		total_payload_size = 4 + (packet_conf.balen + 1) + 1 + packet_conf.maxlen;
+		break;
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+#if CONFIG_HAS_HW_NRF_RADIO_BLE_CODED
+	case NRF_RADIO_MODE_BLE_LR500KBIT:
+	case NRF_RADIO_MODE_BLE_LR125KBIT:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 10 bytes preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_LONG_RANGE;
+		packet_conf.cilen = 2;
+		packet_conf.termlen = 3;
+		packet_conf.big_endian = false;
+		packet_conf.balen = 3;
+
+		/* Set CRC length; CRC calculation does not include the address
+		 * field.
+		 */
+		nrf_radio_crc_configure(NRF_RADIO, RADIO_CRCCNF_LEN_Three,
+					NRF_RADIO_CRC_ADDR_SKIP, 0);
+
+		/* preamble, address (BALEN + PREFIX), lflen, code indicator, TERM, payload, CRC */
+		total_payload_size = 10 + (packet_conf.balen + 1) + 1 + packet_conf.cilen +
+				  packet_conf.termlen + packet_conf.maxlen + RADIO_CRCCNF_LEN_Three;
+		break;
+
+#endif /* CONFIG_HAS_HW_NRF_RADIO_BLE_CODED */
+
+	case NRF_RADIO_MODE_BLE_2MBIT:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 16-bit preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_16BIT;
+
+		/* preamble, address (BALEN + PREFIX), lflen and payload */
+		total_payload_size = 2 + (packet_conf.balen + 1) + 1 + packet_conf.maxlen;
+		break;
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_5)
+	case NRF_RADIO_MODE_NRF_4MBIT_H_0_5:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 16-bit preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_16BIT;
+
+		/* preamble, address (BALEN + PREFIX), lflen and payload */
+		total_payload_size = 2 + (packet_conf.balen + 1) + 1 + packet_conf.maxlen;
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_5) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_25)
+	case NRF_RADIO_MODE_NRF_4MBIT_H_0_25:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 16-bit preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_16BIT;
+
+		/* preamble, address (BALEN + PREFIX), lflen and payload */
+		total_payload_size = 2 + (packet_conf.balen + 1) + 1 + packet_conf.maxlen;
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_25) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6)
+	case NRF_RADIO_MODE_NRF_4MBIT_BT_0_6:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 16-bit preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_16BIT;
+
+		/* preamble, address (BALEN + PREFIX), lflen and payload */
+		total_payload_size = 2 + (packet_conf.balen + 1) + 1 + packet_conf.maxlen;
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6) */
+
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4)
+	case NRF_RADIO_MODE_NRF_4MBIT_BT_0_4:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 16-bit preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_16BIT;
+
+		/* preamble, address (BALEN + PREFIX), lflen and payload */
+		total_payload_size = 2 + (packet_conf.balen + 1) + 1 + packet_conf.maxlen;
+		break;
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4) */
+
+	default:
+		/* Packet configuration:
+		 * S1 size = 0 bits,
+		 * S0 size = 0 bytes,
+		 * 8-bit preamble.
+		 */
+		packet_conf.plen = NRF_RADIO_PREAMBLE_LENGTH_8BIT;
+
+		/* preamble, address (BALEN + PREFIX), lflen, and payload */
+		total_payload_size = 1 + (packet_conf.balen + 1) + 1 + packet_conf.maxlen;
+		break;
+	}
+
+	nrf_radio_packet_configure(NRF_RADIO, &packet_conf);
+}
+
+static void generate_modulated_rf_packet(uint8_t mode,
+					 enum transmit_pattern pattern)
+{
+	radio_config(mode, pattern);
+
+	/* One byte used for size, actual size is SIZE-1 */
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	if (mode == NRF_RADIO_MODE_IEEE802154_250KBIT) {
+		tx_packet[0] = IEEE_MAX_PAYLOAD_LEN - 1;
+	} else {
+		tx_packet[0] = sizeof(tx_packet) - 1;
+	}
+#else
+	tx_packet[0] = sizeof(tx_packet) - 1;
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	switch (pattern) {
+	case TRANSMIT_PATTERN_RANDOM:
+		sys_rand_get(tx_packet + 1, sizeof(tx_packet) - 1);
+		break;
+	case TRANSMIT_PATTERN_11001100:
+		memset(tx_packet + 1, 0xCC, sizeof(tx_packet) - 1);
+		break;
+	case TRANSMIT_PATTERN_11110000:
+		memset(tx_packet + 1, 0xF0, sizeof(tx_packet) - 1);
+		break;
+	default:
+		/* Do nothing. */
+		break;
+	}
+
+	nrf_radio_packetptr_set(NRF_RADIO, tx_packet);
+}
+
+static void radio_disable(void)
+{
+	nrf_radio_shorts_set(NRF_RADIO, 0);
+	nrf_radio_int_disable(NRF_RADIO, ~0);
+	nrf_radio_event_clear(NRF_RADIO, NRF_RADIO_EVENT_DISABLED);
+
+	nrf_radio_task_trigger(NRF_RADIO, NRF_RADIO_TASK_DISABLE);
+	while (!nrf_radio_event_check(NRF_RADIO, NRF_RADIO_EVENT_DISABLED)) {
+		/* Do nothing */
+	}
+	nrf_radio_event_clear(NRF_RADIO, NRF_RADIO_EVENT_DISABLED);
+
+#if CONFIG_FEM
+	fem_txrx_configuration_clear();
+	fem_txrx_stop();
+
+	/* Do not power-down front-end module (FEM) during sweeping. */
+	if (!sweep_processing) {
+		(void)fem_power_down();
+	}
+#endif /* CONFIG_FEM */
+}
+
+static void mltpan_6(nrf_radio_mode_t mode)
+{
+#if defined(NRF54L_SERIES)
+	if (mode == NRF_RADIO_MODE_IEEE802154_250KBIT) {
+		*((volatile uint32_t *)0x5008A810) = 2;
+	}
+#else
+	ARG_UNUSED(mode);
+#endif /* defined(NRF54L_SERIES) */
+}
+
+#if NRF53_ERRATA_117_PRESENT
+static void errata_117(nrf_radio_mode_t mode)
+{
+	if (!nrf53_errata_117()) {
+		return;
+	}
+
+	if ((mode == NRF_RADIO_MODE_NRF_2MBIT) ||
+	    (mode == NRF_RADIO_MODE_BLE_2MBIT) ||
+	    (mode == NRF_RADIO_MODE_IEEE802154_250KBIT)) {
+		*((volatile uint32_t *)0x41008588) = *((volatile uint32_t *)0x01FF0084);
+	} else {
+		*((volatile uint32_t *)0x41008588) = *((volatile uint32_t *)0x01FF0080);
+	}
+}
+#else
+static void errata_117(nrf_radio_mode_t mode)
+{
+	ARG_UNUSED(mode);
+}
+#endif /* NRF53_ERRATA_117_PRESENT */
+
+static void radio_mode_set(NRF_RADIO_Type *reg, nrf_radio_mode_t mode)
+{
+	errata_117(mode);
+	nrf_radio_mode_set(reg, mode);
+	mltpan_6(mode);
+}
+
+static void radio_unmodulated_tx_carrier(uint8_t mode, int8_t txpower, uint8_t channel)
+{
+	radio_disable();
+
+	radio_mode_set(NRF_RADIO, mode);
+	nrf_radio_shorts_enable(NRF_RADIO, NRF_RADIO_SHORT_READY_START_MASK);
+	radio_power_set(mode, channel, txpower);
+
+	radio_channel_set(mode, channel);
+
+#if CONFIG_FEM
+	(void)fem_configure(false, mode, &fem);
+#else
+	if (sweep_processing) {
+		radio_ppi_config(false);
+	}
+#endif /* CONFIG_FEM */
+
+	radio_start(false, sweep_processing);
+}
+
+static void radio_modulated_tx_carrier(uint8_t mode, int8_t txpower, uint8_t channel,
+				       enum transmit_pattern pattern, uint32_t packets_num)
+{
+	radio_disable();
+	generate_modulated_rf_packet(mode, pattern);
+
+	switch (mode) {
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154 || CONFIG_HAS_HW_NRF_RADIO_BLE_CODED
+	case NRF_RADIO_MODE_IEEE802154_250KBIT:
+	case NRF_RADIO_MODE_BLE_LR125KBIT:
+	case NRF_RADIO_MODE_BLE_LR500KBIT:
+		nrf_radio_shorts_enable(NRF_RADIO,
+					NRF_RADIO_SHORT_READY_START_MASK |
+					NRF_RADIO_SHORT_PHYEND_START_MASK);
+		break;
+
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 || CONFIG_HAS_HW_NRF_RADIO_BLE_CODED */
+
+	case NRF_RADIO_MODE_BLE_1MBIT:
+	case NRF_RADIO_MODE_BLE_2MBIT:
+	case NRF_RADIO_MODE_NRF_1MBIT:
+	case NRF_RADIO_MODE_NRF_2MBIT:
+	default:
+#if defined(RADIO_MODE_MODE_Nrf_250Kbit)
+	case NRF_RADIO_MODE_NRF_250KBIT:
+#endif /* defined(RADIO_MODE_MODE_Nrf_250Kbit) */
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_5)
+	case NRF_RADIO_MODE_NRF_4MBIT_H_0_5:
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_5) */
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit0_25)
+	case NRF_RADIO_MODE_NRF_4MBIT_H_0_25:
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit0_25) */
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6)
+	case NRF_RADIO_MODE_NRF_4MBIT_BT_0_6:
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT6) */
+#if defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4)
+	case NRF_RADIO_MODE_NRF_4MBIT_BT_0_4:
+#endif /* defined(RADIO_MODE_MODE_Nrf_4Mbit_0BT4) */
+		nrf_radio_shorts_enable(NRF_RADIO,
+					NRF_RADIO_SHORT_READY_START_MASK |
+					RADIO_TEST_SHORT_END_START_MASK);
+		break;
+	}
+
+	radio_mode_set(NRF_RADIO, mode);
+	radio_power_set(mode, channel, txpower);
+
+	radio_channel_set(mode, channel);
+
+	tx_packet_cnt = 0;
+
+	nrf_radio_event_clear(NRF_RADIO, NRF_RADIO_EVENT_END);
+	if (packets_num != 0U) {
+		nrf_radio_int_enable(NRF_RADIO, NRF_RADIO_INT_END_MASK);
+	}
+
+#if CONFIG_FEM
+	(void)fem_configure(false, mode, &fem);
+#endif /* CONFIG_FEM */
+
+	radio_start(false, false);
+}
+
+static void radio_rx(uint8_t mode, uint8_t channel, enum transmit_pattern pattern,
+		     uint32_t rx_packet_num)
+{
+	radio_disable();
+
+	radio_mode_set(NRF_RADIO, mode);
+
+	nrf_radio_shorts_enable(NRF_RADIO,
+				NRF_RADIO_SHORT_READY_START_MASK |
+				NRF_RADIO_SHORT_END_START_MASK);
+	nrf_radio_packetptr_set(NRF_RADIO, rx_packet);
+
+	radio_config(mode, pattern);
+	radio_channel_set(mode, channel);
+
+	rx_packet_cnt = 0;
+
+	nrf_radio_int_enable(NRF_RADIO, NRF_RADIO_INT_CRCOK_MASK);
+
+#if CONFIG_FEM
+	(void)fem_configure(true, mode, &fem);
+#else
+	if (sweep_processing) {
+		radio_ppi_config(true);
+	}
+#endif /* CONFIG_FEM */
+
+	radio_start(true, sweep_processing);
+
+	if (rx_packet_num > 0) {
+		k_work_reschedule(&rx_timeout_work, K_SECONDS(CONFIG_RADIO_TEST_SD_RX_TIMEOUT));
+	}
+}
+
+static void radio_sweep_start(uint8_t channel, uint32_t delay_ms)
+{
+	current_channel = channel;
+
+#if CONFIG_FEM
+	(void)fem_power_up();
+
+	if ((!IS_ENABLED(CONFIG_RADIO_TEST_SD_POWER_CONTROL_AUTOMATIC)) &&
+	    fem.tx_power_control != FEM_USE_DEFAULT_TX_POWER_CONTROL) {
+		(void)fem_tx_power_control_set(fem.tx_power_control);
+	}
+#endif /* CONFIG_FEM */
+
+	nrfx_timer_disable(&timer);
+	nrf_timer_shorts_disable(timer.p_reg, ~0);
+	nrf_timer_int_disable(timer.p_reg, ~0);
+
+	nrfx_timer_extended_compare(&timer,
+		NRF_TIMER_CC_CHANNEL0,
+		nrfx_timer_ms_to_ticks(&timer, delay_ms),
+		(NRF_TIMER_SHORT_COMPARE0_CLEAR_MASK |
+		NRF_TIMER_SHORT_COMPARE0_STOP_MASK),
+		true);
+
+	nrfx_timer_enable(&timer);
+}
+
+static void radio_modulated_tx_carrier_duty_cycle(uint8_t mode, int8_t txpower,
+						  uint8_t channel,
+						  enum transmit_pattern pattern,
+						  uint32_t duty_cycle)
+{
+	/* Lookup table with time per byte in each radio MODE
+	 * Mapped per NRF_RADIO->MODE available on nRF5-series devices
+	 */
+	static const uint8_t time_in_us_per_byte[16] = {
+		8, 4, 32, 8, 4, 64, 16, 0, 0, 2, 2, 0, 0, 0, 0, 32
+	};
+
+	radio_disable();
+	generate_modulated_rf_packet(mode, pattern);
+
+	radio_mode_set(NRF_RADIO, mode);
+	nrf_radio_shorts_enable(NRF_RADIO,
+				NRF_RADIO_SHORT_READY_START_MASK |
+				RADIO_TEST_SHORT_END_DISABLE_MASK);
+	radio_power_set(mode, channel, txpower);
+	radio_channel_set(mode, channel);
+
+	const uint32_t total_time_per_payload = time_in_us_per_byte[mode] * total_payload_size;
+
+	/* Duty cycle = 100 * Time_on / (time_on + time_off),
+	 * we need to calculate "time_off" for delay.
+	 * In addition, the timer includes the "total_time_per_payload",
+	 * so we need to add this to the total timer cycle.
+	 */
+	uint32_t delay_time = total_time_per_payload +
+			   ((100 * total_time_per_payload - (total_time_per_payload * duty_cycle)) /
+			   duty_cycle);
+
+	/* We let the TIMER start the radio transmission again. */
+	nrfx_timer_disable(&timer);
+
+#if CONFIG_FEM
+	(void)fem_configure(false, mode, &fem);
+#else
+	radio_ppi_config(false);
+#endif /* CONFIG_FEM */
+
+	nrf_timer_shorts_disable(timer.p_reg, ~0);
+	nrf_timer_int_disable(timer.p_reg, ~0);
+
+	nrfx_timer_extended_compare(&timer,
+		NRF_TIMER_CC_CHANNEL1,
+		nrfx_timer_us_to_ticks(&timer, delay_time),
+		NRF_TIMER_SHORT_COMPARE1_CLEAR_MASK,
+		false);
+
+	unsigned int key = irq_lock();
+
+	radio_start(false, true);
+
+	radio_ppi_tx_reconfigure();
+	irq_unlock(key);
+}
+
+void radio_test_start(const struct radio_test_config *config)
+{
+#if CONFIG_FEM
+	fem = config->fem;
+#endif /* CONFIG_FEM */
+
+	switch (config->type) {
+	case UNMODULATED_TX:
+		radio_unmodulated_tx_carrier(config->mode,
+			config->params.unmodulated_tx.txpower,
+			config->params.unmodulated_tx.channel);
+		break;
+	case MODULATED_TX:
+		radio_modulated_tx_carrier(config->mode,
+			config->params.modulated_tx.txpower,
+			config->params.modulated_tx.channel,
+			config->params.modulated_tx.pattern,
+			config->params.modulated_tx.packets_num);
+		break;
+	case RX:
+		radio_rx(config->mode,
+			config->params.rx.channel,
+			config->params.rx.pattern,
+			config->params.rx.packets_num);
+		break;
+	case TX_SWEEP:
+		radio_sweep_start(config->params.tx_sweep.channel_start,
+			config->params.tx_sweep.delay_ms);
+		break;
+	case RX_SWEEP:
+		radio_sweep_start(config->params.rx_sweep.channel_start,
+			config->params.rx_sweep.delay_ms);
+		break;
+	case MODULATED_TX_DUTY_CYCLE:
+		radio_modulated_tx_carrier_duty_cycle(config->mode,
+			config->params.modulated_tx_duty_cycle.txpower,
+			config->params.modulated_tx_duty_cycle.channel,
+			config->params.modulated_tx_duty_cycle.pattern,
+			config->params.modulated_tx_duty_cycle.duty_cycle);
+		break;
+	}
+}
+
+void radio_test_cancel(void)
+{
+	nrfx_timer_disable(&timer);
+	nrfx_timer_clear(&timer);
+
+	sweep_processing = false;
+
+	if (nrfx_gppi_channel_check(ppi_radio_start)) {
+		nrfx_gppi_channels_disable(BIT(ppi_radio_start));
+	}
+
+	endpoints_clear();
+	radio_disable();
+}
+
+void radio_rx_stats_get(struct radio_rx_stats *rx_stats)
+{
+	size_t size;
+
+#if CONFIG_HAS_HW_NRF_RADIO_IEEE802154
+	nrf_radio_mode_t radio_mode;
+
+	radio_mode = nrf_radio_mode_get(NRF_RADIO);
+	if (radio_mode == NRF_RADIO_MODE_IEEE802154_250KBIT) {
+		size = IEEE_MAX_PAYLOAD_LEN;
+	} else {
+		size = sizeof(rx_packet);
+	}
+#else
+	size = sizeof(rx_packet);
+#endif /* CONFIG_HAS_HW_NRF_RADIO_IEEE802154 */
+
+	rx_stats->last_packet.buf = rx_packet;
+	rx_stats->last_packet.len = size;
+	rx_stats->packet_cnt = rx_packet_cnt;
+}
+
+#if NRF_POWER_HAS_DCDCEN_VDDH || NRF_POWER_HAS_DCDCEN
+void toggle_dcdc_state(uint8_t dcdc_state)
+{
+	bool is_enabled;
+
+#if NRF_POWER_HAS_DCDCEN_VDDH
+	if (dcdc_state == 0) {
+		is_enabled = nrf_power_dcdcen_vddh_get(NRF_POWER);
+		nrf_power_dcdcen_vddh_set(NRF_POWER, !is_enabled);
+		return;
+	}
+#endif /* NRF_POWER_HAS_DCDCEN_VDDH */
+
+#if NRF_POWER_HAS_DCDCEN
+	if (dcdc_state <= 1) {
+		is_enabled = nrf_power_dcdcen_get(NRF_POWER);
+		nrf_power_dcdcen_set(NRF_POWER, !is_enabled);
+		return;
+	}
+#endif /* NRF_POWER_HAS_DCDCEN */
+}
+#endif /* NRF_POWER_HAS_DCDCEN_VDDH || NRF_POWER_HAS_DCDCEN */
+
+static void rx_timeout_work_handler(struct k_work *work)
+{
+	radio_disable();
+	if (rx_timeout_cb != NULL && *rx_timeout_cb != NULL) {
+		(*rx_timeout_cb)();
+	}
+}
+
+static void timer_handler(nrf_timer_event_t event_type, void *context)
+{
+	const struct radio_test_config *config =
+		(const struct radio_test_config *) context;
+
+	if (event_type == NRF_TIMER_EVENT_COMPARE0) {
+		uint8_t channel_start;
+		uint8_t channel_end;
+
+		if (config->type == TX_SWEEP) {
+			sweep_processing = true;
+			radio_unmodulated_tx_carrier(config->mode,
+				config->params.tx_sweep.txpower,
+				current_channel);
+
+			channel_start = config->params.tx_sweep.channel_start;
+			channel_end = config->params.tx_sweep.channel_end;
+		} else if (config->type == RX_SWEEP) {
+			sweep_processing = true;
+			radio_rx(config->mode,
+				current_channel,
+				config->params.rx.pattern,
+				0);
+
+			channel_start = config->params.rx_sweep.channel_start;
+			channel_end = config->params.rx_sweep.channel_end;
+		} else {
+			printk("Unexpected test type: %d\n", config->type);
+			return;
+		}
+
+		sweep_processing = false;
+
+		current_channel++;
+		if (current_channel > channel_end) {
+			current_channel = channel_start;
+		}
+	}
+}
+
+static void timer_init(const struct radio_test_config *config)
+{
+	nrfx_err_t          err;
+	nrfx_timer_config_t timer_cfg = {
+		.frequency = NRFX_MHZ_TO_HZ(1),
+		.mode      = NRF_TIMER_MODE_TIMER,
+		.bit_width = NRF_TIMER_BIT_WIDTH_24,
+		.p_context = (void *) config,
+	};
+
+	err = nrfx_timer_init(&timer, &timer_cfg, timer_handler);
+	if (err != NRFX_SUCCESS) {
+		printk("nrfx_timer_init failed with: %d\n", err);
+	}
+}
+
+void radio_handler(const void *context)
+{
+	const struct radio_test_config *config =
+		(const struct radio_test_config *) context;
+
+	if (nrf_radio_int_enable_check(NRF_RADIO, NRF_RADIO_INT_CRCOK_MASK) &&
+	    nrf_radio_event_check(NRF_RADIO, NRF_RADIO_EVENT_CRCOK)) {
+		nrf_radio_event_clear(NRF_RADIO, NRF_RADIO_EVENT_CRCOK);
+		rx_packet_cnt++;
+		if (config->params.rx.packets_num) {
+			if (rx_packet_cnt == config->params.rx.packets_num) {
+				k_work_reschedule(&rx_timeout_work, K_NO_WAIT);
+			} else {
+				k_work_reschedule(&rx_timeout_work, K_MSEC(RX_PACKET_TIMEOUT_MS));
+			}
+		}
+	}
+
+	if (nrf_radio_int_enable_check(NRF_RADIO, NRF_RADIO_INT_END_MASK) &&
+	    nrf_radio_event_check(NRF_RADIO, NRF_RADIO_EVENT_END)) {
+		nrf_radio_event_clear(NRF_RADIO, NRF_RADIO_EVENT_END);
+
+		tx_packet_cnt++;
+		if (tx_packet_cnt == config->params.modulated_tx.packets_num) {
+			radio_disable();
+			config->params.modulated_tx.cb();
+		}
+	}
+}
+
+int radio_test_init(struct radio_test_config *config)
+{
+	nrfx_err_t nrfx_err;
+
+	timer_init(config);
+	IRQ_CONNECT(RADIO_TEST_TIMER_IRQn, IRQ_PRIO_LOWEST,
+		RADIO_TEST_TIMER_IRQ_HANDLER, NULL, 0);
+
+	irq_connect_dynamic(RADIO_TEST_RADIO_IRQn, IRQ_PRIO_LOWEST, radio_handler, config, 0);
+	irq_enable(RADIO_TEST_RADIO_IRQn);
+
+	nrfx_err = nrfx_gppi_channel_alloc(&ppi_radio_start);
+	if (nrfx_err != NRFX_SUCCESS) {
+		printk("Failed to allocate gppi channel.\n");
+		return -EFAULT;
+	}
+
+	rx_timeout_cb = &config->params.rx.cb;
+
+#if CONFIG_FEM
+	int err = fem_init(timer.p_reg,
+			   (BIT(NRF_TIMER_CC_CHANNEL2) | BIT(NRF_TIMER_CC_CHANNEL3)));
+
+	if (err) {
+		return err;
+	}
+#endif /* CONFIG_FEM */
+
+	return 0;
+}
diff --git a/samples/wifi/radio_test/single_domain/src/radio_test.h b/samples/wifi/radio_test/single_domain/src/radio_test.h
new file mode 100644
index 000000000000..0c562aff6cdf
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/src/radio_test.h
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2020 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#ifndef RADIO_TEST_H_
+#define RADIO_TEST_H_
+
+#include <zephyr/types.h>
+#include <hal/nrf_radio.h>
+#include <fem_al/fem_al.h>
+
+#ifdef NRF53_SERIES
+#ifndef RADIO_TXPOWER_TXPOWER_Pos3dBm
+	#define RADIO_TXPOWER_TXPOWER_Pos3dBm (0x03UL)
+#endif /* RADIO_TXPOWER_TXPOWER_Pos3dBm */
+
+#ifndef RADIO_TXPOWER_TXPOWER_Pos2dBm
+	#define RADIO_TXPOWER_TXPOWER_Pos2dBm (0x02UL)
+#endif /* RADIO_TXPOWER_TXPOWER_Pos2dBm */
+
+#ifndef RADIO_TXPOWER_TXPOWER_Pos1dBm
+	#define RADIO_TXPOWER_TXPOWER_Pos1dBm (0x01UL)
+#endif /* RADIO_TXPOWER_TXPOWER_Pos1dBm */
+#endif /* NRF53_SERIES */
+
+/** Maximum radio RX or TX payload. */
+#define RADIO_MAX_PAYLOAD_LEN	256
+/** IEEE 802.15.4 maximum payload length. */
+#define IEEE_MAX_PAYLOAD_LEN	127
+/** IEEE 802.15.4 minimum channel. */
+#define IEEE_MIN_CHANNEL	11
+/** IEEE 802.15.4 maximum channel. */
+#define IEEE_MAX_CHANNEL	26
+
+#define FEM_USE_DEFAULT_TX_POWER_CONTROL 0xFF
+
+/**@brief Radio transmit and address pattern. */
+enum transmit_pattern {
+	/** Random pattern. */
+	TRANSMIT_PATTERN_RANDOM,
+
+	/** Pattern 11110000(F0). */
+	TRANSMIT_PATTERN_11110000,
+
+	/** Pattern 11001100(CC). */
+	TRANSMIT_PATTERN_11001100,
+};
+
+/**@brief Radio test mode. */
+enum radio_test_mode {
+	/** TX carrier. */
+	UNMODULATED_TX,
+
+	/** Modulated TX carrier. */
+	MODULATED_TX,
+
+	/** RX carrier. */
+	RX,
+
+	/** TX carrier sweep. */
+	TX_SWEEP,
+
+	/** RX carrier sweep. */
+	RX_SWEEP,
+
+	/** Duty-cycled modulated TX carrier. */
+	MODULATED_TX_DUTY_CYCLE,
+};
+
+/**@brief Radio test front-end module (FEM) configuration */
+struct radio_test_fem {
+	/* Front-end module radio ramp-up time in microseconds. */
+	uint32_t ramp_up_time;
+
+	/* Front-end module TX power control specific to given front-end module.
+	 * For nRF21540 GPIO/SPI, this is a register value.
+	 * For nRF21540 GPIO, this is MODE pin value.
+	 */
+	fem_tx_power_control tx_power_control;
+};
+
+/**@brief Radio test configuration. */
+struct radio_test_config {
+	/** Radio test type. */
+	enum radio_test_mode type;
+
+	/** Radio mode. Data rate and modulation. */
+	nrf_radio_mode_t mode;
+
+	union {
+		struct {
+			/** Radio output power. */
+			int8_t txpower;
+
+			/** Radio channel. */
+			uint8_t channel;
+		} unmodulated_tx;
+
+		struct {
+			/** Radio output power. */
+			int8_t txpower;
+
+			/** Radio transmission pattern. */
+			enum transmit_pattern pattern;
+
+			/** Radio channel. */
+			uint8_t channel;
+
+			/**
+			 * Number of packets to transmit.
+			 * Set to zero for continuous TX.
+			 */
+			uint32_t packets_num;
+
+			/** Callback to indicate that TX is finished. */
+			void (*cb)(void);
+		} modulated_tx;
+
+		struct {
+			/** Radio transmission pattern. */
+			enum transmit_pattern pattern;
+
+			/** Radio channel. */
+			uint8_t channel;
+
+			/**
+			 * Number of packets to be received.
+			 * Set to zero for continuous RX.
+			 */
+			uint32_t packets_num;
+
+			/** Callback to indicate that RX is finished. */
+			void (*cb)(void);
+		} rx;
+
+		struct {
+			/** Radio output power. */
+			int8_t txpower;
+
+			/** Radio start channel (frequency). */
+			uint8_t channel_start;
+
+			/** Radio end channel (frequency). */
+			uint8_t channel_end;
+
+			/** Delay time in milliseconds. */
+			uint32_t delay_ms;
+		} tx_sweep;
+
+		struct {
+			/** Radio start channel (frequency). */
+			uint8_t channel_start;
+
+			/** Radio end channel (frequency). */
+			uint8_t channel_end;
+
+			/** Delay time in milliseconds. */
+			uint32_t delay_ms;
+		} rx_sweep;
+
+		struct {
+			/** Radio output power. */
+			int8_t txpower;
+
+			/** Radio transmission pattern. */
+			enum transmit_pattern pattern;
+
+			/** Radio channel. */
+			uint8_t channel;
+
+			/** Duty cycle. */
+			uint32_t duty_cycle;
+		} modulated_tx_duty_cycle;
+	} params;
+
+#if CONFIG_FEM
+	/* Front-end module (FEM) configuration. */
+	struct radio_test_fem fem;
+#endif /* CONFIG_FEM */
+};
+
+/**@brief Radio RX statistics. */
+struct radio_rx_stats {
+	/** Content of the last packet. */
+	struct {
+		/** Content of the last packet. */
+		uint8_t *buf;
+
+		/** Length of the last packet. */
+		size_t len;
+	} last_packet;
+
+	/** Number of received packets with valid CRC. */
+	uint32_t packet_cnt;
+};
+
+/**
+ * @brief Function for initializing the Radio Test module.
+ *
+ * @param[in] config  Radio test configuration.
+ *
+ * @retval 0 If the operation was successful.
+ *           Otherwise, a (negative) error code is returned.
+ */
+int radio_test_init(struct radio_test_config *config);
+
+/**
+ * @brief Function for starting radio test.
+ *
+ * @param[in] config  Radio test configuration.
+ */
+void radio_test_start(const struct radio_test_config *config);
+
+/**
+ * @brief Function for stopping ongoing test (Radio and Timer operations).
+ */
+void radio_test_cancel(void);
+
+/**
+ * @brief Function for get RX statistics.
+ *
+ * @param[out] rx_stats RX statistics.
+ */
+void radio_rx_stats_get(struct radio_rx_stats *rx_stats);
+
+/**
+ * @brief Function for toggling the DC/DC converter state.
+ *
+ * @param[in] dcdc_state  DC/DC converter state.
+ */
+void toggle_dcdc_state(uint8_t dcdc_state);
+
+#endif /* RADIO_TEST_H_ */
diff --git a/samples/wifi/radio_test/single_domain/sysbuild.conf b/samples/wifi/radio_test/single_domain/sysbuild.conf
new file mode 100644
index 000000000000..a5af2663d0db
--- /dev/null
+++ b/samples/wifi/radio_test/single_domain/sysbuild.conf
@@ -0,0 +1,8 @@
+#
+# Copyright (c) 2024 Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+#
+
+SB_CONFIG_WIFI_NRF70=y
+SB_CONFIG_WIFI_NRF70_RADIO_TEST=y