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