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