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