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