src/5gnrsch/rg_sch_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_sch_dbm.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_sch_dbm.c
  32 @brief This file contains the APIs exposed for the database handling of the scheduler.
  33 */
  34 static const char* RLOG_MODULE_NAME="MAC";
  35 static int RLOG_FILE_ID=230;
  36 static int RLOG_MODULE_ID=4096;
  37 /* header include files -- defines (.h) */
  38 #include "common_def.h"
  39 #include "lrg.h"
  40 #include "rgr.h"
  41 #include "tfu.h"
  42 #include "rg_env.h"
  43 #include "rg_sch_err.h"
  44 #include "rg_sch_inf.h"
  45 #include "rg_sch.h"
  46 #include "rg_sch_cmn.h"
  47
  48 /* header/extern include files (.x) */
  49 #include "lrg.x"
  50 #include "rgr.x"
  51 #include "tfu.x"
  52 #include "rgm.x"           /* layer management typedefs for MAC */
  53 #include "rg_sch_inf.x"
  54 #include "rg_sch.x"
  55 #include "rg_sch_cmn.x"
  56 #include "rl_interface.h"
  57 #include "rl_common.h"
  58
  59
  60 /* local defines */
  61 PRIVATE S16 rgSCHDbmInitUeCbLst ARGS(( RgSchCellCb *cellCb, U16 numBins));
  62 #ifdef LTE_TDD
  63 PRIVATE S16 rgSCHDbmInitUeTfuPendLst ARGS(( RgSchCellCb *cellCb, U16 numBins));
  64 #endif
  65 PRIVATE Void rgSCHDbmInitDedLcLst ARGS((RgSchUeCb *ueCb));
  66 PRIVATE Void rgSCHDbmInitCmnLcLst ARGS((RgSchCellCb *cellCb));
  67 #ifdef LTEMAC_SPS
  68 PRIVATE S16 rgSCHDbmInitSpsUeCbLst ARGS((RgSchCellCb *cellCb,
  69                       U16 numBins));
  70 #endif
  71 PRIVATE Void rgSCHDbmInitRaCbLst ARGS(( RgSchCellCb *cellCb));
  72 #ifndef LTE_TDD
  73 PRIVATE Void rgSCHDbmInitRaReqLst ARGS(( RgSchCellCb *cellCb));
  74 #endif
  75 PRIVATE Void rgSCHDbmInitCrntRgrCfgLst ARGS(( RgSchCellCb *cellCb));
  76 PRIVATE Void rgSCHDbmInitPndngRgrCfgLst ARGS(( RgSchCellCb *cellCb));
  77
  78 #ifdef EMTC_ENABLE
  79 PUBLIC  S16 rgSCHDbmPutEmtcRnti ARGS((RgSchCellCb *cellCb,RgSchRntiLnk *rntiLnk));
  80 #endif
  81
  82 /* local typedefs */
  83
  84 /* local externs */
  85
  86 /* forward references */
  87
  88 /**
  89  * @brief Handler for Initializing the cell.
  90  *
  91  * @details
  92  *
  93  *     Function : rgSCHDbmInitCell
  94  *
  95  *   Initializes the lists belonging to the cell.
  96  *
  97  *
  98  *  @param[in]  RgSchCellCb *cellCb
  99  *  @return  S16
 100  *      -# ROK
 101  *      -# RFAILED
 102  **/
 103 #ifdef ANSI
 104 PUBLIC S16 rgSCHDbmInitCell
 105 (
 106 RgSchCellCb       *cellCb
 107 )
 108 #else
 109 PUBLIC S16 rgSCHDbmInitCell(cellCb)
 110 RgSchCellCb       *cellCb;
 111 #endif
 112 {
 113    S16 ret;
 114
 115    TRC2(rgSCHDbmInitCell);
 116
 117    /* Initialize ue list */
 118    if ((ret = rgSCHDbmInitUeCbLst(cellCb, RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
 119       RETVALUE(ret);
 120 #ifdef LTE_TDD
 121    if ((ret = rgSCHDbmInitUeTfuPendLst(cellCb,
 122                                        RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
 123       RETVALUE(ret);
 124 #endif
 125
 126 #ifdef LTEMAC_SPS
 127    /* Initialize SPS Ue list */
 128    if ((ret = rgSCHDbmInitSpsUeCbLst(cellCb, RGSCH_MAX_UE_BIN_PER_CELL)) != ROK)
 129       RETVALUE(ret);
 130 #endif /* LTEMAC_SPS */
 131
 132    /* Initialize BCCH/PCCH logical channels */
 133    rgSCHDbmInitCmnLcLst(cellCb);
 134
 135    /* Initialize configuration lists */
 136    rgSCHDbmInitCrntRgrCfgLst(cellCb);
 137    rgSCHDbmInitPndngRgrCfgLst(cellCb);
 138
 139 #ifndef LTE_TDD
 140    /* Initialize raReq list */
 141    rgSCHDbmInitRaReqLst(cellCb);
 142 #endif
 143
 144    /* Initialize raCb list */
 145    rgSCHDbmInitRaCbLst(cellCb);
 146
 147    /* Initialize l2mList */
 148 #ifdef LTE_L2_MEAS
 149    cmLListInit(&cellCb->l2mList);
 150 #endif /* LTE_L2_MEAS */
 151
 152    RETVALUE(ret);
 153
 154 } /* rgSCHDbmInitCell */
 155
 156 /**
 157  * @brief Handler for initializing the ueCbLst under the cellCb.
 158  *
 159  * @details
 160  *
 161  *     Function : rgSCHDbmInitUeCbLst
 162  *
 163  *
 164  *  @param[in] *cellCb
 165  *  @param[in] numBins
 166  *  @return  S16
 167  *      -# ROK
 168  *      -# RFAILED
 169  **/
 170 #ifdef ANSI
 171 PRIVATE S16 rgSCHDbmInitUeCbLst
 172 (
 173 RgSchCellCb    *cellCb,
 174 U16            numBins
 175 )
 176 #else
 177 PRIVATE S16 rgSCHDbmInitUeCbLst(cellCb, numBins)
 178 RgSchCellCb    *cellCb;
 179 U16            numBins;
 180 #endif
 181 {
 182    RgSchUeCellInfo ueCellInfo;
 183    TRC2(rgSCHDbmInitUeCbLst)
 184
 185    /* Fix: syed It is better to compute offset dynamically
 186     * rather than hardcoding it as 0 */
 187    RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ueCellInfo.ueLstEnt) - (PTR)&ueCellInfo), FALSE,
 188                CM_HASH_KEYTYPE_CONID,
 189                rgSchCb[cellCb->instIdx].rgSchInit.region,
 190                rgSchCb[cellCb->instIdx].rgSchInit.pool));
 191
 192 }  /* rgSCHDbmInitUeCbLst */
 193
 194 /**
 195  * @brief Handler for de-initializing the ueCbLst under the cellCb.
 196  *
 197  * @details
 198  *
 199  *     Function : rgSCHDbmDeInitUeCbLst
 200  *
 201  *
 202  *  @param[in] *cellCb
 203  *  @return  S16
 204  *      -# ROK
 205  *      -# RFAILED
 206  **/
 207 #ifdef ANSI
 208 PUBLIC S16 rgSCHDbmDeInitUeCbLst
 209 (
 210 RgSchCellCb       *cellCb
 211 )
 212 #else
 213 PUBLIC S16 rgSCHDbmDeInitUeCbLst(cellCb)
 214 RgSchCellCb       *cellCb;
 215 #endif
 216 {
 217    TRC2(rgSCHDbmDeInitUeCbLst)
 218
 219    RETVALUE(cmHashListDeinit(&cellCb->ueLst));
 220
 221 }  /* rgSCHDbmDeInitUeCbLst */
 222
 223 #ifdef LTEMAC_SPS
 224 /**
 225  * @brief Handler for initializing the spsUeCbLst under the cellCb.
 226  *
 227  * @details
 228  *
 229  *     Function : rgSCHDbmInitSpsUeCbLst
 230  *
 231  *
 232  *  @param[in] *cellCb
 233  *  @param[in] numBins
 234  *  @return  S16
 235  *      -# ROK
 236  *      -# RFAILED
 237  **/
 238 #ifdef ANSI
 239 PRIVATE S16 rgSCHDbmInitSpsUeCbLst
 240 (
 241 RgSchCellCb       *cellCb,
 242 U16               numBins
 243 )
 244 #else
 245 PRIVATE S16 rgSCHDbmInitSpsUeCbLst(cellCb, numBins)
 246 RgSchCellCb       *cellCb;
 247 U16               numBins;
 248 #endif
 249 {
 250    RgSchUeCb ue;
 251    TRC2(rgSCHDbmInitSpsUeCbLst)
 252
 253    RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
 254                CM_HASH_KEYTYPE_CONID,
 255                rgSchCb[cellCb->instIdx].rgSchInit.region,
 256                rgSchCb[cellCb->instIdx].rgSchInit.pool));
 257
 258 }  /* rgSCHDbmInitSpsUeCbLst */
 259
 260 /**
 261  * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
 262  *
 263  * @details
 264  *
 265  *     Function : rgSCHDbmDeInitSpsUeCbLst
 266  *
 267  *
 268  *  @param[in] *cellCb
 269  *  @return  S16
 270  *      -# ROK
 271  *      -# RFAILED
 272  **/
 273 #ifdef ANSI
 274 PUBLIC S16 rgSCHDbmDeInitSpsUeCbLst
 275 (
 276 RgSchCellCb       *cellCb
 277 )
 278 #else
 279 PUBLIC S16 rgSCHDbmDeInitSpsUeCbLst(cellCb)
 280 RgSchCellCb       *cellCb;
 281 #endif
 282 {
 283    TRC2(rgSCHDbmDeInitSpsUeCbLst)
 284
 285    RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
 286
 287 }  /* rgSCHDbmDeInitSpsUeCbLst */
 288
 289 #endif /* LTEMAC_SPS */
 290
 291 /**
 292  * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
 293  *
 294  * @details
 295  *
 296  *     Function : rgSCHDbmInsUeCb
 297  *
 298  *
 299  *  @param[in] *cellCb
 300  *  @param[in] *ueCb
 301  *  @return  S16
 302  *      -# ROK
 303  *      -# RFAILED
 304  **/
 305 #ifdef ANSI
 306 PUBLIC S16 rgSCHDbmInsUeCb
 307 (
 308 RgSchCellCb       *cellCb,
 309 RgSchUeCb         *ueCb
 310 )
 311 #else
 312 PUBLIC S16 rgSCHDbmInsUeCb(cellCb, ueCb)
 313 RgSchCellCb       *cellCb;
 314 RgSchUeCb         *ueCb;
 315 #endif
 316 {
 317    RgSchUeCellInfo *ueCellInfo = NULLP;
 318    TRC2(rgSCHDbmInsUeCb)
 319
 320    ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
 321
 322    RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCellInfo,
 323       (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
 324
 325 }  /* rgSCHDbmInsUeCb */
 326
 327 #ifdef LTEMAC_SPS
 328 /**
 329  * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
 330  *
 331  * @details
 332  *
 333  *     Function : rgSCHDbmInsSpsUeCb
 334  *
 335  *
 336  *  @param[in] *cellCb
 337  *  @param[in] *ueCb
 338  *  @return  S16
 339  *      -# ROK
 340  *      -# RFAILED
 341  **/
 342 #ifdef ANSI
 343 PUBLIC S16 rgSCHDbmInsSpsUeCb
 344 (
 345 RgSchCellCb       *cellCb,
 346 RgSchUeCb         *ueCb
 347 )
 348 #else
 349 PUBLIC S16 rgSCHDbmInsSpsUeCb(cellCb, ueCb)
 350 RgSchCellCb       *cellCb;
 351 RgSchUeCb         *ueCb;
 352 #endif
 353 {
 354    TRC2(rgSCHDbmInsSpsUeCb)
 355
 356    RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
 357       (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
 358
 359 }  /* end of rgSCHDbmInsSpsUeCb */
 360
 361 #endif /* LTEMAC_SPS */
 362
 363 /**
 364  * @brief Handler for accessing the existing ueCb identified by the key ueId
 365  * in the ueCbLst under the cellCb.
 366  *
 367  * @details
 368  *
 369  *     Function : rgSCHDbmGetUeCb
 370  *
 371  *
 372  *  @param[in]  *cellCb
 373  *  @param[in]  ueId
 374  *  @return  RgSchUeCb*
 375  **/
 376 #ifdef ANSI
 377 PUBLIC RgSchUeCb* rgSCHDbmGetUeCb
 378 (
 379 RgSchCellCb       *cellCb,
 380 CmLteRnti      ueId
 381 )
 382 #else
 383 PUBLIC RgSchUeCb* rgSCHDbmGetUeCb(cellCb, ueId)
 384 RgSchCellCb       *cellCb;
 385 CmLteRnti      ueId;
 386 #endif
 387 {
 388    RgSchUeCellInfo *ueCellInfo = NULLP;
 389
 390    TRC2(rgSCHDbmGetUeCb)
 391
 392    cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
 393       sizeof(ueId), 0, (PTR *)&ueCellInfo);
 394
 395    RETVALUE(!ueCellInfo?NULLP:ueCellInfo->ue);
 396 }  /* rgSCHDbmGetUeCb */
 397
 398 #ifdef LTEMAC_SPS
 399 /**
 400  * @brief Handler for accessing the existing ueCb identified by the key
 401  * spsRnti in the spsUeCbLst under the cellCb.
 402  *
 403  * @details
 404  *
 405  *     Function : rgSCHDbmGetSpsUeCb
 406  *
 407  *
 408  *  @param[in]  *cellCb
 409  *  @param[in]  ueId
 410  *  @return  RgSchUeCb*
 411  **/
 412 #ifdef ANSI
 413 PUBLIC RgSchUeCb* rgSCHDbmGetSpsUeCb
 414 (
 415 RgSchCellCb       *cellCb,
 416 CmLteRnti         spsRnti
 417 )
 418 #else
 419 PUBLIC RgSchUeCb* rgSCHDbmGetSpsUeCb(cellCb, spsRnti)
 420 RgSchCellCb       *cellCb;
 421 CmLteRnti         spsRnti;
 422 #endif
 423 {
 424    RgSchUeCb *ueCb = NULLP;
 425
 426    TRC2(rgSCHDbmGetSpsUeCb)
 427
 428    cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
 429       sizeof(spsRnti), 0, (PTR *)&ueCb);
 430    RETVALUE(ueCb);
 431 }  /* rgSCHDbmGetSpsUeCb */
 432 #endif
 433
 434 /**
 435  * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
 436  *  cellCb.
 437  *
 438  * @details
 439  *
 440  *     Function : rgSCHDbmGetNextUeCb
 441  *
 442  *
 443  *  @param[in]  *cellCb
 444  *  @param[in]  *ueCb
 445  *  @return  RgSchUeCb*
 446  **/
 447 #ifdef ANSI
 448 PUBLIC RgSchUeCb* rgSCHDbmGetNextUeCb
 449 (
 450 RgSchCellCb       *cellCb,
 451 RgSchUeCb         *ueCb
 452 )
 453 #else
 454 PUBLIC RgSchUeCb* rgSCHDbmGetNextUeCb(cellCb, ueCb)
 455 RgSchCellCb       *cellCb;
 456 RgSchUeCb         *ueCb;
 457 #endif
 458 {
 459    RgSchUeCellInfo *ueCellInfo = NULLP;
 460    RgSchUeCellInfo *nextUeCellInfo = NULLP;
 461
 462    TRC2(rgSCHDbmGetNextUeCb)
 463
 464    if (ueCb)
 465    {
 466       ueCellInfo = ueCb->cellInfo[
 467          ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
 468    }
 469
 470    cmHashListGetNext(&cellCb->ueLst, (PTR) ueCellInfo, (PTR *)&nextUeCellInfo);
 471    RETVALUE(!nextUeCellInfo?NULLP:nextUeCellInfo->ue);
 472 }  /* rgSCHDbmGetNextUeCb */
 473
 474 #ifdef LTEMAC_SPS
 475 /**
 476  * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
 477  *         using SPS-Rnti under the cellCb.
 478  *
 479  * @details
 480  *
 481  *     Function : rgSCHDbmGetNextSpsUeCb
 482  *
 483  *
 484  *  @param[in]  *cellCb
 485  *  @param[in]  *ueCb
 486  *  @return  RgSchUeCb*
 487  **/
 488 #ifdef ANSI
 489 PUBLIC RgSchUeCb* rgSCHDbmGetNextSpsUeCb
 490 (
 491 RgSchCellCb       *cellCb,
 492 RgSchUeCb         *ueCb
 493 )
 494 #else
 495 PUBLIC RgSchUeCb* rgSCHDbmGetNextSpsUeCb(cellCb, ueCb)
 496 RgSchCellCb       *cellCb;
 497 RgSchUeCb         *ueCb;
 498 #endif
 499 {
 500    RgSchUeCb *nextUeCb = NULLP;
 501
 502    TRC2(rgSCHDbmGetNextSpsUeCb)
 503
 504    cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
 505    RETVALUE(nextUeCb);
 506 }  /* end of rgSCHDbmGetNextSpsUeCb */
 507
 508 #endif /* LTEMAC_SPS */
 509
 510 #ifdef LTE_L2_MEAS
 511 /**
 512  * @brief Handler for Cleaning up L2 Meas related Data in
 513  * cellCb.
 514  *
 515  * @details
 516  *
 517  *     Function : rgSCHDbmDelL2MUe
 518  *
 519  *
 520  *  @param[in]  *cellCb
 521  *  @param[in]  *ueCb
 522  *  @return  S16
 523  *      -# ROK
 524  *      -# RFAILED
 525  **/
 526 #ifdef ANSI
 527 PUBLIC S16 rgSCHDbmDelL2MUe
 528 (
 529 RgSchCellCb       *cellCb,
 530 RgSchUeCb         *ueCb
 531 )
 532 #else
 533 PUBLIC S16 rgSCHDbmDelL2MUe(cellCb, ueCb)
 534 RgSchCellCb       *cellCb;
 535 RgSchUeCb         *ueCb;
 536 #endif
 537 {
 538    U8 lcCnt = 0;
 539    RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
 540
 541    TRC2(rgSCHDbmDelL2MUe)
 542
 543    ueUl->hqEnt.numBusyHqProcs = 0;
 544    /* Clean cell level UE Active Count */
 545    for (lcCnt =0; lcCnt < RGSCH_MAX_LC_PER_UE; lcCnt++)
 546    {
 547       if (ueCb->ul.lcCb[lcCnt].isValid)
 548       {
 549          if((ueCb->ul.lcCb[lcCnt].qciCb->ulUeCount) &&
 550                (ueCb->ulActiveLCs &
 551                 (1 << (ueCb->ul.lcCb[lcCnt].qciCb->qci -1))))
 552          {
 553             ueCb->ul.lcCb[lcCnt].qciCb->ulUeCount--;
 554             ueCb->ulActiveLCs &= ~(1 <<
 555                   (ueCb->ul.lcCb[lcCnt].qciCb->qci -1));
 556          }
 557       }
 558
 559       if (ueCb->dl.lcCb[lcCnt])
 560       {
 561          if (ueCb->qciActiveLCs[ueCb->dl.lcCb[lcCnt]->qciCb->qci])
 562          {
 563             ueCb->dl.lcCb[lcCnt]->qciCb->dlUeCount--;
 564             ueCb->qciActiveLCs[ueCb->dl.lcCb[lcCnt]->qciCb->qci] = 0;
 565          }
 566       }
 567    }
 568
 569    RETVALUE(ROK);
 570 }  /* rgSCHDbmDelL2MUe */
 571
 572 #endif
 573
 574 /**
 575  * @brief Handler for deleting the existing ueCb from the ueCbLst under the
 576  * cellCb.
 577  *
 578  * @details
 579  *
 580  *     Function : rgSCHDbmDelUeCb
 581  *
 582  *
 583  *  @param[in]  *cellCb
 584  *  @param[in]  *ueCb
 585  *  @return  S16
 586  *      -# ROK
 587  *      -# RFAILED
 588  **/
 589 #ifdef ANSI
 590 PUBLIC S16 rgSCHDbmDelUeCb
 591 (
 592 RgSchCellCb       *cellCb,
 593 RgSchUeCb         *ueCb
 594 )
 595 #else
 596 PUBLIC S16 rgSCHDbmDelUeCb(cellCb, ueCb)
 597 RgSchCellCb       *cellCb;
 598 RgSchUeCb         *ueCb;
 599 #endif
 600 {
 601    RgSchUeCellInfo *ueCellInfo = NULLP;
 602    TRC2(rgSCHDbmDelUeCb)
 603
 604    ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
 605
 606    RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCellInfo));
 607 }  /* rgSCHDbmDelUeCb */
 608
 609 #ifdef LTEMAC_SPS
 610 /**
 611  * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
 612  * cellCb.
 613  *
 614  * @details
 615  *
 616  *     Function : rgSCHDbmDelSpsUeCb
 617  *
 618  *
 619  *  @param[in]  *cellCb
 620  *  @param[in]  *ueCb
 621  *  @return  S16
 622  *      -# ROK
 623  *      -# RFAILED
 624  **/
 625 #ifdef ANSI
 626 PUBLIC S16 rgSCHDbmDelSpsUeCb
 627 (
 628 RgSchCellCb       *cellCb,
 629 RgSchUeCb         *ueCb
 630 )
 631 #else
 632 PUBLIC S16 rgSCHDbmDelSpsUeCb(cellCb, ueCb)
 633 RgSchCellCb       *cellCb;
 634 RgSchUeCb         *ueCb;
 635 #endif
 636 {
 637    TRC2(rgSCHDbmDelSpsUeCb)
 638
 639    RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
 640 }  /* end of rgSCHDbmDelSpsUeCb */
 641
 642 #endif /* LTEMAC_SPS */
 643
 644 /**
 645  * @brief Handler for Initializing the UE.
 646  *
 647  * @details
 648  *
 649  *     Function : rgSCHDbmInitUe
 650  *
 651  *   Initializes the lists belonging to the UE.
 652  *
 653  *
 654  *  @param[in]  RgSchUeCb  *ueCb
 655  *  @return  S16
 656  *      -# ROK
 657  *      -# RFAILED
 658  **/
 659 #ifdef ANSI
 660 PUBLIC S16 rgSCHDbmInitUe
 661 (
 662 RgSchUeCb       *ueCb
 663 )
 664 #else
 665 PUBLIC S16 rgSCHDbmInitUe(ueCb)
 666 RgSchUeCb       *ueCb;
 667 #endif
 668 {
 669    S16 ret = ROK;
 670
 671    TRC2(rgSCHDbmInitUe);
 672
 673    /* Initialize Dedicated logical channels */
 674    rgSCHDbmInitDedLcLst(ueCb);
 675
 676    RETVALUE(ret);
 677 } /* rgSCHDbmInitUe */
 678
 679 /**
 680  * @brief Handler for Initializing the dedicated logical channels.
 681  *
 682  * @details
 683  *
 684  *     Function : rgSCHDbmInitDedLcLst
 685  *
 686  *   Initializes dedicated logical channels.
 687  *
 688  *  @param[in]  RgSchUeCb *ueCb
 689  *  @return     Void
 690  **/
 691 #ifdef ANSI
 692 PRIVATE Void rgSCHDbmInitDedLcLst
 693 (
 694 RgSchUeCb       *ueCb
 695 )
 696 #else
 697 PRIVATE Void rgSCHDbmInitDedLcLst(ueCb)
 698 RgSchUeCb       *ueCb;
 699 #endif
 700 {
 701    U8 idx;
 702
 703    TRC2(rgSCHDbmInitDedLcLst);
 704
 705    for (idx = 0; idx < RGSCH_MAX_LC_PER_UE; ++idx)
 706    {
 707       /* Set Dedicated LCs as not configured */
 708       ueCb->ul.lcCb[idx].isValid = FALSE;
 709       ueCb->dl.lcCb[idx] = NULLP;
 710    }
 711
 712    /* Stack Crash problems for TRACE5 Changes. Added the return below */
 713    RETVOID;
 714
 715
 716 } /* rgSCHDbmInitDedLcLst */
 717
 718 /**
 719  * @brief Handler for Initializing the common logical channel list of the cell.
 720  *
 721  * @details
 722  *
 723  *     Function : rgSCHDbmInitCmnLcLst
 724  *
 725  *   Initializes following common logical channels belonging to the cell.
 726  *     - BCCH on BCH
 727  *     - BCCH on DLSCH
 728  *     - PCCH
 729  *
 730  *  @param[in]  RgSchCellCb *cellCb
 731  *  @return  Void
 732  **/
 733 #ifdef ANSI
 734 PRIVATE Void rgSCHDbmInitCmnLcLst
 735 (
 736 RgSchCellCb       *cellCb
 737 )
 738 #else
 739 PRIVATE Void rgSCHDbmInitCmnLcLst(cellCb)
 740 RgSchCellCb       *cellCb;
 741 #endif
 742 {
 743    U8 idx;
 744
 745    TRC2(rgSCHDbmInitCmnLcLst);
 746
 747    for (idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
 748    {
 749       cellCb->cmnLcCb[idx].lcId = RGSCH_INVALID_LC_ID;
 750    }
 751
 752    /* Stack Crash problems for TRACE5 Changes. Added the return below */
 753    RETVOID;
 754
 755 } /* rgSCHDbmInitCmnLcLst */
 756
 757 /**
 758  * @brief Handler for inserting dedicated DL logical channel.
 759  *
 760  * @details
 761  *
 762  *     Function : rgSCHDbmInsDlDedLcCb
 763  *
 764  *  @param[in]  RgSchUeCb *ueCb
 765  *  @param[in]  RgSchDlLcCb* dlLcCb
 766  *  @return  Void
 767  **/
 768 #ifdef ANSI
 769 PUBLIC Void rgSCHDbmInsDlDedLcCb
 770 (
 771 RgSchUeCb         *ueCb,
 772 RgSchDlLcCb       *dlLcCb
 773 )
 774 #else
 775 PUBLIC Void rgSCHDbmInsDlDedLcCb(ueCb, dlLcCb)
 776 RgSchUeCb         *ueCb;
 777 RgSchDlLcCb       *dlLcCb;
 778 #endif
 779 {
 780    TRC2(rgSCHDbmInsDlDedLcCb);
 781
 782    ueCb->dl.lcCb[dlLcCb->lcId - 1] = dlLcCb;
 783
 784 }  /* rgSCHDbmInsDlDedLcCb */
 785
 786 /**
 787  * @brief Handler for deleting dedicated DL logical channel.
 788  *
 789  * @details
 790  *
 791  *     Function : rgSCHDbmDelDlDedLcCb
 792  *
 793  *  @param[in]  RgSchUeCb *ueCb
 794  *  @param[in]  RgSchDlLcCb* dlLcCb
 795  *  @return  Void
 796  **/
 797 #ifdef ANSI
 798 PUBLIC Void rgSCHDbmDelDlDedLcCb
 799 (
 800 RgSchUeCb         *ueCb,
 801 RgSchDlLcCb       *dlLcCb
 802 )
 803 #else
 804 PUBLIC Void rgSCHDbmDelDlDedLcCb(ueCb, dlLcCb)
 805 RgSchUeCb         *ueCb;
 806 RgSchDlLcCb       *dlLcCb;
 807 #endif
 808 {
 809    TRC2(rgSCHDbmDelDlDedLcCb);
 810
 811 #ifdef LTE_L2_MEAS
 812    /* Clean cell level UE Active Count */
 813
 814    if (ueCb->dl.lcCb[dlLcCb->lcId - 1])
 815    {
 816       if ((dlLcCb->qciCb)
 817             && (ueCb->qciActiveLCs[dlLcCb->qciCb->qci]))
 818       {
 819          ueCb->qciActiveLCs[dlLcCb->qciCb->qci]--;
 820          if (!(ueCb->qciActiveLCs[dlLcCb->qciCb->qci]))
 821          {
 822             dlLcCb->qciCb->dlUeCount--;
 823          }
 824       }
 825    }
 826 #endif /* LTE_L2_MEAS */
 827
 828    ueCb->dl.lcCb[dlLcCb->lcId - 1] = NULLP;
 829
 830    /* Stack Crash problems for TRACE5 Changes. Added the return below */
 831    RETVOID;
 832
 833 }  /* rgSCHDbmDelDlDedLcCb */
 834
 835 /**
 836  * @brief Handler for accessing the existing dl dedicated lcCb at idx in the
 837  * lcCbLst of the ueCb.
 838  *
 839  * @details
 840  *
 841  *     Function : rgSCHDbmGetDlDedLcCb
 842  *
 843  *  @param[in]  *ueCb
 844  *  @param[in]  idx
 845  *  @return  RgSchDlLcCb*
 846  **/
 847 #ifdef ANSI
 848 PUBLIC RgSchDlLcCb* rgSCHDbmGetDlDedLcCb
 849 (
 850 RgSchUeCb         *ueCb,
 851 CmLteLcId        idx
 852 )
 853 #else
 854 PUBLIC RgSchDlLcCb* rgSCHDbmGetDlDedLcCb(ueCb, idx)
 855 RgSchUeCb         *ueCb;
 856 CmLteLcId        idx;
 857 #endif
 858 {
 859    TRC2(rgSCHDbmGetDlDedLcCb);
 860
 861    if (idx < RGSCH_DEDLC_MIN_LCID || idx > RGSCH_DEDLC_MAX_LCID)
 862    {
 863       RETVALUE(NULLP);
 864    }
 865    RETVALUE(ueCb->dl.lcCb[idx-1]);
 866
 867 }  /* rgSCHDbmGetDlDedLcCb */
 868
 869 /**
 870  * @brief Handler for accessing the existing first dl dedicated lcCb at idx
 871  * in the lcCbLst of the ueCb.
 872  *
 873  * @details
 874  *
 875  *     Function : rgSCHDbmGetFirstDlDedLcCb
 876  *
 877  *
 878  *  @param[in]  *ueCb
 879  *  @return  RgSchDlLcCb*
 880  **/
 881 #ifdef ANSI
 882 PUBLIC RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb
 883 (
 884 RgSchUeCb         *ueCb
 885 )
 886 #else
 887 PUBLIC RgSchDlLcCb* rgSCHDbmGetFirstDlDedLcCb(ueCb)
 888 RgSchUeCb         *ueCb;
 889 #endif
 890 {
 891    U8 idx;
 892    TRC2(rgSCHDbmGetFirstDlDedLcCb)
 893
 894    for(idx = 0; idx < RGSCH_DEDLC_MAX_LCID; idx++)
 895    {
 896       if(ueCb->dl.lcCb[idx])
 897       {
 898          RETVALUE(ueCb->dl.lcCb[idx]);
 899       }
 900    }
 901    RETVALUE(NULLP);
 902 }  /* rgSCHDbmGetFirstDlDedLcCb */
 903 /**
 904  * @brief Handler for accessing the existing next dl dedicated lcCb at idx
 905  * in the lcCbLst of the ueCb.
 906  *
 907  * @details
 908  *
 909  *     Function : rgSCHDbmGetNextDlDedLcCb
 910  *
 911  *
 912  *  @param[in]  *ueCb
 913  *  @param[in]  *lcCb
 914  *  @return  RgSchDlLcCb*
 915  **/
 916 #ifdef ANSI
 917 PUBLIC RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb
 918 (
 919 RgSchUeCb         *ueCb,
 920 RgSchDlLcCb       *lcCb
 921 )
 922 #else
 923 PUBLIC RgSchDlLcCb* rgSCHDbmGetNextDlDedLcCb(ueCb, lcCb)
 924 RgSchUeCb         *ueCb;
 925 RgSchDlLcCb       *lcCb;
 926 #endif
 927 {
 928    U8 idx;
 929    TRC2(rgSCHDbmGetNextDlDedLcCb);
 930
 931    if (!lcCb)
 932    {
 933       RETVALUE(rgSCHDbmGetFirstDlDedLcCb(ueCb));
 934    }
 935
 936    for(idx = lcCb->lcId; idx < RGSCH_DEDLC_MAX_LCID; idx++)
 937    {
 938       if(ueCb->dl.lcCb[idx])
 939       {
 940          RETVALUE(ueCb->dl.lcCb[idx]);
 941       }
 942    }
 943    RETVALUE(NULLP);
 944 }  /* rgSCHDbmGetNextDlDedLcCb */
 945
 946 /**
 947  * @brief Handler for accessing the existing dl common lcCb identified by the key lcId
 948  * in the lcCbLst of the ueCb.
 949  *
 950  * @details
 951  *
 952  *     Function : rgSCHDbmGetCmnLcCb
 953  *
 954  *
 955  *  @param[in]  *cellCb
 956  *  @param[in]  lcId
 957  *  @return  RgSchClcDlLcCb*
 958  **/
 959 #ifdef ANSI
 960 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb
 961 (
 962 RgSchCellCb       *cellCb,
 963 CmLteLcId         lcId
 964 )
 965 #else
 966 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetCmnLcCb(cellCb, lcId)
 967 RgSchCellCb       *cellCb;
 968 CmLteLcId         lcId;
 969 #endif
 970 {
 971    U8 idx;
 972
 973    TRC2(rgSCHDbmGetCmnLcCb)
 974
 975    for(idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
 976    {
 977       if(cellCb->cmnLcCb[idx].lcId == lcId)
 978       {
 979          RETVALUE(&(cellCb->cmnLcCb[idx]));
 980       }
 981    }
 982    RETVALUE(NULLP);
 983 }  /* rgSCHDbmGetCmnLcCb */
 984
 985 /**
 986  * @brief Handler for accessing the existing BCCH mapped on to BCH in the
 987  * lcCbLst of the ueCb.
 988  *
 989  * @details
 990  *
 991  *     Function : rgSCHDbmGetBcchOnBch
 992  *
 993  *
 994  *  @param[in]  *cellCb
 995  *  @return  RgSchClcDlLcCb*
 996  **/
 997 #ifdef ANSI
 998 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch
 999 (
1000 RgSchCellCb       *cellCb
1001 )
1002 #else
1003 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetBcchOnBch(cellCb)
1004 RgSchCellCb       *cellCb;
1005 #endif
1006 {
1007    TRC2(rgSCHDbmGetBcchOnBch)
1008
1009    if(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].lcId != RGSCH_INVALID_LC_ID)
1010    {
1011       RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX]));
1012    }
1013    RETVALUE(NULLP);
1014 }  /* rgSCHDbmGetBcchOnBch */
1015
1016 /**
1017  * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the
1018  * lcCbLst of the ueCb.
1019  *
1020  * @details
1021  *
1022  *     Function : rgSCHDbmGetFirstBcchOnDlsch
1023  *
1024  *
1025  *  @param[in]  *cellCb
1026  *  @return  RgSchClcDlLcCb*
1027  **/
1028 #ifdef ANSI
1029 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch
1030 (
1031 RgSchCellCb       *cellCb
1032 )
1033 #else
1034 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetFirstBcchOnDlsch(cellCb)
1035 RgSchCellCb       *cellCb;
1036 #endif
1037 {
1038    TRC2(rgSCHDbmGetFirstBcchOnDlsch)
1039
1040    if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId != RGSCH_INVALID_LC_ID)
1041    {
1042       RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1]));
1043    }
1044    RETVALUE(NULLP);
1045 }  /* rgSCHDbmGetFirstBcchOnDlsch */
1046
1047 /**
1048  * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the
1049  * lcCbLst of the ueCb.
1050  *
1051  * @details
1052  *
1053  *     Function : rgSCHDbmGetSecondBcchOnDlsch
1054  *
1055  *
1056  *  @param[in]  *cellCb
1057  *  @return  RgSchClcDlLcCb*
1058  **/
1059 #ifdef ANSI
1060 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch
1061 (
1062 RgSchCellCb       *cellCb
1063 )
1064 #else
1065 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetSecondBcchOnDlsch(cellCb)
1066 RgSchCellCb       *cellCb;
1067 #endif
1068 {
1069    TRC2(rgSCHDbmGetSecondBcchOnDlsch)
1070
1071    if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].lcId != RGSCH_INVALID_LC_ID)
1072    {
1073       RETVALUE(&(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2]));
1074    }
1075    RETVALUE(NULLP);
1076 }  /* rgSCHDbmGetSecondBcchOnDlsch */
1077
1078 /**
1079  * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
1080  *
1081  * @details
1082  *
1083  *     Function : rgSCHDbmGetPcch
1084  *
1085  *
1086  *  @param[in]  *cellCb
1087  *  @return  RgSchClcDlLcCb*
1088  **/
1089 #ifdef ANSI
1090 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetPcch
1091 (
1092 RgSchCellCb       *cellCb
1093 )
1094 #else
1095 PUBLIC RgSchClcDlLcCb* rgSCHDbmGetPcch(cellCb)
1096 RgSchCellCb       *cellCb;
1097 #endif
1098 {
1099    TRC2(rgSCHDbmGetPcch)
1100
1101    if(cellCb->cmnLcCb[RGSCH_PCCH_IDX].lcId != RGSCH_INVALID_LC_ID)
1102    {
1103       RETVALUE(&(cellCb->cmnLcCb[RGSCH_PCCH_IDX]));
1104    }
1105    RETVALUE(NULLP);
1106 }  /* rgSCHDbmGetPcch */
1107
1108 /**
1109  * @brief Handler for inserting the BCCH mapped on to BCH in the
1110  * lcCbLst of the ueCb.
1111  *
1112  * @details
1113  *
1114  *     Function : rgSCHDbmInsBcchOnBch
1115  *
1116  *
1117  *  @param[in]  *cellCb
1118  *  @return  Void
1119  **/
1120 #ifdef ANSI
1121 PUBLIC Void rgSCHDbmInsBcchOnBch
1122 (
1123 RgSchCellCb       *cellCb,
1124 RgSchClcDlLcCb   *cmnDlLcCb
1125 )
1126 #else
1127 PUBLIC Void rgSCHDbmInsBcchOnBch(cellCb, cmnDlLcCb)
1128 RgSchCellCb       *cellCb;
1129 RgSchClcDlLcCb   *cmnDlLcCb;
1130 #endif
1131 {
1132    TRC2(rgSCHDbmInsBcchOnBch)
1133
1134    cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].lcId = cmnDlLcCb->lcId;
1135    cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].boLst = cmnDlLcCb->boLst;
1136
1137    /* Stack Crash problems for TRACE5 Changes. Added the return below */
1138    RETVOID;
1139
1140 }  /* rgSCHDbmInsBcchOnBch */
1141
1142 /**
1143  * @brief Handler for inserting the BCCH mapped on to DLSCH in the
1144  * lcCbLst of the ueCb.
1145  *
1146  * @details
1147  *
1148  *     Function : rgSCHDbmInsBcchOnDlsch
1149  *
1150  *
1151  *  @param[in]  *cellCb
1152  *  @return  Void
1153  **/
1154 #ifdef ANSI
1155 PUBLIC Void rgSCHDbmInsBcchOnDlsch
1156 (
1157 RgSchCellCb       *cellCb,
1158 RgSchClcDlLcCb   *cmnDlLcCb
1159 )
1160 #else
1161 PUBLIC Void rgSCHDbmInsBcchOnDlsch(cellCb, cmnDlLcCb)
1162 RgSchCellCb       *cellCb;
1163 RgSchClcDlLcCb   *cmnDlLcCb;
1164 #endif
1165 {
1166    TRC2(rgSCHDbmInsBcchOnDlsch)
1167
1168    if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId == RGSCH_INVALID_LC_ID)
1169    {
1170       cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].lcId = cmnDlLcCb->lcId;
1171       cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].boLst = cmnDlLcCb->boLst;
1172       cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX1].si = FALSE;
1173    }
1174    else if(cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].lcId == RGSCH_INVALID_LC_ID)
1175    {
1176       cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].lcId = cmnDlLcCb->lcId;
1177       cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].boLst = cmnDlLcCb->boLst;
1178       cellCb->cmnLcCb[RGSCH_BCCH_DLSCH_IDX2].si = TRUE;
1179    }
1180
1181    /* Stack Crash problems for TRACE5 Changes. Added the return below */
1182    RETVOID;
1183
1184 }  /* rgSCHDbmInsBcchOnDlsch */
1185
1186
1187 /**
1188  * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
1189  *
1190  * @details
1191  *
1192  *     Function : rgSCHDbmInsPcch
1193  *
1194  *
1195  *  @param[in]  *cellCb
1196  *  @return  Void
1197  **/
1198 #ifdef ANSI
1199 PUBLIC Void rgSCHDbmInsPcch
1200 (
1201 RgSchCellCb       *cellCb,
1202 RgSchClcDlLcCb   *cmnDlLcCb
1203 )
1204 #else
1205 PUBLIC Void rgSCHDbmInsPcch(cellCb, cmnDlLcCb)
1206 RgSchCellCb       *cellCb;
1207 RgSchClcDlLcCb   *cmnDlLcCb;
1208 #endif
1209 {
1210    TRC2(rgSCHDbmInsPcch)
1211
1212    cellCb->cmnLcCb[RGSCH_PCCH_IDX].lcId = cmnDlLcCb->lcId;
1213    cellCb->cmnLcCb[RGSCH_PCCH_IDX].boLst = cmnDlLcCb->boLst;
1214
1215    /* Stack Crash problems for TRACE5 Changes. Added the return below */
1216    RETVOID;
1217
1218 }  /* rgSCHDbmInsPcch */
1219
1220 /**
1221  * @brief Handler for initializing the boLst.
1222  *
1223  * @details
1224  *
1225  *     Function : rgSCHDbmInitCmnLcBoLst
1226  *
1227  *
1228  *  @param[in] *cmnDlLcCb
1229  *  @return  Void
1230  **/
1231 #ifdef ANSI
1232 PUBLIC Void rgSCHDbmInitCmnLcBoLst
1233 (
1234 RgSchClcDlLcCb       *cmnDlLcCb
1235 )
1236 #else
1237 PUBLIC Void rgSCHDbmInitCmnLcBoLst(cmnDlLcCb)
1238 RgSchClcDlLcCb       *cmnDlLcCb;
1239 #endif
1240 {
1241    TRC2(rgSCHDbmInitCmnLcBoLst)
1242
1243    cmLListInit(&cmnDlLcCb->boLst);
1244    RETVOID;
1245 }  /* rgSCHDbmInitCmnLcBoLst */
1246
1247 /**
1248  * @brief Handler for inserting the bo report in to the boLst.
1249  *
1250  * @details
1251  *
1252  *     Function : rgSCHDbmInsCmnLcBoRpt
1253  *
1254  *
1255  *  @param[in] *cmnDlLcCb
1256  *  @param[in] *boRpt
1257  *  @return  Void
1258  **/
1259 #ifdef ANSI
1260 PUBLIC Void rgSCHDbmInsCmnLcBoRpt
1261 (
1262 RgSchClcDlLcCb    *cmnDlLcCb,
1263 RgSchClcBoRpt     *cmnBoRpt
1264 )
1265 #else
1266 PUBLIC Void rgSCHDbmInsCmnLcBoRpt(cmnDlLcCb, cmnBoRpt)
1267 RgSchClcDlLcCb    *cmnDlLcCb;
1268 RgSchClcBoRpt     *cmnBoRpt;
1269 #endif
1270 {
1271    TRC2(rgSCHDbmInsCmnLcBoRpt)
1272
1273    cmnBoRpt->boLstEnt.next = NULLP;
1274    cmnBoRpt->boLstEnt.prev = NULLP;
1275    cmnBoRpt->boLstEnt.node = (PTR)cmnBoRpt;
1276    cmLListAdd2Tail(&cmnDlLcCb->boLst, &cmnBoRpt->boLstEnt);
1277    RETVOID;
1278 }  /* rgSCHDbmInsCmnLcBoRpt */
1279
1280
1281 /**
1282  * @brief Handler for initializing the raCbLst.
1283  *
1284  * @details
1285  *
1286  *     Function : rgSCHDbmInitRaCbLst
1287  *
1288  *
1289  *  @param[in] *cellCb
1290  *  @return  Void
1291  **/
1292 #ifdef ANSI
1293 PRIVATE Void rgSCHDbmInitRaCbLst
1294 (
1295 RgSchCellCb       *cellCb
1296 )
1297 #else
1298 PRIVATE Void rgSCHDbmInitRaCbLst(cellCb)
1299 RgSchCellCb       *cellCb;
1300 #endif
1301 {
1302    TRC2(rgSCHDbmInitRaCbLst)
1303
1304    cmLListInit(&cellCb->raInfo.raCbLst);
1305    RETVOID;
1306 }  /* rgSCHDbmInitRaCbLst */
1307
1308
1309 /**
1310  * @brief Handler for accessing the existing raCb in the raCbLst.
1311  *
1312  * @details
1313  *
1314  *     Function : rgSCHDbmGetRaCb
1315  *
1316  *
1317  *  @param[in]  *cellCb
1318  *  @param[in]  key
1319  *  @return  RgSchRaCb*
1320  **/
1321 #ifdef ANSI
1322 PUBLIC RgSchRaCb* rgSCHDbmGetRaCb
1323 (
1324 RgSchCellCb       *cellCb,
1325 CmLteRnti      key
1326 )
1327 #else
1328 PUBLIC RgSchRaCb* rgSCHDbmGetRaCb(cellCb, key)
1329 RgSchCellCb       *cellCb;
1330 CmLteRnti      key;
1331 #endif
1332 {
1333    CmLList *tmpNode;
1334
1335    TRC2(rgSCHDbmGetRaCb)
1336
1337    CM_LLIST_FIRST_NODE(&cellCb->raInfo.raCbLst,tmpNode);
1338    while(tmpNode)
1339    {
1340       if(((RgSchRaCb *)tmpNode->node)->tmpCrnti == key)
1341       {
1342          RETVALUE((RgSchRaCb *)(tmpNode->node));
1343       }
1344       CM_LLIST_NEXT_NODE(&cellCb->raInfo.raCbLst,tmpNode);
1345    }
1346    RETVALUE(NULLP);
1347 }  /* rgSCHDbmGetRaCb */
1348
1349 #ifndef LTE_TDD
1350 /**
1351  * @brief Handler for initializing the raReqLst.
1352  g
1353  * @details
1354  *
1355  *     Function : rgSCHDbmInitRaReqLst
1356  *
1357  *
1358  *  @param[in]  *cellCb
1359  *  @return  Void
1360  **/
1361 #ifdef ANSI
1362 PRIVATE Void rgSCHDbmInitRaReqLst
1363 (
1364 RgSchCellCb       *cellCb
1365 )
1366 #else
1367 PRIVATE Void rgSCHDbmInitRaReqLst(cellCb)
1368 RgSchCellCb       *cellCb;
1369 #endif
1370 {
1371    U8 idx;
1372
1373    TRC2(rgSCHDbmInitRaReqLst)
1374
1375    /* ccpu00133557- Memory Leak Fix- initializing for the all nodes
1376     * in RAREQ list*/
1377    for(idx = 0; idx < RGSCH_RAREQ_ARRAY_SIZE; idx++)
1378    {
1379       cmLListInit(&cellCb->raInfo.raReqLst[idx]);
1380    }
1381    RETVOID;
1382 }  /* rgSCHDbmInitRaReqLst */
1383 #endif
1384
1385 /**
1386  * @brief Handler for initializing the crnt rgr cfgLst.
1387  *
1388  * @details
1389  *
1390  *     Function : rgSCHDbmInitCrntRgrCfgLst
1391  *
1392  *
1393  *  @param[in] *cellCb
1394  *  @return  Void
1395  **/
1396 #ifdef ANSI
1397 PRIVATE Void rgSCHDbmInitCrntRgrCfgLst
1398 (
1399 RgSchCellCb       *cellCb
1400 )
1401 #else
1402 PRIVATE Void rgSCHDbmInitCrntRgrCfgLst(cellCb)
1403 RgSchCellCb       *cellCb;
1404 #endif
1405 {
1406    TRC2(rgSCHDbmInitCrntRgrCfgLst)
1407
1408    cmLListInit(&cellCb->rgCfgInfo.crntRgrCfgLst);
1409    RETVOID;
1410 }  /* rgSCHDbmInitCrntRgrCfgLst */
1411
1412 /**
1413  * @brief Handler for initializing the pndng rgr cfgLst.
1414  *
1415  * @details
1416  *
1417  *     Function : rgSCHDbmInitPndngRgrCfgLst
1418  *
1419  *
1420  *  @param[in] *cellCb
1421  *  @return  Void
1422  **/
1423 #ifdef ANSI
1424 PRIVATE Void rgSCHDbmInitPndngRgrCfgLst
1425 (
1426 RgSchCellCb       *cellCb
1427 )
1428 #else
1429 PRIVATE Void rgSCHDbmInitPndngRgrCfgLst(cellCb)
1430 RgSchCellCb       *cellCb;
1431 #endif
1432 {
1433    TRC2(rgSCHDbmInitPndngRgrCfgLst)
1434
1435    cmLListInit(&cellCb->rgCfgInfo.pndngRgrCfgLst);
1436    RETVOID;
1437 }  /* rgSCHDbmInitPndngRgrCfgLst */
1438
1439 /**
1440  * @brief Handler for inserting the cfgElem in to the crntRgrCfgLst.
1441  *
1442  * @details
1443  *
1444  *     Function : rgSCHDbmInsCrntRgrCfgElem
1445  *
1446  *
1447  *  @param[in] *cellCb
1448  *  @param[in] *cfgElem
1449  *  @return  Void
1450  **/
1451 #ifdef ANSI
1452 PUBLIC Void rgSCHDbmInsCrntRgrCfgElem
1453 (
1454 RgSchCellCb       *cellCb,
1455 RgSchCfgElem      *cfgElem
1456 )
1457 #else
1458 PUBLIC Void rgSCHDbmInsCrntRgrCfgElem(cellCb, cfgElem)
1459 RgSchCellCb       *cellCb;
1460 RgSchCfgElem      *cfgElem;
1461 #endif
1462 {
1463    TRC2(rgSCHDbmInsCrntRgrCfgElem)
1464
1465    cfgElem->cfgReqLstEnt.next = NULLP;
1466    cfgElem->cfgReqLstEnt.prev = NULLP;
1467    cmLListAdd2Tail(&cellCb->rgCfgInfo.crntRgrCfgLst, &cfgElem->cfgReqLstEnt);
1468    RETVOID;
1469 }  /* rgSCHDbmInsCrntRgrCfgElem */
1470
1471 /**
1472  * @brief Handler for inserting the cfgElem in to the pndngRgrCfgLst.
1473  *
1474  * @details
1475  *
1476  *     Function : rgSCHDbmInsPndngRgrCfgElem
1477  *
1478  *
1479  *  @param[in] *cellCb
1480  *  @param[in] *cfgElem
1481  *  @return  Void
1482  **/
1483 #ifdef ANSI
1484 PUBLIC Void rgSCHDbmInsPndngRgrCfgElem
1485 (
1486 RgSchCellCb       *cellCb,
1487 RgSchCfgElem      *cfgElem
1488 )
1489 #else
1490 PUBLIC Void rgSCHDbmInsPndngRgrCfgElem(cellCb, cfgElem)
1491 RgSchCellCb       *cellCb;
1492 RgSchCfgElem      *cfgElem;
1493 #endif
1494 {
1495    TRC2(rgSCHDbmInsPndngRgrCfgElem)
1496
1497    cfgElem->cfgReqLstEnt.next = NULLP;
1498    cfgElem->cfgReqLstEnt.prev = NULLP;
1499    cfgElem->cfgReqLstEnt.node = (PTR)cfgElem;
1500    cmLListAdd2Tail(&cellCb->rgCfgInfo.pndngRgrCfgLst, &cfgElem->cfgReqLstEnt);
1501    RETVOID;
1502 }  /* rgSCHDbmInsPndngRgrCfgElem */
1503
1504 /**
1505  * @brief Handler for accessing the existing cfgElem in the crntRgrCfgLst.
1506  *
1507  * @details
1508  *
1509  *     Function : rgSCHDbmGetNextCrntRgrCfgElem
1510  *
1511  *
1512  *  @param[in]  *cellCb
1513  *  @param[in]  *cfgElem
1514  *  @return  RgSchCfgElem*
1515  **/
1516 #ifdef ANSI
1517 PUBLIC RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem
1518 (
1519 RgSchCellCb       *cellCb,
1520 RgSchCfgElem      *cfgElem
1521 )
1522 #else
1523 PUBLIC RgSchCfgElem* rgSCHDbmGetNextCrntRgrCfgElem(cellCb, cfgElem)
1524 RgSchCellCb       *cellCb;
1525 RgSchCfgElem      *cfgElem;
1526 #endif
1527 {
1528    TRC2(rgSCHDbmGetNextCrntRgrCfgElem)
1529
1530    if(!cfgElem)
1531    {
1532       RETVALUE( cellCb->rgCfgInfo.crntRgrCfgLst.first ?
1533                (RgSchCfgElem *)(cellCb->rgCfgInfo.crntRgrCfgLst.first->node) : NULLP );
1534    }
1535    RETVALUE( cfgElem->cfgReqLstEnt.next ?
1536                (RgSchCfgElem *)(cfgElem->cfgReqLstEnt.next->node) : NULLP );
1537 }  /* rgSCHDbmGetNextCrntRgrCfgElem */
1538
1539 /**
1540  * @brief Handler for accessing the existing cfgElem in the pndngRgrCfgLst.
1541  *
1542  * @details
1543  *
1544  *     Function : rgSCHDbmGetNextPndngRgrCfgElem
1545  *
1546  *
1547  *  @param[in]  *cellCb
1548  *  @param[in]  *cfgElem
1549  *  @return  RgSchCfgElem*
1550  **/
1551 #ifdef ANSI
1552 PUBLIC RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem
1553 (
1554 RgSchCellCb       *cellCb,
1555 RgSchCfgElem      *cfgElem
1556 )
1557 #else
1558 PUBLIC RgSchCfgElem* rgSCHDbmGetNextPndngRgrCfgElem(cellCb, cfgElem)
1559 RgSchCellCb       *cellCb;
1560 RgSchCfgElem      *cfgElem;
1561 #endif
1562 {
1563    TRC2(rgSCHDbmGetNextPndngRgrCfgElem)
1564
1565    if(!cfgElem)
1566    {
1567       RETVALUE( cellCb->rgCfgInfo.pndngRgrCfgLst.first ?
1568                (RgSchCfgElem *)(cellCb->rgCfgInfo.pndngRgrCfgLst.first->node) : NULLP );
1569    }
1570    RETVALUE( cfgElem->cfgReqLstEnt.next ?
1571                (RgSchCfgElem *)(cfgElem->cfgReqLstEnt.next->node) : NULLP );
1572 }  /* rgSCHDbmGetNextPndngRgrCfgElem */
1573
1574 /**
1575  * @brief Handler for extracting the existing cfgElem from the pndngRgrCfgLst.
1576  *
1577  * @details
1578  *
1579  *     Function : rgSCHDbmGetPndngRgrCfgElemByKey
1580  *
1581  *
1582  *  @param[in]  *cellCb
1583  *  @param[in]  key
1584  *  @return  RgSchCfgElem*
1585  **/
1586 #ifdef ANSI
1587 PUBLIC RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey
1588 (
1589 RgSchCellCb          *cellCb,
1590 CmLteTimingInfo   key
1591 )
1592 #else
1593 PUBLIC RgSchCfgElem* rgSCHDbmGetPndngRgrCfgElemByKey(cellCb, key)
1594 RgSchCellCb          *cellCb;
1595 CmLteTimingInfo   key;
1596 #endif
1597 {
1598    CmLList  *tmpNode;
1599
1600    TRC2(rgSCHDbmGetPndngRgrCfgElemByKey)
1601
1602    CM_LLIST_FIRST_NODE(&cellCb->rgCfgInfo.pndngRgrCfgLst,tmpNode);
1603    while(tmpNode)
1604    {
1605       if((((RgSchCfgElem *)tmpNode->node)->actvTime.sfn == key.sfn) &&
1606             (((RgSchCfgElem *)tmpNode->node)->actvTime.slot == key.slot))
1607       {
1608          RETVALUE((RgSchCfgElem *)(tmpNode->node));
1609       }
1610       CM_LLIST_NEXT_NODE(&cellCb->rgCfgInfo.pndngRgrCfgLst,tmpNode);
1611    }
1612    RETVALUE(NULLP);
1613 }  /* rgSCHDbmGetPndngRgrCfgElemByKey */
1614
1615 /**
1616  * @brief Handler for deleting the existing cfgElem from the crntRgrCfgLst.
1617  *
1618  * @details
1619  *
1620  *     Function : rgSCHDbmDelCrntRgrCfgElem
1621  *
1622  *
1623  *  @param[in]  *cellCb
1624  *  @param[in]  *cfgElem
1625  *  @return  RgSchCfgElem*
1626  **/
1627 #ifdef ANSI
1628 PUBLIC RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem
1629 (
1630 RgSchCellCb       *cellCb,
1631 RgSchCfgElem      *cfgElem
1632 )
1633 #else
1634 PUBLIC RgSchCfgElem* rgSCHDbmDelCrntRgrCfgElem(cellCb, cfgElem)
1635 RgSchCellCb       *cellCb;
1636 RgSchCfgElem      *cfgElem;
1637 #endif
1638 {
1639    TRC2(rgSCHDbmDelCrntRgrCfgElem)
1640
1641    if(cmLListDelFrm(&cellCb->rgCfgInfo.crntRgrCfgLst,&cfgElem->cfgReqLstEnt))
1642    {
1643       RETVALUE((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
1644    }
1645    RETVALUE(NULLP);
1646 }  /* rgSCHDbmDelCrntRgrCfgElem */
1647
1648 /**
1649  * @brief Handler for deleting the existing cfgElem from the pndngRgrCfgLst.
1650  *
1651  * @details
1652  *
1653  *     Function : rgSCHDbmDelPndngRgrCfgElem
1654  *
1655  *
1656  *  @param[in]  *cellCb
1657  *  @param[in]  *cfgElem
1658  *  @return  RgSchCfgElem*
1659  **/
1660 #ifdef ANSI
1661 PUBLIC RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem
1662 (
1663 RgSchCellCb       *cellCb,
1664 RgSchCfgElem      *cfgElem
1665 )
1666 #else
1667 PUBLIC RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem(cellCb, cfgElem)
1668 RgSchCellCb       *cellCb;
1669 RgSchCfgElem      *cfgElem;
1670 #endif
1671 {
1672    TRC2(rgSCHDbmDelPndngRgrCfgElem)
1673
1674    if(cmLListDelFrm(&cellCb->rgCfgInfo.pndngRgrCfgLst,&cfgElem->cfgReqLstEnt))
1675    {
1676       RETVALUE((RgSchCfgElem *)(cfgElem->cfgReqLstEnt.node));
1677    }
1678    RETVALUE(NULLP);
1679 }  /* rgSCHDbmDelPndngRgrCfgElem */
1680
1681 /**
1682  * @brief Handler for initializing the rntiDb.
1683  *
1684  * @details
1685  *
1686  *     Function : rgSCHDbmRntiDbInit
1687  *
1688  *
1689  *  @param[in]  *cellCb
1690  *  @param[in]  rntiStart
1691  *  @param[in]  maxRntis
1692  *  @return  S16
1693  *      -# ROK
1694  *      -# RFAILED
1695  **/
1696 #ifdef ANSI
1697 PUBLIC S16 rgSCHDbmRntiDbInit
1698 (
1699 RgSchCellCb       *cellCb,
1700 U16            rntiStart,
1701 U16            maxRntis
1702 )
1703 #else
1704 PUBLIC S16 rgSCHDbmRntiDbInit(cellCb, rntiStart, maxRntis)
1705 RgSchCellCb       *cellCb;
1706 U16            rntiStart;
1707 U16            maxRntis;
1708 #endif
1709 {
1710    U16 rnti;
1711    RgSchRntiLnk   *rntiPool;
1712
1713    TRC2(rgSCHDbmRntiDbInit)
1714
1715       /* Fix for Change Request ccpu00099150 */
1716    if(rgSCHUtlAllocSBuf(cellCb->instIdx,
1717        (Data **)&cellCb->rntiDb.rntiPool,maxRntis*sizeof(RgSchRntiLnk)) != ROK)
1718    {
1719       RETVALUE(RFAILED);
1720    }
1721    cellCb->rntiDb.rntiStart = rntiStart;
1722    cellCb->rntiDb.maxRntis = maxRntis;
1723
1724    cellCb->rntiDb.count = maxRntis;
1725
1726    rnti = rntiStart;
1727    rntiPool = cellCb->rntiDb.rntiPool;
1728    if (maxRntis == 1)
1729    {
1730       rntiPool[0].rnti = rnti;
1731       rntiPool[0].prv = NULLP;
1732       rntiPool[0].nxt = NULLP;
1733       cellCb->rntiDb.lastRnti = &rntiPool[0];
1734    }
1735    else
1736    {
1737       U16 idx;
1738       rntiPool[0].rnti = rnti++;
1739       rntiPool[0].prv = NULLP;
1740       rntiPool[0].nxt = &rntiPool[1];
1741       for (idx = 1; idx < maxRntis - 1; ++idx)
1742       {
1743          rntiPool[idx].rnti = rnti++;
1744          rntiPool[idx].prv = &rntiPool[idx-1];
1745          rntiPool[idx].nxt = &rntiPool[idx+1];
1746       }
1747       rntiPool[idx].rnti = rnti++;
1748       rntiPool[idx].prv = &rntiPool[idx-1];
1749       rntiPool[idx].nxt = NULLP;
1750       cellCb->rntiDb.lastRnti = &rntiPool[idx];
1751    }
1752    cellCb->rntiDb.freeRnti = &rntiPool[0];
1753    RETVALUE(ROK);
1754 } /* rgSCHDbmRntiDbInit */
1755
1756 /**
1757  * @brief Handler for de-initializing the rntiDb.
1758  *
1759  * @details
1760  *
1761  *     Function : rgSCHDbmRntiDbDeInit
1762  *
1763  *
1764  *  @param[in]  *cellCb
1765  *  @return  Void
1766  **/
1767 #ifdef ANSI
1768 PUBLIC Void rgSCHDbmRntiDbDeInit
1769 (
1770 RgSchCellCb       *cellCb
1771 )
1772 #else
1773 PUBLIC Void rgSCHDbmRntiDbDeInit(cellCb)
1774 RgSchCellCb       *cellCb;
1775 #endif
1776 {
1777    TRC2(rgSCHDbmRntiDbDeInit)
1778
1779    /* ccpu00117052 - MOD - Passing double pointer
1780    for proper NULLP assignment*/
1781    rgSCHUtlFreeSBuf(cellCb->instIdx, (Data **)(&(cellCb->rntiDb.rntiPool)),
1782                  cellCb->rntiDb.maxRntis*sizeof(RgSchRntiLnk));
1783    cellCb->rntiDb.maxRntis = 0;
1784    cellCb->rntiDb.freeRnti = NULLP;
1785    cellCb->rntiDb.lastRnti = NULLP;
1786    cmLListInit(&cellCb->rntiDb.rntiGuardPool);
1787
1788    /* Stack Crash problems for TRACE5 Changes. Added the return below */
1789    RETVOID;
1790
1791 } /* rgSCHDbmRntiDbDeInit */
1792
1793 /**
1794  * @brief Handler for accessing the free RNTI.
1795  *
1796  * @details
1797  *
1798  *     Function : rgSCHDbmGetRnti
1799  *
1800  *
1801  *  @param[in]  *cellCb
1802  *  @return  RgSchRntiLnk*
1803  **/
1804 #ifdef ANSI
1805 PUBLIC RgSchRntiLnk* rgSCHDbmGetRnti
1806 (
1807 RgSchCellCb       *cellCb
1808 )
1809 #else
1810 PUBLIC RgSchRntiLnk* rgSCHDbmGetRnti(cellCb)
1811 RgSchCellCb       *cellCb;
1812 #endif
1813 {
1814    RgSchRntiLnk *rntiLnk;
1815
1816    TRC2(rgSCHDbmGetRnti)
1817
1818    if (!(cellCb->rntiDb.freeRnti))
1819    {
1820       RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI exhausted count:%d",
1821                 cellCb->rntiDb.count);
1822       RETVALUE(NULLP);
1823    }
1824
1825    rntiLnk = cellCb->rntiDb.freeRnti;
1826    cellCb->rntiDb.freeRnti = rntiLnk->nxt;
1827
1828    /* setting prv and nxt to NULLP may not be needed */
1829    rntiLnk->prv = NULLP;
1830    rntiLnk->nxt = NULLP;
1831
1832    if (cellCb->rntiDb.freeRnti != NULLP)
1833    {
1834       cellCb->rntiDb.freeRnti->prv = NULLP;
1835    }
1836    else
1837    {
1838       cellCb->rntiDb.lastRnti = NULLP;
1839    }
1840
1841    cellCb->rntiDb.count--;
1842
1843    printf("rgSCHDbmGetRnti::rntiLnk->rnti %u\n",rntiLnk->rnti);
1844    RETVALUE(rntiLnk);
1845 } /* rgSCHDbmGetRnti */
1846
1847 /**
1848  * @brief Handler for releasing the RNTI.
1849  *
1850  * @details
1851  *
1852  *     Function : rgSCHDbmRlsRnti
1853  *
1854  *
1855  *  @param[in]  *cellCb
1856  *  @param[in]  rntiLnk
1857  *  @return  Void
1858  **/
1859 #ifdef ANSI
1860 PUBLIC Void rgSCHDbmRlsRnti
1861 (
1862 RgSchCellCb       *cellCb,
1863 RgSchRntiLnk      *rntiLnk
1864 )
1865 #else
1866 PUBLIC Void rgSCHDbmRlsRnti(cellCb, rntiLnk)
1867 RgSchCellCb       *cellCb;
1868 RgSchRntiLnk      *rntiLnk;
1869 #endif
1870 {
1871    TRC2(rgSCHDbmRlsRnti)
1872 #ifdef EMTC_ENABLE
1873       if(ROK==rgSCHDbmPutEmtcRnti(cellCb,rntiLnk))
1874 {
1875 RETVOID;
1876 }
1877 #endif
1878    rntiLnk->nxt = NULLP;
1879    if (cellCb->rntiDb.lastRnti)
1880    {
1881       cellCb->rntiDb.lastRnti->nxt = rntiLnk;
1882       rntiLnk->prv = cellCb->rntiDb.lastRnti;
1883    }
1884    else
1885    {
1886       rntiLnk->prv = NULLP;
1887       cellCb->rntiDb.freeRnti = rntiLnk;
1888    }
1889    cellCb->rntiDb.lastRnti = rntiLnk;
1890
1891    cellCb->rntiDb.count++;
1892
1893    /* Stack Crash problems for TRACE5 Changes. Added the return below */
1894    RETVOID;
1895
1896 } /* rgSCHDbmRlsRnti */
1897
1898 #ifdef LTE_TDD
1899 /**
1900  * @brief Handler for initializing the ueTfuPendLst under the cellCb.
1901  *
1902  * @details
1903  *
1904  *     Function : rgSCHDbmInitUeTfuPendLst
1905  *
1906  *
1907  *  @param[in] *cellCb
1908  *  @param[in] numBins
1909  *  @return  S16
1910  *      -# ROK
1911  *      -# RFAILED
1912  **/
1913 #ifdef ANSI
1914 PRIVATE S16 rgSCHDbmInitUeTfuPendLst
1915 (
1916 RgSchCellCb    *cellCb,
1917 U16            numBins
1918 )
1919 #else
1920 PRIVATE S16 rgSCHDbmInitUeTfuPendLst(cellCb, numBins)
1921 RgSchCellCb    *cellCb;
1922 U16            numBins;
1923 #endif
1924 {
1925    RgSchUePucchRecpInfo pucchInfo;
1926    TRC2(rgSCHDbmInitUeTfuPendLst)
1927
1928    /* Fix: syed It is better to compute offset dynamically
1929     * rather than hardcoding it as 0 */
1930    if(cmHashListInit(&cellCb->ueTfuPendLst, numBins, (U16)((PTR)&(pucchInfo.hashLstEnt) - (PTR)&pucchInfo), FALSE,
1931                CM_HASH_KEYTYPE_CONID,
1932                rgSchCb[cellCb->instIdx].rgSchInit.region,
1933                rgSchCb[cellCb->instIdx].rgSchInit.pool) != ROK)
1934    {
1935       RETVALUE(RFAILED);
1936    }
1937
1938    RETVALUE(ROK);
1939
1940 }  /* rgSCHDbmInitUeTfuPendLst */
1941
1942 /**
1943  * @brief Handler for de-initializing the ueTfuPendLst under the cellCb.
1944  *
1945  * @details
1946  *
1947  *     Function : rgSCHDbmDeInitUeTfuPendLst
1948  *
1949  *
1950  *  @param[in] *cellCb
1951  *  @return  S16
1952  *      -# ROK
1953  *      -# RFAILED
1954  **/
1955 #ifdef ANSI
1956 PUBLIC S16 rgSCHDbmDeInitUeTfuPendLst
1957 (
1958 RgSchCellCb       *cellCb
1959 )
1960 #else
1961 PUBLIC S16 rgSCHDbmDeInitUeTfuPendLst(cellCb)
1962 RgSchCellCb       *cellCb;
1963 #endif
1964 {
1965    TRC2(rgSCHDbmDeInitUeTfuPendLst)
1966
1967    cmHashListDeinit(&cellCb->ueTfuPendLst);
1968
1969    RETVALUE(ROK);
1970 }  /* rgSCHDbmDeInitUeTfuPendLst */
1971 #endif
1972
1973 /**********************************************************************
1974
1975          End of file
1976 **********************************************************************/