zouhaitao/TAIXIN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: TXW82x FPV v2.7.0.7-42229 SDK + project sources

Browse Source
This commit is contained in:
zouhaitao
2026-07-06 11:30:13 +08:00
commit e76462eeb7
3451 changed files with 1415300 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

270
sdk/osal/csky/task.c Normal file
View File

@@ -0,0 +1,270 @@
#include "typesdef.h"
#include "errno.h"
#include "list.h"
#include "osal/string.h"
#include "osal/task.h"
#ifdef CSKY_OS
#include <csi_kernel.h>
#include <k_api.h>
extern uint32_t csi_kernel_task_runtime(struct os_task_info *tsk_rumtime, int count);
extern void csi_kernel_task_dump(k_task_handle_t task_handle, void *stack);
extern void csi_kernel_task_print(void);
extern int csi_kernel_task_count(void);
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)
{
return csi_kernel_task_get_prio(hdl);
}
int32 os_task_stacksize(os_task_t *task)
{
//ASSERT(task);
return task->stack_size;
}
int32 os_task_stacksize2(void *hdl)
{
return csi_kernel_task_get_stack_size(hdl);
}
int32 _os_task_set_priority(os_task_t *task, uint32 prio)
{
int32 pri = KPRIO_NORMAL;
uint8 priority = prio & 0xff;
//ASSERT(task);
//ASSERT(!task->hdl);
if (priority < OS_TASK_PRIORITY_LOW) {
pri = KPRIO_LOW0;
} else if (priority < OS_TASK_PRIORITY_BELOW_NORMAL) {
pri = KPRIO_LOW0 + (priority - OS_TASK_PRIORITY_LOW);
if (pri > KPRIO_LOW7) { pri = KPRIO_LOW7; }
} else if (priority >= OS_TASK_PRIORITY_BELOW_NORMAL && priority < OS_TASK_PRIORITY_NORMAL) {
pri = KPRIO_NORMAL_BELOW0 + (priority - OS_TASK_PRIORITY_BELOW_NORMAL);
if (pri > KPRIO_NORMAL_BELOW7) { pri = KPRIO_NORMAL_BELOW7; }
} else if (priority >= OS_TASK_PRIORITY_NORMAL && priority < OS_TASK_PRIORITY_ABOVE_NORMAL) {
pri = KPRIO_NORMAL + (priority - OS_TASK_PRIORITY_NORMAL);
if (pri > KPRIO_NORMAL7) { pri = KPRIO_NORMAL7; }
} else if (priority >= OS_TASK_PRIORITY_ABOVE_NORMAL && priority < OS_TASK_PRIORITY_HIGH) {
pri = KPRIO_NORMAL_ABOVE0 + (priority - OS_TASK_PRIORITY_ABOVE_NORMAL);
if (pri > KPRIO_NORMAL_ABOVE7) { pri = KPRIO_NORMAL_ABOVE7; }
} else if (priority >= OS_TASK_PRIORITY_HIGH && priority < OS_TASK_PRIORITY_REALTIME) {
pri = KPRIO_HIGH0 + (priority - OS_TASK_PRIORITY_HIGH);
if (pri > KPRIO_HIGH7) { pri = KPRIO_HIGH7; }
} else if (priority >= OS_TASK_PRIORITY_REALTIME && priority < OS_TASK_PRIORITY_ISR) {
pri = KPRIO_REALTIME0 + (priority - OS_TASK_PRIORITY_REALTIME);
if (pri > KPRIO_REALTIME7) { pri = KPRIO_REALTIME7; }
} else {
pri = KPRIO_ISR;
}
if (task) {
task->priority = pri;
task->lprun = (prio & OS_TASK_FLAGS_LPRUN) ? 1 : 0;
if (task->hdl) {
csi_kernel_task_set_prio(task->hdl, task->priority);
csi_kernel_task_set_lprun(task->hdl, 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)
{
//ASSERT(task);
int32 ret = csi_kernel_task_new(os_task_entry, task->name,
(void *)task, task->priority, 0, task->stack,
task->stack_size, &task->hdl);
if(ret == RET_OK){
csi_kernel_task_set_lprun(task->hdl, task->lprun);
}
//ASSERT(!ret);
return ret;
}
int32 os_task_stop(os_task_t *task)
{
//ASSERT(0);
csi_kernel_task_terminate(task->hdl);
return RET_OK;
}
int32 os_task_del(os_task_t *task)
{
int32 ret = 0;
//ASSERT(task);
ASSERT(task->hdl);
void *hdl = task->hdl;
task->hdl = NULL;
ret = csi_kernel_task_del(hdl);
return ret;
}
int32 os_task_runtime(struct os_task_info *tsk_times, int32 count)
{
return csi_kernel_task_runtime(tsk_times, count);
}
void os_task_print(void)
{
csi_kernel_task_print();
}
int32 os_task_count(void)
{
return csi_kernel_task_count();
}
void *os_task_current(void)
{
return csi_kernel_task_get_cur();
}
int32 os_task_suspend(os_task_t *task)
{
return csi_kernel_task_suspend(task->hdl);
}
int32 os_task_resume(os_task_t *task)
{
return csi_kernel_task_resume(task->hdl);
}
void os_task_dump(void *hdl, void *stack)
{
csi_kernel_task_dump(hdl, stack);
}
int32 os_task_yield(void)
{
return csi_kernel_task_yield();
}
int32 os_sched_disable(void)
{
krhino_sched_disable();
return 0;
}
int32 os_sched_enbale(void)
{
krhino_sched_enable();
return 0;
}
os_task_t *os_task_hdl2tsk(void *hdl)
{
ktask_t *task = (ktask_t *)hdl;
return (task && task->arg) ? ((os_task_t *)task->arg) : NULL;
}
void *os_task_data(void *hdl)
{
ktask_t *task = (ktask_t *)hdl;
return task->arg;
}
void *os_task_create(const char *name, os_task_func_t func, void *args, uint32 prio, uint32 time, void *stack, uint32 stack_size)
{
k_task_handle_t hdl = NULL;
uint32 priority = os_task_set_priority(NULL, prio);
int32 ret = csi_kernel_task_new(func, name, args, priority, time, stack, stack_size, &hdl);
if(ret == RET_OK){
if(prio & OS_TASK_FLAGS_LPRUN){
csi_kernel_task_set_lprun(hdl, 1);
}
}
ASSERT(!ret);
return hdl;
}
int32 os_task_destroy(void *hdl)
{
return csi_kernel_task_del(hdl);
}
int32 os_task_suspend2(void *hdl)
{
return csi_kernel_task_suspend((k_task_handle_t)hdl);
}
int32 os_task_resume2(void *hdl)
{
return csi_kernel_task_resume((k_task_handle_t)hdl);
}
int32 os_blklist_init(os_blklist_t *blkobj)
{
void *csi_kernel_blklist_new();
blkobj->hdl = csi_kernel_blklist_new();
return blkobj->hdl ? RET_OK : RET_ERR;
}
void os_blklist_del(os_blklist_t *blkobj)
{
void csi_kernel_blklist_del(void *hdl);
csi_kernel_blklist_del(blkobj->hdl);
}
void os_blklist_suspend(os_blklist_t *blkobj, void *task_hdl)
{
void csi_kernel_blklist_suspend(void *hdl, k_task_handle_t task_hdl);
csi_kernel_blklist_suspend(blkobj->hdl, task_hdl);
}
void os_blklist_resume(os_blklist_t *blkobj)
{
void csi_kernel_blklist_wakeup(void *hdl);
csi_kernel_blklist_wakeup(blkobj->hdl);
}
void os_lpower_mode(uint8 enable)
{
csi_kernel_lpower_mode(enable);
}
#endif