ssp_task.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif 


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

#include "aos.h"




#include "ssp_event.h"
#include "ssp_task.h"
#include "ssp_cputick.h"
#include "ssp_spy.h"


TASK_S *g_pstTask = NULL;
U32     g_ulLastTaskID = U32_BUTT;
U32     g_ulNextTaskID = U32_BUTT;


U32 g_ulRefresh;

extern U32 m_ulIdleTaskId;
extern volatile U32 m_ulCurTicks;

U32 m_task_init()
{
    U32 tid, regNo;
#if( CONFIG_OS_VXWORKS == TRUE )
    U32 osTaskNum, osTaskAry[10], osTid;
#endif

    g_pstTask = (TASK_S*)aos_smem_alloc( MPE_SYS, SID_TASK, sizeof( TASK_S)*CONFIG_TASK_NUMBER );
    if( NULL == g_pstTask )
    {
        return TASK_MOD_INIT_FAIL;
    }

    for( tid=0; tid < CONFIG_TASK_NUMBER; tid++ )
    {
        g_pstTask[tid].status     = TASK_STATUS_NULL;
        g_pstTask[tid].stack_size = 0;
        g_pstTask[tid].task_mode  = 0;
        g_pstTask[tid].entry      = NULL;
        g_pstTask[tid].arg        = NULL;
        g_pstTask[tid].task_prio  = TASK_PRIO_BUTT;
        g_pstTask[tid].name[0]    = '\0';

        g_pstTask[tid].cputicklast.ulHigh  = 0;
        g_pstTask[tid].cputicklast.ulLow   = 0;
        g_pstTask[tid].cputicktotal.ulHigh = 0;
        g_pstTask[tid].cputicktotal.ulLow  = 0;
        
        g_pstTask[tid].sys_task_id   = (SYS_TASK_T)-1;
        g_pstTask[tid].sys_task_hd   = (SYS_TASK_H)-1;

        g_pstTask[tid].sys_event.sys_sem      = (SYS_SEM_T)-1;
        g_pstTask[tid].sys_event.evt_mask     = 0;
        g_pstTask[tid].sys_event.evt_pending  = 0;
        g_pstTask[tid].sys_event.evt_recv     = 0;
        g_pstTask[tid].sys_event.evt_wait_flg = 0;
        g_pstTask[tid].bisVxSysCreate = FALSE;

        for( regNo=0; regNo < TASK_REG_NUM; regNo++ )
        {
            g_pstTask[tid].regAry[regNo] = 0;
        }
        
    }

#if( CONFIG_OS_VXWORKS == TRUE )
    osTaskNum = (U32)taskIdListGet( (int*)osTaskAry, 10 );

    for( tid = 1; tid < 10 && tid < osTaskNum; tid++ )
    {
        aos_raw_task_create( taskName(osTaskAry[tid]), osTaskAry[tid],&osTid );
    }
#endif    
    
    ssp_task_switchhookadd();
    
    return AOS_SUCC;
}

U32 aos_task_create(S8 name[AOS_NAME_LEN+1], 
                    U32 ulStackSize,
                    TASK_PRIO taskPrio,
                    U32 ulTaskMode,
                    VOID(*entry)(VOID*),
                    VOID*arg,
                    U32 *pulTaskId)
{
    U32 lockKey, tid, regNo;
    TASK_S *pTask;
    
    if( NULL == entry )
    {
        return TASK_INVALID_TASK_ENTRY;
    }

    if( NULL == pulTaskId )
    {
        return TASK_INVALID_POINTER_PARA;
    }

    if( taskPrio >= TASK_PRIO_BUTT )
    {
        *pulTaskId = U32_BUTT;
        return TASK_INVALID_PRIORITY;
    }

    lockKey = aos_int_lock();
    for( tid=1; tid < CONFIG_TASK_NUMBER; tid++ )
    {
        if( TASK_STATUS_NULL ==  g_pstTask[tid].status )
        {
            break;
        }
    }
    
    if( tid >= CONFIG_TASK_NUMBER )
    {
        aos_int_unlock( lockKey );
        *pulTaskId = U32_BUTT;

        AOS_ASSERT(0);
        
        return TASK_NO_MEN;
    }
    
    pTask = &g_pstTask[tid];
    pTask->status = TASK_STATUS_CREATE;
    
    aos_int_unlock( lockKey );

    if(  AOS_SUCC != sys_sem_create( name, AOS_FIFO, 0, 
                                     &pTask->sys_event.sys_sem ) )
    {
        lockKey = aos_int_lock();
        pTask->status = TASK_STATUS_NULL;
        aos_int_unlock( lockKey );
        
        *pulTaskId = U32_BUTT;
        AOS_ASSERT(0);
        return TASK_SYS_CREATE_FAIL;
    }
    
    if( AOS_SUCC != sys_task_create( name, 
                                     ulStackSize,
                                     taskPrio,
                                     ulTaskMode,
                                     (VOID(*)(VOID*))ssp_task_entry,
                                     (VOID*)tid,
                                     &pTask->sys_task_id,
                                     &pTask->sys_task_hd ) )
    {
        sys_sem_cancel( &pTask->sys_event.sys_sem );
        
        lockKey = aos_int_lock();
        pTask->status = TASK_STATUS_NULL;
        aos_int_unlock( lockKey );
        
        *pulTaskId = U32_BUTT;
        AOS_ASSERT(0);
        return TASK_SYS_CREATE_FAIL;
    }
    
    pTask->stack_size  = ulStackSize;
    pTask->task_mode   = ulTaskMode;
    pTask->entry       = entry;
    pTask->arg         = arg;
    pTask->task_prio   = taskPrio;

    aos_cputick_get(&(pTask->cputicklast));
    pTask->cputicktotal.ulLow  = 0;
    pTask->cputicktotal.ulHigh = 0;

    pTask->stack_bottom        = NULL;

    for( regNo=0; regNo < TASK_REG_NUM; regNo++ )
    {
        pTask->regAry[regNo] = 0;
    }
    aos_strncpy( pTask->name, name, AOS_NAME_LEN  );

    *pulTaskId = tid;
    
    #if CONFIG_OS_VXWORKS
    sys_task_save_id(pTask->sys_task_hd,tid);
    #endif
    
    sys_sem_post( &pTask->sys_event.sys_sem );

    return AOS_SUCC;
}


U32 aos_raw_task_create(S8 name[AOS_NAME_LEN+1], U32 osTaskId, U32 *pulTaskId )
{
    U32 lockKey, tid, regNo;
    TASK_S *pTask;
#if( CONFIG_OS_VXWORKS == TRUE )
    TASK_DESC vxTaskDesc;
#endif
    lockKey = aos_int_lock();
    for( tid=1; tid < CONFIG_TASK_NUMBER; tid++ )
    {
        if( TASK_STATUS_NULL ==  g_pstTask[tid].status )
        {
            break;
        }
    }
    
    if( tid >= CONFIG_TASK_NUMBER )
    {
        aos_int_unlock( lockKey );
        *pulTaskId = U32_BUTT;
        
        return TASK_NO_MEN;
    }
    
    pTask = &g_pstTask[tid];
    pTask->status = TASK_STATUS_CREATE;
    pTask->bisVxSysCreate = TRUE;
    
    aos_int_unlock( lockKey );

    pTask->sys_task_hd = (SYS_TASK_H)osTaskId;
    pTask->sys_task_id = (SYS_TASK_T)osTaskId;

    aos_cputick_get(&(pTask->cputicklast));
    pTask->cputicktotal.ulLow  = 0;
    pTask->cputicktotal.ulHigh = 0;
    pTask->stack_bottom        = NULL;
    pTask->stack_size = 0;

#if( CONFIG_OS_VXWORKS == TRUE )
    if( 0 != osTaskId )
    {
        taskInfoGet( osTaskId, &vxTaskDesc );
        pTask->stack_size = vxTaskDesc.td_stackSize;
        pTask->stack_bottom = (U32*)vxTaskDesc.td_pStackBase;
    }
#endif
    for( regNo=0; regNo < TASK_REG_NUM; regNo++ )
    {
        pTask->regAry[regNo] = 0;
    }
    aos_strncpy( pTask->name, name, AOS_NAME_LEN  );

    *pulTaskId = tid;
    
    #if CONFIG_OS_VXWORKS == TRUE
    if( pTask->sys_task_hd )
    {
        sys_task_save_id(pTask->sys_task_hd,tid);
    }
    #endif
    
    return AOS_SUCC;
}

U32 aos_task_cancel(U32 ulTaskId)
{
    U32 lockKey;
    TASK_S *pTask;
    SYS_TASK_H task_handle;
    SYS_SEM_T evt_sem;
    
    if( 0 == ulTaskId )
    {
        ulTaskId = aos_task_self();
    }

    lockKey = aos_int_lock();

    if( ulTaskId >= CONFIG_TASK_NUMBER )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }

    pTask = &g_pstTask[ulTaskId];
    if( TASK_STATUS_NULL == pTask->status )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }

    task_handle = pTask->sys_task_hd;
    evt_sem = pTask->sys_event.sys_sem;

    pTask->status       = TASK_STATUS_NULL;
    pTask->stack_size   = 0;
    pTask->task_mode    = 0;
    pTask->entry        = NULL;
    pTask->arg          = NULL;
    pTask->task_prio    = TASK_PRIO_BUTT;
        
    pTask->sys_task_id   = (SYS_TASK_T)-1;
    pTask->sys_task_hd   = (SYS_TASK_H)-1;

    pTask->sys_event.sys_sem        = (SYS_SEM_T)-1;
    pTask->sys_event.evt_mask       = 0;
    pTask->sys_event.evt_pending    = 0;
    pTask->sys_event.evt_recv       = 0;
    pTask->sys_event.evt_wait_flg   = 0;

    aos_int_unlock( lockKey );

    aos_debug_trace_cancel( ulTaskId );

    if( ulTaskId == aos_task_self() )
    {
        if( AOS_SUCC != sys_sem_cancel(&evt_sem) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }

        if( AOS_SUCC != sys_task_cancel(task_handle) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }

    }
    else
    {
        if( AOS_SUCC != sys_task_cancel(task_handle) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }

        if( AOS_SUCC != sys_sem_cancel(&evt_sem) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }
    }

    return AOS_SUCC;
}

U32 aos_task_suspend( U32 ulTaskId )
{
    U32 lockKey;
    TASK_S *pTask;
    
    if( 0 == ulTaskId )
    {
        ulTaskId = aos_task_self();
    }

    lockKey = aos_int_lock();

    if( ulTaskId >= CONFIG_TASK_NUMBER )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }

    pTask = &g_pstTask[ulTaskId];
    if( TASK_STATUS_NULL == pTask->status )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }
    aos_int_unlock( lockKey );

    if( AOS_SUCC != sys_task_suspend(pTask->sys_task_hd) )
    {
        return TASK_SYS_SUSPEND_FAIL;
    }
    
    return AOS_SUCC;
}

U32 aos_task_resume( U32 ulTaskId )
{
    U32 lockKey;
    TASK_S *pTask;
    
    if( 0 == ulTaskId )
    {
        ulTaskId = aos_task_self();
    }

    lockKey = aos_int_lock();

    if( ulTaskId >= CONFIG_TASK_NUMBER )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }

    pTask = &g_pstTask[ulTaskId];
    if( TASK_STATUS_NULL == pTask->status )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }
    aos_int_unlock( lockKey );

    if( AOS_SUCC != sys_task_resume(pTask->sys_task_hd) )
    {
        return TASK_SYS_RESUME_FAIL;
    }

    aos_cputick_get(&(pTask->cputicklast));
    pTask->cputicktotal.ulLow  = 0;
    pTask->cputicktotal.ulHigh = 0;
    
    return AOS_SUCC;
}

U32 aos_task_restart( U32 ulTaskId )
{
    U32 lockKey;
    TASK_S *pTask;
    SYS_TASK_H task_handle;
    SYS_SEM_T evt_sem;
    U32      ret = AOS_SUCC;
    
    if( 0 == ulTaskId )
    {
        ulTaskId = aos_task_self();
    }


    lockKey = aos_int_lock();

    if( ulTaskId >= CONFIG_TASK_NUMBER )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }

    pTask = &g_pstTask[ulTaskId];
    if( TASK_STATUS_NULL == pTask->status )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }

    task_handle = pTask->sys_task_hd;
    evt_sem = pTask->sys_event.sys_sem;

    pTask->sys_event.evt_mask       = 0;
    pTask->sys_event.evt_pending    = 0;
    pTask->sys_event.evt_recv       = 0;
    pTask->sys_event.evt_wait_flg   = 0;

    pTask->status = TASK_STATUS_CREATE;
    pTask->stack_bottom        = NULL;

    aos_int_unlock( lockKey );

    if(  AOS_SUCC != sys_sem_create( pTask->name, AOS_FIFO, 0, 
                                     &pTask->sys_event.sys_sem ) )
    {
        ret = TASK_SYS_CREATE_FAIL;
        goto restart_fail;
    }
    
    if( AOS_SUCC != sys_task_create( pTask->name, 
                                     pTask->stack_size,
                                     (TASK_PRIO)pTask->task_prio,
                                     pTask->task_mode,
                                     (VOID(*)(VOID*))ssp_task_entry,
                                     (VOID*)ulTaskId,
                                     &pTask->sys_task_id,
                                     &pTask->sys_task_hd ) )
    {
        sys_sem_cancel( &pTask->sys_event.sys_sem );
        
        ret = TASK_SYS_CREATE_FAIL;
        goto restart_fail;
    }
    
    #if CONFIG_OS_VXWORKS
    sys_task_save_id(pTask->sys_task_hd,ulTaskId);
    #endif
    
    sys_sem_post( &pTask->sys_event.sys_sem );

old_src_free:
    if( ulTaskId == aos_task_self() )
    {
        if( AOS_SUCC != sys_sem_cancel(&evt_sem) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }

        if( AOS_SUCC != sys_task_cancel(task_handle) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }

    }
    else
    {
        if( AOS_SUCC != sys_task_cancel(task_handle) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }

        if( AOS_SUCC != sys_sem_cancel(&evt_sem) )
        {
            return TASK_SYS_CANCEL_FAIL;
        }
    }
    
    return ret;

restart_fail:

    lockKey = aos_int_lock();
    
    pTask->status       = TASK_STATUS_NULL;
    pTask->stack_size   = 0;
    pTask->task_mode    = 0;
    pTask->entry        = NULL;
    pTask->arg          = NULL;
    pTask->task_prio    = TASK_PRIO_BUTT;
        
    pTask->sys_task_id   = (SYS_TASK_T)-1;
    pTask->sys_task_hd   = (SYS_TASK_H)-1;

    pTask->sys_event.sys_sem        = (SYS_SEM_T)-1;
    pTask->sys_event.evt_mask       = 0;
    pTask->sys_event.evt_pending    = 0;
    pTask->sys_event.evt_recv       = 0;
    pTask->sys_event.evt_wait_flg   = 0;

    aos_int_unlock( lockKey );

    aos_debug_trace_cancel( ulTaskId );

    goto old_src_free;
}

U32 aos_task_self()
{
    #if CONFIG_OS_WINDOWS
    SYS_TASK_T sys_task_id;
    U32 lockKey,tid;

    if( NULL == g_pstTask )
    {
        return U32_BUTT;
    }

    sys_task_id = sys_task_self();

    lockKey = aos_int_lock();
    for( tid=1; tid < CONFIG_TASK_NUMBER; tid++ )
    {
        if( (TASK_STATUS_NULL != g_pstTask[tid].status)
            && (g_pstTask[tid].sys_task_id ==sys_task_id) )
        {
            aos_int_unlock(lockKey);
            return tid;
        }
    }

    aos_int_unlock(lockKey);
    
    return U32_BUTT;
    #endif

    #if CONFIG_OS_VXWORKS
    if( NULL == g_pstTask )
    {
        return U32_BUTT;
    }

    if((taskIdCurrent == NULL) || ((U32)taskIdCurrent->reserved1 != 0xABCDABCD))
    {
        return U32_BUTT;
    }
    
    return (U32)taskIdCurrent->reserved2;
    #endif
}

U32 aos_task_verify( U32 ulTaskId )
{
    U32 lockKey;
    
    if( 0 == ulTaskId )
    {
        ulTaskId = aos_task_self();
    }

    lockKey = aos_int_lock();

    if( (ulTaskId >= CONFIG_TASK_NUMBER) ||
        (TASK_STATUS_NULL == g_pstTask[ulTaskId].status) )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }
    aos_int_unlock( lockKey );

    return AOS_SUCC;
}

U32 aos_task_delay( U32 timeout )
{
    sys_task_delay( timeout );
    
    return AOS_SUCC;
}

U32 aos_task_reg_set( U32 taskId, U32 regNo, U32 value )
{
    U32 lockKey;
    TASK_S *pTask;
    
    if( regNo >= TASK_REG_NUM )
    {
        return TASK_INVALID_TASK_REG_NUM;
    }

    if( 0 == taskId )
    {
        taskId = aos_task_self();
    }

    if( taskId >= CONFIG_TASK_NUMBER )
    {
        return TASK_INVALID_TASK_ID;
    }

    lockKey = aos_int_lock();
    pTask = &g_pstTask[taskId];
    if( TASK_STATUS_NULL == pTask->status )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }
    pTask->regAry[regNo] = value;
    
    aos_int_unlock( lockKey );

    return AOS_SUCC;
}

U32 aos_task_reg_get( U32 taskId, U32 regNo, U32 *pValue )
{
    U32 lockKey;
    TASK_S *pTask;
    
    if( regNo >= TASK_REG_NUM )
    {
        return TASK_INVALID_TASK_REG_NUM;
    }

    if( NULL == pValue )
    {
        return TASK_INVALID_POINTER_PARA;
    }

    if( 0 == taskId )
    {
        taskId = aos_task_self();
    }

    if( taskId >= CONFIG_TASK_NUMBER )
    {
        return TASK_INVALID_TASK_ID;
    }

    lockKey = aos_int_lock();
    pTask = &g_pstTask[taskId];
    if( TASK_STATUS_NULL == pTask->status )
    {
        aos_int_unlock( lockKey );
        return TASK_INVALID_TASK_ID;
    }
    
    *pValue = pTask->regAry[regNo];