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