+
−/****************************************************************************/
+
−/*                                                                          */
+
−/*  Name        rvf_time.c                                                  */
+
−/*                                                                          */
+
−/*  Function    this file contains rvf time related functions               */
+
−/*                                                                          */
+
−/*  Version		0.1															*/
+
−/*																			*/
+
−/* 	Date       	Modification												*/
+
−/*  ------------------------------------									*/
+
−/*  3/12/99		Create														*/
+
−/*  10/27/1999  remove all non-nucleus sections (#ifdef)					*/
+
−/*	30/11/99	compliant to RV coding guidelines							*/
+
−/*  31/01/2003  Timer Redesign/Impl.RV2    Gary TOTNEY						*/
+
−/*																			*/
+
−/*	Author		David Lamy-Charrier (dlamy@tif.ti.com)						*/
+
−/*																			*/
+
−/* (C) Copyright 1999 by Texas Instruments Incorporated, All Rights Reserved*/
+
−/****************************************************************************/
+
−
+
−#include "nucleus.h" 
+
−
+
−#include "rvm/rvm_use_id_list.h"
+
−#include "rvm/rvm_i.h"	// only for MBs [coupling issue]
+
−#include "rvm/rvm_api.h"// MSG			[coupling issue]
+
−#include "rvf/rvf_i.h"
+
−#include "rvf/rvf_api.h"
+
−#include <string.h>
+
−
+
−
+
−
+
−/*
+
−** Define the time control array
+
−*/
+
−static NU_TIMER		rvf_Timer[MAX_RVF_TASKS][RVF_NUM_TASK_TIMERS];
+
−
+
−//extern T_RVF_MB_ID rvm_timer_mem_bank;
+
−
+
−#define _RALLOC_TIMER_BLK(tb) rvf_get_buf(rvm_timer_mem_bank, sizeof(NU_TIMER), tb)
+
−#define _RALLOC_TMS_MSG(id, tb) rvf_get_msg_buf(rvm_tm_notify_mem_bank, sizeof(T_RVF_TMS_MSG), id, tb)
+
−
+
−
+
−/* PRIVATE FUNC FWD DECLs   */
+
−T_RV_TM_ID _invoke_tm(T_RVF_G_ADDR_ID gid, UINT32 t, UINT8 cont, void* action, UINT8 lg);
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         _rvf_timer_expire
+
−**
+
−** Description      This internal function is called by Nucleus OS, when a task
+
−**					timer expires. It sets the corresponding event.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void _rvf_timer_expire(UNSIGNED timer_id)
+
−{ 
+
−	rvf_disable(14);
+
−	/* send the corresponding timer event */
+
−	rvf_send_event((UINT8)(timer_id / RVF_NUM_TASK_TIMERS),(UINT16)(EVENT_MASK(((timer_id % RVF_NUM_TASK_TIMERS)+4)) ) );
+
−	rvf_enable();
+
−}
+
−
+
−void _rvf_tm_notify(UNSIGNED timer_id) {
+
−	T_RVF_TM_UBLK			tmr;
+
−	T_RVF_TM_ATTRIB_UBLK	attr;
+
−	UINT32 tmid=0, cont=0, d;
+
−	OPTION	opt;
+
−	T_RVF_TMS_MSG*		 p_msg=NULL;
+
−	
+
−	if(timer_id) tmr.id=timer_id;
+
−
+
−	if(NU_Timer_Information(tmr.ptr,attr.str, &opt, (UNSIGNED*)&d, (UNSIGNED*)&tmid, (UNSIGNED*)&d, (UNSIGNED*) &cont) == NU_INVALID_TIMER) { // use to get p_attrib
+
−		rvf_send_trace ("FATAL: RVF TIMER ATTIRBUTE ERROR!",
+
−						49,
+
−						NULL_PARAM,
+
−						RV_TRACE_LEVEL_WARNING,
+
−						0);
+
−
+
−	}
+
−/*	printf("%ld %ld %d:",	attr.attrib.host_addr_id,
+
−							attr.attrib.action,
+
−							attr.attrib.legacyFlag);
+
−*/
+
−	if(!pRtAddrIdTable[attr.attrib.host_addr_id]) return; // Don't waste time in HISR			/* MUST BE REPLACED WITH CACHED MSG'ing  */
+
−
+
−	// Will utilise active caching in near future, limiting HISR duration
+
−	if((_RALLOC_TMS_MSG(RVM_TMS_MSG, (T_RVF_MSG**)&p_msg))==RVF_RED){
+
−		rvf_send_trace ("FATAL: RVF TIMER HISR: Insufficient resources!",
+
−						49,
+
−						NULL_PARAM,
+
−						RV_TRACE_LEVEL_WARNING,
+
−						0);
+
−
+
−		return; // (RV_MEMORY_ERR);
+
−	} 
+
−	p_msg->hdr.msg_id=RVM_TMS_MSG;
+
−	p_msg->tm_id=tmr.id;
+
−	p_msg->cont=cont;
+
−	p_msg->action=attr.attrib.action;
+
−	rvf_disable(14);
+
−	rvf_send_priority_msg(attr.attrib.host_addr_id, p_msg); // NOTE: must have id and recognised in FSM core
+
−	rvf_enable();
+
−}
+
−
+
−/********************************************************************************/
+
−/*                                                                              */
+
−/*    Function Name:   rvf_create_timer                                            */
+
−/*                                                                              */
+
−/*    Purpose:         This function is reponsible for stopping timers.         */
+
−/*                                                                              */                      
+
−/*    Revision History:                                                         */
+
−/*                                                                              */
+
−/********************************************************************************/
+
−T_RVF_TIMER_ID rvf_create_timer(T_RVF_G_ADDR_ID		g_addrId,
+
−							UINT32					tmDuration,
+
−							BOOLEAN					isContinuous,
+
−							void*					p_action) {
+
−	
+
−	return _invoke_tm(g_addrId, tmDuration, isContinuous, p_action, 0);
+
−}
+
−
+
−// this exists as part of an on-going initiative to deprecate rvf: start/stop timers
+
−T_RV_TM_ID _invoke_tm(T_RVF_G_ADDR_ID gid, UINT32 t, UINT8 cont, void* action, UINT8 lg) {
+
−	T_RVF_TM_UBLK			tmr;
+
−	T_RVF_TM_ATTRIB_UBLK	tm_attrib;
+
−	UINT32					re_sched=0;
+
−	OPTION					opt=NU_DISABLE_TIMER;
+
−	STATUS					status;
+
−
+
−	if(t) opt=NU_ENABLE_TIMER;
+
−	if(cont) re_sched=t;
+
−
+
−	// TO DO... ret. 0 if alloc fails
+
−	if(_RALLOC_TIMER_BLK((T_RVF_BUFFER**)&tmr.ptr)) return 0;
+
−	
+
−	tm_attrib.attrib.host_addr_id	=gid;
+
−	tm_attrib.attrib.action			=action;
+
−	tm_attrib.attrib.legacyFlag		=lg;
+
−
+
−   	status=NU_Create_Timer( tmr.ptr,			// TIMER CONTROL BLOCK
+
−							tm_attrib.str,		// timer name (overloaded)
+
−							_rvf_tm_notify,		// expiration routine to call					
+
−							tmr.id, 			// unique id which enables to find a specific task and a specific timer
+
−							t,					// duration				
+
−							re_sched,			// continuous = 1		
+
−							opt);
+
−
+
−	if(status!=NU_SUCCESS) tmr.id=0;
+
−	
+
−	return (UINT32)tmr.id;
+
−}
+
−
+
−/*T_RVF_RET rvf_get_remaining_time(T_RV_TM_ID tid, UINT32* t) {
+
−	T_RVF_TM_UBLK			tmr;
+
−
+
−	tmr.id=tid;
+
−	if(NU_Get_Remaining_Time(tmr.ptr, (UNSIGNED*)&t)==NU_INVALID_TIMER) return RV_INVALID_PARAMETER;
+
−
+
−	return RVF_OK;
+
−}*/
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_del_timer
+
−**
+
−** Description      This function is called by an application to delete a timer
+
−**                  entry from a timer list.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void rvf_del_timer(T_RV_TM_ID tm_id) {
+
−	T_RVF_TM_UBLK			tmr;
+
−
+
−	if(tm_id) tmr.id=tm_id;
+
−
+
−	NU_Control_Timer(tmr.ptr, NU_DISABLE_TIMER);
+
−	NU_Delete_Timer(tmr.ptr);
+
−	rvf_free_buf(tmr.ptr);
+
−}
+
−
+
−void rvf_reset_timer(T_RV_TM_ID tm_id, UINT32 new_duration,
+
−										BOOLEAN isContinuous) {
+
−	T_RVF_TM_UBLK			tmr;
+
−	UINT32					re_sched=0;
+
−
+
−	if(isContinuous)re_sched=new_duration;
+
−	if(tm_id)		tmr.id=tm_id;
+
−
+
−	NU_Control_Timer(tmr.ptr, NU_DISABLE_TIMER);
+
−
+
−	if(new_duration) {
+
−		NU_Reset_Timer(	tmr.ptr,
+
−						_rvf_tm_notify,
+
−						new_duration,
+
−						re_sched, 
+
−						NU_ENABLE_TIMER);
+
−	}
+
−
+
−}
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         _rvf_timers_init
+
−**
+
−** Description      This internal function is called once at startup to initialize
+
−**                  all the timer structures.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void _rvf_timers_init(void)
+
−{
+
−    UINT8   task_num, timer_num;
+
−
+
−    for (task_num = 0; task_num< MAX_RVF_TASKS; task_num++)
+
−    {
+
−		for (timer_num = 0; timer_num < RVF_NUM_TASK_TIMERS; timer_num++)
+
−		{
+
−			NU_Create_Timer(	&(rvf_Timer[task_num][timer_num]),/* TIMER CONTROL BLOCK*/
+
−								"", /* timer name */
+
−								_rvf_timer_expire, /* expiration routine to call*/					
+
−								(task_num * RVF_NUM_TASK_TIMERS) +timer_num,
+
−								/* unique id which enables to find a specific task and a specific timer*/
+
−								0,
+
−								0,
+
−								NU_DISABLE_TIMER);
+
−		}		
+
−    }
+
−}
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_get_time_stamp
+
−**
+
−** Description      This function formats the time into a user area
+
−**
+
−** Returns          the address of the user area containing the formatted time
+
−**
+
−*******************************************************************************/
+
−char *rvf_get_time_stamp(char *tbuf)
+
−{
+
−	UINT32 ms_time;
+
−	UINT32 s_time;
+
−	UINT32 m_time;
+
−	UINT32 h_time;
+
−    char   *p_out = tbuf;
+
−
+
−	ms_time = rvf_get_tick_count();
+
−	s_time  = ms_time/100;   /* 100 Ticks per second */
+
−	m_time  = s_time/60;
+
−	h_time  = m_time/60;
+
−
+
−	ms_time -= s_time*100;
+
−	s_time  -= m_time*60;
+
−	m_time  -= h_time*60;
+
−
+
−    *p_out++ = (char)((h_time / 10) + '0');
+
−    *p_out++ = (char)((h_time % 10) + '0');
+
−    *p_out++ = ':';
+
−    *p_out++ = (char)((m_time / 10) + '0');
+
−    *p_out++ = (char)((m_time % 10) + '0');
+
−    *p_out++ = ':';
+
−    *p_out++ = (char)((s_time / 10) + '0');
+
−    *p_out++ = (char)((s_time % 10) + '0');
+
−    *p_out++ = ':';
+
−    *p_out++ = (char)((ms_time / 10) + '0');
+
−    *p_out++ = (char)((ms_time % 10) + '0');
+
−    *p_out++ = ':';
+
−    *p_out   = 0;
+
−
+
−	return tbuf;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_get_tick_count
+
−**
+
−** Description      This function returns the current Nucleus system ticks
+
−**
+
−** Returns          ticks
+
−**
+
−*******************************************************************************/
+
−UINT32	rvf_get_tick_count(void)
+
−{
+
−	return NU_Retrieve_Clock();
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_start_timer
+
−**
+
−** Description      An application can call this function to start one of
+
−**                  it's four general purpose timers. Any of the four timers
+
−**                  can be 1-shot or continuous. If a timer is already running,
+
−**                  it will be reset to the new paramaters.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void rvf_start_timer (UINT8 tnum, UINT32 ticks, BOOLEAN is_continuous)
+
−{	T_RVF_G_ADDR_ID     task_id = rvf_get_taskid();
+
−	
+
−	if(tnum==RVF_TIMER_3 || tnum==RVF_TIMER_2) { // reserved for rvf timer service 
+
−		rvf_send_trace ("WARNING: Timers 2 & 3 are deprecated!",
+
−						37,
+
−						NULL_PARAM,
+
−						RV_TRACE_LEVEL_DEBUG_LOW,
+
−						0); 
+
−//		return;
+
−	}
+
−	if (!ticks) // check if ticks == 0, set it to 1 
+
−		{	ticks = 1;
+
−		}
+
−
+
−	// disable Nucleus timer 
+
−	NU_Control_Timer(	&(rvf_Timer[task_id][tnum]),
+
−						NU_DISABLE_TIMER );
+
−
+
−	// reset the timer with the new settings 
+
−	NU_Reset_Timer(	&(rvf_Timer[task_id][tnum]),
+
−					_rvf_timer_expire,
+
−					ticks,
+
−					is_continuous? ticks:0, // if timer is continuous, reload it 
+
−					NU_ENABLE_TIMER);
+
−}
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_stop_timer
+
−**
+
−** Description      An application can call this function to stop one of
+
−**                  it's four general purpose timers. There is no harm in
+
−**                  stopping a timer that is already stopped.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void rvf_stop_timer (UINT8 tnum)
+
−{	T_RVF_G_ADDR_ID  task_id = rvf_get_taskid();
+
−
+
−	/* disable Nucleus timer */
+
−	NU_Control_Timer(	&(rvf_Timer[task_id][tnum]),
+
−						NU_DISABLE_TIMER );
+
−}
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_init_timer_list
+
−**
+
−** Description      This function is called by applications when they
+
−**                  want to initialize a timer list.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void rvf_init_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq)
+
−{
+
−    p_timer_listq->p_first    = NULL;
+
−    p_timer_listq->p_last     = NULL;
+
−    p_timer_listq->last_ticks = 0;
+
−}
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_init_timer_list_entry
+
−**
+
−** Description      This function is called by the applications when they
+
−**                  want to initialize a timer list entry. This must be
+
−**                  done prior to first use of the entry.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void rvf_init_timer_list_entry (T_RVF_TIMER_LIST_ENT  *p_tle)
+
−{
+
−    p_tle->p_next  = NULL;
+
−    p_tle->p_prev  = NULL;
+
−    p_tle->ticks   = 0xFFFFFFFFL;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_update_timer_list
+
−**
+
−** Description      This function is called by the applications when they
+
−**                  want to update a timer list. This should be at every
+
−**                  timer list unit tick, e.g. once per sec, once per minute etc.
+
−**
+
−** Returns          the number of timers that have expired
+
−**
+
−*******************************************************************************/
+
−UINT16 rvf_revise_timer_list (T_RVF_G_ADDR_ID gid){
+
−	if(!pRtAddrIdTable[gid] );
+
−//	   !pRtAddrIdTable[gid]->p_tm_q ||
+
−//		pRtAddrIdTable[gid]->p_tm_q->timerCnt==0 ||
+
−//		pRtAddrIdTable[gid]->polling_tm!=0 ) return 0;			/* rvf abort     */
+
−//	return rvf_update_timer_list(pRtAddrIdTable[gid]->p_tm_q);	/* tms notify    */
+
−	return 0;
+
−}
+
−UINT16 rvf_update_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq)
+
−{
+
−    T_RVF_TIMER_LIST_ENT  *p_tle;
+
−    UINT16          num_time_out = 0;
+
−
+
−    p_tle = p_timer_listq->p_first;
+
−
+
−    /* First, get the guys who have previously timed out */
+
−    while ((p_tle) && (p_tle->ticks == 0))
+
−    {
+
−        num_time_out++;
+
−        p_tle = p_tle->p_next;
+
−    }
+
−
+
−    /* Now, get the guys who have just timed out */
+
−    if ((p_tle) && (p_tle->ticks))
+
−    {
+
−        if (--p_tle->ticks == 0)
+
−        {
+
−            while (p_tle != NULL && p_tle->ticks == 0)
+
−            {
+
−                num_time_out++;
+
−                p_tle = p_tle->p_next;
+
−            }
+
−        }
+
−    }
+
−
+
−    if (p_timer_listq->last_ticks)
+
−        p_timer_listq->last_ticks--;
+
−
+
−    return (num_time_out);
+
−}
+
−
+
−
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_add_to_timer_list
+
−**
+
−** Description      This function is called by an application to add a timer
+
−**                  entry to a timer list.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void rvf_add_to_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq, T_RVF_TIMER_LIST_ENT  *p_tle)
+
−{
+
−    UINT32           nr_ticks_total;
+
−    T_RVF_TIMER_LIST_ENT  *p_temp;
+
−
+
−    if (p_tle->ticks >= p_timer_listq->last_ticks)
+
−    {
+
−        if (p_timer_listq->p_first == NULL)
+
−            p_timer_listq->p_first = p_tle;
+
−        else
+
−        {
+
−            if (p_timer_listq->p_last != NULL)
+
−                p_timer_listq->p_last->p_next = p_tle;
+
−
+
−            p_tle->p_prev = p_timer_listq->p_last;
+
−        }
+
−
+
−        p_tle->p_next = NULL;
+
−        p_timer_listq->p_last = p_tle;
+
−        nr_ticks_total = p_tle->ticks;
+
−        p_tle->ticks = p_tle->ticks - p_timer_listq->last_ticks;
+
−
+
−        p_timer_listq->last_ticks = nr_ticks_total;
+
−    }
+
−    else
+
−    {
+
−        p_temp = p_timer_listq->p_first;
+
−        while (p_tle->ticks > p_temp->ticks)
+
−        {
+
−            p_tle->ticks = p_tle->ticks - p_temp->ticks;
+
−            p_temp = p_temp->p_next;
+
−        }
+
−        if (p_temp == p_timer_listq->p_first)
+
−        {
+
−            p_tle->p_next = p_timer_listq->p_first;
+
−            p_timer_listq->p_first->p_prev = p_tle;
+
−            p_timer_listq->p_first = p_tle;
+
−        }
+
−        else
+
−        {
+
−            p_temp->p_prev->p_next = p_tle;
+
−            p_tle->p_prev = p_temp->p_prev;
+
−            p_temp->p_prev = p_tle;
+
−            p_tle->p_next = p_temp;
+
−        }
+
−        p_temp->ticks = p_temp->ticks - p_tle->ticks;
+
−    }
+
−}
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_remove_from_timer_list
+
−**
+
−** Description      This function is called by an application to remove a timer
+
−**                  entry from a timer list.
+
−**
+
−** Returns          void
+
−**
+
−*******************************************************************************/
+
−void rvf_remove_from_timer_list (T_RVF_TIMER_LIST_Q *p_timer_listq, T_RVF_TIMER_LIST_ENT  *p_tle)
+
−{
+
−    if (p_tle == NULL || p_tle->ticks == 0xFFFFFFFFL || p_timer_listq->p_first == NULL)
+
−    {
+
−        return;
+
−    }
+
−
+
−    /* Add the ticks remaining in this timer to the next guy in the list.
+
−    */
+
−    if (p_tle->p_next != NULL)
+
−    {
+
−        p_tle->p_next->ticks += p_tle->ticks;
+
−    }
+
−    else
+
−    {
+
−        p_timer_listq->last_ticks -= p_tle->ticks;
+
−    }
+
−
+
−    /* Unlink timer from the list.
+
−    */
+
−    if (p_timer_listq->p_first == p_tle)
+
−    {
+
−        p_timer_listq->p_first = p_tle->p_next;
+
−
+
−        if (p_timer_listq->p_first != NULL)
+
−            p_timer_listq->p_first->p_prev = NULL;
+
−
+
−        if (p_timer_listq->p_last == p_tle)
+
−            p_timer_listq->p_last = NULL;
+
−    }
+
−    else
+
−    {
+
−        if (p_timer_listq->p_last == p_tle)
+
−        {
+
−            p_timer_listq->p_last = p_tle->p_prev;
+
−
+
−            if (p_timer_listq->p_last != NULL)
+
−                p_timer_listq->p_last->p_next = NULL;
+
−        }
+
−        else
+
−        {
+
−            if (p_tle->p_next != NULL && p_tle->p_next->p_prev == p_tle)
+
−                p_tle->p_next->p_prev = p_tle->p_prev;
+
−            else
+
−            {
+
−                /* Error case - chain messed up ?? */
+
−                return;
+
−            }
+
−
+
−            if (p_tle->p_prev != NULL && p_tle->p_prev->p_next == p_tle)
+
−                p_tle->p_prev->p_next = p_tle->p_next;
+
−            else
+
−            {
+
−                /* Error case - chain messed up ?? */
+
−                return;
+
−            }
+
−        }
+
−    }
+
−
+
−    p_tle->p_next = p_tle->p_prev = NULL;
+
−    p_tle->ticks = 0xFFFFFFFFL;
+
−}
+
−
+
−
+
−/*******************************************************************************
+
−**
+
−** Function         rvf_get_expired_entry
+
−**
+
−** Description      This function returns a pointer to the first expired entry in
+
−**					the timer list queue.
+
−**					If no entry in the queue has expired, it returns NULL.
+
−**
+
−** Returns          T_RVF_TIMER_LIST_ENT * : pointer to the expired entry if any.
+
−**
+
−*******************************************************************************/
+
−T_RVF_TIMER_LIST_ENT * rvf_get_expired_entry (T_RVF_TIMER_LIST_Q *p_timer_listq)
+
−{	
+
−	T_RVF_TIMER_LIST_ENT * p_tle;
+
−	/* test if the first entry in the queue has expired */
+
−	if ( (p_timer_listq->p_first != NULL) && (p_timer_listq->p_first->ticks == 0) )
+
−	{	
+
−
+
−		p_tle = p_timer_listq->p_first;
+
−		if(p_tle->t_init) {
+
−			p_tle->ticks=p_tle->t_init;
+
−		} else {
+
−			/* unlink entry from the list */
+
−			p_timer_listq->p_first = p_tle->p_next;
+
−
+
−			if (p_timer_listq->p_first != NULL)
+
−				p_timer_listq->p_first->p_prev = NULL;
+
−
+
−			if (p_timer_listq->p_last == p_tle)
+
−				p_timer_listq->p_last = NULL;
+
−			
+
−			p_tle->p_next = NULL;
+
−			p_tle->p_prev = NULL;
+
−			p_tle->ticks = 0xFFFFFFFFL;
+
−			//return p_tle;
+
−		}
+
−		return p_tle;
+
−	}
+
−	else
+
−	{	return NULL;
+
−	}
+
−}
+
−
+
−
+
−
+
−
+
−
+
−
+
−
+
−
+
−