WIP

Author: maciejbaczmanski

include/openthread/platform/radio.h

@@ -737,6 +737,28 @@ uint64_t otPlatRadioGetNow(otInstance *aInstance);
  */
 uint32_t otPlatRadioGetBusSpeed(otInstance *aInstance);
 
+/**
+ * Get the bus latency in microseconds between the host and the radio chip.
+ *
+ * @param[in]   aInstance    A pointer to an OpenThread instance.
+ *
+ * @returns The bus latency in microseconds between the host and the radio chip.
+ *          Return 0 when the MAC and above layer and Radio layer resides on the same chip.
+ *
+ */
+uint32_t otPlatRadioGetBusLatency(otInstance *aInstance);
+
+/**
+ * Set the bus latency in microseconds between the host and the radio chip.
+ *
+ * @note This function does not do anything when the MAC and above layer and Radio layer resides on the same chip.
+ *
+ * @param[in]   aInstance    A pointer to an OpenThread instance.
+ * @param[in]   aLatency     Bus latency in microseconds.
+ *
+ */
+void otPlatRadioSetBusLatency(otInstance *aInstance, uint32_t aLatency);
+
 /**
  * @}
  *

include/openthread/thread.h

@@ -1136,6 +1136,23 @@ otError otThreadSendProactiveBackboneNotification(otInstance               *aIns
  */
 otError otThreadDetachGracefully(otInstance *aInstance, otDetachGracefullyCallback aCallback, void *aContext);
 
+
+
+/**
+ * Notifies other nodes in the network (if any) and then stops Thread protocol operation.
+ *
+ * It sends an Address Release if it's a router, or sets its child timeout to 0 if it's a child.
+ *
+ * @param[in] aInstance A pointer to an OpenThread instance.
+ * @param[in] aCallback A pointer to a function that is called upon finishing detaching.
+ * @param[in] aContext  A pointer to callback application-specific context.
+ *
+ * @retval OT_ERROR_NONE Successfully started detaching.
+ * @retval OT_ERROR_BUSY Detaching is already in progress.
+ *
+ */
+void otThreaUpdateCslTimeout(otInstance *aInstance);
+
 #define OT_DURATION_STRING_SIZE 21 ///< Recommended size for string representation of `uint32_t` duration in seconds.
 
 /**

src/cli/README.md

@@ -3218,6 +3218,25 @@ OPENTHREAD/20191113-00825-g82053cc9d-dirty; SIMULATION; Jun  4 2020 17:53:16
 Done
 ```
 
+### rcp latency
+
+Get the bus latency betw.
+
+```bash
+> rcp latency
+0
+Done
+```
+
+### rcp latency \<latency\>
+
+Set the Thread Network Key value.
+
+```bash
+> rcp latency 1000
+Done
+```
+
 ### releaserouterid \<routerid\>
 
 Release a Router ID that has been allocated by the device in the Leader role.

src/cli/cli.cpp

@@ -92,6 +92,8 @@
 #include "common/new.hpp"
 #include "common/numeric_limits.hpp"
 #include "common/string.hpp"
+#include "common/locator_getters.hpp"
+
 #include "mac/channel_mask.hpp"
 
 namespace ot {
@@ -5940,6 +5942,7 @@ template <> otError Interpreter::Process<Cmd("rcp")>(Arg aArgs[])
 {
     otError     error   = OT_ERROR_NONE;
     const char *version = otPlatRadioGetVersionString(GetInstancePtr());
+    const uint32_t latency = otPlatRadioGetBusLatency(GetInstancePtr());
 
     VerifyOrExit(version != otGetVersionString(), error = OT_ERROR_NOT_IMPLEMENTED);
     /**
@@ -5957,6 +5960,18 @@ template <> otError Interpreter::Process<Cmd("rcp")>(Arg aArgs[])
         OutputLine("%s", version);
     }
 
+    else if (aArgs[0] == "latency")
+    {
+        if (aArgs[1].IsEmpty())
+        {
+            OutputLine("%lu", ToUlong(latency));
+        }
+        else
+        {
+            error = ProcessSet(aArgs + 1, otPlatRadioSetBusLatency);
+        }
+    }
+
     else
     {
         error = OT_ERROR_INVALID_ARGS;

src/core/api/thread_api.cpp

@@ -512,6 +512,15 @@ otError otThreadDetachGracefully(otInstance *aInstance, otDetachGracefullyCallba
 
 #endif // OPENTHREAD_FTD || OPENTHREAD_MTD
 
+#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE
+
+void otThreaUpdateCslTimeout(otInstance *aInstance)
+{
+    AsCoreType(aInstance).Get<CslTxScheduler>().UpdateFrameRequestAhead();
+    // Get<AnycastLocator>().IsInProgress();
+}
+#endif
+
 #if OPENTHREAD_CONFIG_UPTIME_ENABLE
 void otConvertDurationInSecondsToString(uint32_t aDuration, char *aBuffer, uint16_t aSize)
 {

src/core/instance/instance.hpp

@@ -105,6 +105,7 @@
 #include "thread/announce_begin_server.hpp"
 #include "thread/announce_sender.hpp"
 #include "thread/anycast_locator.hpp"
+#include "thread/csl_tx_scheduler.hpp"
 #include "thread/child_supervision.hpp"
 #include "thread/discover_scanner.hpp"
 #include "thread/dua_manager.hpp"

src/core/radio/radio_platform.cpp

@@ -250,6 +250,19 @@ OT_TOOL_WEAK uint32_t otPlatRadioGetBusSpeed(otInstance *aInstance)
     return 0;
 }
 
+OT_TOOL_WEAK uint32_t otPlatRadioGetBusLatency(otInstance *aInstance)
+{
+    OT_UNUSED_VARIABLE(aInstance);
+
+    return 0;
+}
+
+OT_TOOL_WEAK void otPlatRadioSetBusLatency(otInstance *aInstance, uint32_t aLatency)
+{
+    OT_UNUSED_VARIABLE(aInstance);
+    OT_UNUSED_VARIABLE(aLatency);
+}
+
 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
 OT_TOOL_WEAK otError otPlatRadioResetCsl(otInstance *aInstance)
 {

src/core/thread/csl_tx_scheduler.cpp

@@ -32,6 +32,7 @@
 
 #include "common/locator_getters.hpp"
 #include "common/log.hpp"
+#include "common/num_utils.hpp"
 #include "common/time.hpp"
 #include "mac/mac.hpp"
 
@@ -68,16 +69,21 @@ CslTxScheduler::CslTxScheduler(Instance &aInstance)
     , mFrameContext()
     , mCallbacks(aInstance)
 {
-    InitFrameRequestAhead();
+    UpdateFrameRequestAhead();
 }
 
-void CslTxScheduler::InitFrameRequestAhead(void)
+void CslTxScheduler::UpdateFrameRequestAhead(void)
 {
     uint32_t busSpeedHz = otPlatRadioGetBusSpeed(&GetInstance());
+    uint32_t busLatency = otPlatRadioGetBusLatency(&GetInstance());
+
     // longest frame on bus is 127 bytes with some metadata, use 150 bytes for bus Tx time estimation
     uint32_t busTxTimeUs = ((busSpeedHz == 0) ? 0 : (150 * 8 * 1000000 + busSpeedHz - 1) / busSpeedHz);
 
-    mCslFrameRequestAheadUs = OPENTHREAD_CONFIG_MAC_CSL_REQUEST_AHEAD_US + busTxTimeUs;
+    mCslFrameRequestAheadUs = OPENTHREAD_CONFIG_MAC_CSL_REQUEST_AHEAD_US + busTxTimeUs + busLatency;
+    LogInfo("Declared Bus TX Time: %lu, Latency: %lu. Calculated CSL Frame Request Ahead: %lu",
+            ToUlong(busTxTimeUs), ToUlong(busLatency), ToUlong(mCslFrameRequestAheadUs));
+
 }
 
 void CslTxScheduler::Update(void)

src/core/thread/csl_tx_scheduler.hpp

@@ -231,11 +231,16 @@ class CslTxScheduler : public InstanceLocator, private NonCopyable
      */
     void Clear(void);
 
+    /**
+     * Updates the value of `mCslFrameRequestAheadUs`.
+     *
+     */
+    void UpdateFrameRequestAhead(void);
+
 private:
     // Guard time in usec to add when checking delay while preparing the CSL frame for tx.
     static constexpr uint32_t kFramePreparationGuardInterval = 1500;
 
-    void InitFrameRequestAhead(void);
     void RescheduleCslTx(void);
 
     uint32_t GetNextCslTransmissionDelay(const Child &aChild, uint32_t &aDelayFromLastRx, uint32_t aAheadUs) const;

src/lib/spinel/radio_spinel.cpp

@@ -1900,6 +1900,10 @@ uint64_t RadioSpinel::GetNow(void) { return (mIsTimeSynced) ? (otPlatTimeGet() +
 
 uint32_t RadioSpinel::GetBusSpeed(void) const { return GetSpinelDriver().GetSpinelInterface()->GetBusSpeed(); }
 
+uint32_t RadioSpinel::GetBusLatency(void) const { return GetSpinelDriver().GetSpinelInterface()->GetBusLatency(); }
+
+void RadioSpinel::SetBusLatency(uint32_t aLatency) { GetSpinelDriver().GetSpinelInterface()->SetBusLatency(aLatency); }
+
 void RadioSpinel::HandleRcpUnexpectedReset(spinel_status_t aStatus)
 {
     OT_UNUSED_VARIABLE(aStatus);

src/lib/spinel/radio_spinel.hpp

@@ -843,6 +843,22 @@ class RadioSpinel : private Logger
      */
     uint32_t GetBusSpeed(void) const;
 
+    /**
+     * Returns the bus latency between the host and the radio.
+     *
+     * @returns   Bus latency in microseconds.
+     *
+     */
+    uint32_t GetBusLatency(void) const;
+
+    /**
+     * Returns the bus speed between the host and the radio.
+     *
+     * @param[in]   aLatency  Bus latency in microseconds.
+     *
+     */
+    void SetBusLatency(uint32_t aLatency);
+
     /**
      * Returns the co-processor sw version string.
      *

src/lib/spinel/spinel_interface.hpp

@@ -134,6 +134,22 @@ class SpinelInterface
      */
     virtual uint32_t GetBusSpeed(void) const = 0;
 
+    /**
+     * Returns the bus latency between the host and the radio.
+     *
+     * @returns   Bus latency in microseconds.
+     *
+     */
+    virtual uint32_t GetBusLatency(void) const = 0;
+
+    /**
+     * Sets the bus latency between the host and the radio.
+     *
+     * @param[in]   aLatency  Bus latency in microseconds.
+     *
+     */
+    virtual void SetBusLatency(uint32_t aLatency) = 0;
+
     /**
      * Hardware resets the RCP.
      *

src/posix/platform/hdlc_interface.cpp

@@ -466,6 +466,7 @@ int HdlcInterface::OpenFile(const Url::Url &aRadioUrl)
         speed_t        speed;
         uint8_t        stopBit  = 1;
         uint32_t       baudrate = 115200;
+        uint32_t       latency  = 0;
 
         VerifyOrExit((rval = tcgetattr(fd, &tios)) == 0);
 
@@ -596,6 +597,10 @@ int HdlcInterface::OpenFile(const Url::Url &aRadioUrl)
 
         mBaudRate = baudrate;
 
+        IgnoreError(aRadioUrl.ParseUint32("uart-latency", latency));
+
+        mLatency = latency;
+
         if (aRadioUrl.HasParam("uart-flow-control"))
         {
             tios.c_cflag |= CRTSCTS;

src/posix/platform/hdlc_interface.hpp

@@ -141,6 +141,22 @@ class HdlcInterface : public ot::Spinel::SpinelInterface, public Logger<HdlcInte
      */
     uint32_t GetBusSpeed(void) const { return mBaudRate; }
 
+    /**
+     * Returns the bus latency between the host and the radio.
+     *
+     * @returns   Bus latency in microseconds.
+     *
+     */
+    uint32_t GetBusLatency(void) const { return mLatency; }
+
+    /**
+     * Sets the bus latency between the host and the radio.
+     *
+     * @param[in]   aLatency  Bus latency in microseconds.
+     *
+     */
+    void SetBusLatency(uint32_t aLatency) { mLatency = aLatency; }
+
     /**
      * Hardware resets the RCP.
      *
@@ -263,6 +279,7 @@ class HdlcInterface : public ot::Spinel::SpinelInterface, public Logger<HdlcInte
 
     int             mSockFd;
     uint32_t        mBaudRate;
+    uint32_t        mLatency;
     Hdlc::Decoder   mHdlcDecoder;
     const Url::Url &mRadioUrl;
 

src/posix/platform/radio.cpp

@@ -37,6 +37,7 @@
 
 #include <openthread/logging.h>
 #include <openthread/platform/diag.h>
+#include <openthread/thread.h>
 
 #include "common/code_utils.hpp"
 #include "common/new.hpp"
@@ -900,6 +901,23 @@ uint32_t otPlatRadioGetBusSpeed(otInstance *aInstance)
     return GetRadioSpinel().GetBusSpeed();
 }
 
+uint32_t otPlatRadioGetBusLatency(otInstance *aInstance)
+{
+    OT_UNUSED_VARIABLE(aInstance);
+    return GetRadioSpinel().GetBusLatency();
+}
+
+void otPlatRadioSetBusLatency(otInstance *aInstance, uint32_t aLatency)
+{
+    GetRadioSpinel().SetBusLatency(aLatency);
+#if OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE
+    otThreaUpdateCslTimeout(aInstance);
+#else
+    OT_UNUSED_VARIABLE(aInstance);
+#endif
+
+}
+
 #if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE || OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE
 uint8_t otPlatRadioGetCslAccuracy(otInstance *aInstance)
 {

src/posix/platform/radio_url.cpp

@@ -83,6 +83,7 @@ const char *otSysGetRadioUrlHelpString(void)
     "    uart-parity[=even|odd]         Uart parity config, optional.\n"                             \
     "    uart-stop[=number-of-bits]     Uart stop bit, default is 1.\n"                              \
     "    uart-baudrate[=baudrate]       Uart baud rate, default is 115200.\n"                        \
+    "    uart-latency[=usec]            Uart communication latency in usec, optional.\n"                        \
     "    uart-flow-control              Enable flow control, disabled by default.\n"                 \
     "    uart-reset                     Reset connection after hard resetting RCP(USB CDC ACM).\n"   \
     "\n"

src/posix/platform/vendor_interface.hpp

@@ -136,6 +136,22 @@ class VendorInterface : public ot::Spinel::SpinelInterface
      */
     uint32_t GetBusSpeed(void) const;
 
+    /**
+     * Returns the bus latency between the host and the radio.
+     *
+     * @returns  Bus speed in bits/second.
+     *
+     */
+    uint32_t GetBusLatency(void) const;
+
+    /**
+     * Sets the bus latency between the host and the radio.
+     *
+     * @returns  Bus speed in bits/second.
+     *
+     */
+    void SetBusLatency(uint32_t aLatency);
+
     /**
      * Hardware resets the RCP.
      *
@@ -166,6 +182,9 @@ class VendorInterface : public ot::Spinel::SpinelInterface
         static const char *kInterfaceName = OPENTHREAD_POSIX_CONFIG_SPINEL_VENDOR_INTERFACE_URL_PROTOCOL_NAME;
         return (strncmp(aInterfaceName, kInterfaceName, strlen(kInterfaceName)) == 0);
     }
+
+private:
+    uint32_t mLatency;
 };
 
 } // namespace Posix