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                  - kwDbmInit
  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 "envopt.h"        /* environment options */
  57 #include "envdep.h"        /* environment dependent */
  58 #include "envind.h"        /* environment independent */
  59
  60 #include "gen.h"           /* general */
  61 #include "ssi.h"           /* system services */
  62 #include "cm5.h"           /* common timer defines */
  63 #include "cm_tkns.h"       /* common tokens defines */
  64 #include "cm_mblk.h"       /* common memory allocation library defines */
  65 #include "cm_llist.h"      /* common link list  defines  */
  66 #include "cm_hash.h"       /* common hash list  defines */
  67 #include "cm_lte.h"        /* common LTE defines */
  68 #include "lkw.h"           /* LKW defines */
  69 #include "ckw.h"           /* CKW defines */
  70 #include "kwu.h"           /* KWU defines */
  71 #include "rgu.h"           /* RGU defines */
  72 #include "kw_err.h"        /* Err defines */
  73 #include "kw_env.h"        /* RLC environment options */
  74
  75 #include "kw.h"            /* RLC defines */
  76 #include "kw_udx.h"
  77 #include "kw_dl.h"
  78
  79 /* extern (.x) include files */
  80 #include "gen.x"           /* general */
  81 #include "ssi.x"           /* system services */
  82
  83 #include "cm5.x"           /* common timer library */
  84 #include "cm_tkns.x"       /* common tokens */
  85 #include "cm_mblk.x"       /* common memory allocation */
  86 #include "cm_llist.x"      /* common link list */
  87 #include "cm_hash.x"       /* common hash list */
  88 #include "cm_lte.x"        /* common LTE includes */
  89 #include "cm_lib.x"        /* common memory allocation library */
  90 #include "lkw.x"           /* LKW */
  91 #include "ckw.x"           /* CKW */
  92 #include "kwu.x"           /* KWU */
  93 #include "rgu.x"           /* RGU */
  94
  95 #include "kw.x"
  96 #include "kw_udx.x"
  97 #include "kw_dl.x"
  98
  99
 100 #ifdef TENB_STATS
 101 EXTERN TSL2UeStatsCb* TSL2MapUeStatsBlk (U16 rnti);
 102 #endif
 103 /**
 104  * @file gp_dbm_dl.c
 105  * @brief RLC Downlink database module
 106 */
 107 #define KW_MODULE KW_DBGMASK_DUT
 108 \f
 109
 110 /**
 111  * @brief Handler to initialize hash list
 112  *
 113  * @details
 114  *    This function initializes the UeCb, CellCb hash lists
 115  *
 116  *  @return  S16
 117  *     -# ROK
 118  *     -# RFAILED
 119 */
 120 #ifdef ANSI
 121 PUBLIC S16 kwDbmDlInit
 122 (
 123 KwCb *gCb
 124 )
 125 #else
 126 PUBLIC S16 kwDbmDlInit(gCb)
 127 KwCb *gCb;
 128 #endif
 129 {
 130    TRC3(kwDbmDlInit)
 131
 132    /* Initialize ueCb Hash List */
 133    if(ROK != cmHashListInit(&(gCb->u.dlCb->ueLstCp),
 134                             (U16) KW_UE_LIST_BUCKET_SIZE,
 135                             (U16) 0,
 136                             (Bool) FALSE,
 137                             (U16) CM_HASH_KEYTYPE_CONID,
 138                             KW_GET_MEM_REGION(gCb),
 139                             KW_GET_MEM_POOL(gCb)))
 140    {
 141       RLOG0(L_ERROR, "UeLstCp Initialization Failed");
 142       RETVALUE(RFAILED);
 143    }
 144
 145    /* Initialize cellCb Hash List */
 146    if(ROK != cmHashListInit(&(gCb->u.dlCb->cellLstCp),
 147                             (U16) KW_CELL_LIST_BUCKET_SIZE,
 148                             (U16) 0,
 149                             (Bool) FALSE,
 150                             (U16) CM_HASH_KEYTYPE_CONID,
 151                             KW_GET_MEM_REGION(gCb),
 152                             KW_GET_MEM_POOL(gCb)))
 153    {
 154       cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
 155       RLOG0(L_ERROR, "CellLstCp Initialization Failed");
 156       RETVALUE(RFAILED);
 157    }
 158
 159 /* kw005.201 added support for L2 Measurement */
 160 #ifdef LTE_L2_MEAS_RLC
 161    /* Initialize qcI Hash List */
 162    if(ROK != cmHashListInit(&(kwCb.kwL2Cb.qciHlCp),
 163                             (U16) KW_QCI_LIST_BUCKET_SIZE,
 164                             (U16) 0,
 165                             (Bool) TRUE,
 166                             (U16) CM_HASH_KEYTYPE_DEF,
 167                             kwCb.init.region,
 168                             kwCb.init.pool))
 169    {
 170       cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
 171       cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
 172       RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for kwCb.qciHlCp");
 173       RETVALUE(RFAILED);
 174    }
 175
 176    /* Initialize tbHlCp Hash List */
 177    if(ROK != cmHashListInit(&(kwCb.kwL2Cb.tbHlCp),
 178                             (U16) KW_TB_LIST_BUCKET_SIZE,
 179                             (U16) 0,
 180                             (Bool) FALSE,
 181                             (U16) CM_HASH_KEYTYPE_DEF,
 182                             kwCb.init.region,
 183                             kwCb.init.pool))
 184    {
 185       cmHashListDeinit(&kwCb.kwL2Cb.qciHlCp);
 186       cmHashListDeinit(&gCb->u.dlCb->cellLstCp);
 187       cmHashListDeinit(&gCb->u.dlCb->ueLstCp);
 188       RLOG0(L_ERROR, "kwDbmInit: cmHashListInit Failed for kwCb.tbHlCp");
 189       RETVALUE(RFAILED);
 190    }
 191 #endif /* LTE_L2_MEAS */
 192
 193    RETVALUE(ROK);
 194 } /* kwDbmDlInit */
 195
 196 \f
 197 /**
 198  * @brief Handler to De initialize hash list
 199  *
 200  * @param[in]    gCb      RLC Instance Control Block
 201  *
 202  * @return  Void
 203 */
 204 #ifdef ANSI
 205 PUBLIC Void kwDbmDlDeInit
 206 (
 207 KwCb *gCb
 208 )
 209 #else
 210 PUBLIC Void kwDbmDlDeInit(gCb)
 211 KwCb *gCb;
 212 #endif
 213 {
 214    TRC3(kwDbmDlDeInit);
 215
 216
 217    /* De Initialize ueCb Hash List */
 218    cmHashListDeinit(&(gCb->u.dlCb->ueLstCp));
 219
 220    /* De Initialize cellCb Hash List */
 221    cmHashListDeinit(&(gCb->u.dlCb->cellLstCp));
 222
 223 /* kw005.201 added support for L2 Measurement */
 224 #ifdef LTE_L2_MEAS_RLC
 225    /* De Initialize qciCb Hash List */
 226    cmHashListDeinit(&(kwCb.kwL2Cb.qciHlCp));
 227
 228    /* De Initialize tbHlCp Hash List */
 229    cmHashListDeinit(&(kwCb.kwL2Cb.tbHlCp));
 230
 231 #endif /* LTE_L2_MEAS */
 232
 233    RETVOID;
 234 } /* kwDbmDlDeInit */
 235
 236 \f
 237 /**
 238  * @brief Handler to fetch rbCb by the rlcId
 239  *
 240  * @details
 241  *    This function is invoked by CFG to fetch rbCb from the cellCb/ueCb in
 242  *    the upper interface (CKW/KWU).
 243  *
 244  *  @param[in]    gCb     RLC Instance Control Block
 245  *  @param[in]    rlcId   RLC Identifier
 246  *  @param[out]   rbCb    RB Control Block
 247  *
 248  *  @return  Void
 249 */
 250 #ifdef ANSI
 251 PUBLIC Void kwDbmFetchDlRbCbByRbId
 252 (
 253 KwCb         *gCb,
 254 CmLteRlcId   *rlcId,
 255 KwDlRbCb     **rbCb
 256 )
 257 #else
 258 PUBLIC Void kwDbmFetchDlRbCbByRbId(gCb, rlcId, rbCb)
 259 KwCb         *gCb;
 260 CmLteRlcId   *rlcId;
 261 KwDlRbCb     **rbCb;
 262 #endif
 263 {
 264    TRC3(kwDbmFetchDlRbCbByRbId)
 265
 266    *rbCb= NULLP;
 267
 268    /* Check for UE CB or CELL CB */
 269    if (rlcId->ueId == 0)
 270    {
 271       KwDlCellCb *cellCb;
 272
 273       if(rlcId->rbId >= KW_MAX_RB_PER_CELL)
 274       {
 275          RLOG_ARG3(L_ERROR,DBG_RBID,rlcId->rbId ,
 276                "Invalid RbId, Max is [%d] UEID:%d CELLID:%d",
 277                KW_MAX_RB_PER_CELL,
 278                rlcId->ueId,
 279                rlcId->cellId);
 280          RETVOID;
 281       }
 282
 283       kwDbmFetchDlCellCb(gCb,rlcId->cellId, &cellCb);
 284       if(!cellCb)
 285       {
 286          RLOG_ARG2(L_ERROR,DBG_CELLID,rlcId->cellId,
 287                "CellCb not found UEID:%d RBID:%d",
 288                rlcId->ueId,
 289                rlcId->rbId);
 290          RETVOID;
 291       }
 292
 293       *rbCb = cellCb->rbCb[rlcId->rbId];
 294    }
 295    else
 296    {
 297       KwDlUeCb *ueCb;
 298       if (!(KW_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
 299       {
 300          RLOG_ARG3(L_ERROR,DBG_RBID, rlcId->rbId,
 301                "Invalid RbId for RbType[%d] RBID:%d CELLID:%d",
 302                rlcId->rbType,
 303                rlcId->ueId,
 304                rlcId->cellId);
 305          RETVOID;
 306       }
 307
 308       if (ROK != kwDbmFetchDlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb))
 309       {
 310          RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId->cellId,
 311                "UeId [%d]: UeCb not found RBID:%d",
 312                rlcId->ueId,
 313                rlcId->rbId);
 314          RETVOID;
 315       }
 316
 317       KW_DBM_GET_RBCB_FROM_UECB(rlcId->rbId, rlcId->rbType, ueCb, *rbCb);
 318    }
 319
 320    RETVOID;
 321 } /* kwDbmFetchDlRbCbByRbId */
 322
 323 \f
 324 /**
 325  * @brief Handler to fetch rbCb from Local Channel Id
 326  *
 327  * @details
 328  *    This function is invoked by CFG to fetch rbCb from the cellCb/ueCb
 329  *    from local Channel Id (CKW/KWU).
 330  *
 331  * @param[in]    gCb      -  RLC Instance Control Block
 332  * @param[in]    cellId   -  CELL Identifier
 333  * @param[in]    ueId     -  UE Identifier
 334  * @param[in]    lcId     -  Logical Channel Identifier
 335  * @param[out]   rbCb     -  RB Control Block
 336  *
 337  * @return  Void
 338  *
 339 */
 340 #ifdef ANSI
 341 PUBLIC Void kwDbmFetchDlRbCbFromLchId
 342 (
 343 KwCb          *gCb,
 344 CmLteRnti     ueId,
 345 CmLteCellId   cellId,
 346 CmLteLcId     lcId,
 347 KwDlRbCb      **rbCb
 348 )
 349 #else
 350 PUBLIC Void kwDbmFetchDlRbCbFromLchId(gCb, ueId, cellId, lcId, rbCb)
 351 KwCb          *gCb;
 352 CmLteRnti     ueId;
 353 CmLteCellId   cellId;
 354 CmLteLcId     lcId;
 355 KwDlRbCb      **rbCb;
 356 #endif
 357 {
 358    KwDlUeCb *ueCb;
 359
 360    TRC3(kwDbmFetchDlRbCbFromLchId)
 361
 362
 363    /* Check for UE CB or CELL CB */
 364    if (ueId == 0)
 365    {
 366       KwDlCellCb *cellCb;
 367
 368       kwDbmFetchDlCellCb(gCb, cellId, &cellCb);
 369       if(!cellCb)
 370       {
 371          RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,"CellCb not found UEID:%d",ueId);
 372          RETVOID;
 373       }
 374
 375       *rbCb = cellCb->lCh[lcId - 1].dlRbCb;
 376       RETVOID;
 377    }
 378
 379    if (kwDbmFetchDlUeCb(gCb, ueId, cellId, &ueCb) != ROK)
 380    {
 381       RLOG_ARG1(L_ERROR,DBG_CELLID, cellId,"UeId [%d]: UeCb not found",ueId);
 382       RETVOID;
 383    }
 384
 385    *rbCb = ueCb->lCh[lcId - 1].dlRbCb;
 386
 387    RETVOID;
 388 } /* kwDbmFetchDlRbCbFromLchId */
 389
 390 \f
 391 /**
 392  * @brief Handler to delete RbCb
 393  *
 394  * @details
 395  *    This function is invoked by CFG to remove RbCb from Ue/Cell hashlist
 396  *
 397  * @param[in] gCb       - RLC Instance Control Block
 398  * @param[in] rbCbLst   - Rb Cb List
 399  * @param[in] numRbCb   - Number of rbCbs
 400  *
 401  * @return  Void
 402  *
 403 */
 404 #ifdef ANSI
 405 PUBLIC Void kwDbmDelAllDlRb
 406 (
 407 KwCb       *gCb,
 408 KwDlRbCb   **rbCbLst,
 409 U8         numRbCb
 410 )
 411 #else
 412 PUBLIC Void kwDbmDelAllDlRb(gCb, rbCbLst, numRbCb)
 413 KwCb       *gCb;
 414 KwDlRbCb   **rbCbLst;
 415 U8         numRbCb;
 416 #endif
 417 {
 418    U32 idx;
 419
 420    TRC3(kwDbmDelAllDlRb)
 421
 422
 423    for (idx = 0; idx < numRbCb; idx++)
 424    {
 425       if (rbCbLst[idx] != NULLP)
 426       {
 427 #ifdef LTE_L2_MEAS
 428          KW_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, (rbCbLst[idx]));
 429 #endif
 430          if( CM_LTE_MODE_UM == rbCbLst[idx]->mode)
 431          {
 432             kwUmmFreeDlRbCb(gCb,rbCbLst[idx]);
 433
 434             KW_FREE (gCb,rbCbLst[idx], sizeof (KwDlRbCb));
 435          }
 436          else if( CM_LTE_MODE_AM == rbCbLst[idx]->mode)
 437          {
 438             kwAmmFreeDlRbCb(gCb,rbCbLst[idx]);
 439          }
 440          /* ccpu00136940 */
 441          else if(CM_LTE_MODE_TM == rbCbLst[idx]->mode)
 442          {
 443             cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCbLst[idx]->m.tm.sduQ));
 444             KW_FREE (gCb,rbCbLst[idx], sizeof (KwDlRbCb));
 445          }
 446
 447       }
 448
 449    }
 450
 451    RETVOID;
 452 } /* kwDbmDelAllDlRb */
 453
 454 \f
 455 /**
 456  * @brief  Handler to create an UeCb
 457  *
 458  * @details
 459  *    This function is invoked by CFG to create UeCb and insert into the
 460  *    Ue hashlist of KwCb.
 461  *
 462  * @param[in] gCb       RLC Instance Control Block
 463  * @param[in] ueId      UE Identifier
 464  * @param[in] cellId    Cell Identifier
 465  * @param[in] ueCb      UE Control Block
 466  *
 467  * @return  S16
 468  *    -# ROK
 469  *    -# RFAILED
 470  *
 471 */
 472 #ifdef ANSI
 473 PUBLIC S16 kwDbmCreateDlUeCb
 474 (
 475 KwCb          *gCb,
 476 CmLteRnti     ueId,
 477 CmLteCellId   cellId,
 478 KwDlUeCb      **ueCb
 479 )
 480 #else
 481 PUBLIC S16 kwDbmCreateDlUeCb(gCb,ueId, cellId, ueCb)
 482 KwCb          *gCb;
 483 CmLteRnti     ueId;
 484 CmLteCellId   cellId;
 485 KwDlUeCb      **ueCb;
 486 #endif
 487 {
 488    KwDlUeCb *tUeCb;
 489
 490    TRC3(kwDbmCreateDlUeCb)
 491
 492
 493    KW_ALLOC(gCb,*ueCb, sizeof(KwDlUeCb));
 494
 495 #if (ERRCLASS & ERRCLS_ADD_RES)
 496    if (*ueCb == NULLP)
 497    {
 498       RLOG_ARG1(L_FATAL,DBG_UEID,ueId,
 499             "Memory allocation failed cellID:%d",
 500             cellId);
 501       RETVALUE(RFAILED);
 502    }
 503 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 504
 505    tUeCb = *ueCb;
 506    tUeCb->ueId = ueId;
 507    tUeCb->cellId = cellId;
 508
 509    if (ROK != cmHashListInsert(&(gCb->u.dlCb->ueLstCp),
 510                                (PTR)tUeCb,
 511                                (U8 *)&(tUeCb->ueId),
 512                                (U16) sizeof(CmLteRnti)))
 513    {
 514       RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,
 515             "UeId[%u] HashList Insertion Failed",
 516             ueId);
 517       RETVALUE(RFAILED);
 518    }
 519    /* kw005.201 ccpu00117318, updating the statistics */
 520    gCb->genSts.numUe++;
 521
 522
 523    RETVALUE(ROK);
 524 } /* kwDbmCreateUeCb */
 525
 526 \f
 527 /**
 528  * @brief Handler to Fetch an UeCb
 529  *
 530  * @details
 531  *    This function is invoked by CFG to fetch UeCb from the Ue hashlist
 532  *    of KwCb.
 533  *
 534  * @param[in]    gCb       RLC Instance Control Block
 535  * @param[in]    ueId      UE Identifier
 536  * @param[in]    cellId    Cell Identifier
 537  * @param[out]   ueCb      UE Control Block
 538  *
 539  * @return  S16
 540  *    -# ROK
 541  *    -# RFAILED
 542 */
 543 #ifdef ANSI
 544 PUBLIC S16 kwDbmFetchDlUeCb
 545 (
 546 KwCb          *gCb,
 547 CmLteRnti     ueId,
 548 CmLteCellId   cellId,
 549 KwDlUeCb      **ueCb
 550 )
 551 #else
 552 PUBLIC S16 kwDbmFetchDlUeCb(gCb,ueId, cellId, ueCb)
 553 KwCb          *gCb;
 554 CmLteRnti     ueId;
 555 CmLteCellId   cellId;
 556 KwDlUeCb      **ueCb;
 557 #endif
 558 {
 559
 560    TRC3(kwDbmFetchDlUeCb)
 561
 562
 563    RETVALUE(cmHashListFind(&(gCb->u.dlCb->ueLstCp),
 564                            (U8 *)&(ueId),
 565                            sizeof(CmLteRnti),
 566                            KW_DEF_SEQ_NUM,
 567                            (PTR *) ueCb));
 568 } /* kwDbmFetchDlUeCb */
 569
 570 \f
 571 /**
 572  * @brief Handler to delete an UeCb
 573  *
 574  * @details
 575  *    This function is invoked by CFG to delete UeCb from the Ue hashlist
 576  *    of KwCb.
 577  *
 578  *
 579  * @param[in] gCb      RLC Instance Control Block
 580  * @param[in] ueCb     UE Control Block
 581  * @param[in] abrtFlag Abort Flag
 582  *
 583  * @return Void
 584  *
 585 */
 586 #ifdef ANSI
 587 PUBLIC Void kwDbmDelDlUeCb
 588 (
 589 KwCb       *gCb,
 590 KwDlUeCb   *ueCb,
 591 Bool       abortFlag
 592 )
 593 #else
 594 PUBLIC Void kwDbmDelDlUeCb(gCb,eCb, abortFlag)
 595 KwCb       *gCb;
 596 KwDlUeCb   *ueCb;
 597 Bool       abortFlag;
 598 #endif
 599 {
 600    TRC3(kwDbmDelDlUeCb)
 601
 602
 603 #if  (!defined(KW_PDCP) || !(defined(PJ_SEC_ASYNC) || defined(PJ_CMP_ASYNC)))
 604    UNUSED(abortFlag);
 605 #endif /* (!defined(KW_PDCP) || ! (defined(PJ_SEC_ASYNC) ||
 606           defined(PJ_CMP_ASYNC)))*/
 607
 608    /* Delete all logical channels */
 609    KW_MEM_ZERO(ueCb->lCh,sizeof(KwDlLch) * KW_MAX_LCH_PER_UE);
 610
 611    /* Delete all SRB RbCbs in UeCb */
 612    kwDbmDelAllDlRb(gCb,ueCb->srbCb, KW_MAX_SRB_PER_UE);
 613
 614    /* Delete all DRB RbCbs in UeCb */
 615    kwDbmDelAllDlRb(gCb,ueCb->drbCb, KW_MAX_DRB_PER_UE);
 616
 617    /* Delete ueCb entry from ueLstCp */
 618    if(ROK != cmHashListDelete(&(gCb->u.dlCb->ueLstCp), (PTR) ueCb))
 619    {
 620       RLOG_ARG1(L_ERROR,DBG_CELLID,ueCb->cellId,
 621             "UeId[%u] HashList Insertion Failed",
 622             ueCb->ueId);
 623    }
 624    /* kw005.201 ccpu00117318, updating the statistics */
 625    gCb->genSts.numUe--;
 626
 627    /* Deallocate ueCb */
 628    KW_FREE(gCb,ueCb, sizeof(KwDlUeCb));
 629
 630    RETVOID;
 631 } /* kwDbmDelUeCb */
 632
 633 \f
 634 /**
 635  * @brief Handler to delete all UeCbs
 636  *
 637  * @details
 638  *    This function is invoked by CFG to delete all UeCbs from the Ue
 639  *    hashlist of KwCb.
 640  *
 641  * @param[in] gCb      RLC Instance Control Block
 642  *
 643  * @return  Void
 644 */
 645 #ifdef ANSI
 646 PUBLIC Void kwDbmDelAllDlUe
 647 (
 648 KwCb  *gCb
 649 )
 650 #else
 651 PUBLIC Void kwDbmDelAllDlUe(gCb)
 652 KwCb  *gCb;
 653 #endif
 654 {
 655    KwDlUeCb *ueCb = NULLP;
 656
 657    TRC3(kwDbmDelAllDlUe)
 658
 659
 660    /* Until no more ueCb is ueLstCp hash list get and delete ueCb */
 661    while (ROK == cmHashListGetNext(&(gCb->u.dlCb->ueLstCp),
 662                                    (PTR) ueCb,
 663                                    (PTR *)&ueCb))
 664    {
 665       /* Delete ueCb */
 666       kwDbmDelDlUeCb(gCb,ueCb, TRUE);
 667
 668       ueCb = NULLP;
 669    }
 670
 671    RETVOID;
 672 } /* kwDbmDelAllUe */
 673
 674 /* kw005.201 added support for L2 Measurement */
 675 #ifdef LTE_L2_MEAS
 676 #ifdef ANSI
 677 PUBLIC Void kwDbmDelAllDlL2MeasTbFrmUe
 678 (
 679 KwCb      *gCb,
 680 KwDlUeCb  *ueCb
 681 )
 682 #else
 683 PUBLIC Void kwDbmDelAllDlL2MeasTbFrmUe(gCb,ueCb)
 684 KwCb      *gCb;
 685 KwDlUeCb  *ueCb;
 686 #endif
 687 {
 688    U8           tbIdx;
 689    KwL2MeasTb   *l2MeasTb = NULLP;
 690    for(tbIdx = 0; tbIdx < KW_MAX_TB_PER_UE; tbIdx++)
 691    {
 692        l2MeasTb = ueCb->l2MeasTbCb[tbIdx];
 693        if(l2MeasTb != NULLP)
 694        {
 695           KW_FREE(gCb,l2MeasTb, sizeof(KwL2MeasTb));
 696           ueCb->l2MeasTbCb[tbIdx] = NULLP;
 697        }
 698    }
 699    RETVOID;
 700 }/* End of kwDbmDelL2MeasTb */
 701 #endif /* LTE_L2_MEAS */
 702 \f
 703 /**
 704  * @brief Handler to create CellCb
 705  *
 706  * @details
 707  *    This function is invoked by CFG to create CellCb and insert into
 708  *    the Cell hashlist of KwCb.
 709  *
 710  *  @param[in] gCb      RLC Instance Control Block
 711  *  @param[in] cellId   Cell Identifier
 712  *  @param[in] cellCb   Cell Control Block
 713  *
 714  *  @return  S16
 715  *     -# ROK
 716  *     -# RFAILED
 717 */
 718 #ifdef ANSI
 719 PUBLIC S16 kwDbmCreateDlCellCb
 720 (
 721 KwCb          *gCb,
 722 CmLteCellId   cellId,
 723 KwDlCellCb    **cellCb
 724 )
 725 #else
 726 PUBLIC S16 kwDbmCreateDlCellCb(gCb,cellId, cellCb)
 727 KwCb          *gCb;
 728 CmLteCellId   cellId;
 729 KwDlCellCb    **cellCb;
 730 #endif
 731 {
 732    KwDlCellCb *tCellCb;
 733
 734    TRC3(kwDbmCreateDlCellCb)
 735
 736    KW_ALLOC(gCb,*cellCb, sizeof(KwDlCellCb));
 737 #if (ERRCLASS & ERRCLS_ADD_RES)
 738    if (*cellCb == NULLP)
 739    {
 740       RLOG_ARG0(L_FATAL, DBG_CELLID,cellId,"Memory allocation failed");
 741       RETVALUE(RFAILED);
 742    }
 743 #endif /* ERRCLASS & ERRCLS_ADD_RES */
 744
 745    tCellCb = *cellCb;
 746    tCellCb->cellId = cellId;
 747
 748    if(ROK != cmHashListInsert(&(gCb->u.dlCb->cellLstCp),
 749                               (PTR) tCellCb,
 750                               (U8 *)&(tCellCb->cellId),
 751                               (U16) sizeof(CmLteCellId)))
 752    {
 753       RLOG_ARG0(L_ERROR,DBG_CELLID,cellId,"HashList Insertion Failed");
 754       RETVALUE(RFAILED);
 755    }
 756
 757    RETVALUE(ROK);
 758 } /* kwDbmCreateDlCellCb */
 759
 760 \f
 761 /**
 762  * @brief Handler to Fetch an CellCb
 763  *
 764  * @details
 765  *    This function is invoked by CFG to fetch UeCb from the Ue hashlist
 766  *    of KwCb.
 767  *
 768  * @param[in]    gCb      RLC Instance Control Block
 769  * @param[in]    cellId   Cell Identifier
 770  * @param[out]   cellCb   UE Control Block
 771  *
 772  * @return  S16
 773  *    -# ROK
 774  *    -# RFAILED
 775  *
 776 */
 777 #ifdef ANSI
 778 PUBLIC S16 kwDbmFetchDlCellCb
 779 (
 780 KwCb          *gCb,
 781 CmLteCellId   cellId,
 782 KwDlCellCb    **cellCb
 783 )
 784 #else
 785 PUBLIC S16 kwDbmFetchDlCellCb(gCb,cellId, cellCb)
 786 KwCb          *gCb;
 787 CmLteCellId   cellId;
 788 KwDlCellCb    **cellCb;
 789 #endif
 790 {
 791    TRC3(kwDbmFetchDlCellCb)
 792
 793
 794    *cellCb = NULLP;
 795
 796    if(ROK != cmHashListFind(&(gCb->u.dlCb->cellLstCp),
 797                             (U8 *)&(cellId),
 798                             sizeof(CmLteCellId),
 799                             KW_DEF_SEQ_NUM,
 800                             (PTR*) cellCb))
 801    {
 802       RLOG_ARG0(L_ERROR,DBG_CELLID, cellId,"CellCb not found");
 803       RETVALUE(RFAILED);
 804    }
 805
 806    RETVALUE(ROK);
 807 } /* kwDbmFetchCellCb */
 808
 809 \f
 810 /**
 811  * @brief Handler to delete CellCb
 812  *
 813  * @details
 814  *    This function is invoked by CFG to delete CellCb from the Cell hashlist
 815  *    of KwCb.
 816  *
 817  *  @param[in] gCb      RLC Instance Control Block
 818  *  @param[in] cellCb   Cell Control Block
 819  *
 820  *  @return  Void
 821 */
 822 #ifdef ANSI
 823 PUBLIC Void kwDbmDelDlCellCb
 824 (
 825 KwCb         *gCb,
 826 KwDlCellCb   *cellCb
 827 )
 828 #else
 829 PUBLIC Void kwDbmDelDlCellCb(gCb,cellCb)
 830 KwCb         *gCb;
 831 KwDlCellCb   *cellCb;
 832 #endif
 833 {
 834    TRC3(kwDbmDelDlCellCb)
 835
 836
 837    /* Delete all rbCbs in cellCb */
 838    kwDbmDelAllDlRb(gCb,cellCb->rbCb, KW_MAX_RB_PER_CELL);
 839
 840    /* Delete cellCb entry in hash list cellLstCp */
 841    if(ROK != cmHashListDelete(&(gCb->u.dlCb->cellLstCp), (PTR) cellCb))
 842    {
 843       RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"HashList Deletion Failed");
 844    }
 845
 846    /* Deallocate cellCb */
 847    KW_FREE(gCb, cellCb, sizeof(KwDlCellCb));
 848
 849    RETVOID;
 850 } /* kwDbmDelCellCb */
 851
 852 \f
 853 /**
 854  * @brief Handler to delete all UeCbs
 855  *
 856  * @details
 857  *    This function is invoked by CFG to delete all UeCbs from the Ue
 858  *    hashlist of KwCb.
 859  * @param[in] gCb      RLC Instance Control Block
 860  *
 861  * @return  Void
 862 */
 863 #ifdef ANSI
 864 PUBLIC Void kwDbmDelAllDlCell
 865 (
 866 KwCb *gCb
 867 )
 868 #else
 869 PUBLIC Void kwDbmDelAllDlCell(gCb)
 870 KwCb *gCb;
 871 #endif
 872 {
 873    KwDlCellCb *cellCb = NULLP;
 874
 875    TRC3(kwDbmDelAllDlCell)
 876
 877
 878    /* Until no more cellCb is ueLstCp hash list get and delete cellCb */
 879    while (ROK == cmHashListGetNext(&(gCb->u.dlCb->cellLstCp),
 880                                    (PTR) cellCb,
 881                                    (PTR *)&cellCb))
 882    {
 883       kwDbmDelDlCellCb(gCb, cellCb);
 884
 885       cellCb = NULLP;
 886    }
 887
 888    RETVOID;
 889 } /* kwDbmDelAllDlCell */
 890
 891 \f
 892 /**
 893  * @brief Handler to delete all UeCbs and CellCbs
 894  *
 895  * @details
 896  *    This function is invoked by LMM to delete all UeCbs from the Ue
 897  *    hashlist of KwCb and cellCbs from the Cell hashlist of kwCb.
 898  *
 899  * @param[in] gCb      RLC Instance Control Block
 900  *
 901  * @return  Void
 902 */
 903 #ifdef ANSI
 904 PUBLIC S16 kwDbmDlShutdown
 905 (
 906 KwCb *gCb
 907 )
 908 #else
 909 PUBLIC S16 kwDbmDlShutdown(gCb)
 910 KwCb *gCb;
 911 #endif
 912 {
 913    TRC3(kwDbmDlShutdown)
 914
 915    kwDbmDelAllDlCell(gCb);
 916
 917    kwDbmDelAllDlUe(gCb);
 918
 919    kwDbmDlDeInit(gCb);
 920
 921
 922    RETVALUE(ROK);
 923 } /* kwDbmShutdown */
 924
 925
 926 /********************************************************************30**
 927
 928          End of file
 929 **********************************************************************/