modules: openthread: radio: encapsulate OT 32-bit timestamp

OT does not have 64 bit timestamp support. This is a limitation of OT
and not of the IEEE 802.15.4 driver API. Therefore any workaround
related to such OT idiosyncracies should be encapsulated inside the OT
adapatation layer.

This change moves the OT-specific conversion of OT 32 bit timestamps to
Zephyr 64 bit timestamps into the OT adaptation layer.

Signed-off-by: Florian Grandel <[email protected]>

Author: fg-cfh

drivers/ieee802154/ieee802154_nrf5.c

@@ -484,77 +484,6 @@ static bool nrf5_tx_csma_ca(struct net_pkt *pkt, uint8_t *payload)
 #endif
 
 #if defined(CONFIG_NET_PKT_TXTIME)
-/**
- * @brief Convert 32-bit target time to absolute 64-bit target time.
- *
- * @param target_time_ns_wrapped time in nanoseconds referred to the radio clock
- * modulo (UINT32_MAX * NSEC_PER_USEC).
- */
-static uint64_t target_time_convert_to_64_bits(uint64_t target_time_ns_wrapped)
-{
-	/**
-	 * Target time is provided as two 32-bit integers defining a moment in time
-	 * in microsecond domain. In order to use bit-shifting instead of modulo
-	 * division, calculations are performed in microsecond domain, not in RTC ticks.
-	 *
-	 * The target time can point to a moment in the future, but can be overdue
-	 * as well. In order to determine what's the case and correctly set the
-	 * absolute target time, it's necessary to compare the least significant
-	 * 32 bits of the current time, 64-bit time with the provided 32-bit target
-	 * time. Let's assume that half of the 32-bit range can be used for specifying
-	 * target times in the future, and the other half - in the past.
-	 */
-	uint32_t target_time_us_wrapped = target_time_ns_wrapped / NSEC_PER_USEC;
-	uint64_t now_us = nrf_802154_time_get();
-	uint32_t now_us_wrapped = (uint32_t)now_us;
-	uint32_t time_diff = target_time_us_wrapped - now_us_wrapped;
-	uint64_t result = UINT64_C(0);
-
-	if (time_diff < 0x80000000) {
-		/**
-		 * Target time is assumed to be in the future. Check if a 32-bit overflow
-		 * occurs between the current time and the target time.
-		 */
-		if (now_us_wrapped > target_time_us_wrapped) {
-			/**
-			 * Add a 32-bit overflow and replace the least significant 32 bits
-			 * with the provided target time.
-			 */
-			result = now_us + UINT32_MAX + 1;
-			result &= ~(uint64_t)UINT32_MAX;
-			result |= target_time_us_wrapped;
-		} else {
-			/**
-			 * Leave the most significant 32 bits and replace the least significant
-			 * 32 bits with the provided target time.
-			 */
-			result = (now_us & (~(uint64_t)UINT32_MAX)) | target_time_us_wrapped;
-		}
-	} else {
-		/**
-		 * Target time is assumed to be in the past. Check if a 32-bit overflow
-		 * occurs between the target time and the current time.
-		 */
-		if (now_us_wrapped > target_time_us_wrapped) {
-			/**
-			 * Leave the most significant 32 bits and replace the least significant
-			 * 32 bits with the provided target time.
-			 */
-			result = (now_us & (~(uint64_t)UINT32_MAX)) | target_time_us_wrapped;
-		} else {
-			/**
-			 * Subtract a 32-bit overflow and replace the least significant
-			 * 32 bits with the provided target time.
-			 */
-			result = now_us - UINT32_MAX - 1;
-			result &= ~(uint64_t)UINT32_MAX;
-			result |= target_time_us_wrapped;
-		}
-	}
-
-	return result;
-}
-
 static bool nrf5_tx_at(struct nrf5_802154_data *nrf5_radio, struct net_pkt *pkt,
 		   uint8_t *payload, enum ieee802154_tx_mode mode)
 {
@@ -598,7 +527,7 @@ static bool nrf5_tx_at(struct nrf5_802154_data *nrf5_radio, struct net_pkt *pkt,
 		.extra_cca_attempts = max_extra_cca_attempts,
 #endif
 	};
-	uint64_t tx_at = target_time_convert_to_64_bits(net_ptp_time_to_ns(net_pkt_timestamp(pkt)));
+	uint64_t tx_at = net_ptp_time_to_ns(net_pkt_timestamp(pkt)) / NSEC_PER_USEC;
 
 	return nrf_802154_transmit_raw_at(payload, tx_at, &metadata);
 }
@@ -984,13 +913,7 @@ static int nrf5_configure(const struct device *dev,
 
 #if defined(CONFIG_IEEE802154_CSL_ENDPOINT)
 	case IEEE802154_CONFIG_CSL_RX_TIME: {
-		/*
-		 * `target_time_convert_to_64_bits()` is a workaround until OpenThread (the only
-		 * CSL user in Zephyr so far) is able to schedule RX windows using 64-bit time.
-		 */
-		uint64_t csl_rx_time = target_time_convert_to_64_bits(config->csl_rx_time);
-
-		nrf_802154_csl_writer_anchor_time_set(csl_rx_time);
+		nrf_802154_csl_writer_anchor_time_set(config->csl_rx_time / NSEC_PER_USEC);
 	} break;
 
 	case IEEE802154_CONFIG_RX_SLOT: {
@@ -1000,13 +923,9 @@ static int nrf5_configure(const struct device *dev,
 		 * calculated as if the following reception windows were at times
 		 * anchor_time + n * csl_period. The previously set
 		 * anchor_time will be used for calculations.
-		 *
-		 * `target_time_convert_to_64_bits()` is a workaround until OpenThread
-		 *  is able to schedule RX windows using 64-bit time.
 		 */
-		uint64_t start = target_time_convert_to_64_bits(config->rx_slot.start);
-
-		nrf_802154_receive_at(start, config->rx_slot.duration / NSEC_PER_USEC,
+		nrf_802154_receive_at(config->rx_slot.start / NSEC_PER_USEC,
+				      config->rx_slot.duration / NSEC_PER_USEC,
 				      config->rx_slot.channel, DRX_SLOT_RX);
 	} break;
 

modules/openthread/platform/radio.c

@@ -33,6 +33,7 @@ LOG_MODULE_REGISTER(LOG_MODULE_NAME, CONFIG_OPENTHREAD_L2_LOG_LEVEL);
 #include <openthread/instance.h>
 #include <openthread/platform/radio.h>
 #include <openthread/platform/diag.h>
+#include <openthread/platform/time.h>
 #include <openthread/message.h>
 
 #include "platform-zephyr.h"
@@ -237,6 +238,84 @@ void handle_radio_event(const struct device *dev, enum ieee802154_event evt,
 	}
 }
 
+#if defined(CONFIG_NET_PKT_TXTIME) || defined(CONFIG_OPENTHREAD_CSL_RECEIVER)
+/**
+ * @brief Convert 32-bit (potentially wrapped) OpenThread microsecond timestamps
+ * to 64-bit Zephyr network subsystem nanosecond timestamps.
+ *
+ * This is a workaround until OpenThread is able to schedule 64-bit RX/TX time.
+ *
+ * @param target_time_ns_wrapped time in nanoseconds referred to the radio clock
+ * modulo UINT32_MAX.
+ *
+ * @return 64-bit nanosecond timestamp
+ */
+static net_time_t convert_32bit_us_wrapped_to_64bit_ns(uint32_t target_time_us_wrapped)
+{
+	/**
+	 * OpenThread provides target time as a (potentially wrapped) 32-bit
+	 * integer defining a moment in time in the microsecond domain.
+	 *
+	 * The target time can point to a moment in the future, but can be
+	 * overdue as well. In order to determine what's the case and correctly
+	 * set the absolute (non-wrapped) target time, it's necessary to compare
+	 * the least significant 32 bits of the current 64-bit network subsystem
+	 * time with the provided 32-bit target time. Let's assume that half of
+	 * the 32-bit range can be used for specifying target times in the
+	 * future, and the other half - in the past.
+	 */
+	uint64_t now_us = otPlatTimeGet();
+	uint32_t now_us_wrapped = (uint32_t)now_us;
+	uint32_t time_diff = target_time_us_wrapped - now_us_wrapped;
+	uint64_t result = UINT64_C(0);
+
+	if (time_diff < 0x80000000) {
+		/**
+		 * Target time is assumed to be in the future. Check if a 32-bit overflow
+		 * occurs between the current time and the target time.
+		 */
+		if (now_us_wrapped > target_time_us_wrapped) {
+			/**
+			 * Add a 32-bit overflow and replace the least significant 32 bits
+			 * with the provided target time.
+			 */
+			result = now_us + UINT32_MAX + 1;
+			result &= ~(uint64_t)UINT32_MAX;
+			result |= target_time_us_wrapped;
+		} else {
+			/**
+			 * Leave the most significant 32 bits and replace the least significant
+			 * 32 bits with the provided target time.
+			 */
+			result = (now_us & (~(uint64_t)UINT32_MAX)) | target_time_us_wrapped;
+		}
+	} else {
+		/**
+		 * Target time is assumed to be in the past. Check if a 32-bit overflow
+		 * occurs between the target time and the current time.
+		 */
+		if (now_us_wrapped > target_time_us_wrapped) {
+			/**
+			 * Leave the most significant 32 bits and replace the least significant
+			 * 32 bits with the provided target time.
+			 */
+			result = (now_us & (~(uint64_t)UINT32_MAX)) | target_time_us_wrapped;
+		} else {
+			/**
+			 * Subtract a 32-bit overflow and replace the least significant
+			 * 32 bits with the provided target time.
+			 */
+			result = now_us - UINT32_MAX - 1;
+			result &= ~(uint64_t)UINT32_MAX;
+			result |= target_time_us_wrapped;
+		}
+	}
+
+	__ASSERT_NO_MSG(result <= INT64_MAX / NSEC_PER_USEC);
+	return (net_time_t)result * NSEC_PER_USEC;
+}
+#endif /* CONFIG_NET_PKT_TXTIME || CONFIG_OPENTHREAD_CSL_RECEIVER */
+
 static void dataInit(void)
 {
 	tx_pkt = net_pkt_alloc(K_NO_WAIT);
@@ -315,11 +394,13 @@ void transmit_message(struct k_work *tx_job)
 
 	if ((radio_api->get_capabilities(radio_dev) & IEEE802154_HW_TXTIME) &&
 	    (sTransmitFrame.mInfo.mTxInfo.mTxDelay != 0)) {
-		uint64_t tx_at = sTransmitFrame.mInfo.mTxInfo.mTxDelayBaseTime +
+#if defined(CONFIG_NET_PKT_TXTIME)
+		uint32_t tx_at = sTransmitFrame.mInfo.mTxInfo.mTxDelayBaseTime +
 				 sTransmitFrame.mInfo.mTxInfo.mTxDelay;
-		struct net_ptp_time timestamp = ns_to_net_ptp_time(tx_at * NSEC_PER_USEC);
-
+		struct net_ptp_time timestamp =
+			ns_to_net_ptp_time(convert_32bit_us_wrapped_to_64bit_ns(tx_at));
 		net_pkt_set_timestamp(tx_pkt, &timestamp);
+#endif
 		tx_err =
 			radio_api->tx(radio_dev, IEEE802154_TX_MODE_TXTIME_CCA, tx_pkt, tx_payload);
 	} else if (sTransmitFrame.mInfo.mTxInfo.mCsmaCaEnabled) {
@@ -666,7 +747,7 @@ otError otPlatRadioReceiveAt(otInstance *aInstance, uint8_t aChannel,
 
 	struct ieee802154_config config = {
 		.rx_slot.channel = aChannel,
-		.rx_slot.start = (net_time_t)aStart * NSEC_PER_USEC,
+		.rx_slot.start = convert_32bit_us_wrapped_to_64bit_ns(aStart),
 		.rx_slot.duration = (net_time_t)aDuration * NSEC_PER_USEC,
 	};
 
@@ -1195,7 +1276,8 @@ void otPlatRadioUpdateCslSampleTime(otInstance *aInstance, uint32_t aCslSampleTi
 {
 	ARG_UNUSED(aInstance);
 
-	struct ieee802154_config config = { .csl_rx_time = aCslSampleTime * NSEC_PER_USEC };
+	struct ieee802154_config config = {
+		.csl_rx_time = convert_32bit_us_wrapped_to_64bit_ns(aCslSampleTime)};
 
 	(void)radio_api->configure(radio_dev, IEEE802154_CONFIG_CSL_RX_TIME, &config);
 }

tests/subsys/openthread/radio_test.c

@@ -46,6 +46,7 @@ FAKE_VALUE_FUNC(int, set_channel_mock, const struct device *, uint16_t);
 FAKE_VALUE_FUNC(int, filter_mock, const struct device *, bool, enum ieee802154_filter_type,
 		const struct ieee802154_filter *);
 FAKE_VALUE_FUNC(int, set_txpower_mock, const struct device *, int16_t);
+FAKE_VALUE_FUNC(int64_t, get_time_mock, const struct device *);
 FAKE_VALUE_FUNC(int, tx_mock, const struct device *, enum ieee802154_tx_mode, struct net_pkt *,
 		struct net_buf *);
 FAKE_VALUE_FUNC(int, start_mock, const struct device *);
@@ -62,6 +63,7 @@ static struct ieee802154_radio_api rapi = {.get_capabilities = get_capabilities,
 					   .set_channel = set_channel_mock,
 					   .filter = filter_mock,
 					   .set_txpower = set_txpower_mock,
+					   .get_time = get_time_mock,
 					   .tx = tx_mock,
 					   .start = start_mock,
 					   .stop = stop_mock,
@@ -284,11 +286,17 @@ ZTEST(openthread_radio, test_tx_test)
 	FFF_RESET_HISTORY();
 
 	if (IS_ENABLED(CONFIG_NET_PKT_TXTIME)) {
+		/* cover dealing with wrapped scheduling time:
+		 *  current time: (UINT32_MAX + 1) us
+		 *  target time wrapped: (3 + 5) us, unwrapped: (UINT32_MAX + 3 + 5) us
+		 */
+		get_time_mock_fake.return_val = (int64_t)UINT32_MAX * NSEC_PER_USEC + 1000;
 		frm->mInfo.mTxInfo.mTxDelayBaseTime = 3U;
 		frm->mInfo.mTxInfo.mTxDelay = 5U;
 		expected_target_time =
+			get_time_mock_fake.return_val +
 			(frm->mInfo.mTxInfo.mTxDelayBaseTime + frm->mInfo.mTxInfo.mTxDelay) *
-			NSEC_PER_USEC;
+				NSEC_PER_USEC;
 	}
 
 	/* ACKed frame */