espressif/openthread
1
0
Fork 0
mirror of https://github.com/espressif/openthread.git synced 2026-08-13 06:07:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

[posix] replace fd_sets with the mainloop context (#9127)

Browse Source
This commit is contained in:
Zhanglong Xia
2023-06-06 22:44:39 -07:00
committed by GitHub
parent 439b58279b
commit cc09029188
17 changed files with 354 additions and 494 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/lib/spinel/radio_spinel.hpp
+4 -5
View File
@@ -91,10 +91,9 @@ namespace Spinel {
*
* // This method performs radio driver processing.
*
* // @param[in] aContext The context containing fd_sets.
* // The type is specified by the user in template parameters.
* // @param[in] aContext The process context.
*
* void Process(const ProcessContextType &aContext);
* void Process(const void *aContext);
*
*
* // This method deinitializes the interface to the RCP.
@@ -102,7 +101,7 @@ namespace Spinel {
* void Deinit(void);
* };
*/
template <typename InterfaceType, typename ProcessContextType> class RadioSpinel
template <typename InterfaceType> class RadioSpinel
{
public:
/**
@@ -562,7 +561,7 @@ public:
* @param[in] aContext The process context.
*
*/
void Process(const ProcessContextType &aContext);
void Process(const void *aContext);
/**
* Returns the underlying spinel interface.
src/lib/spinel/radio_spinel_impl.hpp
+167 -232
View File
@@ -162,14 +162,13 @@ static inline void LogIfFail(const char *aText, otError aError)
}
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleReceivedFrame(void *aContext)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::HandleReceivedFrame(void *aContext)
{
static_cast<RadioSpinel *>(aContext)->HandleReceivedFrame();
}
template <typename InterfaceType, typename ProcessContextType>
RadioSpinel<InterfaceType, ProcessContextType>::RadioSpinel(void)
template <typename InterfaceType>
RadioSpinel<InterfaceType>::RadioSpinel(void)
: mInstance(nullptr)
, mRxFrameBuffer()
, mSpinelInterface(HandleReceivedFrame, this, mRxFrameBuffer)
@@ -217,10 +216,8 @@ RadioSpinel<InterfaceType, ProcessContextType>::RadioSpinel(void)
memset(&mRadioSpinelMetrics, 0, sizeof(mRadioSpinelMetrics));
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::Init(bool aResetRadio,
bool aRestoreDatasetFromNcp,
bool aSkipRcpCompatibilityCheck)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::Init(bool aResetRadio, bool aRestoreDatasetFromNcp, bool aSkipRcpCompatibilityCheck)
{
otError error = OT_ERROR_NONE;
bool supportsRcpApiVersion;
@@ -263,8 +260,7 @@ exit:
SuccessOrDie(error);
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::ResetRcp(bool aResetRadio)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::ResetRcp(bool aResetRadio)
{
bool hardwareReset;
bool resetDone = false;
@@ -300,8 +296,7 @@ exit:
}
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::CheckSpinelVersion(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::CheckSpinelVersion(void)
{
otError error = OT_ERROR_NONE;
unsigned int versionMajor;
@@ -323,9 +318,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
bool RadioSpinel<InterfaceType, ProcessContextType>::IsRcp(bool &aSupportsRcpApiVersion,
bool &aSupportsRcpMinHostApiVersion)
template <typename InterfaceType>
bool RadioSpinel<InterfaceType>::IsRcp(bool &aSupportsRcpApiVersion, bool &aSupportsRcpMinHostApiVersion)
{
uint8_t capsBuffer[kCapsBufferSize];
const uint8_t *capsData = capsBuffer;
@@ -384,8 +378,7 @@ bool RadioSpinel<InterfaceType, ProcessContextType>::IsRcp(bool &aSupportsRcpApi
return isRcp;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::CheckRadioCapabilities(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::CheckRadioCapabilities(void)
{
const otRadioCaps kRequiredRadioCaps =
#if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
@@ -421,9 +414,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::CheckRcpApiVersion(bool aSupportsRcpApiVersion,
bool aSupportsRcpMinHostApiVersion)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::CheckRcpApiVersion(bool aSupportsRcpApiVersion, bool aSupportsRcpMinHostApiVersion)
{
otError error = OT_ERROR_NONE;
@@ -473,8 +465,7 @@ exit:
}
#if !OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::RestoreDatasetFromNcp(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::RestoreDatasetFromNcp(void)
{
otError error = OT_ERROR_NONE;
@@ -492,16 +483,14 @@ exit:
}
#endif
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::Deinit(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::Deinit(void)
{
mSpinelInterface.Deinit();
// This allows implementing pseudo reset.
new (this) RadioSpinel();
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleReceivedFrame(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::HandleReceivedFrame(void)
{
otError error = OT_ERROR_NONE;
uint8_t header;
@@ -534,8 +523,8 @@ exit:
UpdateParseErrorCount(error);
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleNotification(SpinelInterface::RxFrameBuffer &aFrameBuffer)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::HandleNotification(SpinelInterface::RxFrameBuffer &aFrameBuffer)
{
spinel_prop_key_t key;
spinel_size_t len = 0;
@@ -589,8 +578,8 @@ exit:
LogIfFail("Error processing notification", error);
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleNotification(const uint8_t *aFrame, uint16_t aLength)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::HandleNotification(const uint8_t *aFrame, uint16_t aLength)
{
spinel_prop_key_t key;
spinel_size_t len = 0;
@@ -611,8 +600,8 @@ exit:
LogIfFail("Error processing saved notification", error);
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleResponse(const uint8_t *aBuffer, uint16_t aLength)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::HandleResponse(const uint8_t *aBuffer, uint16_t aLength)
{
spinel_prop_key_t key;
uint8_t *data = nullptr;
@@ -654,8 +643,8 @@ exit:
}
#if !OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ThreadDatasetHandler(const uint8_t *aBuffer, uint16_t aLength)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::ThreadDatasetHandler(const uint8_t *aBuffer, uint16_t aLength)
{
otError error = OT_ERROR_NONE;
otOperationalDataset opDataset;
@@ -818,11 +807,11 @@ exit:
}
#endif // #if !OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleWaitingResponse(uint32_t aCommand,
spinel_prop_key_t aKey,
const uint8_t *aBuffer,
uint16_t aLength)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::HandleWaitingResponse(uint32_t aCommand,
spinel_prop_key_t aKey,
const uint8_t *aBuffer,
uint16_t aLength)
{
if (aKey == SPINEL_PROP_LAST_STATUS)
{
@@ -887,10 +876,8 @@ exit:
LogIfFail("Error processing result", mError);
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleValueIs(spinel_prop_key_t aKey,
const uint8_t *aBuffer,
uint16_t aLength)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::HandleValueIs(spinel_prop_key_t aKey, const uint8_t *aBuffer, uint16_t aLength)
{
otError error = OT_ERROR_NONE;
spinel_ssize_t unpacked;
@@ -995,11 +982,11 @@ exit:
LogIfFail("Failed to handle ValueIs", error);
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ParseRadioFrame(otRadioFrame &aFrame,
const uint8_t *aBuffer,
uint16_t aLength,
spinel_ssize_t &aUnpacked)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::ParseRadioFrame(otRadioFrame &aFrame,
const uint8_t *aBuffer,
uint16_t aLength,
spinel_ssize_t &aUnpacked)
{
otError error = OT_ERROR_NONE;
uint16_t flags = 0;
@@ -1068,8 +1055,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::ProcessFrameQueue(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::ProcessFrameQueue(void)
{
uint8_t *frame = nullptr;
uint16_t length;
@@ -1082,8 +1068,7 @@ void RadioSpinel<InterfaceType, ProcessContextType>::ProcessFrameQueue(void)
mRxFrameBuffer.ClearSavedFrames();
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::RadioReceive(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::RadioReceive(void)
{
if (!mIsPromiscuous)
{
@@ -1115,10 +1100,8 @@ exit:
return;
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::TransmitDone(otRadioFrame *aFrame,
otRadioFrame *aAckFrame,
otError aError)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::TransmitDone(otRadioFrame *aFrame, otRadioFrame *aAckFrame, otError aError)
{
#if OPENTHREAD_CONFIG_DIAG_ENABLE
if (otPlatDiagModeGet())
@@ -1132,8 +1115,7 @@ void RadioSpinel<InterfaceType, ProcessContextType>::TransmitDone(otRadioFrame *
}
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::ProcessRadioStateMachine(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::ProcessRadioStateMachine(void)
{
if (mState == kStateTransmitDone)
{
@@ -1150,8 +1132,7 @@ void RadioSpinel<InterfaceType, ProcessContextType>::ProcessRadioStateMachine(vo
}
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::Process(const ProcessContextType &aContext)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::Process(const void *aContext)
{
if (mRxFrameBuffer.HasSavedFrame())
{
@@ -1173,8 +1154,7 @@ void RadioSpinel<InterfaceType, ProcessContextType>::Process(const ProcessContex
CalcRcpTimeOffset();
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetPromiscuous(bool aEnable)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetPromiscuous(bool aEnable)
{
otError error;
@@ -1186,8 +1166,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetShortAddress(uint16_t aAddress)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetShortAddress(uint16_t aAddress)
{
otError error = OT_ERROR_NONE;
@@ -1199,12 +1178,12 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetMacKey(uint8_t aKeyIdMode,
uint8_t aKeyId,
const otMacKeyMaterial *aPrevKey,
const otMacKeyMaterial *aCurrKey,
const otMacKeyMaterial *aNextKey)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::SetMacKey(uint8_t aKeyIdMode,
uint8_t aKeyId,
const otMacKeyMaterial *aPrevKey,
const otMacKeyMaterial *aCurrKey,
const otMacKeyMaterial *aNextKey)
{
otError error;
size_t aKeySize;
@@ -1242,8 +1221,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetMacFrameCounter(uint32_t aMacFrameCounter, bool aSetIfLarger)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::SetMacFrameCounter(uint32_t aMacFrameCounter, bool aSetIfLarger)
{
otError error;
@@ -1254,16 +1233,15 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::GetIeeeEui64(uint8_t *aIeeeEui64)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::GetIeeeEui64(uint8_t *aIeeeEui64)
{
memcpy(aIeeeEui64, mIeeeEui64.m8, sizeof(mIeeeEui64.m8));
return OT_ERROR_NONE;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetExtendedAddress(const otExtAddress &aExtAddress)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::SetExtendedAddress(const otExtAddress &aExtAddress)
{
otError error;
@@ -1274,8 +1252,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetPanId(uint16_t aPanId)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetPanId(uint16_t aPanId)
{
otError error = OT_ERROR_NONE;
@@ -1287,14 +1264,12 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::EnableSrcMatch(bool aEnable)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::EnableSrcMatch(bool aEnable)
{
return Set(SPINEL_PROP_MAC_SRC_MATCH_ENABLED, SPINEL_DATATYPE_BOOL_S, aEnable);
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::AddSrcMatchShortEntry(uint16_t aShortAddress)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::AddSrcMatchShortEntry(uint16_t aShortAddress)
{
otError error;
@@ -1318,8 +1293,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::AddSrcMatchExtEntry(const otExtAddress &aExtAddress)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::AddSrcMatchExtEntry(const otExtAddress &aExtAddress)
{
otError error;
@@ -1344,8 +1319,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ClearSrcMatchShortEntry(uint16_t aShortAddress)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::ClearSrcMatchShortEntry(uint16_t aShortAddress)
{
otError error;
@@ -1367,8 +1341,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ClearSrcMatchExtEntry(const otExtAddress &aExtAddress)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::ClearSrcMatchExtEntry(const otExtAddress &aExtAddress)
{
otError error;
@@ -1391,8 +1365,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ClearSrcMatchShortEntries(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::ClearSrcMatchShortEntries(void)
{
otError error;
@@ -1406,8 +1379,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ClearSrcMatchExtEntries(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::ClearSrcMatchExtEntries(void)
{
otError error;
@@ -1421,8 +1393,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::GetTransmitPower(int8_t &aPower)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::GetTransmitPower(int8_t &aPower)
{
otError error = Get(SPINEL_PROP_PHY_TX_POWER, SPINEL_DATATYPE_INT8_S, &aPower);
@@ -1430,8 +1401,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::GetTransmitPower(int8_t
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::GetCcaEnergyDetectThreshold(int8_t &aThreshold)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::GetCcaEnergyDetectThreshold(int8_t &aThreshold)
{
otError error = Get(SPINEL_PROP_PHY_CCA_THRESHOLD, SPINEL_DATATYPE_INT8_S, &aThreshold);
@@ -1439,8 +1409,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::GetCcaEnergyDetectThresh
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::GetFemLnaGain(int8_t &aGain)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::GetFemLnaGain(int8_t &aGain)
{
otError error = Get(SPINEL_PROP_PHY_FEM_LNA_GAIN, SPINEL_DATATYPE_INT8_S, &aGain);
@@ -1448,8 +1417,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::GetFemLnaGain(int8_t &aG
return error;
}
template <typename InterfaceType, typename ProcessContextType>
int8_t RadioSpinel<InterfaceType, ProcessContextType>::GetRssi(void)
template <typename InterfaceType> int8_t RadioSpinel<InterfaceType>::GetRssi(void)
{
int8_t rssi = OT_RADIO_RSSI_INVALID;
otError error = Get(SPINEL_PROP_PHY_RSSI, SPINEL_DATATYPE_INT8_S, &rssi);
@@ -1459,8 +1427,7 @@ int8_t RadioSpinel<InterfaceType, ProcessContextType>::GetRssi(void)
}
#if OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetCoexEnabled(bool aEnabled)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetCoexEnabled(bool aEnabled)
{
otError error;
@@ -1475,8 +1442,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
bool RadioSpinel<InterfaceType, ProcessContextType>::IsCoexEnabled(void)
template <typename InterfaceType> bool RadioSpinel<InterfaceType>::IsCoexEnabled(void)
{
bool enabled;
otError error = Get(SPINEL_PROP_RADIO_COEX_ENABLE, SPINEL_DATATYPE_BOOL_S, &enabled);
@@ -1485,8 +1451,7 @@ bool RadioSpinel<InterfaceType, ProcessContextType>::IsCoexEnabled(void)
return enabled;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::GetCoexMetrics(otRadioCoexMetrics &aCoexMetrics)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::GetCoexMetrics(otRadioCoexMetrics &aCoexMetrics)
{
otError error;
@@ -1526,8 +1491,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::GetCoexMetrics(otRadioCo
}
#endif
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetTransmitPower(int8_t aPower)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetTransmitPower(int8_t aPower)
{
otError error;
@@ -1543,8 +1507,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetCcaEnergyDetectThreshold(int8_t aThreshold)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetCcaEnergyDetectThreshold(int8_t aThreshold)
{
otError error;
@@ -1560,8 +1523,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetFemLnaGain(int8_t aGain)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetFemLnaGain(int8_t aGain)
{
otError error;
@@ -1577,8 +1539,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::EnergyScan(uint8_t aScanChannel, uint16_t aScanDuration)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::EnergyScan(uint8_t aScanChannel, uint16_t aScanDuration)
{
otError error;
@@ -1600,8 +1562,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Get(spinel_prop_key_t aKey, const char *aFormat, ...)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::Get(spinel_prop_key_t aKey, const char *aFormat, ...)
{
otError error;
@@ -1623,12 +1585,12 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::Get(spinel_prop_key_t aK
}
// This is not a normal use case for VALUE_GET command and should be only used to get RCP timestamp with dummy payload
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::GetWithParam(spinel_prop_key_t aKey,
const uint8_t *aParam,
spinel_size_t aParamSize,
const char *aFormat,
...)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::GetWithParam(spinel_prop_key_t aKey,
const uint8_t *aParam,
spinel_size_t aParamSize,
const char *aFormat,
...)
{
otError error;
@@ -1650,8 +1612,8 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::GetWithParam(spinel_prop
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Set(spinel_prop_key_t aKey, const char *aFormat, ...)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::Set(spinel_prop_key_t aKey, const char *aFormat, ...)
{
otError error;
@@ -1673,8 +1635,8 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::Set(spinel_prop_key_t aK
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Insert(spinel_prop_key_t aKey, const char *aFormat, ...)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::Insert(spinel_prop_key_t aKey, const char *aFormat, ...)
{
otError error;
@@ -1696,8 +1658,8 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::Insert(spinel_prop_key_t
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Remove(spinel_prop_key_t aKey, const char *aFormat, ...)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::Remove(spinel_prop_key_t aKey, const char *aFormat, ...)
{
otError error;
@@ -1719,8 +1681,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::Remove(spinel_prop_key_t
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::WaitResponse(bool aHandleRcpTimeout)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::WaitResponse(bool aHandleRcpTimeout)
{
uint64_t end = otPlatTimeGet() + kMaxWaitTime * US_PER_MS;
@@ -1750,8 +1711,7 @@ exit:
return mError;
}
template <typename InterfaceType, typename ProcessContextType>
spinel_tid_t RadioSpinel<InterfaceType, ProcessContextType>::GetNextTid(void)
template <typename InterfaceType> spinel_tid_t RadioSpinel<InterfaceType>::GetNextTid(void)
{
spinel_tid_t tid = mCmdNextTid;
@@ -1775,8 +1735,7 @@ exit:
return tid;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SendReset(uint8_t aResetType)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SendReset(uint8_t aResetType)
{
otError error = OT_ERROR_NONE;
uint8_t buffer[kMaxSpinelFrame];
@@ -1795,12 +1754,12 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SendCommand(uint32_t aCommand,
spinel_prop_key_t aKey,
spinel_tid_t tid,
const char *aFormat,
va_list args)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::SendCommand(uint32_t aCommand,
spinel_prop_key_t aKey,
spinel_tid_t tid,
const char *aFormat,
va_list args)
{
otError error = OT_ERROR_NONE;
uint8_t buffer[kMaxSpinelFrame];
@@ -1831,11 +1790,11 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::RequestV(uint32_t command,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::RequestV(uint32_t command,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs)
{
otError error = OT_ERROR_NONE;
spinel_tid_t tid = GetNextTid();
@@ -1863,11 +1822,8 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Request(uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
...)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::Request(uint32_t aCommand, spinel_prop_key_t aKey, const char *aFormat, ...)
{
va_list args;
va_start(args, aFormat);
@@ -1876,12 +1832,12 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::Request(uint32_t
return status;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::RequestWithPropertyFormat(const char *aPropertyFormat,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
...)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::RequestWithPropertyFormat(const char *aPropertyFormat,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
...)
{
otError error;
va_list args;
@@ -1893,12 +1849,12 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::RequestWithPropertyForma
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::RequestWithPropertyFormatV(const char *aPropertyFormat,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::RequestWithPropertyFormatV(const char *aPropertyFormat,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs)
{
otError error;
@@ -1909,12 +1865,12 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::RequestWithPropertyForma
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::RequestWithExpectedCommandV(uint32_t aExpectedCommand,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::RequestWithExpectedCommandV(uint32_t aExpectedCommand,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs)
{
otError error;
@@ -1925,11 +1881,11 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::RequestWithExpectedComma
return error;
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleTransmitDone(uint32_t aCommand,
spinel_prop_key_t aKey,
const uint8_t *aBuffer,
uint16_t aLength)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::HandleTransmitDone(uint32_t aCommand,
spinel_prop_key_t aKey,
const uint8_t *aBuffer,
uint16_t aLength)
{
otError error = OT_ERROR_NONE;
spinel_status_t status = SPINEL_STATUS_OK;
@@ -1991,8 +1947,7 @@ exit:
LogIfFail("Handle transmit done failed", error);
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Transmit(otRadioFrame &aFrame)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::Transmit(otRadioFrame &aFrame)
{
otError error = OT_ERROR_INVALID_STATE;
@@ -2034,8 +1989,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Receive(uint8_t aChannel)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::Receive(uint8_t aChannel)
{
otError error = OT_ERROR_NONE;
@@ -2066,8 +2020,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Sleep(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::Sleep(void)
{
otError error = OT_ERROR_NONE;
@@ -2092,8 +2045,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Enable(otInstance *aInstance)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::Enable(otInstance *aInstance)
{
otError error = OT_ERROR_NONE;
@@ -2118,8 +2070,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::Disable(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::Disable(void)
{
otError error = OT_ERROR_NONE;
@@ -2135,10 +2086,8 @@ exit:
}
#if OPENTHREAD_CONFIG_DIAG_ENABLE
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::PlatDiagProcess(const char *aString,
char *aOutput,
size_t aOutputMaxLen)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::PlatDiagProcess(const char *aString, char *aOutput, size_t aOutputMaxLen)
{
otError error;
@@ -2154,8 +2103,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::PlatDiagProcess(const ch
}
#endif
template <typename InterfaceType, typename ProcessContextType>
uint32_t RadioSpinel<InterfaceType, ProcessContextType>::GetRadioChannelMask(bool aPreferred)
template <typename InterfaceType> uint32_t RadioSpinel<InterfaceType>::GetRadioChannelMask(bool aPreferred)
{
uint8_t maskBuffer[kChannelMaskBufferSize];
otError error = OT_ERROR_NONE;
@@ -2188,8 +2136,7 @@ exit:
return channelMask;
}
template <typename InterfaceType, typename ProcessContextType>
otRadioState RadioSpinel<InterfaceType, ProcessContextType>::GetState(void) const
template <typename InterfaceType> otRadioState RadioSpinel<InterfaceType>::GetState(void) const
{
static const otRadioState sOtRadioStateMap[] = {
OT_RADIO_STATE_DISABLED, OT_RADIO_STATE_SLEEP, OT_RADIO_STATE_RECEIVE,
@@ -2199,8 +2146,7 @@ otRadioState RadioSpinel<InterfaceType, ProcessContextType>::GetState(void) cons
return sOtRadioStateMap[mState];
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::CalcRcpTimeOffset(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::CalcRcpTimeOffset(void)
{
#if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
otError error = OT_ERROR_NONE;
@@ -2261,20 +2207,17 @@ exit:
#endif // OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
}
template <typename InterfaceType, typename ProcessContextType>
uint64_t RadioSpinel<InterfaceType, ProcessContextType>::GetNow(void)
template <typename InterfaceType> uint64_t RadioSpinel<InterfaceType>::GetNow(void)
{
return (mIsTimeSynced) ? (otPlatTimeGet() + mRadioTimeOffset) : UINT64_MAX;
}
template <typename InterfaceType, typename ProcessContextType>
uint32_t RadioSpinel<InterfaceType, ProcessContextType>::GetBusSpeed(void) const
template <typename InterfaceType> uint32_t RadioSpinel<InterfaceType>::GetBusSpeed(void) const
{
return mSpinelInterface.GetBusSpeed();
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleRcpUnexpectedReset(spinel_status_t aStatus)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::HandleRcpUnexpectedReset(spinel_status_t aStatus)
{
OT_UNUSED_VARIABLE(aStatus);
@@ -2290,8 +2233,7 @@ void RadioSpinel<InterfaceType, ProcessContextType>::HandleRcpUnexpectedReset(sp
#endif
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::HandleRcpTimeout(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::HandleRcpTimeout(void)
{
mRadioSpinelMetrics.mRcpTimeoutCount++;
@@ -2310,8 +2252,7 @@ void RadioSpinel<InterfaceType, ProcessContextType>::HandleRcpTimeout(void)
#endif
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::RecoverFromRcpFailure(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::RecoverFromRcpFailure(void)
{
#if OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT > 0
constexpr int16_t kMaxFailureCount = OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT;
@@ -2381,8 +2322,7 @@ exit:
}
#if OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT > 0
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::RestoreProperties(void)
template <typename InterfaceType> void RadioSpinel<InterfaceType>::RestoreProperties(void)
{
Settings::NetworkInfo networkInfo;
@@ -2461,8 +2401,8 @@ void RadioSpinel<InterfaceType, ProcessContextType>::RestoreProperties(void)
}
#endif // OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT > 0
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetChannelMaxTransmitPower(uint8_t aChannel, int8_t aMaxPower)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::SetChannelMaxTransmitPower(uint8_t aChannel, int8_t aMaxPower)
{
otError error = OT_ERROR_NONE;
VerifyOrExit(aChannel >= Radio::kChannelMin && aChannel <= Radio::kChannelMax, error = OT_ERROR_INVALID_ARGS);
@@ -2473,8 +2413,7 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetRadioRegion(uint16_t aRegionCode)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::SetRadioRegion(uint16_t aRegionCode)
{
otError error;
@@ -2494,8 +2433,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::SetRadioRegion(uint16_t
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::GetRadioRegion(uint16_t *aRegionCode)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::GetRadioRegion(uint16_t *aRegionCode)
{
otError error = OT_ERROR_NONE;
@@ -2507,10 +2445,10 @@ exit:
}
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ConfigureEnhAckProbing(otLinkMetrics aLinkMetrics,
const otShortAddress aShortAddress,
const otExtAddress &aExtAddress)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::ConfigureEnhAckProbing(otLinkMetrics aLinkMetrics,
const otShortAddress aShortAddress,
const otExtAddress &aExtAddress)
{
otError error = OT_ERROR_NONE;
uint8_t flags = 0;
@@ -2544,8 +2482,7 @@ otError RadioSpinel<InterfaceType, ProcessContextType>::ConfigureEnhAckProbing(o
#endif
#if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE || OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE
template <typename InterfaceType, typename ProcessContextType>
uint8_t RadioSpinel<InterfaceType, ProcessContextType>::GetCslAccuracy(void)
template <typename InterfaceType> uint8_t RadioSpinel<InterfaceType>::GetCslAccuracy(void)
{
uint8_t accuracy = UINT8_MAX;
otError error = Get(SPINEL_PROP_RCP_CSL_ACCURACY, SPINEL_DATATYPE_UINT8_S, &accuracy);
@@ -2556,8 +2493,7 @@ uint8_t RadioSpinel<InterfaceType, ProcessContextType>::GetCslAccuracy(void)
#endif
#if OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE
template <typename InterfaceType, typename ProcessContextType>
uint8_t RadioSpinel<InterfaceType, ProcessContextType>::GetCslUncertainty(void)
template <typename InterfaceType> uint8_t RadioSpinel<InterfaceType>::GetCslUncertainty(void)
{
uint8_t uncertainty = UINT8_MAX;
otError error = Get(SPINEL_PROP_RCP_CSL_UNCERTAINTY, SPINEL_DATATYPE_UINT8_S, &uncertainty);
@@ -2568,11 +2504,11 @@ uint8_t RadioSpinel<InterfaceType, ProcessContextType>::GetCslUncertainty(void)
#endif
#if OPENTHREAD_CONFIG_PLATFORM_POWER_CALIBRATION_ENABLE
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::AddCalibratedPower(uint8_t aChannel,
int16_t aActualPower,
const uint8_t *aRawPowerSetting,
uint16_t aRawPowerSettingLength)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::AddCalibratedPower(uint8_t aChannel,
int16_t aActualPower,
const uint8_t *aRawPowerSetting,
uint16_t aRawPowerSettingLength)
{
otError error;
@@ -2585,14 +2521,13 @@ exit:
return error;
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::ClearCalibratedPowers(void)
template <typename InterfaceType> otError RadioSpinel<InterfaceType>::ClearCalibratedPowers(void)
{
return Set(SPINEL_PROP_PHY_CALIBRATED_POWER, nullptr);
}
template <typename InterfaceType, typename ProcessContextType>
otError RadioSpinel<InterfaceType, ProcessContextType>::SetChannelTargetPower(uint8_t aChannel, int16_t aTargetPower)
template <typename InterfaceType>
otError RadioSpinel<InterfaceType>::SetChannelTargetPower(uint8_t aChannel, int16_t aTargetPower)
{
otError error = OT_ERROR_NONE;
VerifyOrExit(aChannel >= Radio::kChannelMin && aChannel <= Radio::kChannelMax, error = OT_ERROR_INVALID_ARGS);
@@ -2604,8 +2539,8 @@ exit:
}
#endif // OPENTHREAD_CONFIG_PLATFORM_POWER_CALIBRATION_ENABLE
template <typename InterfaceType, typename ProcessContextType>
uint32_t RadioSpinel<InterfaceType, ProcessContextType>::Snprintf(char *aDest, uint32_t aSize, const char *aFormat, ...)
template <typename InterfaceType>
uint32_t RadioSpinel<InterfaceType>::Snprintf(char *aDest, uint32_t aSize, const char *aFormat, ...)
{
int len;
va_list args;
@@ -2617,8 +2552,8 @@ uint32_t RadioSpinel<InterfaceType, ProcessContextType>::Snprintf(char *aDest, u
return (len < 0) ? 0 : Min(static_cast<uint32_t>(len), aSize - 1);
}
template <typename InterfaceType, typename ProcessContextType>
void RadioSpinel<InterfaceType, ProcessContextType>::LogSpinelFrame(const uint8_t *aFrame, uint16_t aLength, bool aTx)
template <typename InterfaceType>
void RadioSpinel<InterfaceType>::LogSpinelFrame(const uint8_t *aFrame, uint16_t aLength, bool aTx)
{
otError error = OT_ERROR_NONE;
char buf[OPENTHREAD_CONFIG_LOG_MAX_SIZE] = {0};
src/lib/spinel/spinel_interface.hpp
+5 -7
View File
@@ -37,6 +37,7 @@
#include "lib/hdlc/hdlc.hpp"
#include "lib/spinel/spinel.h"
#include "lib/url/url.hpp"
namespace ot {
namespace Spinel {
@@ -125,21 +126,18 @@ public:
/**
* Updates the file descriptor sets with file descriptors used by the radio driver.
*
* @param[in,out] aReadFdSet A reference to the read file descriptors.
* @param[in,out] aWriteFdSet A reference to the write file descriptors.
* @param[in,out] aMaxFd A reference to the max file descriptor.
* @param[in,out] aTimeout A reference to the timeout.
* @param[in,out] aMainloopContext A pointer to the mainloop context.
*
*/
virtual void UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMaxFd, struct timeval &aTimeout) = 0;
virtual void UpdateFdSet(void *aMainloopContext) = 0;
/**
* Performs radio driver processing.
*
* @param[in] aContext The context containing fd_sets.
* @param[in] aMainloopContext A pointer to the mainloop context.
*
*/
virtual void Process(const RadioProcessContext &aContext) = 0;
virtual void Process(const void *aMainloopContext) = 0;
/**
* Returns the bus speed between the host and the radio.
src/posix/platform/hdlc_interface.cpp
+27 -8
View File
@@ -339,25 +339,44 @@ exit:
return error;
}
void HdlcInterface::UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMaxFd, struct timeval &aTimeout)
void HdlcInterface::UpdateFdSet(void *aMainloopContext)
{
OT_UNUSED_VARIABLE(aWriteFdSet);
OT_UNUSED_VARIABLE(aTimeout);
otSysMainloopContext *context = reinterpret_cast<otSysMainloopContext *>(aMainloopContext);
FD_SET(mSockFd, &aReadFdSet);
assert(context != nullptr);
if (aMaxFd < mSockFd)
FD_SET(mSockFd, &context->mReadFdSet);
if (context->mMaxFd < mSockFd)
{
aMaxFd = mSockFd;
context->mMaxFd = mSockFd;
}
}
void HdlcInterface::Process(const RadioProcessContext &aContext)
void HdlcInterface::Process(const void *aMainloopContext)
{
if (FD_ISSET(mSockFd, aContext.mReadFdSet))
#if OPENTHREAD_POSIX_VIRTUAL_TIME
/**
* Process read data (decode the data).
*
* Is intended only for virtual time simulation. Its behavior is similar to `Read()` but instead of
* reading the data from the radio socket, it uses the given data in @p `event`.
*/
const VirtualTimeEvent *event = reinterpret_cast<const VirtualTimeEvent *>(aMainloopContext);
assert(event != nullptr);
Decode(event->mData, event->mDataLength);
#else
const otSysMainloopContext *context = reinterpret_cast<const otSysMainloopContext *>(aMainloopContext);
assert(context != nullptr);
if (FD_ISSET(mSockFd, &context->mReadFdSet))
{
Read();
}
#endif
}
otError HdlcInterface::WaitForWritable(void)
src/posix/platform/hdlc_interface.hpp
+4 -20
View File
@@ -118,34 +118,18 @@ public:
/**
* Updates the file descriptor sets with file descriptors used by the radio driver.
*
* @param[in,out] aReadFdSet A reference to the read file descriptors.
* @param[in,out] aWriteFdSet A reference to the write file descriptors.
* @param[in,out] aMaxFd A reference to the max file descriptor.
* @param[in,out] aTimeout A reference to the timeout.
* @param[in,out] aMainloopContext A pointer to the mainloop context containing fd_sets.
*
*/
void UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMaxFd, struct timeval &aTimeout);
void UpdateFdSet(void *aMainloopContext);
/**
* Performs radio driver processing.
*
* @param[in] aContext The context containing fd_sets.
* @param[in] aMainloopContext A pointer to the mainloop context containing fd_sets.
*
*/
void Process(const RadioProcessContext &aContext);
#if OPENTHREAD_POSIX_VIRTUAL_TIME
/**
* Process read data (decode the data).
*
* Is intended only for virtual time simulation. Its behavior is similar to `Read()` but instead of
* reading the data from the radio socket, it uses the given data in @p `aEvent`.
*
* @param[in] aEvent The data event.
*
*/
void Process(const VirtualTimeEvent &aEvent) { Decode(aEvent.mData, aEvent.mDataLength); }
#endif
void Process(const void *aMainloopContext);
/**
* Returns the bus speed between the host and the radio.
src/posix/platform/netif.cpp
+24 -25
View File
@@ -1999,93 +1999,92 @@ void platformNetifDeinit(void)
gNetifIndex = 0;
}
void platformNetifUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, fd_set *aErrorFdSet, int *aMaxFd)
void platformNetifUpdateFdSet(otSysMainloopContext *aContext)
{
OT_UNUSED_VARIABLE(aWriteFdSet);
VerifyOrExit(gNetifIndex > 0);
assert(aContext != nullptr);
assert(sTunFd >= 0);
assert(sNetlinkFd >= 0);
assert(sIpFd >= 0);
FD_SET(sTunFd, aReadFdSet);
FD_SET(sTunFd, aErrorFdSet);
FD_SET(sNetlinkFd, aReadFdSet);
FD_SET(sNetlinkFd, aErrorFdSet);
FD_SET(sTunFd, &aContext->mReadFdSet);
FD_SET(sTunFd, &aContext->mErrorFdSet);
FD_SET(sNetlinkFd, &aContext->mReadFdSet);
FD_SET(sNetlinkFd, &aContext->mErrorFdSet);
#if OPENTHREAD_POSIX_USE_MLD_MONITOR
FD_SET(sMLDMonitorFd, aReadFdSet);
FD_SET(sMLDMonitorFd, aErrorFdSet);
FD_SET(sMLDMonitorFd, &aContext->mReadFdSet);
FD_SET(sMLDMonitorFd, &aContext->mErrorFdSet);
#endif
#if OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE
gResolver.UpdateFdSet(aReadFdSet, aErrorFdSet, aMaxFd);
gResolver.UpdateFdSet(*aContext);
#endif
if (sTunFd > *aMaxFd)
if (sTunFd > aContext->mMaxFd)
{
*aMaxFd = sTunFd;
aContext->mMaxFd = sTunFd;
}
if (sNetlinkFd > *aMaxFd)
if (sNetlinkFd > aContext->mMaxFd)
{
*aMaxFd = sNetlinkFd;
aContext->mMaxFd = sNetlinkFd;
}
#if OPENTHREAD_POSIX_USE_MLD_MONITOR
if (sMLDMonitorFd > *aMaxFd)
if (sMLDMonitorFd > aContext->mMaxFd)
{
*aMaxFd = sMLDMonitorFd;
aContext->mMaxFd = sMLDMonitorFd;
}
#endif
exit:
return;
}
void platformNetifProcess(const fd_set *aReadFdSet, const fd_set *aWriteFdSet, const fd_set *aErrorFdSet)
void platformNetifProcess(const otSysMainloopContext *aContext)
{
OT_UNUSED_VARIABLE(aWriteFdSet);
assert(aContext != nullptr);
VerifyOrExit(gNetifIndex > 0);
if (FD_ISSET(sTunFd, aErrorFdSet))
if (FD_ISSET(sTunFd, &aContext->mErrorFdSet))
{
close(sTunFd);
DieNow(OT_EXIT_FAILURE);
}
if (FD_ISSET(sNetlinkFd, aErrorFdSet))
if (FD_ISSET(sNetlinkFd, &aContext->mErrorFdSet))
{
close(sNetlinkFd);
DieNow(OT_EXIT_FAILURE);
}
#if OPENTHREAD_POSIX_USE_MLD_MONITOR
if (FD_ISSET(sMLDMonitorFd, aErrorFdSet))
if (FD_ISSET(sMLDMonitorFd, &aContext->mErrorFdSet))
{
close(sMLDMonitorFd);
DieNow(OT_EXIT_FAILURE);
}
#endif
if (FD_ISSET(sTunFd, aReadFdSet))
if (FD_ISSET(sTunFd, &aContext->mReadFdSet))
{
processTransmit(gInstance);
}
if (FD_ISSET(sNetlinkFd, aReadFdSet))
if (FD_ISSET(sNetlinkFd, &aContext->mReadFdSet))
{
processNetlinkEvent(gInstance);
}
#if OPENTHREAD_POSIX_USE_MLD_MONITOR
if (FD_ISSET(sMLDMonitorFd, aReadFdSet))
if (FD_ISSET(sMLDMonitorFd, &aContext->mReadFdSet))
{
processMLDEvent(gInstance);
}
#endif
#if OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE
gResolver.Process(aReadFdSet, aErrorFdSet);
gResolver.Process(*aContext);
#endif
exit:
src/posix/platform/platform-posix.h
+20 -58
View File
@@ -93,12 +93,6 @@ struct VirtualTimeEvent
uint8_t mData[OT_EVENT_DATA_MAX_SIZE];
} OT_TOOL_PACKED_END;
struct RadioProcessContext
{
const fd_set *mReadFdSet;
const fd_set *mWriteFdSet;
};
/**
* Initializes the alarm service used by OpenThread.
*
@@ -183,23 +177,18 @@ void platformRadioReceive(otInstance *aInstance, uint8_t *aBuf, uint16_t aBufLen
/**
* Updates the file descriptor sets with file descriptors used by the radio driver.
*
* @param[in,out] aReadFdSet A pointer to the read file descriptors.
* @param[in,out] aWriteFdSet A pointer to the write file descriptors.
* @param[in,out] aMaxFd A pointer to the max file descriptor.
* @param[in,out] aTimeout A pointer to the timeout.
* @param[in] aContext A pointer to the mainloop context.
*
*/
void platformRadioUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, int *aMaxFd, struct timeval *aTimeout);
void platformRadioUpdateFdSet(otSysMainloopContext *aContext);
/**
* Performs radio driver processing.
*
* @param[in] aInstance A pointer to the OpenThread instance.
* @param[in] aReadFdSet A pointer to the read file descriptors.
* @param[in] aWriteFdSet A pointer to the write file descriptors.
* @param[in] aContext A pointer to the mainloop context.
*
*/
void platformRadioProcess(otInstance *aInstance, const fd_set *aReadFdSet, const fd_set *aWriteFdSet);
void platformRadioProcess(otInstance *aInstance, const otSysMainloopContext *aContext);
/**
* Initializes the random number service used by OpenThread.
@@ -218,22 +207,18 @@ void platformLoggingInit(const char *aName);
/**
* Updates the file descriptor sets with file descriptors used by the UART driver.
*
* @param[in,out] aReadFdSet A pointer to the read file descriptors.
* @param[in,out] aWriteFdSet A pointer to the write file descriptors.
* @param[in,out] aMaxFd A pointer to the max file descriptor.
* @param[in] aContext A pointer to the mainloop context.
*
*/
void platformUartUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, fd_set *aErrorFdSet, int *aMaxFd);
void platformUartUpdateFdSet(otSysMainloopContext *aContext);
/**
* Performs radio driver processing.
*
* @param[in] aReadFdSet A pointer to the read file descriptors.
* @param[in] aWriteFdSet A pointer to the write file descriptors.
* @param[in] aErrorFdSet A pointer to the error file descriptors.
* @param[in] aContext A pointer to the mainloop context.
*
*/
void platformUartProcess(const fd_set *aReadFdSet, const fd_set *aWriteFdSet, const fd_set *aErrorFdSet);
void platformUartProcess(const otSysMainloopContext *aContext);
/**
* Initializes platform netif.
@@ -274,23 +259,18 @@ void platformNetifDeinit(void);
/**
* Updates the file descriptor sets with file descriptors used by platform netif module.
*
* @param[in,out] aReadFdSet A pointer to the read file descriptors.
* @param[in,out] aWriteFdSet A pointer to the write file descriptors.
* @param[in,out] aErrorFdSet A pointer to the error file descriptors.
* @param[in,out] aMaxFd A pointer to the max file descriptor.
* @param[in,out] aContext A pointer to the mainloop context.
*
*/
void platformNetifUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, fd_set *aErrorFdSet, int *aMaxFd);
void platformNetifUpdateFdSet(otSysMainloopContext *aContext);
/**
* Performs platform netif processing.
*
* @param[in] aReadFdSet A pointer to the read file descriptors.
* @param[in] aWriteFdSet A pointer to the write file descriptors.
* @param[in] aErrorFdSet A pointer to the error file descriptors.
* @param[in] aContext A pointer to the mainloop context.
*
*/
void platformNetifProcess(const fd_set *aReadFdSet, const fd_set *aWriteFdSet, const fd_set *aErrorFdSet);
void platformNetifProcess(const otSysMainloopContext *aContext);
/**
* Performs notifies state changes to platform netif.
@@ -318,32 +298,19 @@ void virtualTimeDeinit(void);
/**
* Performs virtual time simulation processing.
*
* @param[in] aInstance A pointer to the OpenThread instance.
* @param[in] aReadFdSet A pointer to the read file descriptors.
* @param[in] aWriteFdSet A pointer to the write file descriptors.
* @param[in] aContext A pointer to the mainloop context.
*
*/
void virtualTimeProcess(otInstance *aInstance,
const fd_set *aReadFdSet,
const fd_set *aWriteFdSet,
const fd_set *aErrorFdSet);
void virtualTimeProcess(otInstance *aInstance, const otSysMainloopContext *aContext);
/**
* Updates the file descriptor sets with file descriptors
* used by the virtual time simulation.
*
* @param[in,out] aReadFdSet A pointer to the read file descriptors.
* @param[in,out] aWriteFdSet A pointer to the write file descriptors.
* @param[in,out] aErrorFdSet A pointer to the error file descriptors.
* @param[in,out] aMaxFd A pointer to the max file descriptor.
* @param[in,out] aTimeout A pointer to the timeout.
* @param[in,out] aContext A pointer to the mainloop context.
*
*/
void virtualTimeUpdateFdSet(fd_set *aReadFdSet,
fd_set *aWriteFdSet,
fd_set *aErrorFdSet,
int *aMaxFd,
struct timeval *aTimeout);
void virtualTimeUpdateFdSet(otSysMainloopContext *aContext);
/**
* Sends radio spinel event of virtual time simulation.
@@ -402,23 +369,18 @@ void platformTrelDeinit(void);
/**
* Updates the file descriptor sets with file descriptors used by the TREL driver.
*
* @param[in,out] aReadFdSet A pointer to the read file descriptors.
* @param[in,out] aWriteFdSet A pointer to the write file descriptors.
* @param[in,out] aMaxFd A pointer to the max file descriptor.
* @param[in,out] aTimeout A pointer to the timeout.
* @param[in,out] aContext A pointer to the mainloop context.
*
*/
void platformTrelUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, int *aMaxFd, struct timeval *aTimeout);
void platformTrelUpdateFdSet(otSysMainloopContext *aContext);
/**
* Performs TREL driver processing.
*
* @param[in] aInstance A pointer to the OpenThread instance.
* @param[in] aReadFdSet A pointer to the read file descriptors.
* @param[in] aWriteFdSet A pointer to the write file descriptors.
* @param[in] aContext A pointer to the mainloop context.
*
*/
void platformTrelProcess(otInstance *aInstance, const fd_set *aReadFdSet, const fd_set *aWriteFdSet);
void platformTrelProcess(otInstance *aInstance, const otSysMainloopContext *aContext);
/**
* Creates a socket with SOCK_CLOEXEC flag set.
src/posix/platform/radio.cpp
+16 -20
View File
@@ -46,19 +46,15 @@
#if OPENTHREAD_POSIX_CONFIG_RCP_BUS == OT_POSIX_RCP_BUS_UART
#include "hdlc_interface.hpp"
#if OPENTHREAD_POSIX_VIRTUAL_TIME
static ot::Spinel::RadioSpinel<ot::Posix::HdlcInterface, VirtualTimeEvent> sRadioSpinel;
#else
static ot::Spinel::RadioSpinel<ot::Posix::HdlcInterface, RadioProcessContext> sRadioSpinel;
#endif // OPENTHREAD_POSIX_VIRTUAL_TIME
static ot::Spinel::RadioSpinel<ot::Posix::HdlcInterface> sRadioSpinel;
#elif OPENTHREAD_POSIX_CONFIG_RCP_BUS == OT_POSIX_RCP_BUS_SPI
#include "spi_interface.hpp"
static ot::Spinel::RadioSpinel<ot::Posix::SpiInterface, RadioProcessContext> sRadioSpinel;
static ot::Spinel::RadioSpinel<ot::Posix::SpiInterface> sRadioSpinel;
#elif OPENTHREAD_POSIX_CONFIG_RCP_BUS == OT_POSIX_RCP_BUS_VENDOR
#include "vendor_interface.hpp"
static ot::Spinel::RadioSpinel<ot::Posix::VendorInterface, RadioProcessContext> sRadioSpinel;
static ot::Spinel::RadioSpinel<ot::Posix::VendorInterface> sRadioSpinel;
#else
#error "OPENTHREAD_POSIX_CONFIG_RCP_BUS only allows OT_POSIX_RCP_BUS_UART, OT_POSIX_RCP_BUS_SPI and " \
"OT_POSIX_RCP_BUS_VENDOR!"
@@ -313,7 +309,7 @@ bool otPlatRadioGetPromiscuous(otInstance *aInstance)
return sRadioSpinel.IsPromiscuous();
}
void platformRadioUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, int *aMaxFd, struct timeval *aTimeout)
void platformRadioUpdateFdSet(otSysMainloopContext *aContext)
{
uint64_t now = otPlatTimeGet();
uint64_t deadline = sRadioSpinel.GetNextRadioTimeRecalcStart();
@@ -332,24 +328,25 @@ void platformRadioUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, int *aMax
{
uint64_t remain = deadline - now;
if (remain < (static_cast<uint64_t>(aTimeout->tv_sec) * US_PER_S + static_cast<uint64_t>(aTimeout->tv_usec)))
if (remain < (static_cast<uint64_t>(aContext->mTimeout.tv_sec) * US_PER_S +
static_cast<uint64_t>(aContext->mTimeout.tv_usec)))
{
aTimeout->tv_sec = static_cast<time_t>(remain / US_PER_S);
aTimeout->tv_usec = static_cast<suseconds_t>(remain % US_PER_S);
aContext->mTimeout.tv_sec = static_cast<time_t>(remain / US_PER_S);
aContext->mTimeout.tv_usec = static_cast<suseconds_t>(remain % US_PER_S);
}
}
else
{
aTimeout->tv_sec = 0;
aTimeout->tv_usec = 0;
aContext->mTimeout.tv_sec = 0;
aContext->mTimeout.tv_usec = 0;
}
sRadioSpinel.GetSpinelInterface().UpdateFdSet(*aReadFdSet, *aWriteFdSet, *aMaxFd, *aTimeout);
sRadioSpinel.GetSpinelInterface().UpdateFdSet(aContext);
if (sRadioSpinel.HasPendingFrame() || sRadioSpinel.IsTransmitDone())
{
aTimeout->tv_sec = 0;
aTimeout->tv_usec = 0;
aContext->mTimeout.tv_sec = 0;
aContext->mTimeout.tv_usec = 0;
}
}
@@ -357,15 +354,14 @@ void platformRadioUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, int *aMax
void virtualTimeRadioSpinelProcess(otInstance *aInstance, const struct VirtualTimeEvent *aEvent)
{
OT_UNUSED_VARIABLE(aInstance);
sRadioSpinel.Process(*aEvent);
sRadioSpinel.Process(aEvent);
}
#else
void platformRadioProcess(otInstance *aInstance, const fd_set *aReadFdSet, const fd_set *aWriteFdSet)
void platformRadioProcess(otInstance *aInstance, const otSysMainloopContext *aContext)
{
OT_UNUSED_VARIABLE(aInstance);
RadioProcessContext context = {aReadFdSet, aWriteFdSet};
sRadioSpinel.Process(context);
sRadioSpinel.Process(aContext);
}
#endif // OPENTHREAD_POSIX_VIRTUAL_TIME
src/posix/platform/resolver.cpp
+7 -7
View File
@@ -257,30 +257,30 @@ void Resolver::CloseTransaction(Transaction *aTxn)
aTxn->mThreadTxn = nullptr;
}
void Resolver::UpdateFdSet(fd_set *aReadFdSet, fd_set *aErrorFdSet, int *aMaxFd)
void Resolver::UpdateFdSet(otSysMainloopContext &aContext)
{
for (Transaction &txn : mUpstreamTransaction)
{
if (txn.mThreadTxn != nullptr)
{
FD_SET(txn.mUdpFd, aReadFdSet);
FD_SET(txn.mUdpFd, aErrorFdSet);
if (txn.mUdpFd > *aMaxFd)
FD_SET(txn.mUdpFd, &aContext.mReadFdSet);
FD_SET(txn.mUdpFd, &aContext.mErrorFdSet);
if (txn.mUdpFd > aContext.mMaxFd)
{
*aMaxFd = txn.mUdpFd;
aContext.mMaxFd = txn.mUdpFd;
}
}
}
}
void Resolver::Process(const fd_set *aReadFdSet, const fd_set *aErrorFdSet)
void Resolver::Process(const otSysMainloopContext &aContext)
{
for (Transaction &txn : mUpstreamTransaction)
{
if (txn.mThreadTxn != nullptr)
{
// Note: On Linux, we can only get the error via read, so they should share the same logic.
if (FD_ISSET(txn.mUdpFd, aErrorFdSet) || FD_ISSET(txn.mUdpFd, aReadFdSet))
if (FD_ISSET(txn.mUdpFd, &aContext.mErrorFdSet) || FD_ISSET(txn.mUdpFd, &aContext.mReadFdSet))
{
ForwardResponse(&txn);
CloseTransaction(&txn);
src/posix/platform/resolver.hpp
+3 -2
View File
@@ -29,6 +29,7 @@
#ifndef POSIX_PLATFORM_RESOLVER_HPP_
#define POSIX_PLATFORM_RESOLVER_HPP_
#include <openthread/openthread-system.h>
#include <openthread/platform/dns.h>
#include <arpa/inet.h>
@@ -78,7 +79,7 @@ public:
* @param[in,out] aTimeout A reference to the timeout.
*
*/
void UpdateFdSet(fd_set *aReadFdSet, fd_set *aErrorFdSet, int *aMaxFd);
void UpdateFdSet(otSysMainloopContext &aContext);
/**
* Handles the result of select.
@@ -87,7 +88,7 @@ public:
* @param[in] aErrorFdSet A reference to the error file descriptors.
*
*/
void Process(const fd_set *aReadFdSet, const fd_set *aErrorFdSet);
void Process(const otSysMainloopContext &aContext);
private:
static constexpr uint64_t kDnsServerListNullCacheTimeoutMs = 1 * 60 * 1000; // 1 minute
src/posix/platform/spi_interface.cpp
+25 -26
View File
@@ -629,12 +629,13 @@ bool SpiInterface::CheckInterrupt(void)
return (mIntGpioValueFd >= 0) ? (GetGpioValue(mIntGpioValueFd) == kGpioIntAssertState) : true;
}
void SpiInterface::UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMaxFd, struct timeval &aTimeout)
void SpiInterface::UpdateFdSet(void *aMainloopContext)
{
struct timeval timeout = {kSecPerDay, 0};
struct timeval pollingTimeout = {0, kSpiPollPeriodUs};
struct timeval timeout = {kSecPerDay, 0};
struct timeval pollingTimeout = {0, kSpiPollPeriodUs};
otSysMainloopContext *context = reinterpret_cast<otSysMainloopContext *>(aMainloopContext);
OT_UNUSED_VARIABLE(aWriteFdSet);
assert(context != nullptr);
if (mSpiTxIsReady)
{
@@ -645,9 +646,9 @@ void SpiInterface::UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMa
if (mIntGpioValueFd >= 0)
{
if (aMaxFd < mIntGpioValueFd)
if (context->mMaxFd < mIntGpioValueFd)
{
aMaxFd = mIntGpioValueFd;
context->mMaxFd = mIntGpioValueFd;
}
if (CheckInterrupt())
@@ -661,7 +662,7 @@ void SpiInterface::UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMa
{
// The interrupt pin was not asserted, so we wait for the interrupt pin to be asserted by adding it to the
// read set.
FD_SET(mIntGpioValueFd, &aReadFdSet);
FD_SET(mIntGpioValueFd, &context->mReadFdSet);
}
}
else if (timercmp(&pollingTimeout, &timeout, <))
@@ -721,19 +722,19 @@ void SpiInterface::UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMa
mDidPrintRateLimitLog = false;
}
if (timercmp(&timeout, &aTimeout, <))
if (timercmp(&timeout, &context->mTimeout, <))
{
aTimeout = timeout;
context->mTimeout = timeout;
}
}
void SpiInterface::Process(const RadioProcessContext &aContext) { Process(aContext.mReadFdSet, aContext.mWriteFdSet); }
void SpiInterface::Process(const fd_set *aReadFdSet, const fd_set *aWriteFdSet)
void SpiInterface::Process(const void *aMainloopContext)
{
OT_UNUSED_VARIABLE(aWriteFdSet);
const otSysMainloopContext *context = reinterpret_cast<const otSysMainloopContext *>(aMainloopContext);
if (FD_ISSET(mIntGpioValueFd, aReadFdSet))
assert(context != nullptr);
if (FD_ISSET(mIntGpioValueFd, &context->mReadFdSet))
{
struct gpioevent_data event;
@@ -761,25 +762,23 @@ otError SpiInterface::WaitForFrame(uint64_t aTimeoutUs)
while (now < end)
{
fd_set readFdSet;
fd_set writeFdSet;
int maxFds = -1;
struct timeval timeout;
int ret;
otSysMainloopContext context;
int ret;
timeout.tv_sec = static_cast<time_t>((end - now) / US_PER_S);
timeout.tv_usec = static_cast<suseconds_t>((end - now) % US_PER_S);
context.mMaxFd = -1;
context.mTimeout.tv_sec = static_cast<time_t>((end - now) / US_PER_S);
context.mTimeout.tv_usec = static_cast<suseconds_t>((end - now) % US_PER_S);
FD_ZERO(&readFdSet);
FD_ZERO(&writeFdSet);
FD_ZERO(&context.mReadFdSet);
FD_ZERO(&context.mWriteFdSet);
UpdateFdSet(readFdSet, writeFdSet, maxFds, timeout);
UpdateFdSet(&context);
ret = select(maxFds + 1, &readFdSet, &writeFdSet, nullptr, &timeout);
ret = select(context.mMaxFd + 1, &context.mReadFdSet, &context.mWriteFdSet, nullptr, &context.mTimeout);
if (ret >= 0)
{
Process(&readFdSet, &writeFdSet);
Process(&context);
if (mDidRxFrame)
{
src/posix/platform/spi_interface.hpp
+4 -8
View File
@@ -120,21 +120,18 @@ public:
/**
* Updates the file descriptor sets with file descriptors used by the radio driver.
*
* @param[in,out] aReadFdSet A reference to the read file descriptors.
* @param[in,out] aWriteFdSet A reference to the write file descriptors.
* @param[in,out] aMaxFd A reference to the max file descriptor.
* @param[in,out] aTimeout A reference to the timeout.
* @param[in,out] aMainloopContext A pointer to the mainloop context containing fd_sets.
*
*/
void UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMaxFd, struct timeval &aTimeout);
void UpdateFdSet(void *aMainloopContext);
/**
* Performs radio driver processing.
*
* @param[in] aContext The context containing fd_sets.
* @param[in] aMainloopContext A pointer to the mainloop context containing fd_sets.
*
*/
void Process(const RadioProcessContext &aContext);
void Process(const void *aMainloopContext);
/**
* Returns the bus speed between the host and the radio.
@@ -176,7 +173,6 @@ private:
uint8_t *GetRealRxFrameStart(uint8_t *aSpiRxFrameBuffer, uint8_t aAlignAllowance, uint16_t &aSkipLength);
otError DoSpiTransfer(uint8_t *aSpiRxFrameBuffer, uint32_t aTransferLength);
otError PushPullSpi(void);
void Process(const fd_set *aReadFdSet, const fd_set *aWriteFdSet);
bool CheckInterrupt(void);
void LogStats(void);
src/posix/platform/system.cpp
+18 -23
View File
@@ -285,29 +285,26 @@ void otSysDeinit(void)
/**
* Try selecting the given file descriptors in nonblocking mode.
*
* @param[in,out] aReadFdSet A pointer to the read file descriptors.
* @param[in,out] aWriteFdSet A pointer to the write file descriptors.
* @param[in,out] aErrorFdSet A pointer to the error file descriptors.
* @param[in] aMaxFd The max file descriptor.
* @param[in,out] aContext A reference to the mainloop context.
*
* @returns The value returned from select().
*
*/
static int trySelect(fd_set *aReadFdSet, fd_set *aWriteFdSet, fd_set *aErrorFdSet, int aMaxFd)
static int trySelect(otSysMainloopContext &aContext)
{
struct timeval timeout = {0, 0};
fd_set originReadFdSet = *aReadFdSet;
fd_set originWriteFdSet = *aWriteFdSet;
fd_set originErrorFdSet = *aErrorFdSet;
fd_set originReadFdSet = aContext.mReadFdSet;
fd_set originWriteFdSet = aContext.mWriteFdSet;
fd_set originErrorFdSet = aContext.mErrorFdSet;
int rval;
rval = select(aMaxFd + 1, aReadFdSet, aWriteFdSet, aErrorFdSet, &timeout);
rval = select(aContext.mMaxFd + 1, &aContext.mReadFdSet, &aContext.mWriteFdSet, &aContext.mErrorFdSet, &timeout);
if (rval == 0)
{
*aReadFdSet = originReadFdSet;
*aWriteFdSet = originWriteFdSet;
*aErrorFdSet = originErrorFdSet;
aContext.mReadFdSet = originReadFdSet;
aContext.mWriteFdSet = originWriteFdSet;
aContext.mErrorFdSet = originErrorFdSet;
}
return rval;
@@ -320,17 +317,15 @@ void otSysMainloopUpdate(otInstance *aInstance, otSysMainloopContext *aMainloop)
platformAlarmUpdateTimeout(&aMainloop->mTimeout);
#if OPENTHREAD_CONFIG_PLATFORM_NETIF_ENABLE
platformNetifUpdateFdSet(&aMainloop->mReadFdSet, &aMainloop->mWriteFdSet, &aMainloop->mErrorFdSet,
&aMainloop->mMaxFd);
platformNetifUpdateFdSet(aMainloop);
#endif
#if OPENTHREAD_POSIX_VIRTUAL_TIME
virtualTimeUpdateFdSet(&aMainloop->mReadFdSet, &aMainloop->mWriteFdSet, &aMainloop->mErrorFdSet, &aMainloop->mMaxFd,
&aMainloop->mTimeout);
virtualTimeUpdateFdSet(aMainloop);
#else
platformRadioUpdateFdSet(&aMainloop->mReadFdSet, &aMainloop->mWriteFdSet, &aMainloop->mMaxFd, &aMainloop->mTimeout);
platformRadioUpdateFdSet(aMainloop);
#endif
#if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
platformTrelUpdateFdSet(&aMainloop->mReadFdSet, &aMainloop->mWriteFdSet, &aMainloop->mMaxFd, &aMainloop->mTimeout);
platformTrelUpdateFdSet(aMainloop);
#endif
if (otTaskletsArePending(aInstance))
@@ -348,7 +343,7 @@ int otSysMainloopPoll(otSysMainloopContext *aMainloop)
if (timerisset(&aMainloop->mTimeout))
{
// Make sure there are no data ready in UART
rval = trySelect(&aMainloop->mReadFdSet, &aMainloop->mWriteFdSet, &aMainloop->mErrorFdSet, aMainloop->mMaxFd);
rval = trySelect(*aMainloop);
if (rval == 0)
{
@@ -388,16 +383,16 @@ void otSysMainloopProcess(otInstance *aInstance, const otSysMainloopContext *aMa
ot::Posix::Mainloop::Manager::Get().Process(*aMainloop);
#if OPENTHREAD_POSIX_VIRTUAL_TIME
virtualTimeProcess(aInstance, &aMainloop->mReadFdSet, &aMainloop->mWriteFdSet, &aMainloop->mErrorFdSet);
virtualTimeProcess(aInstance, aMainloop);
#else
platformRadioProcess(aInstance, &aMainloop->mReadFdSet, &aMainloop->mWriteFdSet);
platformRadioProcess(aInstance, aMainloop);
#endif
#if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
platformTrelProcess(aInstance, &aMainloop->mReadFdSet, &aMainloop->mWriteFdSet);
platformTrelProcess(aInstance, aMainloop);
#endif
platformAlarmProcess(aInstance);
#if OPENTHREAD_CONFIG_PLATFORM_NETIF_ENABLE
platformNetifProcess(&aMainloop->mReadFdSet, &aMainloop->mWriteFdSet, &aMainloop->mErrorFdSet);
platformNetifProcess(aMainloop);
#endif
}
src/posix/platform/trel.cpp
+16 -20
View File
@@ -388,24 +388,20 @@ OT_TOOL_WEAK void trelDnssdRemoveService(void)
// advertising TREL service after this call.
}
OT_TOOL_WEAK void trelDnssdUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, int *aMaxFd, struct timeval *aTimeout)
OT_TOOL_WEAK void trelDnssdUpdateFdSet(otSysMainloopContext *aContext)
{
// This function can be used to update the file descriptor sets
// by DNS-SD layer (if needed).
OT_UNUSED_VARIABLE(aReadFdSet);
OT_UNUSED_VARIABLE(aWriteFdSet);
OT_UNUSED_VARIABLE(aMaxFd);
OT_UNUSED_VARIABLE(aTimeout);
OT_UNUSED_VARIABLE(aContext);
}
OT_TOOL_WEAK void trelDnssdProcess(otInstance *aInstance, const fd_set *aReadFdSet, const fd_set *aWriteFdSet)
OT_TOOL_WEAK void trelDnssdProcess(otInstance *aInstance, const otSysMainloopContext *aContext)
{
// This function performs processing by DNS-SD (if needed).
OT_UNUSED_VARIABLE(aInstance);
OT_UNUSED_VARIABLE(aReadFdSet);
OT_UNUSED_VARIABLE(aWriteFdSet);
OT_UNUSED_VARIABLE(aContext);
}
//---------------------------------------------------------------------------------------------------------------------
@@ -525,45 +521,45 @@ exit:
return;
}
void platformTrelUpdateFdSet(fd_set *aReadFdSet, fd_set *aWriteFdSet, int *aMaxFd, struct timeval *aTimeout)
void platformTrelUpdateFdSet(otSysMainloopContext *aContext)
{
assert((aReadFdSet != NULL) && (aWriteFdSet != NULL) && (aMaxFd != NULL) && (aTimeout != NULL));
assert(aContext != nullptr);
VerifyOrExit(sEnabled);
FD_SET(sSocket, aReadFdSet);
FD_SET(sSocket, &aContext->mReadFdSet);
if (sTxPacketQueueTail != NULL)
if (sTxPacketQueueTail != nullptr)
{
FD_SET(sSocket, aWriteFdSet);
FD_SET(sSocket, &aContext->mWriteFdSet);
}
if (*aMaxFd < sSocket)
if (aContext->mMaxFd < sSocket)
{
*aMaxFd = sSocket;
aContext->mMaxFd = sSocket;
}
trelDnssdUpdateFdSet(aReadFdSet, aWriteFdSet, aMaxFd, aTimeout);
trelDnssdUpdateFdSet(aContext);
exit:
return;
}
void platformTrelProcess(otInstance *aInstance, const fd_set *aReadFdSet, const fd_set *aWriteFdSet)
void platformTrelProcess(otInstance *aInstance, const otSysMainloopContext *aContext)
{
VerifyOrExit(sEnabled);
if (FD_ISSET(sSocket, aWriteFdSet))
if (FD_ISSET(sSocket, &aContext->mWriteFdSet))
{
SendQueuedPackets();
}
if (FD_ISSET(sSocket, aReadFdSet))
if (FD_ISSET(sSocket, &aContext->mReadFdSet))
{
ReceivePacket(sSocket, aInstance);
}
trelDnssdProcess(aInstance, aReadFdSet, aWriteFdSet);
trelDnssdProcess(aInstance, aContext);
exit:
return;
src/posix/platform/vendor_interface.hpp
+4 -7
View File
@@ -117,21 +117,18 @@ public:
/**
* Updates the file descriptor sets with file descriptors used by the radio driver.
*
* @param[in,out] aReadFdSet A reference to the read file descriptors.
* @param[in,out] aWriteFdSet A reference to the write file descriptors.
* @param[in,out] aMaxFd A reference to the max file descriptor.
* @param[in,out] aTimeout A reference to the timeout.
* @param[in,out] aMainloopContext A pointer to the mainloop context containing fd_sets.
*
*/
void UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMaxFd, struct timeval &aTimeout);
void UpdateFdSet(void *aMainloopContext);
/**
* Performs radio driver processing.
*
* @param[in] aContext The context containing fd_sets.
* @param[in] aMainloopContext A pointer to the mainloop context containing fd_sets.
*
*/
void Process(const RadioProcessContext &aContext);
void Process(const void *aMainloopContext);
/**
* Returns the bus speed between the host and the radio.
src/posix/platform/vendor_interface_example.cpp
+4 -7
View File
@@ -108,19 +108,16 @@ otError VendorInterface::HardwareReset(void)
return OT_ERROR_NOT_IMPLEMENTED;
}
void VendorInterface::UpdateFdSet(fd_set &aReadFdSet, fd_set &aWriteFdSet, int &aMaxFd, struct timeval &aTimeout)
void VendorInterface::UpdateFdSet(void *aMainloopContext)
{
OT_UNUSED_VARIABLE(aReadFdSet);
OT_UNUSED_VARIABLE(aWriteFdSet);
OT_UNUSED_VARIABLE(aMaxFd);
OT_UNUSED_VARIABLE(aTimeout);
OT_UNUSED_VARIABLE(aMainloopContext);
// TODO: Implement vendor code here.
}
void VendorInterface::Process(const RadioProcessContext &aContext)
void VendorInterface::Process(const void *aMainloopContext)
{
OT_UNUSED_VARIABLE(aContext);
OT_UNUSED_VARIABLE(aMainloopContext);
// TODO: Implement vendor code here.
}
src/posix/platform/virtual_time.cpp
+6 -19
View File
@@ -159,37 +159,24 @@ void virtualTimeSendRadioSpinelWriteEvent(const uint8_t *aData, uint16_t aLength
virtualTimeSendEvent(&event, offsetof(struct VirtualTimeEvent, mData) + event.mDataLength);
}
void virtualTimeUpdateFdSet(fd_set *aReadFdSet,
fd_set *aWriteFdSet,
fd_set *aErrorFdSet,
int *aMaxFd,
struct timeval *aTimeout)
void virtualTimeUpdateFdSet(otSysMainloopContext *aContext)
{
OT_UNUSED_VARIABLE(aWriteFdSet);
OT_UNUSED_VARIABLE(aErrorFdSet);
OT_UNUSED_VARIABLE(aTimeout);
FD_SET(sSockFd, aReadFdSet);
if (*aMaxFd < sSockFd)
FD_SET(sSockFd, &aContext->mReadFdSet);
if (aContext->mMaxFd < sSockFd)
{
*aMaxFd = sSockFd;
aContext->mMaxFd = sSockFd;
}
}
void virtualTimeProcess(otInstance *aInstance,
const fd_set *aReadFdSet,
const fd_set *aWriteFdSet,
const fd_set *aErrorFdSet)
void virtualTimeProcess(otInstance *aInstance, const otSysMainloopContext *aContext)
{
struct VirtualTimeEvent event;
memset(&event, 0, sizeof(event));
OT_UNUSED_VARIABLE(aInstance);
OT_UNUSED_VARIABLE(aWriteFdSet);
OT_UNUSED_VARIABLE(aErrorFdSet);
if (FD_ISSET(sSockFd, aReadFdSet))
if (FD_ISSET(sSockFd, &aContext->mReadFdSet))
{
virtualTimeReceiveEvent(&event);
}