src/5gnrsch/rg_sch_dbm.c

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