Remove more unused code from GKI timers. (2018c2f7) · Commits · e / os / android_packages_modules_Bluetooth

gki/common/gki.h

+1 −18

Original line number	Diff line number	Diff line
		@@ -146,7 +146,7 @@ GKI_API extern UINT8 GKI_get_taskid(void);
		GKI_API extern void GKI_init(void);
		GKI_API extern void GKI_shutdown(void);
		GKI_API extern INT8 *GKI_map_taskname(UINT8);
		GKI_API extern void GKI_run(void *);
		GKI_API extern void GKI_run(void);
		GKI_API extern void GKI_stop(void);

		/* To send buffers and events between tasks
		@@ -185,9 +185,7 @@ GKI_API extern UINT16 GKI_get_pool_bufsize (UINT8);
		GKI_API extern void GKI_add_to_timer_list (TIMER_LIST_Q , TIMER_LIST_ENT );
		GKI_API extern void GKI_delay(UINT32);
		GKI_API extern UINT32 GKI_get_tick_count(void);
		GKI_API extern INT8 GKI_get_time_stamp(INT8 );
		GKI_API extern void GKI_init_timer_list (TIMER_LIST_Q *);
		GKI_API extern void GKI_init_timer_list_entry (TIMER_LIST_ENT *);
		GKI_API extern INT32 GKI_ready_to_sleep (void);
		GKI_API extern void GKI_remove_from_timer_list (TIMER_LIST_Q , TIMER_LIST_ENT );
		GKI_API extern void GKI_start_timer(UINT8, INT32, BOOLEAN);
		@@ -198,22 +196,7 @@ GKI_API extern UINT32 GKI_get_remaining_ticks (TIMER_LIST_Q *, TIMER_LIST_ENT
		GKI_API extern UINT16 GKI_wait(UINT16, UINT32);
		GKI_API extern BOOLEAN GKI_timer_queue_is_empty(const TIMER_LIST_Q *timer_q);
		GKI_API extern TIMER_LIST_ENT GKI_timer_getfirst(const TIMER_LIST_Q timer_q);
		GKI_API extern TIMER_LIST_ENT GKI_timer_getlast(const TIMER_LIST_Q timer_q);
		GKI_API extern INT32 GKI_timer_ticks_getlast(const TIMER_LIST_Q *timer_q);
		GKI_API extern TIMER_LIST_ENT GKI_timer_entry_next(const TIMER_LIST_ENT tle);
		GKI_API extern INT32 GKI_timer_ticks_getcurrent(const TIMER_LIST_ENT *tle);
		GKI_API extern INT32 GKI_timer_ticks_getinitial(const TIMER_LIST_ENT *tle);
		GKI_API extern BOOLEAN GKI_timer_in_use(const TIMER_LIST_ENT *tle);

		/* Start and Stop system time tick callback
		* true for start system tick if time queue is not empty
		* false to stop system tick if time queue is empty
		*/
		typedef void (SYSTEM_TICK_CBACK)(BOOLEAN);

		/* Time queue management for system ticks
		*/
		GKI_API extern void GKI_timer_queue_register_callback(SYSTEM_TICK_CBACK *);

		/* Disable Interrupts, Enable Interrupts
		*/

gki/common/gki_common.h

+0 −7

Original line number	Diff line number	Diff line
		@@ -267,9 +267,6 @@ typedef struct
		/* Timer related variables
		*/
		INT32 OSTicksTilExp; /* Number of ticks till next timer expires */
		#if (defined(GKI_DELAY_STOP_SYS_TICK) && (GKI_DELAY_STOP_SYS_TICK > 0))
		UINT32 OSTicksTilStop; /* inactivity delay timer; OS Ticks till stopping system tick */
		#endif
		INT32 OSNumOrigTicks; /* Number of ticks between last timer expiration to the next one */

		INT32 OSWaitTmr [GKI_MAX_TASKS]; /* ticks the task has to wait, for specific events */
		@@ -324,10 +321,6 @@ typedef struct

		BOOLEAN timer_nesting; /* flag to prevent timer interrupt nesting */

		/* System tick callback */
		SYSTEM_TICK_CBACK *p_tick_cb;
		BOOLEAN system_tick_running; /* TRUE if system tick is running. Valid only if p_tick_cb is not NULL */

		#if (GKI_DEBUG == TRUE)
		UINT16 ExceptionCnt; /* number of GKI exceptions that have happened */
		EXCEPTION_T Exception[GKI_MAX_EXCEPTION];

gki/common/gki_time.c

+0 −148

Original line number	Diff line number	Diff line
		@@ -48,9 +48,6 @@ void gki_timers_init(void)

		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++)
		{
		@@ -77,9 +74,6 @@ void gki_timers_init(void)
		#endif
		}

		gki_cb.com.p_tick_cb = NULL;
		gki_cb.com.system_tick_running = FALSE;

		return;
		}

		@@ -210,28 +204,6 @@ void GKI_start_timer (UINT8 tnum, INT32 ticks, BOOLEAN is_continuous)

		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.
		@@ -334,31 +306,6 @@ void GKI_stop_timer (UINT8 tnum)
		break;
		#endif
		}

		GKI_disable();

		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();


		}


		@@ -399,26 +346,6 @@ void GKI_timer_update (INT32 ticks_since_last_update)

		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)
		{
		@@ -438,15 +365,12 @@ void GKI_timer_update (INT32 ticks_since_last_update)
		*/
		gki_cb.com.OSNumOrigTicks -= gki_cb.com.OSTicksTilExp;

		#if GKI_TIMER_LIST_NOPREEMPT == TRUE
		/* Protect this section because if a GKI_timer_stop happens between:
		* - gki_cb.com.OSTaskTmr0[task_id] -= gki_cb.com.OSNumOrigTicks;
		* - gki_cb.com.OSTaskTmr0[task_id] = gki_cb.com.OSTaskTmr0R[task_id];
		* then the timer may appear stopped while it is about to be reloaded.
		* Note: Not needed if this function cannot be preempted (typical).
		*/
		GKI_disable();
		#endif

		/* Check for OS Task Timers */
		for (task_id = 0; task_id < GKI_MAX_TASKS; task_id++)
		@@ -551,36 +475,13 @@ void GKI_timer_update (INT32 ticks_since_last_update)
		// Set alarm service for next alarm.
		alarm_service_reschedule();

		#if GKI_TIMER_LIST_NOPREEMPT == TRUE
		/* End the critical section */
		GKI_enable();
		#endif

		gki_cb.com.timer_nesting = 0;

		return;
		}

		/*******************************************************************************
		**
		** 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
		@@ -609,61 +510,12 @@ TIMER_LIST_ENT GKI_timer_getfirst(const TIMER_LIST_Q timer_q) {
		return timer_q->p_first;
		}

		TIMER_LIST_ENT GKI_timer_getlast(const TIMER_LIST_Q timer_q) {
		assert(timer_q != NULL);
		return timer_q->p_last;
		}

		/* Returns the number of ticks of the last entry in the queue. */
		INT32 GKI_timer_ticks_getlast(const TIMER_LIST_Q *timer_q) {
		assert(timer_q != NULL);
		return timer_q->last_ticks;
		}

		/*******************************************************************************
		**
		** 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 *tle) {
		tle->p_next = NULL;
		tle->p_prev = NULL;
		tle->ticks = GKI_UNUSED_LIST_ENTRY;
		tle->ticks_initial = 0;
		tle->in_use = FALSE;
		}

		/* Returns the next linked entry from this tle or NULL. */
		TIMER_LIST_ENT GKI_timer_entry_next(const TIMER_LIST_ENT tle) {
		assert(tle != NULL);
		return tle->p_next;
		}

		/* Returns the current number of ticks for this timer entry. */
		INT32 GKI_timer_ticks_getcurrent(const TIMER_LIST_ENT *tle) {
		assert(tle != NULL);
		return tle->ticks;
		}

		/* Returns the initial number of ticks for this timer entry. */
		INT32 GKI_timer_ticks_getinitial(const TIMER_LIST_ENT *tle) {
		assert(tle != NULL);
		return tle->ticks_initial;
		}

		BOOLEAN GKI_timer_in_use(const TIMER_LIST_ENT *tle) {
		assert(tle != NULL);
		return tle->in_use;
		}

		/*******************************************************************************
		**
		** Function GKI_update_timer_list

gki/ulinux/gki_ulinux.c

+1 −31

Original line number	Diff line number	Diff line
		@@ -566,27 +566,6 @@ void GKI_shutdown(void)

		}

		/*******************************************************************************
		**
		** Function gki_system_tick_start_stop_cback
		**
		** Description This function runs a task
		**
		** Parameters: start: TRUE start system tick (again), FALSE stop
		**
		** Returns void
		**
		*********************************************************************************/

		void gki_system_tick_start_stop_cback(BOOLEAN start)
		{
		if (start) {
		ALOGV("Starting system ticks\n");
		} else {
		ALOGV("Stopping system ticks\n");
		}
		}

		/*****************************************************************************
		**
		** Function gki_set_timer_scheduling
		@@ -634,20 +613,11 @@ static void gki_set_timer_scheduling( void )
		**
		*******************************************************************************/

		void GKI_run (void * p_task_id)
		void GKI_run(void)
		{
		UNUSED(p_task_id);

		#ifndef GKI_NO_TICK_STOP
		/* adjust btld scheduling scheme now */
		gki_set_timer_scheduling();

		/* register start stop function which disable timer loop in GKI_run() when no timers are
		* in any GKI/BTA/BTU this should save power when BTLD is idle! */
		GKI_timer_queue_register_callback( gki_system_tick_start_stop_cback );
		GKI_TRACE( "GKI_run(): Start/Stop GKI_timer_update_registered!" );
		#endif
		return;
		}

system/include/gki_target.h

+0 −11

Original line number	Diff line number	Diff line
		@@ -129,17 +129,6 @@
		#define GKI_OS_TICKS_TO_SECS(x) ((x) / OS_TICKS_PER_SEC))
		#endif


		/* delay in ticks before stopping system tick. */
		#ifndef GKI_DELAY_STOP_SYS_TICK
		#define GKI_DELAY_STOP_SYS_TICK 0
		#endif

		/* Option to guarantee no preemption during timer expiration (most system don't need this) */
		#ifndef GKI_TIMER_LIST_NOPREEMPT
		#define GKI_TIMER_LIST_NOPREEMPT TRUE
		#endif

		/******************************************************************************
		**
		** Buffer configuration