FreeCalypso > hg > freecalypso-sw
diff gsm-fw/nucleus/tmc.c @ 143:afceeeb2cba1
Our nuc-fw is destined to become gsm-fw, so I went ahead and did the big hg mv
| author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
|---|---|
| date | Tue, 12 Nov 2013 05:35:48 +0000 |
| parents | nuc-fw/nucleus/tmc.c@947b1f473960 |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/nucleus/tmc.c Tue Nov 12 05:35:48 2013 +0000 @@ -0,0 +1,944 @@ +/*************************************************************************/ +/* */ +/* Copyright Mentor Graphics Corporation 2002 */ +/* All Rights Reserved. */ +/* */ +/* THIS WORK CONTAINS TRADE SECRET AND PROPRIETARY INFORMATION WHICH IS */ +/* THE PROPERTY OF MENTOR GRAPHICS CORPORATION OR ITS LICENSORS AND IS */ +/* SUBJECT TO LICENSE TERMS. */ +/* */ +/*************************************************************************/ + +/*************************************************************************/ +/* */ +/* FILE NAME VERSION */ +/* */ +/* tmc.c Nucleus PLUS 1.14 */ +/* */ +/* COMPONENT */ +/* */ +/* TM - Timer Management */ +/* */ +/* DESCRIPTION */ +/* */ +/* This file contains the core routines for the timer management */ +/* component. */ +/* */ +/* DATA STRUCTURES */ +/* */ +/* None */ +/* */ +/* FUNCTIONS */ +/* */ +/* TMC_Init_Task_Timer Initialize task timer */ +/* TMC_Start_Task_Timer Start task timer */ +/* TMC_Stop_Task_Timer Stop task timer */ +/* TMC_Start_Timer Actually start a timer */ +/* TMC_Stop_Timer Actually stop a timer */ +/* TMC_Timer_HISR Timer High-Level Interrupt */ +/* Service Routine (HISR) */ +/* TMC_Timer_Expiration Timer expiration function */ +/* */ +/* DEPENDENCIES */ +/* */ +/* cs_extr.h Common Service functions */ +/* tc_extr.h Thread Control functions */ +/* tm_extr.h Timer functions */ +/* hi_extr.h History functions */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* 08-09-1993 Corrected the following problems */ +/* - Moved sleep, timeout, and */ +/* application timer expiration */ +/* processing to system timer */ +/* HISR. Removed timer task */ +/* logic */ +/* - Corrected a disable timer */ +/* problem that caused a delay */ +/* in subsequent timer */ +/* expiration */ +/* - Corrected the application */ +/* timer ID returned by the */ +/* timer information service */ +/* Corrected the loop to return */ +/* all application timer */ +/* pointers */ +/* - Corrected timer expiration */ +/* while accessing from an LISR */ +/* - Using the task time slice ptr */ +/* instead of the time slice */ +/* state flag */ +/* Modifications resulted in */ +/* version 1.0a */ +/* 08-09-1993 Verified version 1.0a */ +/* 03-01-1994 Moved non-core functions into */ +/* supplemental files, modified */ +/* protection logic to use system */ +/* protect mechanism, removed the */ +/* disable timer logic in start */ +/* timer, insured valid time- */ +/* slice task pointer, added */ +/* register logic, resulting */ +/* in version 1.1 */ +/* */ +/* 3-18-1994 Verified version 1.1 */ +/* 08-25-95 Made the following changes */ +/* */ +/* +INT type = 0; Type of expiration */ +/* +VOID *pointer = NU_NULL; Pointer type */ +/* +UNSIGNED id = 0; Application timer ID */ +/* -INT type; Type of expiration */ +/* -VOID *pointer; Pointer type */ +/* -UNSIGNED id; Application timer ID */ +/* Expiration routine ptr */ +/* +VOID (*expiration_routine)(UNSIGNED)= NU_NULL; */ +/* -VOID (*expiration_routine)(UNSIGNED); */ +/* 04-17-1996 updated to version 1.2 */ +/* 03-24-1998 Released version 1.3. */ +/* 03-26-1999 Released 1.11m (new release */ +/* numbering scheme) */ +/* 04-17-2002 Released version 1.13m */ +/* 11-07-2002 Released version 1.14 */ +/*************************************************************************/ +#define NU_SOURCE_FILE + + +#include "cs_extr.h" /* Common service functions */ +#include "tc_extr.h" /* Thread control functions */ +#include "tm_extr.h" /* Timer functions */ +#include "hi_extr.h" /* History functions */ + + +/* Define external inner-component global data references. */ + +extern TM_TCB *TMD_Active_Timers_List; +extern INT TMD_Active_List_Busy; +extern UNSIGNED TMD_System_Clock; +extern UNSIGNED TMD_Timer_Start; +extern UNSIGNED TMD_Timer; +extern INT TMD_Timer_State; +extern UNSIGNED TMD_Time_Slice; +extern TC_TCB *TMD_Time_Slice_Task; +extern INT TMD_Time_Slice_State; + + +/* Define internal function prototypes. */ + +VOID TMC_Start_Timer(TM_TCB *timer, UNSIGNED time); +VOID TMC_Stop_Timer(TM_TCB *timer); +VOID TMC_Timer_Expiration(VOID); +UNSIGNED TMT_Read_Timer(VOID); +VOID TMT_Enable_Timer(UNSIGNED time); +VOID TMT_Disable_Timer(VOID); + + + +/*************************************************************************/ +/* */ +/* FUNCTION */ +/* */ +/* TMC_Init_Task_Timer */ +/* */ +/* DESCRIPTION */ +/* */ +/* This function is responsible for initializing the supplied task */ +/* timer. This routine must be called from Supervisor mode in a */ +/* Supervisor/User mode switching kernel. */ +/* */ +/* CALLED BY */ +/* */ +/* TCC_Create_Task Task create function */ +/* */ +/* CALLS */ +/* */ +/* None */ +/* */ +/* INPUTS */ +/* */ +/* timer Timer control block pointer */ +/* information Information pointer - always */ +/* the task pointer */ +/* */ +/* OUTPUTS */ +/* */ +/* None */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* */ +/*************************************************************************/ +VOID TMC_Init_Task_Timer(TM_TCB *timer, VOID *information) +{ + + /* Initialize the task timer. */ + timer -> tm_timer_type = TM_TASK_TIMER; + timer -> tm_information = information; + timer -> tm_next_timer = NU_NULL; + timer -> tm_previous_timer = NU_NULL; +} + + +/*************************************************************************/ +/* */ +/* FUNCTION */ +/* */ +/* TMC_Start_Task_Timer */ +/* */ +/* DESCRIPTION */ +/* */ +/* This function is responsible for starting a task timer. Note */ +/* that there are some special protection considerations since */ +/* this function is called from the task control component. This */ +/* routine must be called from Supervisor mode in a Supervisor/User */ +/* mode switching kernel. */ +/* */ +/* CALLED BY */ +/* */ +/* TCC_Suspend_Task Suspend task with a timeout */ +/* */ +/* CALLS */ +/* */ +/* TMC_Start_Timer Start the timer */ +/* */ +/* INPUTS */ +/* */ +/* timer Timer control block pointer */ +/* time Time associated with timer */ +/* */ +/* OUTPUTS */ +/* */ +/* None */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* 03-01-1994 Removed protection logic since */ +/* system protect is in force at */ +/* the time this function is */ +/* called, resulting in */ +/* version 1.1 */ +/* */ +/* 03-18-1994 Verified version 1.1 */ +/* */ +/*************************************************************************/ +VOID TMC_Start_Task_Timer(TM_TCB *timer, UNSIGNED time) +{ + + /* Start the specified timer. */ + TMC_Start_Timer(timer, time); +} + + +/*************************************************************************/ +/* */ +/* FUNCTION */ +/* */ +/* TMC_Stop_Task_Timer */ +/* */ +/* DESCRIPTION */ +/* */ +/* This function is responsible for stopping a task timer. Note */ +/* that there are some special protection considerations since */ +/* this function is called from the task control component. This */ +/* routine must be called from Supervisor mode in a Supervisor/User */ +/* mode switching kernel. */ +/* */ +/* CALLED BY */ +/* */ +/* TCC_Resume_Task Resume task function */ +/* TCC_Terminate_Task Terminate task function */ +/* */ +/* CALLS */ +/* */ +/* TMC_Stop_Timer Stop the timer */ +/* */ +/* INPUTS */ +/* */ +/* timer Timer control block pointer */ +/* */ +/* OUTPUTS */ +/* */ +/* None */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* 03-01-1994 Removed protection logic since */ +/* system protect is in force at */ +/* the time this function is */ +/* called, resulting in */ +/* version 1.1 */ +/* */ +/* 03-18-1994 Verified version 1.1 */ +/* */ +/*************************************************************************/ +VOID TMC_Stop_Task_Timer(TM_TCB *timer) +{ + + /* Stop the specified timer - if it is still active. */ + if (timer -> tm_next_timer) + + TMC_Stop_Timer(timer); +} + + +/*************************************************************************/ +/* */ +/* FUNCTION */ +/* */ +/* TMC_Start_Timer */ +/* */ +/* DESCRIPTION */ +/* */ +/* This function is responsible for starting both application and */ +/* task timers. This routine must be called from Supervisor mode */ +/* in a Supervisor/User mode switching kernel. */ +/* */ +/* CALLED BY */ +/* */ +/* TMC_Control_Timer Control application timer */ +/* TMC_Start_Task_Timer Start task timer */ +/* */ +/* CALLS */ +/* */ +/* TMT_Read_Timer Read current timer counter */ +/* TMT_Adjust_Timer Adjust the count-down timer */ +/* TMT_Enable_Timer Enable count-down timer */ +/* */ +/* INPUTS */ +/* */ +/* timer Timer control block pointer */ +/* time Time associated with timer */ +/* */ +/* OUTPUTS */ +/* */ +/* None */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* 08-09-1993 Added logic to check for timer */ +/* expiration before or during */ +/* another LISR's access, */ +/* resulting in version 1.0a */ +/* 08-09-1993 Verified version 1.0a */ +/* 03-01-1994 Removed disable timer logic to */ +/* insure there is no timer loss, */ +/* added register logic, */ +/* resulting in version 1.1 */ +/* */ +/* 03-18-1994 Verified version 1.1 */ +/* */ +/*************************************************************************/ +VOID TMC_Start_Timer(TM_TCB *timer, UNSIGNED time) +{ + +R1 TM_TCB *list_ptr; /* Working pointer timer ptr */ +UNSIGNED elapsed; /* Elapsed time variable */ +INT done; /* Search finished flag */ + + + /* Note that protection over the active timer list is in force when this + function is called. */ + + /* Determine if the active list is empty. */ + if (TMD_Active_Timers_List == NU_NULL) + { + + /* Place the timer on an empty list. */ + timer -> tm_next_timer = timer; + timer -> tm_previous_timer = timer; + + /* Link the timer to the list head. */ + TMD_Active_Timers_List = timer; + + /* Setup the actual count-down timer structures. */ + TMD_Timer_Start = time; + timer -> tm_remaining_time = time; + + + /* BUG FIX FOR NU_RESET WITH INITIAL TIME OF 0 */ + /* Determine if there is any time remaining on the timer. + If so, enable the timer. Otherwise, the Timer HISR is + already pending, so skip starting the timer again. */ + + if (time != 0) + /* Start the actual count-down timer. */ + TMT_Enable_Timer(TMD_Timer_Start); + else + TMD_Timer_State = TM_EXPIRED; + + } + else + { + + /* Place the new timer into the list. */ + + /* Pickup the head of the list. */ + list_ptr = TMD_Active_Timers_List; + + /* Determine if the timer is being added while the timer + expiration task is running. If so, don't attempt to adjust + the expiration list. If not, adjust the list. */ + if (!TMD_Active_List_Busy) + { + + /* Calculate the elapsed amount of time from the last timer + request. */ + elapsed = TMD_Timer_Start - TMT_Read_Timer(); + + /* Adjust the first entry in the timer list and the timer + start value accordingly. */ + TMD_Timer_Start = TMD_Timer_Start - elapsed; + + /* Make sure the remaining time is never below zero. */ + if (list_ptr -> tm_remaining_time > elapsed) + { + list_ptr -> tm_remaining_time = list_ptr -> tm_remaining_time + - elapsed; + } + else + { + list_ptr -> tm_remaining_time = 0; + } + + + } + + /* At this point the timer list is accurate again. Find the + appropriate place on the timer list for the new timer. */ + + /* Determine where to place the timer in the list. */ + done = NU_FALSE; + do + { + + /* Determine if the timer belongs before the current timer + pointed to by list_ptr. */ + if (time < list_ptr -> tm_remaining_time) + { + + /* Update the time of the next timer. */ + list_ptr -> tm_remaining_time = + list_ptr -> tm_remaining_time - time; + + /* Determine if an insertion at the head of the list is + present. */ + if (list_ptr == TMD_Active_Timers_List) + + /* Move the list head to the new timer. */ + TMD_Active_Timers_List = timer; + + /* Set the done flag to end the search. */ + done = NU_TRUE; + } + else + { + + /* Decrement the time by the remaining value of each timer in + the list. In this way, the list never has to be searched + again. */ + time = time - list_ptr -> tm_remaining_time; + + /* Move the list pointer to the next timer in the list. */ + list_ptr = list_ptr -> tm_next_timer; + + /* Check to see if the list has wrapped around. */ + if (list_ptr == TMD_Active_Timers_List) + + /* Searching is done. */ + done = NU_TRUE; + } + } while (!done); + + /* Link the new timer into the list. */ + timer -> tm_next_timer = list_ptr; + timer -> tm_previous_timer = list_ptr -> tm_previous_timer; + (list_ptr -> tm_previous_timer) -> tm_next_timer = timer; + list_ptr -> tm_previous_timer = timer; + + /* Update the remaining time parameter. */ + timer -> tm_remaining_time = time; + + /* Determine if a new timer should be started. */ + if (!TMD_Active_List_Busy) + { + + /* Calculate the new timer expiration. */ + time = TMD_Active_Timers_List -> tm_remaining_time; + + /* Determine if the new expiration is less than the current + time, if any. If not, let already started time expire. */ + if (time <= TMD_Timer_Start) + { + + /* Setup for a smaller timer expiration. */ + TMD_Timer_Start = time; + + /* Determine if there is any time remaining on the timer in + the front of the list. If so, adjust the timer. + Otherwise, the Timer HISR is already pending, so skip + starting the timer again. */ + if (TMD_Timer_Start) + + /* Still some remaining time, adjust the timer. */ + TMT_Adjust_Timer(TMD_Timer_Start); + else + + /* Indicate that the task and application timer has + expired. */ + TMD_Timer_State = TM_EXPIRED; + } + } + } +} + + +/*************************************************************************/ +/* */ +/* FUNCTION */ +/* */ +/* TMC_Stop_Timer */ +/* */ +/* DESCRIPTION */ +/* */ +/* This function is responsible for stopping both application and */ +/* task timers. This routine must be called from Supervisor mode */ +/* in a Supervisor/User mode switching kernel. */ +/* */ +/* CALLED BY */ +/* */ +/* TMC_Control_Timer Control application timer */ +/* TMC_Stop_Task_Timer Start task timer */ +/* */ +/* CALLS */ +/* */ +/* TMT_Disable_Timer Disable the count-down timer */ +/* */ +/* INPUTS */ +/* */ +/* timer Timer control block pointer */ +/* */ +/* OUTPUTS */ +/* */ +/* None */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* 08-09-1993 Corrected a problem associated */ +/* with stopping the last timer */ +/* on the active list, resulting */ +/* in version 1.0a */ +/* 08-09-1993 Verified version 1.0a */ +/* */ +/*************************************************************************/ +VOID TMC_Stop_Timer(TM_TCB *timer) +{ + + /* Note that the active timer list is already under protection. */ + + /* If the next neighbor of the timer that needs to be stopped is not the + head of the timer list, add the remaining time field to the remaining + time of the next neighbor. */ + if ((timer -> tm_next_timer) != TMD_Active_Timers_List) + + /* Adjust the next neighbor's remaining time field. */ + (timer -> tm_next_timer) -> tm_remaining_time = + (timer -> tm_next_timer) -> tm_remaining_time + + timer -> tm_remaining_time; + + /* Unlink the timer from the active list. */ + if (timer -> tm_next_timer == timer) + { + /* Only timer on the list. */ + TMD_Active_Timers_List = NU_NULL; + + /* Disable the timer. */ + TMT_Disable_Timer(); + } + else + { + + /* More than one timer on the list. */ + (timer -> tm_previous_timer) -> tm_next_timer = timer -> tm_next_timer; + (timer -> tm_next_timer) -> tm_previous_timer = + timer -> tm_previous_timer; + + /* Determine if the timer is at the head of the list. */ + if (TMD_Active_Timers_List == timer) + + /* Yes, move the head pointer to the next timer. */ + TMD_Active_Timers_List = timer -> tm_next_timer; + } + + /* Clear the timer's next and previous pointers. */ + timer -> tm_next_timer = NU_NULL; + timer -> tm_previous_timer = NU_NULL; +} + + +/*************************************************************************/ +/* */ +/* FUNCTION */ +/* */ +/* TMC_Timer_HISR */ +/* */ +/* DESCRIPTION */ +/* */ +/* This function is responsible for High-Level interrupt processing */ +/* of a timer expiration. If an application timer has expired, */ +/* the timer expiration function is called. Otherwise, if the */ +/* time-slice timer has expired, time-slice processing is invoked. */ +/* */ +/* CALLED BY */ +/* */ +/* None */ +/* */ +/* CALLS */ +/* */ +/* TCC_Time_Slice Task time-slice processing */ +/* TMC_Timer_Expiration Timer expiration processing */ +/* TMT_Retrieve_TS_Task Retrieve time-sliced task ptr*/ +/* */ +/* INPUTS */ +/* */ +/* None */ +/* */ +/* OUTPUTS */ +/* */ +/* None */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* 08-09-1993 Added sleep, timeout, and */ +/* application timer expiration */ +/* processing to the timer HISR, */ +/* using time slice task pointer */ +/* instead of state flag, */ +/* resulting in version 1.0a */ +/* 08-09-1993 Verified version 1.0a */ +/* 03-01-1994 Modified function interface to */ +/* TCC_Time_Slice, added logic to */ +/* insure valid pointer for some */ +/* ports, resulting in version 1.1 */ +/* */ +/* 03-18-1994 Verified version 1.1 */ +/* */ +/*************************************************************************/ +VOID TMC_Timer_HISR(VOID) +{ + +NU_TASK *task; /* Time slice task. */ + + + /* Determine if the task timer has expired. */ + if (TMD_Timer_State == TM_EXPIRED) + + /* Resume the timer task. */ + TMC_Timer_Expiration(); + + /* Determine if the time-slice timer has expired. */ + task = TMT_Retrieve_TS_Task(); + if (task) + { + NU_SUPERV_USER_VARIABLES + + /* Switch to supervisor mode + + Note that this HISR function can make the switch to supervisor mode + this is only possible because the code lives within the kernel */ + NU_SUPERVISOR_MODE(); + + /* Reset the time-slice state. */ + TMD_Time_Slice_State = TM_NOT_ACTIVE; + + /* Process the time-slice. */ + TCC_Time_Slice(task); + + /* Clear the time slice task pointer. */ + TMD_Time_Slice_Task = NU_NULL; + + /* Return to user mode */ + NU_USER_MODE(); + } +} + + +/*************************************************************************/ +/* */ +/* FUNCTION */ +/* */ +/* TMC_Timer_Expiration */ +/* */ +/* DESCRIPTION */ +/* */ +/* This function is responsible for processing all task timer */ +/* expirations. This includes application timers and basic task */ +/* timers that are used for task sleeping and timeouts. */ +/* */ +/* CALLED BY */ +/* */ +/* None */ +/* */ +/* CALLS */ +/* */ +/* expiration_function Application specified timer */ +/* expiration function */ +/* TCC_Task_Timeout Task timeout function */ +/* TCT_System_Protect Protect active timer list */ +/* TCT_Unprotect Release protection of list */ +/* TMC_Stop_Timer Stop timer */ +/* TMC_Start_Timer Start timer */ +/* TMT_Disable_Timer Disable timer */ +/* TMT_Enable_Timer Enable timer */ +/* */ +/* INPUTS */ +/* */ +/* None */ +/* */ +/* OUTPUTS */ +/* */ +/* None */ +/* */ +/* HISTORY */ +/* */ +/* DATE REMARKS */ +/* */ +/* 03-01-1993 Created initial version 1.0 */ +/* 04-19-1993 Verified version 1.0 */ +/* 08-09-1993 Changed from TMC_Timer_Task to */ +/* TMC_Timer_Expiration, */ +/* resulting in version 1.0a */ +/* 08-09-1993 Verified version 1.0a */ +/* 03-01-1994 Modified function interface to */ +/* TCC_Task_Timeout, changed */ +/* protection logic to use system */ +/* protetion, added register */ +/* logic, resulting in version 1.1 */ +/* */ +/* 03-18-1994 Verified version 1.1 */ +/* 08-25-95 Made the following changes */ +/* */ +/* +INT type = 0; Type of expiration */ +/* +VOID *pointer = NU_NULL; Pointer type */ +/* +UNSIGNED id = 0; Application timer ID */ +/* -INT type; Type of expiration */ +/* -VOID *pointer; Pointer type */ +/* -UNSIGNED id; Application timer ID */ +/* Expiration routine ptr */ +/* +VOID (*expiration_routine)(UNSIGNED)= NU_NULL; */ +/* -VOID (*expiration_routine)(UNSIGNED); */ +/* */ +/*************************************************************************/ +VOID TMC_Timer_Expiration(VOID) +{ + +R1 TM_TCB *timer; /* Pointer to timer */ +R2 TM_APP_TCB *app_timer; /* Pointer to app timer */ +INT done; /* Expiration completion */ +INT type = 0; /* Type of expiration */ +VOID *pointer = NU_NULL; /* Pointer type */ +UNSIGNED id = 0; /* Application timer ID */ + /* Expiration routine ptr */ +VOID (*expiration_routine)(UNSIGNED)= NU_NULL; +NU_SUPERV_USER_VARIABLES + + /* Switch to supervisor mode */ + NU_SUPERVISOR_MODE(); + + /* Use system protect to protect the active timer list. */ + TCT_System_Protect(); + + /* Reset the timer state flag. */ + TMT_Disable_Timer(); + + /* Set the busy flag to indicate that the list is being processed. */ + TMD_Active_List_Busy = NU_TRUE; + + /* Update the head of the list with the timer expiration + value. */ + timer = TMD_Active_Timers_List; + if (timer) + { + + /* Adjust the active timer's remaining time value. Note that + TMD_Timer_Start is never greater than the value in the first + timer location. */ + if (timer -> tm_remaining_time > TMD_Timer_Start) + + /* Timer has not expired. Simply subtract the last timer + value. */ + timer -> tm_remaining_time = timer -> tm_remaining_time - + TMD_Timer_Start; + else + + /* Clear the remaining time field of the timer. */ + timer -> tm_remaining_time = 0; + } + + /* Release protection, but keep the busy flag set to prevent + activating new timers. */ + TCT_Unprotect(); + + + /* Find expired timers. Note that the expired timers have values of + 0 in the remaining time field. */ + done = NU_FALSE; + do + { + + /* Protect against list access. */ + TCT_System_Protect(); + + /* Pickup the head of the active list. */ + timer = TMD_Active_Timers_List; + + /* Determine if the timer now at the head of the list has + expired. Processing continues until the list is empty or + until a non-expired timer is at the front of the list. */ + if ((timer) && (timer -> tm_remaining_time == 0)) + { + + /* Timer has expired. Determine which type of timer has + expired. */ + if (timer -> tm_timer_type == TM_APPL_TIMER) + { + + /* Application timer has expired. */ + type = TM_APPL_TIMER; + + /* Pickup the pointer to the application timer control + block. */ + app_timer = (TM_APP_TCB *) timer -> tm_information; + + /* Increment the number of expirations. */ + app_timer -> tm_expirations++; +#ifdef INCLUDE_PROVIEW + _RTProf_DumpTimer(RT_PROF_APP_TIMER_EXPIRED,app_timer,RT_PROF_OK); +#endif + + /* Move the expiration information into local variables + in case they get corrupted before this expiration can + be processed. Expirations are processed without the + list protection in force. */ + id = app_timer -> tm_expiration_id; + expiration_routine = app_timer -> tm_expiration_routine; + + /* Clear the enabled flag and remove the timer from the + list. */ + app_timer -> tm_enabled = NU_FALSE; + TMC_Stop_Timer(timer); + + /* Determine if this timer should be started again. */ + if (app_timer -> tm_reschedule_time) + { + + /* Timer needs to be rescheduled. */ + + /* Setup the enable flag to show that the timer is + enabled. */ + app_timer -> tm_enabled = NU_TRUE; + + /* Call the start timer function to actually enable + the timer. This also puts it in the proper place + on the list. */ + TMC_Start_Timer(timer,app_timer -> tm_reschedule_time); + } + } + else + { + + /* Task timer has expired (sleeps and timeouts). */ + type = TM_TASK_TIMER; + + /* Remove the timer from the list. */ + TMC_Stop_Timer(timer); + + /* Save-off the task control block pointer. */ + pointer = timer -> tm_information; + } + } + else + + /* Processing is now complete- no more expired timers on the + list. */ + done = NU_TRUE; + + /* Release protection of active list. */ + TCT_Unprotect(); + + /* Determine if a timer expiration needs to be finished. Note + that the actual expiration processing is done with protection + disabled. This prevents deadlock situations from arising. */ + if (!done) + { + + /* Determine which type of timer has expired. */ + if (type == TM_APPL_TIMER) + + /* Call application timer's expiration function. */ + (*(expiration_routine)) (id); + else + + /* Call the task timeout function in the thread control + function. */ + TCC_Task_Timeout((NU_TASK *) pointer); + } + } while (!done); + + /* Protect the active list again. */ + TCT_System_Protect(); + + /* Clear the busy flag to indicate that list processing is complete. */ + TMD_Active_List_Busy = NU_FALSE; + + /* Determine if a new timer should be enabled. */ + if (TMD_Active_Timers_List) + { + + /* Yes, a new timer should be activated. */ + + /* Pickup the new timer expiration value. */ + TMD_Timer_Start = TMD_Active_Timers_List -> tm_remaining_time; + + /* Start the new timer. */ + TMT_Enable_Timer(TMD_Timer_Start); + } + + /* Release protection of the active timer list. */ + TCT_Unprotect(); + + /* Return to user mode */ + NU_USER_MODE(); +} + + + + +