cu link failure fix
[o-du/l2.git] / src / 5gnrrlc / kw_tmr.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
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                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
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 *******************************************************************************/
18
19 /********************************************************************20**
20   
21         Name:    RLC - TMR module file
22     
23         Type:    C source file
24   
25         Desc:    Source code for timer functions such as, 
26
27                  - kwStartTmr
28                  - kwStopTmr
29                  - kwTmrExpiry
30                  - kwBndTmrExpiry  
31                   
32         File:    kw_tmr.c
33   
34 *********************************************************************21*/
35 static const char* RLOG_MODULE_NAME="TMR";
36 static int RLOG_MODULE_ID=2048;
37 static int RLOG_FILE_ID=202;
38
39
40 /* header (.h) include files */
41 #include "envopt.h"        /* environment options */
42 #include "envdep.h"        /* environment dependent */
43 #include "envind.h"        /* environment independent */
44
45 #include "gen.h"           /* general */
46 #include "ssi.h"           /* system services */
47 #include "cm5.h"           /* common timer defines */
48 #include "cm_tkns.h"       /* common tokens defines */
49 #include "cm_mblk.h"       /* common memory allocation library defines */
50 #include "cm_llist.h"      /* common link list  defines  */
51 #include "cm_hash.h"       /* common hash list  defines */
52 #include "cm_lte.h"        /* common LTE defines */
53 #include "lkw.h"           /* LKW defines */
54 #include "ckw.h"           /* CKW defines */
55 #include "kwu.h"           /* KWU defines */
56 #include "rgu.h"           /* RGU defines */
57 #include "kw_env.h"        /* RLC environment options */
58
59 #include "kw.h"            /* RLC defines */
60 #include "kw_err.h"        /* Error defines */
61 #include "kw_ul.h"
62 #include "kw_udx.h"
63 #include "kw_dl.h"
64
65 /* extern (.x) include files */
66 #include "gen.x"           /* general */
67 #include "ssi.x"           /* system services */
68 #include "cm5.x"           /* common timer library */
69 #include "cm_tkns.x"       /* common tokens */
70 #include "cm_mblk.x"       /* common memory allocation */
71 #include "cm_llist.x"      /* common link list */
72 #include "cm_hash.x"       /* common hash list */
73 #include "cm_lte.x"        /* common LTE includes */
74 #include "cm_lib.x"        /* common memory allocation library */
75 #include "lkw.x"           /* LKW */
76 #include "ckw.x"           /* CKW */
77 #include "kwu.x"           /* KWU */
78 #include "rgu.x"           /* RGU */
79
80 #include "kw.x"
81 #include "kw_udx.x"
82 #include "kw_dl.x"
83 #include "kw_ul.x"
84
85 /** 
86  * @file gp_tmr.c
87  * @brief RLC Timer Module
88 */
89
90 /**
91  * @def KW_TMR_CALCUATE_WAIT
92  *
93  *    This macro calculates and assigns wait time based on the value of the 
94  *    timer and the timer resolution. Timer value of 0 signifies that the
95  *    timer is not configured
96  *
97  * @param[out] _wait   Time for which to arm the timer changed to proper 
98  *                     value according to the resolution
99  * @param[in] _tmrVal   Value of the timer
100  * @param[in] _timerRes   Resolution of the timer
101  *
102 */
103 #define KW_TMR_CALCUATE_WAIT(_wait, _tmrVal, _timerRes)       \
104 {                                                             \
105    (_wait) = ((_tmrVal) * SS_TICKS_SEC)/((_timerRes) * 1000); \
106    if((0 != (_tmrVal)) && (0 == (_wait)))                     \
107    {                                                          \
108       (_wait) = 1;                                            \
109    }                                                          \
110 }
111
112 /* private function declarations */
113 PRIVATE Void kwBndTmrExpiry(PTR cb);
114
115 /**
116  * @brief Handler to start timer
117  *       
118  * @param[in] gCb       Pointer to the RLC instance control block
119  * @param[in] cb        Control block depending on the type of the timer event. 
120  *                      It can be uplink/downlink rbCb or rgu sap control block
121  * @param[in] tmrEvnt   Timer event to be started
122  *
123  * @return  Void
124 */
125 #ifdef ANSI
126 PUBLIC Void kwStartTmr
127 (
128 KwCb  *gCb,
129 PTR   cb,          
130 S16   tmrEvnt     
131 )
132 #else
133 PUBLIC Void kwStartTmr (gCb,cb, tmrEvnt)
134 KwCb  *gCb;
135 PTR   cb;        
136 S16   tmrEvnt;  
137 #endif
138 {
139 /* kw005.201 added support for L2 Measurement */
140 #ifdef LTE_L2_MEAS
141    KwL2MeasEvtCb *measEvtCb = NULLP;
142 #endif
143
144    CmTmrArg arg;
145    arg.wait = 0;
146
147    TRC2(kwStartTmr)
148
149    /* kw002.201 Adjusting the wait time as per timeRes configured by layer manager */
150    switch (tmrEvnt)
151    {
152       case KW_EVT_UMUL_REORD_TMR:
153       {
154          KwUmUl* umUl = &(((KwUlRbCb *)cb)->m.umUl);
155          /* kw005.201 Changed wait calculation ccpu00117634*/ 
156          KW_TMR_CALCUATE_WAIT(arg.wait, umUl->reOrdTmrInt, gCb->genCfg.timeRes);
157
158          arg.timers = &umUl->reOrdTmr;
159          arg.max = KW_MAX_UM_TMR;
160          break;
161       }
162       case KW_EVT_AMUL_REORD_TMR:
163       {
164          KwAmUl* amUl = &(((KwUlRbCb *)cb)->m.amUl);
165          /* kw005.201 Changed wait calculation ccpu00117634*/ 
166          KW_TMR_CALCUATE_WAIT(arg.wait, amUl->reOrdTmrInt, gCb->genCfg.timeRes);         
167
168          arg.timers = &amUl->reOrdTmr;
169          arg.max = KW_MAX_AM_TMR;
170          break;
171       }
172       case KW_EVT_AMUL_STA_PROH_TMR:
173       {
174          KwAmUl* amUl = &(((KwUlRbCb *)cb)->m.amUl);
175          /* kw005.201 Changed wait calculation ccpu00117634*/ 
176          KW_TMR_CALCUATE_WAIT(arg.wait,
177                               amUl->staProhTmrInt,
178                               gCb->genCfg.timeRes);                  
179
180          arg.timers = &amUl->staProhTmr;
181          arg.max = KW_MAX_AM_TMR;
182          break;
183       } 
184       case KW_EVT_AMDL_POLL_RETX_TMR:
185       {
186          KwAmDl* amDl = &(((KwDlRbCb *)cb)->m.amDl);
187          /* kw005.201 Changed wait calculation ccpu00117634*/ 
188          KW_TMR_CALCUATE_WAIT(arg.wait, 
189                               amDl->pollRetxTmrInt, 
190                               gCb->genCfg.timeRes);                  
191
192          arg.timers = &amDl->pollRetxTmr;
193          arg.max = KW_MAX_AM_TMR;
194          break;
195       } 
196       case KW_EVT_WAIT_BNDCFM:
197       {
198          KwRguSapCb* rguSap = (KwRguSapCb *)cb;
199          /* kw005.201 Changed wait calculation ccpu00117634*/ 
200          KW_TMR_CALCUATE_WAIT(arg.wait, rguSap->bndTmrInt, gCb->genCfg.timeRes);                  
201
202          arg.timers = &rguSap->bndTmr;
203          arg.max = KW_MAX_RGUSAP_TMR;
204          break;
205       }
206 /* kw005.201 added support for L2 Measurement */
207 #ifdef LTE_L2_MEAS
208       case KW_EVT_L2_TMR:
209       {
210          measEvtCb = (KwL2MeasEvtCb *)cb;
211          /* kw005.201 Changed wait calculation ccpu00117634*/ 
212          KW_TMR_CALCUATE_WAIT(arg.wait, 
213                               measEvtCb->l2TmrCfg.val, 
214                               gCb->genCfg.timeRes);                  
215
216          arg.timers = &measEvtCb->l2Tmr;
217          arg.max = KW_L2_MAX_TIMERS;
218          break;
219       }
220 #endif
221       default:
222       {
223          RLOG0(L_ERROR, "Invalid tmr Evnt");
224       }
225    } 
226
227    if(arg.wait != 0)
228    {
229       arg.tqCp   = &gCb->kwTqCp;
230       arg.tq     = gCb->kwTq;
231       arg.cb     = cb;
232       arg.evnt   = tmrEvnt;
233       arg.tNum   = 0;
234
235       cmPlcCbTq(&arg);
236    }
237
238    RETVOID;
239 }
240
241 /**
242  * @brief Handler to stop a timer
243  *       
244  * @param[in] gCb       Pointer to the RLC instance control block
245  * @param[in] cb        Control block depending on the type of the timer event. 
246  *                      It can be uplink/downlink rbCb or rgu sap control block
247  * @param[in] tmrType   Timer event to be started
248  *
249  * @return  Void
250 */
251 #ifdef ANSI
252 PUBLIC Void kwStopTmr
253 (
254 KwCb   *gCb,
255 PTR    cb,
256 U8     tmrType
257 )
258 #else
259 PUBLIC Void kwStopTmr (gCb, cb, tmrType)
260 KwCb   *gCb;
261 PTR    cb; 
262 U8     tmrType;
263 #endif
264 {
265    CmTmrArg   arg;
266 /* kw005.201 added support for L2 Measurement */
267 #ifdef LTE_L2_MEAS
268    KwL2MeasEvtCb *measEvtCb = NULLP;
269 #endif
270    TRC2(kwStopTmr)
271
272    arg.timers = NULLP;
273
274    switch (tmrType)
275    {
276       case KW_EVT_UMUL_REORD_TMR:
277       {
278          arg.timers  = &((KwUlRbCb *)cb)->m.umUl.reOrdTmr;
279          arg.max = KW_MAX_UM_TMR;
280          break;
281       }
282       case KW_EVT_AMUL_REORD_TMR:
283       {
284          arg.timers = &((KwUlRbCb *)cb)->m.amUl.reOrdTmr;
285          arg.max = KW_MAX_AM_TMR;
286          break;
287       }
288       case KW_EVT_AMUL_STA_PROH_TMR:
289       {
290          arg.timers = &((KwUlRbCb *)cb)->m.amUl.staProhTmr;
291          arg.max = KW_MAX_AM_TMR;
292          break;
293       } 
294       case KW_EVT_AMDL_POLL_RETX_TMR:
295       {
296          arg.timers = &((KwDlRbCb *)cb)->m.amDl.pollRetxTmr;
297          arg.max = KW_MAX_AM_TMR;
298          break;
299       } 
300       case KW_EVT_WAIT_BNDCFM:
301       {
302          arg.timers = &((KwRguSapCb *)cb)->bndTmr;
303          arg.max = KW_MAX_RGUSAP_TMR;
304          break;
305       }
306 /* kw005.201 added support for L2 Measurement */
307 #ifdef LTE_L2_MEAS
308       case KW_EVT_L2_TMR:
309       {
310          measEvtCb = (KwL2MeasEvtCb *)cb;
311          arg.timers   = &measEvtCb->l2Tmr;
312          arg.max  = KW_L2_MAX_TIMERS;
313          break;
314       }
315 #endif
316       default:
317       {
318          RLOG0(L_ERROR, "Invalid tmr Evnt");
319       }
320    } 
321    if (tmrType != TMR0)
322    {
323       arg.tqCp   = &gCb->kwTqCp;
324       arg.tq     = gCb->kwTq;
325       arg.cb     = cb;
326       arg.evnt   = tmrType;
327       arg.wait   = 0;
328       arg.tNum   = 0;
329       cmRmvCbTq(&arg);
330    }
331    
332    RETVOID;
333 }
334
335 /**
336  * @brief Handler to invoke events on expiry of timer.
337  *
338  * @details
339  *    This function is used to handle expiry of timer,it invokes relevant 
340  *    functions.
341  *       
342  * @param[in] cb        Control block depending on the type of the timer event. 
343  *                      It can be uplink/downlink rbCb or rgu sap control block
344  * @param[in] tmrEvnt   Timer event to be started
345  *
346  * @return  Void
347 */
348 #ifdef ANSI
349 PUBLIC Void kwTmrExpiry
350 (
351 PTR   cb,
352 S16   tmrEvnt 
353 )
354 #else
355 PUBLIC Void kwTmrExpiry (cb, tmrEvnt)
356 PTR   cb;
357 S16   tmrEvnt;
358 #endif
359 {
360 /* kw005.201 added support for L2 Measurement */
361    TRC2(kwTmrExpiry)
362
363    switch (tmrEvnt)
364    {
365       case KW_EVT_UMUL_REORD_TMR:
366       {
367          KwUlRbCb *ulRbCb = (KwUlRbCb *)cb;
368          kwUmmReOrdTmrExp(KW_GET_KWCB(ulRbCb->inst), ulRbCb);
369
370          break;
371       }
372       case KW_EVT_AMUL_REORD_TMR:
373       {
374          KwUlRbCb *ulRbCb = (KwUlRbCb *)cb;
375          kwAmmReOrdTmrExp(KW_GET_KWCB(ulRbCb->inst), ulRbCb);
376          break;
377       }
378       case KW_EVT_AMUL_STA_PROH_TMR:
379       {
380          KwUlRbCb *ulRbCb = (KwUlRbCb *)cb;
381          kwAmmStaProTmrExp(KW_GET_KWCB(ulRbCb->inst), ulRbCb);
382
383          break;
384       }
385       case KW_EVT_AMDL_POLL_RETX_TMR:
386       {
387          KwDlRbCb *dlRbCb = (KwDlRbCb *)cb;
388          KwCb *gCb = KW_GET_KWCB(dlRbCb->inst);
389          
390          kwAmmPollRetxTmrExp(gCb, dlRbCb);
391
392          gCb->genSts.protTimeOut++;
393          break;
394       }
395       case KW_EVT_WAIT_BNDCFM:
396       {
397          kwBndTmrExpiry(cb);
398          break;
399       }
400       /* kw005.201 L2 Measurement support */
401       default:
402       {
403          break;
404       }
405    }
406
407    RETVOID;
408 }
409
410 /**
411  * @brief Handler to check if the timer is running
412  *       
413  * @param[in] gCb       Pointer to the RLC instance control block
414  * @param[in] cb        Control block depending on the type of the timer event. 
415  *                      It can be uplink/downlink rbCb or rgu sap control block
416  * @param[in] tmrEvnt   Timer event to be started
417  *
418  * @return  Bool indicating whether the timer is running or not
419  *      -# ROK 
420  *      -# RFAILED 
421 */
422 #ifdef ANSI
423 PUBLIC Bool kwChkTmr
424 (
425 KwCb   *gCb,
426 PTR    cb,
427 S16    tmrEvnt
428 )
429 #else
430 PUBLIC Bool kwChkTmr(gCb,cb, tmrEvnt)
431 KwCb   *gCb;
432 PTR    cb;
433 S16    tmrEvnt;
434 #endif
435 {
436    TRC2(kwChkTmr)
437
438    switch (tmrEvnt)
439    {
440       case KW_EVT_UMUL_REORD_TMR:
441       {
442          return (((KwUlRbCb *)cb)->m.umUl.reOrdTmr.tmrEvnt == 
443                   KW_EVT_UMUL_REORD_TMR);
444       }
445       case KW_EVT_AMUL_REORD_TMR:
446       {
447          return (((KwUlRbCb *)cb)->m.amUl.reOrdTmr.tmrEvnt == 
448                   KW_EVT_AMUL_REORD_TMR);
449       }
450       case KW_EVT_AMUL_STA_PROH_TMR:
451       {
452          return (((KwUlRbCb *)cb)->m.amUl.staProhTmr.tmrEvnt == 
453                   KW_EVT_AMUL_STA_PROH_TMR);
454       } 
455       case KW_EVT_AMDL_POLL_RETX_TMR:
456       {
457          return (((KwDlRbCb *)cb)->m.amDl.pollRetxTmr.tmrEvnt == 
458                   KW_EVT_AMDL_POLL_RETX_TMR);
459       } 
460       case KW_EVT_WAIT_BNDCFM:
461       {
462          return (((KwRguSapCb *)cb)->bndTmr.tmrEvnt == KW_EVT_WAIT_BNDCFM);
463       }
464       default:
465       {
466          RLOG0(L_ERROR, "Invalid tmr Evnt");
467       }
468    } 
469
470    RETVALUE(FALSE);
471 }
472
473 /**
474  * @brief Handler to do processing on expiry of the bind timer
475  *
476  * @details
477  *    This function processes the RLC bind timer expiry. If the number of 
478  *    retries is less than the maximum retry counter, bind request is sent 
479  *    again, else an alarm is raised to the layer manager.
480  *       
481  * @param[in] cb  Pointer to the Rgu sap
482  *
483  * @return  Void
484 */
485 #ifdef ANSI
486 PRIVATE Void kwBndTmrExpiry
487 (
488 PTR cb
489 )
490 #else
491 PRIVATE Void kwBndTmrExpiry(cb)
492 PTR cb;
493 #endif
494 {
495    KwRguSapCb *rguSapCb; 
496
497    TRC2(kwBndTmrExpiry)
498
499    rguSapCb = (KwRguSapCb *) cb;
500
501    if (rguSapCb->state == KW_SAP_BINDING)
502    {
503       if (rguSapCb->retryCnt < KW_MAX_SAP_BND_RETRY)
504       {
505          /* start timer to wait for bind confirm */
506          kwStartTmr(KW_GET_KWCB(rguSapCb->pst.srcInst),
507                     (PTR)rguSapCb, 
508                     KW_EVT_WAIT_BNDCFM);
509          
510          /* Send bind request */
511          rguSapCb->retryCnt++;
512          KwLiRguBndReq (&rguSapCb->pst, rguSapCb->suId, rguSapCb->spId);
513       }
514       else
515       {
516          rguSapCb->retryCnt = 0;
517          rguSapCb->state = KW_SAP_CFG;
518
519          /* Send alarm to the layer manager */
520 #ifdef LTE_L2_MEAS
521          kwLmmSendAlarm(KW_GET_KWCB(rguSapCb->pst.srcInst),
522                         LCM_CATEGORY_INTERFACE, 
523                         LCM_EVENT_BND_FAIL,
524                         LCM_CAUSE_TMR_EXPIRED, 
525                         0, 
526                         0, 
527                         0);
528 #else
529          kwLmmSendAlarm(KW_GET_KWCB(rguSapCb->pst.srcInst),
530                         LCM_CATEGORY_INTERFACE, 
531                         LCM_EVENT_BND_FAIL,
532                         LCM_CAUSE_TMR_EXPIRED, 
533                         0, /* suId */
534                         0 /* ueId */);
535 #endif
536       }
537    }
538
539    RETVOID;
540 }
541
542
543 \f  
544 /********************************************************************30**
545   
546          End of file
547 **********************************************************************/