src/5gnrrlc/kw_dbm_dl.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 - Database module file
  22
  23         Type:    C source file
  24
  25         Desc:    Source code for Database Module functions such as,
  26
  27                  - rlcDbmInit
  28                  - kwDbmDeInit
  29                  - kwDbmCreateRbCb
  30                  - kwDbmFetchRbCb
  31                  - kwDbmUpdateRbCb
  32                  - kwDbmDelRbCb
  33                  - kwDbmDelAllRb
  34                  - kwDbmCreateUeCb
  35                  - kwDbmFetchUeCb
  36                  - kwDbmUpdateUeCb
  37                  - kwDbmDelUeCb
  38                  - kwDbmDelAllUe
  39                  - kwDbmDelMeasEvtCb
  40                  - kwDbmCreateCellCb
  41                  - kwDbmFetchCellCb
  42                  - kwDbmUpdateCellCb
  43                  - kwDbmDelCellCb
  44                  - kwDbmDelAllCell
  45                  - kwDbmShutdown
  46
  47         File:    kw_dbm_dl.c
  48
  49 *********************************************************************21*/
  50
  51 \f
  52 /* header (.h) include files */
  53 #include "common_def.h"
  54 #include "lkw.h"           /* LKW defines */
  55 #include "ckw.h"           /* CKW defines */
  56 #include "rgu.h"           /* RGU defines */
  57 #include "kwu.h"           /* KWU defines */
  58 #include "kw_err.h"        /* Err defines */
  59 #include "kw_env.h"        /* RLC environment options */
  60 #include "kw.h"            /* RLC defines */
  61 #include "kw_udx.h"
  62 #include "kw_dl.h"
  63
  64 /* extern (.x) include files */
  65 #include "lkw.x"           /* LKW */
  66 #include "ckw.x"           /* CKW */
  67 #include "rgu.x"           /* RGU */
  68 #include "kwu.x"           /* KWU */
  69 #include "kw.x"
  70 #include "kw_udx.x"
  71 #include "kw_dl.x"
  72
  73
  74 #ifdef TENB_STATS
  75 TSL2UeStatsCb* TSL2MapUeStatsBlk (uint16_t rnti);
  76 #endif
  77 /**
  78  * @file gp_dbm_dl.c
  79  * @brief RLC Downlink database module
  80 */
  81 #define RLC_MODULE RLC_DBGMASK_DUT
  82 \f
  83
  84 /**
  85  * @brief Handler to initialize hash list
  86  *
  87  * @details
  88  *    This function initializes the UeCb, CellCb hash lists
  89  *
  90  *  @return  S16
  91  *     -# ROK
  92  *     -# RFAILED
  93 */
  94 S16 rlcDbmDlInit(RlcCb *gCb)
  95 {
  96
  97    /* Initialize ueCb Hash List */
  98    if(ROK != cmHashListInit(&(gCb->u.dlCb->ueLstCp),
  99                             (uint16_t) RLC_UE_LIST_BUCKET_SIZE,
 100                             (uint16_t) 0,
 101                             (Bool) FALSE,
 102                             (uint16_t) CM_HASH_KEYTYPE_CONID,
 103                             RLC_GET_MEM_REGION(gCb),
 104                             RLC_GET_MEM_POOL(gCb)))
 105    {
 106       DU_LOG("\nERROR  -->  RLC_DL : UeLstCp Initialization Failed");
 107       return RFAILED;
 108    }
 109
 110    /* Initialize cellCb Hash List */
 111    if(ROK != cmHashListInit(&(gCb->u.dlCb->cellLstCp),
 112                             (uint16_t) RLC_CELL_LIST_BUCKET_SIZE,
 113                             (uint16_t) 0,
 114                             (Bool) FALSE,
 115                             (uint16_t) CM_HASH_KEYTYPE_CONID,
 116                             RLC_GET_MEM_REGION(gCb),
 117                             RLC_GET_MEM_POOL(gCb)))
 118    {
 119       cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
 120       DU_LOG("\nERROR  -->  RLC_DL : CellLstCp Initialization Failed");
 121       return RFAILED;
 122    }
 123
 124 /* kw005.201 added support for L2 Measurement */
 125 #ifdef LTE_L2_MEAS_RLC
 126    /* Initialize qcI Hash List */
 127    if(ROK != cmHashListInit(&(rlcCb.rlcL2Cb.qciHlCp),
 128                             (uint16_t) RLC_QCI_LIST_BUCKET_SIZE,
 129                             (uint16_t) 0,
 130                             (Bool) TRUE,
 131                             (uint16_t) CM_HASH_KEYTYPE_DEF,
 132                             rlcCb.init.region,
 133                             rlcCb.init.pool))
 134    {
 135       cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
 136       cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
 137       DU_LOG("\nERROR  -->  RLC_DL : rlcDbmInit: cmHashListInit Failed for rlcCb.qciHlCp");
 138       return RFAILED;
 139    }
 140
 141    /* Initialize tbHlCp Hash List */
 142    if(ROK != cmHashListInit(&(rlcCb.rlcL2Cb.tbHlCp),
 143                             (uint16_t) RLC_TB_LIST_BUCKET_SIZE,
 144                             (uint16_t) 0,
 145                             (Bool) FALSE,
 146                             (uint16_t) CM_HASH_KEYTYPE_DEF,
 147                             rlcCb.init.region,
 148                             rlcCb.init.pool))
 149    {
 150       cmHashListDeinit(&rlcCb.rlcL2Cb.qciHlCp);
 151       cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
 152       cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
 153       DU_LOG("\nERROR  -->  RLC_DL : rlcDbmInit: cmHashListInit Failed for rlcCb.tbHlCp");
 154       return RFAILED;
 155    }
 156 #endif /* LTE_L2_MEAS */
 157
 158    return ROK;
 159 } /* rlcDbmDlInit */
 160
 161 \f
 162 /**
 163  * @brief Handler to De initialize hash list
 164  *
 165  * @param[in]    gCb      RLC Instance Control Block
 166  *
 167  * @return  Void
 168 */
 169 Void rlcDbmDlDeInit(RlcCb *gCb)
 170 {
 171
 172
 173    /* De Initialize ueCb Hash List */
 174    cmHashListDeinit(&(gCb->u.dlCb->ueLstCp));
 175
 176    /* De Initialize cellCb Hash List */
 177    cmHashListDeinit(&(gCb->u.dlCb->cellLstCp));
 178
 179 /* kw005.201 added support for L2 Measurement */
 180 #ifdef LTE_L2_MEAS_RLC
 181    /* De Initialize qciCb Hash List */
 182    cmHashListDeinit(&(rlcCb.rlcL2Cb.qciHlCp));
 183
 184    /* De Initialize tbHlCp Hash List */
 185    cmHashListDeinit(&(rlcCb.rlcL2Cb.tbHlCp));
 186
 187 #endif /* LTE_L2_MEAS */
 188
 189    return;
 190 } /* rlcDbmDlDeInit */
 191
 192 \f
 193 /**
 194  * @brief Handler to fetch rbCb by the rlcId
 195  *
 196  * @details
 197  *    This function is invoked by CFG to fetch rbCb from the cellCb/ueCb in
 198  *    the upper interface (CKW/KWU).
 199  *
 200  *  @param[in]    gCb     RLC Instance Control Block
 201  *  @param[in]    rlcId   RLC Identifier
 202  *  @param[out]   rbCb    RB Control Block
 203  *
 204  *  @return  Void
 205 */
 206 void rlcDbmFetchDlRbCbByRbId(RlcCb *gCb,CmLteRlcId *rlcId, RlcDlRbCb **rbCb)
 207 {
 208    *rbCb= NULLP;
 209
 210    /* Check for UE CB or CELL CB */
 211    if (rlcId->ueId == 0)
 212    {
 213       RlcDlCellCb *cellCb;
 214
 215       if(rlcId->rbId >= RLC_MAX_RB_PER_CELL)
 216       {
 217          DU_LOG("\nERROR  -->  RLC_DL : rlcDbmFetchDlRbCbByRbId : Invalid RbId, Max is [%d] \
 218             UEID:%d CELLID:%d", RLC_MAX_RB_PER_CELL, rlcId->ueId, rlcId->cellId);
 219          return;
 220       }
 221
 222       rlcDbmFetchDlCellCb(gCb,rlcId->cellId, &cellCb);
 223       if(!cellCb)
 224       {
 225          DU_LOG("\nERROR  -->  RLC_DL : rlcDbmFetchDlRbCbByRbId : CellCb[%d] not found UEID:%d \
 226             RBID:%d", rlcId->cellId, rlcId->ueId, rlcId->rbId);
 227          return;
 228       }
 229
 230       *rbCb = cellCb->rbCb[rlcId->rbId];
 231    }
 232    else
 233    {
 234       RlcDlUeCb *ueCb;
 235       if (!(RLC_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
 236       {
 237          DU_LOG("\nERROR  -->  RLC_DL : rlcDbmFetchDlRbCbByRbId : Invalid RbId[%d] for RbType[%d] \
 238             RBID:%d CELLID:%d", rlcId->rbId, rlcId->rbType, rlcId->ueId, rlcId->cellId);
 239          return;
 240       }
 241
 242       if (ROK != rlcDbmFetchDlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb))
 243       {
 244          DU_LOG("\nERROR  -->  RLC_DL : rlcDbmFetchDlRbCbByRbId : UeId [%d]: UeCb not found RBID:%d",\
 245             rlcId->ueId, rlcId->rbId);
 246          return;
 247       }
 248
 249       RLC_DBM_GET_RBCB_FROM_UECB(rlcId->rbId, rlcId->rbType, ueCb, *rbCb);
 250    }
 251
 252    return;
 253 } /* rlcDbmFetchDlRbCbByRbId */
 254
 255 \f
 256 /**
 257  * @brief Handler to fetch rbCb from Local Channel Id
 258  *
 259  * @details
 260  *    This function is invoked by CFG to fetch rbCb from the cellCb/ueCb
 261  *    from local Channel Id (CKW/KWU).
 262  *
 263  * @param[in]    gCb      -  RLC Instance Control Block
 264  * @param[in]    cellId   -  CELL Identifier
 265  * @param[in]    ueId     -  UE Identifier
 266  * @param[in]    lcId     -  Logical Channel Identifier
 267  * @param[out]   rbCb     -  RB Control Block
 268  *
 269  * @return  Void
 270  *
 271 */
 272 void rlcDbmFetchDlRbCbFromLchId(RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId, \
 273 CmLteLcId lcId, RlcDlRbCb **rbCb)
 274 {
 275    RlcDlUeCb *ueCb;
 276
 277    /* Check for UE CB or CELL CB */
 278    if (ueId == 0)
 279    {
 280       RlcDlCellCb *cellCb;
 281
 282       rlcDbmFetchDlCellCb(gCb, cellId, &cellCb);
 283       if(!cellCb)
 284       {
 285          DU_LOG("\nERROR  -->  RLC_DL : rlcDbmFetchDlRbCbFromLchId: CellCb[%d] not found UEID:%d", \
 286             cellId, ueId);
 287          return;
 288       }
 289
 290       *rbCb = cellCb->lCh[lcId - 1].dlRbCb;
 291       return;
 292    }
 293
 294    if (rlcDbmFetchDlUeCb(gCb, ueId, cellId, &ueCb) != ROK)
 295    {
 296       DU_LOG("\nERROR  -->  RLC_DL : rlcDbmFetchDlRbCbFromLchId: UeId [%d]: UeCb not found",ueId);
 297       return;
 298    }
 299
 300    *rbCb = ueCb->lCh[lcId - 1].dlRbCb;
 301
 302    return;
 303 } /* rlcDbmFetchDlRbCbFromLchId */
 304
 305 \f
 306 /**
 307  * @brief Handler to delete RbCb
 308  *
 309  * @details
 310  *    This function is invoked by CFG to remove RbCb from Ue/Cell hashlist
 311  *
 312  * @param[in] gCb       - RLC Instance Control Block
 313  * @param[in] rbCbLst   - Rb Cb List
 314  * @param[in] numRbCb   - Number of rbCbs
 315  *
 316  * @return  Void
 317  *
 318 */
 319 Void rlcDbmDelAllDlRb(RlcCb *gCb,RlcDlRbCb **rbCbLst,uint8_t numRbCb)
 320 {
 321    uint32_t idx;
 322
 323
 324    for (idx = 0; idx < numRbCb; idx++)
 325    {
 326       if (rbCbLst[idx] != NULLP)
 327       {
 328 #ifdef LTE_L2_MEAS
 329          RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, (rbCbLst[idx]));
 330 #endif
 331          if( RLC_MODE_UM == rbCbLst[idx]->mode)
 332          {
 333             rlcUmmFreeDlRbCb(gCb,rbCbLst[idx]);
 334
 335             RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcDlRbCb));
 336          }
 337          else if( RLC_MODE_AM == rbCbLst[idx]->mode)
 338          {
 339             rlcAmmFreeDlRbCb(gCb,rbCbLst[idx]);
 340          }
 341          /* ccpu00136940 */
 342          else if(RLC_MODE_TM == rbCbLst[idx]->mode)
 343          {
 344             cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCbLst[idx]->m.tm.sduQ));
 345             RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcDlRbCb));
 346          }
 347
 348       }
 349
 350    }
 351
 352    return;
 353 } /* rlcDbmDelAllDlRb */
 354
 355 \f
 356 /**
 357  * @brief  Handler to create an UeCb
 358  *
 359  * @details
 360  *    This function is invoked by CFG to create UeCb and insert into the
 361  *    Ue hashlist of RlcCb.
 362  *
 363  * @param[in] gCb       RLC Instance Control Block
 364  * @param[in] ueId      UE Identifier
 365  * @param[in] cellId    Cell Identifier
 366  * @param[in] ueCb      UE Control Block
 367  *
 368  * @return  S16
 369  *    -# ROK
 370  *    -# RFAILED
 371  *
 372 */
 373 S16 rlcDbmCreateDlUeCb(RlcCb *gCb,CmLteRnti ueId,CmLteCellId cellId,RlcDlUeCb **ueCb)
 374 {
 375    RlcDlUeCb *tUeCb;
 376
 377    RLC_ALLOC(gCb,*ueCb, sizeof(RlcDlUeCb));
 378
 379 #if (ERRCLASS & ERRCLS_ADD_RES)
 380    if (*ueCb == NULLP)
 381    {
 382       DU_LOG("\nERROR  -->  RLC_DL : Memory allocation failed cellID:%d",
 383             cellId);
 384       return RFAILED;
 385    }
 386 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 387
 388    tUeCb = *ueCb;
 389    tUeCb->ueId = ueId;
 390    tUeCb->cellId = cellId;
 391
 392    if (ROK != cmHashListInsert(&(gCb->u.dlCb->ueLstCp),
 393                                (PTR)tUeCb,
 394                                (uint8_t *)&(tUeCb->ueId),
 395                                (uint16_t) sizeof(CmLteRnti)))
 396    {
 397       DU_LOG("\nERROR  -->  RLC_DL : UeId[%u] HashList Insertion Failed",
 398             ueId);
 399       return RFAILED;
 400    }
 401    /* kw005.201 ccpu00117318, updating the statistics */
 402    gCb->genSts.numUe++;
 403
 404
 405    return ROK;
 406 } /* kwDbmCreateUeCb */
 407
 408 \f
 409 /**
 410  * @brief Handler to Fetch an UeCb
 411  *
 412  * @details
 413  *    This function is invoked by CFG to fetch UeCb from the Ue hashlist
 414  *    of RlcCb.
 415  *
 416  * @param[in]    gCb       RLC Instance Control Block
 417  * @param[in]    ueId      UE Identifier
 418  * @param[in]    cellId    Cell Identifier
 419  * @param[out]   ueCb      UE Control Block
 420  *
 421  * @return  S16
 422  *    -# ROK
 423  *    -# RFAILED
 424 */
 425 uint8_t rlcDbmFetchDlUeCb(RlcCb *gCb, CmLteRnti ueId, CmLteCellId  cellId, RlcDlUeCb **ueCb)
 426 {
 427    return (cmHashListFind(&(gCb->u.dlCb->ueLstCp),
 428                            (uint8_t *)&(ueId),
 429                            sizeof(CmLteRnti),
 430                            RLC_DEF_SEQ_NUM,
 431                            (PTR *) ueCb));
 432 } /* rlcDbmFetchDlUeCb */
 433
 434 \f
 435 /**
 436  * @brief Handler to delete an UeCb
 437  *
 438  * @details
 439  *    This function is invoked by CFG to delete UeCb from the Ue hashlist
 440  *    of RlcCb.
 441  *
 442  *
 443  * @param[in] gCb      RLC Instance Control Block
 444  * @param[in] ueCb     UE Control Block
 445  * @param[in] abrtFlag Abort Flag
 446  *
 447  * @return Void
 448  *
 449 */
 450 Void rlcDbmDelDlUeCb(RlcCb *gCb,RlcDlUeCb *ueCb,Bool abortFlag)
 451 {
 452
 453 #if  (!defined(KW_PDCP) || !(defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))
 454    UNUSED(abortFlag);
 455 #endif /* (!defined(KW_PDCP) || ! (defined(PJ_SEC_ASYNC) ||
 456           defined(PJ_CMP_ASYNC)))*/
 457
 458    /* Delete all logical channels */
 459    RLC_MEM_ZERO(ueCb->lCh,sizeof(RlcDlLch) * RLC_MAX_LCH_PER_UE);
 460
 461    /* Delete all SRB RbCbs in UeCb */
 462    rlcDbmDelAllDlRb(gCb,ueCb->srbCb, RLC_MAX_SRB_PER_UE);
 463
 464    /* Delete all DRB RbCbs in UeCb */
 465    rlcDbmDelAllDlRb(gCb,ueCb->drbCb, RLC_MAX_DRB_PER_UE);
 466
 467    /* Delete ueCb entry from ueLstCp */
 468    if(ROK != cmHashListDelete(&(gCb->u.dlCb->ueLstCp), (PTR) ueCb))
 469    {
 470       DU_LOG("\nERROR  -->  RLC_DL : UeId[%u] HashList Insertion Failed",
 471             ueCb->ueId);
 472    }
 473    /* kw005.201 ccpu00117318, updating the statistics */
 474    gCb->genSts.numUe--;
 475
 476    /* Deallocate ueCb */
 477    RLC_FREE(gCb,ueCb, sizeof(RlcDlUeCb));
 478
 479    return;
 480 } /* kwDbmDelUeCb */
 481
 482 \f
 483 /**
 484  * @brief Handler to delete all UeCbs
 485  *
 486  * @details
 487  *    This function is invoked by CFG to delete all UeCbs from the Ue
 488  *    hashlist of RlcCb.
 489  *
 490  * @param[in] gCb      RLC Instance Control Block
 491  *
 492  * @return  Void
 493 */
 494 Void rlcDbmDelAllDlUe(RlcCb  *gCb)
 495 {
 496    RlcDlUeCb *ueCb = NULLP;
 497
 498    /* Until no more ueCb is ueLstCp hash list get and delete ueCb */
 499    while (ROK == cmHashListGetNext(&(gCb->u.dlCb->ueLstCp),
 500                                    (PTR) ueCb,
 501                                    (PTR *)&ueCb))
 502    {
 503       /* Delete ueCb */
 504       rlcDbmDelDlUeCb(gCb,ueCb, TRUE);
 505
 506       ueCb = NULLP;
 507    }
 508
 509    return;
 510 } /* kwDbmDelAllUe */
 511
 512 /* kw005.201 added support for L2 Measurement */
 513 #ifdef LTE_L2_MEAS
 514 Void rlcDbmDelAllDlL2MeasTbFrmUe(RlcCb *gCb,RlcDlUeCb  *ueCb)
 515 {
 516    uint8_t       tbIdx;
 517    RlcL2MeasTb   *l2MeasTb = NULLP;
 518    for(tbIdx = 0; tbIdx < RLC_MAX_TB_PER_UE; tbIdx++)
 519    {
 520        l2MeasTb = ueCb->l2MeasTbCb[tbIdx];
 521        if(l2MeasTb != NULLP)
 522        {
 523           RLC_FREE(gCb,l2MeasTb, sizeof(RlcL2MeasTb));
 524           ueCb->l2MeasTbCb[tbIdx] = NULLP;
 525        }
 526    }
 527    return;
 528 }/* End of kwDbmDelL2MeasTb */
 529 #endif /* LTE_L2_MEAS */
 530 \f
 531 /**
 532  * @brief Handler to create CellCb
 533  *
 534  * @details
 535  *    This function is invoked by CFG to create CellCb and insert into
 536  *    the Cell hashlist of RlcCb.
 537  *
 538  *  @param[in] gCb      RLC Instance Control Block
 539  *  @param[in] cellId   Cell Identifier
 540  *  @param[in] cellCb   Cell Control Block
 541  *
 542  *  @return  S16
 543  *     -# ROK
 544  *     -# RFAILED
 545 */
 546 S16 rlcDbmCreateDlCellCb(RlcCb *gCb,CmLteCellId cellId,RlcDlCellCb **cellCb)
 547 {
 548    RlcDlCellCb *tCellCb;
 549
 550
 551    RLC_ALLOC(gCb,*cellCb, sizeof(RlcDlCellCb));
 552 #if (ERRCLASS & ERRCLS_ADD_RES)
 553    if (*cellCb == NULLP)
 554    {
 555       DU_LOG("\nERROR  -->  RLC_DL : Memory allocation failed");
 556       return RFAILED;
 557    }
 558 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 559
 560    tCellCb = *cellCb;
 561    tCellCb->cellId = cellId;
 562
 563    if(ROK != cmHashListInsert(&(gCb->u.dlCb->cellLstCp),
 564                               (PTR) tCellCb,
 565                               (uint8_t *)&(tCellCb->cellId),
 566                               (uint16_t) sizeof(CmLteCellId)))
 567    {
 568       DU_LOG("\nERROR  -->  RLC_DL : HashList Insertion Failed");
 569       return RFAILED;
 570    }
 571
 572    return (ROK);
 573 } /* rlcDbmCreateDlCellCb */
 574
 575 \f
 576 /**
 577  * @brief Handler to Fetch an CellCb
 578  *
 579  * @details
 580  *    This function is invoked by CFG to fetch UeCb from the Ue hashlist
 581  *    of RlcCb.
 582  *
 583  * @param[in]    gCb      RLC Instance Control Block
 584  * @param[in]    cellId   Cell Identifier
 585  * @param[out]   cellCb   UE Control Block
 586  *
 587  * @return  S16
 588  *    -# ROK
 589  *    -# RFAILED
 590  *
 591 */
 592 uint8_t rlcDbmFetchDlCellCb(RlcCb *gCb, CmLteCellId  cellId, RlcDlCellCb **cellCb)
 593 {
 594    *cellCb = NULLP;
 595
 596    if(ROK != cmHashListFind(&(gCb->u.dlCb->cellLstCp),
 597                             (uint8_t *)&(cellId),
 598                             sizeof(CmLteCellId),
 599                             RLC_DEF_SEQ_NUM,
 600                             (PTR*) cellCb))
 601    {
 602       DU_LOG("\nERROR  -->  RLC_DL : CellCb [%d] not found", cellId);
 603       return RFAILED;
 604    }
 605
 606    return ROK;
 607 } /* kwDbmFetchCellCb */
 608
 609 \f
 610 /**
 611  * @brief Handler to delete CellCb
 612  *
 613  * @details
 614  *    This function is invoked by CFG to delete CellCb from the Cell hashlist
 615  *    of RlcCb.
 616  *
 617  *  @param[in] gCb      RLC Instance Control Block
 618  *  @param[in] cellCb   Cell Control Block
 619  *
 620  *  @return  Void
 621 */
 622 Void rlcDbmDelDlCellCb(RlcCb *gCb,RlcDlCellCb *cellCb)
 623 {
 624
 625    /* Delete all rbCbs in cellCb */
 626    rlcDbmDelAllDlRb(gCb,cellCb->rbCb, RLC_MAX_RB_PER_CELL);
 627
 628    /* Delete cellCb entry in hash list cellLstCp */
 629    if(ROK != cmHashListDelete(&(gCb->u.dlCb->cellLstCp), (PTR) cellCb))
 630    {
 631       DU_LOG("\nERROR  -->  RLC_DL : HashList Deletion Failed");
 632    }
 633
 634    /* Deallocate cellCb */
 635    RLC_FREE(gCb, cellCb, sizeof(RlcDlCellCb));
 636
 637    return;
 638 } /* kwDbmDelCellCb */
 639
 640 \f
 641 /**
 642  * @brief Handler to delete all UeCbs
 643  *
 644  * @details
 645  *    This function is invoked by CFG to delete all UeCbs from the Ue
 646  *    hashlist of RlcCb.
 647  * @param[in] gCb      RLC Instance Control Block
 648  *
 649  * @return  Void
 650 */
 651 Void rlcDbmDelAllDlCell(RlcCb *gCb)
 652 {
 653    RlcDlCellCb *cellCb = NULLP;
 654
 655    /* Until no more cellCb is ueLstCp hash list get and delete cellCb */
 656    while (ROK == cmHashListGetNext(&(gCb->u.dlCb->cellLstCp),
 657                                    (PTR) cellCb,
 658                                    (PTR *)&cellCb))
 659    {
 660       rlcDbmDelDlCellCb(gCb, cellCb);
 661
 662       cellCb = NULLP;
 663    }
 664
 665    return;
 666 } /* rlcDbmDelAllDlCell */
 667
 668 \f
 669 /**
 670  * @brief Handler to delete all UeCbs and CellCbs
 671  *
 672  * @details
 673  *    This function is invoked by LMM to delete all UeCbs from the Ue
 674  *    hashlist of RlcCb and cellCbs from the Cell hashlist of rlcCb.
 675  *
 676  * @param[in] gCb      RLC Instance Control Block
 677  *
 678  * @return  Void
 679 */
 680 S16 rlcDbmDlShutdown(RlcCb *gCb)
 681 {
 682
 683    rlcDbmDelAllDlCell(gCb);
 684
 685    rlcDbmDelAllDlUe(gCb);
 686
 687    rlcDbmDlDeInit(gCb);
 688
 689
 690    return ROK;
 691 } /* kwDbmShutdown */
 692
 693
 694 /********************************************************************30**
 695
 696          End of file
 697 **********************************************************************/