nfc: separate TNEP signalling functionality for NFC tag

The NFC TNEP signalling functionality in the nRF Connect SDK
is based on Zephyr kernel primitives.  In the Bare Metal the Zephyr
primitives are not available. The Bare Metal will need a separate
implementation based on Bare Metal primitives. To allow that the
TNEP signalling is extracted from the subsys/nfc/tnep/tag.c into
separate files.

The include/nfc/tnep/tag_signalling.h is the header that defines
the signalling API that is used by subsys/nfc/tnep/tag.c
implementation.

The subsys/nfc/tnep/tag.c is now signalling-agnostic and uses the
signalling API defined in include/nfc/tnep/tag_signalling.h.

The subsys/nfc/tnep/tag_signalling_zephyr.c contains the Zephyr-based
implementation of the signalling API and the Zephyr-specific
initialization function. For other non Zephyr-based platforms
separate signalling implementation files may be created.

Because the way of handling signalling is platform-specific,
the `nfc_tnep_tag_init()` API is changed to not require
`struct k_poll_event *events, uint8_t event_cnt` parameters.
Instead, the platform-specific signalling initialization must be called
before calling `nfc_tnep_tag_init()`. The Zephyr-based signalling
initialization function is named `nfc_tnep_tag_signalling_init()`,
its prototype is declared in include/nfc/tnep/tag_signalling_zephyr.h,
and it is implemented in subsys/nfc/tnep/tag_signalling_zephyr.c.

To allow selection of applicable signalling implementation the
Kconfig choice `NFC_TNEP_TAG_SIGNALLING` is added. In the
nRF Connect SDK it has only one choice:
`NFC_TNEP_TAG_SIGNALLING_ZEPHYR`. The Bare Metal will extend the
choice and provide separate signalling implementation.

The applications based on nRF Connect SDK using the NFC TNEP tag
functionality must be updated in the following way:
- include the signalling header
  `#include <nfc/tnep/tag_signalling_zephyr.h>`
- call the signalling initialization function
  `nfc_tnep_tag_signalling_init()` before calling `nfc_tnep_tag_init()`
  The `events` and `event_cnt` parameters that were previously passed
  to `nfc_tnep_tag_init()` now are to be passed to
  `nfc_tnep_tag_signalling_init` function.

Signed-off-by: Andrzej Kuros <[email protected]>

Author: ankuns

include/nfc/tnep/tag.h

@@ -17,9 +17,6 @@
 #include <nfc/tnep/base.h>
 #include <zephyr/kernel.h>
 
-/** NFC TNEP library event count. */
-#define NFC_TNEP_EVENTS_NUMBER 2
-
 /** Maximum Service Waiting Time. */
 #define NFC_TNEP_TAG_MAX_WAIT_TIME 63
 
@@ -188,8 +185,8 @@ int nfc_tnep_tag_tx_msg_buffer_register(uint8_t *tx_buff,
 /**
  * @brief Start communication using TNEP.
  *
- * @param[out] events TNEP Tag Events.
- * @param[in] event_cnt Event count. This library needs 2 events.
+ * @note This function must be called after @ref nfc_tnep_tag_signalling_init.
+ *
  * @param[in] payload_set Function for setting NDEF data for NFC TNEP
  *                        Tag Device. This library use it internally
  *                        to set raw NDEF message to the Tag NDEF file.
@@ -199,8 +196,7 @@ int nfc_tnep_tag_tx_msg_buffer_register(uint8_t *tx_buff,
  * @retval 0 If the operation was successful.
  *           Otherwise, a (negative) error code is returned.
  */
-int nfc_tnep_tag_init(struct k_poll_event *events, uint8_t event_cnt,
-		      nfc_payload_set_t payload_set);
+int nfc_tnep_tag_init(nfc_payload_set_t payload_set);
 
 /**
  * @brief Create the Initial TNEP NDEF message.

include/nfc/tnep/tag_signalling.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#ifndef NFC_TNEP_TAG_SIGNALLING_H_
+#define NFC_TNEP_TAG_SIGNALLING_H_
+
+#include <stdbool.h>
+
+enum tnep_event {
+	TNEP_EVENT_DUMMY,
+	TNEP_EVENT_MSG_RX_NEW,
+	TNEP_EVENT_TAG_SELECTED,
+};
+
+/** @brief Raises a receive event.
+ *
+ * @param event Event to be raised.
+ */
+void nfc_tnep_tag_signalling_rx_event_raise(enum tnep_event event);
+
+/** @brief Raises a transmit event.
+ *
+ * @param event Event to be raised.
+ */
+void nfc_tnep_tag_signalling_tx_event_raise(enum tnep_event event);
+
+/** @brief Checks and clears receive event.
+ *
+ * @param event Pointer to store the raised event.
+ *              The value is valid only if the function returns @c true.
+ *
+ * @retval true  if a receive event was raised.
+ * @retval false if no receive event was raised.
+ */
+bool nfc_tnep_tag_signalling_rx_event_check_and_clear(enum tnep_event *event);
+
+/** @brief Checks and clears transmit event.
+ *
+ * @param event Pointer to store the raised event.
+ *              The value is valid only if the function returns @c true.
+ *
+ * @retval true  if a transmit event was raised.
+ * @retval false if no transmit event was raised.
+ */
+bool nfc_tnep_tag_signalling_tx_event_check_and_clear(enum tnep_event *event);
+
+#endif /* NFC_TNEP_TAG_SIGNALLING_H_ */

include/nfc/tnep/tag_signalling_zephyr.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#ifndef NFC_TNEP_TAG_SIGNALLING_ZEPHYR_H_
+#define NFC_TNEP_TAG_SIGNALLING_ZEPHYR_H_
+
+#include <stdint.h>
+#include <zephyr/kernel.h>
+
+/** NFC TNEP library event count. */
+#define NFC_TNEP_EVENTS_NUMBER 2
+
+/** @brief Initializes TNEP signalling using Zephyr primitives.
+ *
+ * @param[out] events     Pointer to array of k_poll_event structures.
+ * @param[in]  event_cnt  Number of events in the array.
+ *                        Must be @ref NFC_TNEP_EVENTS_NUMBER.
+ *
+ * @retval 0 If the operation was successful.
+ *           Otherwise, an (negative) error code is returned.
+ */
+int nfc_tnep_tag_signalling_init(struct k_poll_event *events, uint8_t event_cnt);
+
+#endif /* NFC_TNEP_TAG_SIGNALLING_ZEPHYR_H_ */

subsys/nfc/tnep/CMakeLists.txt

@@ -6,6 +6,7 @@
 
 zephyr_library()
 zephyr_library_sources_ifdef(CONFIG_NFC_TNEP_TAG tag.c)
+zephyr_library_sources_ifdef(CONFIG_NFC_TNEP_TAG_SIGNALLING_ZEPHYR tag_signalling_zephyr.c)
 zephyr_library_sources_ifdef(CONFIG_NFC_TNEP_POLLER poller.c)
 
 add_subdirectory_ifdef(CONFIG_NFC_TNEP_CH ch)

subsys/nfc/tnep/Kconfig

@@ -28,6 +28,15 @@ config NFC_TNEP_RX_MAX_RECORD_SIZE
 	help
 	  Set the maximum size of received NDEF Record
 
+choice NFC_TNEP_TAG_SIGNALLING
+	prompt "NFC TNEP Tag signalling method"
+
+config NFC_TNEP_TAG_SIGNALLING_ZEPHYR
+	bool "NFC TNEP Tag signalling using Zephyr primitives"
+	select POLL
+
+endchoice
+
 module = NFC_TNEP_TAG
 module-str = TNEP_TAG
 source "$(ZEPHYR_BASE)/subsys/logging/Kconfig.template.log_config"

subsys/nfc/tnep/tag.c

@@ -7,22 +7,14 @@
 #include <stdbool.h>
 #include <zephyr/kernel.h>
 #include <nfc/tnep/tag.h>
+#include <nfc/tnep/tag_signalling.h>
 #include <nfc/ndef/msg.h>
 #include <nfc/t4t/ndef_file.h>
 #include <nfc/ndef/msg_parser.h>
 #include <zephyr/logging/log.h>
 
 LOG_MODULE_REGISTER(nfc_tnep_tag, CONFIG_NFC_TNEP_TAG_LOG_LEVEL);
 
-#define TNEP_EVENT_RX_IDX 0
-#define TNEP_EVENT_TX_IDX 1
-
-enum tnep_event {
-	TNEP_EVENT_DUMMY,
-	TNEP_EVENT_MSG_RX_NEW,
-	TNEP_EVENT_TAG_SELECTED,
-};
-
 enum tnep_state_name {
 	TNEP_STATE_DISABLED,
 	TNEP_STATE_SERVICE_READY,
@@ -53,12 +45,6 @@ struct tnep_rx_buffer {
 	size_t len;
 };
 
-struct tnep_control {
-	struct k_poll_event *events;
-	struct k_poll_signal msg_rx;
-	struct k_poll_signal msg_tx;
-};
-
 struct tnep_tag {
 	struct nfc_ndef_msg_desc *msg;
 	struct tnep_buffer tx;
@@ -72,7 +58,6 @@ struct tnep_tag {
 	uint8_t *current_buff;
 };
 
-static struct tnep_control tnep_ctrl;
 static struct tnep_tag tnep;
 
 struct tnep_state {
@@ -501,11 +486,10 @@ void nfc_tnep_tag_rx_msg_indicate(const uint8_t *rx_buffer, size_t len)
 	tnep.rx.len = len;
 	tnep.rx.data = rx_buffer;
 
-	k_poll_signal_raise(&tnep_ctrl.msg_rx, TNEP_EVENT_MSG_RX_NEW);
+	nfc_tnep_tag_signalling_rx_event_raise(TNEP_EVENT_MSG_RX_NEW);
 }
 
-int nfc_tnep_tag_init(struct k_poll_event *events, uint8_t event_cnt,
-		      nfc_payload_set_t payload_set)
+int nfc_tnep_tag_init(nfc_payload_set_t payload_set)
 {
 	extern struct nfc_tnep_tag_service
 			_nfc_tnep_tag_service_list_start[];
@@ -514,21 +498,11 @@ int nfc_tnep_tag_init(struct k_poll_event *events, uint8_t event_cnt,
 
 	LOG_DBG("TNEP initialization");
 
-	if (!events) {
-		return -EINVAL;
-	}
-
 	if (!payload_set) {
 		LOG_ERR("No function for NFC payload set provided");
 		return -EINVAL;
 	}
 
-	if (event_cnt != NFC_TNEP_EVENTS_NUMBER) {
-		LOG_ERR("Invalid k_pool events count. Got %d events, required %d",
-			event_cnt, NFC_TNEP_EVENTS_NUMBER);
-		return -EINVAL;
-	}
-
 	if (!atomic_cas(&current_state, TNEP_STATE_DISABLED,
 			TNEP_STATE_DISABLED)) {
 		LOG_ERR("TNEP already running");
@@ -541,25 +515,11 @@ int nfc_tnep_tag_init(struct k_poll_event *events, uint8_t event_cnt,
 		return -EIO;
 	}
 
-	tnep_ctrl.events = events;
 	tnep.current_buff = tnep.tx.data;
 	tnep.data_set = payload_set;
 	tnep.svc_cnt = _nfc_tnep_tag_service_list_end -
 		       _nfc_tnep_tag_service_list_start;
 
-	LOG_DBG("k_pool signals initialization");
-
-	k_poll_signal_init(&tnep_ctrl.msg_rx);
-	k_poll_signal_init(&tnep_ctrl.msg_tx);
-
-	k_poll_event_init(&tnep_ctrl.events[TNEP_EVENT_RX_IDX],
-			  K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY,
-			  &tnep_ctrl.msg_rx);
-
-	k_poll_event_init(&tnep_ctrl.events[TNEP_EVENT_TX_IDX],
-			  K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY,
-			  &tnep_ctrl.msg_tx);
-
 	return 0;
 }
 
@@ -635,19 +595,16 @@ int nfc_tnep_initial_msg_encode(struct nfc_ndef_msg_desc *msg,
 
 void nfc_tnep_tag_process(void)
 {
-	/* Check for signals */
-	for (size_t i = 0; i < NFC_TNEP_EVENTS_NUMBER; i++) {
-		if (tnep_ctrl.events[i].state == K_POLL_STATE_SIGNALED) {
-			enum tnep_event event;
-
-			event = tnep_ctrl.events[i].signal->result;
+	enum tnep_event event = TNEP_EVENT_DUMMY;
 
-			k_poll_signal_reset(tnep_ctrl.events[i].signal);
-			tnep_ctrl.events[i].state = K_POLL_STATE_NOT_READY;
+	if (nfc_tnep_tag_signalling_rx_event_check_and_clear(&event)) {
+		/* Run TNEP State Machine - prepare response */
+		tnep_state_machine[atomic_get(&current_state)].process(event);
+	}
 
-			/* Run TNEP State Machine - prepare response */
-			tnep_state_machine[atomic_get(&current_state)].process(event);
-		}
+	if (nfc_tnep_tag_signalling_tx_event_check_and_clear(&event)) {
+		/* Run TNEP State Machine - prepare response */
+		tnep_state_machine[atomic_get(&current_state)].process(event);
 	}
 }
 
@@ -707,7 +664,7 @@ int nfc_tnep_tag_tx_msg_no_app_data(void)
 
 void nfc_tnep_tag_on_selected(void)
 {
-	k_poll_signal_raise(&tnep_ctrl.msg_tx, TNEP_EVENT_TAG_SELECTED);
+	nfc_tnep_tag_signalling_tx_event_raise(TNEP_EVENT_TAG_SELECTED);
 }
 
 size_t nfc_tnep_tag_svc_count_get(void)

subsys/nfc/tnep/tag_signalling_zephyr.c

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2026 Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/logging/log.h>
+#include <nfc/tnep/tag_signalling.h>
+#include <nfc/tnep/tag_signalling_zephyr.h>
+
+LOG_MODULE_DECLARE(nfc_tnep_tag, CONFIG_NFC_TNEP_TAG_LOG_LEVEL);
+
+#define TNEP_EVENT_RX_IDX 0
+#define TNEP_EVENT_TX_IDX 1
+
+struct tnep_control {
+	struct k_poll_event *events;
+	struct k_poll_signal msg_rx;
+	struct k_poll_signal msg_tx;
+};
+
+static struct tnep_control tnep_ctrl;
+
+int nfc_tnep_tag_signalling_init(struct k_poll_event *events, uint8_t event_cnt)
+{
+	if (!events) {
+		return -EINVAL;
+	}
+
+	if (event_cnt != NFC_TNEP_EVENTS_NUMBER) {
+		LOG_ERR("Invalid k_pool events count. Got %d events, required %d",
+			event_cnt, NFC_TNEP_EVENTS_NUMBER);
+		return -EINVAL;
+	}
+
+	tnep_ctrl.events = events;
+
+	k_poll_signal_init(&tnep_ctrl.msg_rx);
+	k_poll_signal_init(&tnep_ctrl.msg_tx);
+
+	k_poll_event_init(&tnep_ctrl.events[TNEP_EVENT_RX_IDX],
+			  K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY,
+			  &tnep_ctrl.msg_rx);
+
+	k_poll_event_init(&tnep_ctrl.events[TNEP_EVENT_TX_IDX],
+			  K_POLL_TYPE_SIGNAL, K_POLL_MODE_NOTIFY_ONLY,
+			  &tnep_ctrl.msg_tx);
+
+	return 0;
+}
+
+void nfc_tnep_tag_signalling_rx_event_raise(enum tnep_event event)
+{
+	k_poll_signal_raise(&tnep_ctrl.msg_rx, event);
+}
+
+void nfc_tnep_tag_signalling_tx_event_raise(enum tnep_event event)
+{
+	k_poll_signal_raise(&tnep_ctrl.msg_tx, event);
+}
+
+static bool event_check_and_clear(int event_idx, enum tnep_event *event)
+{
+	if (tnep_ctrl.events[event_idx].state == K_POLL_STATE_SIGNALED) {
+		*event = tnep_ctrl.events[event_idx].signal->result;
+
+		k_poll_signal_reset(tnep_ctrl.events[event_idx].signal);
+		tnep_ctrl.events[event_idx].state = K_POLL_STATE_NOT_READY;
+
+		return true;
+	}
+
+	return false;
+}
+
+bool nfc_tnep_tag_signalling_rx_event_check_and_clear(enum tnep_event *event)
+{
+	return event_check_and_clear(TNEP_EVENT_RX_IDX, event);
+}
+
+bool nfc_tnep_tag_signalling_tx_event_check_and_clear(enum tnep_event *event)
+{
+	return event_check_and_clear(TNEP_EVENT_TX_IDX, event);
+}