1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /********************************************************************20**
21 Name: RLC - TMR module file
25 Desc: Source code for timer functions such as,
34 *********************************************************************21*/
35 static const char* RLOG_MODULE_NAME="TMR";
36 static int RLOG_MODULE_ID=2048;
37 static int RLOG_FILE_ID=202;
40 /* header (.h) include files */
41 #include "common_def.h"
42 #include "lkw.h" /* LKW defines */
43 #include "ckw.h" /* CKW defines */
44 #include "kwu.h" /* KWU defines */
45 #include "rgu.h" /* RGU defines */
46 #include "kw_env.h" /* RLC environment options */
48 #include "kw.h" /* RLC defines */
49 #include "kw_err.h" /* Error defines */
54 /* extern (.x) include files */
55 #include "lkw.x" /* LKW */
56 #include "ckw.x" /* CKW */
57 #include "kwu.x" /* KWU */
58 #include "rgu.x" /* RGU */
67 * @brief RLC Timer Module
71 * @def KW_TMR_CALCUATE_WAIT
73 * This macro calculates and assigns wait time based on the value of the
74 * timer and the timer resolution. Timer value of 0 signifies that the
75 * timer is not configured
77 * @param[out] _wait Time for which to arm the timer changed to proper
78 * value according to the resolution
79 * @param[in] _tmrVal Value of the timer
80 * @param[in] _timerRes Resolution of the timer
83 #define KW_TMR_CALCUATE_WAIT(_wait, _tmrVal, _timerRes) \
85 (_wait) = ((_tmrVal) * SS_TICKS_SEC)/((_timerRes) * 1000); \
86 if((0 != (_tmrVal)) && (0 == (_wait))) \
92 /* private function declarations */
93 PRIVATE Void kwBndTmrExpiry(PTR cb);
96 * @brief Handler to start timer
98 * @param[in] gCb Pointer to the RLC instance control block
99 * @param[in] cb Control block depending on the type of the timer event.
100 * It can be uplink/downlink rbCb or rgu sap control block
101 * @param[in] tmrEvnt Timer event to be started
106 PUBLIC Void kwStartTmr
113 PUBLIC Void kwStartTmr (gCb,cb, tmrEvnt)
119 /* kw005.201 added support for L2 Measurement */
121 KwL2MeasEvtCb *measEvtCb = NULLP;
129 /* kw002.201 Adjusting the wait time as per timeRes configured by layer manager */
132 case KW_EVT_UMUL_REORD_TMR:
134 KwUmUl* umUl = &(((RlcUlRbCb *)cb)->m.umUl);
135 /* kw005.201 Changed wait calculation ccpu00117634*/
136 KW_TMR_CALCUATE_WAIT(arg.wait, umUl->reOrdTmrInt, gCb->genCfg.timeRes);
138 arg.timers = &umUl->reOrdTmr;
139 arg.max = KW_MAX_UM_TMR;
142 case KW_EVT_AMUL_REORD_TMR:
144 KwAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
145 /* kw005.201 Changed wait calculation ccpu00117634*/
146 KW_TMR_CALCUATE_WAIT(arg.wait, amUl->reOrdTmrInt, gCb->genCfg.timeRes);
148 arg.timers = &amUl->reOrdTmr;
149 arg.max = KW_MAX_AM_TMR;
152 case KW_EVT_AMUL_STA_PROH_TMR:
154 KwAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
155 /* kw005.201 Changed wait calculation ccpu00117634*/
156 KW_TMR_CALCUATE_WAIT(arg.wait,
158 gCb->genCfg.timeRes);
160 arg.timers = &amUl->staProhTmr;
161 arg.max = KW_MAX_AM_TMR;
164 case KW_EVT_AMDL_POLL_RETX_TMR:
166 KwAmDl* amDl = &(((RlcDlRbCb *)cb)->m.amDl);
167 /* kw005.201 Changed wait calculation ccpu00117634*/
168 KW_TMR_CALCUATE_WAIT(arg.wait,
169 amDl->pollRetxTmrInt,
170 gCb->genCfg.timeRes);
172 arg.timers = &amDl->pollRetxTmr;
173 arg.max = KW_MAX_AM_TMR;
176 case KW_EVT_WAIT_BNDCFM:
178 KwRguSapCb* rguSap = (KwRguSapCb *)cb;
179 /* kw005.201 Changed wait calculation ccpu00117634*/
180 KW_TMR_CALCUATE_WAIT(arg.wait, rguSap->bndTmrInt, gCb->genCfg.timeRes);
182 arg.timers = &rguSap->bndTmr;
183 arg.max = KW_MAX_RGUSAP_TMR;
186 /* kw005.201 added support for L2 Measurement */
190 measEvtCb = (KwL2MeasEvtCb *)cb;
191 /* kw005.201 Changed wait calculation ccpu00117634*/
192 KW_TMR_CALCUATE_WAIT(arg.wait,
193 measEvtCb->l2TmrCfg.val,
194 gCb->genCfg.timeRes);
196 arg.timers = &measEvtCb->l2Tmr;
197 arg.max = KW_L2_MAX_TIMERS;
203 RLOG0(L_ERROR, "Invalid tmr Evnt");
209 arg.tqCp = &gCb->kwTqCp;
222 * @brief Handler to stop a timer
224 * @param[in] gCb Pointer to the RLC instance control block
225 * @param[in] cb Control block depending on the type of the timer event.
226 * It can be uplink/downlink rbCb or rgu sap control block
227 * @param[in] tmrType Timer event to be started
232 PUBLIC Void kwStopTmr
239 PUBLIC Void kwStopTmr (gCb, cb, tmrType)
246 /* kw005.201 added support for L2 Measurement */
248 KwL2MeasEvtCb *measEvtCb = NULLP;
256 case KW_EVT_UMUL_REORD_TMR:
258 arg.timers = &((RlcUlRbCb *)cb)->m.umUl.reOrdTmr;
259 arg.max = KW_MAX_UM_TMR;
262 case KW_EVT_AMUL_REORD_TMR:
264 arg.timers = &((RlcUlRbCb *)cb)->m.amUl.reOrdTmr;
265 arg.max = KW_MAX_AM_TMR;
268 case KW_EVT_AMUL_STA_PROH_TMR:
270 arg.timers = &((RlcUlRbCb *)cb)->m.amUl.staProhTmr;
271 arg.max = KW_MAX_AM_TMR;
274 case KW_EVT_AMDL_POLL_RETX_TMR:
276 arg.timers = &((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr;
277 arg.max = KW_MAX_AM_TMR;
280 case KW_EVT_WAIT_BNDCFM:
282 arg.timers = &((KwRguSapCb *)cb)->bndTmr;
283 arg.max = KW_MAX_RGUSAP_TMR;
286 /* kw005.201 added support for L2 Measurement */
290 measEvtCb = (KwL2MeasEvtCb *)cb;
291 arg.timers = &measEvtCb->l2Tmr;
292 arg.max = KW_L2_MAX_TIMERS;
298 RLOG0(L_ERROR, "Invalid tmr Evnt");
303 arg.tqCp = &gCb->kwTqCp;
316 * @brief Handler to invoke events on expiry of timer.
319 * This function is used to handle expiry of timer,it invokes relevant
322 * @param[in] cb Control block depending on the type of the timer event.
323 * It can be uplink/downlink rbCb or rgu sap control block
324 * @param[in] tmrEvnt Timer event to be started
329 PUBLIC Void kwTmrExpiry
335 PUBLIC Void kwTmrExpiry (cb, tmrEvnt)
340 /* kw005.201 added support for L2 Measurement */
345 case KW_EVT_UMUL_REORD_TMR:
347 RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
348 kwUmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
352 case KW_EVT_AMUL_REORD_TMR:
354 RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
355 kwAmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
358 case KW_EVT_AMUL_STA_PROH_TMR:
360 RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
361 kwAmmStaProTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
365 case KW_EVT_AMDL_POLL_RETX_TMR:
367 RlcDlRbCb *dlRbCb = (RlcDlRbCb *)cb;
368 RlcCb *gCb = RLC_GET_RLCCB(dlRbCb->inst);
370 kwAmmPollRetxTmrExp(gCb, dlRbCb);
372 gCb->genSts.protTimeOut++;
375 case KW_EVT_WAIT_BNDCFM:
380 /* kw005.201 L2 Measurement support */
391 * @brief Handler to check if the timer is running
393 * @param[in] gCb Pointer to the RLC instance control block
394 * @param[in] cb Control block depending on the type of the timer event.
395 * It can be uplink/downlink rbCb or rgu sap control block
396 * @param[in] tmrEvnt Timer event to be started
398 * @return Bool indicating whether the timer is running or not
410 PUBLIC Bool kwChkTmr(gCb,cb, tmrEvnt)
420 case KW_EVT_UMUL_REORD_TMR:
422 return (((RlcUlRbCb *)cb)->m.umUl.reOrdTmr.tmrEvnt ==
423 KW_EVT_UMUL_REORD_TMR);
425 case KW_EVT_AMUL_REORD_TMR:
427 return (((RlcUlRbCb *)cb)->m.amUl.reOrdTmr.tmrEvnt ==
428 KW_EVT_AMUL_REORD_TMR);
430 case KW_EVT_AMUL_STA_PROH_TMR:
432 return (((RlcUlRbCb *)cb)->m.amUl.staProhTmr.tmrEvnt ==
433 KW_EVT_AMUL_STA_PROH_TMR);
435 case KW_EVT_AMDL_POLL_RETX_TMR:
437 return (((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr.tmrEvnt ==
438 KW_EVT_AMDL_POLL_RETX_TMR);
440 case KW_EVT_WAIT_BNDCFM:
442 return (((KwRguSapCb *)cb)->bndTmr.tmrEvnt == KW_EVT_WAIT_BNDCFM);
446 RLOG0(L_ERROR, "Invalid tmr Evnt");
454 * @brief Handler to do processing on expiry of the bind timer
457 * This function processes the RLC bind timer expiry. If the number of
458 * retries is less than the maximum retry counter, bind request is sent
459 * again, else an alarm is raised to the layer manager.
461 * @param[in] cb Pointer to the Rgu sap
466 PRIVATE Void kwBndTmrExpiry
471 PRIVATE Void kwBndTmrExpiry(cb)
475 KwRguSapCb *rguSapCb;
479 rguSapCb = (KwRguSapCb *) cb;
481 if (rguSapCb->state == KW_SAP_BINDING)
483 if (rguSapCb->retryCnt < KW_MAX_SAP_BND_RETRY)
485 /* start timer to wait for bind confirm */
486 kwStartTmr(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
490 /* Send bind request */
491 rguSapCb->retryCnt++;
492 KwLiRguBndReq (&rguSapCb->pst, rguSapCb->suId, rguSapCb->spId);
496 rguSapCb->retryCnt = 0;
497 rguSapCb->state = KW_SAP_CFG;
499 /* Send alarm to the layer manager */
501 kwLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
502 LCM_CATEGORY_INTERFACE,
504 LCM_CAUSE_TMR_EXPIRED,
509 kwLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
510 LCM_CATEGORY_INTERFACE,
512 LCM_CAUSE_TMR_EXPIRED,
524 /********************************************************************30**
527 **********************************************************************/