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