Initial commit: TXW82x FPV v2.7.0.7-42229 SDK + project sources
This commit is contained in:
454
sdk/osal/ohos/task.c
Normal file
454
sdk/osal/ohos/task.c
Normal file
@@ -0,0 +1,454 @@
|
||||
#include "typesdef.h"
|
||||
#include "errno.h"
|
||||
#include "list.h"
|
||||
#include "osal/event.h"
|
||||
|
||||
#ifdef OHOS
|
||||
#include "los_event.h"
|
||||
#include "los_membox.h"
|
||||
#include "los_memory.h"
|
||||
#include "los_interrupt.h"
|
||||
#include "los_mux.h"
|
||||
#include "los_queue.h"
|
||||
#include "los_sem.h"
|
||||
#include "los_swtmr.h"
|
||||
#include "los_task.h"
|
||||
#include "los_timer.h"
|
||||
#include "los_debug.h"
|
||||
#if (LOSCFG_MUTEX_CREATE_TRACE == 1)
|
||||
#include "los_arch.h"
|
||||
#endif
|
||||
#include "osal/string.h"
|
||||
#include "osal/task.h"
|
||||
#include "los_cpup.h"
|
||||
|
||||
static void os_task_entry(void *args)
|
||||
{
|
||||
os_task_t *task = (os_task_t *)args;
|
||||
task->func((void *)task->args);
|
||||
}
|
||||
|
||||
int32 os_task_init(const uint8 *name, os_task_t *task, os_task_func_t func, uint32 data)
|
||||
{
|
||||
//ASSERT(task);
|
||||
os_memset(task, 0, sizeof(os_task_t));
|
||||
task->args = data;
|
||||
task->func = func;
|
||||
task->name = (const char *)name;
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
int32 os_task_priority(os_task_t *task)
|
||||
{
|
||||
//ASSERT(task);
|
||||
return task->priority;
|
||||
}
|
||||
int32 os_task_priority2(void *hdl)
|
||||
{
|
||||
UINT32 tsk_hdl = (UINT32)hdl;
|
||||
if(tsk_hdl > 0){
|
||||
return LOS_TaskPriGet(tsk_hdl - 1);
|
||||
}else{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int32 os_task_stacksize(os_task_t *task)
|
||||
{
|
||||
//ASSERT(task);
|
||||
return task->stack_size;
|
||||
}
|
||||
int32 os_task_stacksize2(void *hdl)
|
||||
{
|
||||
UINT32 tsk_hdl = (UINT32)hdl;
|
||||
if(tsk_hdl > 0){
|
||||
LosTaskCB *taskCB = OS_TCB_FROM_TID(tsk_hdl - 1);
|
||||
return taskCB->stackSize;
|
||||
}else{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int32 _os_task_set_priority(os_task_t *task, uint32 prio)
|
||||
{
|
||||
int32 pri = 12;
|
||||
uint8 priority = prio&0xff;
|
||||
|
||||
//ASSERT(task);
|
||||
//ASSERT(!task->hdl);
|
||||
if (priority < OS_TASK_PRIORITY_LOW) {
|
||||
pri = 31;
|
||||
} else if (priority < OS_TASK_PRIORITY_BELOW_NORMAL) {
|
||||
pri = 24 + (priority - OS_TASK_PRIORITY_LOW);
|
||||
if (pri > 30) { pri = 30; }
|
||||
} else if (priority >= OS_TASK_PRIORITY_BELOW_NORMAL && priority < OS_TASK_PRIORITY_NORMAL) {
|
||||
pri = 18 + (priority - OS_TASK_PRIORITY_BELOW_NORMAL);
|
||||
if (pri > 24) { pri = 24; }
|
||||
} else if (priority >= OS_TASK_PRIORITY_NORMAL && priority < OS_TASK_PRIORITY_ABOVE_NORMAL) {
|
||||
pri = 12 + (priority - OS_TASK_PRIORITY_NORMAL);
|
||||
if (pri > 18) { pri = 18; }
|
||||
} else if (priority >= OS_TASK_PRIORITY_ABOVE_NORMAL && priority < OS_TASK_PRIORITY_HIGH) {
|
||||
pri = 6 + (priority - OS_TASK_PRIORITY_ABOVE_NORMAL);
|
||||
if (pri > 12) { pri = 12; }
|
||||
} else if (priority >= OS_TASK_PRIORITY_HIGH && priority < OS_TASK_PRIORITY_REALTIME) {
|
||||
pri = 2 + (priority - OS_TASK_PRIORITY_HIGH);
|
||||
if (pri > 6) { pri = 6; }
|
||||
} else if (priority >= OS_TASK_PRIORITY_REALTIME && priority < OS_TASK_PRIORITY_ISR) {
|
||||
pri = 1;
|
||||
} else {
|
||||
pri = 0;
|
||||
}
|
||||
|
||||
if (task) {
|
||||
task->priority = pri;
|
||||
task->lprun = (prio & OS_TASK_FLAGS_LPRUN) ? 1 : 0;
|
||||
if (task->hdl) {
|
||||
LOS_TaskPriSet((UINT32)task->hdl - 1, task->priority);
|
||||
LOS_Task_LpowerRun((UINT32)task->hdl - 1, task->lprun);
|
||||
}
|
||||
}
|
||||
return pri;
|
||||
}
|
||||
|
||||
int32 os_task_set_priority(os_task_t *task, uint32 pri)
|
||||
{
|
||||
uint8 priority = pri & 0xff;
|
||||
if (priority >= OS_TASK_PRIORITY_HIGH) {
|
||||
priority = OS_TASK_PRIORITY_HIGH - 1;
|
||||
pri &= 0xffffff00;
|
||||
pri |= priority;
|
||||
os_printf("INVALID PRIORITY\r\n");
|
||||
}
|
||||
return _os_task_set_priority(task, pri);
|
||||
}
|
||||
|
||||
int32 os_task_set_stack(os_task_t *task, void *stack, int32 stack_size)
|
||||
{
|
||||
//ASSERT(task);
|
||||
//ASSERT(!task->hdl);
|
||||
task->stack = stack;
|
||||
task->stack_size = stack_size;
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
int32 os_task_run(os_task_t *task)
|
||||
{
|
||||
UINT32 hdl = 0;
|
||||
TSK_INIT_PARAM_S stTskInitParam;
|
||||
os_memset(&stTskInitParam, 0, sizeof(stTskInitParam));
|
||||
stTskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)os_task_entry;
|
||||
stTskInitParam.uwArg = (UINT32)task;
|
||||
stTskInitParam.uwStackSize = task->stack_size;
|
||||
stTskInitParam.pcName = (char *)task->name;
|
||||
stTskInitParam.uwResved = LOS_TASK_ATTR_JOINABLE;
|
||||
stTskInitParam.usTaskPrio = task->priority;
|
||||
if (LOS_OK == LOS_TaskCreate(&hdl, &stTskInitParam)) {
|
||||
LOS_Task_LpowerRun(hdl, task->lprun);
|
||||
task->hdl = (void *)(hdl + 1);
|
||||
return RET_OK;
|
||||
}
|
||||
return RET_ERR;
|
||||
}
|
||||
|
||||
int32 os_task_stop(os_task_t *task)
|
||||
{
|
||||
//ASSERT(0);
|
||||
return RET_OK;
|
||||
}
|
||||
|
||||
int32 os_task_del(os_task_t *task)
|
||||
{
|
||||
UINT32 hdl = (UINT32)task->hdl;
|
||||
task->hdl = NULL;
|
||||
if(hdl > 0){
|
||||
return LOS_TaskDelete(hdl - 1);
|
||||
}else{
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
int32 os_task_runtime(struct os_task_info *tsk_times, int32 count)
|
||||
{
|
||||
#if (LOSCFG_BASE_CORE_CPUP == 1)
|
||||
int32 i = 0;
|
||||
int32 j = 0;
|
||||
LosTaskCB *taskCB;
|
||||
CPUP_INFO_S info[LOSCFG_BASE_CORE_TSK_LIMIT + 1];
|
||||
os_memset(info, 0, sizeof(info));
|
||||
LOS_AllTaskCpuUsage(info, CPUP_IN_10S);
|
||||
for (i = 0; i < count && i < LOSCFG_BASE_CORE_TSK_LIMIT + 1; i++) {
|
||||
if (info[i].usStatus && i != g_idleTaskID) {
|
||||
taskCB = OS_TCB_FROM_TID(i);
|
||||
tsk_times[j].id = i;
|
||||
tsk_times[j].name = (const char *)taskCB->taskName;
|
||||
tsk_times[j].prio = taskCB->priority;
|
||||
tsk_times[j].arg = i+1;
|
||||
tsk_times[j].stack = taskCB->stackSize / 4;
|
||||
tsk_times[j].time = info[i].uwUsage / LOS_CPUP_PRECISION_MULT;
|
||||
tsk_times[j].status = (const char *)OsConvertTskStatus(g_taskCBArray[i].taskStatus);
|
||||
j++;
|
||||
}
|
||||
}
|
||||
return j;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
void os_task_print(void)
|
||||
{
|
||||
#if (LOSCFG_BASE_CORE_CPUP == 1)
|
||||
int32 i = 0;
|
||||
LosTaskCB *taskCB;
|
||||
CPUP_INFO_S info[LOSCFG_BASE_CORE_TSK_LIMIT + 1];
|
||||
os_memset(info, 0, sizeof(info));
|
||||
LOS_AllTaskCpuUsage(info, CPUP_IN_10S);
|
||||
for (i = 0; i < LOSCFG_BASE_CORE_TSK_LIMIT + 1; i++) {
|
||||
if (info[i].usStatus) {
|
||||
taskCB = OS_TCB_FROM_TID(i);
|
||||
printf("\0011Task %s %s ticks:%d stack:%d prio:%d, arg:0x%x\r\n", taskCB->taskName,
|
||||
(const char *)OsConvertTskStatus(info[i].usStatus),
|
||||
info[i].uwUsage / LOS_CPUP_PRECISION_MULT,
|
||||
taskCB->stackSize / 4, taskCB->priority, taskCB->arg);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
int32 os_task_count(void)
|
||||
{
|
||||
#if (LOSCFG_BASE_CORE_CPUP == 1)
|
||||
int32 i = 0;
|
||||
int32 j = 0;
|
||||
CPUP_INFO_S info[LOSCFG_BASE_CORE_TSK_LIMIT + 1];
|
||||
os_memset(info, 0, sizeof(info));
|
||||
LOS_AllTaskCpuUsage(info, CPUP_IN_10S);
|
||||
for (i = 0; i < LOSCFG_BASE_CORE_TSK_LIMIT + 1; i++) {
|
||||
if (info[i].usStatus) {
|
||||
j++;
|
||||
}
|
||||
}
|
||||
return j;
|
||||
#else
|
||||
return 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
void *os_task_current(void)
|
||||
{
|
||||
return (void *)(g_losTask.runTask->taskID + 1);
|
||||
}
|
||||
|
||||
int32 os_task_suspend(os_task_t *task)
|
||||
{
|
||||
UINT32 hdl = (UINT32)task->hdl;
|
||||
if(hdl > 0){
|
||||
return LOS_TaskSuspend(hdl - 1);
|
||||
}else{
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
int32 os_task_resume(os_task_t *task)
|
||||
{
|
||||
UINT32 hdl = (UINT32)task->hdl;
|
||||
|
||||
if(hdl > 0){
|
||||
return LOS_TaskResume(hdl - 1);
|
||||
}else{
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
UINT8 os_task_state_convert(UINT16 taskStatus)
|
||||
{
|
||||
if (taskStatus & OS_TASK_STATUS_RUNNING) {
|
||||
return 1;
|
||||
} else if (taskStatus & OS_TASK_STATUS_READY) {
|
||||
return 1; //READY
|
||||
} else if (taskStatus & OS_TASK_STATUS_EXIT) {
|
||||
return 7; //delete
|
||||
} else if (taskStatus & OS_TASK_STATUS_SUSPEND) {
|
||||
return 3; //suspend
|
||||
} else if (taskStatus & OS_TASK_STATUS_DELAY) {
|
||||
return 5; //sleep
|
||||
} else if (taskStatus & OS_TASK_STATUS_PEND) {
|
||||
if (taskStatus & OS_TASK_STATUS_PEND_TIME) {
|
||||
return 6; //
|
||||
}
|
||||
return 2; //pend
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void os_task_dump(void *hdl, void *stack)
|
||||
{
|
||||
UINT32 i = 0;
|
||||
UINT32 *p;
|
||||
UINT32 *addr = 0;
|
||||
LosTaskCB *task;
|
||||
UINT32 taskID = (UINT32)hdl;
|
||||
UINT32 *sp = (uint32_t *)__get_SP();
|
||||
|
||||
if(hdl == NULL){
|
||||
return;
|
||||
}
|
||||
|
||||
taskID = taskID - 1;
|
||||
task = OS_TCB_FROM_TID(taskID);
|
||||
p = (stack ? stack : task->stackPointer);
|
||||
__lable:
|
||||
printf("\0011Task:%s\r\n", task->taskName);
|
||||
printf("\0011 task_state: %d\r\n", os_task_state_convert(task->taskStatus));
|
||||
printf("\0011 stack_size: %d\r\n", task->stackSize);
|
||||
printf("\0011 task_stack: 0x%08x,0x%08x,0x%08x\r\n", (uint32_t)task->topOfStack, (uint32_t)p, (uint32_t)(task->topOfStack + task->stackSize));
|
||||
if(task == g_losTask.runTask){
|
||||
printf("\0011 task_lr : %p\r\n", __builtin_return_address(0));
|
||||
printf("\0011 task_pc : %p\r\n", &&__lable);
|
||||
p = sp;
|
||||
}
|
||||
|
||||
printf("\0011 stack dump:\r\n ");
|
||||
for(addr=p; (UINT32)addr<task->topOfStack+task->stackSize; addr++){
|
||||
printf("\00110x%08x,", *addr);
|
||||
if(++i == 4){
|
||||
printf("\0011\r\n ");
|
||||
i = 0;
|
||||
}
|
||||
}
|
||||
printf("\0011\r\n");
|
||||
}
|
||||
|
||||
int32 os_task_yield(void)
|
||||
{
|
||||
return LOS_TaskYield();
|
||||
}
|
||||
|
||||
int32 os_sched_disable(void)
|
||||
{
|
||||
LOS_TaskLock();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int32 os_sched_enbale(void)
|
||||
{
|
||||
LOS_TaskUnlock();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void *os_task_data(void *hdl)
|
||||
{
|
||||
LosTaskCB *task;
|
||||
UINT32 taskID = (UINT32)hdl;
|
||||
if(taskID > 0){
|
||||
task = OS_TCB_FROM_TID(taskID-1);
|
||||
return (void *)task->arg;
|
||||
}else{
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void *os_task_create(const char *name, os_task_func_t func, void *args, uint32 prio, uint32 time, void *stack, uint32 stack_size)
|
||||
{
|
||||
UINT32 hdl = 0;
|
||||
TSK_INIT_PARAM_S stTskInitParam;
|
||||
os_memset(&stTskInitParam, 0, sizeof(stTskInitParam));
|
||||
stTskInitParam.pfnTaskEntry = (TSK_ENTRY_FUNC)func;
|
||||
stTskInitParam.uwArg = (UINT32)args;
|
||||
stTskInitParam.uwStackSize = stack_size;
|
||||
stTskInitParam.pcName = (char *)name;
|
||||
stTskInitParam.uwResved = LOS_TASK_ATTR_JOINABLE;
|
||||
stTskInitParam.usTaskPrio = os_task_set_priority(NULL, prio);
|
||||
if (LOS_OK == LOS_TaskCreate(&hdl, &stTskInitParam)) {
|
||||
if(prio & OS_TASK_FLAGS_LPRUN){
|
||||
LOS_Task_LpowerRun(hdl, 1);
|
||||
}
|
||||
hdl++;
|
||||
}
|
||||
return (void *)hdl;
|
||||
}
|
||||
|
||||
int32 os_task_destroy(void *hdl)
|
||||
{
|
||||
UINT32 tsk_hdl = (UINT32)hdl;
|
||||
if(tsk_hdl > 0){
|
||||
return LOS_TaskDelete(tsk_hdl - 1);
|
||||
}else{
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
void os_lpower_mode(uint8 enable)
|
||||
{
|
||||
UINT32 intSave;
|
||||
UINT32 loopNum;
|
||||
LosTaskCB *taskCB = (LosTaskCB *)NULL;
|
||||
intSave = LOS_IntLock();
|
||||
for (loopNum = 0; loopNum < g_taskMaxNum; loopNum++) {
|
||||
taskCB = (((LosTaskCB *)g_taskCBArray) + loopNum);
|
||||
if (taskCB->taskStatus & OS_TASK_STATUS_UNUSED) {
|
||||
continue;
|
||||
}
|
||||
if(loopNum != g_idleTaskID && !taskCB->lpRun){
|
||||
if(enable){
|
||||
LOS_TaskSuspend(loopNum);
|
||||
}else{
|
||||
LOS_TaskResume(loopNum);
|
||||
}
|
||||
}
|
||||
}
|
||||
LOS_IntRestore(intSave);
|
||||
}
|
||||
|
||||
|
||||
int32 os_task_suspend2(void *task_hdl)
|
||||
{
|
||||
UINT32 hdl = (UINT32)task_hdl;
|
||||
if(hdl > 0){
|
||||
return LOS_TaskSuspend(hdl - 1);
|
||||
}else{
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
int32 os_task_resume2(void *task_hdl)
|
||||
{
|
||||
UINT32 hdl = (UINT32)task_hdl;
|
||||
if(hdl > 0){
|
||||
return LOS_TaskResume(hdl - 1);
|
||||
}else{
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
int32 os_blklist_init(os_blklist_t *blkobj)
|
||||
{
|
||||
blkobj->hdl = LOS_Blklist_New();
|
||||
return blkobj->hdl ? RET_OK : RET_ERR;
|
||||
}
|
||||
|
||||
void os_blklist_del(os_blklist_t *blkobj)
|
||||
{
|
||||
if(blkobj->hdl){
|
||||
LOS_Blklist_Delete(blkobj->hdl);
|
||||
}
|
||||
}
|
||||
|
||||
void os_blklist_suspend(os_blklist_t *blkobj, void *hdl)
|
||||
{
|
||||
UINT32 task_hdl = (UINT32)hdl;
|
||||
if(blkobj->hdl && task_hdl > 0){
|
||||
LOS_Blklist_Suspend(blkobj->hdl, task_hdl-1);
|
||||
}
|
||||
}
|
||||
|
||||
void os_blklist_resume(os_blklist_t *blkobj)
|
||||
{
|
||||
if(blkobj->hdl){
|
||||
LOS_Blklist_Resume(blkobj->hdl);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user