[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / connectivity / combo / drv_wlan / mt6628 / wlan / mgmt / cnm_timer.c

/*
** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/mgmt/cnm_timer.c#1 $
*/

/*! \file   "cnm_timer.c"
    \brief

*/


/*
** $Log: cnm_timer.c $
 *
 * 12 13 2011 cm.chang
 * [WCXRP00001136] [All Wi-Fi][Driver] Add wake lock for pending timer
 * Add wake lock if timer timeout value is smaller than 5 seconds
 *
 * 02 24 2011 cp.wu
 * [WCXRP00000490] [MT6620 Wi-Fi][Driver][Win32] modify kalMsleep() implementation because NdisMSleep() won't sleep long enough for specified interval such as 500ms
 * modify cnm_timer and hem_mbox APIs to be thread safe to ease invoking restrictions
 *
 * 07 08 2010 cp.wu
 *
 * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 *
 * 06 08 2010 cp.wu
 * [WPD00003833][MT6620 and MT5931] Driver migration
 * cnm_timer has been migrated.
 *
 * 05 28 2010 cm.chang
 * [BORA00000018]Integrate WIFI part into BORA for the 1st time
 * Support sleep notification to host
 *
 * 05 19 2010 cm.chang
 * [BORA00000018]Integrate WIFI part into BORA for the 1st time
 * Add some checking assertions
 *
 * 04 24 2010 cm.chang
 * [BORA00000018]Integrate WIFI part into BORA for the 1st time
 * Return timer token back to COS when entering wait off state
 *
 * 01 11 2010 cm.chang
 * [BORA00000018]Integrate WIFI part into BORA for the 1st time
 * Remove compiling warning
 *
 * 01 08 2010 cm.chang
 * [BORA00000018]Integrate WIFI part into BORA for the 1st time
 * Support longer timeout interval to 45 days from 65secu1rwduu`wvpghlqg|fh+fmdkb
 *
 * 01 06 2010 cm.chang
 * [BORA00000018]Integrate WIFI part into BORA for the 1st time
 * Fix system time is 32KHz instead of 1ms
 *
 * 01 04 2010 tehuang.liu
 * [BORA00000018]Integrate WIFI part into BORA for the 1st time
 * For working out the first connection Chariot-verified version
 *
 * Dec 3 2009 mtk01461
 * [BORA00000018] Integrate WIFI part into BORA for the 1st time
 * Place rRootTimer.rNextExpiredSysTime = rExpiredSysTime; before set timer
 *
 * Oct 30 2009 mtk01104
 * [BORA00000018] Integrate WIFI part into BORA for the 1st time
 * In cnmTimerInitialize(), just stop timer if it was already created.
 *
 * Oct 30 2009 mtk01461
 * [BORA00000018] Integrate WIFI part into BORA for the 1st time
 * Move the external reference for Lint to precomp.h
 *
 * Oct 30 2009 mtk01461
 * [BORA00000018] Integrate WIFI part into BORA for the 1st time
 * Fix lint warning
 *
 * Oct 28 2009 mtk01104
 * [BORA00000018] Integrate WIFI part into BORA for the 1st time
 *
**
*/

/*******************************************************************************
*                         C O M P I L E R   F L A G S
********************************************************************************
*/

/*******************************************************************************
*                    E X T E R N A L   R E F E R E N C E S
********************************************************************************
*/
#include "precomp.h"

/*******************************************************************************
*                              C O N S T A N T S
********************************************************************************
*/

/*******************************************************************************
*                             D A T A   T Y P E S
********************************************************************************
*/

/*******************************************************************************
*                            P U B L I C   D A T A
********************************************************************************
*/

/*******************************************************************************
*                           P R I V A T E   D A T A
********************************************************************************
*/

/*******************************************************************************
*                                 M A C R O S
********************************************************************************
*/

/*******************************************************************************
*                   F U N C T I O N   D E C L A R A T I O N S
********************************************************************************
*/

/*******************************************************************************
*                              F U N C T I O N S
********************************************************************************
*/

/*----------------------------------------------------------------------------*/
/*!
* \brief This routine is called to set the time to do the time out check.
*
* \param[in] rTimeout Time out interval from current time.
*
* \retval TRUE Success.
*
*/
/*----------------------------------------------------------------------------*/
static BOOLEAN cnmTimerSetTimer(IN P_ADAPTER_T prAdapter, IN OS_SYSTIME rTimeout)
{
	P_ROOT_TIMER prRootTimer;
	BOOLEAN fgNeedWakeLock;

	ASSERT(prAdapter);

	prRootTimer = &prAdapter->rRootTimer;

	kalSetTimer(prAdapter->prGlueInfo, rTimeout);

	if (rTimeout <= SEC_TO_SYSTIME(WAKE_LOCK_MAX_TIME)) {
		fgNeedWakeLock = TRUE;

		if (!prRootTimer->fgWakeLocked) {
			KAL_WAKE_LOCK(prAdapter, &prRootTimer->rWakeLock);
			prRootTimer->fgWakeLocked = TRUE;
		}
	} else {
		fgNeedWakeLock = FALSE;
	}

	return fgNeedWakeLock;
}

/*----------------------------------------------------------------------------*/
/*!
* \brief This routines is called to initialize a root timer.
*
* \param[in] prAdapter
*
* \return (none)
*/
/*----------------------------------------------------------------------------*/
VOID cnmTimerInitialize(IN P_ADAPTER_T prAdapter)
{
	P_ROOT_TIMER prRootTimer;
	KAL_SPIN_LOCK_DECLARATION();

	ASSERT(prAdapter);

	prRootTimer = &prAdapter->rRootTimer;

	/* Note: glue layer have configured timer */

	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
	LINK_INITIALIZE(&prRootTimer->rLinkHead);
	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);

	KAL_WAKE_LOCK_INIT(prAdapter, &prRootTimer->rWakeLock, "WLAN Timer");
	prRootTimer->fgWakeLocked = FALSE;
	return;
}

/*----------------------------------------------------------------------------*/
/*!
* \brief This routines is called to destroy a root timer.
*        When WIFI is off, the token shall be returned back to system.
*
* \param[in]
*
* \return (none)
*/
/*----------------------------------------------------------------------------*/
VOID cnmTimerDestroy(IN P_ADAPTER_T prAdapter)
{
	P_ROOT_TIMER prRootTimer;
	KAL_SPIN_LOCK_DECLARATION();

	ASSERT(prAdapter);

	prRootTimer = &prAdapter->rRootTimer;

	if (prRootTimer->fgWakeLocked) {
		KAL_WAKE_UNLOCK(prAdapter, &prRootTimer->rWakeLock);
		prRootTimer->fgWakeLocked = FALSE;
	}
	KAL_WAKE_LOCK_DESTROY(prAdapter, &prRootTimer->rWakeLock);

	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
	LINK_INITIALIZE(&prRootTimer->rLinkHead);
	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);

	/* Note: glue layer will be responsible for timer destruction */

	return;
}

/*----------------------------------------------------------------------------*/
/*!
* \brief This routines is called to initialize a timer.
*
* \param[in] prTimer Pointer to a timer structure.
* \param[in] pfnFunc Pointer to the call back function.
* \param[in] u4Data Parameter for call back function.
*
* \return (none)
*/
/*----------------------------------------------------------------------------*/
VOID
cnmTimerInitTimer(IN P_ADAPTER_T prAdapter,
		  IN P_TIMER_T prTimer, IN PFN_MGMT_TIMEOUT_FUNC pfFunc, IN UINT_32 u4Data)
{
	ASSERT(prAdapter);

	ASSERT(prTimer);

#if DBG
	/* Note: NULL function pointer is permitted for HEM POWER */
	if (pfFunc == NULL) {
		DBGLOG(CNM, WARN, ("Init timer with NULL callback function!\n"));
	}
#endif

#if DBG
	ASSERT(prAdapter->rRootTimer.rLinkHead.prNext);
	{
		P_LINK_T prTimerList;
		P_LINK_ENTRY_T prLinkEntry;
		P_TIMER_T prPendingTimer;

		prTimerList = &(prAdapter->rRootTimer.rLinkHead);

		LINK_FOR_EACH(prLinkEntry, prTimerList) {
			prPendingTimer = LINK_ENTRY(prLinkEntry, TIMER_T, rLinkEntry);
			ASSERT(prPendingTimer);
			ASSERT(prPendingTimer != prTimer);
		}
	}
#endif

	LINK_ENTRY_INITIALIZE(&prTimer->rLinkEntry);

	prTimer->pfMgmtTimeOutFunc = pfFunc;
	prTimer->u4Data = u4Data;

	return;
}


/*----------------------------------------------------------------------------*/
/*!
* \brief This routines is called to stop a timer.
*
* \param[in] prTimer Pointer to a timer structure.
*
* \return (none)
*/
/*----------------------------------------------------------------------------*/
static VOID
cnmTimerStopTimer_impl(IN P_ADAPTER_T prAdapter, IN P_TIMER_T prTimer, IN BOOLEAN fgAcquireSpinlock)
{
	P_ROOT_TIMER prRootTimer;
	KAL_SPIN_LOCK_DECLARATION();

	ASSERT(prAdapter);
	ASSERT(prTimer);

	prRootTimer = &prAdapter->rRootTimer;

	if (fgAcquireSpinlock) {
		KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
	}

	if (timerPendingTimer(prTimer)) {
		LINK_REMOVE_KNOWN_ENTRY(&prRootTimer->rLinkHead, &prTimer->rLinkEntry);

		/* Reduce dummy timeout for power saving, especially HIF activity.
		 * If two or more timers exist and being removed timer is smallest,
		 * this dummy timeout will still happen, but it is OK.
		 */
		if (LINK_IS_EMPTY(&prRootTimer->rLinkHead)) {
			kalCancelTimer(prAdapter->prGlueInfo);

			if (fgAcquireSpinlock && prRootTimer->fgWakeLocked) {
				KAL_WAKE_UNLOCK(prAdapter, &prRootTimer->rWakeLock);
				prRootTimer->fgWakeLocked = FALSE;
			}
		}
	}

	if (fgAcquireSpinlock) {
		KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
	}
}

/*----------------------------------------------------------------------------*/
/*!
* \brief This routines is called to stop a timer.
*
* \param[in] prTimer Pointer to a timer structure.
*
* \return (none)
*/
/*----------------------------------------------------------------------------*/
VOID cnmTimerStopTimer(IN P_ADAPTER_T prAdapter, IN P_TIMER_T prTimer)
{
	ASSERT(prAdapter);
	ASSERT(prTimer);

	cnmTimerStopTimer_impl(prAdapter, prTimer, TRUE);
}

/*----------------------------------------------------------------------------*/
/*!
* \brief This routines is called to start a timer with wake_lock.
*
* \param[in] prTimer Pointer to a timer structure.
* \param[in] u4TimeoutMs Timeout to issue the timer and call back function
*                        (unit: ms).
*
* \return (none)
*/
/*----------------------------------------------------------------------------*/
VOID cnmTimerStartTimer(IN P_ADAPTER_T prAdapter, IN P_TIMER_T prTimer, IN UINT_32 u4TimeoutMs)
{
	P_ROOT_TIMER prRootTimer;
	P_LINK_T prTimerList;
	OS_SYSTIME rExpiredSysTime, rTimeoutSystime;
	KAL_SPIN_LOCK_DECLARATION();

	ASSERT(prAdapter);
	ASSERT(prTimer);

	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);

	prRootTimer = &prAdapter->rRootTimer;
	prTimerList = &prRootTimer->rLinkHead;

	/* If timeout interval is larger than 1 minute, the mod value is set
	 * to the timeout value first, then per minutue.
	 */
	if (u4TimeoutMs > MSEC_PER_MIN) {
		ASSERT(u4TimeoutMs <= ((UINT_32) 0xFFFF * MSEC_PER_MIN));

		prTimer->u2Minutes = (UINT_16) (u4TimeoutMs / MSEC_PER_MIN);
		u4TimeoutMs -= (prTimer->u2Minutes * MSEC_PER_MIN);
		if (u4TimeoutMs == 0) {
			u4TimeoutMs = MSEC_PER_MIN;
			prTimer->u2Minutes--;
		}
	} else {
		prTimer->u2Minutes = 0;
	}

	/* The assertion check if MSEC_TO_SYSTIME() may be overflow. */
	ASSERT(u4TimeoutMs < (((UINT_32) 0x80000000 - MSEC_PER_SEC) / KAL_HZ));
	rTimeoutSystime = MSEC_TO_SYSTIME(u4TimeoutMs);
	rExpiredSysTime = kalGetTimeTick() + rTimeoutSystime;

	/* If no timer pending or the fast time interval is used. */
	if (LINK_IS_EMPTY(prTimerList) ||
	    TIME_BEFORE(rExpiredSysTime, prRootTimer->rNextExpiredSysTime)) {

		prRootTimer->rNextExpiredSysTime = rExpiredSysTime;
		cnmTimerSetTimer(prAdapter, rTimeoutSystime);
	}

	/* Add this timer to checking list */
	prTimer->rExpiredSysTime = rExpiredSysTime;

	if (!timerPendingTimer(prTimer)) {
		LINK_INSERT_TAIL(prTimerList, &prTimer->rLinkEntry);
	}

	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);

	return;
}

/*----------------------------------------------------------------------------*/
/*!
* \brief This routines is called to check the timer list.
*
* \param[in]
*
* \return (none)
*/
/*----------------------------------------------------------------------------*/
VOID cnmTimerDoTimeOutCheck(IN P_ADAPTER_T prAdapter)
{
	P_ROOT_TIMER prRootTimer;
	P_LINK_T prTimerList;
	P_LINK_ENTRY_T prLinkEntry;
	P_TIMER_T prTimer;
	OS_SYSTIME rCurSysTime;
	PFN_MGMT_TIMEOUT_FUNC pfMgmtTimeOutFunc;
	UINT_32 u4TimeoutData;
	BOOLEAN fgNeedWakeLock;
	KAL_SPIN_LOCK_DECLARATION();

	ASSERT(prAdapter);

	/* acquire spin lock */
	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);

	prRootTimer = &prAdapter->rRootTimer;
	prTimerList = &prRootTimer->rLinkHead;

	rCurSysTime = kalGetTimeTick();

	/* Set the permitted max timeout value for new one */
	prRootTimer->rNextExpiredSysTime = rCurSysTime + MGMT_MAX_TIMEOUT_INTERVAL;

	LINK_FOR_EACH(prLinkEntry, prTimerList) {
		prTimer = LINK_ENTRY(prLinkEntry, TIMER_T, rLinkEntry);
		ASSERT(prTimer);

		/* Check if this entry is timeout. */
		if (!TIME_BEFORE(rCurSysTime, prTimer->rExpiredSysTime)) {
			cnmTimerStopTimer_impl(prAdapter, prTimer, FALSE);

			pfMgmtTimeOutFunc = prTimer->pfMgmtTimeOutFunc;
			u4TimeoutData = prTimer->u4Data;

			if (prTimer->u2Minutes > 0) {
				prTimer->u2Minutes--;
				prTimer->rExpiredSysTime =
				    rCurSysTime + MSEC_TO_SYSTIME(MSEC_PER_MIN);
				LINK_INSERT_TAIL(prTimerList, &prTimer->rLinkEntry);
			} else if (pfMgmtTimeOutFunc) {
				KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
				(pfMgmtTimeOutFunc) (prAdapter, u4TimeoutData);
				KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
			}

			/* Search entire list again because of nest del and add timers
			 * and current MGMT_TIMER could be volatile after stopped
			 */
			prLinkEntry = (P_LINK_ENTRY_T) prTimerList;

			prRootTimer->rNextExpiredSysTime = rCurSysTime + MGMT_MAX_TIMEOUT_INTERVAL;
		} else if (TIME_BEFORE(prTimer->rExpiredSysTime, prRootTimer->rNextExpiredSysTime)) {
			prRootTimer->rNextExpiredSysTime = prTimer->rExpiredSysTime;
		}
	}			/* end of for loop */

	/* Setup the prNext timeout event. It is possible the timer was already
	 * set in the above timeout callback function.
	 */
	fgNeedWakeLock = FALSE;
	if (!LINK_IS_EMPTY(prTimerList)) {
		ASSERT(TIME_AFTER(prRootTimer->rNextExpiredSysTime, rCurSysTime));

		fgNeedWakeLock = cnmTimerSetTimer(prAdapter, (OS_SYSTIME)
						  ((INT_32) prRootTimer->rNextExpiredSysTime -
						   (INT_32) rCurSysTime));
	}

	if (prRootTimer->fgWakeLocked && !fgNeedWakeLock) {
		KAL_WAKE_UNLOCK(prAdapter, &prRootTimer->rWakeLock);
		prRootTimer->fgWakeLocked = FALSE;
	}

	/* release spin lock */
	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
}
Commit	Line	Data
6fa3eb70 S	1	/*
	2	** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/mgmt/cnm_timer.c#1 $
	3	*/
	4
	5	/*! \file "cnm_timer.c"
	6	\brief
	7
	8	*/
	9
	10
	11
	12	/*
	13	** $Log: cnm_timer.c $
	14	*
	15	* 12 13 2011 cm.chang
	16	* [WCXRP00001136] [All Wi-Fi][Driver] Add wake lock for pending timer
	17	* Add wake lock if timer timeout value is smaller than 5 seconds
	18	*
	19	* 02 24 2011 cp.wu
	20	* [WCXRP00000490] [MT6620 Wi-Fi][Driver][Win32] modify kalMsleep() implementation because NdisMSleep() won't sleep long enough for specified interval such as 500ms
	21	* modify cnm_timer and hem_mbox APIs to be thread safe to ease invoking restrictions
	22	*
	23	* 07 08 2010 cp.wu
	24	*
	25	* [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
	26	*
	27	* 06 08 2010 cp.wu
	28	* [WPD00003833][MT6620 and MT5931] Driver migration
	29	* cnm_timer has been migrated.
	30	*
	31	* 05 28 2010 cm.chang
	32	* [BORA00000018]Integrate WIFI part into BORA for the 1st time
	33	* Support sleep notification to host
	34	*
	35	* 05 19 2010 cm.chang
	36	* [BORA00000018]Integrate WIFI part into BORA for the 1st time
	37	* Add some checking assertions
	38	*
	39	* 04 24 2010 cm.chang
	40	* [BORA00000018]Integrate WIFI part into BORA for the 1st time
	41	* Return timer token back to COS when entering wait off state
	42	*
	43	* 01 11 2010 cm.chang
	44	* [BORA00000018]Integrate WIFI part into BORA for the 1st time
	45	* Remove compiling warning
	46	*
	47	* 01 08 2010 cm.chang
	48	* [BORA00000018]Integrate WIFI part into BORA for the 1st time
	49	* Support longer timeout interval to 45 days from 65secu1rwduu`wvpghlqg\|fh+fmdkb
	50	*
	51	* 01 06 2010 cm.chang
	52	* [BORA00000018]Integrate WIFI part into BORA for the 1st time
	53	* Fix system time is 32KHz instead of 1ms
	54	*
	55	* 01 04 2010 tehuang.liu
	56	* [BORA00000018]Integrate WIFI part into BORA for the 1st time
	57	* For working out the first connection Chariot-verified version
	58	*
	59	* Dec 3 2009 mtk01461
	60	* [BORA00000018] Integrate WIFI part into BORA for the 1st time
	61	* Place rRootTimer.rNextExpiredSysTime = rExpiredSysTime; before set timer
	62	*
	63	* Oct 30 2009 mtk01104
	64	* [BORA00000018] Integrate WIFI part into BORA for the 1st time
65	* In cnmTimerInitialize(), just stop timer if it was already created.
66	*
67	* Oct 30 2009 mtk01461
68	* [BORA00000018] Integrate WIFI part into BORA for the 1st time
69	* Move the external reference for Lint to precomp.h
70	*
71	* Oct 30 2009 mtk01461
72	* [BORA00000018] Integrate WIFI part into BORA for the 1st time
73	* Fix lint warning
74	*
75	* Oct 28 2009 mtk01104
76	* [BORA00000018] Integrate WIFI part into BORA for the 1st time
77	*
78	**
79	*/
80
81	/*******************************************************************************
82	* C O M P I L E R F L A G S
83	********************************************************************************
84	*/
85
86	/*******************************************************************************
87	* E X T E R N A L R E F E R E N C E S
88	********************************************************************************
89	*/
90	#include "precomp.h"
91
92	/*******************************************************************************
93	* C O N S T A N T S
94	********************************************************************************
95	*/
96
97	/*******************************************************************************
98	* D A T A T Y P E S
99	********************************************************************************
100	*/
101
102	/*******************************************************************************
103	* P U B L I C D A T A
104	********************************************************************************
105	*/
106
107	/*******************************************************************************
108	* P R I V A T E D A T A
109	********************************************************************************
110	*/
111
112	/*******************************************************************************
113	* M A C R O S
114	********************************************************************************
115	*/
116
117	/*******************************************************************************
118	* F U N C T I O N D E C L A R A T I O N S
119	********************************************************************************
120	*/
121
122	/*******************************************************************************
123	* F U N C T I O N S
124	********************************************************************************
125	*/
126
127	/----------------------------------------------------------------------------/
128	/*!
129	* \brief This routine is called to set the time to do the time out check.
130	*
131	* \param[in] rTimeout Time out interval from current time.
132	*
133	* \retval TRUE Success.
134	*
135	*/
136	/----------------------------------------------------------------------------/
137	static BOOLEAN cnmTimerSetTimer(IN P_ADAPTER_T prAdapter, IN OS_SYSTIME rTimeout)
138	{
139	P_ROOT_TIMER prRootTimer;
140	BOOLEAN fgNeedWakeLock;
141
142	ASSERT(prAdapter);
143
144	prRootTimer = &prAdapter->rRootTimer;
145
146	kalSetTimer(prAdapter->prGlueInfo, rTimeout);
147
148	if (rTimeout <= SEC_TO_SYSTIME(WAKE_LOCK_MAX_TIME)) {
149	fgNeedWakeLock = TRUE;
150
151	if (!prRootTimer->fgWakeLocked) {
152	KAL_WAKE_LOCK(prAdapter, &prRootTimer->rWakeLock);
153	prRootTimer->fgWakeLocked = TRUE;
154	}
155	} else {
156	fgNeedWakeLock = FALSE;
157	}
158
159	return fgNeedWakeLock;
160	}
161
162	/----------------------------------------------------------------------------/
163	/*!
164	* \brief This routines is called to initialize a root timer.
165	*
166	* \param[in] prAdapter
167	*
168	* \return (none)
169	*/
170	/----------------------------------------------------------------------------/
171	VOID cnmTimerInitialize(IN P_ADAPTER_T prAdapter)
172	{
173	P_ROOT_TIMER prRootTimer;
174	KAL_SPIN_LOCK_DECLARATION();
175
176	ASSERT(prAdapter);
177
178	prRootTimer = &prAdapter->rRootTimer;
179
180	/* Note: glue layer have configured timer */
181
182	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
183	LINK_INITIALIZE(&prRootTimer->rLinkHead);
184	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
185
186	KAL_WAKE_LOCK_INIT(prAdapter, &prRootTimer->rWakeLock, "WLAN Timer");
187	prRootTimer->fgWakeLocked = FALSE;
188	return;
189	}
190
191	/----------------------------------------------------------------------------/
192	/*!
193	* \brief This routines is called to destroy a root timer.
194	* When WIFI is off, the token shall be returned back to system.
195	*
196	* \param[in]
197	*
198	* \return (none)
199	*/
200	/----------------------------------------------------------------------------/
201	VOID cnmTimerDestroy(IN P_ADAPTER_T prAdapter)
202	{
203	P_ROOT_TIMER prRootTimer;
204	KAL_SPIN_LOCK_DECLARATION();
205
206	ASSERT(prAdapter);
207
208	prRootTimer = &prAdapter->rRootTimer;
209
210	if (prRootTimer->fgWakeLocked) {
211	KAL_WAKE_UNLOCK(prAdapter, &prRootTimer->rWakeLock);
212	prRootTimer->fgWakeLocked = FALSE;
213	}
214	KAL_WAKE_LOCK_DESTROY(prAdapter, &prRootTimer->rWakeLock);
215
216	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
217	LINK_INITIALIZE(&prRootTimer->rLinkHead);
218	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
219
220	/* Note: glue layer will be responsible for timer destruction */
221
222	return;
223	}
224
225	/----------------------------------------------------------------------------/
226	/*!
227	* \brief This routines is called to initialize a timer.
228	*
229	* \param[in] prTimer Pointer to a timer structure.
230	* \param[in] pfnFunc Pointer to the call back function.
231	* \param[in] u4Data Parameter for call back function.
232	*
233	* \return (none)
234	*/
235	/----------------------------------------------------------------------------/
236	VOID
237	cnmTimerInitTimer(IN P_ADAPTER_T prAdapter,
238	IN P_TIMER_T prTimer, IN PFN_MGMT_TIMEOUT_FUNC pfFunc, IN UINT_32 u4Data)
239	{
240	ASSERT(prAdapter);
241
242	ASSERT(prTimer);
243
244	#if DBG
245	/* Note: NULL function pointer is permitted for HEM POWER */
246	if (pfFunc == NULL) {
247	DBGLOG(CNM, WARN, ("Init timer with NULL callback function!\n"));
248	}
249	#endif
250
251	#if DBG
252	ASSERT(prAdapter->rRootTimer.rLinkHead.prNext);
253	{
254	P_LINK_T prTimerList;
255	P_LINK_ENTRY_T prLinkEntry;
256	P_TIMER_T prPendingTimer;
257
258	prTimerList = &(prAdapter->rRootTimer.rLinkHead);
259
260	LINK_FOR_EACH(prLinkEntry, prTimerList) {
261	prPendingTimer = LINK_ENTRY(prLinkEntry, TIMER_T, rLinkEntry);
262	ASSERT(prPendingTimer);
263	ASSERT(prPendingTimer != prTimer);
264	}
265	}
266	#endif
267
268	LINK_ENTRY_INITIALIZE(&prTimer->rLinkEntry);
269
270	prTimer->pfMgmtTimeOutFunc = pfFunc;
271	prTimer->u4Data = u4Data;
272
273	return;
274	}
275
276
277	/----------------------------------------------------------------------------/
278	/*!
279	* \brief This routines is called to stop a timer.
280	*
281	* \param[in] prTimer Pointer to a timer structure.
282	*
283	* \return (none)
284	*/
285	/----------------------------------------------------------------------------/
286	static VOID
287	cnmTimerStopTimer_impl(IN P_ADAPTER_T prAdapter, IN P_TIMER_T prTimer, IN BOOLEAN fgAcquireSpinlock)
288	{
289	P_ROOT_TIMER prRootTimer;
290	KAL_SPIN_LOCK_DECLARATION();
291
292	ASSERT(prAdapter);
293	ASSERT(prTimer);
294
295	prRootTimer = &prAdapter->rRootTimer;
296
297	if (fgAcquireSpinlock) {
298	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
299	}
300
301	if (timerPendingTimer(prTimer)) {
302	LINK_REMOVE_KNOWN_ENTRY(&prRootTimer->rLinkHead, &prTimer->rLinkEntry);
303
304	/* Reduce dummy timeout for power saving, especially HIF activity.
305	* If two or more timers exist and being removed timer is smallest,
306	* this dummy timeout will still happen, but it is OK.
307	*/
308	if (LINK_IS_EMPTY(&prRootTimer->rLinkHead)) {
309	kalCancelTimer(prAdapter->prGlueInfo);
310
311	if (fgAcquireSpinlock && prRootTimer->fgWakeLocked) {
312	KAL_WAKE_UNLOCK(prAdapter, &prRootTimer->rWakeLock);
313	prRootTimer->fgWakeLocked = FALSE;
314	}
315	}
316	}
317
318	if (fgAcquireSpinlock) {
319	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
320	}
321	}
322
323	/----------------------------------------------------------------------------/
324	/*!
325	* \brief This routines is called to stop a timer.
326	*
327	* \param[in] prTimer Pointer to a timer structure.
328	*
329	* \return (none)
330	*/
331	/----------------------------------------------------------------------------/
332	VOID cnmTimerStopTimer(IN P_ADAPTER_T prAdapter, IN P_TIMER_T prTimer)
333	{
334	ASSERT(prAdapter);
335	ASSERT(prTimer);
336
337	cnmTimerStopTimer_impl(prAdapter, prTimer, TRUE);
338	}
339
340	/----------------------------------------------------------------------------/
341	/*!
342	* \brief This routines is called to start a timer with wake_lock.
343	*
344	* \param[in] prTimer Pointer to a timer structure.
345	* \param[in] u4TimeoutMs Timeout to issue the timer and call back function
346	* (unit: ms).
347	*
348	* \return (none)
349	*/
350	/----------------------------------------------------------------------------/
351	VOID cnmTimerStartTimer(IN P_ADAPTER_T prAdapter, IN P_TIMER_T prTimer, IN UINT_32 u4TimeoutMs)
352	{
353	P_ROOT_TIMER prRootTimer;
354	P_LINK_T prTimerList;
355	OS_SYSTIME rExpiredSysTime, rTimeoutSystime;
356	KAL_SPIN_LOCK_DECLARATION();
357
358	ASSERT(prAdapter);
359	ASSERT(prTimer);
360
361	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
362
363	prRootTimer = &prAdapter->rRootTimer;
364	prTimerList = &prRootTimer->rLinkHead;
365
366	/* If timeout interval is larger than 1 minute, the mod value is set
367	* to the timeout value first, then per minutue.
368	*/
369	if (u4TimeoutMs > MSEC_PER_MIN) {
370	ASSERT(u4TimeoutMs <= ((UINT_32) 0xFFFF * MSEC_PER_MIN));
371
372	prTimer->u2Minutes = (UINT_16) (u4TimeoutMs / MSEC_PER_MIN);
373	u4TimeoutMs -= (prTimer->u2Minutes * MSEC_PER_MIN);
374	if (u4TimeoutMs == 0) {
375	u4TimeoutMs = MSEC_PER_MIN;
376	prTimer->u2Minutes--;
377	}
378	} else {
379	prTimer->u2Minutes = 0;
380	}
381
382	/* The assertion check if MSEC_TO_SYSTIME() may be overflow. */
383	ASSERT(u4TimeoutMs < (((UINT_32) 0x80000000 - MSEC_PER_SEC) / KAL_HZ));
384	rTimeoutSystime = MSEC_TO_SYSTIME(u4TimeoutMs);
385	rExpiredSysTime = kalGetTimeTick() + rTimeoutSystime;
386
387	/* If no timer pending or the fast time interval is used. */
388	if (LINK_IS_EMPTY(prTimerList) \|\|
389	TIME_BEFORE(rExpiredSysTime, prRootTimer->rNextExpiredSysTime)) {
390
391	prRootTimer->rNextExpiredSysTime = rExpiredSysTime;
392	cnmTimerSetTimer(prAdapter, rTimeoutSystime);
393	}
394
395	/* Add this timer to checking list */
396	prTimer->rExpiredSysTime = rExpiredSysTime;
397
398	if (!timerPendingTimer(prTimer)) {
399	LINK_INSERT_TAIL(prTimerList, &prTimer->rLinkEntry);
400	}
401
402	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
403
404	return;
405	}
406
407	/----------------------------------------------------------------------------/
408	/*!
409	* \brief This routines is called to check the timer list.
410	*
411	* \param[in]
412	*
413	* \return (none)
414	*/
415	/----------------------------------------------------------------------------/
416	VOID cnmTimerDoTimeOutCheck(IN P_ADAPTER_T prAdapter)
417	{
418	P_ROOT_TIMER prRootTimer;
419	P_LINK_T prTimerList;
420	P_LINK_ENTRY_T prLinkEntry;
421	P_TIMER_T prTimer;
422	OS_SYSTIME rCurSysTime;
423	PFN_MGMT_TIMEOUT_FUNC pfMgmtTimeOutFunc;
424	UINT_32 u4TimeoutData;
425	BOOLEAN fgNeedWakeLock;
426	KAL_SPIN_LOCK_DECLARATION();
427
428	ASSERT(prAdapter);
429
430	/* acquire spin lock */
431	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
432
433	prRootTimer = &prAdapter->rRootTimer;
434	prTimerList = &prRootTimer->rLinkHead;
435
436	rCurSysTime = kalGetTimeTick();
437
438	/* Set the permitted max timeout value for new one */
439	prRootTimer->rNextExpiredSysTime = rCurSysTime + MGMT_MAX_TIMEOUT_INTERVAL;
440
441	LINK_FOR_EACH(prLinkEntry, prTimerList) {
442	prTimer = LINK_ENTRY(prLinkEntry, TIMER_T, rLinkEntry);
443	ASSERT(prTimer);
444
445	/* Check if this entry is timeout. */
446	if (!TIME_BEFORE(rCurSysTime, prTimer->rExpiredSysTime)) {
447	cnmTimerStopTimer_impl(prAdapter, prTimer, FALSE);
448
449	pfMgmtTimeOutFunc = prTimer->pfMgmtTimeOutFunc;
450	u4TimeoutData = prTimer->u4Data;
451
452	if (prTimer->u2Minutes > 0) {
453	prTimer->u2Minutes--;
454	prTimer->rExpiredSysTime =
455	rCurSysTime + MSEC_TO_SYSTIME(MSEC_PER_MIN);
456	LINK_INSERT_TAIL(prTimerList, &prTimer->rLinkEntry);
457	} else if (pfMgmtTimeOutFunc) {
458	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
459	(pfMgmtTimeOutFunc) (prAdapter, u4TimeoutData);
460	KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
461	}
462
463	/* Search entire list again because of nest del and add timers
464	* and current MGMT_TIMER could be volatile after stopped
465	*/
466	prLinkEntry = (P_LINK_ENTRY_T) prTimerList;
467
468	prRootTimer->rNextExpiredSysTime = rCurSysTime + MGMT_MAX_TIMEOUT_INTERVAL;
469	} else if (TIME_BEFORE(prTimer->rExpiredSysTime, prRootTimer->rNextExpiredSysTime)) {
470	prRootTimer->rNextExpiredSysTime = prTimer->rExpiredSysTime;
471	}
472	} /* end of for loop */
473
474	/* Setup the prNext timeout event. It is possible the timer was already
475	* set in the above timeout callback function.
476	*/
477	fgNeedWakeLock = FALSE;
478	if (!LINK_IS_EMPTY(prTimerList)) {
479	ASSERT(TIME_AFTER(prRootTimer->rNextExpiredSysTime, rCurSysTime));
480
481	fgNeedWakeLock = cnmTimerSetTimer(prAdapter, (OS_SYSTIME)
482	((INT_32) prRootTimer->rNextExpiredSysTime -
483	(INT_32) rCurSysTime));
484	}
485
486	if (prRootTimer->fgWakeLocked && !fgNeedWakeLock) {
487	KAL_WAKE_UNLOCK(prAdapter, &prRootTimer->rWakeLock);
488	prRootTimer->fgWakeLocked = FALSE;
489	}
490
491	/* release spin lock */
492	KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TIMER);
493	}