main
parent
fff141af85
commit
93e3b39fa3
@ -0,0 +1,138 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_bitmap.h"
|
||||
#include "los_printf.h"
|
||||
#include "los_toolchain.h"
|
||||
|
||||
|
||||
#define OS_BITMAP_MASK 0x1FU
|
||||
#define OS_BITMAP_WORD_MASK ~0UL
|
||||
|
||||
/* find first zero bit starting from LSB */
|
||||
STATIC INLINE UINT16 Ffz(UINTPTR x)
|
||||
{
|
||||
return __builtin_ffsl(~x) - 1;
|
||||
}
|
||||
|
||||
VOID LOS_BitmapSet(UINT32 *bitmap, UINT16 pos)
|
||||
{
|
||||
if (bitmap == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
*bitmap |= 1U << (pos & OS_BITMAP_MASK);
|
||||
}
|
||||
|
||||
VOID LOS_BitmapClr(UINT32 *bitmap, UINT16 pos)
|
||||
{
|
||||
if (bitmap == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
*bitmap &= ~(1U << (pos & OS_BITMAP_MASK));
|
||||
}
|
||||
|
||||
UINT16 LOS_HighBitGet(UINT32 bitmap)
|
||||
{
|
||||
if (bitmap == 0) {
|
||||
return LOS_INVALID_BIT_INDEX;
|
||||
}
|
||||
|
||||
return (OS_BITMAP_MASK - CLZ(bitmap));
|
||||
}
|
||||
|
||||
UINT16 LOS_LowBitGet(UINT32 bitmap)
|
||||
{
|
||||
if (bitmap == 0) {
|
||||
return LOS_INVALID_BIT_INDEX;
|
||||
}
|
||||
|
||||
return CTZ(bitmap);
|
||||
}
|
||||
|
||||
VOID LOS_BitmapSetNBits(UINTPTR *bitmap, UINT32 start, UINT32 numsSet)
|
||||
{
|
||||
UINTPTR *p = bitmap + BITMAP_WORD(start);
|
||||
const UINT32 size = start + numsSet;
|
||||
UINT16 bitsToSet = BITMAP_BITS_PER_WORD - (start % BITMAP_BITS_PER_WORD);
|
||||
UINTPTR maskToSet = BITMAP_FIRST_WORD_MASK(start);
|
||||
|
||||
while (numsSet > bitsToSet) {
|
||||
*p |= maskToSet;
|
||||
numsSet -= bitsToSet;
|
||||
bitsToSet = BITMAP_BITS_PER_WORD;
|
||||
maskToSet = OS_BITMAP_WORD_MASK;
|
||||
p++;
|
||||
}
|
||||
if (numsSet) {
|
||||
maskToSet &= BITMAP_LAST_WORD_MASK(size);
|
||||
*p |= maskToSet;
|
||||
}
|
||||
}
|
||||
|
||||
VOID LOS_BitmapClrNBits(UINTPTR *bitmap, UINT32 start, UINT32 numsClear)
|
||||
{
|
||||
UINTPTR *p = bitmap + BITMAP_WORD(start);
|
||||
const UINT32 size = start + numsClear;
|
||||
UINT16 bitsToClear = BITMAP_BITS_PER_WORD - (start % BITMAP_BITS_PER_WORD);
|
||||
UINTPTR maskToClear = BITMAP_FIRST_WORD_MASK(start);
|
||||
|
||||
while (numsClear >= bitsToClear) {
|
||||
*p &= ~maskToClear;
|
||||
numsClear -= bitsToClear;
|
||||
bitsToClear = BITMAP_BITS_PER_WORD;
|
||||
maskToClear = OS_BITMAP_WORD_MASK;
|
||||
p++;
|
||||
}
|
||||
if (numsClear) {
|
||||
maskToClear &= BITMAP_LAST_WORD_MASK(size);
|
||||
*p &= ~maskToClear;
|
||||
}
|
||||
}
|
||||
|
||||
INT32 LOS_BitmapFfz(UINTPTR *bitmap, UINT32 numBits)
|
||||
{
|
||||
INT32 bit, i;
|
||||
|
||||
for (i = 0; i < BITMAP_NUM_WORDS(numBits); i++) {
|
||||
if (bitmap[i] == OS_BITMAP_WORD_MASK) {
|
||||
continue;
|
||||
}
|
||||
bit = i * BITMAP_BITS_PER_WORD + Ffz(bitmap[i]);
|
||||
if (bit < numBits) {
|
||||
return bit;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,84 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_smp.h"
|
||||
#include "arch_config.h"
|
||||
#include "los_atomic.h"
|
||||
#include "los_task_pri.h"
|
||||
#include "los_init_pri.h"
|
||||
#include "los_process_pri.h"
|
||||
#include "los_sched_pri.h"
|
||||
#include "los_swtmr_pri.h"
|
||||
|
||||
#ifdef LOSCFG_KERNEL_SMP
|
||||
STATIC struct SmpOps *g_smpOps = NULL;
|
||||
|
||||
STATIC VOID OsSmpSecondaryInit(VOID *arg)
|
||||
{
|
||||
UNUSED(arg);
|
||||
OsInitCall(LOS_INIT_LEVEL_PLATFORM);
|
||||
|
||||
OsCurrProcessSet(OS_PCB_FROM_PID(OsGetKernelInitProcessID()));
|
||||
OsInitCall(LOS_INIT_LEVEL_KMOD_BASIC);
|
||||
|
||||
#ifdef LOSCFG_BASE_CORE_SWTMR_ENABLE
|
||||
OsSwtmrInit();
|
||||
#endif
|
||||
|
||||
OsInitCall(LOS_INIT_LEVEL_KMOD_EXTENDED);
|
||||
|
||||
OsIdleTaskCreate();
|
||||
OsInitCall(LOS_INIT_LEVEL_KMOD_TASK);
|
||||
|
||||
OsSchedStart();
|
||||
}
|
||||
|
||||
VOID LOS_SmpOpsSet(struct SmpOps *ops)
|
||||
{
|
||||
g_smpOps = ops;
|
||||
}
|
||||
|
||||
VOID OsSmpInit(VOID)
|
||||
{
|
||||
UINT32 cpuNum = 1; /* Start the secondary cpus. */
|
||||
|
||||
if (g_smpOps == NULL) {
|
||||
PRINT_ERR("Must call the interface(LOS_SmpOpsSet) to register smp operations firstly!\n");
|
||||
return;
|
||||
}
|
||||
|
||||
for (; cpuNum < CORE_NUM; cpuNum++) {
|
||||
HalArchCpuOn(cpuNum, OsSmpSecondaryInit, g_smpOps, 0);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
#endif
|
@ -0,0 +1,536 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_swtmr_pri.h"
|
||||
#include "los_init.h"
|
||||
#include "los_process_pri.h"
|
||||
#include "los_queue_pri.h"
|
||||
#include "los_sched_pri.h"
|
||||
#include "los_sortlink_pri.h"
|
||||
#include "los_task_pri.h"
|
||||
#include "los_hook.h"
|
||||
|
||||
#ifdef LOSCFG_BASE_CORE_SWTMR_ENABLE
|
||||
#if (LOSCFG_BASE_CORE_SWTMR_LIMIT <= 0)
|
||||
#error "swtmr maxnum cannot be zero"
|
||||
#endif /* LOSCFG_BASE_CORE_SWTMR_LIMIT <= 0 */
|
||||
|
||||
LITE_OS_SEC_BSS SWTMR_CTRL_S *g_swtmrCBArray = NULL; /* First address in Timer memory space */
|
||||
LITE_OS_SEC_BSS UINT8 *g_swtmrHandlerPool = NULL; /* Pool of Swtmr Handler */
|
||||
LITE_OS_SEC_BSS LOS_DL_LIST g_swtmrFreeList; /* Free list of Software Timer */
|
||||
|
||||
/* spinlock for swtmr module, only available on SMP mode */
|
||||
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_swtmrSpin);
|
||||
#define SWTMR_LOCK(state) LOS_SpinLockSave(&g_swtmrSpin, &(state))
|
||||
#define SWTMR_UNLOCK(state) LOS_SpinUnlockRestore(&g_swtmrSpin, (state))
|
||||
|
||||
LITE_OS_SEC_TEXT VOID OsSwtmrTask(VOID)
|
||||
{
|
||||
SwtmrHandlerItemPtr swtmrHandlePtr = NULL;
|
||||
SwtmrHandlerItem swtmrHandle;
|
||||
UINT32 ret, swtmrHandlerQueue;
|
||||
|
||||
swtmrHandlerQueue = OsPercpuGet()->swtmrHandlerQueue;
|
||||
for (;;) {
|
||||
ret = LOS_QueueRead(swtmrHandlerQueue, &swtmrHandlePtr, sizeof(CHAR *), LOS_WAIT_FOREVER);
|
||||
if ((ret == LOS_OK) && (swtmrHandlePtr != NULL)) {
|
||||
swtmrHandle.handler = swtmrHandlePtr->handler;
|
||||
swtmrHandle.arg = swtmrHandlePtr->arg;
|
||||
(VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandlePtr);
|
||||
if (swtmrHandle.handler != NULL) {
|
||||
swtmrHandle.handler(swtmrHandle.arg);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrTaskCreate(VOID)
|
||||
{
|
||||
UINT32 ret, swtmrTaskID;
|
||||
TSK_INIT_PARAM_S swtmrTask;
|
||||
UINT32 cpuid = ArchCurrCpuid();
|
||||
|
||||
(VOID)memset_s(&swtmrTask, sizeof(TSK_INIT_PARAM_S), 0, sizeof(TSK_INIT_PARAM_S));
|
||||
swtmrTask.pfnTaskEntry = (TSK_ENTRY_FUNC)OsSwtmrTask;
|
||||
swtmrTask.uwStackSize = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
|
||||
swtmrTask.pcName = "Swt_Task";
|
||||
swtmrTask.usTaskPrio = 0;
|
||||
swtmrTask.uwResved = LOS_TASK_STATUS_DETACHED;
|
||||
#ifdef LOSCFG_KERNEL_SMP
|
||||
swtmrTask.usCpuAffiMask = CPUID_TO_AFFI_MASK(cpuid);
|
||||
#endif
|
||||
ret = LOS_TaskCreate(&swtmrTaskID, &swtmrTask);
|
||||
if (ret == LOS_OK) {
|
||||
g_percpu[cpuid].swtmrTaskID = swtmrTaskID;
|
||||
OS_TCB_FROM_TID(swtmrTaskID)->taskStatus |= OS_TASK_FLAG_SYSTEM_TASK;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_INIT VOID OsSwtmrRecycle(UINT32 processID)
|
||||
{
|
||||
for (UINT16 index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++) {
|
||||
if (g_swtmrCBArray[index].uwOwnerPid == processID) {
|
||||
LOS_SwtmrDelete(index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_INIT UINT32 OsSwtmrInit(VOID)
|
||||
{
|
||||
UINT32 size;
|
||||
UINT16 index;
|
||||
UINT32 ret;
|
||||
SWTMR_CTRL_S *swtmr = NULL;
|
||||
UINT32 swtmrHandlePoolSize;
|
||||
UINT32 cpuid = ArchCurrCpuid();
|
||||
if (cpuid == 0) {
|
||||
size = sizeof(SWTMR_CTRL_S) * LOSCFG_BASE_CORE_SWTMR_LIMIT;
|
||||
swtmr = (SWTMR_CTRL_S *)LOS_MemAlloc(m_aucSysMem0, size); /* system resident resource */
|
||||
if (swtmr == NULL) {
|
||||
ret = LOS_ERRNO_SWTMR_NO_MEMORY;
|
||||
goto ERROR;
|
||||
}
|
||||
|
||||
(VOID)memset_s(swtmr, size, 0, size);
|
||||
g_swtmrCBArray = swtmr;
|
||||
LOS_ListInit(&g_swtmrFreeList);
|
||||
for (index = 0; index < LOSCFG_BASE_CORE_SWTMR_LIMIT; index++, swtmr++) {
|
||||
swtmr->usTimerID = index;
|
||||
LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
|
||||
}
|
||||
|
||||
swtmrHandlePoolSize = LOS_MEMBOX_SIZE(sizeof(SwtmrHandlerItem), OS_SWTMR_HANDLE_QUEUE_SIZE);
|
||||
|
||||
g_swtmrHandlerPool = (UINT8 *)LOS_MemAlloc(m_aucSysMem1, swtmrHandlePoolSize); /* system resident resource */
|
||||
if (g_swtmrHandlerPool == NULL) {
|
||||
ret = LOS_ERRNO_SWTMR_NO_MEMORY;
|
||||
goto ERROR;
|
||||
}
|
||||
|
||||
ret = LOS_MemboxInit(g_swtmrHandlerPool, swtmrHandlePoolSize, sizeof(SwtmrHandlerItem));
|
||||
if (ret != LOS_OK) {
|
||||
ret = LOS_ERRNO_SWTMR_HANDLER_POOL_NO_MEM;
|
||||
goto ERROR;
|
||||
}
|
||||
|
||||
ret = OsSchedSwtmrScanRegister((SchedScan)OsSwtmrScan);
|
||||
if (ret != LOS_OK) {
|
||||
goto ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
ret = LOS_QueueCreate(NULL, OS_SWTMR_HANDLE_QUEUE_SIZE, &g_percpu[cpuid].swtmrHandlerQueue, 0, sizeof(CHAR *));
|
||||
if (ret != LOS_OK) {
|
||||
ret = LOS_ERRNO_SWTMR_QUEUE_CREATE_FAILED;
|
||||
goto ERROR;
|
||||
}
|
||||
|
||||
ret = OsSwtmrTaskCreate();
|
||||
if (ret != LOS_OK) {
|
||||
ret = LOS_ERRNO_SWTMR_TASK_CREATE_FAILED;
|
||||
goto ERROR;
|
||||
}
|
||||
|
||||
ret = OsSortLinkInit(&g_percpu[cpuid].swtmrSortLink);
|
||||
if (ret != LOS_OK) {
|
||||
ret = LOS_ERRNO_SWTMR_SORTLINK_CREATE_FAILED;
|
||||
goto ERROR;
|
||||
}
|
||||
|
||||
return LOS_OK;
|
||||
|
||||
ERROR:
|
||||
PRINT_ERR("OsSwtmrInit error! ret = %u\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Description: Start Software Timer
|
||||
* Input : swtmr --- Need to start software timer
|
||||
*/
|
||||
LITE_OS_SEC_TEXT VOID OsSwtmrStart(UINT64 currTime, SWTMR_CTRL_S *swtmr)
|
||||
{
|
||||
UINT32 ticks;
|
||||
|
||||
if ((swtmr->uwOverrun == 0) && ((swtmr->ucMode == LOS_SWTMR_MODE_ONCE) ||
|
||||
(swtmr->ucMode == LOS_SWTMR_MODE_OPP) ||
|
||||
(swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE))) {
|
||||
ticks = swtmr->uwExpiry;
|
||||
} else {
|
||||
ticks = swtmr->uwInterval;
|
||||
}
|
||||
swtmr->ucState = OS_SWTMR_STATUS_TICKING;
|
||||
|
||||
OsAdd2SortLink(&swtmr->stSortList, swtmr->startTime, ticks, OS_SORT_LINK_SWTMR);
|
||||
OsSchedUpdateExpireTime(currTime);
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Description: Delete Software Timer
|
||||
* Input : swtmr --- Need to delete software timer, When using, Ensure that it can't be NULL.
|
||||
*/
|
||||
STATIC INLINE VOID OsSwtmrDelete(SWTMR_CTRL_S *swtmr)
|
||||
{
|
||||
/* insert to free list */
|
||||
LOS_ListTailInsert(&g_swtmrFreeList, &swtmr->stSortList.sortLinkNode);
|
||||
swtmr->ucState = OS_SWTMR_STATUS_UNUSED;
|
||||
swtmr->uwOwnerPid = 0;
|
||||
}
|
||||
|
||||
STATIC INLINE VOID OsWakePendTimeSwtmr(Percpu *cpu, UINT64 currTime, SWTMR_CTRL_S *swtmr)
|
||||
{
|
||||
LOS_SpinLock(&g_swtmrSpin);
|
||||
SwtmrHandlerItemPtr swtmrHandler = (SwtmrHandlerItemPtr)LOS_MemboxAlloc(g_swtmrHandlerPool);
|
||||
if (swtmrHandler != NULL) {
|
||||
swtmrHandler->handler = swtmr->pfnHandler;
|
||||
swtmrHandler->arg = swtmr->uwArg;
|
||||
|
||||
if (LOS_QueueWrite(cpu->swtmrHandlerQueue, swtmrHandler, sizeof(CHAR *), LOS_NO_WAIT)) {
|
||||
(VOID)LOS_MemboxFree(g_swtmrHandlerPool, swtmrHandler);
|
||||
}
|
||||
}
|
||||
|
||||
if (swtmr->ucMode == LOS_SWTMR_MODE_ONCE) {
|
||||
OsSwtmrDelete(swtmr);
|
||||
|
||||
if (swtmr->usTimerID < (OS_SWTMR_MAX_TIMERID - LOSCFG_BASE_CORE_SWTMR_LIMIT)) {
|
||||
swtmr->usTimerID += LOSCFG_BASE_CORE_SWTMR_LIMIT;
|
||||
} else {
|
||||
swtmr->usTimerID %= LOSCFG_BASE_CORE_SWTMR_LIMIT;
|
||||
}
|
||||
} else if (swtmr->ucMode == LOS_SWTMR_MODE_NO_SELFDELETE) {
|
||||
swtmr->ucState = OS_SWTMR_STATUS_CREATED;
|
||||
} else {
|
||||
swtmr->uwOverrun++;
|
||||
OsSwtmrStart(currTime, swtmr);
|
||||
}
|
||||
|
||||
LOS_SpinUnlock(&g_swtmrSpin);
|
||||
}
|
||||
|
||||
/*
|
||||
* Description: Tick interrupt interface module of software timer
|
||||
* Return : LOS_OK on success or error code on failure
|
||||
*/
|
||||
LITE_OS_SEC_TEXT VOID OsSwtmrScan(VOID)
|
||||
{
|
||||
Percpu *cpu = OsPercpuGet();
|
||||
SortLinkAttribute* swtmrSortLink = &OsPercpuGet()->swtmrSortLink;
|
||||
LOS_DL_LIST *listObject = &swtmrSortLink->sortLink;
|
||||
|
||||
/*
|
||||
* it needs to be carefully coped with, since the swtmr is in specific sortlink
|
||||
* while other cores still has the chance to process it, like stop the timer.
|
||||
*/
|
||||
LOS_SpinLock(&cpu->swtmrSortLinkSpin);
|
||||
|
||||
if (LOS_ListEmpty(listObject)) {
|
||||
LOS_SpinUnlock(&cpu->swtmrSortLinkSpin);
|
||||
return;
|
||||
}
|
||||
SortLinkList *sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
|
||||
|
||||
UINT64 currTime = OsGetCurrSchedTimeCycle();
|
||||
while (sortList->responseTime <= currTime) {
|
||||
sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
|
||||
SWTMR_CTRL_S *swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
|
||||
swtmr->startTime = GET_SORTLIST_VALUE(sortList);
|
||||
OsDeleteNodeSortLink(swtmrSortLink, sortList);
|
||||
LOS_SpinUnlock(&cpu->swtmrSortLinkSpin);
|
||||
|
||||
OsHookCall(LOS_HOOK_TYPE_SWTMR_EXPIRED, swtmr);
|
||||
OsWakePendTimeSwtmr(cpu, currTime, swtmr);
|
||||
|
||||
LOS_SpinLock(&cpu->swtmrSortLinkSpin);
|
||||
if (LOS_ListEmpty(listObject)) {
|
||||
break;
|
||||
}
|
||||
|
||||
sortList = LOS_DL_LIST_ENTRY(listObject->pstNext, SortLinkList, sortLinkNode);
|
||||
}
|
||||
|
||||
LOS_SpinUnlock(&cpu->swtmrSortLinkSpin);
|
||||
}
|
||||
|
||||
/*
|
||||
* Description: Get next timeout
|
||||
* Return : Count of the Timer list
|
||||
*/
|
||||
LITE_OS_SEC_TEXT UINT32 OsSwtmrGetNextTimeout(VOID)
|
||||
{
|
||||
return OsSortLinkGetNextExpireTime(&OsPercpuGet()->swtmrSortLink);
|
||||
}
|
||||
|
||||
/*
|
||||
* Description: Stop of Software Timer interface
|
||||
* Input : swtmr --- the software timer contrl handler
|
||||
*/
|
||||
LITE_OS_SEC_TEXT STATIC VOID OsSwtmrStop(SWTMR_CTRL_S *swtmr)
|
||||
{
|
||||
OsDeleteSortLink(&swtmr->stSortList, OS_SORT_LINK_SWTMR);
|
||||
|
||||
swtmr->ucState = OS_SWTMR_STATUS_CREATED;
|
||||
swtmr->uwOverrun = 0;
|
||||
|
||||
OsSchedUpdateExpireTime(OsGetCurrSchedTimeCycle());
|
||||
}
|
||||
|
||||
/*
|
||||
* Description: Get next software timer expiretime
|
||||
* Input : swtmr --- the software timer contrl handler
|
||||
*/
|
||||
LITE_OS_SEC_TEXT STATIC UINT32 OsSwtmrTimeGet(const SWTMR_CTRL_S *swtmr)
|
||||
{
|
||||
return OsSortLinkGetTargetExpireTime(&swtmr->stSortList);
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_INIT UINT32 LOS_SwtmrCreate(UINT32 interval,
|
||||
UINT8 mode,
|
||||
SWTMR_PROC_FUNC handler,
|
||||
UINT16 *swtmrID,
|
||||
UINTPTR arg)
|
||||
{
|
||||
SWTMR_CTRL_S *swtmr = NULL;
|
||||
UINT32 intSave;
|
||||
SortLinkList *sortList = NULL;
|
||||
|
||||
if (interval == 0) {
|
||||
return LOS_ERRNO_SWTMR_INTERVAL_NOT_SUITED;
|
||||
}
|
||||
|
||||
if ((mode != LOS_SWTMR_MODE_ONCE) && (mode != LOS_SWTMR_MODE_PERIOD) &&
|
||||
(mode != LOS_SWTMR_MODE_NO_SELFDELETE)) {
|
||||
return LOS_ERRNO_SWTMR_MODE_INVALID;
|
||||
}
|
||||
|
||||
if (handler == NULL) {
|
||||
return LOS_ERRNO_SWTMR_PTR_NULL;
|
||||
}
|
||||
|
||||
if (swtmrID == NULL) {
|
||||
return LOS_ERRNO_SWTMR_RET_PTR_NULL;
|
||||
}
|
||||
|
||||
SWTMR_LOCK(intSave);
|
||||
if (LOS_ListEmpty(&g_swtmrFreeList)) {
|
||||
SWTMR_UNLOCK(intSave);
|
||||
return LOS_ERRNO_SWTMR_MAXSIZE;
|
||||
}
|
||||
|
||||
sortList = LOS_DL_LIST_ENTRY(g_swtmrFreeList.pstNext, SortLinkList, sortLinkNode);
|
||||
swtmr = LOS_DL_LIST_ENTRY(sortList, SWTMR_CTRL_S, stSortList);
|
||||
LOS_ListDelete(LOS_DL_LIST_FIRST(&g_swtmrFreeList));
|
||||
SWTMR_UNLOCK(intSave);
|
||||
|
||||
swtmr->uwOwnerPid = OsCurrProcessGet()->processID;
|
||||
swtmr->pfnHandler = handler;
|
||||
swtmr->ucMode = mode;
|
||||
swtmr->uwOverrun = 0;
|
||||
swtmr->uwInterval = interval;
|
||||
swtmr->uwExpiry = interval;
|
||||
swtmr->uwArg = arg;
|
||||
swtmr->ucState = OS_SWTMR_STATUS_CREATED;
|
||||
SET_SORTLIST_VALUE(&swtmr->stSortList, OS_SORT_LINK_INVALID_TIME);
|
||||
*swtmrID = swtmr->usTimerID;
|
||||
OsHookCall(LOS_HOOK_TYPE_SWTMR_CREATE, swtmr);
|
||||
return LOS_OK;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStart(UINT16 swtmrID)
|
||||
{
|
||||
SWTMR_CTRL_S *swtmr = NULL;
|
||||
UINT32 intSave;
|
||||
UINT32 ret = LOS_OK;
|
||||
UINT16 swtmrCBID;
|
||||
|
||||
if (swtmrID >= OS_SWTMR_MAX_TIMERID) {
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
|
||||
swtmrCBID = swtmrID % LOSCFG_BASE_CORE_SWTMR_LIMIT;
|
||||
swtmr = g_swtmrCBArray + swtmrCBID;
|
||||
|
||||
SWTMR_LOCK(intSave);
|
||||
if (swtmr->usTimerID != swtmrID) {
|
||||
SWTMR_UNLOCK(intSave);
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
|
||||
switch (swtmr->ucState) {
|
||||
case OS_SWTMR_STATUS_UNUSED:
|
||||
ret = LOS_ERRNO_SWTMR_NOT_CREATED;
|
||||
break;
|
||||
/*
|
||||
* If the status of swtmr is timing, it should stop the swtmr first,
|
||||
* then start the swtmr again.
|
||||
*/
|
||||
case OS_SWTMR_STATUS_TICKING:
|
||||
OsSwtmrStop(swtmr);
|
||||
/* fall-through */
|
||||
case OS_SWTMR_STATUS_CREATED:
|
||||
swtmr->startTime = OsGetCurrSchedTimeCycle();
|
||||
OsSwtmrStart(swtmr->startTime, swtmr);
|
||||
break;
|
||||
default:
|
||||
ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
|
||||
break;
|
||||
}
|
||||
|
||||
SWTMR_UNLOCK(intSave);
|
||||
OsHookCall(LOS_HOOK_TYPE_SWTMR_START, swtmr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrStop(UINT16 swtmrID)
|
||||
{
|
||||
SWTMR_CTRL_S *swtmr = NULL;
|
||||
UINT32 intSave;
|
||||
UINT32 ret = LOS_OK;
|
||||
UINT16 swtmrCBID;
|
||||
|
||||
if (swtmrID >= OS_SWTMR_MAX_TIMERID) {
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
|
||||
swtmrCBID = swtmrID % LOSCFG_BASE_CORE_SWTMR_LIMIT;
|
||||
swtmr = g_swtmrCBArray + swtmrCBID;
|
||||
SWTMR_LOCK(intSave);
|
||||
|
||||
if (swtmr->usTimerID != swtmrID) {
|
||||
SWTMR_UNLOCK(intSave);
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
|
||||
switch (swtmr->ucState) {
|
||||
case OS_SWTMR_STATUS_UNUSED:
|
||||
ret = LOS_ERRNO_SWTMR_NOT_CREATED;
|
||||
break;
|
||||
case OS_SWTMR_STATUS_CREATED:
|
||||
ret = LOS_ERRNO_SWTMR_NOT_STARTED;
|
||||
break;
|
||||
case OS_SWTMR_STATUS_TICKING:
|
||||
OsSwtmrStop(swtmr);
|
||||
break;
|
||||
default:
|
||||
ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
|
||||
break;
|
||||
}
|
||||
|
||||
SWTMR_UNLOCK(intSave);
|
||||
OsHookCall(LOS_HOOK_TYPE_SWTMR_STOP, swtmr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrTimeGet(UINT16 swtmrID, UINT32 *tick)
|
||||
{
|
||||
SWTMR_CTRL_S *swtmr = NULL;
|
||||
UINT32 intSave;
|
||||
UINT32 ret = LOS_OK;
|
||||
UINT16 swtmrCBID;
|
||||
|
||||
if (swtmrID >= OS_SWTMR_MAX_TIMERID) {
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
|
||||
if (tick == NULL) {
|
||||
return LOS_ERRNO_SWTMR_TICK_PTR_NULL;
|
||||
}
|
||||
|
||||
swtmrCBID = swtmrID % LOSCFG_BASE_CORE_SWTMR_LIMIT;
|
||||
swtmr = g_swtmrCBArray + swtmrCBID;
|
||||
SWTMR_LOCK(intSave);
|
||||
|
||||
if (swtmr->usTimerID != swtmrID) {
|
||||
SWTMR_UNLOCK(intSave);
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
switch (swtmr->ucState) {
|
||||
case OS_SWTMR_STATUS_UNUSED:
|
||||
ret = LOS_ERRNO_SWTMR_NOT_CREATED;
|
||||
break;
|
||||
case OS_SWTMR_STATUS_CREATED:
|
||||
ret = LOS_ERRNO_SWTMR_NOT_STARTED;
|
||||
break;
|
||||
case OS_SWTMR_STATUS_TICKING:
|
||||
*tick = OsSwtmrTimeGet(swtmr);
|
||||
break;
|
||||
default:
|
||||
ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
|
||||
break;
|
||||
}
|
||||
SWTMR_UNLOCK(intSave);
|
||||
return ret;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT UINT32 LOS_SwtmrDelete(UINT16 swtmrID)
|
||||
{
|
||||
SWTMR_CTRL_S *swtmr = NULL;
|
||||
UINT32 intSave;
|
||||
UINT32 ret = LOS_OK;
|
||||
UINT16 swtmrCBID;
|
||||
|
||||
if (swtmrID >= OS_SWTMR_MAX_TIMERID) {
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
|
||||
swtmrCBID = swtmrID % LOSCFG_BASE_CORE_SWTMR_LIMIT;
|
||||
swtmr = g_swtmrCBArray + swtmrCBID;
|
||||
SWTMR_LOCK(intSave);
|
||||
|
||||
if (swtmr->usTimerID != swtmrID) {
|
||||
SWTMR_UNLOCK(intSave);
|
||||
return LOS_ERRNO_SWTMR_ID_INVALID;
|
||||
}
|
||||
|
||||
switch (swtmr->ucState) {
|
||||
case OS_SWTMR_STATUS_UNUSED:
|
||||
ret = LOS_ERRNO_SWTMR_NOT_CREATED;
|
||||
break;
|
||||
case OS_SWTMR_STATUS_TICKING:
|
||||
OsSwtmrStop(swtmr);
|
||||
/* fall-through */
|
||||
case OS_SWTMR_STATUS_CREATED:
|
||||
OsSwtmrDelete(swtmr);
|
||||
break;
|
||||
default:
|
||||
ret = LOS_ERRNO_SWTMR_STATUS_INVALID;
|
||||
break;
|
||||
}
|
||||
|
||||
SWTMR_UNLOCK(intSave);
|
||||
OsHookCall(LOS_HOOK_TYPE_SWTMR_DELETE, swtmr);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif /* LOSCFG_BASE_CORE_SWTMR_ENABLE */
|
@ -0,0 +1,72 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_sys_pri.h"
|
||||
#include "los_sched_pri.h"
|
||||
|
||||
|
||||
#define OS_MAX_VALUE 0xFFFFFFFFUL
|
||||
|
||||
LITE_OS_SEC_TEXT_MINOR UINT64 LOS_TickCountGet(VOID)
|
||||
{
|
||||
return OsGetCurrSchedTimeCycle() / OS_CYCLE_PER_TICK;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_CyclePerTickGet(VOID)
|
||||
{
|
||||
return g_sysClock / LOSCFG_BASE_CORE_TICK_PER_SECOND;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_MS2Tick(UINT32 millisec)
|
||||
{
|
||||
if (millisec == OS_MAX_VALUE) {
|
||||
return OS_MAX_VALUE;
|
||||
}
|
||||
|
||||
return ((UINT64)millisec * LOSCFG_BASE_CORE_TICK_PER_SECOND) / OS_SYS_MS_PER_SECOND;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_MINOR UINT32 LOS_Tick2MS(UINT32 tick)
|
||||
{
|
||||
return ((UINT64)tick * OS_SYS_MS_PER_SECOND) / LOSCFG_BASE_CORE_TICK_PER_SECOND;
|
||||
}
|
||||
|
||||
LITE_OS_SEC_TEXT_MINOR UINT32 OsNS2Tick(UINT64 nanoseconds)
|
||||
{
|
||||
const UINT32 nsPerTick = OS_SYS_NS_PER_SECOND / LOSCFG_BASE_CORE_TICK_PER_SECOND;
|
||||
|
||||
UINT64 ticks = (nanoseconds + nsPerTick - 1) / nsPerTick;
|
||||
if (ticks > OS_MAX_VALUE) {
|
||||
ticks = OS_MAX_VALUE;
|
||||
}
|
||||
return (UINT32)ticks;
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_tick_pri.h"
|
||||
#include "los_swtmr_pri.h"
|
||||
#include "los_sched_pri.h"
|
||||
#ifdef LOSCFG_KERNEL_VDSO
|
||||
#include "los_vdso.h"
|
||||
#endif
|
||||
|
||||
|
||||
LITE_OS_SEC_DATA_INIT UINT32 g_sysClock;
|
||||
LITE_OS_SEC_DATA_INIT UINT32 g_tickPerSecond;
|
||||
LITE_OS_SEC_BSS DOUBLE g_cycle2NsScale;
|
||||
|
||||
/* spinlock for task module */
|
||||
LITE_OS_SEC_BSS SPIN_LOCK_INIT(g_tickSpin);
|
||||
|
||||
/*
|
||||
* Description : Tick interruption handler
|
||||
*/
|
||||
LITE_OS_SEC_TEXT VOID OsTickHandler(VOID)
|
||||
{
|
||||
#ifdef LOSCFG_SCHED_TICK_DEBUG
|
||||
OsSchedDebugRecordData();
|
||||
#endif
|
||||
|
||||
#ifdef LOSCFG_KERNEL_VDSO
|
||||
OsVdsoTimevalUpdate();
|
||||
#endif
|
||||
|
||||
#ifdef LOSCFG_BASE_CORE_TICK_HW_TIME
|
||||
HalClockIrqClear(); /* diff from every platform */
|
||||
#endif
|
||||
|
||||
OsSchedTick();
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,232 @@
|
||||
/*
|
||||
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
|
||||
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification,
|
||||
* are permitted provided that the following conditions are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
* conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
* of conditions and the following disclaimer in the documentation and/or other materials
|
||||
* provided with the distribution.
|
||||
*
|
||||
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
|
||||
* to endorse or promote products derived from this software without specific prior written
|
||||
* permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
||||
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
||||
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
||||
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
||||
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "los_sortlink_pri.h"
|
||||
#include "los_memory.h"
|
||||
#include "los_exc.h"
|
||||
#include "los_percpu_pri.h"
|
||||
#include "los_sched_pri.h"
|
||||
#include "los_mp.h"
|
||||
|
||||
UINT32 OsSortLinkInit(SortLinkAttribute *sortLinkHeader)
|
||||
{
|
||||
LOS_ListInit(&sortLinkHeader->sortLink);
|
||||
sortLinkHeader->nodeNum = 0;
|
||||
return LOS_OK;
|
||||
}
|
||||
|
||||
STATIC INLINE VOID OsAddNode2SortLink(SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
|
||||
{
|
||||
LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink;
|
||||
|
||||
if (LOS_ListEmpty(head)) {
|
||||
LOS_ListHeadInsert(head, &sortList->sortLinkNode);
|
||||
sortLinkHeader->nodeNum++;
|
||||
return;
|
||||
}
|
||||
|
||||
SortLinkList *listSorted = LOS_DL_LIST_ENTRY(head->pstNext, SortLinkList, sortLinkNode);
|
||||
if (listSorted->responseTime > sortList->responseTime) {
|
||||
LOS_ListAdd(head, &sortList->sortLinkNode);
|
||||
sortLinkHeader->nodeNum++;
|
||||
return;
|
||||
} else if (listSorted->responseTime == sortList->responseTime) {
|
||||
LOS_ListAdd(head->pstNext, &sortList->sortLinkNode);
|
||||
sortLinkHeader->nodeNum++;
|
||||
return;
|
||||
}
|
||||
|
||||
LOS_DL_LIST *prevNode = head->pstPrev;
|
||||
do {
|
||||
listSorted = LOS_DL_LIST_ENTRY(prevNode, SortLinkList, sortLinkNode);
|
||||
if (listSorted->responseTime <= sortList->responseTime) {
|
||||
LOS_ListAdd(prevNode, &sortList->sortLinkNode);
|
||||
sortLinkHeader->nodeNum++;
|
||||
break;
|
||||
}
|
||||
|
||||
prevNode = prevNode->pstPrev;
|
||||
} while (1);
|
||||
}
|
||||
|
||||
VOID OsDeleteNodeSortLink(SortLinkAttribute *sortLinkHeader, SortLinkList *sortList)
|
||||
{
|
||||
LOS_ListDelete(&sortList->sortLinkNode);
|
||||
SET_SORTLIST_VALUE(sortList, OS_SORT_LINK_INVALID_TIME);
|
||||
sortLinkHeader->nodeNum--;
|
||||
}
|
||||
|
||||
STATIC INLINE UINT64 OsGetSortLinkNextExpireTime(SortLinkAttribute *sortHeader, UINT64 startTime)
|
||||
{
|
||||
LOS_DL_LIST *head = &sortHeader->sortLink;
|
||||
LOS_DL_LIST *list = head->pstNext;
|
||||
|
||||
if (LOS_ListEmpty(head)) {
|
||||
return OS_SCHED_MAX_RESPONSE_TIME - OS_TICK_RESPONSE_PRECISION;
|
||||
}
|
||||
|
||||
SortLinkList *listSorted = LOS_DL_LIST_ENTRY(list, SortLinkList, sortLinkNode);
|
||||
if (listSorted->responseTime <= (startTime + OS_TICK_RESPONSE_PRECISION)) {
|
||||
return startTime + OS_TICK_RESPONSE_PRECISION;
|
||||
}
|
||||
|
||||
return listSorted->responseTime;
|
||||
}
|
||||
|
||||
STATIC Percpu *OsFindIdleCpu(UINT16 *idleCpuID)
|
||||
{
|
||||
Percpu *idleCpu = OsPercpuGetByID(0);
|
||||
*idleCpuID = 0;
|
||||
|
||||
#ifdef LOSCFG_KERNEL_SMP
|
||||
UINT16 cpuID = 1;
|
||||
UINT32 nodeNum = idleCpu->taskSortLink.nodeNum + idleCpu->swtmrSortLink.nodeNum;
|
||||
|
||||
do {
|
||||
Percpu *cpu = OsPercpuGetByID(cpuID);
|
||||
UINT32 temp = cpu->taskSortLink.nodeNum + cpu->swtmrSortLink.nodeNum;
|
||||
if (nodeNum > temp) {
|
||||
idleCpu = cpu;
|
||||
*idleCpuID = cpuID;
|
||||
}
|
||||
|
||||
cpuID++;
|
||||
} while (cpuID < LOSCFG_KERNEL_CORE_NUM);
|
||||
#endif
|
||||
|
||||
return idleCpu;
|
||||
}
|
||||
|
||||
VOID OsAdd2SortLink(SortLinkList *node, UINT64 startTime, UINT32 waitTicks, SortLinkType type)
|
||||
{
|
||||
UINT32 intSave;
|
||||
Percpu *cpu = NULL;
|
||||
SortLinkAttribute *sortLinkHeader = NULL;
|
||||
SPIN_LOCK_S *spinLock = NULL;
|
||||
UINT16 idleCpu;
|
||||
|
||||
if (OS_SCHEDULER_ACTIVE) {
|
||||
cpu = OsFindIdleCpu(&idleCpu);
|
||||
} else {
|
||||
idleCpu = ArchCurrCpuid();
|
||||
cpu = OsPercpuGet();
|
||||
}
|
||||
|
||||
if (type == OS_SORT_LINK_TASK) {
|
||||
sortLinkHeader = &cpu->taskSortLink;
|
||||
spinLock = &cpu->taskSortLinkSpin;
|
||||
} else if (type == OS_SORT_LINK_SWTMR) {
|
||||
sortLinkHeader = &cpu->swtmrSortLink;
|
||||
spinLock = &cpu->swtmrSortLinkSpin;
|
||||
} else {
|
||||
LOS_Panic("Sort link type error : %u\n", type);
|
||||
}
|
||||
|
||||
LOS_SpinLockSave(spinLock, &intSave);
|
||||
SET_SORTLIST_VALUE(node, startTime + (UINT64)waitTicks * OS_CYCLE_PER_TICK);
|
||||
OsAddNode2SortLink(sortLinkHeader, node);
|
||||
#ifdef LOSCFG_KERNEL_SMP
|
||||
node->cpuid = idleCpu;
|
||||
if (idleCpu != ArchCurrCpuid()) {
|
||||
LOS_MpSchedule(CPUID_TO_AFFI_MASK(idleCpu));
|
||||
}
|
||||
#endif
|
||||
LOS_SpinUnlockRestore(spinLock, intSave);
|
||||
}
|
||||
|
||||
VOID OsDeleteSortLink(SortLinkList *node, SortLinkType type)
|
||||
{
|
||||
UINT32 intSave;
|
||||
#ifdef LOSCFG_KERNEL_SMP
|
||||
Percpu *cpu = OsPercpuGetByID(node->cpuid);
|
||||
#else
|
||||
Percpu *cpu = OsPercpuGetByID(0);
|
||||
#endif
|
||||
|
||||
SPIN_LOCK_S *spinLock = NULL;
|
||||
SortLinkAttribute *sortLinkHeader = NULL;
|
||||
if (type == OS_SORT_LINK_TASK) {
|
||||
sortLinkHeader = &cpu->taskSortLink;
|
||||
spinLock = &cpu->taskSortLinkSpin;
|
||||
} else if (type == OS_SORT_LINK_SWTMR) {
|
||||
sortLinkHeader = &cpu->swtmrSortLink;
|
||||
spinLock = &cpu->swtmrSortLinkSpin;
|
||||
} else {
|
||||
LOS_Panic("Sort link type error : %u\n", type);
|
||||
}
|
||||
|
||||
LOS_SpinLockSave(spinLock, &intSave);
|
||||
if (node->responseTime != OS_SORT_LINK_INVALID_TIME) {
|
||||
OsDeleteNodeSortLink(sortLinkHeader, node);
|
||||
}
|
||||
LOS_SpinUnlockRestore(spinLock, intSave);
|
||||
}
|
||||
|
||||
UINT64 OsGetNextExpireTime(UINT64 startTime)
|
||||
{
|
||||
UINT32 intSave;
|
||||
Percpu *cpu = OsPercpuGet();
|
||||
SortLinkAttribute *taskHeader = &cpu->taskSortLink;
|
||||
SortLinkAttribute *swtmrHeader = &cpu->swtmrSortLink;
|
||||
|
||||
LOS_SpinLockSave(&cpu->taskSortLinkSpin, &intSave);
|
||||
UINT64 taskExpirTime = OsGetSortLinkNextExpireTime(taskHeader, startTime);
|
||||
LOS_SpinUnlockRestore(&cpu->taskSortLinkSpin, intSave);
|
||||
|
||||
LOS_SpinLockSave(&cpu->swtmrSortLinkSpin, &intSave);
|
||||
UINT64 swtmrExpirTime = OsGetSortLinkNextExpireTime(swtmrHeader, startTime);
|
||||
LOS_SpinUnlockRestore(&cpu->swtmrSortLinkSpin, intSave);
|
||||
|
||||
return (taskExpirTime < swtmrExpirTime) ? taskExpirTime : swtmrExpirTime;
|
||||
}
|
||||
|
||||
UINT32 OsSortLinkGetTargetExpireTime(const SortLinkList *targetSortList)
|
||||
{
|
||||
UINT64 currTimes = OsGetCurrSchedTimeCycle();
|
||||
if (currTimes >= targetSortList->responseTime) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return (UINT32)(targetSortList->responseTime - currTimes) / OS_CYCLE_PER_TICK;
|
||||
}
|
||||
|
||||
UINT32 OsSortLinkGetNextExpireTime(const SortLinkAttribute *sortLinkHeader)
|
||||
{
|
||||
LOS_DL_LIST *head = (LOS_DL_LIST *)&sortLinkHeader->sortLink;
|
||||
|
||||
if (LOS_ListEmpty(head)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
SortLinkList *listSorted = LOS_DL_LIST_ENTRY(head->pstNext, SortLinkList, sortLinkNode);
|
||||
return OsSortLinkGetTargetExpireTime(listSorted);
|
||||
}
|
||||
|
Loading…
Reference in new issue