sys_task.c

abstract rtos

#include "syscfg.h"

#ifdef __cplusplus
#if __cplusplus
extern "C"{
#endif 
#endif 



#include "sys/sys_pub.h"
#include "aos.h"





AOS_ASSERTFILE();

AOS_INLINE U32 sys_task_prio( TASK_PRIO task_prio );


AOS_INLINE U32 sys_task_create(S8 name[AOS_NAME_LEN+1], 
                    U32 stack_size,
                    TASK_PRIO task_prio,
                    U32 task_mode,
                    VOID(*entry)(VOID*),
                    VOID*arg,
                    SYS_TASK_T *task_id,
                    SYS_TASK_H *task_hd)
{
    AOS_ASSERT( (NULL != entry) && (NULL != task_id) && (NULL!=task_hd) );
    if((entry == NULL) || (task_id == NULL) || (task_hd == NULL))
    {
        return SYS_OBJ_CREATE_FAIL;
    }
    
    *task_hd =  CreateThread( NULL, 
    	                      stack_size, 
    	                      (LPTHREAD_START_ROUTINE) entry, 
    	                      (LPVOID)arg, 
    	                      0, 
    	                      (LPDWORD)task_id);

    if( NULL == *task_hd )
    {
        *task_id = (SYS_TASK_T)-1;
        *task_hd =(SYS_TASK_H)-1;
        return SYS_OBJ_CREATE_FAIL;
    }

    sys_task_setprio( *task_hd, task_prio );

    (void)name;
    (void)task_mode;
    
    return AOS_SUCC;
}

AOS_INLINE U32 sys_task_cancel(SYS_TASK_H task_hd)
{
    if( 0 == task_hd )
    {
        task_hd = GetCurrentThread();
    }
    
    if( 0 == TerminateThread( task_hd, 0 ) )
    {
        return SYS_CALL_FAIL;
    }

    return AOS_SUCC;
}

AOS_INLINE SYS_TASK_T sys_task_self()
{
    return GetCurrentThreadId();
}

AOS_INLINE U32 sys_task_setprio(SYS_TASK_H task_hd, TASK_PRIO task_prio )
{
    U32 sys_prio;

    sys_prio = sys_task_prio(task_prio);
    if( 0 == SetThreadPriority( task_hd, (S32)sys_prio ) )
    {
        return SYS_CALL_FAIL;
    }
    
    return AOS_SUCC;
}

AOS_INLINE U32 sys_task_lock()
{
    
    return AOS_SUCC;
}

AOS_INLINE U32 sys_task_unlock()
{
    
    return AOS_SUCC;
}

AOS_INLINE U32 sys_task_suspend( SYS_TASK_H task_hd )
{
    if( 0 == task_hd )
    {
        task_hd = GetCurrentThread();
    }

    if( 0xffffffff == SuspendThread( task_hd ) )
    {
        return SYS_CALL_FAIL;
    }

    return AOS_SUCC;
}

AOS_INLINE U32 sys_task_resume( SYS_TASK_H task_hd )
{
    if( 0 == task_hd )
    {
        task_hd = GetCurrentThread();
    }

    if( 0xffffffff == ResumeThread( task_hd ) )
    {
        return SYS_CALL_FAIL;
    }

    return AOS_SUCC;
}

AOS_INLINE U32 sys_task_delay( U32 timeout )
{
    Sleep(timeout);
    
    return AOS_SUCC;
}



AOS_INLINE U32 sys_task_prio( TASK_PRIO task_prio )
{
    S32 prio = THREAD_PRIORITY_NORMAL;

    switch( task_prio )
    {
        case TASK_PRIO_IDLE:
        	prio =THREAD_PRIORITY_IDLE;
        	break;
        	
        case TASK_PRIO_ABOVE_IDLE:
        	prio =THREAD_PRIORITY_LOWEST;
        	break;

        case TASK_PRIO_LOWEST:
        	prio =THREAD_PRIORITY_LOWEST;
        	break;

        case TASK_PRIO_BELOW_NORMAL:
        	prio =THREAD_PRIORITY_BELOW_NORMAL;
        	break;

        	
        case TASK_PRIO_NORMAL:
        	prio =THREAD_PRIORITY_NORMAL;
        	break;

        case TASK_PRIO_ABOVE_NORMAL:
        	prio =THREAD_PRIORITY_ABOVE_NORMAL;
        	break;

        case TASK_PRIO_HIGHEST:
        	prio =THREAD_PRIORITY_HIGHEST;
        	break;

        case TASK_PRIO_TIME_CRITICAL:
        	prio =THREAD_PRIORITY_TIME_CRITICAL;
        	break;

        default:
        	AOS_ASSERT(0);
        	break;
    }
    
    return (U32)prio;
}

AOS_INLINE U32 sys_task_status(SYS_TASK_H task_hd,S8 *szStatus)
{
    aos_sprintf(szStatus,"%s","unknown");

    (void)task_hd;
    return AOS_SUCC;
}

AOS_INLINE BOOL_T sys_task_is_ready(SYS_TASK_H task_hd)
{
	return FALSE;
}

AOS_INLINE U32 sys_task_sp(SYS_TASK_H task_hd)
{
    return 0;
}

AOS_INLINE U32 sys_task_bp(SYS_TASK_H task_hd)
{
    return 0;
}

AOS_INLINE U32 sys_task_pc(SYS_TASK_H task_hd)
{
    return 0;
}

AOS_INLINE U32 sys_get_cur_sp(SYS_TASK_H task_hd)
{
    return 0;
}

#ifdef __cplusplus
#if __cplusplus
}
#endif 
#endif