FreeCalypso > hg > fc-magnetite
view src/cs/riviera/rvf/rvf_time.c @ 159:5184c0ba4574
sim_b_lib.lib compiles
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Tue, 11 Oct 2016 00:26:19 +0000 |
parents | 945cf7f506b2 |
children |
line wrap: on
line source
/****************************************************************************/ /* */ /* 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; } }