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