src/5gnrmac/rg_dbm.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
  21      Name:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for Entry point fucntions
  26
  27      File:     rg_dbm.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_dbm.c
  32 @brief This file contains the APIs exposed for the insertion/fetching/deletion of cellCb/ueCb and traversal of LcCbLst.
  33 */
  34
  35 /* header include files -- defines (.h) */
  36 #include "envopt.h"        /* environment options */
  37 #include "envdep.h"        /* environment dependent */
  38 #include "envind.h"        /* environment independent */
  39 #include "gen.h"           /* general layer */
  40 #include "ssi.h"           /* system service interface */
  41 #include "cm_hash.h"       /* common hash list */
  42 #include "cm_mblk.h"       /* common memory link list library */
  43 #include "cm_llist.h"      /* common linked list library */
  44 #include "cm_err.h"        /* common error */
  45 #include "cm_lte.h"        /* common LTE */
  46 #include "lrg.h"
  47 #include "crg.h"
  48 #include "rgu.h"
  49 #include "tfu.h"
  50 #include "rg_sch_inf.h"
  51 #include "rg_env.h"
  52 #include "rg.h"
  53
  54 /* header/extern include files (.x) */
  55 #include "gen.x"           /* general layer */
  56 #include "ssi.x"           /* system service interface */
  57 #include "cm5.x"           /* common timers */
  58 #include "cm_lib.x"        /* common library */
  59 #include "cm_hash.x"       /* common hash list */
  60 #include "cm_mblk.x"       /* common memory link list library */
  61 #include "cm_llist.x"      /* common linked list library */
  62 #include "cm_tkns.x"       /* common tokens */
  63 #include "cm_lte.x"        /* common LTE */
  64 #include "lrg.x"
  65 #include "crg.x"
  66 #include "rgu.x"
  67 #include "tfu.x"
  68 #include "rg_sch_inf.x"
  69 #include "rg_prg.x"       /* PRG interface typedefs*/
  70 #include "du_app_mac_inf.h"
  71 #include "rg.x"
  72
  73
  74 /* local defines */
  75 PRIVATE S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, U16 numBins));
  76 PRIVATE Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
  77 PRIVATE Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
  78 PRIVATE Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
  79 #ifdef LTEMAC_SPS
  80 PRIVATE S16 rgDBMInitSpsUeCbLst ARGS((
  81 RgCellCb       *cellCb,
  82 U16            numBins
  83 ));
  84 #endif
  85
  86 /* local typedefs */
  87
  88 /* local externs */
  89
  90 /* forward references */
  91
  92 /**
  93  * @brief Handler for Initializing the cell.
  94  *
  95  * @details
  96  *
  97  *     Function : rgDBMInitCell
  98  *
  99  *   Initializes the lists belonging to the cell.
 100  *
 101  *
 102  *  @param[in]  RgCellCb *cellCb
 103  *  @return  S16
 104  *      -# ROK
 105  *      -# RFAILED
 106  **/
 107 #ifdef ANSI
 108 PUBLIC S16 rgDBMInitCell
 109 (
 110 RgCellCb       *cellCb
 111 )
 112 #else
 113 PUBLIC S16 rgDBMInitCell(cellCb)
 114 RgCellCb       *cellCb;
 115 #endif
 116 {
 117    S16 ret;
 118
 119    TRC2(rgDBMInitCell);
 120
 121    /* Initialize ue list */
 122    if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
 123       RETVALUE(ret);
 124
 125 #ifdef LTEMAC_SPS
 126    /* Initialize SPS Ue list */
 127    if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
 128       RETVALUE(ret);
 129 #endif /* LTEMAC_SPS */
 130
 131    /* Initialize BCCH/PCCH logical channels */
 132    rgDBMInitCmnLcLst(cellCb);
 133
 134
 135    /* Initialize rach ue list */
 136    rgDBMInitRachLst(cellCb);
 137
 138    RETVALUE(ret);
 139
 140 } /* rgDBMInitCell */
 141
 142 /**
 143  * @brief Handler for initializing the ueCbLst under the cellCb.
 144  *
 145  * @details
 146  *
 147  *     Function : rgDBMInitUeCbLst
 148  *
 149  *
 150  *  @param[in] *cellCb
 151  *  @param[in] numBins
 152  *  @return  S16
 153  *      -# ROK
 154  *      -# RFAILED
 155  **/
 156 #ifdef ANSI
 157 PRIVATE S16 rgDBMInitUeCbLst
 158 (
 159 RgCellCb       *cellCb,
 160 U16            numBins
 161 )
 162 #else
 163 PRIVATE S16 rgDBMInitUeCbLst(cellCb, numBins)
 164 RgCellCb       *cellCb;
 165 U16            numBins;
 166 #endif
 167 {
 168    Inst inst = cellCb->macInst - RG_INST_START;
 169    RgUeCb ue;
 170    TRC2(rgDBMInitUeCbLst)
 171
 172    RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
 173                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
 174
 175 }  /* rgDBMInitUeCbLst */
 176
 177 /**
 178  * @brief Handler for de-initializing the ueCbLst under the cellCb.
 179  *
 180  * @details
 181  *
 182  *     Function : rgDBMDeInitUeCbLst
 183  *
 184  *
 185  *  @param[in] *cellCb
 186  *  @return  S16
 187  *      -# ROK
 188  *      -# RFAILED
 189  **/
 190 #ifdef ANSI
 191 PUBLIC S16 rgDBMDeInitUeCbLst
 192 (
 193 RgCellCb       *cellCb
 194 )
 195 #else
 196 PUBLIC S16 rgDBMDeInitUeCbLst(cellCb)
 197 RgCellCb       *cellCb;
 198 #endif
 199 {
 200    TRC2(rgDBMDeInitUeCbLst)
 201
 202    RETVALUE(cmHashListDeinit(&cellCb->ueLst));
 203
 204 }  /* rgDBMDeInitUeCbLst */
 205
 206 #ifdef LTEMAC_SPS
 207 /**
 208  * @brief Handler for initializing the spsUeCbLst under the cellCb.
 209  *
 210  * @details
 211  *
 212  *     Function : rgDBMInitSpsUeCbLst
 213  *
 214  *
 215  *  @param[in] *cellCb
 216  *  @param[in] numBins
 217  *  @return  S16
 218  *      -# ROK
 219  *      -# RFAILED
 220  **/
 221 #ifdef ANSI
 222 PRIVATE S16 rgDBMInitSpsUeCbLst
 223 (
 224 RgCellCb       *cellCb,
 225 U16            numBins
 226 )
 227 #else
 228 PRIVATE S16 rgDBMInitSpsUeCbLst(cellCb, numBins)
 229 RgCellCb       *cellCb;
 230 U16            numBins;
 231 #endif
 232 {
 233    Inst inst = cellCb->macInst - RG_INST_START;
 234    RgUeCb ue;
 235    TRC2(rgDBMInitSpsUeCbLst)
 236
 237    RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
 238                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
 239
 240 }  /* rgDBMInitSpsUeCbLst */
 241
 242 /**
 243  * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
 244  *
 245  * @details
 246  *
 247  *     Function : rgDBMDeInitSpsUeCbLst
 248  *
 249  *
 250  *  @param[in] *cellCb
 251  *  @return  S16
 252  *      -# ROK
 253  *      -# RFAILED
 254  **/
 255 #ifdef ANSI
 256 PUBLIC S16 rgDBMDeInitSpsUeCbLst
 257 (
 258 RgCellCb       *cellCb
 259 )
 260 #else
 261 PUBLIC S16 rgDBMDeInitSpsUeCbLst(cellCb)
 262 RgCellCb       *cellCb;
 263 #endif
 264 {
 265    TRC2(rgDBMDeInitSpsUeCbLst)
 266
 267    RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
 268
 269 }  /* rgDBMDeInitSpsUeCbLst */
 270
 271 #endif /* LTEMAC_SPS */
 272
 273 /**
 274  * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
 275  *
 276  * @details
 277  *
 278  *     Function : rgDBMInsUeCb
 279  *
 280  *
 281  *  @param[in] *cellCb
 282  *  @param[in] *ueCb
 283  *  @return  S16
 284  *      -# ROK
 285  *      -# RFAILED
 286  **/
 287 #ifdef ANSI
 288 PUBLIC S16 rgDBMInsUeCb
 289 (
 290 RgCellCb       *cellCb,
 291 RgUeCb         *ueCb
 292 )
 293 #else
 294 PUBLIC S16 rgDBMInsUeCb(cellCb, ueCb)
 295 RgCellCb       *cellCb;
 296 RgUeCb         *ueCb;
 297 #endif
 298 {
 299    TRC2(rgDBMInsUeCb)
 300
 301    RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
 302       (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
 303
 304 }  /* rgDBMInsUeCb */
 305
 306 #ifdef LTEMAC_SPS
 307 /**
 308  * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
 309  *
 310  * @details
 311  *
 312  *     Function : rgDBMInsSpsUeCb
 313  *
 314  *
 315  *  @param[in] *cellCb
 316  *  @param[in] *ueCb
 317  *  @return  S16
 318  *      -# ROK
 319  *      -# RFAILED
 320  **/
 321 #ifdef ANSI
 322 PUBLIC S16 rgDBMInsSpsUeCb
 323 (
 324 RgCellCb       *cellCb,
 325 RgUeCb         *ueCb
 326 )
 327 #else
 328 PUBLIC S16 rgDBMInsSpsUeCb(cellCb, ueCb)
 329 RgCellCb       *cellCb;
 330 RgUeCb         *ueCb;
 331 #endif
 332 {
 333    TRC2(rgDBMInsSpsUeCb)
 334
 335    RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
 336       (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
 337
 338 }  /* end of rgDBMInsSpsUeCb */
 339
 340 #endif /* LTEMAC_SPS */
 341
 342 /**
 343  * @brief Handler for accessing the existing ueCb identified by the key ueId
 344  * in the ueCbLst under the cellCb.
 345  *
 346  * @details
 347  *
 348  *     Function : rgDBMGetUeCb
 349  *
 350  *
 351  *  @param[in]  *cellCb
 352  *  @param[in]  ueId
 353  *  @return  RgUeCb*
 354  **/
 355 #ifdef ANSI
 356 PUBLIC RgUeCb* rgDBMGetUeCb
 357 (
 358 RgCellCb       *cellCb,
 359 CmLteRnti      ueId
 360 )
 361 #else
 362 PUBLIC RgUeCb* rgDBMGetUeCb(cellCb, ueId)
 363 RgCellCb       *cellCb;
 364 CmLteRnti      ueId;
 365 #endif
 366 {
 367    RgUeCb *ueCb = NULLP;
 368
 369    TRC2(rgDBMGetUeCb)
 370
 371    cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
 372       sizeof(ueId), 0, (PTR *)&ueCb);
 373    RETVALUE(ueCb);
 374 }  /* rgDBMGetUeCb */
 375
 376 #ifdef LTEMAC_SPS
 377 /**
 378  * @brief Handler for accessing the ueCb identified by the key sps-rnti
 379  * in the spsUeLst under the cellCb.
 380  *
 381  * @details
 382  *
 383  *     Function : rgDBMGetSpsUeCb
 384  *
 385  *
 386  *  @param[in]  *cellCb
 387  *  @param[in]  ueId
 388  *  @return  RgUeCb*
 389  **/
 390 #ifdef ANSI
 391 PUBLIC RgUeCb* rgDBMGetSpsUeCb
 392 (
 393 RgCellCb       *cellCb,
 394 CmLteRnti      spsRnti
 395 )
 396 #else
 397 PUBLIC RgUeCb* rgDBMGetSpsUeCb(cellCb, spsRnti)
 398 RgCellCb       *cellCb;
 399 CmLteRnti      spsRnti;
 400 #endif
 401 {
 402    RgUeCb *ueCb = NULLP;
 403
 404    TRC2(rgDBMGetSpsUeCb)
 405
 406    cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
 407       sizeof(spsRnti), 0, (PTR *)&ueCb);
 408    RETVALUE(ueCb);
 409 }  /* rgDBMGetSpsUeCb */
 410
 411 #endif /* LTEMAC_SPS */
 412
 413 /**
 414  * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
 415  *  cellCb.
 416  *
 417  * @details
 418  *
 419  *     Function : rgDBMGetNextUeCb
 420  *
 421  *
 422  *  @param[in]  *cellCb
 423  *  @param[in]  *ueCb
 424  *  @return  RgUeCb*
 425  **/
 426 #ifdef ANSI
 427 PUBLIC RgUeCb* rgDBMGetNextUeCb
 428 (
 429 RgCellCb       *cellCb,
 430 RgUeCb         *ueCb
 431 )
 432 #else
 433 PUBLIC RgUeCb* rgDBMGetNextUeCb(cellCb, ueCb)
 434 RgCellCb       *cellCb;
 435 RgUeCb         *ueCb;
 436 #endif
 437 {
 438    RgUeCb *nextUeCb = NULLP;
 439
 440    TRC2(rgDBMGetNextUeCb)
 441
 442    cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
 443    RETVALUE(nextUeCb);
 444 }  /* rgDBMGetNextUeCb */
 445
 446 #ifdef LTEMAC_SPS
 447 /**
 448  * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
 449  *         using SPS-Rnti under the cellCb.
 450  *
 451  * @details
 452  *
 453  *     Function : rgDBMGetNextSpsUeCb
 454  *
 455  *
 456  *  @param[in]  *cellCb
 457  *  @param[in]  *ueCb
 458  *  @return  RgUeCb*
 459  **/
 460 #ifdef ANSI
 461 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb
 462 (
 463 RgCellCb       *cellCb,
 464 RgUeCb         *ueCb
 465 )
 466 #else
 467 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb(cellCb, ueCb)
 468 RgCellCb       *cellCb;
 469 RgUeCb         *ueCb;
 470 #endif
 471 {
 472    RgUeCb *nextUeCb = NULLP;
 473
 474    TRC2(rgDBMGetNextSpsUeCb)
 475
 476    cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
 477    RETVALUE(nextUeCb);
 478 }  /* end of rgDBMGetNextSpsUeCb */
 479
 480 #endif /* LTEMAC_SPS */
 481
 482
 483 /**
 484  * @brief Handler for deleting the existing ueCb from the ueCbLst under the
 485  * cellCb.
 486  *
 487  * @details
 488  *
 489  *     Function : rgDBMDelUeCb
 490  *
 491  *
 492  *  @param[in]  *cellCb
 493  *  @param[in]  *ueCb
 494  *  @return  S16
 495  *      -# ROK
 496  *      -# RFAILED
 497  **/
 498 #ifdef ANSI
 499 PUBLIC S16 rgDBMDelUeCb
 500 (
 501 RgCellCb       *cellCb,
 502 RgUeCb         *ueCb
 503 )
 504 #else
 505 PUBLIC S16 rgDBMDelUeCb(cellCb, ueCb)
 506 RgCellCb       *cellCb;
 507 RgUeCb         *ueCb;
 508 #endif
 509 {
 510    TRC2(rgDBMDelUeCb)
 511
 512    RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
 513 }  /* rgDBMDelUeCb */
 514
 515 #ifdef LTEMAC_SPS
 516 /**
 517  * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
 518  * cellCb.
 519  *
 520  * @details
 521  *
 522  *     Function : rgDBMDelSpsUeCb
 523  *
 524  *
 525  *  @param[in]  *cellCb
 526  *  @param[in]  *ueCb
 527  *  @return  S16
 528  *      -# ROK
 529  *      -# RFAILED
 530  **/
 531 #ifdef ANSI
 532 PUBLIC S16 rgDBMDelSpsUeCb
 533 (
 534 RgCellCb       *cellCb,
 535 RgUeCb         *ueCb
 536 )
 537 #else
 538 PUBLIC S16 rgDBMDelSpsUeCb(cellCb, ueCb)
 539 RgCellCb       *cellCb;
 540 RgUeCb         *ueCb;
 541 #endif
 542 {
 543    TRC2(rgDBMDelSpsUeCb)
 544
 545    RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
 546 }  /* end of rgDBMDelSpsUeCb */
 547
 548 #endif /* LTEMAC_SPS */
 549
 550 /**
 551  * @brief Handler for Initializing the UE.
 552  *
 553  * @details
 554  *
 555  *     Function : rgDBMInitUe
 556  *
 557  *   Initializes the lists belonging to the UE.
 558  *
 559  *
 560  *  @param[in]  RgUeCb  *ueCb
 561  *  @return  S16
 562  *      -# ROK
 563  *      -# RFAILED
 564  **/
 565 #ifdef ANSI
 566 PUBLIC Void rgDBMInitUe
 567 (
 568 RgUeCb       *ueCb
 569 )
 570 #else
 571 PUBLIC Void rgDBMInitUe(ueCb)
 572 RgUeCb       *ueCb;
 573 #endif
 574 {
 575 #ifdef LTEMAC_SPS
 576    U8        idx;
 577 #endif
 578
 579    TRC2(rgDBMInitUe);
 580
 581    /* Initialize Dedicated logical channels */
 582    rgDBMInitDedLcLst(ueCb);
 583
 584 #ifdef LTEMAC_SPS
 585    /* Initialize the SPS LC Ids */
 586    for (idx=0; idx < RG_MAX_LC_PER_UE; idx++)
 587    {
 588       ueCb->ul.spsLcId[idx] = FALSE;
 589    }
 590 #endif
 591
 592
 593    RETVOID;
 594 } /* rgDBMInitUe */
 595
 596 /**
 597  * @brief Handler for Initializing the dedicated logical channels.
 598  *
 599  * @details
 600  *
 601  *     Function : rgDBMInitDedLcLst
 602  *
 603  *   Initializes dedicated logical channels.
 604  *
 605  *  @param[in]  RgUeCb *ueCb
 606  *  @return     Void
 607  **/
 608 #ifdef ANSI
 609 PRIVATE Void rgDBMInitDedLcLst
 610 (
 611 RgUeCb       *ueCb
 612 )
 613 #else
 614 PRIVATE Void rgDBMInitDedLcLst(ueCb)
 615 RgUeCb       *ueCb;
 616 #endif
 617 {
 618    U8 idx;
 619
 620    TRC2(rgDBMInitDedLcLst);
 621
 622    for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
 623    {
 624       /* Set Dedicated LCs as not configured */
 625       ueCb->ul.lcCb[idx].lcId = RG_INVALID_LC_ID;
 626       ueCb->ul.lcCb[idx].lcgId = RG_INVALID_LCG_ID;
 627       ueCb->dl.lcCb[idx].lcId = RG_INVALID_LC_ID;
 628    }
 629
 630    for (idx = 0; idx < RG_MAX_LCG_PER_UE; ++idx)
 631    {
 632       /* Set LCGs as not configured */
 633       ueCb->ul.lcgArr[idx].lcgId = RG_INVALID_LCG_ID;
 634       ueCb->ul.lcgArr[idx].lcCount = 0;
 635    }
 636
 637    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 638   RETVOID;
 639 } /* rgDBMInitDedLcLst */
 640
 641 /**
 642  * @brief Handler for Initializing the common logical channel list of the cell.
 643  *
 644  * @details
 645  *
 646  *     Function : rgDBMInitCmnLcLst
 647  *
 648  *   Initializes following common logical channels belonging to the cell.
 649  *     - BCCH on BCH
 650  *     - BCCH on DLSCH
 651  *     - PCCH
 652  *
 653  *  @param[in]  RgCellCb *cellCb
 654  *  @return  Void
 655  **/
 656 #ifdef ANSI
 657 PRIVATE Void rgDBMInitCmnLcLst
 658 (
 659 RgCellCb       *cellCb
 660 )
 661 #else
 662 PRIVATE Void rgDBMInitCmnLcLst(cellCb)
 663 RgCellCb       *cellCb;
 664 #endif
 665 {
 666    U8 idx;
 667
 668    TRC2(rgDBMInitCmnLcLst);
 669
 670    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
 671    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
 672
 673    cellCb->numBcchDlschInfo = 0;
 674    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
 675    {
 676       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
 677       cellCb->bcchDlschInfo[idx].tb = NULLP;
 678    }
 679
 680    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 681   RETVOID;
 682 } /* rgDBMInitCmnLcLst */
 683
 684 /**
 685  * @brief Handler for Initializing the common logical channel list of the cell.
 686  *
 687  * @details
 688  *
 689  *     Function : rgDBMFreeCmnLcLst
 690  *
 691  *   Initializes following common logical channels belonging to the cell.
 692  *     - BCCH on BCH
 693  *     - BCCH on DLSCH
 694  *     - PCCH
 695  *
 696  *  @param[in]  RgCellCb *cellCb
 697  *  @return  Void
 698  **/
 699 #ifdef ANSI
 700 PUBLIC Void rgDBMFreeCmnLcLst
 701 (
 702 RgCellCb       *cellCb
 703 )
 704 #else
 705 PUBLIC Void rgDBMFreeCmnLcLst(cellCb)
 706 RgCellCb       *cellCb;
 707 #endif
 708 {
 709    U8 idx;
 710
 711    TRC2(rgDBMFreeCmnLcLst);
 712
 713    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
 714    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
 715
 716    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
 717    {
 718       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
 719       RG_FREE_MSG(cellCb->bcchDlschInfo[idx].tb);
 720    }
 721    cellCb->numBcchDlschInfo = 0;
 722
 723    /* Stack Crash problem for TRACE5 Changes. Added the return below */
 724   RETVOID;
 725 } /* rgDBMFreeCmnLcLst */
 726
 727 /**
 728  * @brief Handler for inserting dedicated DL logical channel.
 729  *
 730  * @details
 731  *
 732  *     Function : rgDBMInsDlDedLcCb
 733  *
 734  *  @param[in]  RgUeCb *ueCb
 735  *  @param[in]  RgDlLcCb* dlLcCb
 736  *  @return  Void
 737  **/
 738 #ifdef ANSI
 739 PUBLIC Void rgDBMInsDlDedLcCb
 740 (
 741 RgUeCb         *ueCb,
 742 CmLteLcId        idx
 743 )
 744 #else
 745 PUBLIC Void rgDBMInsDlDedLcCb(ueCb, idx)
 746 RgUeCb         *ueCb;
 747 CmLteLcId        idx;
 748 #endif
 749 {
 750    TRC2(rgDBMInsDlDedLcCb);
 751    if( idx >= RG_DEDLC_MIN_LCID )
 752    {
 753       ueCb->dl.lcCb[idx-1].lcId = idx;
 754    }
 755   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 756   RETVOID;
 757 }  /* rgDBMInsDlDedLcCb */
 758
 759 /**
 760  * @brief Handler for deleting dedicated DL logical channel.
 761  *
 762  * @details
 763  *
 764  *     Function : rgDBMDelDlDedLcCb
 765  *
 766  *  @param[in]  RgUeCb *ueCb
 767  *  @param[in]  RgDlLcCb* dlLcCb
 768  *  @return  Void
 769  **/
 770 #ifdef ANSI
 771 PUBLIC Void rgDBMDelDlDedLcCb
 772 (
 773 RgUeCb         *ueCb,
 774 RgDlLcCb       *dlLcCb
 775 )
 776 #else
 777 PUBLIC Void rgDBMDelDlDedLcCb(ueCb, dlLcCb)
 778 RgUeCb         *ueCb;
 779 RgDlLcCb       *dlLcCb;
 780 #endif
 781 {
 782    TRC2(rgDBMDelDlDedLcCb);
 783
 784    ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
 785
 786   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 787   RETVOID;
 788
 789 }  /* rgDBMDelDlDedLcCb */
 790
 791 /**
 792  * @brief Handler for accessing the existing DL dedicated lcCb at idx in the
 793  * lcCbLst of the ueCb.
 794  *
 795  * @details
 796  *
 797  *     Function : rgDBMGetDlDedLcCb
 798  *
 799  *  @param[in]  *ueCb
 800  *  @param[in]  idx
 801  *  @return  RgDlLcCb*
 802  **/
 803 #ifdef ANSI
 804 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb
 805 (
 806 RgUeCb         *ueCb,
 807 CmLteLcId        idx
 808 )
 809 #else
 810 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb(ueCb, idx)
 811 RgUeCb         *ueCb;
 812 CmLteLcId        idx;
 813 #endif
 814 {
 815    TRC2(rgDBMGetDlDedLcCb);
 816
 817    if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
 818    {
 819       RETVALUE(NULLP);
 820    }
 821    if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
 822    {
 823       RETVALUE(NULLP);
 824    }
 825
 826    RETVALUE(&ueCb->dl.lcCb[idx-1]);
 827
 828 }  /* rgDBMGetDlDedLcCb */
 829
 830 /**
 831  * @brief Handler for inserting dedicated UL logical channel.
 832  *
 833  * @details
 834  *
 835  *     Function : rgDBMInsUlDedLcCb
 836  *
 837  *
 838  *  @param[in]  RgUeCb *ueCb
 839  *  @param[in]  CmLteLcId idx
 840  *  @param[in]  LteLcgId gId
 841  *  @return  Void
 842  **/
 843 #ifdef LTE_L2_MEAS
 844 #ifdef ANSI
 845 PUBLIC Void rgDBMInsUlDedLcCb
 846 (
 847 RgUeCb         *ueCb,
 848 CmLteLcId      idx,
 849 LteLcgId       gId,
 850 U8             qci
 851 )
 852 #else
 853 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
 854 RgUeCb         *ueCb;
 855 CmLteLcId      idx;
 856 LteLcgId       gId;
 857 U8             qci;
 858 #endif
 859 #else
 860 #ifdef ANSI
 861 PUBLIC Void rgDBMInsUlDedLcCb
 862 (
 863 RgUeCb         *ueCb,
 864 CmLteLcId      idx,
 865 LteLcgId       gId
 866 )
 867 #else
 868 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId)
 869 RgUeCb         *ueCb;
 870 CmLteLcId      idx;
 871 LteLcgId       gId;
 872 #endif
 873 #endif
 874 {
 875    TRC2(rgDBMInsUlDedLcCb);
 876    if ( idx >= RG_DEDLC_MIN_LCID)
 877    {
 878       ueCb->ul.lcCb[idx - 1].lcId = idx;
 879       ueCb->ul.lcCb[idx - 1].lcgId = gId;
 880 #ifdef LTE_L2_MEAS
 881       ueCb->ul.lcCb[idx - 1].qci = qci;
 882 #endif
 883    }
 884    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
 885    {
 886       ueCb->ul.lcgArr[gId].lcgId = gId;
 887    }
 888    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
 889
 890
 891   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 892   RETVOID;
 893
 894 }  /* rgDBMInsUlDedLcCb */
 895
 896 /**
 897  * @brief Handler for deleting the dedicated UL logical channel.
 898  *
 899  * @details
 900  *
 901  *     Function : rgDBMUpdUlDedLcCb
 902  *
 903  *
 904  *  @param[in]  RgUeCb *ueCb
 905  *  @param[in]  RgUlLcCb* ulLcCb
 906  *  @param[in]  LteLcgId gId
 907  *  @return  Void
 908  **/
 909 #ifdef ANSI
 910 PUBLIC Void rgDBMUpdUlDedLcCb
 911 (
 912 RgUeCb         *ueCb,
 913 RgUlLcCb       *ulLcCb,
 914 LteLcgId       gId
 915 )
 916 #else
 917 PUBLIC Void rgDBMUpdUlDedLcCb(ueCb, ulLcCb, gId)
 918 RgUeCb         *ueCb;
 919 RgUlLcCb       *ulLcCb;
 920 LteLcgId       gId;
 921 #endif
 922 {
 923    TRC2(rgDBMUpdUlDedLcCb);
 924
 925    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
 926                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
 927    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
 928    {
 929       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
 930    }
 931    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = gId;
 932
 933    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
 934    {
 935       ueCb->ul.lcgArr[gId].lcgId = gId;
 936    }
 937    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
 938
 939   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 940   RETVOID;
 941 }  /* rgDBMUpdUlDedLcCb */
 942
 943 /**
 944  * @brief Handler for updating the dedicated UL logical channel.
 945  *
 946  * @details
 947  *
 948  *     Function : rgDBMDelUlDedLcCb
 949  *
 950  *
 951  *  @param[in]  RgUeCb *ueCb
 952  *  @param[in]  RgUlLcCb* ulLcCb
 953  *  @return  Void
 954  **/
 955 #ifdef ANSI
 956 PUBLIC Void rgDBMDelUlDedLcCb
 957 (
 958 RgUeCb         *ueCb,
 959 RgUlLcCb       *ulLcCb
 960 )
 961 #else
 962 PUBLIC Void rgDBMDelUlDedLcCb(ueCb, ulLcCb)
 963 RgUeCb         *ueCb;
 964 RgUlLcCb       *ulLcCb;
 965 #endif
 966 {
 967    TRC2(rgDBMDelUlDedLcCb);
 968
 969    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
 970                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
 971    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
 972    {
 973       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
 974    }
 975    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = RG_INVALID_LCG_ID;
 976    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
 977
 978   /* Stack Crash problem for TRACE5 Changes. Added the return below */
 979   RETVOID;
 980 }  /* rgDBMDelUlDedLcCb */
 981
 982 /**
 983  * @brief Handler for accessing the existing UL dedicated lcCb at idx in the
 984  * lcCbLst of the ueCb.
 985  *
 986  * @details
 987  *
 988  *     Function : rgDBMGetUlDedLcCb
 989  *
 990  *
 991  *  @param[in]  *ueCb
 992  *  @param[in]  idx
 993  *  @return  RgUlLcCb*
 994  **/
 995 #ifdef ANSI
 996 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb
 997 (
 998 RgUeCb         *ueCb,
 999 CmLteLcId        idx
1000 )
1001 #else
1002 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb(ueCb, idx)
1003 RgUeCb         *ueCb;
1004 CmLteLcId        idx;
1005 #endif
1006 {
1007    TRC2(rgDBMGetUlDedLcCb)
1008
1009    if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
1010    {
1011       RETVALUE(NULLP);
1012    }
1013    if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
1014    {
1015       RETVALUE(NULLP);
1016    }
1017
1018    RETVALUE(&ueCb->ul.lcCb[idx-1]);
1019 }  /* rgDBMGetDlDedLcCb */
1020
1021 /**
1022  * @brief Handler for accessing the existing DL common lcCb identified by the key lcId
1023  * in the lcCbLst of the ueCb.
1024  *
1025  * @details
1026  *
1027  *     Function : rgDBMChkCmnLcCb
1028  *
1029  *
1030  *  @param[in]  *cellCb
1031  *  @param[in]  lcId
1032  *  @return  S16
1033  *      -# ROK
1034  *      -# RFAILED
1035  **/
1036 #ifdef ANSI
1037 PUBLIC S16 rgDBMChkCmnLcCb
1038 (
1039 RgCellCb       *cellCb,
1040 CmLteLcId        lcId
1041 )
1042 #else
1043 PUBLIC S16 rgDBMChkCmnLcCb(cellCb, lcId)
1044 RgCellCb       *cellCb;
1045 CmLteLcId        lcId;
1046 #endif
1047 {
1048    U8 idx;
1049
1050    TRC2(rgDBMChkCmnLcCb)
1051
1052    if(cellCb->bcchBchInfo.lcId == lcId)
1053    {
1054       RETVALUE(ROK);
1055    }
1056    if(cellCb->pcchInfo.lcId == lcId)
1057    {
1058       RETVALUE(ROK);
1059    }
1060
1061    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
1062    {
1063       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1064       {
1065          RETVALUE(ROK);
1066       }
1067    }
1068    RETVALUE(RFAILED);
1069 }  /* rgDBMChkCmnLcCb */
1070
1071 /**
1072  * @brief Handler for accessing the existing BCCH mapped on to BCH in the
1073  * lcCbLst of the ueCb.
1074  *
1075  * @details
1076  *
1077  *     Function : rgDBMGetBcchOnBch
1078  *
1079  *
1080  *  @param[in]  *cellCb
1081  *  @return  RgBcchBchLcCb*
1082  **/
1083 #ifdef ANSI
1084 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch
1085 (
1086 RgCellCb       *cellCb
1087 )
1088 #else
1089 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch(cellCb)
1090 RgCellCb       *cellCb;
1091 #endif
1092 {
1093    TRC2(rgDBMGetBcchOnBch)
1094
1095    if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
1096    {
1097       RETVALUE(&(cellCb->bcchBchInfo));
1098    }
1099    RETVALUE(NULLP);
1100 }  /* rgDBMGetBcchOnBch */
1101
1102 /**
1103  * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the
1104  * lcCbLst of the ueCb.
1105  *
1106  * @details
1107  *
1108  *     Function : rgDBMGetBcchOnDlsch
1109  *
1110  *
1111  *  @param[in]  *cellCb
1112  *  @param[in]  lcId
1113  *  @return  RgBcchDlschLcCb*
1114  **/
1115 #ifdef ANSI
1116 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch
1117 (
1118 RgCellCb       *cellCb,
1119 CmLteLcId      lcId
1120 )
1121 #else
1122 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(cellCb,lcId)
1123 RgCellCb       *cellCb;
1124 CmLteLcId      lcId;
1125 #endif
1126 {
1127    U8 idx;
1128
1129    TRC2(rgDBMGetBcchOnDlsch)
1130
1131    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
1132    {
1133       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1134       {
1135          RETVALUE(&(cellCb->bcchDlschInfo[idx]));
1136       }
1137    }
1138    RETVALUE(NULLP);
1139 }  /* rgDBMGetBcchOnDlsch */
1140
1141 /**
1142  * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
1143  *
1144  * @details
1145  *
1146  *     Function : rgDBMGetPcch
1147  *
1148  *
1149  *  @param[in]  *cellCb
1150  *  @return  RgPcchLcCb*
1151  **/
1152 #ifdef ANSI
1153 PUBLIC RgPcchLcCb* rgDBMGetPcch
1154 (
1155 RgCellCb       *cellCb
1156 )
1157 #else
1158 PUBLIC RgPcchLcCb* rgDBMGetPcch(cellCb)
1159 RgCellCb       *cellCb;
1160 #endif
1161 {
1162    TRC2(rgDBMGetPcch)
1163
1164    if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
1165    {
1166       RETVALUE(&(cellCb->pcchInfo));
1167    }
1168    RETVALUE(NULLP);
1169 }  /* rgDBMGetPcch */
1170
1171 /**
1172  * @brief Handler for inserting the BCCH mapped on to BCH in the
1173  * lcCbLst of the ueCb.
1174  *
1175  * @details
1176  *
1177  *     Function : rgDBMInsBcchOnBch
1178  *
1179  *
1180  *  @param[in]  *cellCb
1181  *  @return  Void
1182  **/
1183 #ifdef ANSI
1184 PUBLIC Void rgDBMInsBcchOnBch
1185 (
1186 RgCellCb       *cellCb,
1187 CmLteLcId      idx
1188 )
1189 #else
1190 PUBLIC Void rgDBMInsBcchOnBch(cellCb, idx)
1191 RgCellCb       *cellCb;
1192 CmLteLcId      idx;
1193 #endif
1194 {
1195    TRC2(rgDBMInsBcchOnBch)
1196
1197    cellCb->bcchBchInfo.lcId = idx;
1198
1199   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1200   RETVOID;
1201 }  /* rgDBMInsBcchOnBch */
1202
1203 /**
1204  * @brief Handler for inserting the BCCH mapped on to DLSCH in the
1205  * lcCbLst of the ueCb.
1206  *
1207  * @details
1208  *
1209  *     Function : rgDBMInsBcchOnDlsch
1210  *
1211  *
1212  *  @param[in]  *cellCb
1213  *  @return  Void
1214  **/
1215 #ifdef ANSI
1216 PUBLIC Void rgDBMInsBcchOnDlsch
1217 (
1218 RgCellCb       *cellCb,
1219 CmLteLcId      idx
1220 )
1221 #else
1222 PUBLIC Void rgDBMInsBcchOnDlsch(cellCb, idx)
1223 RgCellCb       *cellCb;
1224 CmLteLcId      idx;
1225 #endif
1226 {
1227    TRC2(rgDBMInsBcchOnDlsch)
1228
1229    cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
1230    cellCb->numBcchDlschInfo++;
1231
1232   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1233   RETVOID;
1234 }  /* rgDBMInsBcchOnDlsch */
1235
1236
1237 /**
1238  * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
1239  *
1240  * @details
1241  *
1242  *     Function : rgDBMInsPcch
1243  *
1244  *
1245  *  @param[in]  *cellCb
1246  *  @return  Void
1247  **/
1248 #ifdef ANSI
1249 PUBLIC Void rgDBMInsPcch
1250 (
1251 RgCellCb       *cellCb,
1252 CmLteLcId      idx
1253 )
1254 #else
1255 PUBLIC Void rgDBMInsPcch(cellCb, idx)
1256 RgCellCb       *cellCb;
1257 CmLteLcId      idx;
1258 #endif
1259 {
1260    TRC2(rgDBMInsPcch)
1261
1262    cellCb->pcchInfo.lcId = idx;
1263
1264   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1265   RETVOID;
1266 }  /* rgDBMInsPcch */
1267
1268 /**
1269  * @brief Handler for initializing the rachLst
1270  *
1271  * @details
1272  *
1273  *     Function : rgDBMInitRachLst
1274  *
1275  *
1276  *  @param[in] *cellCb
1277  *  @return  Void
1278  **/
1279 #ifdef ANSI
1280 PRIVATE Void rgDBMInitRachLst
1281 (
1282 RgCellCb       *cellCb
1283 )
1284 #else
1285 PRIVATE Void rgDBMInitRachLst(cellCb)
1286 RgCellCb       *cellCb;
1287 #endif
1288 {
1289    TRC2(rgDBMInitRachLst)
1290
1291    cmLListInit(&cellCb->raInfo.ueRachLst);
1292    RETVOID;
1293 }  /* rgDBMInitRachLst */
1294
1295 /**
1296  * @brief Handler for inserting the ueCb in the rachLst.
1297  *
1298  * @details
1299  *
1300  *     Function : rgDBMInsUeCbInRachLst
1301  *
1302  *
1303  *  @param[in]  *cellCb
1304  *  @param[in]  *ueCb
1305  *  @return  Void
1306  **/
1307 #ifdef ANSI
1308 PUBLIC Void rgDBMInsUeCbInRachLst
1309 (
1310 RgCellCb       *cellCb,
1311 RgUeCb         *ueCb
1312 )
1313 #else
1314 PUBLIC Void rgDBMInsUeCbInRachLst(cellCb, ueCb)
1315 RgCellCb       *cellCb;
1316 RgUeCb         *ueCb;
1317 #endif
1318 {
1319    TRC2(rgDBMInsUeCbInRachLst)
1320
1321    cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
1322
1323    RETVOID;
1324 }  /* rgDBMInsUeCbInRachLst */
1325
1326 /**
1327  * @brief Handler for accessing the existing raCb in the rachLst.
1328  *
1329  * @details
1330  *
1331  *     Function : rgDBMGetUeCbFromRachLst
1332  *
1333  *
1334  *  @param[in]  *cellCb
1335  *  @param[in]  key
1336  *  @return  RgUeCb*
1337  **/
1338 #ifdef ANSI
1339 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst
1340 (
1341 RgCellCb       *cellCb,
1342 CmLteRnti      key
1343 )
1344 #else
1345 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst(cellCb, key)
1346 RgCellCb       *cellCb;
1347 CmLteRnti      key;
1348 #endif
1349 {
1350    CmLList *tmpNode;
1351
1352    TRC2(rgDBMGetUeCbFromRachLst)
1353
1354    CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1355    while(tmpNode)
1356    {
1357       if(((RgUeCb *)tmpNode->node)->ueId == key)
1358       {
1359          RETVALUE((RgUeCb *)(tmpNode->node));
1360       }
1361       CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1362    }
1363    RETVALUE(NULLP);
1364 }  /* rgDBMGetUeCbFromRachLst */
1365
1366 /**
1367  * @brief Handler for accessing the existing ueCb from rachLst.
1368  *
1369  * @details
1370  *
1371  *     Function : rgDBMGetNextUeCbFromRachLst
1372  *
1373  *
1374  *  @param[in]  *cellCb
1375  *  @param[in]  *ueCb
1376  *  @return  RgUeCb*
1377  **/
1378 #ifdef ANSI
1379 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst
1380 (
1381 RgCellCb       *cellCb,
1382 RgUeCb         *ueCb
1383 )
1384 #else
1385 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst(cellCb, ueCb)
1386 RgCellCb       *cellCb;
1387 RgUeCb         *ueCb;
1388 #endif
1389 {
1390    TRC2(rgDBMGetNextUeCbFromRachLst)
1391
1392    if(!ueCb)
1393    {
1394       RETVALUE( cellCb->raInfo.ueRachLst.first ?
1395                (RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
1396    }
1397    RETVALUE( ueCb->rachLstEnt.next ?
1398                (RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
1399 }  /* rgDBMGetNextUeCbFromRachLst */
1400
1401 /**
1402  * @brief Handler for deleting the existing ueCb in the rachLst.
1403  *
1404  * @details
1405  *
1406  *     Function : rgDBMDelUeCbFromRachLst
1407  *
1408  *
1409  *  @param[in]  *cellCb
1410  *  @param[in]  key
1411  *  @return  RgUeCb*
1412  **/
1413 #ifdef ANSI
1414 PUBLIC Void rgDBMDelUeCbFromRachLst
1415 (
1416 RgCellCb       *cellCb,
1417 RgUeCb         *ueCb
1418 )
1419 #else
1420 PUBLIC Void rgDBMDelUeCbFromRachLst(cellCb, ueCb)
1421 RgCellCb       *cellCb;
1422 RgUeCb         *ueCb;
1423 #endif
1424 {
1425    TRC2(rgDBMDelUeCbFromRachLst)
1426
1427    cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
1428    RETVOID;
1429 }  /* rgDBMDelUeCbFromRachLst */
1430
1431 /**********************************************************************
1432
1433          End of file
1434 **********************************************************************/