diff --git a/Android.mk b/Android.mk index 9d9d73e58..4c1337f59 100644 --- a/Android.mk +++ b/Android.mk @@ -41,6 +41,7 @@ OPENTHREAD_COMMON_FLAGS := \ -DOPENTHREAD_FTD=1 \ -DOPENTHREAD_POSIX=1 \ -DOPENTHREAD_POSIX_RCP_UART_ENABLE=1 \ + -DOPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=1 \ -DPACKAGE=\"openthread\" \ -DPACKAGE_BUGREPORT=\"openthread-devel@googlegroups.com\" \ -DPACKAGE_NAME=\"OPENTHREAD\" \ @@ -233,9 +234,6 @@ LOCAL_SRC_FILES := \ src/core/utils/parse_cmdline.cpp \ src/core/utils/slaac_address.cpp \ src/ncp/hdlc.cpp \ - src/ncp/spinel.c \ - src/ncp/spinel_decoder.cpp \ - src/ncp/spinel_encoder.cpp \ src/posix/platform/alarm.cpp \ src/posix/platform/entropy.cpp \ src/posix/platform/hdlc_interface.cpp \ @@ -248,6 +246,9 @@ LOCAL_SRC_FILES := \ src/posix/platform/system.cpp \ src/posix/platform/uart.cpp \ src/posix/platform/udp.cpp \ + src/spinel/spinel.c \ + src/spinel/spinel_decoder.cpp \ + src/spinel/spinel_encoder.cpp \ third_party/mbedtls/repo/library/md.c \ third_party/mbedtls/repo/library/md_wrap.c \ third_party/mbedtls/repo/library/memory_buffer_alloc.c \ @@ -389,8 +390,8 @@ LOCAL_SRC_FILES := \ src/ncp/ncp_base_mtd.cpp \ src/ncp/ncp_base_ftd.cpp \ src/ncp/ncp_base_dispatcher.cpp \ - src/ncp/ncp_buffer.cpp \ src/ncp/ncp_uart.cpp \ + src/spinel/spinel_buffer.cpp \ $(NULL) include $(BUILD_STATIC_LIBRARY) diff --git a/BUILD.gn b/BUILD.gn index a9dff17ae..a8f9dc462 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -162,9 +162,9 @@ static_library("lib-ot-core") { "src/core/utils/parse_cmdline.cpp", "src/core/utils/slaac_address.cpp", "src/ncp/hdlc.cpp", - "src/ncp/spinel.c", - "src/ncp/spinel_decoder.cpp", - "src/ncp/spinel_encoder.cpp", + "src/spinel/spinel.c", + "src/spinel/spinel_decoder.cpp", + "src/spinel/spinel_encoder.cpp", "third_party/mbedtls/repo/library/md.c", "third_party/mbedtls/repo/library/md_wrap.c", "third_party/mbedtls/repo/library/memory_buffer_alloc.c", diff --git a/configure.ac b/configure.ac index db0bd3429..253d0bb52 100644 --- a/configure.ac +++ b/configure.ac @@ -1065,6 +1065,7 @@ src/ncp/Makefile src/core/Makefile src/posix/Makefile src/posix/platform/Makefile +src/spinel/Makefile third_party/Makefile third_party/jlink/Makefile third_party/mbedtls/Makefile diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 71a61436f..6b724c10b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -29,3 +29,4 @@ add_subdirectory(cli) add_subdirectory(core) add_subdirectory(ncp) +add_subdirectory(spinel) diff --git a/src/Makefile.am b/src/Makefile.am index 9107ec9b8..75197cdc4 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -35,12 +35,14 @@ DIST_SUBDIRS = \ cli \ ncp \ posix \ + spinel \ $(NULL) # Always build (e.g. for 'make all') these subdirectories. SUBDIRS = \ core \ + spinel \ $(NULL) if OPENTHREAD_ENABLE_CLI @@ -62,6 +64,7 @@ PRETTY_SUBDIRS = \ core \ ncp \ posix \ + spinel \ $(NULL) include $(abs_top_nlbuild_autotools_dir)/automake/post.am diff --git a/src/ncp/CMakeLists.txt b/src/ncp/CMakeLists.txt index 7d0836bab..ca49e4cae 100644 --- a/src/ncp/CMakeLists.txt +++ b/src/ncp/CMakeLists.txt @@ -82,12 +82,8 @@ set(COMMON_SOURCES ncp_base_mtd.cpp ncp_base_radio.cpp ncp_base_dispatcher.cpp - ncp_buffer.cpp ncp_spi.cpp ncp_uart.cpp - spinel.c - spinel_decoder.cpp - spinel_encoder.cpp ) target_include_directories(openthread-ncp-ftd PUBLIC ${OT_PUBLIC_INCLUDES} PRIVATE ${COMMON_INCLUDES}) @@ -97,3 +93,7 @@ target_include_directories(openthread-rcp PUBLIC ${OT_PUBLIC_INCLUDES} PRIVATE $ target_sources(openthread-ncp-ftd PRIVATE ${COMMON_SOURCES}) target_sources(openthread-ncp-mtd PRIVATE ${COMMON_SOURCES}) target_sources(openthread-rcp PRIVATE ${COMMON_SOURCES}) + +target_link_libraries(openthread-ncp-ftd openthread-spinel-ncp) +target_link_libraries(openthread-ncp-mtd openthread-spinel-ncp) +target_link_libraries(openthread-rcp openthread-spinel-rcp) diff --git a/src/ncp/Makefile.am b/src/ncp/Makefile.am index 24e301b29..3e0b2d3fa 100644 --- a/src/ncp/Makefile.am +++ b/src/ncp/Makefile.am @@ -58,27 +58,39 @@ COMMON_CPPFLAGS = \ $(OPENTHREAD_TARGET_DEFINES) \ $(NULL) -libopenthread_ncp_mtd_a_CPPFLAGS = \ - -DOPENTHREAD_RADIO=0 \ - -DOPENTHREAD_FTD=0 \ - -DOPENTHREAD_MTD=1 \ - $(COMMON_CPPFLAGS) \ +libopenthread_ncp_mtd_a_CPPFLAGS = \ + -DOPENTHREAD_RADIO=0 \ + -DOPENTHREAD_FTD=0 \ + -DOPENTHREAD_MTD=1 \ + -DOPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=1 \ + $(COMMON_CPPFLAGS) \ $(NULL) -libopenthread_ncp_ftd_a_CPPFLAGS = \ - -DOPENTHREAD_RADIO=0 \ - -DOPENTHREAD_FTD=1 \ - -DOPENTHREAD_MTD=0 \ - $(COMMON_CPPFLAGS) \ +libopenthread_ncp_ftd_a_CPPFLAGS = \ + -DOPENTHREAD_RADIO=0 \ + -DOPENTHREAD_FTD=1 \ + -DOPENTHREAD_MTD=0 \ + -DOPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=1 \ + $(COMMON_CPPFLAGS) \ $(NULL) -libopenthread_rcp_a_CPPFLAGS = \ - -DOPENTHREAD_RADIO=1 \ - -DOPENTHREAD_FTD=0 \ - -DOPENTHREAD_MTD=0 \ - $(COMMON_CPPFLAGS) \ +libopenthread_rcp_a_CPPFLAGS = \ + -DOPENTHREAD_RADIO=1 \ + -DOPENTHREAD_FTD=0 \ + -DOPENTHREAD_MTD=0 \ + -DOPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=0 \ + $(COMMON_CPPFLAGS) \ $(NULL) +libopenthread_ncp_mtd_a_LIBADD = \ + $(addprefix $(top_builddir)/src/spinel/,$(filter %.o,$(shell $(AR) t $(top_builddir)/src/spinel/libopenthread-spinel-ncp.a))) + +libopenthread_ncp_ftd_a_LIBADD = \ + $(addprefix $(top_builddir)/src/spinel/,$(filter %.o,$(shell $(AR) t $(top_builddir)/src/spinel/libopenthread-spinel-ncp.a))) + +libopenthread_rcp_a_LIBADD = \ + $(addprefix $(top_builddir)/src/spinel/,$(filter %.o,$(shell $(AR) t $(top_builddir)/src/spinel/libopenthread-spinel-rcp.a))) + COMMON_SOURCES = \ changed_props_set.cpp \ changed_props_set.hpp \ @@ -90,20 +102,11 @@ COMMON_SOURCES = \ ncp_base_mtd.cpp \ ncp_base_radio.cpp \ ncp_base_dispatcher.cpp \ - ncp_buffer.cpp \ - ncp_buffer.hpp \ ncp_config.h \ ncp_spi.cpp \ ncp_spi.hpp \ ncp_uart.cpp \ ncp_uart.hpp \ - spinel.c \ - spinel.h \ - spinel_decoder.cpp \ - spinel_decoder.hpp \ - spinel_encoder.cpp \ - spinel_encoder.hpp \ - spinel_platform.h \ $(NULL) if OPENTHREAD_ENABLE_NCP_VENDOR_HOOK @@ -139,25 +142,4 @@ libopenthread_rcp_a_SOURCES = \ include_HEADERS = \ $(NULL) -if OPENTHREAD_BUILD_TESTS - -check_PROGRAMS = spinel-test -spinel_test_SOURCES = spinel.c -spinel_test_CFLAGS = \ - $(COMMON_CPPFLAGS) \ - -DSPINEL_SELF_TEST=1 \ - -D_GNU_SOURCE \ - -I$(top_srcdir)/src/core \ - -I$(top_srcdir)/include \ - $(NULL) - -TESTS = spinel-test - -install-headers: install-includeHEADERS - -if OPENTHREAD_BUILD_COVERAGE -CLEANFILES = $(wildcard *.gcda *.gcno) -endif # OPENTHREAD_BUILD_COVERAGE -endif # OPENTHREAD_BUILD_TESTS - include $(abs_top_nlbuild_autotools_dir)/automake/post.am diff --git a/src/ncp/changed_props_set.hpp b/src/ncp/changed_props_set.hpp index c92db15de..75b2b3305 100644 --- a/src/ncp/changed_props_set.hpp +++ b/src/ncp/changed_props_set.hpp @@ -39,7 +39,7 @@ #include -#include "spinel.h" +#include "spinel/spinel.h" namespace ot { namespace Ncp { diff --git a/src/ncp/example_vendor_hook.cpp b/src/ncp/example_vendor_hook.cpp index 948c8f1ea..75a7d4dd7 100644 --- a/src/ncp/example_vendor_hook.cpp +++ b/src/ncp/example_vendor_hook.cpp @@ -43,8 +43,7 @@ otError NcpBase::VendorCommandHandler(uint8_t aHeader, unsigned int aCommand) switch (aCommand) { - - // TODO: Implement your command handlers here. + // TODO: Implement your command handlers here. default: error = PrepareLastStatusResponse(aHeader, SPINEL_STATUS_INVALID_COMMAND); @@ -53,7 +52,7 @@ otError NcpBase::VendorCommandHandler(uint8_t aHeader, unsigned int aCommand) return error; } -void NcpBase::VendorHandleFrameRemovedFromNcpBuffer(NcpFrameBuffer::FrameTag aFrameTag) +void NcpBase::VendorHandleFrameRemovedFromNcpBuffer(Spinel::Buffer::FrameTag aFrameTag) { // This method is a callback which mirrors `NcpBase::HandleFrameRemovedFromNcpBuffer()`. // It is called when a spinel frame is sent and removed from NCP buffer. @@ -75,13 +74,12 @@ otError NcpBase::VendorGetPropertyHandler(spinel_prop_key_t aPropKey) switch (aPropKey) { - - // TODO: Implement your property get handlers here. - // - // Get handler should retrieve the property value and then encode and write the - // value into the NCP buffer. If the "get" operation itself fails, handler should - // write a `LAST_STATUS` with the error status into the NCP buffer. `OT_ERROR_NO_BUFS` - // should be returned if NCP buffer is full and response cannot be written. + // TODO: Implement your property get handlers here. + // + // Get handler should retrieve the property value and then encode and write the + // value into the NCP buffer. If the "get" operation itself fails, handler should + // write a `LAST_STATUS` with the error status into the NCP buffer. `OT_ERROR_NO_BUFS` + // should be returned if NCP buffer is full and response cannot be written. default: error = OT_ERROR_NOT_FOUND; @@ -97,16 +95,15 @@ otError NcpBase::VendorSetPropertyHandler(spinel_prop_key_t aPropKey) switch (aPropKey) { - - // TODO: Implement your property set handlers here. - // - // Set handler should first decode the value from the input Spinel frame and then - // perform the corresponding set operation. The handler should not prepare the - // spinel response and therefore should not write anything to the NCP buffer. - // The error returned from handler (other than `OT_ERROR_NOT_FOUND`) indicates the - // error in either parsing of the input or the error of the set operation. In case - // of a successful "set", `NcpBase` set command handler will invoke the - // `VendorGetPropertyHandler()` for the same property key to prepare the response. + // TODO: Implement your property set handlers here. + // + // Set handler should first decode the value from the input Spinel frame and then + // perform the corresponding set operation. The handler should not prepare the + // spinel response and therefore should not write anything to the NCP buffer. + // The error returned from handler (other than `OT_ERROR_NOT_FOUND`) indicates the + // error in either parsing of the input or the error of the set operation. In case + // of a successful "set", `NcpBase` set command handler will invoke the + // `VendorGetPropertyHandler()` for the same property key to prepare the response. default: error = OT_ERROR_NOT_FOUND; @@ -116,8 +113,8 @@ otError NcpBase::VendorSetPropertyHandler(spinel_prop_key_t aPropKey) return error; } -} // namespace Ncp -} // namespace ot +} // namespace Ncp +} // namespace ot //------------------------------------------------------------------------------------------------------------------- // When OPENTHREAD_ENABLE_NCP_VENDOR_HOOK is enabled, vendor code is @@ -135,7 +132,8 @@ class NcpVendorUart : public ot::Ncp::NcpUart public: NcpVendorUart(ot::Instance *aInstance) : ot::Ncp::NcpUart(aInstance) - {} + { + } // Add public/private methods or member variables }; diff --git a/src/ncp/ncp_base.cpp b/src/ncp/ncp_base.cpp index bb91b56d2..90abe65f1 100644 --- a/src/ncp/ncp_base.cpp +++ b/src/ncp/ncp_base.cpp @@ -209,7 +209,7 @@ NcpBase::NcpBase(Instance *aInstance) , mThreadChangedFlags(0) , mChangedPropsSet() , mHostPowerState(SPINEL_HOST_POWER_STATE_ONLINE) - , mHostPowerReplyFrameTag(NcpFrameBuffer::kInvalidTag) + , mHostPowerReplyFrameTag(Spinel::Buffer::kInvalidTag) , mHostPowerStateHeader(0) #if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE , mAllowPeekDelegate(NULL) @@ -318,7 +318,7 @@ void NcpBase::ResetCounters(void) // MARK: Serial Traffic Glue // ---------------------------------------------------------------------------- -NcpFrameBuffer::FrameTag NcpBase::GetLastOutboundFrameTag(void) +Spinel::Buffer::FrameTag NcpBase::GetLastOutboundFrameTag(void) { return mTxFrameBuffer.InFrameGetLastTag(); } @@ -387,9 +387,9 @@ exit: } void NcpBase::HandleFrameRemovedFromNcpBuffer(void * aContext, - NcpFrameBuffer::FrameTag aFrameTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpBuffer) + Spinel::Buffer::FrameTag aFrameTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aNcpBuffer) { OT_UNUSED_VARIABLE(aNcpBuffer); OT_UNUSED_VARIABLE(aPriority); @@ -397,7 +397,7 @@ void NcpBase::HandleFrameRemovedFromNcpBuffer(void * aContext, static_cast(aContext)->HandleFrameRemovedFromNcpBuffer(aFrameTag); } -void NcpBase::HandleFrameRemovedFromNcpBuffer(NcpFrameBuffer::FrameTag aFrameTag) +void NcpBase::HandleFrameRemovedFromNcpBuffer(Spinel::Buffer::FrameTag aFrameTag) { if (mHostPowerStateInProgress) { @@ -2040,7 +2040,7 @@ otError NcpBase::HandlePropertySet_SPINEL_PROP_HOST_POWER_STATE(uint8_t aHeader) } else { - mHostPowerReplyFrameTag = NcpFrameBuffer::kInvalidTag; + mHostPowerReplyFrameTag = Spinel::Buffer::kInvalidTag; } mHostPowerStateInProgress = true; diff --git a/src/ncp/ncp_base.hpp b/src/ncp/ncp_base.hpp index b6bd8755f..70ae05b16 100644 --- a/src/ncp/ncp_base.hpp +++ b/src/ncp/ncp_base.hpp @@ -51,13 +51,12 @@ #include "changed_props_set.hpp" #include "common/instance.hpp" #include "common/tasklet.hpp" -#include "ncp/ncp_buffer.hpp" -#include "ncp/spinel_decoder.hpp" -#include "ncp/spinel_encoder.hpp" +#include "spinel/spinel.h" +#include "spinel/spinel_buffer.hpp" +#include "spinel/spinel_decoder.hpp" +#include "spinel/spinel_encoder.hpp" #include "utils/static_assert.hpp" -#include "spinel.h" - namespace ot { namespace Ncp { @@ -208,7 +207,7 @@ protected: NcpBase::PropertyHandler mHandler; }; - NcpFrameBuffer::FrameTag GetLastOutboundFrameTag(void); + Spinel::Buffer::FrameTag GetLastOutboundFrameTag(void); otError HandleCommand(uint8_t aHeader); @@ -259,10 +258,10 @@ protected: void UpdateChangedProps(void); static void HandleFrameRemovedFromNcpBuffer(void * aContext, - NcpFrameBuffer::FrameTag aFrameTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpBuffer); - void HandleFrameRemovedFromNcpBuffer(NcpFrameBuffer::FrameTag aFrameTag); + Spinel::Buffer::FrameTag aFrameTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aNcpBuffer); + void HandleFrameRemovedFromNcpBuffer(Spinel::Buffer::FrameTag aFrameTag); otError EncodeChannelMask(uint32_t aChannelMask); otError DecodeChannelMask(uint32_t &aChannelMask); @@ -472,7 +471,7 @@ protected: * @param[in] aFrameTag The tag of the frame removed from NCP buffer. * */ - void VendorHandleFrameRemovedFromNcpBuffer(NcpFrameBuffer::FrameTag aFrameTag); + void VendorHandleFrameRemovedFromNcpBuffer(Spinel::Buffer::FrameTag aFrameTag); /** * This method defines a vendor "get property handler" hook to process vendor spinel properties. @@ -520,9 +519,9 @@ protected: bool aDeviceType, bool aNetworkData); Instance * mInstance; - NcpFrameBuffer mTxFrameBuffer; - SpinelEncoder mEncoder; - SpinelDecoder mDecoder; + Spinel::Buffer mTxFrameBuffer; + Spinel::Encoder mEncoder; + Spinel::Decoder mDecoder; bool mHostPowerStateInProgress; enum @@ -544,7 +543,7 @@ protected: ChangedPropsSet mChangedPropsSet; spinel_host_power_state_t mHostPowerState; - NcpFrameBuffer::FrameTag mHostPowerReplyFrameTag; + Spinel::Buffer::FrameTag mHostPowerReplyFrameTag; uint8_t mHostPowerStateHeader; #if OPENTHREAD_CONFIG_NCP_ENABLE_PEEK_POKE diff --git a/src/ncp/ncp_spi.cpp b/src/ncp/ncp_spi.cpp index d3b78299f..de572faed 100644 --- a/src/ncp/ncp_spi.cpp +++ b/src/ncp/ncp_spi.cpp @@ -241,11 +241,11 @@ void NcpSpi::SpiTransactionProcess(void) } void NcpSpi::HandleFrameAddedToTxBuffer(void * aContext, - NcpFrameBuffer::FrameTag aTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpFrameBuffer) + Spinel::Buffer::FrameTag aTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aBuffer) { - OT_UNUSED_VARIABLE(aNcpFrameBuffer); + OT_UNUSED_VARIABLE(aBuffer); OT_UNUSED_VARIABLE(aTag); OT_UNUSED_VARIABLE(aPriority); diff --git a/src/ncp/ncp_spi.hpp b/src/ncp/ncp_spi.hpp index 5018f29ec..d4a87dd17 100644 --- a/src/ncp/ncp_spi.hpp +++ b/src/ncp/ncp_spi.hpp @@ -294,9 +294,9 @@ private: void SpiTransactionProcess(void); static void HandleFrameAddedToTxBuffer(void * aContext, - NcpFrameBuffer::FrameTag aFrameTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpFrameBuffer); + Spinel::Buffer::FrameTag aFrameTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aBuffer); static void PrepareTxFrame(Tasklet &aTasklet); void PrepareTxFrame(void); diff --git a/src/ncp/ncp_uart.cpp b/src/ncp/ncp_uart.cpp index 60f27f01f..71b6d590b 100644 --- a/src/ncp/ncp_uart.cpp +++ b/src/ncp/ncp_uart.cpp @@ -101,11 +101,11 @@ NcpUart::NcpUart(Instance *aInstance) } void NcpUart::HandleFrameAddedToNcpBuffer(void * aContext, - NcpFrameBuffer::FrameTag aTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpFrameBuffer) + Spinel::Buffer::FrameTag aTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aBuffer) { - OT_UNUSED_VARIABLE(aNcpFrameBuffer); + OT_UNUSED_VARIABLE(aBuffer); OT_UNUSED_VARIABLE(aTag); OT_UNUSED_VARIABLE(aPriority); @@ -134,9 +134,9 @@ void NcpUart::EncodeAndSendToUart(void) uint16_t len; bool prevHostPowerState; #if OPENTHREAD_ENABLE_NCP_SPINEL_ENCRYPTER - NcpFrameBufferEncrypterReader &txFrameBuffer = mTxFrameBufferEncrypterReader; + Spinel::BufferEncrypterReader &txFrameBuffer = mTxFrameBufferEncrypterReader; #else - NcpFrameBuffer &txFrameBuffer = mTxFrameBuffer; + Spinel::Buffer &txFrameBuffer = mTxFrameBuffer; #endif // OPENTHREAD_ENABLE_NCP_SPINEL_ENCRYPTER while (!txFrameBuffer.IsEmpty() || (mState == kFinalizingFrame)) @@ -310,19 +310,19 @@ void NcpUart::HandleError(otError aError, uint8_t *aBuf, uint16_t aBufLength) #if OPENTHREAD_ENABLE_NCP_SPINEL_ENCRYPTER -NcpUart::NcpFrameBufferEncrypterReader::NcpFrameBufferEncrypterReader(NcpFrameBuffer &aTxFrameBuffer) +NcpUart::Spinel::BufferEncrypterReader::SpinelBufferEncrypterReader(Spinel::Buffer &aTxFrameBuffer) : mTxFrameBuffer(aTxFrameBuffer) , mDataBufferReadIndex(0) , mOutputDataLength(0) { } -bool NcpUart::NcpFrameBufferEncrypterReader::IsEmpty(void) const +bool NcpUart::Spinel::BufferEncrypterReader::IsEmpty(void) const { return mTxFrameBuffer.IsEmpty() && !mOutputDataLength; } -otError NcpUart::NcpFrameBufferEncrypterReader::OutFrameBegin(void) +otError NcpUart::Spinel::BufferEncrypterReader::OutFrameBegin(void) { otError status = OT_ERROR_FAILED; @@ -352,22 +352,22 @@ otError NcpUart::NcpFrameBufferEncrypterReader::OutFrameBegin(void) return status; } -bool NcpUart::NcpFrameBufferEncrypterReader::OutFrameHasEnded(void) +bool NcpUart::Spinel::BufferEncrypterReader::OutFrameHasEnded(void) { return (mDataBufferReadIndex >= mOutputDataLength); } -uint8_t NcpUart::NcpFrameBufferEncrypterReader::OutFrameReadByte(void) +uint8_t NcpUart::Spinel::BufferEncrypterReader::OutFrameReadByte(void) { return mDataBuffer[mDataBufferReadIndex++]; } -otError NcpUart::NcpFrameBufferEncrypterReader::OutFrameRemove(void) +otError NcpUart::Spinel::BufferEncrypterReader::OutFrameRemove(void) { return mTxFrameBuffer.OutFrameRemove(); } -void NcpUart::NcpFrameBufferEncrypterReader::Reset(void) +void NcpUart::Spinel::BufferEncrypterReader::Reset(void) { mOutputDataLength = 0; mDataBufferReadIndex = 0; diff --git a/src/ncp/ncp_uart.hpp b/src/ncp/ncp_uart.hpp index 8e61e7222..5aa9dd9a5 100644 --- a/src/ncp/ncp_uart.hpp +++ b/src/ncp/ncp_uart.hpp @@ -87,17 +87,17 @@ private: #if OPENTHREAD_ENABLE_NCP_SPINEL_ENCRYPTER /** - * Wraps NcpFrameBuffer allowing to read data through spinel encrypter. + * Wraps Spinel::Buffer allowing to read data through spinel encrypter. * Creates additional buffers to allow transforming of the whole spinel frames. */ - class NcpFrameBufferEncrypterReader + class Spinel::BufferEncrypterReader { public: /** * C-tor. - * Takes a reference to NcpFrameBuffer in order to read spinel frames. + * Takes a reference to Spinel::Buffer in order to read spinel frames. */ - explicit NcpFrameBufferEncrypterReader(NcpFrameBuffer &aTxFrameBuffer); + explicit Spinel::BufferEncrypterReader(Spinel::Buffer &aTxFrameBuffer); bool IsEmpty(void) const; otError OutFrameBegin(void); bool OutFrameHasEnded(void); @@ -107,7 +107,7 @@ private: private: void Reset(void); - NcpFrameBuffer &mTxFrameBuffer; + Spinel::Buffer &mTxFrameBuffer; uint8_t mDataBuffer[kRxBufferSize]; size_t mDataBufferReadIndex; size_t mOutputDataLength; @@ -123,9 +123,9 @@ private: static void EncodeAndSendToUart(Tasklet &aTasklet); static void HandleFrame(void *aContext, otError aError); static void HandleFrameAddedToNcpBuffer(void * aContext, - NcpFrameBuffer::FrameTag aTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpFrameBuffer); + Spinel::Buffer::FrameTag aTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aBuffer); Hdlc::Encoder mFrameEncoder; Hdlc::Decoder mFrameDecoder; @@ -137,7 +137,7 @@ private: Tasklet mUartSendTask; #if OPENTHREAD_ENABLE_NCP_SPINEL_ENCRYPTER - NcpFrameBufferEncrypterReader mTxFrameBufferEncrypterReader; + Spinel::BufferEncrypterReader mTxFrameBufferEncrypterReader; #endif // OPENTHREAD_ENABLE_NCP_SPINEL_ENCRYPTER }; diff --git a/src/posix/platform/radio_spinel.cpp b/src/posix/platform/radio_spinel.cpp index b10563f24..c49d26b38 100644 --- a/src/posix/platform/radio_spinel.cpp +++ b/src/posix/platform/radio_spinel.cpp @@ -34,7 +34,7 @@ #include "radio_spinel.hpp" #include "platform-posix.h" -#include "ncp/spinel_decoder.hpp" +#include "spinel/spinel_decoder.hpp" #include #include @@ -66,6 +66,8 @@ #define TX_WAIT_US (5 * US_PER_S) #endif +using ot::Spinel::Decoder; + static ot::PosixApp::RadioSpinel sRadioSpinel; namespace ot { @@ -498,7 +500,7 @@ otError RadioSpinel::ThreadDatasetHandler(const uint8_t *aBuffer, uint16_t aLeng otError error = OT_ERROR_NONE; otOperationalDataset opDataset; bool isActive = ((mWaitingKey == SPINEL_PROP_THREAD_ACTIVE_DATASET) ? true : false); - Ncp::SpinelDecoder decoder; + Spinel::Decoder decoder; MeshCoP::Dataset dataset(isActive ? MeshCoP::Tlv::kActiveTimestamp : MeshCoP::Tlv::kPendingTimestamp); memset(&opDataset, 0, sizeof(otOperationalDataset)); diff --git a/src/posix/platform/radio_spinel.hpp b/src/posix/platform/radio_spinel.hpp index 4612cc507..cf04fcf7b 100644 --- a/src/posix/platform/radio_spinel.hpp +++ b/src/posix/platform/radio_spinel.hpp @@ -52,7 +52,7 @@ #include "spinel_interface.hpp" #include "ncp/ncp_config.h" -#include "ncp/spinel.h" +#include "spinel/spinel.h" namespace ot { namespace PosixApp { diff --git a/src/spinel/CMakeLists.txt b/src/spinel/CMakeLists.txt new file mode 100644 index 000000000..fd901ca7a --- /dev/null +++ b/src/spinel/CMakeLists.txt @@ -0,0 +1,71 @@ +# +# Copyright (c) 2020, The OpenThread Authors. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. Neither the name of the copyright holder nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# + +add_library(openthread-spinel-ncp) +add_library(openthread-spinel-rcp) + +target_compile_definitions(openthread-spinel-ncp PRIVATE + ${OT_PRIVATE_DEFINES} + OPENTHREAD_FTD=1 + OPENTHREAD_CONFIG_NCP_UART_ENABLE=1 + PUBLIC OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=1 +) + +target_compile_definitions(openthread-spinel-rcp PRIVATE + ${OT_PRIVATE_DEFINES} + OPENTHREAD_RADIO=1 + OPENTHREAD_CONFIG_NCP_UART_ENABLE=1 + PUBLIC OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=0 +) + +target_compile_options(openthread-spinel-ncp PRIVATE + ${OT_CFLAGS} +) + +target_compile_options(openthread-spinel-rcp PRIVATE + ${OT_CFLAGS} +) + +set(COMMON_INCLUDES + ${OT_PRIVATE_INCLUDES} + ${PROJECT_SOURCE_DIR}/src + ${PROJECT_SOURCE_DIR}/src/core +) + +set(COMMON_SOURCES + spinel.c + spinel_buffer.cpp + spinel_decoder.cpp + spinel_encoder.cpp +) + +target_include_directories(openthread-spinel-ncp PUBLIC ${OT_PUBLIC_INCLUDES} PRIVATE ${COMMON_INCLUDES}) +target_include_directories(openthread-spinel-rcp PUBLIC ${OT_PUBLIC_INCLUDES} PRIVATE ${COMMON_INCLUDES}) + +target_sources(openthread-spinel-ncp PRIVATE ${COMMON_SOURCES}) +target_sources(openthread-spinel-rcp PRIVATE ${COMMON_SOURCES}) diff --git a/src/spinel/Makefile.am b/src/spinel/Makefile.am new file mode 100644 index 000000000..c9812fa74 --- /dev/null +++ b/src/spinel/Makefile.am @@ -0,0 +1,114 @@ +# +# Copyright (c) 2020, The OpenThread Authors. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# 3. Neither the name of the copyright holder nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# + +include $(abs_top_nlbuild_autotools_dir)/automake/pre.am + +noinst_LIBRARIES = + +if OPENTHREAD_ENABLE_FTD +noinst_LIBRARIES += libopenthread-spinel-ncp.a +endif + +if OPENTHREAD_ENABLE_MTD +noinst_LIBRARIES += libopenthread-spinel-ncp.a +endif + +if OPENTHREAD_ENABLE_RADIO_ONLY +noinst_LIBRARIES += libopenthread-spinel-rcp.a +endif + +COMMON_CPPFLAGS = \ + -I$(top_srcdir)/include \ + -I$(top_srcdir)/src \ + -I$(top_srcdir)/src/core \ + -I$(top_srcdir)/third_party \ + -D_GNU_SOURCE \ + -DSPINEL_PLATFORM_HEADER=\"spinel_platform.h\" \ + $(OPENTHREAD_TARGET_DEFINES) \ + $(NULL) + +COMMON_SOURCES = \ + spinel.c \ + spinel_buffer.cpp \ + spinel_decoder.cpp \ + spinel_encoder.cpp \ + $(NULL) + + +include_HEADERS = \ + spinel.h \ + $(NULL) + +noinst_HEADERS = \ + spinel_buffer.hpp \ + spinel_decoder.hpp \ + spinel_encoder.hpp \ + spinel_platform.h \ + openthread-spinel-config.h \ + $(NULL) + +libopenthread_spinel_ncp_a_CPPFLAGS = \ + -DOPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=1 \ + $(COMMON_CPPFLAGS) \ + $(NULL) + +libopenthread_spinel_ncp_a_SOURCES = \ + $(COMMON_SOURCES) \ + $(NULL) + +libopenthread_spinel_rcp_a_CPPFLAGS = \ + -DOPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=0 \ + $(COMMON_CPPFLAGS) \ + $(NULL) + +libopenthread_spinel_rcp_a_SOURCES = \ + $(COMMON_SOURCES) \ + $(NULL) + +if OPENTHREAD_BUILD_TESTS + +check_PROGRAMS = spinel-test +spinel_test_SOURCES = spinel.c +spinel_test_CFLAGS = \ + $(COMMON_CPPFLAGS) \ + -DSPINEL_SELF_TEST=1 \ + -D_GNU_SOURCE \ + -I$(top_srcdir)/src/core \ + -I$(top_srcdir)/include \ + $(NULL) + +TESTS = spinel-test + +install-headers: install-includeHEADERS + +if OPENTHREAD_BUILD_COVERAGE +CLEANFILES = $(wildcard *.gcda *.gcno) +endif # OPENTHREAD_BUILD_COVERAGE +endif # OPENTHREAD_BUILD_TESTS + +include $(abs_top_nlbuild_autotools_dir)/automake/post.am diff --git a/src/spinel/openthread-spinel-config.h b/src/spinel/openthread-spinel-config.h new file mode 100644 index 000000000..390e3e30b --- /dev/null +++ b/src/spinel/openthread-spinel-config.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2020, The OpenThread Authors. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * @file + * This file includes compile-time configuration constants for OpenThread. + */ + +#ifndef OPENTHREAD_SPINEL_CONFIG_H_ +#define OPENTHREAD_SPINEL_CONFIG_H_ + +/** + * @def OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE + * + * Define 1 to enable feeding an OpenThread message to encoder/decoder. + * + */ +#ifndef OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE +#define OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE 0 +#endif + +#endif // OPENTHREAD_SPINEL_CONFIG_H_ diff --git a/src/ncp/spinel.c b/src/spinel/spinel.c similarity index 100% rename from src/ncp/spinel.c rename to src/spinel/spinel.c diff --git a/src/ncp/spinel.h b/src/spinel/spinel.h similarity index 100% rename from src/ncp/spinel.h rename to src/spinel/spinel.h diff --git a/src/ncp/ncp_buffer.cpp b/src/spinel/spinel_buffer.cpp similarity index 88% rename from src/ncp/ncp_buffer.cpp rename to src/spinel/spinel_buffer.cpp index 2a63f5bd4..867f98352 100644 --- a/src/ncp/ncp_buffer.cpp +++ b/src/spinel/spinel_buffer.cpp @@ -30,22 +30,22 @@ * This file implements NCP frame buffer class. */ -#include "ncp_buffer.hpp" +#include "spinel_buffer.hpp" #include "common/code_utils.hpp" #include "common/debug.hpp" namespace ot { -namespace Ncp { +namespace Spinel { -const NcpFrameBuffer::FrameTag NcpFrameBuffer::kInvalidTag = NULL; +const Buffer::FrameTag Buffer::kInvalidTag = NULL; -NcpFrameBuffer::NcpFrameBuffer(uint8_t *aBuffer, uint16_t aBufferLength) +Buffer::Buffer(uint8_t *aBuffer, uint16_t aBufferLength) : mBuffer(aBuffer) , mBufferEnd(aBuffer + aBufferLength) , mBufferLength(aBufferLength) { -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE for (uint8_t priority = 0; priority < kNumPrios; priority++) { otMessageQueueInit(&mMessageQueue[priority]); @@ -59,9 +59,9 @@ NcpFrameBuffer::NcpFrameBuffer(uint8_t *aBuffer, uint16_t aBufferLength) Clear(); } -void NcpFrameBuffer::Clear(void) +void Buffer::Clear(void) { -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE otMessage *message; #endif @@ -84,7 +84,7 @@ void NcpFrameBuffer::Clear(void) mReadSegmentTail = mBuffer; mReadPointer = mBuffer; -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE mReadMessage = NULL; mReadMessageOffset = 0; mReadMessageTail = mMessageBuffer; @@ -96,7 +96,7 @@ void NcpFrameBuffer::Clear(void) otMessageQueueDequeue(&mWriteFrameMessageQueue, message); // Note that messages associated with current (unfinished) input frame - // are not yet owned by the `NcpFrameBuffer` and therefore should not + // are not yet owned by the `Buffer` and therefore should not // be freed. } @@ -111,13 +111,13 @@ void NcpFrameBuffer::Clear(void) #endif } -void NcpFrameBuffer::SetFrameAddedCallback(BufferCallback aFrameAddedCallback, void *aFrameAddedContext) +void Buffer::SetFrameAddedCallback(BufferCallback aFrameAddedCallback, void *aFrameAddedContext) { mFrameAddedCallback = aFrameAddedCallback; mFrameAddedContext = aFrameAddedContext; } -void NcpFrameBuffer::SetFrameRemovedCallback(BufferCallback aFrameRemovedCallback, void *aFrameRemovedContext) +void Buffer::SetFrameRemovedCallback(BufferCallback aFrameRemovedCallback, void *aFrameRemovedContext) { mFrameRemovedCallback = aFrameRemovedCallback; mFrameRemovedContext = aFrameRemovedContext; @@ -125,7 +125,7 @@ void NcpFrameBuffer::SetFrameRemovedCallback(BufferCallback aFrameRemovedCallbac // Returns an updated buffer pointer by moving forward/backward (based on `aDirection`) from `aBufPtr` by a given // offset. The resulting buffer pointer is ensured to stay within the `mBuffer` boundaries. -uint8_t *NcpFrameBuffer::GetUpdatedBufPtr(uint8_t *aBufPtr, uint16_t aOffset, Direction aDirection) const +uint8_t *Buffer::GetUpdatedBufPtr(uint8_t *aBufPtr, uint16_t aOffset, Direction aDirection) const { uint8_t *ptr = aBufPtr; @@ -160,7 +160,7 @@ uint8_t *NcpFrameBuffer::GetUpdatedBufPtr(uint8_t *aBufPtr, uint16_t aOffset, Di } // Gets the distance between two buffer pointers (adjusts for the wrap-around) given a direction (forward or backward). -uint16_t NcpFrameBuffer::GetDistance(const uint8_t *aStartPtr, const uint8_t *aEndPtr, Direction aDirection) const +uint16_t Buffer::GetDistance(const uint8_t *aStartPtr, const uint8_t *aEndPtr, Direction aDirection) const { size_t distance = 0; @@ -203,14 +203,14 @@ uint16_t NcpFrameBuffer::GetDistance(const uint8_t *aStartPtr, const uint8_t *aE } // Writes a uint16 value at the given buffer pointer (big-endian style). -void NcpFrameBuffer::WriteUint16At(uint8_t *aBufPtr, uint16_t aValue, Direction aDirection) +void Buffer::WriteUint16At(uint8_t *aBufPtr, uint16_t aValue, Direction aDirection) { *aBufPtr = (aValue >> 8); *GetUpdatedBufPtr(aBufPtr, 1, aDirection) = (aValue & 0xff); } // Reads a uint16 value at the given buffer pointer (big-endian style). -uint16_t NcpFrameBuffer::ReadUint16At(uint8_t *aBufPtr, Direction aDirection) +uint16_t Buffer::ReadUint16At(uint8_t *aBufPtr, Direction aDirection) { uint16_t value; @@ -221,7 +221,7 @@ uint16_t NcpFrameBuffer::ReadUint16At(uint8_t *aBufPtr, Direction aDirection) } // Appends a byte at the write tail and updates the tail, discards the frame if buffer gets full. -otError NcpFrameBuffer::InFrameAppend(uint8_t aByte) +otError Buffer::InFrameAppend(uint8_t aByte) { otError error = OT_ERROR_NONE; uint8_t *newTail; @@ -246,7 +246,7 @@ otError NcpFrameBuffer::InFrameAppend(uint8_t aByte) } // This method begins a new segment (if one is not already open). -otError NcpFrameBuffer::InFrameBeginSegment(void) +otError Buffer::InFrameBeginSegment(void) { otError error = OT_ERROR_NONE; uint16_t headerFlags = kSegmentHeaderNoFlag; @@ -274,7 +274,7 @@ exit: } // This function closes/ends the current segment. -void NcpFrameBuffer::InFrameEndSegment(uint16_t aSegmentHeaderFlags) +void Buffer::InFrameEndSegment(uint16_t aSegmentHeaderFlags) { uint16_t segmentLength; uint16_t header; @@ -303,9 +303,9 @@ void NcpFrameBuffer::InFrameEndSegment(uint16_t aSegmentHeaderFlags) } // This method discards the current frame being written. -void NcpFrameBuffer::InFrameDiscard(void) +void Buffer::InFrameDiscard(void) { -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE otMessage *message; #endif @@ -314,13 +314,13 @@ void NcpFrameBuffer::InFrameDiscard(void) // Move the write segment head and tail pointers back to frame start. mWriteSegmentHead = mWriteSegmentTail = mWriteFrameStart[mWriteDirection]; -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE while ((message = otMessageQueueGetHead(&mWriteFrameMessageQueue)) != NULL) { otMessageQueueDequeue(&mWriteFrameMessageQueue, message); // Note that messages associated with current (unfinished) input frame - // being discarded, are not yet owned by the `NcpFrameBuffer` and + // being discarded, are not yet owned by the `Buffer` and // therefore should not be freed. } #endif @@ -332,12 +332,12 @@ exit: } // Returns `true` if in middle of writing a frame with given priority. -bool NcpFrameBuffer::InFrameIsWriting(Priority aPriority) const +bool Buffer::InFrameIsWriting(Priority aPriority) const { return (mWriteDirection == static_cast(aPriority)); } -void NcpFrameBuffer::InFrameBegin(Priority aPriority) +void Buffer::InFrameBegin(Priority aPriority) { // Discard any previous unfinished frame. InFrameDiscard(); @@ -357,7 +357,7 @@ void NcpFrameBuffer::InFrameBegin(Priority aPriority) mWriteSegmentHead = mWriteSegmentTail = mWriteFrameStart[mWriteDirection]; } -otError NcpFrameBuffer::InFrameFeedByte(uint8_t aByte) +otError Buffer::InFrameFeedByte(uint8_t aByte) { otError error = OT_ERROR_NONE; @@ -372,7 +372,7 @@ exit: return error; } -otError NcpFrameBuffer::InFrameFeedData(const uint8_t *aDataBuffer, uint16_t aDataBufferLength) +otError Buffer::InFrameFeedData(const uint8_t *aDataBuffer, uint16_t aDataBufferLength) { otError error = OT_ERROR_NONE; @@ -391,8 +391,8 @@ exit: return error; } -#if OPENTHREAD_MTD || OPENTHREAD_FTD -otError NcpFrameBuffer::InFrameFeedMessage(otMessage *aMessage) +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE +otError Buffer::InFrameFeedMessage(otMessage *aMessage) { otError error = OT_ERROR_NONE; @@ -413,7 +413,7 @@ exit: } #endif -otError NcpFrameBuffer::InFrameGetPosition(WritePosition &aPosition) +otError Buffer::InFrameGetPosition(WritePosition &aPosition) { otError error = OT_ERROR_NONE; @@ -429,9 +429,7 @@ exit: return error; } -otError NcpFrameBuffer::InFrameOverwrite(const WritePosition &aPosition, - const uint8_t * aDataBuffer, - uint16_t aDataBufferLength) +otError Buffer::InFrameOverwrite(const WritePosition &aPosition, const uint8_t *aDataBuffer, uint16_t aDataBufferLength) { otError error = OT_ERROR_NONE; uint8_t *bufPtr; @@ -462,7 +460,7 @@ exit: return error; } -uint16_t NcpFrameBuffer::InFrameGetDistance(const WritePosition &aPosition) const +uint16_t Buffer::InFrameGetDistance(const WritePosition &aPosition) const { uint16_t distance = 0; uint16_t segmentLength; @@ -481,7 +479,7 @@ exit: return distance; } -otError NcpFrameBuffer::InFrameReset(const WritePosition &aPosition) +otError Buffer::InFrameReset(const WritePosition &aPosition) { otError error = OT_ERROR_NONE; uint16_t segmentLength; @@ -500,9 +498,9 @@ exit: return error; } -otError NcpFrameBuffer::InFrameEnd(void) +otError Buffer::InFrameEnd(void) { -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE otMessage *message; #endif otError error = OT_ERROR_NONE; @@ -518,7 +516,7 @@ otError NcpFrameBuffer::InFrameEnd(void) // Update the frame start pointer to current segment head to be ready for next frame. mWriteFrameStart[mWriteDirection] = mWriteSegmentHead; -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE // Move all the messages from the frame queue to the main queue. while ((message = otMessageQueueGetHead(&mWriteFrameMessageQueue)) != NULL) { @@ -538,22 +536,22 @@ exit: return error; } -NcpFrameBuffer::FrameTag NcpFrameBuffer::InFrameGetLastTag(void) const +Buffer::FrameTag Buffer::InFrameGetLastTag(void) const { return mWriteFrameTag; } -bool NcpFrameBuffer::HasFrame(Priority aPriority) const +bool Buffer::HasFrame(Priority aPriority) const { return mReadFrameStart[aPriority] != mWriteFrameStart[aPriority]; } -bool NcpFrameBuffer::IsEmpty(void) const +bool Buffer::IsEmpty(void) const { return !HasFrame(kPriorityHigh) && !HasFrame(kPriorityLow); } -void NcpFrameBuffer::OutFrameSelectReadDirection(void) +void Buffer::OutFrameSelectReadDirection(void) { if (mReadState == kReadStateNotActive) { @@ -562,7 +560,7 @@ void NcpFrameBuffer::OutFrameSelectReadDirection(void) } // Start/Prepare a new segment for reading. -otError NcpFrameBuffer::OutFramePrepareSegment(void) +otError Buffer::OutFramePrepareSegment(void) { otError error = OT_ERROR_NONE; uint16_t header; @@ -601,7 +599,7 @@ otError NcpFrameBuffer::OutFramePrepareSegment(void) ExitNow(); } -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE // No data in this segment, prepare any appended/associated message of this segment. if (OutFramePrepareMessage() == OT_ERROR_NONE) { @@ -622,10 +620,10 @@ exit: return error; } -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE // This method prepares an associated message in current segment and fills the message buffer. It returns // ThreadError_NotFound if there is no message or if the message has no content. -otError NcpFrameBuffer::OutFramePrepareMessage(void) +otError Buffer::OutFramePrepareMessage(void) { otError error = OT_ERROR_NONE; uint16_t header; @@ -657,7 +655,7 @@ exit: // This method fills content from current message into the message buffer. It returns OT_ERROR_NOT_FOUND if no more // content in the current message. -otError NcpFrameBuffer::OutFrameFillMessageBuffer(void) +otError Buffer::OutFrameFillMessageBuffer(void) { otError error = OT_ERROR_NONE; int readLength; @@ -682,9 +680,9 @@ otError NcpFrameBuffer::OutFrameFillMessageBuffer(void) exit: return error; } -#endif // #if OPENTHREAD_MTD || OPENTHREAD_FTD +#endif // #if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE -otError NcpFrameBuffer::OutFrameBegin(void) +otError Buffer::OutFrameBegin(void) { otError error = OT_ERROR_NONE; @@ -695,7 +693,7 @@ otError NcpFrameBuffer::OutFrameBegin(void) // Move the segment head and tail to start of frame. mReadSegmentHead = mReadSegmentTail = mReadFrameStart[mReadDirection]; -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE mReadMessage = NULL; #endif @@ -706,12 +704,12 @@ exit: return error; } -bool NcpFrameBuffer::OutFrameHasEnded(void) +bool Buffer::OutFrameHasEnded(void) { return (mReadState == kReadStateDone) || (mReadState == kReadStateNotActive); } -uint8_t NcpFrameBuffer::OutFrameReadByte(void) +uint8_t Buffer::OutFrameReadByte(void) { otError error; uint8_t retval = kReadByteAfterFrameHasEnded; @@ -737,7 +735,7 @@ uint8_t NcpFrameBuffer::OutFrameReadByte(void) // Check if at end of current segment. if (mReadPointer == mReadSegmentTail) { -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE // Prepare any message associated with this segment. error = OutFramePrepareMessage(); #else @@ -754,7 +752,7 @@ uint8_t NcpFrameBuffer::OutFrameReadByte(void) break; case kReadStateInMessage: -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE // Read a byte from current read pointer and move the read pointer by 1 byte. retval = *mReadPointer; mReadPointer++; @@ -778,7 +776,7 @@ uint8_t NcpFrameBuffer::OutFrameReadByte(void) return retval; } -uint16_t NcpFrameBuffer::OutFrameRead(uint16_t aReadLength, uint8_t *aDataBuffer) +uint16_t Buffer::OutFrameRead(uint16_t aReadLength, uint8_t *aDataBuffer) { uint16_t bytesRead = 0; @@ -790,7 +788,7 @@ uint16_t NcpFrameBuffer::OutFrameRead(uint16_t aReadLength, uint8_t *aDataBuffer return bytesRead; } -otError NcpFrameBuffer::OutFrameRemove(void) +otError Buffer::OutFrameRemove(void) { otError error = OT_ERROR_NONE; uint8_t *bufPtr; @@ -825,7 +823,7 @@ otError NcpFrameBuffer::OutFrameRemove(void) } } -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE // If current segment has an appended message, remove it from message queue and free it. if (header & kSegmentHeaderMessageIndicatorFlag) { @@ -865,7 +863,7 @@ exit: return error; } -void NcpFrameBuffer::UpdateReadWriteStartPointers(void) +void Buffer::UpdateReadWriteStartPointers(void) { // If there is no fully written high priority frame, and not in middle of writing a new frame either. if (!HasFrame(kPriorityHigh) && !InFrameIsWriting(kPriorityHigh)) @@ -888,13 +886,13 @@ exit: return; } -uint16_t NcpFrameBuffer::OutFrameGetLength(void) +uint16_t Buffer::OutFrameGetLength(void) { uint16_t frameLength = 0; uint16_t header; uint8_t *bufPtr; uint8_t numSegments; -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE otMessage *message = NULL; #endif @@ -925,7 +923,7 @@ uint16_t NcpFrameBuffer::OutFrameGetLength(void) } } -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE // If current segment has an associated message, add its length to frame length. if (header & kSegmentHeaderMessageIndicatorFlag) { @@ -962,7 +960,7 @@ exit: return frameLength; } -NcpFrameBuffer::FrameTag NcpFrameBuffer::OutFrameGetTag(void) +Buffer::FrameTag Buffer::OutFrameGetTag(void) { OutFrameSelectReadDirection(); @@ -972,5 +970,5 @@ NcpFrameBuffer::FrameTag NcpFrameBuffer::OutFrameGetTag(void) return IsEmpty() ? kInvalidTag : mReadFrameStart[mReadDirection]; } -} // namespace Ncp +} // namespace Spinel } // namespace ot diff --git a/src/ncp/ncp_buffer.hpp b/src/spinel/spinel_buffer.hpp similarity index 95% rename from src/ncp/ncp_buffer.hpp rename to src/spinel/spinel_buffer.hpp index 8b63fdf6f..c1de00775 100644 --- a/src/ncp/ncp_buffer.hpp +++ b/src/spinel/spinel_buffer.hpp @@ -33,25 +33,25 @@ #ifndef NCP_FRAME_BUFFER_HPP_ #define NCP_FRAME_BUFFER_HPP_ -#include "openthread-core-config.h" +#include "openthread-spinel-config.h" #include namespace ot { -namespace Ncp { +namespace Spinel { /** - * This class implements a buffer/queue for storing NCP frames. + * This class implements a buffer/queue for storing Ncp frames. * * A frame can consist of a sequence of data bytes and/or the content of an `otMessage` or a combination of the two. - * `NcpFrameBuffer` implements priority FIFO logic for storing and reading frames. Two priority levels of high and low + * `Buffer` implements priority FIFO logic for storing and reading frames. Two priority levels of high and low * are supported. Within same priority level first-in-first-out order is preserved. High priority frames are read * ahead of any low priority ones. * */ -class NcpFrameBuffer +class Buffer { - friend class SpinelEncoder; + friend class Encoder; public: /** @@ -67,7 +67,7 @@ public: /** * Defines the (abstract) frame tag type. The tag is a unique value (within currently queued frames) associated - * with a frame in the `NcpFrameBuffer`. Frame tags can be compared with one another using operator `==`. + * with a frame in the `Buffer`. Frame tags can be compared with one another using operator `==`. * */ typedef const void *FrameTag; @@ -81,7 +81,7 @@ public: /** * Defines the structure to hold a write position for an input frame (frame being written). * - * It should be considered as an opaque data structure to users of `NcpFrameBuffer`. + * It should be considered as an opaque data structure to users of `Buffer`. * */ struct WritePosition @@ -101,20 +101,20 @@ public: uint8_t *mPosition; //< Pointer into buffer corresponding to saved write position. uint8_t *mSegmentHead; //< Pointer to segment head. - friend class NcpFrameBuffer; + friend class Buffer; }; /** - * Defines a function pointer callback which is invoked to inform a change in `NcpFrameBuffer` either when a new - * frame is added/written to `NcpFrameBuffer` or when a frame is removed from `NcpFrameBuffer`. + * Defines a function pointer callback which is invoked to inform a change in `Buffer` either when a new + * frame is added/written to `Buffer` or when a frame is removed from `Buffer`. * * @param[in] aContext A pointer to arbitrary context information. * @param[in] aTag The tag associated with the frame which is added or removed. * @param[in] aPriority The priority of frame. - * @param[in] aNcpFrameBuffer A pointer to the `NcpFrameBuffer`. + * @param[in] aBuffer A pointer to the `Buffer`. * */ - typedef void (*BufferCallback)(void *aContext, FrameTag aTag, Priority aPriority, NcpFrameBuffer *aNcpFrameBuffer); + typedef void (*BufferCallback)(void *aContext, FrameTag aTag, Priority aPriority, Buffer *aBuffer); /** * This constructor initializes an NCP frame buffer. @@ -123,7 +123,7 @@ public: * @param[in] aBufferLength The buffer size (in bytes). * */ - NcpFrameBuffer(uint8_t *aBuffer, uint16_t aBufferLength); + Buffer(uint8_t *aBuffer, uint16_t aBufferLength); /** * This method clears the NCP frame buffer. All the frames are cleared/removed. @@ -201,7 +201,7 @@ public: */ otError InFrameFeedData(const uint8_t *aDataBuffer, uint16_t aDataBufferLength); -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE /** * This method adds a message to the current input frame. * @@ -211,7 +211,7 @@ public: * If no buffer space is available, this method will discard and clear the frame and return error status * `OT_ERROR_NO_BUFS`. * - * The ownership of the passed-in message @p aMessage changes to `NcpFrameBuffer` ONLY when the entire frame is + * The ownership of the passed-in message @p aMessage changes to `Buffer` ONLY when the entire frame is * successfully finished (i.e., with a successful call to `InFrameEnd()` for the current input frame), and in this * case the `otMessage` instance will be freed once the frame is removed (using `OutFrameRemove()`) from NCP buffer. * However, if the input frame gets discarded before it is finished (e.g., running out of buffer space), the @@ -318,7 +318,7 @@ public: /** * This method returns the tag assigned to last successfully written/added frame to NcpBuffer (i.e., last input * frame for which `InFrameEnd()` was called and returned success status). The tag is a unique value (within - * currently queued frames) associated with a frame in the `NcpFrameBuffer`. The tag can be used to identify the + * currently queued frames) associated with a frame in the `Buffer`. The tag can be used to identify the * same frame when it is read and removed from the NcpBuffer. Tags can be compared using operator `==`. * * @returns The tag of the last successfully written frame, or `kInvalidTag` if no frame is written so far. @@ -445,10 +445,10 @@ public: private: /* - * `NcpFrameBuffer` Implementation + * `Buffer` Implementation * ------------------------------- * - * `NcpFrameBuffer` internally stores a frame as a sequence of data segments. Each segment stores a portion of + * `Buffer` internally stores a frame as a sequence of data segments. Each segment stores a portion of * frame. The data segments are stored in the main buffer `mBuffer`. `mBuffer` is utilized as a circular buffer. * The content of messages (which are added using `InFrameFeedMessage()`) are not directly copied in the `mBuffer` @@ -491,7 +491,7 @@ private: * Segment #1 Header Segment #2 Header * * - * `NcpFrameBuffer` uses the `mBuffer` as a circular/ring buffer. To support two frame priorities the buffer is + * `Buffer` uses the `mBuffer` as a circular/ring buffer. To support two frame priorities the buffer is * divided into two high-priority and low-priority regions. The high priority frames are stored in buffer in * backward direction while the low-priority frames use the buffer in forward direction. This model ensures the * available buffer space is utilized efficiently between all frame types. @@ -515,7 +515,7 @@ private: * When frames are removed, if possible, the `mReadFrameStart` and `mWriteFrameStart` pointers of the two priority * levels are moved closer to avoid gaps. * - * For an output frame (frame being read), NcpFrameBuffer maintains a `ReadState` along with a set of pointers + * For an output frame (frame being read), Buffer maintains a `ReadState` along with a set of pointers * into the buffer: * * mReadFrameStart[priority]: Start of the current/front frame. @@ -615,7 +615,7 @@ private: otError OutFramePrepareSegment(void); void OutFrameMoveToNextSegment(void); -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE otError OutFramePrepareMessage(void); otError OutFrameFillMessageBuffer(void); #endif @@ -644,7 +644,7 @@ private: uint8_t *mReadSegmentTail; // Pointer to end of current segment in the frame being read. uint8_t *mReadPointer; // Pointer to next byte to read (either in segment or in msg buffer). -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE otMessageQueue mWriteFrameMessageQueue; // Message queue for the current frame being written. otMessageQueue mMessageQueue[kNumPrios]; // Main message queues. otMessage * mReadMessage; // Current Message in the frame being read. @@ -654,7 +654,7 @@ private: #endif }; -} // namespace Ncp +} // namespace Spinel } // namespace ot #endif // NCP_FRAME_BUFFER_HPP_ diff --git a/src/ncp/spinel_decoder.cpp b/src/spinel/spinel_decoder.cpp similarity index 85% rename from src/ncp/spinel_decoder.cpp rename to src/spinel/spinel_decoder.cpp index 43f161839..0c26259e4 100644 --- a/src/ncp/spinel_decoder.cpp +++ b/src/spinel/spinel_decoder.cpp @@ -30,17 +30,15 @@ * This file implements a spinel decoder. */ -#include - #include "spinel_decoder.hpp" #include "common/code_utils.hpp" #include "common/string.hpp" namespace ot { -namespace Ncp { +namespace Spinel { -SpinelDecoder::SpinelDecoder(void) +Decoder::Decoder(void) : mFrame(NULL) , mLength(0) , mIndex(0) @@ -52,7 +50,7 @@ SpinelDecoder::SpinelDecoder(void) { } -void SpinelDecoder::Init(const uint8_t *aFrame, uint16_t aLength) +void Decoder::Init(const uint8_t *aFrame, uint16_t aLength) { mFrame = aFrame; mLength = (mFrame != NULL) ? aLength : 0; @@ -61,7 +59,7 @@ void SpinelDecoder::Init(const uint8_t *aFrame, uint16_t aLength) ClearSavedPosition(); } -void SpinelDecoder::Reset(void) +void Decoder::Reset(void) { mIndex = 0; mEnd = mLength; @@ -69,7 +67,7 @@ void SpinelDecoder::Reset(void) ClearSavedPosition(); } -otError SpinelDecoder::ReadBool(bool &aBool) +otError Decoder::ReadBool(bool &aBool) { otError error = OT_ERROR_NONE; uint8_t byte; @@ -94,7 +92,7 @@ exit: return error; } -otError SpinelDecoder::ReadUint8(uint8_t &aUint8) +otError Decoder::ReadUint8(uint8_t &aUint8) { otError error = OT_ERROR_NONE; @@ -106,7 +104,7 @@ exit: return error; } -otError SpinelDecoder::ReadInt8(int8_t &aInt8) +otError Decoder::ReadInt8(int8_t &aInt8) { otError error = OT_ERROR_NONE; uint8_t byte; @@ -118,7 +116,7 @@ exit: return error; } -otError SpinelDecoder::ReadUint16(uint16_t &aUint16) +otError Decoder::ReadUint16(uint16_t &aUint16) { otError error = OT_ERROR_NONE; @@ -132,7 +130,7 @@ exit: return error; } -otError SpinelDecoder::ReadInt16(int16_t &aInt16) +otError Decoder::ReadInt16(int16_t &aInt16) { otError error = OT_ERROR_NONE; uint16_t u16; @@ -144,7 +142,7 @@ exit: return error; } -otError SpinelDecoder::ReadUint32(uint32_t &aUint32) +otError Decoder::ReadUint32(uint32_t &aUint32) { otError error = OT_ERROR_NONE; @@ -159,7 +157,7 @@ exit: return error; } -otError SpinelDecoder::ReadInt32(int32_t &aInt32) +otError Decoder::ReadInt32(int32_t &aInt32) { otError error = OT_ERROR_NONE; uint32_t u32; @@ -171,7 +169,7 @@ exit: return error; } -otError SpinelDecoder::ReadUint64(uint64_t &aUint64) +otError Decoder::ReadUint64(uint64_t &aUint64) { otError error = OT_ERROR_NONE; @@ -188,7 +186,7 @@ exit: return error; } -otError SpinelDecoder::ReadInt64(int64_t &aInt64) +otError Decoder::ReadInt64(int64_t &aInt64) { otError error = OT_ERROR_NONE; uint64_t u64; @@ -200,7 +198,7 @@ exit: return error; } -otError SpinelDecoder::ReadUintPacked(unsigned int &aUint) +otError Decoder::ReadUintPacked(unsigned int &aUint) { otError error = OT_ERROR_NONE; spinel_ssize_t parsedLen; @@ -217,7 +215,7 @@ exit: } // Reads an item of given size and updates the pointer `aPtr`. -otError SpinelDecoder::ReadItem(const uint8_t **aPtr, uint16_t aSize) +otError Decoder::ReadItem(const uint8_t **aPtr, uint16_t aSize) { otError error = OT_ERROR_NONE; @@ -231,7 +229,7 @@ exit: return error; } -otError SpinelDecoder::ReadIp6Address(spinel_ipv6addr_t &aIp6Addr) +otError Decoder::ReadIp6Address(spinel_ipv6addr_t &aIp6Addr) { otError error = OT_ERROR_NONE; const spinel_ipv6addr_t *ipv6AddrPtr; @@ -243,7 +241,7 @@ exit: return error; } -otError SpinelDecoder::ReadIp6Address(otIp6Address &aIp6Addr) +otError Decoder::ReadIp6Address(otIp6Address &aIp6Addr) { otError error = OT_ERROR_NONE; const otIp6Address *ipv6AddrPtr; @@ -255,7 +253,7 @@ exit: return error; } -otError SpinelDecoder::ReadEui64(spinel_eui64_t &aEui64) +otError Decoder::ReadEui64(spinel_eui64_t &aEui64) { otError error = OT_ERROR_NONE; const spinel_eui64_t *eui64Ptr; @@ -267,7 +265,7 @@ exit: return error; } -otError SpinelDecoder::ReadEui64(otExtAddress &aEui64) +otError Decoder::ReadEui64(otExtAddress &aEui64) { otError error = OT_ERROR_NONE; const otExtAddress *eui64Ptr; @@ -279,7 +277,7 @@ exit: return error; } -otError SpinelDecoder::ReadEui48(spinel_eui48_t &aEui48) +otError Decoder::ReadEui48(spinel_eui48_t &aEui48) { otError error = OT_ERROR_NONE; const spinel_eui48_t *eui48Ptr; @@ -291,7 +289,7 @@ exit: return error; } -otError SpinelDecoder::ReadUtf8(const char *&aUtf8) +otError Decoder::ReadUtf8(const char *&aUtf8) { otError error = OT_ERROR_NONE; size_t len; @@ -311,14 +309,14 @@ exit: return error; } -otError SpinelDecoder::ReadData(const uint8_t *&aData, uint16_t &aDataLen) +otError Decoder::ReadData(const uint8_t *&aData, uint16_t &aDataLen) { aDataLen = mEnd - mIndex; return ReadItem(&aData, aDataLen); } -otError SpinelDecoder::ReadDataWithLen(const uint8_t *&aData, uint16_t &aDataLen) +otError Decoder::ReadDataWithLen(const uint8_t *&aData, uint16_t &aDataLen) { otError error = OT_ERROR_NONE; uint16_t len; @@ -331,7 +329,7 @@ exit: return error; } -otError SpinelDecoder::OpenStruct(void) +otError Decoder::OpenStruct(void) { otError error = OT_ERROR_NONE; uint16_t structLen; @@ -349,7 +347,7 @@ exit: return error; } -otError SpinelDecoder::CloseStruct(void) +otError Decoder::CloseStruct(void) { otError error = OT_ERROR_NONE; @@ -373,14 +371,14 @@ exit: return error; } -void SpinelDecoder::SavePosition(void) +void Decoder::SavePosition(void) { mSavedIndex = mIndex; mSavedEnd = mEnd; mSavedNumOpenStructs = mNumOpenStructs; } -otError SpinelDecoder::ResetToSaved(void) +otError Decoder::ResetToSaved(void) { otError error = OT_ERROR_NONE; @@ -394,5 +392,5 @@ exit: return error; } -} // namespace Ncp +} // namespace Spinel } // namespace ot diff --git a/src/ncp/spinel_decoder.hpp b/src/spinel/spinel_decoder.hpp similarity index 98% rename from src/ncp/spinel_decoder.hpp rename to src/spinel/spinel_decoder.hpp index 8267e77ef..77328d70b 100644 --- a/src/ncp/spinel_decoder.hpp +++ b/src/spinel/spinel_decoder.hpp @@ -33,22 +33,21 @@ #ifndef SPINEL_DECODER_HPP_ #define SPINEL_DECODER_HPP_ -#include +#include "openthread-spinel-config.h" #include #include -#include "openthread-core-config.h" -#include "ncp/spinel.h" +#include "spinel.h" namespace ot { -namespace Ncp { +namespace Spinel { /** * This class defines a spinel decoder. * */ -class SpinelDecoder +class Decoder { public: enum @@ -57,10 +56,10 @@ public: }; /** - * This constructor initializes a `SpinelDecoder` object. + * This constructor initializes a `Decoder` object. * */ - SpinelDecoder(void); + Decoder(void); /** * This method initializes the decoder to start decoding a new frame. @@ -586,7 +585,7 @@ private: uint16_t mPrevEnd[kMaxNestedStructs]; }; -} // namespace Ncp +} // namespace Spinel } // namespace ot #endif // SPINEL_DECODER_HPP_ diff --git a/src/ncp/spinel_encoder.cpp b/src/spinel/spinel_encoder.cpp similarity index 86% rename from src/ncp/spinel_encoder.cpp rename to src/spinel/spinel_encoder.cpp index 332a04b57..91a9ec36c 100644 --- a/src/ncp/spinel_encoder.cpp +++ b/src/spinel/spinel_encoder.cpp @@ -37,16 +37,16 @@ #include "common/code_utils.hpp" namespace ot { -namespace Ncp { +namespace Spinel { -otError SpinelEncoder::BeginFrame(NcpFrameBuffer::Priority aPriority) +otError Encoder::BeginFrame(Spinel::Buffer::Priority aPriority) { mNumOpenStructs = 0; mNcpBuffer.InFrameBegin(aPriority); return OT_ERROR_NONE; } -otError SpinelEncoder::BeginFrame(uint8_t aHeader, unsigned int aCommand) +otError Encoder::BeginFrame(uint8_t aHeader, unsigned int aCommand) { otError error = OT_ERROR_NONE; @@ -54,11 +54,11 @@ otError SpinelEncoder::BeginFrame(uint8_t aHeader, unsigned int aCommand) if (SPINEL_HEADER_GET_TID(aHeader) != 0) { - SuccessOrExit(error = BeginFrame(NcpFrameBuffer::kPriorityHigh)); + SuccessOrExit(error = BeginFrame(Spinel::Buffer::kPriorityHigh)); } else { - SuccessOrExit(error = BeginFrame(NcpFrameBuffer::kPriorityLow)); + SuccessOrExit(error = BeginFrame(Spinel::Buffer::kPriorityLow)); } SuccessOrExit(error = WriteUint8(aHeader)); @@ -68,7 +68,7 @@ exit: return error; } -otError SpinelEncoder::BeginFrame(uint8_t aHeader, unsigned int aCommand, spinel_prop_key_t aKey) +otError Encoder::BeginFrame(uint8_t aHeader, unsigned int aCommand, spinel_prop_key_t aKey) { otError error = OT_ERROR_NONE; @@ -87,7 +87,7 @@ exit: return error; } -otError SpinelEncoder::OverwriteWithLastStatusError(spinel_status_t aStatus) +otError Encoder::OverwriteWithLastStatusError(spinel_status_t aStatus) { otError error = OT_ERROR_NONE; @@ -99,7 +99,7 @@ exit: return error; } -otError SpinelEncoder::EndFrame(void) +otError Encoder::EndFrame(void) { otError error = OT_ERROR_NONE; @@ -114,7 +114,7 @@ exit: return error; } -otError SpinelEncoder::WriteUint16(uint16_t aUint16) +otError Encoder::WriteUint16(uint16_t aUint16) { otError error = OT_ERROR_NONE; @@ -125,7 +125,7 @@ exit: return error; } -otError SpinelEncoder::WriteUint32(uint32_t aUint32) +otError Encoder::WriteUint32(uint32_t aUint32) { otError error = OT_ERROR_NONE; @@ -138,7 +138,7 @@ exit: return error; } -otError SpinelEncoder::WriteUint64(uint64_t aUint64) +otError Encoder::WriteUint64(uint64_t aUint64) { otError error = OT_ERROR_NONE; @@ -155,7 +155,7 @@ exit: return error; } -otError SpinelEncoder::WriteUintPacked(unsigned int aUint) +otError Encoder::WriteUintPacked(unsigned int aUint) { uint8_t buffer[6]; spinel_ssize_t len; @@ -165,7 +165,7 @@ otError SpinelEncoder::WriteUintPacked(unsigned int aUint) return WriteData(buffer, static_cast(len)); } -otError SpinelEncoder::WriteDataWithLen(const uint8_t *aData, uint16_t aDataLen) +otError Encoder::WriteDataWithLen(const uint8_t *aData, uint16_t aDataLen) { otError error = OT_ERROR_NONE; @@ -176,7 +176,7 @@ exit: return error; } -otError SpinelEncoder::WriteUtf8(const char *aUtf8) +otError Encoder::WriteUtf8(const char *aUtf8) { otError error; size_t len = strlen(aUtf8); @@ -193,7 +193,7 @@ exit: return error; } -otError SpinelEncoder::OpenStruct(void) +otError Encoder::OpenStruct(void) { otError error = OT_ERROR_NONE; @@ -210,7 +210,7 @@ exit: return error; } -otError SpinelEncoder::CloseStruct(void) +otError Encoder::CloseStruct(void) { otError error = OT_ERROR_NONE; uint16_t len; @@ -234,7 +234,7 @@ exit: return error; } -otError SpinelEncoder::SavePosition(void) +otError Encoder::SavePosition(void) { otError error = OT_ERROR_NONE; @@ -245,7 +245,7 @@ exit: return error; } -otError SpinelEncoder::ResetToSaved(void) +otError Encoder::ResetToSaved(void) { otError error = OT_ERROR_NONE; @@ -256,7 +256,7 @@ exit: return error; } -otError SpinelEncoder::WritePacked(const char *aPackFormat, ...) +otError Encoder::WritePacked(const char *aPackFormat, ...) { uint8_t buf[kPackFormatBufferSize]; otError error = OT_ERROR_NONE; @@ -276,7 +276,7 @@ exit: return error; } -otError SpinelEncoder::WriteVPacked(const char *aPackFormat, va_list aArgs) +otError Encoder::WriteVPacked(const char *aPackFormat, va_list aArgs) { uint8_t buf[kPackFormatBufferSize]; otError error = OT_ERROR_NONE; @@ -291,5 +291,5 @@ exit: return error; } -} // namespace Ncp +} // namespace Spinel } // namespace ot diff --git a/src/ncp/spinel_encoder.hpp b/src/spinel/spinel_encoder.hpp similarity index 97% rename from src/ncp/spinel_encoder.hpp rename to src/spinel/spinel_encoder.hpp index 45654966c..f0487d856 100644 --- a/src/ncp/spinel_encoder.hpp +++ b/src/spinel/spinel_encoder.hpp @@ -33,33 +33,32 @@ #ifndef SPINEL_ENCODER_HPP_ #define SPINEL_ENCODER_HPP_ -#include "openthread-core-config.h" +#include "openthread-spinel-config.h" #include #include #include -#include "openthread-core-config.h" -#include "ncp/ncp_buffer.hpp" -#include "ncp/spinel.h" +#include "spinel.h" +#include "spinel_buffer.hpp" namespace ot { -namespace Ncp { +namespace Spinel { /** * This class defines a spinel encoder. * */ -class SpinelEncoder +class Encoder { public: /** - * This constructor initializes a `SpinelEncoder` object. + * This constructor initializes a `Encoder` object. * - * @param[in] aNcpBuffer A reference to a `NcpFrameBuffer` where the frames are written. + * @param[in] aNcpBuffer A reference to a `Spinel::Buffer` where the frames are written. * */ - explicit SpinelEncoder(NcpFrameBuffer &aNcpBuffer) + explicit Encoder(Spinel::Buffer &aNcpBuffer) : mNcpBuffer(aNcpBuffer) , mNumOpenStructs(0) , mSavedNumOpenStructs(0) @@ -79,7 +78,7 @@ public: * @retval OT_ERROR_NO_BUFS Insufficient buffer space available to start a new frame. * */ - otError BeginFrame(NcpFrameBuffer::Priority aPriority); + otError BeginFrame(Spinel::Buffer::Priority aPriority); /** * This method begins a new spinel command frame to be added/written to the frame buffer. @@ -541,7 +540,7 @@ public: */ otError WriteDataWithLen(const uint8_t *aData, uint16_t aDataLen); -#if OPENTHREAD_MTD || OPENTHREAD_FTD +#if OPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE /** * This method adds a message to the current input frame. * @@ -551,10 +550,10 @@ public: * If no buffer space is available, this method will discard and clear the frame and return error status * `OT_ERROR_NO_BUFS`. * - * The ownership of the passed-in message @p aMessage changes to underlying `NcpFrameBuffer` ONLY when the entire + * The ownership of the passed-in message @p aMessage changes to underlying `Spinel::Buffer` ONLY when the entire * frame is successfully finished (i.e., with a successful call to `EndFrame()` for the current frame being * written), and in this case the `otMessage` instance will be freed once the frame is removed from the - * `NcpFrameBuffer`. However, if the frame gets discarded before it is finished (e.g., running out of buffer space), + * `Spinel::Buffer`. However, if the frame gets discarded before it is finished (e.g., running out of buffer space), * the `otMessage` instance remains unchanged. * * @param[in] aMessage A message to be added to current frame. @@ -685,15 +684,15 @@ private: kMaxNestedStructs = 4, ///< Maximum number of nested structs. }; - NcpFrameBuffer & mNcpBuffer; - NcpFrameBuffer::WritePosition mStructPosition[kMaxNestedStructs]; + Spinel::Buffer & mNcpBuffer; + Spinel::Buffer::WritePosition mStructPosition[kMaxNestedStructs]; uint8_t mNumOpenStructs; uint8_t mSavedNumOpenStructs; - NcpFrameBuffer::WritePosition mSavedPosition; + Spinel::Buffer::WritePosition mSavedPosition; }; -} // namespace Ncp +} // namespace Spinel } // namespace ot #endif // SPINEL_ENCODER_HPP_ diff --git a/src/ncp/spinel_encrypter.hpp b/src/spinel/spinel_encrypter.hpp similarity index 100% rename from src/ncp/spinel_encrypter.hpp rename to src/spinel/spinel_encrypter.hpp diff --git a/src/ncp/spinel_platform.h b/src/spinel/spinel_platform.h similarity index 98% rename from src/ncp/spinel_platform.h rename to src/spinel/spinel_platform.h index d0263cb31..744feff4a 100644 --- a/src/ncp/spinel_platform.h +++ b/src/spinel/spinel_platform.h @@ -49,8 +49,6 @@ * */ -#include "openthread-core-config.h" - #include #include #include diff --git a/tests/unit/Makefile.am b/tests/unit/Makefile.am index 2e1860598..8764e9710 100644 --- a/tests/unit/Makefile.am +++ b/tests/unit/Makefile.am @@ -53,6 +53,7 @@ AM_CPPFLAGS = \ -DOPENTHREAD_FTD=1 \ -DOPENTHREAD_MTD=0 \ -DOPENTHREAD_RADIO=0 \ + -DOPENTHREAD_SPINEL_CONFIG_OPENTHREAD_MESSAGE_ENABLE=1 \ -I$(top_srcdir)/include \ -I$(top_srcdir)/src \ -I$(top_srcdir)/src/core \ @@ -128,7 +129,7 @@ check_PROGRAMS += \ if OPENTHREAD_ENABLE_NCP check_PROGRAMS += \ test-hdlc \ - test-ncp-buffer \ + test-spinel-buffer \ test-spinel-decoder \ test-spinel-encoder \ $(NULL) @@ -202,8 +203,8 @@ test_message_SOURCES = $(COMMON_SOURCES) test_message.cpp test_message_queue_LDADD = $(COMMON_LDADD) test_message_queue_SOURCES = $(COMMON_SOURCES) test_message_queue.cpp -test_ncp_buffer_LDADD = $(COMMON_LDADD) -test_ncp_buffer_SOURCES = $(COMMON_SOURCES) test_ncp_buffer.cpp +test_spinel_buffer_LDADD = $(COMMON_LDADD) +test_spinel_buffer_SOURCES = $(COMMON_SOURCES) test_spinel_buffer.cpp test_netif_LDADD = $(COMMON_LDADD) test_netif_SOURCES = $(COMMON_SOURCES) test_netif.cpp @@ -247,7 +248,7 @@ PRETTY_FILES = \ $(test_mac_frame_SOURCES) \ $(test_message_queue_SOURCES) \ $(test_message_SOURCES) \ - $(test_ncp_buffer_SOURCES) \ + $(test_spinel_buffer_SOURCES) \ $(test_netif_SOURCES) \ $(test_network_data_SOURCES) \ $(test_priority_queue_SOURCES) \ diff --git a/tests/unit/test_ncp_buffer.cpp b/tests/unit/test_spinel_buffer.cpp similarity index 83% rename from tests/unit/test_ncp_buffer.cpp rename to tests/unit/test_spinel_buffer.cpp index 354529011..7bc898d46 100644 --- a/tests/unit/test_ncp_buffer.cpp +++ b/tests/unit/test_spinel_buffer.cpp @@ -32,15 +32,15 @@ #include "common/instance.hpp" #include "common/message.hpp" #include "common/random.hpp" -#include "ncp/ncp_buffer.hpp" +#include "spinel/spinel_buffer.hpp" #include "test_platform.h" #include "test_util.hpp" namespace ot { -namespace Ncp { +namespace Spinel { -// This module implements unit-test for NcpFrameBuffer class. +// This module implements unit-test for Spinel::Buffer class. // Test related constants: enum @@ -78,10 +78,10 @@ enum kTestFrame4Size = sizeof(sOpenThreadText), }; -NcpFrameBuffer::FrameTag sTagHistoryArray[kNumPrios][kTagArraySize]; +Spinel::Buffer::FrameTag sTagHistoryArray[kNumPrios][kTagArraySize]; uint32_t sTagHistoryHead[kNumPrios] = {0}; uint32_t sTagHistoryTail[kNumPrios] = {0}; -NcpFrameBuffer::FrameTag sExpectedRemovedTag = NcpFrameBuffer::kInvalidTag; +Spinel::Buffer::FrameTag sExpectedRemovedTag = Spinel::Buffer::kInvalidTag; void ClearTagHistory(void) { @@ -91,7 +91,7 @@ void ClearTagHistory(void) } } -void AddTagToHistory(NcpFrameBuffer::FrameTag aTag, NcpFrameBuffer::Priority aPriority) +void AddTagToHistory(Spinel::Buffer::FrameTag aTag, Spinel::Buffer::Priority aPriority) { uint8_t priority = static_cast(aPriority); @@ -106,7 +106,7 @@ void AddTagToHistory(NcpFrameBuffer::FrameTag aTag, NcpFrameBuffer::Priority aPr "Ran out of space in `TagHistoryArray`, increase its size."); } -void VerifyAndRemoveTagFromHistory(NcpFrameBuffer::FrameTag aTag, NcpFrameBuffer::Priority aPriority) +void VerifyAndRemoveTagFromHistory(Spinel::Buffer::FrameTag aTag, Spinel::Buffer::Priority aPriority) { uint8_t priority = static_cast(aPriority); @@ -119,23 +119,23 @@ void VerifyAndRemoveTagFromHistory(NcpFrameBuffer::FrameTag aTag, NcpFrameBuffer sTagHistoryHead[priority] = 0; } - if (sExpectedRemovedTag != NcpFrameBuffer::kInvalidTag) + if (sExpectedRemovedTag != Spinel::Buffer::kInvalidTag) { VerifyOrQuit(sExpectedRemovedTag == aTag, "Removed tag does match the previous OutFrameGetTag()"); - sExpectedRemovedTag = NcpFrameBuffer::kInvalidTag; + sExpectedRemovedTag = Spinel::Buffer::kInvalidTag; } } void FrameAddedCallback(void * aContext, - NcpFrameBuffer::FrameTag aTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpBuffer) + Spinel::Buffer::FrameTag aTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aNcpBuffer) { CallbackContext *callbackContext = reinterpret_cast(aContext); - VerifyOrQuit(aNcpBuffer != NULL, "Null NcpFrameBuffer in the callback"); + VerifyOrQuit(aNcpBuffer != NULL, "Null Spinel::Buffer in the callback"); VerifyOrQuit(callbackContext != NULL, "Null context in the callback"); - VerifyOrQuit(aTag != NcpFrameBuffer::kInvalidTag, "Invalid tag in the callback"); + VerifyOrQuit(aTag != Spinel::Buffer::kInvalidTag, "Invalid tag in the callback"); VerifyOrQuit(aTag == aNcpBuffer->InFrameGetLastTag(), "InFrameGetLastTag() does not match the tag from callback"); AddTagToHistory(aTag, aPriority); @@ -144,15 +144,15 @@ void FrameAddedCallback(void * aContext, } void FrameRemovedCallback(void * aContext, - NcpFrameBuffer::FrameTag aTag, - NcpFrameBuffer::Priority aPriority, - NcpFrameBuffer * aNcpBuffer) + Spinel::Buffer::FrameTag aTag, + Spinel::Buffer::Priority aPriority, + Spinel::Buffer * aNcpBuffer) { CallbackContext *callbackContext = reinterpret_cast(aContext); - VerifyOrQuit(aNcpBuffer != NULL, "Null NcpFrameBuffer in the callback"); + VerifyOrQuit(aNcpBuffer != NULL, "Null Spinel::Buffer in the callback"); VerifyOrQuit(callbackContext != NULL, "Null context in the callback"); - VerifyOrQuit(aTag != NcpFrameBuffer::kInvalidTag, "Invalid tag in the callback"); + VerifyOrQuit(aTag != Spinel::Buffer::kInvalidTag, "Invalid tag in the callback"); VerifyAndRemoveTagFromHistory(aTag, aPriority); @@ -160,7 +160,7 @@ void FrameRemovedCallback(void * aContext, } // Reads bytes from the ncp buffer, and verifies that it matches with the given content buffer. -void ReadAndVerifyContent(NcpFrameBuffer &aNcpBuffer, const uint8_t *aContentBuffer, uint16_t aBufferLength) +void ReadAndVerifyContent(Spinel::Buffer &aNcpBuffer, const uint8_t *aContentBuffer, uint16_t aBufferLength) { while (aBufferLength--) { @@ -171,7 +171,7 @@ void ReadAndVerifyContent(NcpFrameBuffer &aNcpBuffer, const uint8_t *aContentBuf } } -void WriteTestFrame1(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPriority) +void WriteTestFrame1(Spinel::Buffer &aNcpBuffer, Spinel::Buffer::Priority aPriority) { Message * message; CallbackContext oldContext; @@ -192,7 +192,7 @@ void WriteTestFrame1(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPrior VerifyOrQuit(oldContext.mFrameRemovedCount == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -void VerifyAndRemoveFrame1(NcpFrameBuffer &aNcpBuffer) +void VerifyAndRemoveFrame1(Spinel::Buffer &aNcpBuffer) { CallbackContext oldContext = sContext; @@ -214,7 +214,7 @@ void VerifyAndRemoveFrame1(NcpFrameBuffer &aNcpBuffer) VerifyOrQuit(oldContext.mFrameRemovedCount + 1 == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -void WriteTestFrame2(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPriority) +void WriteTestFrame2(Spinel::Buffer &aNcpBuffer, Spinel::Buffer::Priority aPriority) { Message * message1; Message * message2; @@ -240,7 +240,7 @@ void WriteTestFrame2(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPrior VerifyOrQuit(oldContext.mFrameRemovedCount == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -void VerifyAndRemoveFrame2(NcpFrameBuffer &aNcpBuffer) +void VerifyAndRemoveFrame2(Spinel::Buffer &aNcpBuffer) { CallbackContext oldContext = sContext; @@ -260,7 +260,7 @@ void VerifyAndRemoveFrame2(NcpFrameBuffer &aNcpBuffer) VerifyOrQuit(oldContext.mFrameRemovedCount + 1 == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -void WriteTestFrame3(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPriority) +void WriteTestFrame3(Spinel::Buffer &aNcpBuffer, Spinel::Buffer::Priority aPriority) { Message * message1; CallbackContext oldContext = sContext; @@ -280,7 +280,7 @@ void WriteTestFrame3(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPrior VerifyOrQuit(oldContext.mFrameRemovedCount == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -void VerifyAndRemoveFrame3(NcpFrameBuffer &aNcpBuffer) +void VerifyAndRemoveFrame3(Spinel::Buffer &aNcpBuffer) { CallbackContext oldContext = sContext; @@ -298,7 +298,7 @@ void VerifyAndRemoveFrame3(NcpFrameBuffer &aNcpBuffer) VerifyOrQuit(oldContext.mFrameRemovedCount + 1 == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -void WriteTestFrame4(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPriority) +void WriteTestFrame4(Spinel::Buffer &aNcpBuffer, Spinel::Buffer::Priority aPriority) { CallbackContext oldContext = sContext; @@ -310,7 +310,7 @@ void WriteTestFrame4(NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPrior VerifyOrQuit(oldContext.mFrameRemovedCount == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -void VerifyAndRemoveFrame4(NcpFrameBuffer &aNcpBuffer) +void VerifyAndRemoveFrame4(Spinel::Buffer &aNcpBuffer) { CallbackContext oldContext = sContext; @@ -328,17 +328,17 @@ void VerifyAndRemoveFrame4(NcpFrameBuffer &aNcpBuffer) VerifyOrQuit(oldContext.mFrameRemovedCount + 1 == sContext.mFrameRemovedCount, "FrameRemovedCallback failed."); } -// This function implements the NcpFrameBuffer tests -void TestNcpFrameBuffer(void) +// This function implements the Spinel::Buffer tests +void TestBuffer(void) { unsigned i, j; uint8_t buffer[kTestBufferSize]; - NcpFrameBuffer ncpBuffer(buffer, kTestBufferSize); + Spinel::Buffer ncpBuffer(buffer, kTestBufferSize); Message * message; uint8_t readBuffer[16]; uint16_t readLen, readOffset; - NcpFrameBuffer::WritePosition pos1, pos2; + Spinel::Buffer::WritePosition pos1, pos2; sInstance = testInitInstance(); sMessagePool = &sInstance->Get(); @@ -360,18 +360,18 @@ void TestNcpFrameBuffer(void) printf("\nTest 1: Check initial buffer state"); VerifyOrQuit(ncpBuffer.IsEmpty() == true, "Not empty after init."); - VerifyOrQuit(ncpBuffer.InFrameGetLastTag() == NcpFrameBuffer::kInvalidTag, "Incorrect tag after init."); - VerifyOrQuit(ncpBuffer.OutFrameGetTag() == NcpFrameBuffer::kInvalidTag, "Incorrect OutFrameTag after init."); + VerifyOrQuit(ncpBuffer.InFrameGetLastTag() == Spinel::Buffer::kInvalidTag, "Incorrect tag after init."); + VerifyOrQuit(ncpBuffer.OutFrameGetTag() == Spinel::Buffer::kInvalidTag, "Incorrect OutFrameTag after init."); printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 2: Write and read a single frame"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); DumpBuffer("\nBuffer after frame1 (low priority)", buffer, kTestBufferSize); printf("\nFrameLen is %u", ncpBuffer.OutFrameGetLength()); VerifyAndRemoveFrame1(ncpBuffer); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); DumpBuffer("\nBuffer after frame1 (high priority)", buffer, kTestBufferSize); printf("\nFrameLen is %u", ncpBuffer.OutFrameGetLength()); VerifyAndRemoveFrame1(ncpBuffer); @@ -382,7 +382,7 @@ void TestNcpFrameBuffer(void) for (j = 0; j < kTestIterationAttemps; j++) { printf("*"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.IsEmpty() == false, "IsEmpty() is incorrect when buffer is non-empty"); VerifyAndRemoveFrame1(ncpBuffer); @@ -393,7 +393,7 @@ void TestNcpFrameBuffer(void) for (j = 0; j < kTestIterationAttemps; j++) { printf("*"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyOrQuit(ncpBuffer.IsEmpty() == false, "IsEmpty() is incorrect when buffer is non-empty"); VerifyAndRemoveFrame1(ncpBuffer); @@ -404,7 +404,7 @@ void TestNcpFrameBuffer(void) for (j = 0; j < kTestIterationAttemps; j++) { printf("*"); - WriteTestFrame1(ncpBuffer, ((j % 5) == 0) ? NcpFrameBuffer::kPriorityHigh : NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, ((j % 5) == 0) ? Spinel::Buffer::kPriorityHigh : Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.IsEmpty() == false, "IsEmpty() is incorrect when buffer is non-empty"); VerifyAndRemoveFrame1(ncpBuffer); @@ -416,10 +416,10 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 3: Multiple frames write and read (same priority)"); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); DumpBuffer("\nBuffer after multiple frames", buffer, kTestBufferSize); @@ -435,15 +435,15 @@ void TestNcpFrameBuffer(void) { printf("*"); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyAndRemoveFrame2(ncpBuffer); VerifyAndRemoveFrame3(ncpBuffer); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyAndRemoveFrame2(ncpBuffer); VerifyAndRemoveFrame2(ncpBuffer); @@ -457,52 +457,52 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 4: Multiple frames write and read (mixed priority)"); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame3(ncpBuffer); VerifyAndRemoveFrame2(ncpBuffer); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame4(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame4(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame3(ncpBuffer); VerifyAndRemoveFrame4(ncpBuffer); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame2(ncpBuffer); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame4(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame4(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame2(ncpBuffer); VerifyAndRemoveFrame4(ncpBuffer); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame3(ncpBuffer); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame4(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame4(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame2(ncpBuffer); VerifyAndRemoveFrame4(ncpBuffer); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame3(ncpBuffer); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame4(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame4(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame2(ncpBuffer); VerifyAndRemoveFrame3(ncpBuffer); VerifyAndRemoveFrame4(ncpBuffer); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame2(ncpBuffer); - WriteTestFrame4(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame4(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame3(ncpBuffer); VerifyAndRemoveFrame4(ncpBuffer); VerifyAndRemoveFrame1(ncpBuffer); @@ -520,10 +520,10 @@ void TestNcpFrameBuffer(void) printf("*"); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityHigh); - ncpBuffer.InFrameBegin((j % 2) == 0 ? NcpFrameBuffer::kPriorityHigh : NcpFrameBuffer::kPriorityLow); + ncpBuffer.InFrameBegin((j % 2) == 0 ? Spinel::Buffer::kPriorityHigh : Spinel::Buffer::kPriorityLow); ncpBuffer.InFrameFeedData(sHelloText, sizeof(sHelloText)); message = sMessagePool->New(Message::kTypeIp6, 0); @@ -534,7 +534,7 @@ void TestNcpFrameBuffer(void) ncpBuffer.InFrameFeedMessage(message); // Start writing a new frame in middle of an unfinished frame. Ensure the first one is discarded. - WriteTestFrame1(ncpBuffer, frame1IsHighPriority ? NcpFrameBuffer::kPriorityHigh : NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, frame1IsHighPriority ? Spinel::Buffer::kPriorityHigh : Spinel::Buffer::kPriorityLow); // Note that message will not be freed by the NCP buffer since the frame associated with it was discarded and // not yet finished/ended. @@ -568,13 +568,13 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 6: Clear() and empty buffer method tests"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); ncpBuffer.Clear(); ClearTagHistory(); - VerifyOrQuit(ncpBuffer.InFrameGetLastTag() == NcpFrameBuffer::kInvalidTag, "Incorrect last tag after Clear()."); - VerifyOrQuit(ncpBuffer.OutFrameGetTag() == NcpFrameBuffer::kInvalidTag, "Incorrect OutFrameTag after Clear()."); + VerifyOrQuit(ncpBuffer.InFrameGetLastTag() == Spinel::Buffer::kInvalidTag, "Incorrect last tag after Clear()."); + VerifyOrQuit(ncpBuffer.OutFrameGetTag() == Spinel::Buffer::kInvalidTag, "Incorrect OutFrameTag after Clear()."); VerifyOrQuit(ncpBuffer.IsEmpty() == true, "IsEmpty() is incorrect when buffer is empty."); VerifyOrQuit(ncpBuffer.OutFrameHasEnded() == true, "OutFrameHasEnded() is incorrect when no data in buffer."); VerifyOrQuit(ncpBuffer.OutFrameRemove() == OT_ERROR_NOT_FOUND, @@ -582,7 +582,7 @@ void TestNcpFrameBuffer(void) VerifyOrQuit(ncpBuffer.OutFrameGetLength() == 0, "OutFrameGetLength() returned non-zero length when buffer is empty."); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyAndRemoveFrame1(ncpBuffer); VerifyOrQuit(ncpBuffer.IsEmpty() == true, "IsEmpty() is incorrect when buffer is empty."); @@ -597,7 +597,7 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 7: OutFrameRead() in parts\n"); - ncpBuffer.InFrameBegin(NcpFrameBuffer::kPriorityLow); + ncpBuffer.InFrameBegin(Spinel::Buffer::kPriorityLow); ncpBuffer.InFrameFeedData(sMottoText, sizeof(sMottoText)); ncpBuffer.InFrameEnd(); @@ -623,8 +623,8 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 8: Remove a frame without reading it first"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); SuccessOrQuit(ncpBuffer.OutFrameRemove(), "Remove() failed."); VerifyAndRemoveFrame2(ncpBuffer); @@ -632,9 +632,9 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 9: Check length when front frame gets changed (a higher priority frame is added)"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame3Size, "GetLength() is incorrect."); VerifyAndRemoveFrame3(ncpBuffer); VerifyAndRemoveFrame1(ncpBuffer); @@ -642,12 +642,12 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 10: Active out frame remaining unchanged when a higher priority frame is written while reading it"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); SuccessOrQuit(ncpBuffer.OutFrameBegin(), "OutFrameBegin() failed unexpectedly."); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); ReadAndVerifyContent(ncpBuffer, sMottoText, sizeof(sMottoText)); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); ReadAndVerifyContent(ncpBuffer, sMysteryText, sizeof(sMysteryText)); SuccessOrQuit(ncpBuffer.OutFrameBegin(), "OutFrameBegin() failed unexpectedly."); @@ -657,20 +657,20 @@ void TestNcpFrameBuffer(void) ReadAndVerifyContent(ncpBuffer, sMottoText, sizeof(sMottoText)); ReadAndVerifyContent(ncpBuffer, sHelloText, sizeof(sHelloText)); VerifyOrQuit(ncpBuffer.OutFrameHasEnded() == true, "Frame longer than expected."); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame4(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame4(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame2(ncpBuffer); VerifyAndRemoveFrame3(ncpBuffer); VerifyAndRemoveFrame4(ncpBuffer); // Repeat test reversing frame priority orders. - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); SuccessOrQuit(ncpBuffer.OutFrameBegin(), "OutFrameBegin() failed unexpectedly."); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); ReadAndVerifyContent(ncpBuffer, sMottoText, sizeof(sMottoText)); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); ReadAndVerifyContent(ncpBuffer, sMysteryText, sizeof(sMysteryText)); SuccessOrQuit(ncpBuffer.OutFrameBegin(), "OutFrameBegin() failed unexpectedly."); @@ -680,8 +680,8 @@ void TestNcpFrameBuffer(void) ReadAndVerifyContent(ncpBuffer, sMottoText, sizeof(sMottoText)); ReadAndVerifyContent(ncpBuffer, sHelloText, sizeof(sHelloText)); VerifyOrQuit(ncpBuffer.OutFrameHasEnded() == true, "Frame longer than expected."); - WriteTestFrame3(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame4(ncpBuffer, NcpFrameBuffer::kPriorityLow); + WriteTestFrame3(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame4(ncpBuffer, Spinel::Buffer::kPriorityLow); VerifyOrQuit(ncpBuffer.OutFrameGetLength() == kTestFrame1Size, "GetLength() is incorrect."); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame3(ncpBuffer); @@ -691,24 +691,24 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\n Test 11: Read and remove in middle of an active input frame write"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - ncpBuffer.InFrameBegin(NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + ncpBuffer.InFrameBegin(Spinel::Buffer::kPriorityHigh); SuccessOrQuit(ncpBuffer.InFrameFeedData(sOpenThreadText, sizeof(sOpenThreadText)), "InFrameFeedData() failed."); VerifyAndRemoveFrame1(ncpBuffer); VerifyOrQuit(ncpBuffer.IsEmpty() == true, "IsEmpty() failed."); SuccessOrQuit(ncpBuffer.InFrameEnd(), "InFrameEnd() failed."); VerifyAndRemoveFrame4(ncpBuffer); // Repeat the test reversing priorities - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - ncpBuffer.InFrameBegin(NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); + ncpBuffer.InFrameBegin(Spinel::Buffer::kPriorityLow); SuccessOrQuit(ncpBuffer.InFrameFeedData(sOpenThreadText, sizeof(sOpenThreadText)), "InFrameFeedData() failed."); VerifyAndRemoveFrame1(ncpBuffer); VerifyOrQuit(ncpBuffer.IsEmpty() == true, "IsEmpty() failed."); SuccessOrQuit(ncpBuffer.InFrameEnd(), "InFrameEnd() failed."); VerifyAndRemoveFrame4(ncpBuffer); // Repeat the test with same priorities - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - ncpBuffer.InFrameBegin(NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); + ncpBuffer.InFrameBegin(Spinel::Buffer::kPriorityHigh); SuccessOrQuit(ncpBuffer.InFrameFeedData(sOpenThreadText, sizeof(sOpenThreadText)), "InFrameFeedData() failed."); VerifyAndRemoveFrame1(ncpBuffer); VerifyOrQuit(ncpBuffer.IsEmpty() == true, "IsEmpty() failed."); @@ -718,14 +718,14 @@ void TestNcpFrameBuffer(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\n Test 12: Check returned error status"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - ncpBuffer.InFrameBegin(NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + ncpBuffer.InFrameBegin(Spinel::Buffer::kPriorityHigh); VerifyOrQuit(ncpBuffer.InFrameFeedData(buffer, sizeof(buffer)) == OT_ERROR_NO_BUFS, "Incorrect error status"); VerifyAndRemoveFrame1(ncpBuffer); VerifyOrQuit(ncpBuffer.IsEmpty() == true, "IsEmpty() failed."); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityLow); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityLow); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityHigh); // Ensure writes with starting `InFrameBegin()` fail VerifyOrQuit(ncpBuffer.InFrameFeedData(sOpenThreadText, 1) == OT_ERROR_INVALID_STATE, "Incorrect error status"); VerifyOrQuit(ncpBuffer.InFrameFeedData(sOpenThreadText, 0) == OT_ERROR_INVALID_STATE, "Incorrect error status"); @@ -742,25 +742,25 @@ void TestNcpFrameBuffer(void) VerifyAndRemoveFrame1(ncpBuffer); VerifyOrQuit(ncpBuffer.IsEmpty(), "IsEmpty() failed"); VerifyOrQuit(ncpBuffer.OutFrameBegin() == OT_ERROR_NOT_FOUND, "OutFrameBegin() failed on empty queue"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame1(ncpBuffer); VerifyOrQuit(ncpBuffer.IsEmpty(), "IsEmpty() failed"); printf(" -- PASS\n"); printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\n Test 13: Ensure we can utilize the full buffer size when frames removed during write"); - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - ncpBuffer.InFrameBegin(NcpFrameBuffer::kPriorityHigh); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + ncpBuffer.InFrameBegin(Spinel::Buffer::kPriorityHigh); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame2(ncpBuffer); SuccessOrQuit(ncpBuffer.InFrameFeedData(buffer, sizeof(buffer) - 4), "InFrameFeedData() failed."); SuccessOrQuit(ncpBuffer.InFrameEnd(), "InFrameEnd() failed."); SuccessOrQuit(ncpBuffer.OutFrameRemove(), "OutFrameRemove() failed."); // Repeat the test with a low priority buffer write - WriteTestFrame1(ncpBuffer, NcpFrameBuffer::kPriorityHigh); - WriteTestFrame2(ncpBuffer, NcpFrameBuffer::kPriorityLow); - ncpBuffer.InFrameBegin(NcpFrameBuffer::kPriorityLow); + WriteTestFrame1(ncpBuffer, Spinel::Buffer::kPriorityHigh); + WriteTestFrame2(ncpBuffer, Spinel::Buffer::kPriorityLow); + ncpBuffer.InFrameBegin(Spinel::Buffer::kPriorityLow); VerifyAndRemoveFrame1(ncpBuffer); VerifyAndRemoveFrame2(ncpBuffer); SuccessOrQuit(ncpBuffer.InFrameFeedData(buffer, sizeof(buffer) - 4), "InFrameFeedData() failed."); @@ -776,10 +776,10 @@ void TestNcpFrameBuffer(void) { uint16_t index; bool addExtra = ((j % 7) != 0); - NcpFrameBuffer::Priority priority; + Spinel::Buffer::Priority priority; printf("*"); - priority = ((j % 3) == 0) ? NcpFrameBuffer::kPriorityHigh : NcpFrameBuffer::kPriorityLow; + priority = ((j % 3) == 0) ? Spinel::Buffer::kPriorityHigh : Spinel::Buffer::kPriorityLow; index = static_cast(j % sizeof(sHexText)); ncpBuffer.InFrameBegin(priority); SuccessOrQuit(ncpBuffer.InFrameFeedData(sHexText, index), "InFrameFeedData() failed."); @@ -822,10 +822,10 @@ void TestNcpFrameBuffer(void) { uint16_t index; bool addExtra = ((j % 7) != 0); - NcpFrameBuffer::Priority priority; + Spinel::Buffer::Priority priority; printf("*"); - priority = ((j % 3) == 0) ? NcpFrameBuffer::kPriorityHigh : NcpFrameBuffer::kPriorityLow; + priority = ((j % 3) == 0) ? Spinel::Buffer::kPriorityHigh : Spinel::Buffer::kPriorityLow; index = static_cast(j % sizeof(sHexText)); ncpBuffer.InFrameBegin(priority); SuccessOrQuit(ncpBuffer.InFrameFeedData(sHexText, index), "InFrameFeedData() failed."); @@ -903,7 +903,7 @@ uint32_t GetRandom(uint32_t max) return value % max; } -otError WriteRandomFrame(uint32_t aLength, NcpFrameBuffer &aNcpBuffer, NcpFrameBuffer::Priority aPriority) +otError WriteRandomFrame(uint32_t aLength, Spinel::Buffer &aNcpBuffer, Spinel::Buffer::Priority aPriority) { otError error; uint8_t byte; @@ -932,7 +932,7 @@ exit: return error; } -otError ReadRandomFrame(uint32_t aLength, NcpFrameBuffer &aNcpBuffer, uint8_t priority) +otError ReadRandomFrame(uint32_t aLength, Spinel::Buffer &aNcpBuffer, uint8_t priority) { CallbackContext oldContext = sContext; @@ -956,10 +956,10 @@ otError ReadRandomFrame(uint32_t aLength, NcpFrameBuffer &aNcpBuffer, uint8_t pr } // This runs a fuzz test of NCP buffer -void TestFuzzNcpFrameBuffer(void) +void TestFuzzBuffer(void) { uint8_t buffer[kFuzTestBufferSize]; - NcpFrameBuffer ncpBuffer(buffer, kFuzTestBufferSize); + Spinel::Buffer ncpBuffer(buffer, kFuzTestBufferSize); uint32_t lensArray[kNumPrios][kLensArraySize]; // Keeps track of length of written frames so far uint32_t lensArrayStart[kNumPrios]; @@ -1004,29 +1004,29 @@ void TestFuzzNcpFrameBuffer(void) uint32_t len; uint8_t priority; - priority = (lensArrayCount[NcpFrameBuffer::kPriorityHigh] != 0) ? NcpFrameBuffer::kPriorityHigh - : NcpFrameBuffer::kPriorityLow; + priority = (lensArrayCount[Spinel::Buffer::kPriorityHigh] != 0) ? Spinel::Buffer::kPriorityHigh + : Spinel::Buffer::kPriorityLow; len = lensArray[priority][lensArrayStart[priority]]; lensArrayStart[priority] = (lensArrayStart[priority] + 1) % kLensArraySize; lensArrayCount[priority]--; - printf("R%c%d ", priority == NcpFrameBuffer::kPriorityHigh ? 'H' : 'L', len); + printf("R%c%d ", priority == Spinel::Buffer::kPriorityHigh ? 'H' : 'L', len); SuccessOrQuit(ReadRandomFrame(len, ncpBuffer, priority), "Failed to read random frame."); } else { uint32_t len = GetRandom(kMaxFrameLen) + 1; - NcpFrameBuffer::Priority priority; + Spinel::Buffer::Priority priority; if (GetRandom(100) < kHighPriorityProbablity) { - priority = NcpFrameBuffer::kPriorityHigh; + priority = Spinel::Buffer::kPriorityHigh; } else { - priority = NcpFrameBuffer::kPriorityLow; + priority = Spinel::Buffer::kPriorityLow; } if (WriteRandomFrame(len, ncpBuffer, priority) == OT_ERROR_NONE) @@ -1034,7 +1034,7 @@ void TestFuzzNcpFrameBuffer(void) lensArray[priority][(lensArrayStart[priority] + lensArrayCount[priority]) % kLensArraySize] = len; lensArrayCount[priority]++; - printf("W%c%d ", priority == NcpFrameBuffer::kPriorityHigh ? 'H' : 'L', len); + printf("W%c%d ", priority == Spinel::Buffer::kPriorityHigh ? 'H' : 'L', len); } else { @@ -1054,13 +1054,13 @@ void TestFuzzNcpFrameBuffer(void) testFreeInstance(sInstance); } -} // namespace Ncp +} // namespace Spinel } // namespace ot int main(void) { - ot::Ncp::TestNcpFrameBuffer(); - ot::Ncp::TestFuzzNcpFrameBuffer(); + ot::Spinel::TestBuffer(); + ot::Spinel::TestFuzzBuffer(); printf("\nAll tests passed.\n"); return 0; } diff --git a/tests/unit/test_spinel_decoder.cpp b/tests/unit/test_spinel_decoder.cpp index 0a2d67498..615c228e9 100644 --- a/tests/unit/test_spinel_decoder.cpp +++ b/tests/unit/test_spinel_decoder.cpp @@ -28,22 +28,22 @@ #include "common/code_utils.hpp" #include "common/instance.hpp" -#include "ncp/spinel_decoder.hpp" +#include "spinel/spinel_decoder.hpp" #include "test_util.hpp" namespace ot { -namespace Ncp { +namespace Spinel { enum { kTestBufferSize = 800, }; -void TestSpinelDecoder(void) +void TestDecoder(void) { - uint8_t buffer[kTestBufferSize]; - SpinelDecoder decoder; + uint8_t buffer[kTestBufferSize]; + Spinel::Decoder decoder; spinel_ssize_t frameLen; @@ -638,12 +638,12 @@ void TestSpinelDecoder(void) printf(" -- PASS\n"); } -} // namespace Ncp +} // namespace Spinel } // namespace ot int main(void) { - ot::Ncp::TestSpinelDecoder(); + ot::Spinel::Decoder(); printf("\nAll tests passed.\n"); return 0; } diff --git a/tests/unit/test_spinel_encoder.cpp b/tests/unit/test_spinel_encoder.cpp index 3030bc47e..b4fc03deb 100644 --- a/tests/unit/test_spinel_encoder.cpp +++ b/tests/unit/test_spinel_encoder.cpp @@ -28,19 +28,19 @@ #include "common/code_utils.hpp" #include "common/instance.hpp" -#include "ncp/spinel_encoder.hpp" +#include "spinel/spinel_encoder.hpp" #include "test_util.hpp" namespace ot { -namespace Ncp { +namespace Spinel { enum { kTestBufferSize = 800, }; -otError ReadFrame(NcpFrameBuffer &aNcpBuffer, uint8_t *aFrame, uint16_t &aFrameLen) +otError ReadFrame(Spinel::Buffer &aNcpBuffer, uint8_t *aFrame, uint16_t &aFrameLen) { otError error = OT_ERROR_NONE; @@ -53,11 +53,11 @@ exit: return error; } -void TestSpinelEncoder(void) +void TestEncoder(void) { - uint8_t buffer[kTestBufferSize]; - NcpFrameBuffer ncpBuffer(buffer, kTestBufferSize); - SpinelEncoder encoder(ncpBuffer); + uint8_t buffer[kTestBufferSize]; + Spinel::Buffer ncpBuffer(buffer, kTestBufferSize); + Spinel::Encoder encoder(ncpBuffer); uint8_t frame[kTestBufferSize]; uint16_t frameLen; @@ -117,7 +117,7 @@ void TestSpinelEncoder(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 1: Encoding of simple types"); - SuccessOrQuit(encoder.BeginFrame(NcpFrameBuffer::kPriorityLow), "BeginFrame() failed."); + SuccessOrQuit(encoder.BeginFrame(Spinel::Buffer::kPriorityLow), "BeginFrame() failed."); SuccessOrQuit(encoder.WriteBool(kBool_1), "WriteBool() failed."); SuccessOrQuit(encoder.WriteBool(kBool_2), "WriteBool() failed."); SuccessOrQuit(encoder.WriteUint8(kUint8), "WriteUint8() failed."); @@ -183,7 +183,7 @@ void TestSpinelEncoder(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 2: Test a single simple struct."); - SuccessOrQuit(encoder.BeginFrame(NcpFrameBuffer::kPriorityLow), "BeginFrame() failed."); + SuccessOrQuit(encoder.BeginFrame(Spinel::Buffer::kPriorityLow), "BeginFrame() failed."); SuccessOrQuit(encoder.WriteUint8(kUint8), "WriteUint8() failed."); SuccessOrQuit(encoder.OpenStruct(), "OpenStruct() failed."); { @@ -230,7 +230,7 @@ void TestSpinelEncoder(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 3: Test multiple structs and struct within struct."); - SuccessOrQuit(encoder.BeginFrame(NcpFrameBuffer::kPriorityLow), "BeginFrame() failed."); + SuccessOrQuit(encoder.BeginFrame(Spinel::Buffer::kPriorityLow), "BeginFrame() failed."); SuccessOrQuit(encoder.OpenStruct(), "OpenStruct() failed."); { SuccessOrQuit(encoder.WriteUint8(kUint8), "WriteUint8() failed."); @@ -279,7 +279,7 @@ void TestSpinelEncoder(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 4: Test unclosed struct."); - SuccessOrQuit(encoder.BeginFrame(NcpFrameBuffer::kPriorityLow), "BeginFrame() failed."); + SuccessOrQuit(encoder.BeginFrame(Spinel::Buffer::kPriorityLow), "BeginFrame() failed."); SuccessOrQuit(encoder.WriteUint8(kUint8), "WriteUint8() failed."); SuccessOrQuit(encoder.OpenStruct(), "OpenStruct() failed."); { @@ -312,7 +312,7 @@ void TestSpinelEncoder(void) printf("\n- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"); printf("\nTest 5: Test saving position and reseting back to a saved position"); - SuccessOrQuit(encoder.BeginFrame(NcpFrameBuffer::kPriorityLow), "BeginFrame() failed."); + SuccessOrQuit(encoder.BeginFrame(Spinel::Buffer::kPriorityLow), "BeginFrame() failed."); SuccessOrQuit(encoder.WriteUint8(kUint8), "WriteUint8() failed."); SuccessOrQuit(encoder.OpenStruct(), "OpenStruct() failed."); { @@ -357,12 +357,12 @@ void TestSpinelEncoder(void) printf(" -- PASS\n"); } -} // namespace Ncp +} // namespace Spinel } // namespace ot int main(void) { - ot::Ncp::TestSpinelEncoder(); + ot::Spinel::TestEncoder(); printf("\nAll tests passed.\n"); return 0; }