Symbols ![]()
loading...
Files ![]()
loading...
ot::Spinel::RadioSpinel class
The class for providing a OpenThread radio interface by talking with a radio-only co-processor(RCP).
Syntax
class RadioSpinel : private Logger
{
public:
RadioSpinel(void);
~RadioSpinel(void) { Deinit(); }
void Init(bool aSkipRcpVersionCheck,
bool aSoftwareReset,
SpinelDriver *aSpinelDriver,
otRadioCaps aRequiredRadioCaps,
bool aEnableRcpTimeSync);
void SetCallbacks(const struct RadioSpinelCallbacks &aCallbacks);
void Deinit(void);
bool IsPromiscuous(void) const { return mIsPromiscuous; }
otError SetPromiscuous(bool aEnable);
otError SetRxOnWhenIdle(bool aEnable);
otError SetShortAddress(uint16_t aAddress);
otError GetIeeeEui64(uint8_t *aIeeeEui64);
otError SetExtendedAddress(const otExtAddress &aExtAddress);
otError SetPanId(uint16_t aPanId);
otError GetTransmitPower(int8_t &aPower);
otError SetTransmitPower(int8_t aPower);
otError GetCcaEnergyDetectThreshold(int8_t &aThreshold);
otError SetCcaEnergyDetectThreshold(int8_t aThreshold);
otError GetFemLnaGain(int8_t &aGain);
otError SetFemLnaGain(int8_t aGain);
otRadioCaps GetRadioCaps(void) const { return sRadioCaps; }
int8_t GetRssi(void);
int8_t GetReceiveSensitivity(void) const { return mRxSensitivity; }
otRadioState GetState(void) const;
uint8_t GetChannel(void) const { return mChannel; }
#if OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE
otError SetCoexEnabled(bool aEnabled);
bool IsCoexEnabled(void);
otError GetCoexMetrics(otRadioCoexMetrics &aCoexMetrics);
#endif
otError GetMultipanActiveInterface(spinel_iid_t *aIid);
otError SetMultipanActiveInterface(spinel_iid_t aIid, bool aCompletePending);
otRadioFrame &GetTransmitFrame(void) { return mTxRadioFrame; }
otError EnableSrcMatch(bool aEnable);
otError AddSrcMatchShortEntry(uint16_t aShortAddress);
otError ClearSrcMatchShortEntry(uint16_t aShortAddress);
otError ClearSrcMatchShortEntries(void);
otError AddSrcMatchExtEntry(const otExtAddress &aExtAddress);
otError ClearSrcMatchExtEntry(const otExtAddress &aExtAddress);
otError ClearSrcMatchExtEntries(void);
otError EnergyScan(uint8_t aScanChannel, uint16_t aScanDuration);
otError Transmit(otRadioFrame &aFrame);
otError Receive(uint8_t aChannel);
otError Sleep(void);
otError Enable(otInstance *aInstance);
otError Disable(void);
bool IsEnabled(void) const { return mState != kStateDisabled; }
bool IsTransmitting(void) const { return mState == kStateTransmitting; }
bool IsTransmitDone(void) const { return mState == kStateTransmitDone; }
uint64_t GetTxRadioEndUs(void) const { return mTxRadioEndUs; }
void Process(const void *aContext);
#if OPENTHREAD_CONFIG_DIAG_ENABLE
void SetDiagEnabled(bool aMode) { mDiagMode = aMode; }
bool IsDiagEnabled(void) const { return mDiagMode; }
otError RadioSpinelDiagProcess(char *aArgs[], uint8_t aArgsLength);
otError PlatDiagProcess(const char *aString);
void SetDiagOutputCallback(otPlatDiagOutputCallback aCallback, void *aContext);
void GetDiagOutputCallback(otPlatDiagOutputCallback &aCallback, void *&aContext);
#endif
uint32_t GetRadioChannelMask(bool aPreferred);
otError SetMacKey(uint8_t aKeyIdMode,
uint8_t aKeyId,
const otMacKeyMaterial *aPrevKey,
const otMacKeyMaterial *aCurrKey,
const otMacKeyMaterial *aNextKey);
otError SetMacFrameCounter(uint32_t aMacFrameCounter, bool aSetIfLarger);
otError SetRadioRegion(uint16_t aRegionCode);
otError GetRadioRegion(uint16_t *aRegionCode);
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
otError ConfigureEnhAckProbing(otLinkMetrics aLinkMetrics,
const otShortAddress &aShortAddress,
const otExtAddress &aExtAddress);
#endif
#if OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE || OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE
uint8_t GetCslAccuracy(void);
#endif
#if OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE
uint8_t GetCslUncertainty(void);
#endif
bool HasPendingFrame(void) const { return mSpinelDriver->HasPendingFrame(); }
uint64_t GetNextRadioTimeRecalcStart(void) const { return mRadioTimeRecalcStart; }
uint64_t GetNow(void);
uint32_t GetBusSpeed(void) const;
uint32_t GetBusLatency(void) const;
void SetBusLatency(uint32_t aBusLatency);
const char *GetVersion(void) const { return mSpinelDriver->GetVersion(); }
otError SetChannelMaxTransmitPower(uint8_t aChannel, int8_t aMaxPower);
otError Get(spinel_prop_key_t aKey, const char *aFormat, ...);
otError GetWithParam(spinel_prop_key_t aKey,
const uint8_t *aParam,
spinel_size_t aParamSize,
const char *aFormat,
...);
otError Set(spinel_prop_key_t aKey, const char *aFormat, ...);
otError Insert(spinel_prop_key_t aKey, const char *aFormat, ...);
otError Remove(spinel_prop_key_t aKey, const char *aFormat, ...);
otError SendReset(uint8_t aResetType);
const otRadioSpinelMetrics *GetRadioSpinelMetrics(void) const { return &mRadioSpinelMetrics; }
#if OPENTHREAD_CONFIG_PLATFORM_POWER_CALIBRATION_ENABLE
otError AddCalibratedPower(uint8_t aChannel,
int16_t aActualPower,
const uint8_t *aRawPowerSetting,
uint16_t aRawPowerSettingLength);
otError ClearCalibratedPowers(void);
otError SetChannelTargetPower(uint8_t aChannel, int16_t aTargetPower);
#endif
#if OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT > 0
void RestoreProperties(void);
#endif
#if OPENTHREAD_SPINEL_CONFIG_VENDOR_HOOK_ENABLE
otError VendorHandleValueIs(spinel_prop_key_t aPropKey);
typedef void (*otRadioSpinelVendorRestorePropertiesCallback)(void *aContext);
void SetVendorRestorePropertiesCallback(otRadioSpinelVendorRestorePropertiesCallback aCallback, void *aContext);
#endif
#if OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE
typedef void (*otRadioSpinelCompatibilityErrorCallback)(void *aContext);
void SetCompatibilityErrorCallback(otRadioSpinelCompatibilityErrorCallback aCallback, void *aContext);
#endif
void SetTimeSyncState(bool aOn) { mTimeSyncOn = aOn; }
private:
enum
{
kMaxWaitTime = 2000,
kVersionStringSize = 128,
kCapsBufferSize = 100,
kChannelMaskBufferSize = 32,
};
enum State
{
kStateDisabled,
kStateSleep,
kStateReceive,
kStateTransmitting,
kStateTransmitDone,
};
static constexpr uint32_t kUsPerMs = 1000;
static constexpr uint32_t kMsPerSec = 1000;
static constexpr uint32_t kUsPerSec = kUsPerMs * kMsPerSec;
static constexpr uint64_t kTxWaitUs =
OPENTHREAD_SPINEL_CONFIG_RCP_TX_WAIT_TIME_SECS *
kUsPerSec;
typedef otError (RadioSpinel::*ResponseHandler)(const uint8_t *aBuffer, uint16_t aLength);
SpinelDriver &GetSpinelDriver(void) const;
otError CheckSpinelVersion(void);
otError CheckRadioCapabilities(otRadioCaps aRequiredRadioCaps);
otError CheckRcpApiVersion(bool aSupportsRcpApiVersion, bool aSupportsRcpMinHostApiVersion);
void InitializeCaps(bool &aSupportsRcpApiVersion, bool &aSupportsRcpMinHostApiVersion);
void ProcessRadioStateMachine(void);
void ProcessFrameQueue(void);
spinel_tid_t GetNextTid(void);
void FreeTid(spinel_tid_t tid) { mCmdTidsInUse &= ~(1 << tid); }
otError RequestV(uint32_t aCommand, spinel_prop_key_t aKey, const char *aFormat, va_list aArgs);
otError Request(uint32_t aCommand, spinel_prop_key_t aKey, const char *aFormat, ...);
otError RequestWithPropertyFormat(const char *aPropertyFormat,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
...);
otError RequestWithPropertyFormatV(const char *aPropertyFormat,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs);
otError RequestWithExpectedCommandV(uint32_t aExpectedCommand,
uint32_t aCommand,
spinel_prop_key_t aKey,
const char *aFormat,
va_list aArgs);
otError WaitResponse(bool aHandleRcpTimeout = true);
otError ParseRadioFrame(otRadioFrame &aFrame, const uint8_t *aBuffer, uint16_t aLength, spinel_ssize_t &aUnpacked);
bool IsSafeToHandleNow(spinel_prop_key_t aKey) const
{
return !(aKey == SPINEL_PROP_STREAM_RAW || aKey == SPINEL_PROP_MAC_ENERGY_SCAN_RESULT);
}
void HandleNotification(const uint8_t *aFrame, uint16_t aLength, bool &aShouldSaveFrame);
void HandleNotification(const uint8_t *aFrame, uint16_t aLength);
void HandleValueIs(spinel_prop_key_t aKey, const uint8_t *aBuffer, uint16_t aLength);
void HandleResponse(const uint8_t *aBuffer, uint16_t aLength);
void HandleTransmitDone(uint32_t aCommand, spinel_prop_key_t aKey, const uint8_t *aBuffer, uint16_t aLength);
void HandleWaitingResponse(uint32_t aCommand, spinel_prop_key_t aKey, const uint8_t *aBuffer, uint16_t aLength);
void RadioReceive(void);
void TransmitDone(otRadioFrame *aFrame, otRadioFrame *aAckFrame, otError aError);
void CalcRcpTimeOffset(void);
void HandleRcpUnexpectedReset(spinel_status_t aStatus);
void HandleRcpTimeout(void);
void RecoverFromRcpFailure(void);
static void HandleReceivedFrame(const uint8_t *aFrame,
uint16_t aLength,
uint8_t aHeader,
bool &aSave,
void *aContext);
void HandleReceivedFrame(const uint8_t *aFrame, uint16_t aLength, uint8_t aHeader, bool &aShouldSaveFrame);
static void HandleSavedFrame(const uint8_t *aFrame, uint16_t aLength, void *aContext);
void HandleSavedFrame(const uint8_t *aFrame, uint16_t aLength);
void UpdateParseErrorCount(otError aError)
{
mRadioSpinelMetrics.mSpinelParseErrorCount += (aError == OT_ERROR_PARSE) ? 1 : 0;
}
otError SetMacKey(uint8_t aKeyIdMode,
uint8_t aKeyId,
const otMacKey &aPrevKey,
const otMacKey &aCurrKey,
const otMacKey &NextKey);
#if OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE
static otError ReadMacKey(const otMacKeyMaterial &aKeyMaterial, otMacKey &aKey);
#endif
#if OPENTHREAD_CONFIG_DIAG_ENABLE
void PlatDiagOutput(const char *aFormat, ...);
#endif
void HandleCompatibilityError(void);
otInstance *mInstance;
RadioSpinelCallbacks mCallbacks;
uint16_t mCmdTidsInUse;
spinel_tid_t mCmdNextTid;
spinel_tid_t mTxRadioTid;
spinel_tid_t mWaitingTid;
spinel_prop_key_t mWaitingKey;
const char *mPropertyFormat;
va_list mPropertyArgs;
uint32_t mExpectedCommand;
otError mError;
uint8_t mRxPsdu[OT_RADIO_FRAME_MAX_SIZE];
uint8_t mTxPsdu[OT_RADIO_FRAME_MAX_SIZE];
uint8_t mAckPsdu[OT_RADIO_FRAME_MAX_SIZE];
otRadioFrame mRxRadioFrame;
otRadioFrame mTxRadioFrame;
otRadioFrame mAckRadioFrame;
otRadioFrame *mTransmitFrame;
#if OPENTHREAD_CONFIG_MAC_HEADER_IE_SUPPORT && OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
otRadioIeInfo mTxIeInfo;
#endif
otExtAddress mExtendedAddress;
uint16_t mShortAddress;
uint16_t mPanId;
uint8_t mChannel;
int8_t mRxSensitivity;
otError mTxError;
static otExtAddress sIeeeEui64;
static otRadioCaps sRadioCaps;
uint32_t mBusLatency;
State mState;
bool mIsPromiscuous : 1;
bool mRxOnWhenIdle : 1;
bool mIsTimeSynced : 1;
static bool sSupportsLogStream;
static bool sSupportsResetToBootloader;
static bool sSupportsLogCrashDump;
#if OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT > 0
enum
{
kRcpFailureNone,
kRcpFailureTimeout,
kRcpFailureUnexpectedReset,
};
bool mResetRadioOnStartup : 1;
int16_t mRcpFailureCount;
uint8_t mRcpFailure : 2;
uint8_t mKeyIdMode;
uint8_t mKeyId;
otMacKey mPrevKey;
otMacKey mCurrKey;
otMacKey mNextKey;
static_assert(OPENTHREAD_SPINEL_CONFIG_MAX_SRC_MATCH_ENTRIES >= OPENTHREAD_CONFIG_MLE_MAX_CHILDREN,
"SPINEL_CONFIG_MAX_SRC_MATCH_ENTRIES is not large enough to cover MLE_MAX_CHILDREN");
uint16_t mSrcMatchShortEntries[OPENTHREAD_SPINEL_CONFIG_MAX_SRC_MATCH_ENTRIES];
int16_t mSrcMatchShortEntryCount;
otExtAddress mSrcMatchExtEntries[OPENTHREAD_SPINEL_CONFIG_MAX_SRC_MATCH_ENTRIES];
int16_t mSrcMatchExtEntryCount;
uint8_t mScanChannel;
uint16_t mScanDuration;
int8_t mCcaEnergyDetectThreshold;
int8_t mTransmitPower;
int8_t mFemLnaGain;
bool mCoexEnabled : 1;
bool mSrcMatchEnabled : 1;
bool mMacKeySet : 1;
bool mCcaEnergyDetectThresholdSet : 1;
bool mTransmitPowerSet : 1;
bool mCoexEnabledSet : 1;
bool mFemLnaGainSet : 1;
bool mEnergyScanning : 1;
bool mMacFrameCounterSet : 1;
bool mSrcMatchSet : 1;
#endif
#if OPENTHREAD_CONFIG_DIAG_ENABLE
bool mDiagMode;
otPlatDiagOutputCallback mOutputCallback;
void *mOutputContext;
#endif
uint64_t mTxRadioEndUs;
uint64_t mRadioTimeRecalcStart;
uint64_t mRadioTimeOffset;
MaxPowerTable mMaxPowerTable;
otRadioSpinelMetrics mRadioSpinelMetrics;
#if OPENTHREAD_SPINEL_CONFIG_VENDOR_HOOK_ENABLE
otRadioSpinelVendorRestorePropertiesCallback mVendorRestorePropertiesCallback;
void *mVendorRestorePropertiesContext;
#endif
#if OPENTHREAD_SPINEL_CONFIG_COMPATIBILITY_ERROR_CALLBACK_ENABLE
otRadioSpinelCompatibilityErrorCallback mCompatibilityErrorCallback;
void *mCompatibilityErrorContext;
#endif
bool mTimeSyncEnabled : 1;
bool mTimeSyncOn : 1;
SpinelDriver *mSpinelDriver;
};
Fields
Field
Declared as
const char *
uint16_t