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