/** * Function documented in platform/alarm-milli.h */ void otPlatAlarmMilliStartAt(otInstance *aInstance, uint32_t aT0, uint32_t aDt) { OT_UNUSED_VARIABLE(aInstance); sTime0 = aT0; sAlarmTime = aDt; sIsRunning = true; }
otError otPlatSettingsGet(otInstance *aInstance, uint16_t aKey, int aIndex, uint8_t *aValue, uint16_t *aValueLength) { OT_UNUSED_VARIABLE(aInstance); otError error = OT_ERROR_NOT_FOUND; uint32_t address = sSettingsBaseAddress + OT_SETTINGS_FLAG_SIZE; uint16_t valueLength = 0; int index = 0; while (address < (sSettingsBaseAddress + sSettingsUsedSize)) { struct settingsBlock block; utilsFlashRead(address, (uint8_t *)(&block), sizeof(block)); if (block.key == aKey) { if (!(block.flag & OT_FLASH_BLOCK_INDEX_0_FLAG)) { index = 0; } if (!(block.flag & OT_FLASH_BLOCK_ADD_COMPLETE_FLAG) && (block.flag & OT_FLASH_BLOCK_DELETE_FLAG)) { if (index == aIndex) { uint16_t readLength = block.length; // only perform read if an input buffer was passed in if (aValue != NULL && aValueLength != NULL) { // adjust read length if input buffer length is smaller if (readLength > *aValueLength) { readLength = *aValueLength; } utilsFlashRead(address + sizeof(struct settingsBlock), aValue, readLength); } valueLength = block.length; error = OT_ERROR_NONE; } index++; } } address += (getAlignLength(block.length) + sizeof(struct settingsBlock)); } if (aValueLength != NULL) { *aValueLength = valueLength; } return error; }
otError otPlatRadioSetTransmitPower(otInstance *aInstance, int8_t aPower) { OT_UNUSED_VARIABLE(aInstance); sDefaultTxPower = aPower; nrf_802154_tx_power_set(aPower); return OT_ERROR_NONE; }
void otPlatRadioSetPanId(otInstance *aInstance, uint16_t aPanId) { OT_UNUSED_VARIABLE(aInstance); uint8_t address[SHORT_ADDRESS_SIZE]; convertShortAddress(address, aPanId); nrf_802154_pan_id_set(address); }
void otPlatRadioGetIeeeEui64(otInstance *aInstance, uint8_t *aIeeeEui64) { OT_UNUSED_VARIABLE(aInstance); uint64_t factoryAddress = (uint64_t)NRF_FICR->DEVICEID[0] << 32; factoryAddress |= NRF_FICR->DEVICEID[1]; memcpy(aIeeeEui64, &factoryAddress, sizeof(factoryAddress)); }
void otPlatRadioSetShortAddress(otInstance *aInstance, uint16_t aShortAddress) { OT_UNUSED_VARIABLE(aInstance); uint8_t address[SHORT_ADDRESS_SIZE]; convertShortAddress(address, aShortAddress); nrf_802154_short_address_set(address); }
AnnounceBeginServer &AnnounceBeginServer::GetOwner(const Context &aContext) { #if OPENTHREAD_ENABLE_MULTIPLE_INSTANCES AnnounceBeginServer &server = *static_cast<AnnounceBeginServer *>(aContext.GetContext()); #else AnnounceBeginServer &server = otGetThreadNetif().GetAnnounceBeginServer(); OT_UNUSED_VARIABLE(aContext); #endif return server; }
Mpl &Mpl::GetOwner(const Context &aContext) { #if OPENTHREAD_ENABLE_MULTIPLE_INSTANCES Mpl &mpl = *static_cast<Mpl *>(aContext.GetContext()); #else Mpl &mpl = otGetIp6().GetMpl(); OT_UNUSED_VARIABLE(aContext); #endif return mpl; }
SupervisionListener &SupervisionListener::GetOwner(const Context &aContext) { #if OPENTHREAD_ENABLE_MULTIPLE_INSTANCES SupervisionListener &listener = *static_cast<SupervisionListener *>(aContext.GetContext()); #else SupervisionListener &listener = otGetThreadNetif().GetSupervisionListener(); OT_UNUSED_VARIABLE(aContext); #endif return listener; }
ChildSupervisor &ChildSupervisor::GetOwner(const Context &aContext) { #if OPENTHREAD_ENABLE_MULTIPLE_INSTANCES ChildSupervisor &supervisor = *static_cast<ChildSupervisor *>(aContext.GetContext()); #else ChildSupervisor &supervisor = otGetThreadNetif().GetChildSupervisor(); OT_UNUSED_VARIABLE(aContext); #endif return supervisor; }
void otPlatReset(otInstance *aInstance) { OT_UNUSED_VARIABLE(aInstance); #if OPENTHREAD_PLATFORM_USE_PSEUDO_RESET gPlatformPseudoResetWasRequested = true; sResetReason = POWER_RESETREAS_SREQ_Msk; #else // if OPENTHREAD_PLATFORM_USE_PSEUDO_RESET NVIC_SystemReset(); #endif // else OPENTHREAD_PLATFORM_USE_PSEUDO_RESET }
otError otPlatRadioSleep(otInstance *aInstance) { OT_UNUSED_VARIABLE(aInstance); if (sState == OT_RADIO_STATE_RECEIVE) { qorvoRadioSetRxOnWhenIdle(false); sState = OT_RADIO_STATE_SLEEP; } return OT_ERROR_NONE; }
otError CoapSecure::Send(ot::Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { OT_UNUSED_VARIABLE(aMessageInfo); otError error; SuccessOrExit(error = mTransmitQueue.Enqueue(aMessage)); mTransmitTask.Post(); exit: return error; }
otError otPlatRadioReceive(otInstance *aInstance, uint8_t aChannel) { OT_UNUSED_VARIABLE(aInstance); bool result; nrf_802154_channel_set(aChannel); nrf_802154_tx_power_set(sDefaultTxPower); result = nrf_802154_receive(); clearPendingEvents(); return result ? OT_ERROR_NONE : OT_ERROR_INVALID_STATE; }
otError otPlatRadioDisable(otInstance *aInstance) { OT_UNUSED_VARIABLE(aInstance); if (otPlatRadioIsEnabled(aInstance)) { if (sState == OT_RADIO_STATE_RECEIVE) { qorvoRadioSetRxOnWhenIdle(false); } sState = OT_RADIO_STATE_DISABLED; } return OT_ERROR_NONE; }
otError otPlatRadioSleep(otInstance *aInstance) { OT_UNUSED_VARIABLE(aInstance); if (nrf_802154_sleep()) { clearPendingEvents(); } else { clearPendingEvents(); setPendingEvent(kPendingEventSleep); } return OT_ERROR_NONE; }
// settings API void otPlatSettingsInit(otInstance *aInstance) { OT_UNUSED_VARIABLE(aInstance); uint8_t index; uint32_t settingsSize = SETTINGS_CONFIG_PAGE_SIZE * SETTINGS_CONFIG_PAGE_NUM / 2; sSettingsBaseAddress = SETTINGS_CONFIG_BASE_ADDRESS; utilsFlashInit(); for (index = 0; index < 2; index++) { uint32_t blockFlag; sSettingsBaseAddress += settingsSize * index; utilsFlashRead(sSettingsBaseAddress, (uint8_t *)(&blockFlag), sizeof(blockFlag)); if (blockFlag == OT_SETTINGS_IN_USE) { break; } } if (index == 2) { initSettings(sSettingsBaseAddress, (uint32_t)OT_SETTINGS_IN_USE); } sSettingsUsedSize = OT_SETTINGS_FLAG_SIZE; while (sSettingsUsedSize < settingsSize) { struct settingsBlock block; utilsFlashRead(sSettingsBaseAddress + sSettingsUsedSize, (uint8_t *)(&block), sizeof(block)); if (!(block.flag & OT_FLASH_BLOCK_ADD_BEGIN_FLAG)) { sSettingsUsedSize += (getAlignLength(block.length) + sizeof(struct settingsBlock)); } else { break; } } }
otError otPlatRadioGetTransmitPower(otInstance *aInstance, int8_t *aPower) { OT_UNUSED_VARIABLE(aInstance); otError error = OT_ERROR_NONE; if (aPower == NULL) { error = OT_ERROR_INVALID_ARGS; } else { *aPower = sDefaultTxPower; } return error; }
otError otPlatRadioClearSrcMatchExtEntry(otInstance *aInstance, const otExtAddress *aExtAddress) { OT_UNUSED_VARIABLE(aInstance); otError error; if (nrf_802154_pending_bit_for_addr_clear(aExtAddress->m8, true)) { error = OT_ERROR_NONE; } else { error = OT_ERROR_NO_ADDRESS; } return error; }
otError otPlatSettingsDelete(otInstance *aInstance, uint16_t aKey, int aIndex) { OT_UNUSED_VARIABLE(aInstance); otError error = OT_ERROR_NOT_FOUND; uint32_t address = sSettingsBaseAddress + OT_SETTINGS_FLAG_SIZE; int index = 0; while (address < (sSettingsBaseAddress + sSettingsUsedSize)) { struct settingsBlock block; utilsFlashRead(address, (uint8_t *)(&block), sizeof(block)); if (block.key == aKey) { if (!(block.flag & OT_FLASH_BLOCK_INDEX_0_FLAG)) { index = 0; } if (!(block.flag & OT_FLASH_BLOCK_ADD_COMPLETE_FLAG) && (block.flag & OT_FLASH_BLOCK_DELETE_FLAG)) { if (aIndex == index || aIndex == -1) { error = OT_ERROR_NONE; block.flag &= (~OT_FLASH_BLOCK_DELETE_FLAG); utilsFlashWrite(address, (uint8_t *)(&block), sizeof(block)); } if (index == 1 && aIndex == 0) { block.flag &= (~OT_FLASH_BLOCK_INDEX_0_FLAG); utilsFlashWrite(address, (uint8_t *)(&block), sizeof(block)); } index++; } } address += (getAlignLength(block.length) + sizeof(struct settingsBlock)); } return error; }
otError otPlatRadioDisable(otInstance *aInstance) { otError error; OT_UNUSED_VARIABLE(aInstance); if (!sDisabled) { sDisabled = true; error = OT_ERROR_NONE; } else { error = OT_ERROR_INVALID_STATE; } return error; }
void JoinerRouter::HandleJoinerEntrustResponse(Coap::Message * aMessage, const Ip6::MessageInfo *aMessageInfo, otError aResult) { OT_UNUSED_VARIABLE(aMessageInfo); mExpectJoinEntRsp = false; SendDelayedJoinerEntrust(); VerifyOrExit(aResult == OT_ERROR_NONE && aMessage != NULL); VerifyOrExit(aMessage->GetCode() == OT_COAP_CODE_CHANGED); otLogInfoMeshCoP("Receive joiner entrust response"); otLogCertMeshCoP("[THCI] direction=recv | type=JOIN_ENT.rsp"); exit: return; }
otError otPlatRadioClearSrcMatchShortEntry(otInstance *aInstance, const uint16_t aShortAddress) { OT_UNUSED_VARIABLE(aInstance); otError error; uint8_t shortAddress[SHORT_ADDRESS_SIZE]; convertShortAddress(shortAddress, aShortAddress); if (nrf_802154_pending_bit_for_addr_clear(shortAddress, false)) { error = OT_ERROR_NONE; } else { error = OT_ERROR_NO_ADDRESS; } return error; }
void Leader::HandlePetition(Coap::Header &aHeader, Message &aMessage, const Ip6::MessageInfo &aMessageInfo) { CommissioningData data; CommissionerIdTlv commissionerId; StateTlv::State state = StateTlv::kReject; otLogInfoMeshCoP(GetInstance(), "received petition"); SuccessOrExit(Tlv::GetTlv(aMessage, Tlv::kCommissionerId, sizeof(commissionerId), commissionerId)); VerifyOrExit(commissionerId.IsValid()); if (mTimer.IsRunning()) { VerifyOrExit(!strncmp(commissionerId.GetCommissionerId(), mCommissionerId.GetCommissionerId(), sizeof(mCommissionerId))); ResignCommissioner(); } data.mBorderAgentLocator.Init(); data.mBorderAgentLocator.SetBorderAgentLocator(HostSwap16(aMessageInfo.GetPeerAddr().mFields.m16[7])); data.mCommissionerSessionId.Init(); data.mCommissionerSessionId.SetCommissionerSessionId(++mSessionId); data.mSteeringData.Init(); data.mSteeringData.SetLength(1); data.mSteeringData.Clear(); SuccessOrExit(GetNetif().GetNetworkDataLeader().SetCommissioningData(reinterpret_cast<uint8_t *>(&data), data.GetLength())); mCommissionerId = commissionerId; state = StateTlv::kAccept; mTimer.Start(TimerMilli::SecToMsec(kTimeoutLeaderPetition)); exit: OT_UNUSED_VARIABLE(aMessageInfo); SendPetitionResponse(aHeader, aMessageInfo, state); }
otError otPlatRadioEnergyScan(otInstance *aInstance, uint8_t aScanChannel, uint16_t aScanDuration) { OT_UNUSED_VARIABLE(aInstance); sEnergyDetectionTime = (uint32_t)aScanDuration * 1000UL; sEnergyDetectionChannel = aScanChannel; clearPendingEvents(); nrf_802154_channel_set(aScanChannel); if (nrf_802154_energy_detection(sEnergyDetectionTime)) { resetPendingEvent(kPendingEventEnergyDetectionStart); } else { setPendingEvent(kPendingEventEnergyDetectionStart); } return OT_ERROR_NONE; }
void NcpBase::LinkRawTransmitDone(otRadioFrame *aFrame, otRadioFrame *aAckFrame, otError aError) { if (mCurTransmitTID) { uint8_t header = SPINEL_HEADER_FLAG | SPINEL_HEADER_IID_0 | mCurTransmitTID; bool framePending = (aAckFrame != NULL && static_cast<Mac::Frame *>(aAckFrame)->GetFramePending()); // Clear cached transmit TID mCurTransmitTID = 0; SuccessOrExit(mEncoder.BeginFrame(header, SPINEL_CMD_PROP_VALUE_IS, SPINEL_PROP_LAST_STATUS)); SuccessOrExit(mEncoder.WriteUintPacked(ThreadErrorToSpinelStatus(aError))); SuccessOrExit(mEncoder.WriteBool(framePending)); if (aAckFrame && aError == OT_ERROR_NONE) { SuccessOrExit(mEncoder.WriteUint16(aAckFrame->mLength)); SuccessOrExit(mEncoder.WriteData(aAckFrame->mPsdu, aAckFrame->mLength)); SuccessOrExit(mEncoder.WriteInt8(aAckFrame->mInfo.mRxInfo.mRssi)); // RSSI SuccessOrExit(mEncoder.WriteInt8(-128)); // Noise Floor (Currently unused) SuccessOrExit(mEncoder.WriteUint16(0)); // Flags SuccessOrExit(mEncoder.OpenStruct()); // PHY-data SuccessOrExit(mEncoder.WriteUint8(aAckFrame->mChannel)); // Receive channel SuccessOrExit(mEncoder.WriteUint8(aAckFrame->mInfo.mRxInfo.mLqi)); // Link Quality Indicator SuccessOrExit(mEncoder.CloseStruct()); } SuccessOrExit(mEncoder.EndFrame()); } exit: OT_UNUSED_VARIABLE(aFrame); return; }
int Dtls::HandleMbedtlsEntropyPoll(void *aData, unsigned char *aOutput, size_t aInLen, size_t *aOutLen) { OT_UNUSED_VARIABLE(aData); otError error; int rval = 0; error = otPlatRandomGetTrue(static_cast<uint8_t *>(aOutput), static_cast<uint16_t>(aInLen)); SuccessOrExit(error); if (aOutLen != NULL) { *aOutLen = aInLen; } exit: if (error != OT_ERROR_NONE) { rval = MBEDTLS_ERR_ENTROPY_SOURCE_FAILED; } return rval; }
otError LinkRaw::Transmit(otRadioFrame *aFrame, otLinkRawTransmitDone aCallback) { otError error = OT_ERROR_INVALID_STATE; if (mEnabled) { mTransmitDoneCallback = aCallback; #if OPENTHREAD_CONFIG_ENABLE_SOFTWARE_RETRANSMIT OT_UNUSED_VARIABLE(aFrame); mTransmitAttempts = 0; mCsmaAttempts = 0; // Start the transmission backlog logic StartCsmaBackoff(); error = OT_ERROR_NONE; #else // Let the hardware do the transmission logic error = DoTransmit(aFrame); #endif } return error; }
static void handleSignal(int aSignal) { OT_UNUSED_VARIABLE(aSignal); gTerminate = true; }
/** * This method removes metadata from the message. * * @param[in] aMessage A reference to the message. * */ static void RemoveFrom(Message &aMessage) { otError error = aMessage.SetLength(aMessage.GetLength() - sizeof(EnqueuedResponseHeader)); assert(error == OT_ERROR_NONE); OT_UNUSED_VARIABLE(error); }