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