yystopf
/
openharmony_kernel_liteos_m
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 低功耗支持冻结线程等需求 

1.支持低功耗时冻结线程
2.支持延时锁
3.低功耗与idle分离
4.支持对接电源管组件的低功耗接口
LOS_PmReadLock --- 常阻塞，低功耗线程阻塞于该接口，当系统无任何模块持锁时会唤醒低功耗线程, 触发低功耗流程
LOS_PmSuspend --- 进入低功耗流程
Close #I49FJF

Signed-off-by: zhushengle <zhushengle@huawei.com>
Change-Id: I009255cfa1852b109dd8bfaf9c779e976660d621
This commit is contained in:
zhushengle 2021-09-11 17:12:26 +08:00
parent c77c178ec1
commit 9b5739ab11
12 changed files with 835 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

325
components/power/los_pm.c
View File

@ -34,20 +34,23 @@
#include "los_sched.h"
#include "los_timer.h"
#include "los_memory.h"
#include "los_swtmr.h"
#if (LOSCFG_KERNEL_PM == 1)
#define OS_PM_NODE_FREE 0x80000000U
#define OS_PM_LOCK_MAX 0xFFFFU
#define OS_PM_SYS_EARLY 1
#define OS_PM_SYS_DEVICE_EARLY 2
typedef UINT32 (*Suspend)(VOID);
typedef UINT32 (*SysSuspend)(VOID);
typedef UINT32 (*Suspend)(UINT32 mode);
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
typedef struct {
CHAR *name;
UINT32 count;
UINT32 swtmrID;
LOS_DL_LIST list;
} OsPmLockCB;
#endif
typedef struct {
LOS_SysSleepEnum pmMode;
@ -60,11 +63,12 @@ typedef struct {
#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
UINT64 enterSleepTime;
#endif
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
LOS_DL_LIST lockList;
#endif
} LosPmCB;
#define PM_EVENT_LOCK_MASK 0xF
#define PM_EVENT_LOCK_RELEASE 0x1
STATIC EVENT_CB_S g_pmEvent;
STATIC LosPmCB g_pmCB;
STATIC LosPmSysctrl *g_sysctrl = NULL;
STATIC UINT64 g_pmSleepTime;
@ -99,7 +103,7 @@ STATIC VOID OsPmTickTimerStart(LosPmCB *pm)
return;
}
STATIC VOID OsPmTickTimerStop(LosPmCB *pm)
STATIC BOOL OsPmTickTimerStop(LosPmCB *pm)
{
#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
UINT64 sleepCycle;
@ -108,13 +112,13 @@ STATIC VOID OsPmTickTimerStop(LosPmCB *pm)
LosPmTickTimer *tickTimer = pm->tickTimer;
if ((tickTimer == NULL) || (tickTimer->tickLock == NULL)) {
return;
return FALSE;
}
#if (LOSCFG_BASE_CORE_TICK_WTIMER == 0)
if (tickTimer->timerStart != NULL) {
if (realSleepTime == 0) {
return;
return FALSE;
}
sleepCycle = OS_SYS_CYCLE_TO_NS(realSleepTime, OS_SYS_CLOCK);
@ -124,12 +128,12 @@ STATIC VOID OsPmTickTimerStop(LosPmCB *pm)
pm->enterSleepTime = OsGetCurrSysTimeCycle();
tickTimer->tickLock();
tickTimer->timerStart(sleepCycle);
return;
return TRUE;
}
#endif
tickTimer->tickLock();
return;
return TRUE;
}
STATIC VOID OsPmCpuResume(LosPmCB *pm)
@ -143,9 +147,9 @@ STATIC VOID OsPmCpuResume(LosPmCB *pm)
}
}
STATIC Suspend OsPmCpuSuspend(LosPmCB *pm)
STATIC SysSuspend OsPmCpuSuspend(LosPmCB *pm)
{
Suspend sysSuspend = NULL;
SysSuspend sysSuspend = NULL;
/* cpu enter low power mode */
LOS_ASSERT(pm->sysctrl != NULL);
@ -165,36 +169,94 @@ STATIC Suspend OsPmCpuSuspend(LosPmCB *pm)
return sysSuspend;
}
STATIC UINT32 OsPmSuspendSleep(LosPmCB *pm)
STATIC VOID OsPmResumePrepare(LosPmCB *pm, UINT32 mode, UINT32 prepare)
{
if ((prepare == 0) && (pm->device->resume != NULL)) {
pm->device->resume(mode);
}
if (((prepare == 0) || (prepare == OS_PM_SYS_DEVICE_EARLY)) && (pm->sysctrl->late != NULL)) {
pm->sysctrl->late(mode);
}
}
STATIC UINT32 OsPmSuspendPrepare(Suspend sysSuspendEarly, Suspend deviceSuspend, UINT32 mode, UINT32 *prepare)
{
UINT32 ret;
if (sysSuspendEarly != NULL) {
ret = sysSuspendEarly(mode);
if (ret != LOS_OK) {
*prepare = OS_PM_SYS_EARLY;
return ret;
}
}
if (deviceSuspend != NULL) {
ret = deviceSuspend(mode);
if (ret != LOS_OK) {
*prepare = OS_PM_SYS_DEVICE_EARLY;
return ret;
}
}
return LOS_OK;
}
STATIC UINT32 OsPmSuspendCheck(LosPmCB *pm, Suspend *sysSuspendEarly, Suspend *deviceSuspend, LOS_SysSleepEnum *mode)
{
UINT32 ret = LOS_OK;
UINT32 intSave;
LOS_SysSleepEnum mode;
Suspend sysSuspend = NULL;
intSave = LOS_IntLock();
pm->sysMode = pm->pmMode;
if ((pm->pmMode != LOS_SYS_NORMAL_SLEEP) && (pm->lock > 0)) {
if (pm->lock > 0) {
pm->sysMode = LOS_SYS_NORMAL_SLEEP;
}
if (pm->sysMode == LOS_SYS_NORMAL_SLEEP) {
LOS_IntRestore(intSave);
return LOS_NOK;
}
pm->isWake = FALSE;
LOS_TaskLock();
*mode = pm->sysMode;
*sysSuspendEarly = pm->sysctrl->early;
*deviceSuspend = pm->device->suspend;
LOS_IntRestore(intSave);
return LOS_OK;
}
mode = pm->sysMode;
if (pm->device->suspend != NULL) {
ret = pm->device->suspend(mode);
if (ret != LOS_OK) {
goto DEVICE_EXIT;
}
STATIC UINT32 OsPmSuspendSleep(LosPmCB *pm)
{
UINT32 ret, intSave;
Suspend sysSuspendEarly, deviceSuspend;
LOS_SysSleepEnum mode;
UINT32 prepare = 0;
BOOL tickTimerStop = FALSE;
SysSuspend sysSuspend;
UINT64 currTime;
ret = OsPmSuspendCheck(pm, &sysSuspendEarly, &deviceSuspend, &mode);
if (ret != LOS_OK) {
return ret;
}
OsPmTickTimerStop(pm);
ret = OsPmSuspendPrepare(sysSuspendEarly, deviceSuspend, (UINT32)mode, &prepare);
if (ret != LOS_OK) {
intSave = LOS_IntLock();
LOS_TaskLock();
goto EXIT;
}
intSave = LOS_IntLock();
LOS_TaskLock();
if (pm->isWake || (pm->lock > 0)) {
goto EXIT;
}
tickTimerStop = OsPmTickTimerStop(pm);
if (!tickTimerStop) {
currTime = OsGetCurrSchedTimeCycle();
OsSchedResetSchedResponseTime(0);
OsSchedSetNextExpireTime(currTime, OS_INVALID, OS_SCHED_MAX_RESPONSE_TIME, TRUE);
}
sysSuspend = OsPmCpuSuspend(pm);
LOS_IntRestore(intSave);
@ -209,22 +271,20 @@ STATIC UINT32 OsPmSuspendSleep(LosPmCB *pm)
OsPmTickTimerStart(pm);
if (pm->device->resume != NULL) {
pm->device->resume(mode);
}
DEVICE_EXIT:
EXIT:
pm->sysMode = LOS_SYS_NORMAL_SLEEP;
OsPmResumePrepare(pm, (UINT32)mode, prepare);
LOS_IntRestore(intSave);
LOS_TaskUnlock();
return ret;
}
STATIC VOID OsPmNormalSleep(LosPmCB *pm)
STATIC VOID OsPmNormalSleep(VOID)
{
UINT32 intSave;
Suspend sysSuspend = NULL;
LosPmCB *pm = &g_pmCB;
SysSuspend sysSuspend = NULL;
intSave = LOS_IntLock();
sysSuspend = OsPmCpuSuspend(pm);
@ -237,24 +297,6 @@ STATIC VOID OsPmNormalSleep(LosPmCB *pm)
LOS_IntRestore(intSave);
}
STATIC VOID OsPmEnter(VOID)
{
UINT32 ret;
LosPmCB *pm = &g_pmCB;
ret = OsPmSuspendSleep(pm);
if (ret != LOS_OK) {
OsPmNormalSleep(pm);
}
return;
}
STATIC VOID OsPmTask(VOID)
{
OsPmEnter();
}
STATIC UINT32 OsPmDeviceRegister(LosPmCB *pm, LosPmDevice *device)
{
UINT32 intSave;
@ -438,11 +480,8 @@ LOS_SysSleepEnum LOS_PmModeGet(VOID)
UINT32 LOS_PmModeSet(LOS_SysSleepEnum mode)
{
UINT32 intSave;
UINT32 taskID;
UINT32 ret;
LosPmCB *pm = &g_pmCB;
INT32 sleepMode = (INT32)mode;
TSK_INIT_PARAM_S taskInitParam = { 0 };
if ((sleepMode < 0) || (sleepMode > LOS_SYS_SHUTDOWN)) {
return LOS_ERRNO_PM_INVALID_MODE;
@ -472,17 +511,6 @@ UINT32 LOS_PmModeSet(LOS_SysSleepEnum mode)
pm->pmMode = mode;
LOS_IntRestore(intSave);
if ((mode == LOS_SYS_DEEP_SLEEP) || (mode == LOS_SYS_SHUTDOWN)) {
taskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)OsPmTask;
taskInitParam.uwStackSize = LOSCFG_KERNEL_PM_TASK_STACKSIZE;
taskInitParam.pcName = "pm";
taskInitParam.usTaskPrio = LOSCFG_KERNEL_PM_TASK_PTIORITY;
ret = LOS_TaskCreate(&taskID, &taskInitParam);
if (ret != LOS_OK) {
return ret;
}
}
return LOS_OK;
}
@ -509,24 +537,17 @@ VOID LOS_PmLockInfoShow(VOID)
}
#endif
UINT32 LOS_PmLockRequest(const CHAR *name)
UINT32 OsPmLockRequest(const CHAR *name, UINT32 swtmrID)
{
UINT32 intSave;
UINT32 ret = LOS_ERRNO_PM_NOT_LOCK;
LosPmCB *pm = &g_pmCB;
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
OsPmLockCB *listNode = NULL;
OsPmLockCB *lock = NULL;
LOS_DL_LIST *head = &pm->lockList;
LOS_DL_LIST *list = head->pstNext;
if (name == NULL) {
return LOS_ERRNO_PM_INVALID_PARAM;
}
#endif
intSave = LOS_IntLock();
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
while (list != head) {
listNode = LOS_DL_LIST_ENTRY(list, OsPmLockCB, list);
if (strcmp(name, listNode->name) == 0) {
@ -545,11 +566,17 @@ UINT32 LOS_PmLockRequest(const CHAR *name)
}
lock->name = (CHAR *)name;
lock->count = 1;
lock->swtmrID = swtmrID;
LOS_ListTailInsert(head, &lock->list);
} else if (lock->count < OS_PM_LOCK_MAX) {
lock->count++;
}
#endif
if ((lock->swtmrID != OS_INVALID) && (lock->count > 1)) {
lock->count--;
LOS_IntRestore(intSave);
return LOS_ERRNO_PM_ALREADY_LOCK;
}
if (pm->lock < OS_PM_LOCK_MAX) {
pm->lock++;
@ -560,25 +587,34 @@ UINT32 LOS_PmLockRequest(const CHAR *name)
return ret;
}
UINT32 LOS_PmLockRequest(const CHAR *name)
{
if (name == NULL) {
return LOS_ERRNO_PM_INVALID_PARAM;
}
return OsPmLockRequest(name, OS_INVALID);
}
UINT32 LOS_PmLockRelease(const CHAR *name)
{
UINT32 intSave;
UINT32 ret = LOS_ERRNO_PM_NOT_LOCK;
LosPmCB *pm = &g_pmCB;
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
OsPmLockCB *lock = NULL;
OsPmLockCB *listNode = NULL;
LOS_DL_LIST *head = &pm->lockList;
LOS_DL_LIST *list = head->pstNext;
VOID *lockFree = NULL;
OsPmLockCB *lockFree = NULL;
BOOL isRelease = FALSE;
UINT32 mode;
if (name == NULL) {
return LOS_ERRNO_PM_INVALID_PARAM;
}
#endif
intSave = LOS_IntLock();
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
mode = (UINT32)pm->pmMode;
while (list != head) {
listNode = LOS_DL_LIST_ENTRY(list, OsPmLockCB, list);
if (strcmp(name, listNode->name) == 0) {
@ -599,25 +635,139 @@ UINT32 LOS_PmLockRelease(const CHAR *name)
lockFree = lock;
}
}
#endif
if (pm->lock > 0) {
pm->lock--;
if (pm->lock == 0) {
isRelease = TRUE;
}
ret = LOS_OK;
}
LOS_IntRestore(intSave);
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
(VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, lockFree);
#endif
if (lockFree != NULL) {
(VOID)LOS_SwtmrDelete(lockFree->swtmrID);
(VOID)LOS_MemFree((VOID *)OS_SYS_MEM_ADDR, lockFree);
}
if (isRelease && (mode > LOS_SYS_NORMAL_SLEEP)) {
(VOID)LOS_EventWrite(&g_pmEvent, PM_EVENT_LOCK_RELEASE);
}
return ret;
}
VOID OsPmFreezeTaskUnsafe(UINT32 taskID)
{
UINT64 responseTime;
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
responseTime = GET_SORTLIST_VALUE(&taskCB->sortList);
OsDeleteSortLink(&taskCB->sortList, OS_SORT_LINK_TASK);
SET_SORTLIST_VALUE(&taskCB->sortList, responseTime);
taskCB->taskStatus |= OS_TASK_FALG_FREEZE;
return;
}
VOID OsPmUnfreezeTaskUnsafe(UINT32 taskID)
{
LosTaskCB *taskCB = OS_TCB_FROM_TID(taskID);
UINT64 currTime, responseTime;
UINT32 remainTick;
taskCB->taskStatus &= ~OS_TASK_FALG_FREEZE;
currTime = OsGetCurrSchedTimeCycle();
responseTime = GET_SORTLIST_VALUE(&taskCB->sortList);
if (responseTime > currTime) {
remainTick = ((responseTime - currTime) + OS_CYCLE_PER_TICK - 1) / OS_CYCLE_PER_TICK;
OsAdd2SortLink(&taskCB->sortList, currTime, remainTick, OS_SORT_LINK_TASK);
return;
}
SET_SORTLIST_VALUE(&taskCB->sortList, OS_SORT_LINK_INVALID_TIME);
LOS_ListDelete(&taskCB->pendList);
taskCB->taskStatus &= ~(OS_TASK_STATUS_DELAY | OS_TASK_STATUS_PEND_TIME);
return;
}
STATIC VOID OsPmSwtmrHandler(UINT32 arg)
{
const CHAR *name = (const CHAR *)arg;
UINT32 ret = LOS_PmLockRelease(name);
if (ret != LOS_OK) {
PRINT_ERR("Pm delay lock %s release faled! : 0x%x\n", name, ret);
}
}
UINT32 LOS_PmTimeLockRequest(const CHAR *name, UINT64 millisecond)
{
UINT32 ticks;
UINT32 swtmrID;
UINT32 ret;
if ((name == NULL) || !millisecond) {
return LOS_ERRNO_PM_INVALID_PARAM;
}
ticks = (UINT32)((millisecond + OS_MS_PER_TICK - 1) / OS_MS_PER_TICK);
#if (LOSCFG_BASE_CORE_SWTMR_ALIGN == 1)
ret = LOS_SwtmrCreate(ticks, LOS_SWTMR_MODE_ONCE, OsPmSwtmrHandler, &swtmrID, (UINT32)(UINTPTR)name,
OS_SWTMR_ROUSES_ALLOW, OS_SWTMR_ALIGN_INSENSITIVE);
#else
ret = LOS_SwtmrCreate(ticks, LOS_SWTMR_MODE_ONCE, OsPmSwtmrHandler, &swtmrID, (UINT32)(UINTPTR)name);
#endif
if (ret != LOS_OK) {
return ret;
}
ret = OsPmLockRequest(name, swtmrID);
if (ret != LOS_OK) {
(VOID)LOS_SwtmrDelete(swtmrID);
return ret;
}
ret = LOS_SwtmrStart(swtmrID);
if (ret != LOS_OK) {
(VOID)LOS_PmLockRelease(name);
}
return ret;
}
UINT32 LOS_PmReadLock(VOID)
{
UINT32 ret = LOS_EventRead(&g_pmEvent, PM_EVENT_LOCK_MASK, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
if (ret > PM_EVENT_LOCK_MASK) {
PRINT_ERR("%s event read failed! ERROR: 0x%x\n", ret);
}
return LOS_OK;
}
UINT32 LOS_PmSuspend(UINT32 wakeCount)
{
(VOID)wakeCount;
return OsPmSuspendSleep(&g_pmCB);
}
STATIC VOID OsPmSleepTimeSet(UINT64 sleepTime)
{
g_pmSleepTime = sleepTime;
}
BOOL OsIsPmMode(VOID)
{
LosPmCB *pm = &g_pmCB;
UINT32 intSave = LOS_IntLock();
if ((pm->sysMode != LOS_SYS_NORMAL_SLEEP) && (pm->lock == 0)) {
LOS_IntRestore(intSave);
return TRUE;
}
LOS_IntRestore(intSave);
return FALSE;
}
UINT32 OsPmInit(VOID)
{
UINT32 ret;
@ -626,16 +776,15 @@ UINT32 OsPmInit(VOID)
(VOID)memset_s(pm, sizeof(LosPmCB), 0, sizeof(LosPmCB));
pm->pmMode = LOS_SYS_NORMAL_SLEEP;
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
LOS_ListInit(&pm->lockList);
#endif
(VOID)LOS_EventInit(&g_pmEvent);
ret = OsSchedRealSleepTimeSet(OsPmSleepTimeSet);
if (ret != LOS_OK) {
return ret;
}
ret = OsPmEnterHandlerSet(OsPmEnter);
ret = OsPmEnterHandlerSet(OsPmNormalSleep);
if (ret != LOS_OK) {
return ret;
}

158
components/power/los_pm.h
View File

@ -118,6 +118,15 @@
*/
#define LOS_ERRNO_PM_DEVICE_NULL LOS_ERRNO_OS_ERROR(LOS_MOD_PM, 0x09)
/**
* @ingroup los_pm
* Pm error code: The delay lock has already been activated.
*
* Value: 0x0200200a
*
*/
#define LOS_ERRNO_PM_ALREADY_LOCK LOS_ERRNO_OS_ERROR(LOS_MOD_PM, 0x0a)
typedef enum {
LOS_SYS_NORMAL_SLEEP = 0,
LOS_SYS_LIGHT_SLEEP,
@ -132,8 +141,8 @@ typedef enum {
} LOS_PmNodeType;
typedef struct {
UINT32 (*suspend)(UINT32 mode);
VOID (*resume)(UINT32 mode);
UINT32 (*suspend)(UINT32 mode); /* The device enters low power consumption, Unlocked task scheduling. */
VOID (*resume)(UINT32 mode); /* The device exits from low power consumption, Unlocked task scheduling. */
} LosPmDevice;
typedef struct {
@ -146,13 +155,47 @@ typedef struct {
} LosPmTickTimer;
typedef struct {
/* Preparations before the CPU enters low power consumption.
* All modes except normal mode are invoked.
* Unlocked task scheduling.
*/
UINT32 (*early)(UINT32 mode);
/* The system performs low-power recovery.
* All modes except normal mode are invoked.
* Unlocked task scheduling.
*/
VOID (*late)(UINT32 mode);
/* The system enters the Normal sleep mode.
* In normal mode, the value cannot be NULL.
*/
UINT32 (*normalSuspend)(VOID);
/* The system recovers from normal sleep.
* The value can be NULL.
*/
VOID (*normalResume)(VOID);
/* The system enters the light sleep mode.
* In light sleep mode, the value cannot be NULL.
*/
UINT32 (*lightSuspend)(VOID);
/* The system recovers from light sleep.
* The value can be NULL.
*/
VOID (*lightResume)(VOID);
/* The system enters the deep sleep mode.
* In deep sleep mode, the value cannot be NULL.
*/
UINT32 (*deepSuspend)(VOID);
/* The system recovers from deep sleep.
* The value can be NULL.
*/
VOID (*deepResume)(VOID);
/* The system enters the shutdown mode.
* In shutdown mode, the value cannot be NULL.
*/
UINT32 (*shutdownSuspend)(VOID);
/* The system recovers from shutdown.
* In shutdown mode, the value cannot be NULL.
*/
VOID (*shutdownResume)(VOID);
} LosPmSysctrl;
@ -174,6 +217,60 @@ typedef struct {
*/
UINT32 OsPmInit(VOID);
/**
* @ingroup los_pm
* @brief Whether the low power consumption condition is met.
*
* @par Description:
* This API is used to check whether low power consumption is met.
*
* @attention None.
*
* @param None.
*
* @retval TRUE or FALSE.
* @par Dependency:
* <ul><li>los_pm.h: the header file that contains the API declaration.</li></ul>
* @see
*/
BOOL OsIsPmMode(VOID);
/**
* @ingroup los_pm
* @brief Freeze delay tasks, internal interfaces between modules.
*
* @par Description:
* This API is used to freeze delay tasks.
*
* @attention None.
*
* @param taskID [IN] task ID.
*
* @retval None.
* @par Dependency:
* <ul><li>los_pm.h: the header file that contains the API declaration.</li></ul>
* @see OsPmUnfreezeTaskUnsafe
*/
VOID OsPmFreezeTaskUnsafe(UINT32 taskID);
/**
* @ingroup los_pm
* @brief Unfreeze delayed tasks, internal interface between modules.
*
* @par Description:
* This API is used to unfreeze delayed tasks.
*
* @attention None.
*
* @param taskID [IN] task ID.
*
* @retval None.
* @par Dependency:
* <ul><li>los_pm.h: the header file that contains the API declaration.</li></ul>
* @see OsPmFreezeTaskUnsafe
*/
VOID OsPmUnfreezeTaskUnsafe(UINT32 taskID);
/**
* @ingroup los_pm
* @brief Register a power management node.
@ -285,6 +382,27 @@ UINT32 LOS_PmModeSet(LOS_SysSleepEnum mode);
*/
UINT32 LOS_PmLockRequest(const CHAR *name);
/**
* @ingroup los_pm
* @brief Request to obtain the lock in current mode, so that the system will not enter
* this mode when it enters the idle task next time. After the specified interval, the
* lock is automatically released.
*
* @par Description:
* This API is used to obtain the delay lock in current mode.
*
* @attention None.
*
* @param name [IN] Who requests the lock.
* @param millisecond [IN] Specifies the time to automatically release the lock.
*
* @retval error code, LOS_OK means success.
* @par Dependency:
* <ul><li>los_pm.h: the header file that contains the API declaration.</li></ul>
* @see LOS_PmLockRelease
*/
UINT32 LOS_PmTimeLockRequest(const CHAR *name, UINT64 millisecond);
/**
* @ingroup los_pm
* @brief Release the lock in current mode so that the next time the system enters
@ -304,6 +422,42 @@ UINT32 LOS_PmLockRequest(const CHAR *name);
*/
UINT32 LOS_PmLockRelease(const CHAR *name);
/**
* @ingroup los_pm
* @brief Gets the current PM lock status.
*
* @par Description:
* This API is used to Get the current PM lock status.
*
* @attention None.
*
* @param NA.
*
* @retval Number of awakening sources of the device.
* @par Dependency:
* <ul><li>los_pm.h: the header file that contains the API declaration.</li></ul>
* @see
*/
UINT32 LOS_PmReadLock(VOID);
/**
* @ingroup los_pm
* @brief The system enters the low-power flow.
*
* @par Description:
* This API is used to enter the system into a low-power process.
*
* @attention None.
*
* @param wakeCount [IN] Number of wake sources.
*
* @retval error code, LOS_OK means success.
* @par Dependency:
* <ul><li>los_pm.h: the header file that contains the API declaration.</li></ul>
* @see
*/
UINT32 LOS_PmSuspend(UINT32 wakeCount);
#if (LOSCFG_KERNEL_PM_DEBUG == 1)
/**
* @ingroup los_pm

2
kernel/include/los_sched.h
View File

@ -61,6 +61,8 @@ VOID OsSchedSetIdleTaskSchedParam(LosTaskCB *idleTask);
UINT32 OsSchedSwtmrScanRegister(SchedScan func);
VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime, BOOL timeUpdate);
VOID OsSchedUpdateExpireTime(UINT64 startTime, BOOL timeUpdate);
VOID OsSchedTaskDeQueue(LosTaskCB *taskCB);

8
kernel/include/los_task.h
View File

@ -1175,6 +1175,14 @@ extern VOID LOS_UDelay(UINT64 microseconds);
*/
#define OS_TASK_STATUS_PEND_TIME 0x0080
/**
* @ingroup los_task
* Flag that indicates the task or task control block status.
*
* The delayed operation of this task is frozen.
*/
#define OS_TASK_FALG_FREEZE 0x4000
/**
* @ingroup los_task
* Flag that indicates the task is in userspace.

4
kernel/src/los_sched.c
View File

@ -179,7 +179,7 @@ STATIC INLINE VOID OsSchedTickReload(UINT64 nextResponseTime, UINT32 responseID,
HalSysTickReload(nextResponseTime);
}
STATIC INLINE VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime, BOOL timeUpdate)
VOID OsSchedSetNextExpireTime(UINT64 startTime, UINT32 responseID, UINT64 taskEndTime, BOOL timeUpdate)
{
UINT64 nextExpireTime;
UINT64 nextResponseTime = 0;
@ -415,7 +415,7 @@ BOOL OsSchedModifyTaskSchedParam(LosTaskCB *taskCB, UINT16 priority)
}
taskCB->priority = priority;
OsHookCall(LOS_HOOK_TYPE_TASK_PRIMODIFY, taskCB, taskCB->priority);
OsHookCall(LOS_HOOK_TYPE_TASK_PRIMODIFY, taskCB, taskCB->priority);
if (taskCB->taskStatus & OS_TASK_STATUS_RUNNING) {
return TRUE;
}

16
kernel/src/los_task.c
View File

@ -44,6 +44,9 @@
#if (LOSCFG_BASE_CORE_CPUP == 1)
#include "los_cpup.h"
#endif
#if (LOSCFG_KERNEL_PM == 1)
#include "los_pm.h"
#endif
/**
* @ingroup los_task
@ -403,7 +406,6 @@ LITE_OS_SEC_TEXT_INIT UINT32 OsIdleTaskCreate(VOID)
taskInitParam.pcName = "IdleCore000";
taskInitParam.usTaskPrio = OS_TASK_PRIORITY_LOWEST;
retVal = LOS_TaskCreateOnly(&g_idleTaskID, &taskInitParam);
if (retVal != LOS_OK) {
return retVal;
}
@ -803,6 +805,12 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskResume(UINT32 taskID)
OS_GOTO_ERREND();
}
#if (LOSCFG_KERNEL_PM == 1)
if (tempStatus & OS_TASK_FALG_FREEZE) {
OsPmUnfreezeTaskUnsafe(taskID);
}
#endif
taskCB->taskStatus &= (~OS_TASK_STATUS_SUSPEND);
if (!(taskCB->taskStatus & OS_CHECK_TASK_BLOCK)) {
OsSchedTaskEnQueue(taskCB);
@ -862,6 +870,12 @@ LITE_OS_SEC_TEXT_INIT UINT32 LOS_TaskSuspend(UINT32 taskID)
OsSchedTaskDeQueue(taskCB);
}
#if (LOSCFG_KERNEL_PM == 1)
if ((tempStatus & (OS_TASK_STATUS_PEND_TIME | OS_TASK_STATUS_DELAY)) && OsIsPmMode()) {
OsPmFreezeTaskUnsafe(taskID);
}
#endif
taskCB->taskStatus |= OS_TASK_STATUS_SUSPEND;
OsHookCall(LOS_HOOK_TYPE_MOVEDTASKTOSUSPENDEDLIST, taskCB);
if (taskID == g_losTask.runTask->taskID) {

1
testsuits/sample/kernel/power/BUILD.gn
View File

@ -31,6 +31,7 @@ static_library("test_pm") {
"It_los_pm.c",
"It_los_pm_001.c",
"It_los_pm_002.c",
"It_los_pm_003.c",
]
include_dirs = [ "//kernel/liteos_m/components/power" ]

3
testsuits/sample/kernel/power/It_los_pm.c
View File

@ -31,9 +31,10 @@
#include "osTest.h"
#include "It_los_pm.h"
VOID ItSuiteLosPm()
VOID ItSuiteLosPm(VOID)
{
ItLosPm001();
ItLosPm002();
ItLosPm003();
}

1
testsuits/sample/kernel/power/It_los_pm.h
View File

@ -55,6 +55,7 @@ extern "C" {
extern VOID ItLosPm001(VOID);
extern VOID ItLosPm002(VOID);
extern VOID ItLosPm003(VOID);
#ifdef __cplusplus
#if __cplusplus

20
testsuits/sample/kernel/power/It_los_pm_001.c
View File

@ -50,16 +50,21 @@ static VOID SysResume(VOID)
{
}
static UINT32 SysSuspend(VOID)
{
return HalEnterSleep();
}
static LosPmSysctrl g_sysctrl = {
.normalSuspend = NULL,
.normalResume = SysResume,
};
static VOID TimerStart(UINT64 timer)
{
}
static UINT64 GetTimerCycle(VOID)
{
return 0;
}
static VOID TickLock(VOID)
{
return;
@ -128,7 +133,7 @@ static UINT32 TestCase(VOID)
g_tickTimer.tickLock = TickLock;
g_tickTimer.tickUnlock = TickUnlock;
g_tickTimer.timerStart = TickLock;
g_tickTimer.timerStart = TimerStart;
ret = LOS_PmRegister(LOS_PM_TYPE_TICK_TIMER, &g_tickTimer);
ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_PM_INVALID_PARAM, ret);
@ -136,7 +141,7 @@ static UINT32 TestCase(VOID)
ret = LOS_PmRegister(LOS_PM_TYPE_TICK_TIMER, &g_tickTimer);
ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_PM_INVALID_PARAM, ret);
g_tickTimer.timerCycleGet = TickLock;
g_tickTimer.timerCycleGet = GetTimerCycle;
ret = LOS_PmRegister(LOS_PM_TYPE_TICK_TIMER, &g_tickTimer);
ICUNIT_ASSERT_EQUAL(ret, LOS_ERRNO_PM_INVALID_PARAM, ret);
@ -159,4 +164,3 @@ VOID ItLosPm001(VOID) // IT_Layer_ModuleORFeature_No
{
TEST_ADD_CASE("ItLosPm001", TestCase, TEST_LOS, TEST_TASK, TEST_LEVEL0, TEST_FUNCTION);
}

196
testsuits/sample/kernel/power/It_los_pm_002.c
View File

@ -32,9 +32,14 @@
#include "It_los_pm.h"
#include "los_timer.h"
#define myprintf // printf
#define TEST_LOOP 5
static EVENT_CB_S g_pmTestEvent;
static UINT32 g_taskID1, g_taskID2;
static UINT32 g_deviceCount = 0;
static UINT32 g_sysCount = 0;
static UINT32 g_sysTickTimerCount = 0;
static volatile UINT32 g_pmTestCount = 0;
static UINT32 DeviceSuspend(UINT32 mode)
{
g_deviceCount++;
@ -53,26 +58,6 @@ static LosPmDevice g_device = {
.resume = DeviceResume,
};
static VOID TickLock(VOID)
{
g_testCount++;
g_sysTickTimerCount++;
}
static VOID TickUnlock(VOID)
{
g_sysTickTimerCount--;
}
static LosPmTickTimer g_tickTimer = {
.tickLock = TickLock,
.tickUnlock = TickUnlock,
.timerStart = NULL,
.timerStop = NULL,
.timerCycleGet = NULL,
.freq = 0,
};
static VOID SysResume(VOID)
{
if (g_sysCount != (UINT32)-1) {
@ -85,29 +70,154 @@ static UINT32 SysSuspend(VOID)
g_testCount++;
g_sysCount++;
if ((g_sysTickTimerCount != 1) || (g_deviceCount != 1) || (g_sysCount != 1)) {
if ((g_deviceCount != 1) || (g_sysCount != 1)) { /* 1: sys count */
g_sysCount = (UINT32)-1;
}
UINT64 timeout = LOS_SchedTickTimeoutNsGet();
printf("pm timeout : %u ns -> %u ticks\n", (UINT32)timeout, (UINT32)(timeout / OS_NS_PER_TICK));
return HalEnterSleep();
}
static UINT32 SystemPmEarly(UINT32 mode)
{
UINT32 ret;
ret = LOS_TaskSuspend(g_taskID2);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_TaskSuspend(g_taskID1);
if (ret != LOS_OK) {
(VOID)LOS_TaskResume(g_taskID2);
}
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
return LOS_OK;
}
static VOID SystemPmLate(UINT32 mode)
{
UINT32 ret;
LosTaskCB *taskCB = NULL;
ICUNIT_ASSERT_EQUAL_VOID(mode, LOS_SYS_LIGHT_SLEEP, mode);
ret = LOS_TaskResume(g_taskID2);
ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
ret = LOS_TaskResume(g_taskID1);
ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
}
static LosPmSysctrl g_sysctrl = {
.early = SystemPmEarly,
.late = SystemPmLate,
.normalSuspend = HalEnterSleep,
.normalResume = NULL,
.lightSuspend = SysSuspend,
.lightResume = SysResume,
};
#define TEST_FLAGS 100
static VOID PmTestTask(VOID)
{
UINT32 ret;
UINT32 wakeCount;
while (1) {
wakeCount = LOS_PmReadLock();
ret = LOS_PmSuspend(wakeCount);
ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
ICUNIT_GOTO_NOT_EQUAL(g_testCount, 0, g_sysCount, EXIT);
ICUNIT_GOTO_EQUAL(g_sysCount, 0, g_sysCount, EXIT);
g_pmTestCount++;
if (g_pmTestCount > TEST_LOOP) {
break;
}
printf("PmTestTask loop: %u\n", g_pmTestCount);
}
EXIT:
g_pmTestCount = TEST_FLAGS;
(VOID)LOS_EventWrite(&g_pmTestEvent, 0x1); /* 0x1: test exit evnet */
return;
}
#define TEST_TASK1_LOOP 10
static volatile UINT32 g_testSample1Count, g_testSample2Count;
static void TaskSampleEntry2(void)
{
UINT32 g_testSample2Count = TEST_FLAGS;
while (1) {
if (g_testSample2Count == TEST_FLAGS) {
g_testSample2Count = 0;
LOS_PmLockRequest("TaskSampleEntry2");
myprintf("%s request pm lock\n", __FUNCTION__);
}
myprintf("TaskSampleEntry2 running...count: %u\n\r", g_testSample2Count);
LOS_TaskDelay(20); /* sleep 20 ticks */
if (g_testSample2Count <= TEST_TASK1_LOOP) { /* */
g_testSample2Count++;
}
if (g_testSample2Count == TEST_TASK1_LOOP) {
LOS_PmLockRelease("TaskSampleEntry2");
myprintf("%s release pm lock\n", __FUNCTION__);
}
if (g_pmTestCount > TEST_LOOP) {
break;
}
}
LOS_PmLockRelease("TaskSampleEntry2");
myprintf("TaskSampleEntry2 exit\n");
}
static void TaskSampleEntry1(void)
{
UINT32 g_testSample1Count = 0;
while (1) {
if (g_testSample1Count == 0) {
LOS_PmLockRequest("TaskSampleEntry1");
myprintf("%s request pm lock\n", __FUNCTION__);
}
myprintf("TaskSampleEntry1 running...%u\n\r", g_testSample1Count);
LOS_TaskDelay(50); /* sleep 50 ticks */
g_testSample1Count++;
if (g_testSample1Count == TEST_TASK1_LOOP) {
LOS_PmLockRelease("TaskSampleEntry1");
myprintf("%s release pm lock\n", __FUNCTION__);
} else if (g_testSample1Count == (TEST_TASK1_LOOP + 1)) { /* 1: incremental */
g_testSample1Count = 0;
g_testSample2Count = TEST_FLAGS;
}
if (g_pmTestCount > TEST_LOOP) {
break;
}
}
LOS_PmLockRelease("TaskSampleEntry1");
myprintf("TaskSampleEntry1 exit\n");
}
static UINT32 TestCase(VOID)
{
UINT32 ret;
TSK_INIT_PARAM_S task1 = { 0 };
g_sysCount = 0;
g_deviceCount = 0;
g_sysTickTimerCount = 0;
g_testCount = 0;
ret = LOS_PmRegister(LOS_PM_TYPE_TICK_TIMER, &g_tickTimer);
ret = LOS_EventInit(&g_pmTestEvent);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_PmRegister(LOS_PM_TYPE_DEVICE, &g_device);
@ -119,34 +229,42 @@ static UINT32 TestCase(VOID)
ret = LOS_PmModeSet(LOS_SYS_LIGHT_SLEEP);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
LOS_PmLockRequest("testlock");
LOS_TaskDelay(100); /* delay 100 ticks */
LOS_PmLockRelease("testlock");
task1.pfnTaskEntry = (TSK_ENTRY_FUNC)PmTestTask;
task1.uwStackSize = 0x2000; /* 0x2000 pm task stack size */
task1.pcName = "pmTask";
task1.usTaskPrio = 5; /* 5: pm task prio */
ret = LOS_TaskCreate(&g_testTaskID01, &task1);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ICUNIT_GOTO_EQUAL(g_testCount, 0, g_testCount, EXIT);
task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskSampleEntry1;
task1.uwStackSize = 0x1000; /* 0x1000 task stack size */
task1.pcName = "TaskSampleEntry1";
task1.usTaskPrio = 10; /* 10: task prio */
ret = LOS_TaskCreate(&g_taskID1, &task1);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
LOS_TaskDelay(100); /* delay 100 ticks */
task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskSampleEntry2;
task1.uwStackSize = 0x1000; /* 0x1000 task stack size */
task1.pcName = "TaskSampleEntry2";
task1.usTaskPrio = 12; /* 12: task prio */
ret = LOS_TaskCreate(&g_taskID2, &task1);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ICUNIT_GOTO_NOT_EQUAL(g_testCount, 0, g_sysCount, EXIT);
ICUNIT_GOTO_EQUAL(g_sysCount, 0, g_sysCount, EXIT);
(VOID)LOS_EventRead(&g_pmTestEvent, 0xff, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
ret = LOS_PmUnregister(LOS_PM_TYPE_DEVICE, &g_device);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_PmUnregister(LOS_PM_TYPE_TICK_TIMER, &g_tickTimer);
ret = LOS_PmModeSet(LOS_SYS_NORMAL_SLEEP);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
(VOID)LOS_TaskDelete(g_taskID1);
(VOID)LOS_TaskDelete(g_taskID2);
(VOID)LOS_TaskDelete(g_testTaskID01);
return LOS_OK;
EXIT:
LOS_PmUnregister(LOS_PM_TYPE_DEVICE, &g_device);
LOS_PmUnregister(LOS_PM_TYPE_TICK_TIMER, &g_tickTimer);
return LOS_NOK;
}
VOID ItLosPm002(VOID) // IT_Layer_ModuleORFeature_No
{
TEST_ADD_CASE("ItLosPm002", TestCase, TEST_LOS, TEST_TASK, TEST_LEVEL0, TEST_FUNCTION);
}

242
testsuits/sample/kernel/power/It_los_pm_003.c Normal file
View File

@ -0,0 +1,242 @@
/*
* Copyright (c) 2021-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 "osTest.h"
#include "It_los_pm.h"
#include "los_timer.h"
#define TEST_LOOP 5
static EVENT_CB_S g_pmTestEvent;
static UINT32 g_taskID1, g_taskID2;
static UINT32 g_deviceCount = 0;
static UINT32 g_sysCount = 0;
static volatile UINT32 g_pmTestCount = 0;
static UINT32 g_pmTimeLock = 0;
static UINT32 DeviceSuspend(UINT32 mode)
{
g_deviceCount++;
g_testCount++;
return LOS_OK;
}
static VOID DeviceResume(UINT32 mode)
{
g_deviceCount--;
return;
}
static LosPmDevice g_device = {
.suspend = DeviceSuspend,
.resume = DeviceResume,
};
static VOID SysResume(VOID)
{
if (g_sysCount != (UINT32)-1) {
g_sysCount--;
}
}
static UINT32 SysSuspend(VOID)
{
g_testCount++;
g_sysCount++;
if ((g_deviceCount != 1) || (g_sysCount != 1)) { /* 2: device count 1: sys count */
g_sysCount = (UINT32)-1;
}
UINT64 timeout = LOS_SchedTickTimeoutNsGet();
printf("pm timeout : %u ns -> %u ticks\n", (UINT32)timeout, (UINT32)(timeout / OS_NS_PER_TICK));
return HalEnterSleep();
}
static UINT32 SystemPmEarly(UINT32 mode)
{
UINT32 ret;
ICUNIT_ASSERT_EQUAL(mode, LOS_SYS_LIGHT_SLEEP, mode);
ret = LOS_TaskSuspend(g_taskID2);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_TaskSuspend(g_taskID1);
if (ret != LOS_OK) {
(VOID)LOS_TaskResume(g_taskID2);
}
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
return LOS_OK;
}
static VOID SystemPmLate(UINT32 mode)
{
UINT32 ret;
ICUNIT_ASSERT_EQUAL_VOID(mode, LOS_SYS_LIGHT_SLEEP, mode);
ret = LOS_TaskResume(g_taskID2);
ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
ret = LOS_TaskResume(g_taskID1);
ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
}
static LosPmSysctrl g_sysctrl = {
.early = SystemPmEarly,
.late = SystemPmLate,
.normalSuspend = HalEnterSleep,
.normalResume = NULL,
.lightSuspend = SysSuspend,
.lightResume = SysResume,
};
#define TEST_FLAGS 100
static VOID PmTestTask(VOID)
{
UINT32 ret;
UINT32 wakeCount;
while (1) {
wakeCount = LOS_PmReadLock();
ret = LOS_PmSuspend(wakeCount);
ICUNIT_GOTO_EQUAL(ret, LOS_OK, ret, EXIT);
ICUNIT_GOTO_NOT_EQUAL(g_testCount, 0, g_sysCount, EXIT);
ICUNIT_GOTO_EQUAL(g_sysCount, 0, g_sysCount, EXIT);
g_pmTimeLock = 0;
g_pmTestCount++;
if (g_pmTestCount > TEST_LOOP) {
break;
}
printf("PmTestTask loop: %u\n", g_pmTestCount);
}
EXIT:
g_pmTestCount = TEST_FLAGS;
(VOID)LOS_EventWrite(&g_pmTestEvent, 0x1); /* 0x1: test exit evnet */
return;
}
static void TaskSampleEntry2(void)
{
while (1) {
LOS_TaskDelay(20); /* sleep 20 ticks */
if (g_pmTestCount > TEST_LOOP) {
break;
}
}
}
static void TaskSampleEntry1(void)
{
UINT32 ret;
while (1) {
if (g_pmTimeLock == 0) {
g_pmTimeLock = TEST_FLAGS;
ret = LOS_PmTimeLockRequest("TaskSampleEntry1", 1000); /* delay 1000 ms */
ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_OK, ret);
ret = LOS_PmTimeLockRequest("TaskSampleEntry1", 1000); /* delay 1000 ms */
ICUNIT_ASSERT_EQUAL_VOID(ret, LOS_ERRNO_PM_ALREADY_LOCK, ret);
}
LOS_TaskDelay(50); /* sleep 50 ticks */
if (g_pmTestCount > TEST_LOOP) {
break;
}
}
return;
}
static UINT32 TestCase(VOID)
{
UINT32 ret;
TSK_INIT_PARAM_S task1 = { 0 };
g_sysCount = 0;
g_deviceCount = 0;
g_testCount = 0;
ret = LOS_EventInit(&g_pmTestEvent);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_PmRegister(LOS_PM_TYPE_DEVICE, &g_device);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_PmRegister(LOS_PM_TYPE_SYSCTRL, &g_sysctrl);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_PmModeSet(LOS_SYS_LIGHT_SLEEP);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
task1.pfnTaskEntry = (TSK_ENTRY_FUNC)PmTestTask;
task1.uwStackSize = 0x2000; /* 0x2000 pm task stack size */
task1.pcName = "pmTask";
task1.usTaskPrio = 5; /* 5: pm task prio */
ret = LOS_TaskCreate(&g_testTaskID01, &task1);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskSampleEntry1;
task1.uwStackSize = 0x1000; /* 0x1000 task stack size */
task1.pcName = "TaskSampleEntry1";
task1.usTaskPrio = 10; /* 10: task prio */
ret = LOS_TaskCreate(&g_taskID1, &task1);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
task1.pfnTaskEntry = (TSK_ENTRY_FUNC)TaskSampleEntry2;
task1.uwStackSize = 0x1000; /* 0x1000 task stack size */
task1.pcName = "TaskSampleEntry2";
task1.usTaskPrio = 12; /* 12: task prio */
ret = LOS_TaskCreate(&g_taskID2, &task1);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
(VOID)LOS_EventRead(&g_pmTestEvent, 0xff, LOS_WAITMODE_OR | LOS_WAITMODE_CLR, LOS_WAIT_FOREVER);
ret = LOS_PmUnregister(LOS_PM_TYPE_DEVICE, &g_device);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
ret = LOS_PmModeSet(LOS_SYS_NORMAL_SLEEP);
ICUNIT_ASSERT_EQUAL(ret, LOS_OK, ret);
(VOID)LOS_TaskDelete(g_taskID1);
(VOID)LOS_TaskDelete(g_taskID2);
(VOID)LOS_TaskDelete(g_testTaskID01);
return LOS_OK;
}
VOID ItLosPm003(VOID) // IT_Layer_ModuleORFeature_No
{
TEST_ADD_CASE("ItLosPm003", TestCase, TEST_LOS, TEST_TASK, TEST_LEVEL0, TEST_FUNCTION);
}