ssp_tick.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif 


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

#include "aos.h"

#include "ssp_msg.h"
#include "ssp_cputick.h"
#include "ssp_spy.h"

#include "ssp_event.h"
#include "ssp_task.h"


#include "ssp_tick.h"


U32 m_ulTickTaskId,m_ulIdleTaskId, m_ulIsrTaskId;

volatile U32 m_ulCurTicks = 0;
volatile U32 m_ulAllTicks = 0;
volatile U32 m_ulResTicks = CONFIG_TICKS_PER_SECOND;

U32 m_ulBaseIdleCount = (U32)-1;
U32 m_ulCurIdleCount = 0;

U32 m_ulPerformance_cur  = 0;
U32 m_ulPerformance_5s   = 0;
U32 m_ulPerformance_60s  = 0;
U32 m_ulPerformance_600s = 0;

U8 gulDelay = 0;

U32 m_ulTickTaskNum  = 0;
U32 m_ulIntTaskId    = 0;
    
TICK_TASK_S m_TickTask[CONFIG_TICK_TASK_NUM];

#if( CONFIG_CPU_ARM == TRUE || CONFIG_CPU_MIPS == TRUE )
CPU_TICK_S g_GlobalCpuTimeBase;
U32 g_SysCpuTimeBase;
#endif
void (* tick_poll_callback) (void ) = NULL;


#if CONFIG_OS_VXWORKS
typedef void(*FUN_PTR)();
extern FUN_PTR tick_isr_callback;
AOS_INLINE U32 sys_task_lock();
AOS_INLINE U32 sys_task_unlock();
void clear_watch_dog(void);

#endif

#ifndef _EIA2000V5
#if (CONFIG_BOARD_EIA == TRUE)
extern VOID rtp_eia_ticking(VOID);
#endif
#endif

#if( CONFIG_BOARD_GDSP == TRUE )
extern VOID rtp_gdsp_ticking(VOID);
#endif

#if (AOS_INCLUDE_DRIVER_AC483 == TRUE && CONFIG_BOARD_EIA == TRUE)
VOID ac483_ticking();
#endif

#if (CONFIG_BOARD_EIA == TRUE) && (AUTO_DIAL_ENABLE == TRUE)
VOID autodial_ticking();
#endif

void (*faxd_poll_ticking)(void)= NULL;

#if CONFIG_OS_WINDOWS
void CALLBACK aos_tick_announce_0( UINT uID, UINT uMsg, DWORD dwUser, DWORD dw1,DWORD dw2)
{
	aos_tick_announce();
}
#endif

U32 m_tick_init( )
{
    U32 result, i;

    m_ulTickTaskId  = U32_BUTT;
    m_ulIdleTaskId  = U32_BUTT;
    m_ulIsrTaskId = U32_BUTT;
    
    m_ulCurTicks = 0;
    m_ulAllTicks = 0;

    m_ulResTicks = 0;
    m_ulBaseIdleCount = (U32)-1;
    m_ulCurIdleCount = 0;

    m_ulTickTaskNum = 0;

    tick_poll_callback = NULL;

    for( i=0; i<CONFIG_TICK_TASK_NUM; i++ )
    {
    	m_TickTask[i].mpe     = MPE_BUTT;
    	m_TickTask[i].routine = NULL;
    }

    m_ulIntTaskId = 0;
    
#if CONFIG_OS_WINDOWS
    {
        U32 end;
        

        end =GetTickCount()+CONFIG_TICKS_PER_SECOND;
    
        IDLE_LOOP( end > GetTickCount() );
        m_ulBaseIdleCount = m_ulCurIdleCount;
    }

#elif CONFIG_OS_VXWORKS
    result = aos_raw_task_create( "t_isr", AOS_T_ISR, &m_ulIntTaskId );
    if( AOS_SUCC !=  result )
    {
        return result;
    }

    {
        CPU_TICK_S StartCpuTick;
        CPU_TICK_S EndCpuTick;
#if( CONFIG_CPU_ARM == TRUE || CONFIG_CPU_MIPS == TRUE )
        U32              high;
#endif

        disable_watch_dog();


        lcm_init_rapid_pkt_list();

        
        
        
        tick_isr_callback = (FUN_PTR)aos_tick_announce;

        
        sys_task_lock();

#if( CONFIG_CPU_ARM == TRUE || CONFIG_CPU_MIPS == TRUE )
        g_GlobalCpuTimeBase.ulHigh = 0;
        g_GlobalCpuTimeBase.ulLow = 0;
        
        sysGetTimeBase( &g_SysCpuTimeBase, &high );
#endif
        
        m_ulResTicks = CONFIG_TICKS_PER_SECOND;
        aos_cputick_get(&StartCpuTick);

        IDLE_LOOP(m_ulResTicks);

        m_ulBaseIdleCount = m_ulCurIdleCount;
        aos_cputick_get(&EndCpuTick);
        sys_task_unlock();
        enable_watch_dog();
        
        aos_cputick_sub(&EndCpuTick,&StartCpuTick);
        aos_cputick_div32(&EndCpuTick, CPUTICK_ONESECOND);
        AOS_ASSERT( 0==EndCpuTick.ulHigh );
        g_ulCpuTickBase = EndCpuTick.ulLow;
        
        g_cputAllowed = EndCpuTick;
        aos_cputick_mul32( &g_cputAllowed, CONFIG_TICKS_ONCE_PROCESS );

        g_cputStarve = EndCpuTick;
        aos_cputick_mul32( &g_cputStarve, CONFIG_TICKS_FOR_STARVE );
        
        result = aos_task_create( 
                                  "aidle",
                                  1024*2,
                                  TASK_PRIO_IDLE,
                                  AOS_TASK_PREEMPT,
                                  ssp_idle_task,
                                  (VOID*) NULL,
                                 &m_ulIdleTaskId );
                                 
        if( AOS_SUCC !=  result )
        {
            return result;
        }
    }
#else

#error "please config os"

#endif
    
    result = aos_task_create( "tick",
                              CONFIG_TICK_TASK_STACK_SIZE,
                              TASK_PRIO_TIME_CRITICAL,
                              AOS_TASK_NOPREEMPT,
                              (VOID(*)(VOID*))ssp_tick_task,
                              (VOID*) NULL,
                              &m_ulTickTaskId);
                             
    if( AOS_SUCC !=  result )
    {
        return result;
    }
    
#if CONFIG_OS_WINDOWS

    timeSetEvent( 10, 0, aos_tick_announce_0, 0, TIME_PERIODIC );

#elif CONFIG_OS_VXWORKS

#else

#error "please config os"

#endif
    return AOS_SUCC;
}

U32 aos_tick_task_add( MPE mpe, TICK_TASK_ROUTINE pTickRtn  )
{
	if( m_ulTickTaskNum >= CONFIG_TICK_TASK_NUM )
	{
		return AOS_FAIL;
	}

	m_TickTask[m_ulTickTaskNum].mpe = mpe;
	m_TickTask[m_ulTickTaskNum].routine = pTickRtn;
	m_ulTickTaskNum++;

	return AOS_SUCC;

}

AOS_INLINE VOID aos_tick_announce( )
{
    U32 tSelf;
    CPU_TICK_S startTick, startTick2, endTick;

#if( CONFIG_OS_VXWORKS == TRUE )
    ssp_add_task_switch_track( (U32)taskIdCurrent,AOS_T_ISR );
#endif

    aos_cputick_get(&startTick);
    tSelf = aos_task_self();

    m_ulCurTicks++;
    m_ulAllTicks++;

    if( m_ulResTicks )
    {
        m_ulResTicks--;
    }
    
#if (AOS_INCLUDE_SERVICE_RTPRTCP == TRUE)

#ifndef _EIA2000V5
#if (CONFIG_BOARD_EIA == TRUE)
        rtp_eia_ticking();
#endif
#endif


#if (CONFIG_BOARD_GDSP == TRUE)
    rtp_gdsp_ticking();
#endif

#endif

#if (AOS_INCLUDE_DRIVER_AC483 == TRUE && CONFIG_BOARD_EIA == TRUE)
    ac483_ticking();
#endif

#if (CONFIG_BOARD_EIA == TRUE) && (AUTO_DIAL_ENABLE == TRUE)
    autodial_ticking();
#endif


#if( AOS_INCLUDE_SSP_KER_SPY == TRUE )
    ssp_task_spy();
#endif

    if(tick_poll_callback)
    {
        (*tick_poll_callback)();
    }
    
    aos_event_post( m_ulTickTaskId, TICK_NOTIFY_EVENT );

    aos_cputick_get( &endTick );
    startTick2 = startTick;
    if( U32_BUTT != tSelf )
    {
        aos_cputick_sub(&startTick,&(g_pstTask[tSelf].cputicklast));
        aos_cputick_add(&(g_pstTask[tSelf].cputicktotal),&startTick);
        
        g_pstTask[tSelf].cputicklast = endTick;
    }

    aos_cputick_sub(&endTick,&startTick2);
    aos_cputick_add(&(g_pstTask[m_ulIntTaskId].cputicktotal),&endTick);

#if( CONFIG_OS_VXWORKS == TRUE )
    ssp_add_task_switch_track( AOS_T_ISR,(U32)taskIdCurrent );
#endif
}

U32 aos_tick_get()
{
    return m_ulAllTicks;
}


U32 aos_tick_run()
{
    return m_ulCurTicks;
}

U32 aos_cpu_performance_get(U32 *pulPerCur,U32 *pulPer5s,U32 *pulPer60s,U32 *pulPer600s)
{
    if((pulPerCur  == NULL) || 
       (pulPer5s   == NULL) || 
       (pulPer60s  == NULL) || 
       (pulPer600s == NULL))
    {
        return AOS_FAIL;
    }
#if 0
    *pulPerCur  = m_ulPerformance_cur;
    *pulPer5s   = m_ulPerformance_5s;
    *pulPer60s  = m_ulPerformance_60s;
    *pulPer600s = m_ulPerformance_600s;
#else
    if( AOS_SUCC != aos_task_performance_get( m_ulIdleTaskId, pulPerCur, pulPer5s, pulPer60s, pulPer600s ) )
    {
        return AOS_FAIL;        
    }
    *pulPerCur  = 100 - *pulPerCur;
    *pulPer5s   = 100 - *pulPer5s;
    *pulPer60s  = 100 - *pulPer60s;
    *pulPer600s = 100 - *pulPer600s;
#endif    
    return AOS_SUCC;
}


VOID ssp_tick_task()
{
    U32 event;
    U32 ticks, i;
#if( CONFIG_CPU_ARM == TRUE || CONFIG_CPU_MIPS == TRUE )
    U32 high,low;
#endif

    static U32 ticks_5s       = 0;
    static U32 ticks_60s      = 0;
    static U32 ticks_600s     = 0;
    static U32 idlecount_5s   = 0;
    static U32 idlecount_60s  = 0;
    static U32 idlecount_600s = 0;
    
    (void)ticks_5s;
    (void)ticks_60s;
    (void)ticks_600s;
    (void)idlecount_5s;
    (void)idlecount_60s;
    (void)idlecount_600s;

    m_ulCurTicks = 0;
    
    for( ;; )
    {
        dbg_track_tick_state( 0 );
        aos_event_wait( TICK_NOTIFY_EVENT, AOS_WAIT_ANY, 0, &event );
        clear_watch_dog();
        dbg_track_tick_state( 1 );
        
        ticks = m_ulCurTicks;
        m_ulCurTicks = 0;

#if( CONFIG_CPU_ARM == TRUE )
        sysGetTimeBase( &low, &high );
        AOS_U64_ADD32( &g_GlobalCpuTimeBase, (g_SysCpuTimeBase-low)&0xffffff );
        g_SysCpuTimeBase = low;
#elif( CONFIG_CPU_MIPS == TRUE )
        sysGetTimeBase( &low, &high );
        AOS_U64_ADD32( &g_GlobalCpuTimeBase, (low-g_SysCpuTimeBase)&0xffffff );
        g_SysCpuTimeBase = low;
#endif

        lcm_rapid_eth_recv_task();

#if( AOS_INCLUDE_SSP_KER_SPY == TRUE )
        
        if( ticks >= CONFIG_TICKS_ONCE_PROCESS )
        {
             aos_printf( MPE_TASK, "%d ticks lost,system inits too long(normal)"
                " or some task runs too long(abnormal)", ticks );
             ssp_show_task_switch_track();
        }
#endif

#if CONFIG_OS_WINDOWS

#elif CONFIG_OS_VXWORKS
        
        ticks_5s   += ticks;
        ticks_60s  += ticks;
        ticks_600s += ticks;
        
        idlecount_5s   += m_ulCurIdleCount;
        idlecount_60s  += m_ulCurIdleCount;
        idlecount_600s += m_ulCurIdleCount;
        
        
        if(ticks)
        {
            m_ulPerformance_cur = 100-(m_ulCurIdleCount*100*CONFIG_TICKS_PER_SECOND)/(m_ulBaseIdleCount*ticks);
            if(m_ulPerformance_cur > 100)
            {
                m_ulPerformance_cur = 100;
            }
            
            m_ulCurIdleCount =0;

            aos_task_performance(0);
        }
        else
        {
            aos_printf( MPE_TASK, "ticks is zero" );
        }

        
        {
            if( ticks_5s >= 5 *CONFIG_TICKS_PER_SECOND )
            {
                m_ulPerformance_5s = 100-idlecount_5s*20/m_ulBaseIdleCount;
                if(m_ulPerformance_5s > 100)
                {
                    m_ulPerformance_5s = 100;
                }
                
                ticks_5s     = 0;
                idlecount_5s = 0;

                aos_task_performance(5);
            }
        }

        
        {
            if( ticks_60s >= 60 *CONFIG_TICKS_PER_SECOND )
            {
                m_ulPerformance_60s = 100-(idlecount_60s*100)/(m_ulBaseIdleCount*60);
                if(m_ulPerformance_60s > 100)
                {
                    m_ulPerformance_60s = 100;
                }
                
                ticks_60s     = 0;
                idlecount_60s = 0;

                aos_task_performance(60);
            }
        }

        
        {
            if( ticks_600s >= 600 *CONFIG_TICKS_PER_SECOND )
            {
                m_ulPerformance_600s = 100-(idlecount_600s*100)/(m_ulBaseIdleCount*600);
                if(m_ulPerformance_600s > 100)
                {
                    m_ulPerformance_600s = 100;
                }
                
                ticks_600s     = 0;
                idlecount_600s = 0;

                aos_task_performance(600);
            }
        }
        
#else

#error "please config os"

#endif
        
        ssp_time_update( ticks );

        for( i=0; i< m_ulTickTaskNum; i++ )
        {
        	if( m_TickTask[i].routine )
        	{
        		m_TickTask[i].routine();
        	}
        }
        dbg_track_tick_state( 2 );
        
        SYS_HANDLE_LOCK();

#if (AOS_INCLUDE_SERVICE_FAX_D == TRUE)
        if( faxd_poll_ticking ) 
        {
            (*faxd_poll_ticking)();
        }
#endif

        ssp_timer_ticking( ticks );

        SYS_HANDLE_UNLOCK();
        
#if( CONFIG_VERSION_DEBUG == TRUE )
        ssp_has_starve_task();
#endif

    }

}

VOID ssp_idle_task(  U32 zero )
{
    for( ;; )
    {
        IDLE_LOOP( zero );
    }
}

VOID ssp_isr_task()
{
    for( ;; )
    {
        aos_tick_announce();
        aos_task_delay( 1000/CONFIG_TICKS_PER_SECOND );
    }
}

#ifdef __cplusplus
}
#endif