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