blob: 98855b5ea7037f8799de319d5bcaee92d33f3ad8 [file] [log] [blame]
/*
*
* Copyright (c) 2020 Project CHIP Authors
* Copyright (c) 2019 Nest Labs, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file
* Provides an implementation of the ThreadStackManager object for
* CC13XX_26XX platforms using the Texas Instruments SDK and the
* OpenThread stack.
*
*/
/* this file behaves like a config.h, comes first */
#include <platform/internal/CHIPDeviceLayerInternal.h>
#include <platform/FreeRTOS/GenericThreadStackManagerImpl_FreeRTOS.hpp>
#include <platform/OpenThread/GenericThreadStackManagerImpl_OpenThread_LwIP.cpp>
#include <mbedtls/platform.h>
#include <openthread/heap.h>
#include <platform/OpenThread/OpenThreadUtils.h>
#include <platform/ThreadStackManager.h>
// platform folder in the TI SDK example application
#include <system.h>
// DMM Includes
#ifdef USE_DMM
#include "ti_dmm_application_policy.h"
#include <dmm/dmm_policy.h>
#include <dmm/dmm_priority_ble_thread.h>
#include <dmm/dmm_scheduler.h>
#endif
namespace chip {
namespace DeviceLayer {
using namespace ::chip::DeviceLayer::Internal;
ThreadStackManagerImpl ThreadStackManagerImpl::sInstance;
#if OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE != 0
static void * ot_calloc(size_t n, size_t size)
{
void * p_ptr = NULL;
p_ptr = pvPortMalloc(n * size);
memset(p_ptr, 0, n * size);
return p_ptr;
}
static void ot_free(void * p_ptr)
{
vPortFree(p_ptr);
}
#endif /* OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE != 0 */
CHIP_ERROR ThreadStackManagerImpl::_InitThreadStack(void)
{
return InitThreadStack(NULL);
}
CHIP_ERROR ThreadStackManagerImpl::InitThreadStack(otInstance * otInst)
{
CHIP_ERROR err = CHIP_NO_ERROR;
// Create FreeRTOS queue for platform driver messages
procQueue = xQueueCreate(20U, sizeof(ThreadStackManagerImpl::procQueueMsg));
procQueue_radio = xQueueCreate(20U, sizeof(ThreadStackManagerImpl::procQueueMsg));
#if OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE != 0
mbedtls_platform_set_calloc_free(ot_calloc, ot_free);
#endif /* OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE != 0 */
// Initialize the OpenThread platform layer
platformAlarmInit();
platformAlarmMicroInit();
platformRandomInit();
platformRadioInit();
#ifdef USE_DMM
// DMM Init
DMMSch_registerClient(xTaskGetCurrentTaskHandle(), DMMPolicy_StackRole_threadFtd);
DMMPolicy_updateStackState(DMMPolicy_StackRole_threadFtd, DMMPOLICY_THREAD_IDLE);
#endif
// Initialize the generic implementation base classes.
err = GenericThreadStackManagerImpl_FreeRTOS<ThreadStackManagerImpl>::DoInit();
SuccessOrExit(err);
err = GenericThreadStackManagerImpl_OpenThread_LwIP<ThreadStackManagerImpl>::DoInit(otInst);
SuccessOrExit(err);
exit:
return err;
}
bool ThreadStackManagerImpl::IsInitialized()
{
return sInstance.mThreadStackLock != NULL;
}
void ThreadStackManagerImpl::_SendProcMessage(ThreadStackManagerImpl::procQueueMsg & procMsg)
{
BaseType_t err;
if (procMsg.cmd == procQueueCmd_radio)
{
err = xQueueSendFromISR(procQueue_radio, &procMsg, NULL);
}
else
{
err = xQueueSendFromISR(procQueue, &procMsg, NULL);
}
(void) err;
// signal processing loop
SignalThreadActivityPendingFromISR();
}
extern "C" void * otPlatCAlloc(size_t aNum, size_t aSize)
{
return chip::Platform::MemoryCalloc(aNum, aSize);
}
extern "C" void otPlatFree(void * aPtr)
{
if (aPtr != nullptr)
{
chip::Platform::MemoryFree(aPtr);
}
}
void ThreadStackManagerImpl::_ProcMessage(otInstance * aInstance)
{
procQueueMsg procMsg;
procQueueMsg procMsg_radio;
/* Process Radio events */
while (pdTRUE == xQueueReceive(procQueue_radio, &procMsg_radio, 0U))
{
switch (procMsg_radio.cmd)
{
case procQueueCmd_radio: {
platformRadioProcess(aInstance, procMsg_radio.arg);
break;
}
default: {
break;
}
}
}
while (pdTRUE == xQueueReceive(procQueue, &procMsg, 0U))
{
switch (procMsg.cmd)
{
case procQueueCmd_alarm: {
platformAlarmProcess(aInstance);
break;
}
case procQueueCmd_tasklets: {
otTaskletsProcess(aInstance);
break;
}
case procQueueCmd_alarmu: {
platformAlarmMicroProcess(aInstance);
break;
}
default: {
break;
}
}
}
}
void ThreadStackManagerImpl::GetExtAddress(otExtAddress & aExtAddr)
{
const otExtAddress * extAddr;
LockThreadStack();
extAddr = otLinkGetExtendedAddress(OTInstance());
UnlockThreadStack();
memcpy(aExtAddr.m8, extAddr->m8, OT_EXT_ADDRESS_SIZE);
}
bool ThreadStackManagerImpl::IsThreadAttached()
{
return _IsThreadAttached();
}
bool ThreadStackManagerImpl::IsThreadEnabled()
{
return _IsThreadEnabled();
}
} // namespace DeviceLayer
} // namespace chip
using namespace ::chip::DeviceLayer;
/**
* Glue function called by alarm processing layer to notify OpenThread the driver needs processing.
*/
extern "C" void platformAlarmSignal()
{
ThreadStackManagerImpl::procQueueMsg msg;
msg.cmd = ThreadStackManagerImpl::procQueueCmd_alarm;
ThreadStackMgrImpl()._SendProcMessage(msg);
}
/**
* Glue function called by alarm processing layer to notify OpenThread the driver needs processing.
*/
extern "C" void platformAlarmMicroSignal()
{
ThreadStackManagerImpl::procQueueMsg msg;
msg.cmd = ThreadStackManagerImpl::procQueueCmd_alarmu;
ThreadStackMgrImpl()._SendProcMessage(msg);
}
/**
* Glue function called by radio processing layer to notify OpenThread the driver needs processing.
*/
extern "C" void platformRadioSignal(uintptr_t arg)
{
ThreadStackManagerImpl::procQueueMsg msg;
msg.cmd = ThreadStackManagerImpl::procQueueCmd_radio;
msg.arg = arg;
ThreadStackMgrImpl()._SendProcMessage(msg);
}
/**
* Glue function called directly by the OpenThread stack when tasklet processing work
* is pending.
*/
extern "C" void otTaskletsSignalPending(otInstance * p_instance)
{
ThreadStackMgrImpl().SignalThreadActivityPending();
}
/**
* Process events from the drivers
*/
extern "C" void otSysProcessDrivers(otInstance * aInstance)
{
ThreadStackMgrImpl()._ProcMessage(aInstance);
}
/**
* Get a pointer to the OpenThread instance object.
*
* @return Pointer to the OpenThread instance object.
*/
extern "C" otInstance * OtInstance_get(void)
{
return ThreadStackMgrImpl().OTInstance();
}