| /****************************************************************************** |
| * |
| * Copyright (C) 1999-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| #include "gki_int.h" |
| |
| #ifndef BT_ERROR_TRACE_0 |
| #define BT_ERROR_TRACE_0(l,m) |
| #endif |
| |
| /* Make sure that this has been defined in target.h */ |
| #ifndef GKI_NUM_TIMERS |
| #error NO TIMERS: Must define at least 1 timer in the system! |
| #endif |
| |
| |
| #define GKI_NO_NEW_TMRS_STARTED (0x7fffffffL) /* Largest signed positive timer count */ |
| #define GKI_UNUSED_LIST_ENTRY (0x80000000L) /* Marks an unused timer list entry (initial value) */ |
| #define GKI_MAX_INT32 (0x7fffffffL) |
| |
| /******************************************************************************* |
| ** |
| ** Function gki_timers_init |
| ** |
| ** Description This internal function is called once at startup to initialize |
| ** all the timer structures. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gki_timers_init(void) |
| { |
| UINT8 tt; |
| |
| gki_cb.com.OSTicksTilExp = 0; /* Remaining time (of OSTimeCurTimeout) before next timer expires */ |
| gki_cb.com.OSNumOrigTicks = 0; |
| #if (defined(GKI_DELAY_STOP_SYS_TICK) && (GKI_DELAY_STOP_SYS_TICK > 0)) |
| gki_cb.com.OSTicksTilStop = 0; /* clear inactivity delay timer */ |
| #endif |
| |
| for (tt = 0; tt < GKI_MAX_TASKS; tt++) |
| { |
| gki_cb.com.OSWaitTmr [tt] = 0; |
| |
| #if (GKI_NUM_TIMERS > 0) |
| gki_cb.com.OSTaskTmr0 [tt] = 0; |
| gki_cb.com.OSTaskTmr0R [tt] = 0; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 1) |
| gki_cb.com.OSTaskTmr1 [tt] = 0; |
| gki_cb.com.OSTaskTmr1R [tt] = 0; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 2) |
| gki_cb.com.OSTaskTmr2 [tt] = 0; |
| gki_cb.com.OSTaskTmr2R [tt] = 0; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 3) |
| gki_cb.com.OSTaskTmr3 [tt] = 0; |
| gki_cb.com.OSTaskTmr3R [tt] = 0; |
| #endif |
| } |
| |
| for (tt = 0; tt < GKI_MAX_TIMER_QUEUES; tt++) |
| { |
| gki_cb.com.timer_queues[tt] = NULL; |
| } |
| |
| gki_cb.com.p_tick_cb = NULL; |
| gki_cb.com.system_tick_running = FALSE; |
| |
| return; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function gki_timers_is_timer_running |
| ** |
| ** Description This internal function is called to test if any gki timer are running |
| ** |
| ** |
| ** Returns TRUE if at least one time is running in the system, FALSE else. |
| ** |
| *******************************************************************************/ |
| BOOLEAN gki_timers_is_timer_running(void) |
| { |
| UINT8 tt; |
| for (tt = 0; tt < GKI_MAX_TASKS; tt++) |
| { |
| |
| #if (GKI_NUM_TIMERS > 0) |
| if(gki_cb.com.OSTaskTmr0 [tt]) |
| { |
| return TRUE; |
| } |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 1) |
| if(gki_cb.com.OSTaskTmr1 [tt] ) |
| { |
| return TRUE; |
| } |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 2) |
| if(gki_cb.com.OSTaskTmr2 [tt] ) |
| { |
| return TRUE; |
| } |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 3) |
| if(gki_cb.com.OSTaskTmr3 [tt] ) |
| { |
| return TRUE; |
| } |
| #endif |
| } |
| |
| return FALSE; |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_get_tick_count |
| ** |
| ** Description This function returns the current system ticks |
| ** |
| ** Returns The current number of system ticks |
| ** |
| *******************************************************************************/ |
| UINT32 GKI_get_tick_count(void) |
| { |
| return gki_cb.com.OSTicks; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_ready_to_sleep |
| ** |
| ** Description This function returns the number of system ticks until the |
| ** next timer will expire. It is typically called by a power |
| ** savings manager to find out how long it can have the system |
| ** sleep before it needs to service the next entry. |
| ** |
| ** Parameters: None |
| ** |
| ** Returns Number of ticks til the next timer expires |
| ** Note: the value is a signed value. This value should be |
| ** compared to x > 0, to avoid misinterpreting negative tick |
| ** values. |
| ** |
| *******************************************************************************/ |
| INT32 GKI_ready_to_sleep (void) |
| { |
| return (gki_cb.com.OSTicksTilExp); |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_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 parameters. |
| ** |
| ** Parameters tnum - (input) timer number to be started (TIMER_0, |
| ** TIMER_1, TIMER_2, or TIMER_3) |
| ** ticks - (input) the number of system ticks til the |
| ** timer expires. |
| ** is_continuous - (input) TRUE if timer restarts automatically, |
| ** else FALSE if it is a 'one-shot'. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void GKI_start_timer (UINT8 tnum, INT32 ticks, BOOLEAN is_continuous) |
| { |
| INT32 reload; |
| INT32 orig_ticks; |
| UINT8 task_id = GKI_get_taskid(); |
| BOOLEAN bad_timer = FALSE; |
| |
| if (ticks <= 0) |
| ticks = 1; |
| |
| orig_ticks = ticks; /* save the ticks in case adjustment is necessary */ |
| |
| |
| /* If continuous timer, set reload, else set it to 0 */ |
| if (is_continuous) |
| reload = ticks; |
| else |
| reload = 0; |
| |
| GKI_disable(); |
| |
| if(gki_timers_is_timer_running() == FALSE) |
| { |
| #if (defined(GKI_DELAY_STOP_SYS_TICK) && (GKI_DELAY_STOP_SYS_TICK > 0)) |
| /* if inactivity delay timer is not running, start system tick */ |
| if(gki_cb.com.OSTicksTilStop == 0) |
| { |
| #endif |
| if(gki_cb.com.p_tick_cb) |
| { |
| /* start system tick */ |
| gki_cb.com.system_tick_running = TRUE; |
| (gki_cb.com.p_tick_cb) (TRUE); |
| } |
| #if (defined(GKI_DELAY_STOP_SYS_TICK) && (GKI_DELAY_STOP_SYS_TICK > 0)) |
| } |
| else |
| { |
| /* clear inactivity delay timer */ |
| gki_cb.com.OSTicksTilStop = 0; |
| } |
| #endif |
| } |
| /* Add the time since the last task timer update. |
| ** Note that this works when no timers are active since |
| ** both OSNumOrigTicks and OSTicksTilExp are 0. |
| */ |
| if (GKI_MAX_INT32 - (gki_cb.com.OSNumOrigTicks - gki_cb.com.OSTicksTilExp) > ticks) |
| { |
| ticks += gki_cb.com.OSNumOrigTicks - gki_cb.com.OSTicksTilExp; |
| } |
| else |
| ticks = GKI_MAX_INT32; |
| |
| switch (tnum) |
| { |
| #if (GKI_NUM_TIMERS > 0) |
| case TIMER_0: |
| gki_cb.com.OSTaskTmr0R[task_id] = reload; |
| gki_cb.com.OSTaskTmr0 [task_id] = ticks; |
| break; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 1) |
| case TIMER_1: |
| gki_cb.com.OSTaskTmr1R[task_id] = reload; |
| gki_cb.com.OSTaskTmr1 [task_id] = ticks; |
| break; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 2) |
| case TIMER_2: |
| gki_cb.com.OSTaskTmr2R[task_id] = reload; |
| gki_cb.com.OSTaskTmr2 [task_id] = ticks; |
| break; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 3) |
| case TIMER_3: |
| gki_cb.com.OSTaskTmr3R[task_id] = reload; |
| gki_cb.com.OSTaskTmr3 [task_id] = ticks; |
| break; |
| #endif |
| default: |
| bad_timer = TRUE; /* Timer number is bad, so do not use */ |
| } |
| |
| /* Update the expiration timeout if a legitimate timer */ |
| if (!bad_timer) |
| { |
| /* Only update the timeout value if it is less than any other newly started timers */ |
| gki_adjust_timer_count (orig_ticks); |
| } |
| |
| GKI_enable(); |
| |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_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. |
| ** |
| ** Parameters tnum - (input) timer number to be started (TIMER_0, |
| ** TIMER_1, TIMER_2, or TIMER_3) |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void GKI_stop_timer (UINT8 tnum) |
| { |
| UINT8 task_id = GKI_get_taskid(); |
| |
| GKI_disable(); |
| |
| switch (tnum) |
| { |
| #if (GKI_NUM_TIMERS > 0) |
| case TIMER_0: |
| gki_cb.com.OSTaskTmr0R[task_id] = 0; |
| gki_cb.com.OSTaskTmr0 [task_id] = 0; |
| break; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 1) |
| case TIMER_1: |
| gki_cb.com.OSTaskTmr1R[task_id] = 0; |
| gki_cb.com.OSTaskTmr1 [task_id] = 0; |
| break; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 2) |
| case TIMER_2: |
| gki_cb.com.OSTaskTmr2R[task_id] = 0; |
| gki_cb.com.OSTaskTmr2 [task_id] = 0; |
| break; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 3) |
| case TIMER_3: |
| gki_cb.com.OSTaskTmr3R[task_id] = 0; |
| gki_cb.com.OSTaskTmr3 [task_id] = 0; |
| break; |
| #endif |
| } |
| |
| if (gki_timers_is_timer_running() == FALSE) |
| { |
| if (gki_cb.com.p_tick_cb) |
| { |
| #if (defined(GKI_DELAY_STOP_SYS_TICK) && (GKI_DELAY_STOP_SYS_TICK > 0)) |
| /* if inactivity delay timer is not running */ |
| if ((gki_cb.com.system_tick_running)&&(gki_cb.com.OSTicksTilStop == 0)) |
| { |
| /* set inactivity delay timer */ |
| /* when timer expires, system tick will be stopped */ |
| gki_cb.com.OSTicksTilStop = GKI_DELAY_STOP_SYS_TICK; |
| } |
| #else |
| gki_cb.com.system_tick_running = FALSE; |
| gki_cb.com.p_tick_cb(FALSE); /* stop system tick */ |
| #endif |
| } |
| } |
| |
| GKI_enable(); |
| |
| |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_timer_update |
| ** |
| ** Description This function is called by an OS to drive the GKI's timers. |
| ** It is typically called at every system tick to |
| ** update the timers for all tasks, and check for timeouts. |
| ** |
| ** Note: It has been designed to also allow for variable tick updates |
| ** so that systems with strict power savings requirements can |
| ** have the update occur at variable intervals. |
| ** |
| ** Parameters: ticks_since_last_update - (input) This is the number of TICKS that have |
| ** occurred since the last time GKI_timer_update was called. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void GKI_timer_update (INT32 ticks_since_last_update) |
| { |
| UINT8 task_id; |
| long next_expiration; /* Holds the next soonest expiration time after this update */ |
| |
| /* Increment the number of ticks used for time stamps */ |
| gki_cb.com.OSTicks += ticks_since_last_update; |
| |
| /* If any timers are running in any tasks, decrement the remaining time til |
| * the timer updates need to take place (next expiration occurs) |
| */ |
| gki_cb.com.OSTicksTilExp -= ticks_since_last_update; |
| |
| /* Don't allow timer interrupt nesting */ |
| if (gki_cb.com.timer_nesting) |
| return; |
| |
| gki_cb.com.timer_nesting = 1; |
| |
| #if (defined(GKI_DELAY_STOP_SYS_TICK) && (GKI_DELAY_STOP_SYS_TICK > 0)) |
| /* if inactivity delay timer is set and expired */ |
| if (gki_cb.com.OSTicksTilStop) |
| { |
| if( gki_cb.com.OSTicksTilStop <= (UINT32)ticks_since_last_update ) |
| { |
| if(gki_cb.com.p_tick_cb) |
| { |
| gki_cb.com.system_tick_running = FALSE; |
| (gki_cb.com.p_tick_cb) (FALSE); /* stop system tick */ |
| } |
| gki_cb.com.OSTicksTilStop = 0; /* clear inactivity delay timer */ |
| gki_cb.com.timer_nesting = 0; |
| return; |
| } |
| else |
| gki_cb.com.OSTicksTilStop -= ticks_since_last_update; |
| } |
| #endif |
| |
| /* No need to update the ticks if no timeout has occurred */ |
| if (gki_cb.com.OSTicksTilExp > 0) |
| { |
| gki_cb.com.timer_nesting = 0; |
| return; |
| } |
| |
| GKI_disable(); |
| |
| next_expiration = GKI_NO_NEW_TMRS_STARTED; |
| |
| /* If here then gki_cb.com.OSTicksTilExp <= 0. If negative, then increase gki_cb.com.OSNumOrigTicks |
| to account for the difference so timer updates below are decremented by the full number |
| of ticks. gki_cb.com.OSNumOrigTicks is reset at the bottom of this function so changing this |
| value only affects the timer updates below |
| */ |
| gki_cb.com.OSNumOrigTicks -= gki_cb.com.OSTicksTilExp; |
| |
| /* Check for OS Task Timers */ |
| for (task_id = 0; task_id < GKI_MAX_TASKS; task_id++) |
| { |
| if (gki_cb.com.OSWaitTmr[task_id] > 0) /* If timer is running */ |
| { |
| gki_cb.com.OSWaitTmr[task_id] -= gki_cb.com.OSNumOrigTicks; |
| if (gki_cb.com.OSWaitTmr[task_id] <= 0) |
| { |
| /* Timer Expired */ |
| gki_cb.com.OSRdyTbl[task_id] = TASK_READY; |
| } |
| } |
| |
| #if (GKI_NUM_TIMERS > 0) |
| /* If any timer is running, decrement */ |
| if (gki_cb.com.OSTaskTmr0[task_id] > 0) |
| { |
| gki_cb.com.OSTaskTmr0[task_id] -= gki_cb.com.OSNumOrigTicks; |
| |
| if (gki_cb.com.OSTaskTmr0[task_id] <= 0) |
| { |
| /* Set Timer 0 Expired event mask and reload timer */ |
| #if (defined(GKI_TIMER_UPDATES_FROM_ISR) && GKI_TIMER_UPDATES_FROM_ISR == TRUE) |
| GKI_isend_event (task_id, TIMER_0_EVT_MASK); |
| #else |
| GKI_send_event (task_id, TIMER_0_EVT_MASK); |
| #endif |
| gki_cb.com.OSTaskTmr0[task_id] = gki_cb.com.OSTaskTmr0R[task_id]; |
| } |
| } |
| |
| /* Check to see if this timer is the next one to expire */ |
| if (gki_cb.com.OSTaskTmr0[task_id] > 0 && gki_cb.com.OSTaskTmr0[task_id] < next_expiration) |
| next_expiration = gki_cb.com.OSTaskTmr0[task_id]; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 1) |
| /* If any timer is running, decrement */ |
| if (gki_cb.com.OSTaskTmr1[task_id] > 0) |
| { |
| gki_cb.com.OSTaskTmr1[task_id] -= gki_cb.com.OSNumOrigTicks; |
| |
| if (gki_cb.com.OSTaskTmr1[task_id] <= 0) |
| { |
| /* Set Timer 1 Expired event mask and reload timer */ |
| #if (defined(GKI_TIMER_UPDATES_FROM_ISR) && GKI_TIMER_UPDATES_FROM_ISR == TRUE) |
| GKI_isend_event (task_id, TIMER_1_EVT_MASK); |
| #else |
| GKI_send_event (task_id, TIMER_1_EVT_MASK); |
| #endif |
| gki_cb.com.OSTaskTmr1[task_id] = gki_cb.com.OSTaskTmr1R[task_id]; |
| } |
| } |
| |
| /* Check to see if this timer is the next one to expire */ |
| if (gki_cb.com.OSTaskTmr1[task_id] > 0 && gki_cb.com.OSTaskTmr1[task_id] < next_expiration) |
| next_expiration = gki_cb.com.OSTaskTmr1[task_id]; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 2) |
| /* If any timer is running, decrement */ |
| if (gki_cb.com.OSTaskTmr2[task_id] > 0) |
| { |
| gki_cb.com.OSTaskTmr2[task_id] -= gki_cb.com.OSNumOrigTicks; |
| |
| if (gki_cb.com.OSTaskTmr2[task_id] <= 0) |
| { |
| /* Set Timer 2 Expired event mask and reload timer */ |
| #if (defined(GKI_TIMER_UPDATES_FROM_ISR) && GKI_TIMER_UPDATES_FROM_ISR == TRUE) |
| GKI_isend_event (task_id, TIMER_2_EVT_MASK); |
| #else |
| GKI_send_event (task_id, TIMER_2_EVT_MASK); |
| #endif |
| gki_cb.com.OSTaskTmr2[task_id] = gki_cb.com.OSTaskTmr2R[task_id]; |
| } |
| } |
| |
| /* Check to see if this timer is the next one to expire */ |
| if (gki_cb.com.OSTaskTmr2[task_id] > 0 && gki_cb.com.OSTaskTmr2[task_id] < next_expiration) |
| next_expiration = gki_cb.com.OSTaskTmr2[task_id]; |
| #endif |
| |
| #if (GKI_NUM_TIMERS > 3) |
| /* If any timer is running, decrement */ |
| if (gki_cb.com.OSTaskTmr3[task_id] > 0) |
| { |
| gki_cb.com.OSTaskTmr3[task_id] -= gki_cb.com.OSNumOrigTicks; |
| |
| if (gki_cb.com.OSTaskTmr3[task_id] <= 0) |
| { |
| /* Set Timer 3 Expired event mask and reload timer */ |
| #if (defined(GKI_TIMER_UPDATES_FROM_ISR) && GKI_TIMER_UPDATES_FROM_ISR == TRUE) |
| GKI_isend_event (task_id, TIMER_3_EVT_MASK); |
| #else |
| GKI_send_event (task_id, TIMER_3_EVT_MASK); |
| #endif |
| gki_cb.com.OSTaskTmr3[task_id] = gki_cb.com.OSTaskTmr3R[task_id]; |
| } |
| } |
| |
| /* Check to see if this timer is the next one to expire */ |
| if (gki_cb.com.OSTaskTmr3[task_id] > 0 && gki_cb.com.OSTaskTmr3[task_id] < next_expiration) |
| next_expiration = gki_cb.com.OSTaskTmr3[task_id]; |
| #endif |
| |
| } |
| |
| /* Set the next timer experation value if there is one to start */ |
| if (next_expiration < GKI_NO_NEW_TMRS_STARTED) |
| { |
| gki_cb.com.OSTicksTilExp = gki_cb.com.OSNumOrigTicks = next_expiration; |
| } |
| else |
| { |
| gki_cb.com.OSTicksTilExp = gki_cb.com.OSNumOrigTicks = 0; |
| } |
| |
| gki_cb.com.timer_nesting = 0; |
| |
| GKI_enable(); |
| |
| return; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_timer_queue_empty |
| ** |
| ** Description This function is called by applications to see whether the timer |
| ** queue is empty |
| ** |
| ** Parameters |
| ** |
| ** Returns BOOLEAN |
| ** |
| *******************************************************************************/ |
| BOOLEAN GKI_timer_queue_empty (void) |
| { |
| UINT8 tt; |
| |
| for (tt = 0; tt < GKI_MAX_TIMER_QUEUES; tt++) |
| { |
| if (gki_cb.com.timer_queues[tt]) |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_timer_queue_register_callback |
| ** |
| ** Description This function is called by applications to register system tick |
| ** start/stop callback for time queues |
| ** |
| ** |
| ** Parameters p_callback - (input) pointer to the system tick callback |
| ** |
| ** Returns BOOLEAN |
| ** |
| *******************************************************************************/ |
| void GKI_timer_queue_register_callback (SYSTEM_TICK_CBACK *p_callback) |
| { |
| gki_cb.com.p_tick_cb = p_callback; |
| |
| return; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_init_timer_list |
| ** |
| ** Description This function is called by applications when they |
| ** want to initialize a timer list. |
| ** |
| ** Parameters p_timer_listq - (input) pointer to the timer list queue object |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void GKI_init_timer_list (TIMER_LIST_Q *p_timer_listq) |
| { |
| p_timer_listq->p_first = NULL; |
| p_timer_listq->p_last = NULL; |
| p_timer_listq->last_ticks = 0; |
| |
| return; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_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. |
| ** |
| ** Parameters p_tle - (input) pointer to a timer list queue entry |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void GKI_init_timer_list_entry (TIMER_LIST_ENT *p_tle) |
| { |
| p_tle->p_next = NULL; |
| p_tle->p_prev = NULL; |
| p_tle->ticks = GKI_UNUSED_LIST_ENTRY; |
| p_tle->in_use = FALSE; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_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. |
| ** |
| ** Parameters p_timer_listq - (input) pointer to the timer list queue object |
| ** num_units_since_last_update - (input) number of units since the last update |
| ** (allows for variable unit update) |
| ** |
| ** NOTE: The following timer list update routines should not be used for exact time |
| ** critical purposes. The timer tasks should be used when exact timing is needed. |
| ** |
| ** Returns the number of timers that have expired |
| ** |
| *******************************************************************************/ |
| UINT16 GKI_update_timer_list (TIMER_LIST_Q *p_timer_listq, INT32 num_units_since_last_update) |
| { |
| TIMER_LIST_ENT *p_tle; |
| UINT16 num_time_out = 0; |
| INT32 rem_ticks; |
| INT32 temp_ticks; |
| |
| p_tle = p_timer_listq->p_first; |
| |
| /* First, get the guys who have previously timed out */ |
| /* Note that the tick value of the timers should always be '0' */ |
| while ((p_tle) && (p_tle->ticks <= 0)) |
| { |
| num_time_out++; |
| p_tle = p_tle->p_next; |
| } |
| |
| /* Timer entriy tick values are relative to the preceeding entry */ |
| rem_ticks = num_units_since_last_update; |
| |
| /* Now, adjust remaining timer entries */ |
| while ((p_tle != NULL) && (rem_ticks > 0)) |
| { |
| temp_ticks = p_tle->ticks; |
| p_tle->ticks -= rem_ticks; |
| |
| /* See if this timer has just timed out */ |
| if (p_tle->ticks <= 0) |
| { |
| /* We set the number of ticks to '0' so that the legacy code |
| * that assumes a '0' or nonzero value will still work as coded. */ |
| p_tle->ticks = 0; |
| |
| num_time_out++; |
| } |
| |
| rem_ticks -= temp_ticks; /* Decrement the remaining ticks to process */ |
| p_tle = p_tle->p_next; |
| } |
| |
| if (p_timer_listq->last_ticks > 0) |
| { |
| p_timer_listq->last_ticks -= num_units_since_last_update; |
| |
| /* If the last timer has expired set last_ticks to 0 so that other list update |
| * functions will calculate correctly |
| */ |
| if (p_timer_listq->last_ticks < 0) |
| p_timer_listq->last_ticks = 0; |
| } |
| |
| return (num_time_out); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_get_remaining_ticks |
| ** |
| ** Description This function is called by an application to get remaining |
| ** ticks to expire |
| ** |
| ** Parameters p_timer_listq - (input) pointer to the timer list queue object |
| ** p_target_tle - (input) pointer to a timer list queue entry |
| ** |
| ** Returns 0 if timer is not used or timer is not in the list |
| ** remaining ticks if success |
| ** |
| *******************************************************************************/ |
| UINT32 GKI_get_remaining_ticks (TIMER_LIST_Q *p_timer_listq, TIMER_LIST_ENT *p_target_tle) |
| { |
| TIMER_LIST_ENT *p_tle; |
| UINT32 rem_ticks = 0; |
| |
| if (p_target_tle->in_use) |
| { |
| p_tle = p_timer_listq->p_first; |
| |
| /* adding up all of ticks in previous entries */ |
| while ((p_tle)&&(p_tle != p_target_tle)) |
| { |
| rem_ticks += p_tle->ticks; |
| p_tle = p_tle->p_next; |
| } |
| |
| /* if found target entry */ |
| if (p_tle == p_target_tle) |
| { |
| rem_ticks += p_tle->ticks; |
| } |
| else |
| { |
| BT_ERROR_TRACE_0(TRACE_LAYER_GKI, "GKI_get_remaining_ticks: No timer entry in the list"); |
| return(0); |
| } |
| } |
| else |
| { |
| BT_ERROR_TRACE_0(TRACE_LAYER_GKI, "GKI_get_remaining_ticks: timer entry is not active"); |
| } |
| |
| return (rem_ticks); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_add_to_timer_list |
| ** |
| ** Description This function is called by an application to add a timer |
| ** entry to a timer list. |
| ** |
| ** Note: A timer value of '0' will effectively insert an already |
| ** expired event. Negative tick values will be ignored. |
| ** |
| ** Parameters p_timer_listq - (input) pointer to the timer list queue object |
| ** p_tle - (input) pointer to a timer list queue entry |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void GKI_add_to_timer_list (TIMER_LIST_Q *p_timer_listq, TIMER_LIST_ENT *p_tle) |
| { |
| UINT32 nr_ticks_total; |
| UINT8 tt; |
| TIMER_LIST_ENT *p_temp; |
| if (p_tle == NULL || p_timer_listq == NULL) { |
| GKI_TRACE_3("%s: invalid argument %x, %x****************************<<", __func__, p_timer_listq, p_tle); |
| return; |
| } |
| |
| |
| /* Only process valid tick values */ |
| if (p_tle->ticks >= 0) |
| { |
| /* If this entry is the last in the list */ |
| if (p_tle->ticks >= p_timer_listq->last_ticks) |
| { |
| /* If this entry is the only entry in the list */ |
| if (p_timer_listq->p_first == NULL) |
| p_timer_listq->p_first = p_tle; |
| else |
| { |
| /* Insert the entry onto the end of the list */ |
| 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_timer_listq->last_ticks; |
| |
| p_timer_listq->last_ticks = nr_ticks_total; |
| } |
| else /* This entry needs to be inserted before the last entry */ |
| { |
| /* Find the entry that the new one needs to be inserted in front of */ |
| p_temp = p_timer_listq->p_first; |
| while (p_tle->ticks > p_temp->ticks) |
| { |
| /* Update the tick value if looking at an unexpired entry */ |
| if (p_temp->ticks > 0) |
| p_tle->ticks -= p_temp->ticks; |
| |
| p_temp = p_temp->p_next; |
| } |
| |
| /* The new entry is the first in the list */ |
| 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_tle->ticks; |
| } |
| |
| p_tle->in_use = TRUE; |
| |
| /* if we already add this timer queue to the array */ |
| for (tt = 0; tt < GKI_MAX_TIMER_QUEUES; tt++) |
| { |
| if (gki_cb.com.timer_queues[tt] == p_timer_listq) |
| return; |
| } |
| /* add this timer queue to the array */ |
| for (tt = 0; tt < GKI_MAX_TIMER_QUEUES; tt++) |
| { |
| if (gki_cb.com.timer_queues[tt] == NULL) |
| break; |
| } |
| if (tt < GKI_MAX_TIMER_QUEUES) |
| { |
| gki_cb.com.timer_queues[tt] = p_timer_listq; |
| } |
| } |
| |
| return; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function GKI_remove_from_timer_list |
| ** |
| ** Description This function is called by an application to remove a timer |
| ** entry from a timer list. |
| ** |
| ** Parameters p_timer_listq - (input) pointer to the timer list queue object |
| ** p_tle - (input) pointer to a timer list queue entry |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void GKI_remove_from_timer_list (TIMER_LIST_Q *p_timer_listq, TIMER_LIST_ENT *p_tle) |
| { |
| UINT8 tt; |
| |
| /* Verify that the entry is valid */ |
| if (p_tle == NULL || p_tle->in_use == FALSE || p_timer_listq->p_first == NULL) |
| { |
| return; |
| } |
| |
| /* Add the ticks remaining in this timer (if any) to the next guy in the list. |
| ** Note: Expired timers have a tick value of '0'. |
| */ |
| 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 = GKI_UNUSED_LIST_ENTRY; |
| p_tle->in_use = FALSE; |
| |
| /* if timer queue is empty */ |
| if (p_timer_listq->p_first == NULL && p_timer_listq->p_last == NULL) |
| { |
| for (tt = 0; tt < GKI_MAX_TIMER_QUEUES; tt++) |
| { |
| if (gki_cb.com.timer_queues[tt] == p_timer_listq) |
| { |
| gki_cb.com.timer_queues[tt] = NULL; |
| break; |
| } |
| } |
| } |
| |
| return; |
| } |
| |
| |
| /******************************************************************************* |
| ** |
| ** Function gki_adjust_timer_count |
| ** |
| ** Description This function is called whenever a new timer or GKI_wait occurs |
| ** to adjust (if necessary) the current time til the first expiration. |
| ** This only needs to make an adjustment if the new timer (in ticks) is |
| ** less than the number of ticks remaining on the current timer. |
| ** |
| ** Parameters: ticks - (input) number of system ticks of the new timer entry |
| ** |
| ** NOTE: This routine MUST be called while interrupts are disabled to |
| ** avoid updates while adjusting the timer variables. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void gki_adjust_timer_count (INT32 ticks) |
| { |
| if (ticks > 0) |
| { |
| /* See if the new timer expires before the current first expiration */ |
| if (gki_cb.com.OSNumOrigTicks == 0 || (ticks < gki_cb.com.OSTicksTilExp && gki_cb.com.OSTicksTilExp > 0)) |
| { |
| gki_cb.com.OSNumOrigTicks = (gki_cb.com.OSNumOrigTicks - gki_cb.com.OSTicksTilExp) + ticks; |
| gki_cb.com.OSTicksTilExp = ticks; |
| } |
| } |
| |
| return; |
| } |
