update spinel_hdlc.cpp to use the latest RadioSpinel API

src/imx_rt/platform/radio.cpp

@@ -34,12 +34,16 @@
 
 #include "ot_platform_common.h"
 
+#include <openthread/logging.h>
 #include <openthread/platform/radio.h>
 
 #include "spinel_hdlc.hpp"
+#include <lib/platform/exit_code.h>
 #include <lib/spinel/radio_spinel.hpp>
 
-static ot::Spinel::RadioSpinel<ot::RT::HdlcInterface> sRadioSpinel;
+static ot::Url::Url            sUrl;
+static ot::RT::HdlcInterface   sSpinelInterface(sUrl);
+static ot::Spinel::RadioSpinel sRadioSpinel;
 
 void otPlatRadioGetIeeeEui64(otInstance *aInstance, uint8_t *aIeeeEui64)
 {
@@ -361,8 +365,7 @@ otRadioState otPlatRadioGetState(otInstance *aInstance)
 
 void otPlatRadioInit(void)
 {
-    sRadioSpinel.GetSpinelInterface().Init();
-    sRadioSpinel.Init(true, false);
+    sRadioSpinel.Init(sSpinelInterface, true, false);
 }
 
 void otPlatRadioDeinit(void)

src/imx_rt/platform/spinel_hdlc.cpp

@@ -89,25 +89,33 @@ namespace ot {
 
 namespace RT {
 
-HdlcInterface::HdlcInterface(ot::Spinel::SpinelInterface::ReceiveFrameCallback aCallback,
-                             void                                             *aCallbackContext,
-                             ot::Spinel::SpinelInterface::RxFrameBuffer       &aFrameBuffer)
-    : mReceiveFrameCallback(aCallback)
-    , mReceiveFrameContext(aCallbackContext)
-    , mReceiveFrameBuffer(aFrameBuffer)
+HdlcInterface::HdlcInterface(const Url::Url &aRadioUrl)
+    : mReceiveFrameCallback(nullptr)
+    , mReceiveFrameContext(nullptr)
+    , mReceiveFrameBuffer(nullptr)
     , encoderBuffer()
     , mHdlcEncoder(encoderBuffer)
-    , mHdlcDecoder(aFrameBuffer, HandleHdlcFrame, this)
+    , mHdlcDecoder()
 {
+    OT_UNUSED_VARIABLE(aRadioUrl);
 }
 
 HdlcInterface::~HdlcInterface(void)
 {
 }
 
-void HdlcInterface::Init(void)
+otError HdlcInterface::Init(ot::Spinel::SpinelInterface::ReceiveFrameCallback aCallback,
+                            void                                             *aCallbackContext,
+                            ot::Spinel::SpinelInterface::RxFrameBuffer       &aFrameBuffer)
 {
+    mReceiveFrameCallback = aCallback;
+    mReceiveFrameContext  = aCallbackContext;
+    mReceiveFrameBuffer   = &aFrameBuffer;
+    mHdlcDecoder.Init(aFrameBuffer, HandleHdlcFrame, this);
+
     InitUart();
+
+    return OT_ERROR_NONE;
 }
 
 void HdlcInterface::Deinit(void)
@@ -237,7 +245,7 @@ void HdlcInterface::HandleHdlcFrame(otError aError)
     else
     {
         OT_PLAT_DBG_NO_FUNC("Frame will be discarded error = 0x%x", aError);
-        mReceiveFrameBuffer.DiscardFrame();
+        mReceiveFrameBuffer->DiscardFrame();
     }
 }
 

src/imx_rt/platform/spinel_hdlc.hpp

@@ -36,6 +36,7 @@
 #include "lib/hdlc/hdlc.hpp"
 #include "lib/spinel/multi_frame_buffer.hpp"
 #include "lib/spinel/spinel_interface.hpp"
+#include "lib/url/url.hpp"
 
 namespace ot {
 
@@ -47,20 +48,16 @@ typedef uint8_t HdlcSpinelContext;
  * This class defines an HDLC spinel interface to the Radio Co-processor (RCP).
  *
  */
-class HdlcInterface
+class HdlcInterface : public ot::Spinel::SpinelInterface
 {
 public:
     /**
      * This constructor initializes the object.
      *
-     * @param[in] aCallback         Callback on frame received
-     * @param[in] aCallbackContext  Callback context
-     * @param[in] aFrameBuffer      A reference to a `RxFrameBuffer` object.
+     * @param[in] aRadioUrl  RadioUrl parsed from radio url.
      *
      */
-    HdlcInterface(ot::Spinel::SpinelInterface::ReceiveFrameCallback aCallback,
-                  void                                             *aCallbackContext,
-                  ot::Spinel::SpinelInterface::RxFrameBuffer       &aFrameBuffer);
+    HdlcInterface(const Url::Url &aRadioUrl);
 
     /**
      * This destructor deinitializes the object.
@@ -71,8 +68,12 @@ class HdlcInterface
     /**
      * This method initializes the HDLC interface.
      *
+     * @param[in] aCallback         Callback on frame received
+     * @param[in] aCallbackContext  Callback context
+     * @param[in] aFrameBuffer      A reference to a `RxFrameBuffer` object.
+     *
      */
-    void Init(void);
+    otError Init(ReceiveFrameCallback aCallback, void *aCallbackContext, RxFrameBuffer &aFrameBuffer);
 
     /**
      * This method deinitializes the HDLC interface.
@@ -108,19 +109,32 @@ class HdlcInterface
     otError WaitForFrame(uint64_t aTimeoutUs);
 
     /**
-     * This method performs radio driver processing.
+     * Updates the file descriptor sets with file descriptors used by the radio driver.
      *
-     * @param[in]  aInstance  The ot instance
+     * @param[in,out]   aMainloopContext  A pointer to the mainloop context containing fd_sets.
      *
      */
-    void Process(const void *aContext);
+    void UpdateFdSet(void *aMainloopContext) { OT_UNUSED_VARIABLE(aMainloopContext); }
 
     /**
-     * This method is called when RCP is reset to recreate the connection with it.
-     * Intentionally empty.
+     * Returns the bus speed between the host and the radio.
+     *
+     * @returns   Bus speed in bits/second.
      *
      */
-    otError ResetConnection(void) { return OT_ERROR_NONE; }
+    uint32_t GetBusSpeed(void) const
+    {
+        static constexpr uint32_t kDefaultSpeed = 1000000;
+        return kDefaultSpeed;
+    }
+
+    /**
+     * This method performs radio driver processing.
+     *
+     * @param[in]  aInstance  The ot instance
+     *
+     */
+    void Process(const void *aContext);
 
     /**
      * This method hardware resets the RCP.
@@ -131,6 +145,14 @@ class HdlcInterface
      */
     otError HardwareReset(void) { return OT_ERROR_NOT_IMPLEMENTED; }
 
+    /**
+     * Returns the RCP interface metrics.
+     *
+     * @returns The RCP interface metrics.
+     *
+     */
+    const otRcpInterfaceMetrics *GetRcpInterfaceMetrics(void) const { return nullptr; }
+
 private:
     enum
     {
@@ -144,7 +166,7 @@ class HdlcInterface
 
     ot::Spinel::SpinelInterface::ReceiveFrameCallback mReceiveFrameCallback;
     void                                             *mReceiveFrameContext;
-    ot::Spinel::SpinelInterface::RxFrameBuffer       &mReceiveFrameBuffer;
+    ot::Spinel::SpinelInterface::RxFrameBuffer       *mReceiveFrameBuffer;
 
     ot::Spinel::FrameBuffer<ot::Spinel::SpinelInterface::kMaxFrameSize> encoderBuffer;
     ot::Hdlc::Encoder                                                   mHdlcEncoder;