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