//////////////////////////////////////////////////
//Title    : wxc_timer.c
//Auhtor   : Liu Wei
//Desc     : WXC2 Public Timer Managemnet 
//Created  : 2007-04-27
//Revision :
//
//Revision :
//
//////////////////////////////////////////////////

#include "./include/pub_timer.h"

/*@ignore@*/
///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

//by simon at 23/9/25
u8  TMHeap[TMHEAP_MM_SIZE];
WxcTimerNode tTimerListHead;
WxcTimerNode *pTLHead;
WxcTimerNode *pTLCur;

extern void TimerAdd ( WxcTimer * pTimer )
{
    WxcTimerNode *pTNode;

    assert ( NULL != pTimer && NULL != pTimer->pFunc );
    assert ( pTimer->dExpires && pTimer->dSuitNumber < TM_CLOCK_MAX );

    //pTimer->dSuitNumber = ? : 1;

    pTNode =
        ( WxcTimerNode * ) WxcMalloc ( GET_TNODE_SIZE ( pTimer->dSuitNumber ) );
    if( NULL == pTNode )
    {
    	return ;
    }
    pTNode->pNext = NULL;
    pTNode->pPrev = pTLCur;
    pTNode->pTimer = ( WxcTimer * ) ( pTNode + 4 * sizeof ( void * ) );
    pTimer->pTimerNode = ( void * ) pTNode;
    memcpy ( pTNode->pTimer, pTimer, sizeof ( WxcTimer ) );
    pTNode->dClockArray = ( u32 * ) ( pTNode->pTimer + sizeof ( WxcTimer ) );
    pTLCur = pTNode;
}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

inline void TimerStart ( WxcTimer * pTimer, u16 dSuitId )
{
    assert ( pTimer && pTimer->pTimerNode );
    assert ( dSuitId < pTimer->dSuitNumber );

    ( ( WxcTimerNode * ) pTimer->pTimerNode )->dClockArray[dSuitId] = 1;
}

extern void TimerMod ( WxcTimer * pTimer, u16 dExpires )
{
    int     i;

    assert ( NULL != pTimer && dExpires );

    pTimer->dExpires = dExpires;
    for ( i = 0; i < pTimer->dSuitNumber; i++ )
    {
        TimerStart ( pTimer, i );
    }
}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

extern void TimerDel ( WxcTimer * pTimer )
{
    assert ( pTimer && pTimer->pTimerNode );

    WxcFree ( pTimer->pTimerNode );
    pTimer->pTimerNode = NULL;
}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

extern inline void TimerStop ( WxcTimer * pTimer, u16 dSuitId )
{
    assert ( NULL != pTimer && dSuitId < pTimer->dSuitNumber );

    ( ( WxcTimerNode * ) pTimer->pTimerNode )->dClockArray[dSuitId] = 0;
}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

#define TimerRestart(pTimer)  TimerStart(pTimer)

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

static void *TM_Alloc ( u16 dSize )
{

}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

static void TM_Free ( void *p )
{

}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

static inline int TM_Pending ( WxcTimerNode * pTNode, u16 dSuitId )
{
    return ( pTNode->dClockArray[dSuitId] ? 1 : 0 );
}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

static inline int TM_Expiring ( WxcTimerNode * pTNode, u16 dSuitId )
{
    return ( TimerAfter
             ( pTNode->dClockArray[dSuitId], pTNode->pTimer->dExpires ) );
}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

extern inline void TM_Init (  )
{
    pTLCur = pTLHead = &tTimerListHead;
}

///////////////////////////////////////////////////////////////////////////
//                                                                      ///
///////////////////////////////////////////////////////////////////////////

extern void TM_RT (  )
{
    u16     sid;
    WxcTimer *pTimer;
    WxcTimerNode *pTNode;

    pTNode = pTLHead;

    for ( ; NULL != pTNode; pTNode = pTNode->pNext )
    {
        pTimer = pTNode->pTimer;
        for ( sid = 0; sid <= pTimer->dSuitNumber; sid++ )
        {
            if ( !TM_Pending ( pTNode, sid ) )
            {
                pTNode->dClockArray[sid]++;
                if ( TM_Expiring ( pTNode, sid ) )
                {
                    pTimer->pFunc ( pTimer->dData, sid );
                }
            }
        }
    }
}

/*@end@*/