/**
* 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);
}
