src/5gnrrlc/rlc_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                  - rlcStartTmr
  28                  - rlcStopTmr
  29                  - rlcTmrExpiry
  30                  - rlcBndTmrExpiry
  31
  32         File:    rlc_tmr.c
  33
  34 *********************************************************************21*/
  35
  36 /* header (.h) include files */
  37 #include "common_def.h"
  38 #include "lkw.h"           /* LKW defines */
  39 #include "ckw.h"           /* CKW defines */
  40 #include "kwu.h"           /* KWU defines */
  41 #include "rgu.h"           /* RGU defines */
  42 #include "rlc_env.h"        /* RLC environment options */
  43 #include "rlc_err.h"        /* Error defines */
  44
  45 /* extern (.x) include files */
  46 #include "lkw.x"           /* LKW */
  47 #include "ckw.x"           /* CKW */
  48 #include "kwu.x"           /* KWU */
  49 #include "rgu.x"           /* RGU */
  50
  51 #include "du_app_rlc_inf.h"
  52 #include "rlc_utils.h"            /* RLC defines */
  53 #include "rlc_dl_ul_inf.h"
  54 #include "rlc_dl.h"
  55 #include "rlc_ul.h"
  56 #include "rlc_mgr.h"
  57
  58 /**
  59  * @file gp_tmr.c
  60  * @brief RLC Timer Module
  61 */
  62
  63 /**
  64  * @def RLC_TMR_CALCUATE_WAIT
  65  *
  66  *    This macro calculates and assigns wait time based on the value of the
  67  *    timer and the timer resolution. Timer value of 0 signifies that the
  68  *    timer is not configured
  69  *
  70  * @param[out] _wait   Time for which to arm the timer changed to proper
  71  *                     value according to the resolution
  72  * @param[in] _tmrVal   Value of the timer
  73  * @param[in] _timerRes   Resolution of the timer
  74  *
  75 */
  76 #define RLC_TMR_CALCUATE_WAIT(_wait, _tmrVal, _timerRes)       \
  77 {                                                             \
  78    (_wait) = ((_tmrVal) * SS_TICKS_SEC)/((_timerRes) * 1000); \
  79    if((0 != (_tmrVal)) && (0 == (_wait)))                     \
  80    {                                                          \
  81       (_wait) = 1;                                            \
  82    }                                                          \
  83 }
  84
  85 /* private function declarations */
  86 static Void rlcBndTmrExpiry(PTR cb);
  87
  88
  89 /**
  90  * @brief Handler to start timer
  91  *
  92  * @param[in] gCb       Pointer to the RLC instance control block
  93  * @param[in] cb        Control block depending on the type of the timer event.
  94  *                      It can be uplink/downlink rbCb or rgu sap control block
  95  * @param[in] tmrEvnt   Timer event to be started
  96  *
  97  * @return  Void
  98 */
  99 void rlcStartTmr(RlcCb *gCb, PTR cb, int16_t tmrEvnt)
 100 {
 101 /* kw005.201 added support for L2 Measurement */
 102 #ifdef LTE_L2_MEAS
 103    RlcL2MeasEvtCb *measEvtCb = NULLP;
 104 #endif
 105
 106    CmTmrArg arg;
 107    arg.wait = 0;
 108
 109    /* kw002.201 Adjusting the wait time as per timeRes configured by layer manager */
 110    switch (tmrEvnt)
 111    {
 112       case EVENT_RLC_UMUL_REASSEMBLE_TMR:
 113       {
 114          RlcUmUl* umUl = &(((RlcUlRbCb *)cb)->m.umUl);
 115          /* kw005.201 Changed wait calculation ccpu00117634*/
 116          RLC_TMR_CALCUATE_WAIT(arg.wait, umUl->reAsmblTmrInt, gCb->genCfg.timeRes);
 117
 118          arg.timers = &umUl->reAsmblTmr;
 119          arg.max = RLC_MAX_UM_TMR;
 120          break;
 121       }
 122       case EVENT_RLC_AMUL_REASSEMBLE_TMR:
 123       {
 124          RlcAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
 125          /* kw005.201 Changed wait calculation ccpu00117634*/
 126          RLC_TMR_CALCUATE_WAIT(arg.wait, amUl->reAsmblTmrInt, gCb->genCfg.timeRes);
 127
 128          arg.timers = &amUl->reAsmblTmr;
 129          arg.max = RLC_MAX_AM_TMR;
 130          break;
 131       }
 132       case EVENT_RLC_AMUL_STA_PROH_TMR:
 133       {
 134          RlcAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
 135          /* kw005.201 Changed wait calculation ccpu00117634*/
 136          RLC_TMR_CALCUATE_WAIT(arg.wait,
 137                               amUl->staProhTmrInt,
 138                               gCb->genCfg.timeRes);
 139
 140          arg.timers = &amUl->staProhTmr;
 141          arg.max = RLC_MAX_AM_TMR;
 142          break;
 143       }
 144       case EVENT_RLC_AMDL_POLL_RETX_TMR:
 145       {
 146          RlcAmDl* amDl = &(((RlcDlRbCb *)cb)->m.amDl);
 147          /* kw005.201 Changed wait calculation ccpu00117634*/
 148          RLC_TMR_CALCUATE_WAIT(arg.wait,
 149                               amDl->pollRetxTmrInt,
 150                               gCb->genCfg.timeRes);
 151
 152          arg.timers = &amDl->pollRetxTmr;
 153          arg.max = RLC_MAX_AM_TMR;
 154          break;
 155       }
 156       case EVENT_RLC_WAIT_BNDCFM:
 157       {
 158          RlcRguSapCb* rguSap = (RlcRguSapCb *)cb;
 159          /* kw005.201 Changed wait calculation ccpu00117634*/
 160          RLC_TMR_CALCUATE_WAIT(arg.wait, rguSap->bndTmrInt, gCb->genCfg.timeRes);
 161
 162          arg.timers = &rguSap->bndTmr;
 163          arg.max = RLC_MAX_RGUSAP_TMR;
 164          break;
 165       }
 166 /* kw005.201 added support for L2 Measurement */
 167 #ifdef LTE_L2_MEAS
 168       case EVENT_RLC_L2_TMR:
 169       {
 170          measEvtCb = (RlcL2MeasEvtCb *)cb;
 171          /* kw005.201 Changed wait calculation ccpu00117634*/
 172          RLC_TMR_CALCUATE_WAIT(arg.wait,
 173                               measEvtCb->l2TmrCfg.val,
 174                               gCb->genCfg.timeRes);
 175
 176          arg.timers = &measEvtCb->l2Tmr;
 177          arg.max = RLC_L2_MAX_TIMERS;
 178          break;
 179       }
 180 #endif
 181       case EVENT_RLC_UE_THROUGHPUT_TMR:
 182       {
 183          RlcThpt *thptCb = (RlcThpt *)cb;
 184          RLC_TMR_CALCUATE_WAIT(arg.wait, ODU_UE_THROUGHPUT_PRINT_TIME_INTERVAL, gCb->genCfg.timeRes);
 185          arg.timers = &thptCb->ueTputInfo.ueThptTmr;
 186          arg.max = RLC_MAX_THPT_TMR;
 187          break;
 188       }
 189       case EVENT_RLC_UE_DELETE_TMR:
 190       {
 191          RlcUlUeCb *ulUeCb = (RlcUlUeCb*)cb;
 192          RLC_TMR_CALCUATE_WAIT(arg.wait, RLC_UE_DELETE_WAIT_TIME, gCb->genCfg.timeRes);
 193          arg.timers = &ulUeCb->ueDeleteInfo.ueDelTmr;
 194          arg.max = RLC_MAX_UE_TMR;
 195          break;
 196       }
 197       case EVENT_RLC_SNSSAI_THROUGHPUT_TMR:
 198       {
 199          RlcThpt *thptCb = (RlcThpt *)cb;
 200          RLC_TMR_CALCUATE_WAIT(arg.wait, ODU_SNSSAI_THROUGHPUT_PRINT_TIME_INTERVAL, gCb->genCfg.timeRes);
 201          arg.timers = &thptCb->snssaiTputInfo.snssaiThptTmr;
 202          arg.max = RLC_MAX_THPT_TMR;
 203          break;
 204       }
 205       default:
 206       {
 207          DU_LOG("\nERROR  -->  RLC : rlcStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
 208       }
 209    }
 210
 211    if(arg.wait != 0)
 212    {
 213       arg.tqCp   = &gCb->rlcTqCp;
 214       arg.tq     = gCb->rlcTq;
 215       arg.cb     = cb;
 216       arg.evnt   = tmrEvnt;
 217       arg.tNum   = 0;
 218
 219       cmPlcCbTq(&arg);
 220    }
 221
 222    return;
 223 }
 224
 225 /**
 226  * @brief Handler to stop a timer
 227  *
 228  * @param[in] gCb       Pointer to the RLC instance control block
 229  * @param[in] cb        Control block depending on the type of the timer event.
 230  *                      It can be uplink/downlink rbCb or rgu sap control block
 231  * @param[in] tmrType   Timer event to be started
 232  *
 233  * @return  Void
 234 */
 235 void rlcStopTmr(RlcCb *gCb, PTR cb, uint8_t tmrType)
 236 {
 237    CmTmrArg   arg;
 238 /* kw005.201 added support for L2 Measurement */
 239 #ifdef LTE_L2_MEAS
 240    RlcL2MeasEvtCb *measEvtCb = NULLP;
 241 #endif
 242
 243    arg.timers = NULLP;
 244
 245    switch (tmrType)
 246    {
 247       case EVENT_RLC_UMUL_REASSEMBLE_TMR:
 248       {
 249          arg.timers  = &((RlcUlRbCb *)cb)->m.umUl.reAsmblTmr;
 250          arg.max = RLC_MAX_UM_TMR;
 251          break;
 252       }
 253       case EVENT_RLC_AMUL_REASSEMBLE_TMR:
 254       {
 255          arg.timers = &((RlcUlRbCb *)cb)->m.amUl.reAsmblTmr;
 256          arg.max = RLC_MAX_AM_TMR;
 257          break;
 258       }
 259       case EVENT_RLC_AMUL_STA_PROH_TMR:
 260       {
 261          arg.timers = &((RlcUlRbCb *)cb)->m.amUl.staProhTmr;
 262          arg.max = RLC_MAX_AM_TMR;
 263          break;
 264       }
 265       case EVENT_RLC_AMDL_POLL_RETX_TMR:
 266       {
 267          arg.timers = &((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr;
 268          arg.max = RLC_MAX_AM_TMR;
 269          break;
 270       }
 271       case EVENT_RLC_WAIT_BNDCFM:
 272       {
 273          arg.timers = &((RlcRguSapCb *)cb)->bndTmr;
 274          arg.max = RLC_MAX_RGUSAP_TMR;
 275          break;
 276       }
 277 /* kw005.201 added support for L2 Measurement */
 278 #ifdef LTE_L2_MEAS
 279       case EVENT_RLC_L2_TMR:
 280       {
 281          measEvtCb = (RlcL2MeasEvtCb *)cb;
 282          arg.timers   = &measEvtCb->l2Tmr;
 283          arg.max  = RLC_L2_MAX_TIMERS;
 284          break;
 285       }
 286 #endif
 287       case EVENT_RLC_UE_THROUGHPUT_TMR:
 288       {
 289          arg.timers   = &((RlcThpt *)cb)->ueTputInfo.ueThptTmr;
 290          arg.max  = RLC_MAX_THPT_TMR;
 291          break;
 292       }
 293       case EVENT_RLC_UE_DELETE_TMR:
 294       {
 295          arg.timers   = &((RlcUlUeCb*)cb)->ueDeleteInfo.ueDelTmr;
 296          arg.max  = EVENT_RLC_UE_DELETE_TMR;
 297          break;
 298       }
 299       case EVENT_RLC_SNSSAI_THROUGHPUT_TMR:
 300       {
 301          arg.timers   = &((RlcThpt *)cb)->snssaiTputInfo.snssaiThptTmr;
 302          arg.max  = RLC_MAX_THPT_TMR;
 303          break;
 304       }
 305       default:
 306       {
 307          DU_LOG("\nERROR  -->  RLC : rlcStopTmr: Invalid tmr Evnt[%d]", tmrType);
 308          break;
 309       }
 310    }
 311    if (tmrType != TMR0)
 312    {
 313       arg.tqCp   = &gCb->rlcTqCp;
 314       arg.tq     = gCb->rlcTq;
 315       arg.cb     = cb;
 316       arg.evnt   = tmrType;
 317       arg.wait   = 0;
 318       arg.tNum   = 0;
 319       cmRmvCbTq(&arg);
 320    }
 321
 322    return;
 323 }
 324
 325 /**
 326  * @brief Handler to invoke events on expiry of timer.
 327  *
 328  * @details
 329  *    This function is used to handle expiry of timer,it invokes relevant
 330  *    functions.
 331  *
 332  * @param[in] cb        Control block depending on the type of the timer event.
 333  *                      It can be uplink/downlink rbCb or rgu sap control block
 334  * @param[in] tmrEvnt   Timer event to be started
 335  *
 336  * @return  Void
 337 */
 338 Void rlcTmrExpiry(PTR cb,S16 tmrEvnt)
 339 {
 340 /* kw005.201 added support for L2 Measurement */
 341
 342    switch (tmrEvnt)
 343    {
 344       case EVENT_RLC_UMUL_REASSEMBLE_TMR:
 345       {
 346          RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
 347          rlcUmmReAsmblTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
 348
 349          break;
 350       }
 351       case EVENT_RLC_AMUL_REASSEMBLE_TMR:
 352       {
 353          RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
 354          rlcAmmReAsmblTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
 355          break;
 356       }
 357       case EVENT_RLC_AMUL_STA_PROH_TMR:
 358       {
 359          RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
 360          rlcAmmStaProTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
 361
 362          break;
 363       }
 364       case EVENT_RLC_AMDL_POLL_RETX_TMR:
 365       {
 366          RlcDlRbCb *dlRbCb = (RlcDlRbCb *)cb;
 367          RlcCb *gCb = RLC_GET_RLCCB(dlRbCb->inst);
 368
 369          rlcAmmPollRetxTmrExp(gCb, dlRbCb);
 370
 371          gCb->genSts.protTimeOut++;
 372          break;
 373       }
 374       case EVENT_RLC_WAIT_BNDCFM:
 375       {
 376          rlcBndTmrExpiry(cb);
 377          break;
 378       }
 379       case EVENT_RLC_UE_THROUGHPUT_TMR:
 380       {
 381          rlcUeThptTmrExpiry(cb);
 382          break;
 383       }
 384       case EVENT_RLC_UE_DELETE_TMR:
 385       {
 386          rlcUeDeleteTmrExpiry(cb);
 387          break;
 388       }
 389       case EVENT_RLC_SNSSAI_THROUGHPUT_TMR:
 390       {
 391          rlcSnssaiThptTmrExpiry(cb);
 392          break;
 393       }
 394       default:
 395       {
 396          break;
 397       }
 398    }
 399
 400    return;
 401 }
 402
 403 /**
 404  * @brief Handler to check if the timer is running
 405  *
 406  * @param[in] gCb       Pointer to the RLC instance control block
 407  * @param[in] cb        Control block depending on the type of the timer event.
 408  *                      It can be uplink/downlink rbCb or rgu sap control block
 409  * @param[in] tmrEvnt   Timer event to be started
 410  *
 411  * @return  Bool indicating whether the timer is running or not
 412  *      -# ROK
 413  *      -# RFAILED
 414 */
 415 bool rlcChkTmr(RlcCb *gCb, PTR cb, int16_t tmrEvnt)
 416 {
 417    switch (tmrEvnt)
 418    {
 419       case EVENT_RLC_UMUL_REASSEMBLE_TMR:
 420       {
 421          return (((RlcUlRbCb *)cb)->m.umUl.reAsmblTmr.tmrEvnt ==
 422                   EVENT_RLC_UMUL_REASSEMBLE_TMR);
 423       }
 424       case EVENT_RLC_AMUL_REASSEMBLE_TMR:
 425       {
 426          return (((RlcUlRbCb *)cb)->m.amUl.reAsmblTmr.tmrEvnt ==
 427                   EVENT_RLC_AMUL_REASSEMBLE_TMR);
 428       }
 429       case EVENT_RLC_AMUL_STA_PROH_TMR:
 430       {
 431          return (((RlcUlRbCb *)cb)->m.amUl.staProhTmr.tmrEvnt ==
 432                   EVENT_RLC_AMUL_STA_PROH_TMR);
 433       }
 434       case EVENT_RLC_AMDL_POLL_RETX_TMR:
 435       {
 436          return (((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr.tmrEvnt ==
 437                   EVENT_RLC_AMDL_POLL_RETX_TMR);
 438       }
 439       case EVENT_RLC_WAIT_BNDCFM:
 440       {
 441          return (((RlcRguSapCb *)cb)->bndTmr.tmrEvnt == EVENT_RLC_WAIT_BNDCFM);
 442       }
 443       case EVENT_RLC_UE_THROUGHPUT_TMR:
 444       {
 445          return (((RlcThpt *)cb)->ueTputInfo.ueThptTmr.tmrEvnt == EVENT_RLC_UE_THROUGHPUT_TMR);
 446       }
 447       case EVENT_RLC_UE_DELETE_TMR:
 448       {
 449          return (((RlcUlUeCb *)cb)->ueDeleteInfo.ueDelTmr.tmrEvnt == EVENT_RLC_UE_DELETE_TMR);
 450       }
 451       case EVENT_RLC_SNSSAI_THROUGHPUT_TMR:
 452       {
 453          return (((RlcThpt *)cb)->snssaiTputInfo.snssaiThptTmr.tmrEvnt == EVENT_RLC_SNSSAI_THROUGHPUT_TMR);
 454       }
 455       default:
 456       {
 457          DU_LOG("\nERROR  -->  RLC : rlcChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
 458       }
 459    }
 460
 461    return FALSE;
 462 }
 463
 464 /**
 465  * @brief Handler to do processing on expiry of the bind timer
 466  *
 467  * @details
 468  *    This function processes the RLC bind timer expiry. If the number of
 469  *    retries is less than the maximum retry counter, bind request is sent
 470  *    again, else an alarm is raised to the layer manager.
 471  *
 472  * @param[in] cb  Pointer to the Rgu sap
 473  *
 474  * @return  Void
 475 */
 476 static Void rlcBndTmrExpiry(PTR cb)
 477 {
 478    RlcRguSapCb *rguSapCb;
 479
 480    rguSapCb = (RlcRguSapCb *) cb;
 481
 482    if (rguSapCb->state == RLC_SAP_BINDING)
 483    {
 484       if (rguSapCb->retryCnt < RLC_MAX_SAP_BND_RETRY)
 485       {
 486          /* start timer to wait for bind confirm */
 487          rlcStartTmr(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
 488                     (PTR)rguSapCb,
 489                     EVENT_RLC_WAIT_BNDCFM);
 490
 491          /* Send bind request */
 492          rguSapCb->retryCnt++;
 493          RlcLiRguBndReq (&rguSapCb->pst, rguSapCb->suId, rguSapCb->spId);
 494       }
 495       else
 496       {
 497          rguSapCb->retryCnt = 0;
 498          rguSapCb->state = RLC_SAP_CFG;
 499
 500          /* Send alarm to the layer manager */
 501 #ifdef LTE_L2_MEAS
 502          rlcLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
 503                         LCM_CATEGORY_INTERFACE,
 504                         LCM_EVENT_BND_FAIL,
 505                         LCM_CAUSE_TMR_EXPIRED,
 506                         0,
 507                         0,
 508                         0);
 509 #else
 510          rlcLmmSendAlarm(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
 511                         LCM_CATEGORY_INTERFACE,
 512                         LCM_EVENT_BND_FAIL,
 513                         LCM_CAUSE_TMR_EXPIRED,
 514                         0, /* suId */
 515                         0 /* ueId */);
 516 #endif
 517       }
 518    }
 519
 520    return;
 521 }
 522
 523 /**
 524  * @brief Handler to do processing on expiry of UE throughput timer
 525  *
 526  * @details
 527  *    This function processes the RLC UE throughput timer expiry.
 528  *
 529  * @param[in] cb  Pointer to the RLC throughput struct
 530  *
 531  * @return  Void
 532  */
 533 void rlcUeThptTmrExpiry(PTR cb)
 534 {
 535    uint16_t  ueIdx;
 536    long double tpt;
 537    RlcThpt *rlcThptCb = (RlcThpt*)cb;
 538
 539    /* If cell is not up, throughput details cannot be printed */
 540    if(gCellStatus != CELL_UP)
 541    {
 542       /* Restart timer */
 543       rlcStartTmr(RLC_GET_RLCCB(rlcThptCb->inst), (PTR)(rlcThptCb), EVENT_RLC_UE_THROUGHPUT_TMR);
 544       return;
 545    }
 546
 547    /* If cell is up, print throughout for each UE attached to the cell */
 548    DU_LOG("\n===================== DL Throughput Per UE==============================");
 549    DU_LOG("\nNumber of UEs : %d", rlcThptCb->ueTputInfo.numActvUe);
 550    if(rlcThptCb->ueTputInfo.numActvUe)
 551    {
 552       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 553       {
 554          if(rlcThptCb->ueTputInfo.thptPerUe[ueIdx].ueId)
 555          {
 556             /* Spec 28.552, section 5.1.1.3 :
 557              * Throughput in kilobits/sec = (dataVol in kiloBits * 1000)/time in milligseconds
 558              *
 559              * Since our dataVol is in bytes, multiplying 0.008 to covert into kilobits i.e.
 560              * Throughput[kbits/sec] = (dataVol * 0.008 * 1000)/time in ms
 561              */
 562              tpt = (double)(rlcThptCb->ueTputInfo.thptPerUe[ueIdx].dataVol * 8)/(double)ODU_UE_THROUGHPUT_PRINT_TIME_INTERVAL;
 563
 564              DU_LOG("\nUE Id : %d   DL Tpt : %.2Lf", rlcThptCb->ueTputInfo.thptPerUe[ueIdx].ueId, tpt);
 565              rlcThptCb->ueTputInfo.thptPerUe[ueIdx].dataVol = 0;
 566          }
 567       }
 568    }
 569    DU_LOG("\n==================================================================");
 570
 571    /* Restart timer */
 572    rlcStartTmr(RLC_GET_RLCCB(rlcThptCb->inst), (PTR)rlcThptCb, EVENT_RLC_UE_THROUGHPUT_TMR);
 573
 574    return;
 575 }
 576
 577 /**
 578  * @brief Handler to do processing on expiry of the SNSSAI throughput timer
 579  *
 580  * @details
 581  *    This function processes the RLC SNSSAI throughput timer expiry.
 582  *
 583  * @param[in] cb  Pointer to the RLC throughput struct
 584  *
 585  * @return  Void
 586  */
 587 void rlcSnssaiThptTmrExpiry(PTR cb)
 588 {
 589    RlcThpt *rlcThptCb = (RlcThpt*)cb;
 590
 591    static uint8_t snssaiCntDl = 0, snssaiCntUl = 0;
 592    /*Bit map to keep record of reception of DL and UL Snssai Tput expiry*/
 593    static uint8_t snssaiTputBitmap = DIR_NONE;
 594
 595    /* If cell is not up, throughput details cannot be printed */
 596    if(gCellStatus != CELL_UP)
 597    {
 598       /* Restart timer */
 599       rlcStartTmr(RLC_GET_RLCCB(rlcThptCb->inst), (PTR)(rlcThptCb), EVENT_RLC_SNSSAI_THROUGHPUT_TMR);
 600       return;
 601    }
 602
 603    if(rlcThptCb->snssaiTputInfo.dlTputPerSnssaiList != NULLP)
 604    {
 605       snssaiCntDl = rlcCalculateTputPerSnssai(rlcThptCb->snssaiTputInfo.dlTputPerSnssaiList, DIR_DL);
 606       snssaiTputBitmap |= DIR_DL;
 607       arrTputPerSnssai[DIR_DL] = rlcThptCb->snssaiTputInfo.dlTputPerSnssaiList;
 608    }
 609    if(rlcThptCb->snssaiTputInfo.ulTputPerSnssaiList != NULLP)
 610    {
 611       snssaiCntUl = rlcCalculateTputPerSnssai(rlcThptCb->snssaiTputInfo.ulTputPerSnssaiList, DIR_UL);
 612       snssaiTputBitmap |= DIR_UL;
 613       arrTputPerSnssai[DIR_UL] = rlcThptCb->snssaiTputInfo.ulTputPerSnssaiList;
 614    }
 615    if(snssaiTputBitmap == DIR_BOTH)
 616    {
 617       //call the function
 618       BuildSliceReportToDu(MAX(snssaiCntUl, snssaiCntDl));
 619       snssaiTputBitmap = DIR_NONE;
 620    }
 621    /* Restart timer */
 622    rlcStartTmr(RLC_GET_RLCCB(rlcThptCb->inst), (PTR)rlcThptCb, EVENT_RLC_SNSSAI_THROUGHPUT_TMR);
 623    return;
 624 }
 625 /**
 626 *
 627 * @brief filling RLC UE delete configuration
 628 *
 629 * @details
 630 *    filling RLC UE delete configuration
 631 *
 632 * @params[in] RlcUlUeCb *ueCb, RlcCfgInfo *rlcUeCfg
 633 *
 634 * @return void
 635 *
 636 */
 637
 638 void fillRlcUeDelInfo(RlcUlUeCb *ueCb, RlcCfgInfo *rlcUeCfg)
 639 {
 640    uint8_t lcIdx;
 641
 642    rlcUeCfg->ueId    = ueCb->ueId;
 643    rlcUeCfg->cellId  = ueCb->cellId;
 644    rlcUeCfg->numEnt = 0;
 645    for(lcIdx=0; lcIdx<RLC_MAX_LCH_PER_UE && rlcUeCfg->numEnt < 1; lcIdx++)
 646    {
 647       if(ueCb->lCh[lcIdx].ulRbCb != NULLP)
 648       {
 649          rlcUeCfg->entCfg[rlcUeCfg->numEnt].rbId    = 0;
 650          rlcUeCfg->entCfg[rlcUeCfg->numEnt].rbType  = 0;
 651          rlcUeCfg->entCfg[rlcUeCfg->numEnt].cfgType = CKW_CFG_DELETE_UE;
 652          rlcUeCfg->numEnt++;
 653       }
 654    }
 655 }
 656
 657 /**
 658 * @brief Handler to do processing on expiry of the UE delete timer
 659 *
 660 * @details
 661 *    This function processes the RLC UE delete timer expiry.
 662 *
 663 * @param[in] cb  Pointer to the RlcUlUeCb
 664 *
 665 * @return  uint8_t
 666 */
 667
 668 uint8_t rlcUeDeleteTmrExpiry(PTR cb)
 669 {
 670    RlcCb *gRlcCb = NULLP;
 671    RlcCfgInfo *rlcUeCfg = NULLP;
 672    RlcUlUeCb *ueCb = (RlcUlUeCb*)cb;
 673
 674    gRlcCb = RLC_GET_RLCCB(ueCb->ueDeleteInfo.pst.dstInst);
 675    RLC_ALLOC(gRlcCb, rlcUeCfg, sizeof(RlcCfgInfo));
 676    if(rlcUeCfg == NULLP)
 677    {
 678       DU_LOG("\nERROR  -->  RLC: rlcUeDeleteTmrExpiry(): Failed to allocate memory");
 679       return RFAILED;
 680    }
 681    memset(rlcUeCfg, 0, sizeof(RlcCfgInfo));
 682    fillRlcUeDelInfo(ueCb, rlcUeCfg);
 683    if(RlcProcCfgReq(&ueCb->ueDeleteInfo.pst, rlcUeCfg) != ROK)
 684    {
 685       DU_LOG("\nERROR  -->  RLC: rlcUeDeleteTmrExpiry(): Failed to delete UE");
 686       if(sendRlcUeDeleteRspToDu(rlcUeCfg->cellId, rlcUeCfg->ueId, INVALID_UEID) != ROK)
 687       {
 688          DU_LOG("ERROR  --> RLC: rlcUeDeleteTmrExpiry(): Failed to send UE delete response ");
 689          return RFAILED;
 690       }
 691    }
 692    return ROK;
 693 }
 694 \f
 695 /********************************************************************30**
 696
 697          End of file
 698 **********************************************************************/