src/5gnrsch/rg_sch_gom.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_gom.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_sch_gom.c
  32 @brief This module does processing related to handling of upper interface APIs
  33 invoked by RRM towards MAC.
  34 */
  35
  36 static const char* RLOG_MODULE_NAME="MAC";
  37 static int RLOG_MODULE_ID=4096;
  38 static int RLOG_FILE_ID=164;
  39
  40 /* header include files -- defines (.h) */
  41 #include "common_def.h"
  42 #include "lrg.h"
  43 #include "rgr.h"
  44 #include "tfu.h"
  45 #include "rg_env.h"
  46 #include "rg_sch_inf.h"
  47 #include "rg_sch.h"
  48 #include "rg_sch_err.h"
  49 #include "rl_interface.h"
  50 #include "rl_common.h"
  51
  52 /* header/extern include files (.x) */
  53 #include "lrg.x"
  54 #include "rgr.x"
  55 #include "tfu.x"
  56 #include "rg_sch_inf.x"
  57 #include "rg_sch.x"
  58
  59 /* local defines */
  60 PRIVATE S16 rgSCHGomHndlCfgReq ARGS((RgSchCb *instCb, SpId spId,
  61          RgrCfg  *cfg, RgSchErrInfo *errInfo));
  62 PRIVATE S16 rgSCHGomHndlRecfgReq ARGS((RgSchCb *instCb, SpId spId,
  63          RgrRecfg  *recfg, RgSchErrInfo *errInfo));
  64 PRIVATE S16 rgSCHGomHndlResetReq ARGS((RgSchCb *instCb,SpId spId,RgrRst *reset,
  65          RgSchErrInfo  *errInfo));
  66 PRIVATE S16 rgSCHGomGetCellIdFrmCfgReq ARGS((RgrCfgReqInfo *rgrCfgReq,
  67          CmLteCellId *cellId));
  68 PRIVATE S16 rgSCHGomCfgReq ARGS((Region reg, Pool pool, RgSchCb *instCb,
  69          RgrCfgTransId transId, RgrCfgReqInfo *cfgReqInfo));
  70 PRIVATE S16 rgSCHGomEnqCfgReq ARGS((Region reg, Pool pool, RgSchCellCb *cell,
  71          RgrCfgTransId transId, RgrCfgReqInfo *rgrCfgReq));
  72 PRIVATE S16 rgSCHGomHndlDelReq ARGS((RgSchCb  *instCb,SpId spId,
  73          RgrDel  *del,RgSchErrInfo  *errInfo));
  74 #ifdef LTE_ADV
  75 PRIVATE S16 rgSCHGomHndlSCellActDeactReq ARGS((RgSchCb *instCb, SpId spId,
  76          RgrSCellActDeactEvnt  *sCellActDeactEvnt, RgSchErrInfo *errInfo, U8 action));
  77 #endif /* LTE_ADV */
  78 #ifdef EMTC_ENABLE
  79 EXTERN S16 rgSchEmtcGetSiWinPerd ARGS((
  80 RgSchCellCb   *cell,
  81 U16  *siWinSize,
  82 U16  *minPeriod
  83 ));
  84 extern S16 rgSCHEmtcUtlCalMcsAndNPrb
  85 (
  86  RgSchCellCb         *cell,
  87  U8                  cfgType,
  88  MsgLen              msgLen,
  89  U8                  siId
  90  );
  91
  92 EXTERN S32 rgSCHEmtcUtlGetAllwdCchTbSzForSI ARGS(
  93 (
  94 U32 bo
  95 ));
  96
  97 EXTERN Void rgSCHEmtcWarningSiCfg ARGS(
  98 (
  99 RgSchCellCb             *cell,
 100 RgrWarningSiCfgReqInfo  *warningSiCfgReqInfo,
 101 U16                     idx
 102 ));
 103 #endif
 104
 105
 106 /* local typedefs */
 107
 108 /* local externs */
 109
 110 /* forward references */
 111
 112 \f
 113
 114 /**
 115  * @brief Handler for config request from RRM to Schedular.
 116  *
 117  * @details
 118  *
 119  *     Function: rgSCHGomHndlCfg
 120  *
 121  *     This API is called from schedulers UIM and it handles config request
 122  *     from RRM to Scheduler.
 123  *
 124  *     Processing Steps:
 125  *      - If the request is for the inactive cell,
 126  *       - Handle request.Call rgSCHGomCfgReq.
 127  *      - Else,
 128  *       - Enqueue the request. Call rgSCHGomEnqCfgReq.
 129  *
 130  *  @param[in]  Pst           *pst
 131  *  @param[in]  RgSchCb       *instCb
 132  *  @param[in]  RgrCfgTransId transId
 133  *  @param[in]  RgrCfgReqInfo *cfgReqInfo
 134  *  @return  S16
 135  *      -# ROK
 136  *      -# RFAILED
 137  **/
 138 #ifdef ANSI
 139 S16 rgSCHGomHndlCfg
 140 (
 141 Pst           *pst,
 142 RgSchCb       *instCb,
 143 RgrCfgTransId transId,
 144 RgrCfgReqInfo *cfgReqInfo
 145 )
 146 #else
 147 S16 rgSCHGomHndlCfg(pst, instCb, transId, cfgReqInfo)
 148 Pst           *pst;
 149 RgSchCb       *instCb;
 150 RgrCfgTransId transId;
 151 RgrCfgReqInfo *cfgReqInfo;
 152 #endif
 153 {
 154    S16           ret;
 155    SpId          spId = 0;
 156    CmLteCellId   cellId;
 157    RgSchCellCb   *cell = NULLP;
 158    U8            cfmStatus = RGR_CFG_CFM_NOK;
 159 #ifdef DEBUGP
 160    Inst          inst = (instCb->rgSchInit.inst );
 161 #endif
 162
 163    /* Apply the configuration for Cell Configuration or Delete */
 164    if (cfgReqInfo->action != RGR_RECONFIG)
 165    {
 166       ret = rgSCHGomCfgReq (pst->region, pst->pool, instCb,
 167             transId, cfgReqInfo);
 168       return (ret);
 169    }
 170
 171    /* Fetch the cell Id for the recieved request */
 172    if((rgSCHGomGetCellIdFrmCfgReq(cfgReqInfo, &cellId)) != ROK)
 173    {
 174       RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Action.Config Type Error");
 175
 176       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
 177             (Size)sizeof(*cfgReqInfo));
 178       cfgReqInfo = NULLP;
 179       schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
 180       return RFAILED;
 181    }
 182    /* Extract the cell and Enquee Config Request */
 183    if(NULLP != instCb->rgrSap[spId].cell)
 184    {
 185       if(cellId != instCb->rgrSap[spId].cell->cellId)
 186       {
 187          RLOG_ARG2(L_ERROR,DBG_CELLID,cellId, "Cell with Id %d already exists "
 188            "on sap %d", instCb->rgrSap[spId].cell->cellId, spId);
 189
 190          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
 191                (Size)sizeof(*cfgReqInfo));
 192          cfgReqInfo = NULLP;
 193          schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
 194          return RFAILED;
 195       }
 196       cell = instCb->rgrSap[spId].cell;
 197
 198       /* Enqueue the configuration */
 199       ret = rgSCHGomEnqCfgReq(pst->region, pst->pool, cell, transId, cfgReqInfo);
 200       if (ret != ROK)
 201       {
 202          RLOG_ARG0(L_ERROR,DBG_CELLID,cellId, "rgSCHGomHndlCfg: Enqueuing CfgReq "
 203               "Failed ");
 204
 205          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
 206                (Size)sizeof(*cfgReqInfo));
 207          cfgReqInfo = NULLP;
 208          schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
 209          return RFAILED;
 210       }
 211
 212       return ROK;
 213    }
 214    SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
 215          (Size)sizeof(*cfgReqInfo));
 216    cfgReqInfo = NULLP;
 217    schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
 218    return RFAILED;
 219
 220 }/* rgSCHGomHndlCfg */
 221
 222
 223 /**
 224  * @brief Handler to handle config request from RRM to Scheduler.
 225  *
 226  * @details
 227  *
 228  *     Function: rgSCHGomCfgReq
 229  *
 230  *     This API handles processing for config request from RRM to Scheduler.
 231  *
 232  *     Processing Steps:
 233  *      - If Configuration request, call rgSCHGomHndlCfgReq.
 234  *      - Else if Reconfiguration request, call rgSCHGomHndlRecfgReq.
 235  *      - If successful, send configuration confirm to RRM.
 236  *        Call schSendCfgCfm else FAIL.
 237  *
 238  *  @param[in]  Region        reg
 239  *  @param[in]  Pool          pool
 240  *  @param[in]  RgSchCb       *instCb
 241  *  @param[in]  RgrCfgTransId transId
 242  *  @param[in]  RgrCfgReqInfo *cfgReqInfo
 243  *  @return  S16
 244  *      -# ROK
 245  *      -# RFAILED
 246  **/
 247 #ifdef ANSI
 248 PRIVATE S16 rgSCHGomCfgReq
 249 (
 250 Region        reg,
 251 Pool          pool,
 252 RgSchCb       *instCb,
 253 RgrCfgTransId transId,
 254 RgrCfgReqInfo *cfgReqInfo
 255 )
 256 #else
 257 PRIVATE S16 rgSCHGomCfgReq(reg, pool, instCb, transId, cfgReqInfo)
 258 Region        reg;
 259 Pool          pool;
 260 RgSchCb       *instCb;
 261 RgrCfgTransId transId;
 262 RgrCfgReqInfo *cfgReqInfo;
 263 #endif
 264 {
 265    SpId          spId = 0;
 266    U8              cfmStatus = RGR_CFG_CFM_OK;
 267    S16             ret;
 268    RgSchErrInfo    errInfo;
 269 #ifdef DEBUGP
 270    Inst            inst = (instCb->rgSchInit.inst );
 271 #endif
 272 #ifdef EMTC_ENABLE
 273 printf("\n AT MAC rgSCHGomCfgReq \n");
 274 #endif
 275
 276    /* Process Config/Reconfig/Delete request from RRM */
 277    switch (cfgReqInfo->action)
 278    {
 279       case SCH_CONFIG:
 280          {
 281             ret = rgSCHGomHndlCfgReq(instCb, spId,
 282                              &cfgReqInfo->u.cfgInfo, &errInfo);
 283             break;
 284          }
 285       case RGR_RECONFIG:
 286          {
 287             ret = rgSCHGomHndlRecfgReq(instCb, spId,
 288                              &cfgReqInfo->u.recfgInfo, &errInfo);
 289             break;
 290          }
 291       case RGR_RESET:
 292          {
 293             ret = rgSCHGomHndlResetReq(instCb, spId,
 294                              &cfgReqInfo->u.rstInfo, &errInfo);
 295             break;
 296          }
 297       case RGR_DELETE:
 298          {
 299             ret = rgSCHGomHndlDelReq(instCb, spId,
 300                              &cfgReqInfo->u.delInfo, &errInfo);
 301             break;
 302          }
 303 #ifdef LTE_ADV
 304       case RGR_SCELL_ACT:
 305       case RGR_SCELL_DEACT:
 306       case RGR_SCELL_READY:
 307          {
 308             ret = rgSCHGomHndlSCellActDeactReq(instCb, spId,
 309                              &cfgReqInfo->u.sCellActDeactEvnt, &errInfo, cfgReqInfo->action);
 310             break;
 311          }
 312 #endif /* LTE_ADV */
 313       default:
 314          {
 315             RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "Invalid configuration "
 316                "action %d", cfgReqInfo->action);
 317             ret = RFAILED;
 318          }
 319    } /* End of switch */
 320
 321    if (ret != ROK)
 322    {
 323       cfmStatus = RGR_CFG_CFM_NOK;
 324    }
 325
 326    SPutSBuf(reg, pool, (Data *)cfgReqInfo,
 327          (Size)sizeof(*cfgReqInfo));
 328    cfgReqInfo = NULLP;
 329 #ifdef EMTC_ENABLE
 330 printf("\n AT MAC sending RGR cfg cfm \n");
 331 #endif
 332
 333    /* Send back confirmation status to RRM */
 334    schSendCfgCfm(reg, pool, transId, cfmStatus);
 335 #ifdef EMTC_ENABLE
 336 printf("\n AT MAC RGR cfg cfm sent\n");
 337 #endif
 338
 339    return (ret);
 340 }  /* rgSCHGomCfgReq */
 341
 342
 343 /**
 344  * @brief Handler to enqueuing config request from RRM to Scheduler.
 345  *
 346  * @details
 347  *
 348  *     Function: rgSCHGomEnqCfgReq
 349  *
 350  *     This API enqueues config request from RRM to MAC.
 351  *
 352  *     Processing Steps:
 353  *      - Allocate the configuration request element.
 354  *      - Copy the contents of the recieved configuration to config request
 355  *        element and free the recieved configuration pointer.
 356  *      - If the configuration is without activation time,
 357  *         - Enqueue the request in crntRgrCfgLst of the cell at the end of
 358  *           the list.
 359  *      - Else
 360  *         - Enqueue the request in pndngRgrCfgLst of the cell.
 361  *
 362  *  @param[in]  Region        reg,
 363  *  @param[in]  Pool          pool
 364  *  @param[in]  RgSchCellCb   *cell
 365  *  @param[in]  RgrCfgTransId transId
 366  *  @param[in]  RgrCfgReqInfo *rgrCfgReq
 367  *  @return  S16
 368  *      -# ROK
 369  *      -# RFAILED
 370  **/
 371 #ifdef ANSI
 372 PRIVATE S16 rgSCHGomEnqCfgReq
 373 (
 374 Region        reg,
 375 Pool          pool,
 376 RgSchCellCb   *cell,
 377 RgrCfgTransId transId,
 378 RgrCfgReqInfo *rgrCfgReq
 379 )
 380 #else
 381 PRIVATE S16 rgSCHGomEnqCfgReq(reg, pool, cell, transId, rgrCfgReq)
 382 Region        reg;
 383 Pool          pool;
 384 RgSchCellCb   *cell;
 385 RgrCfgTransId transId;
 386 RgrCfgReqInfo *rgrCfgReq;
 387 #endif
 388 {
 389    S16                ret;
 390    U32                sfDiff;
 391    RgSchCfgElem       *rgrCfgElem  = NULLP;
 392    CmLteTimingInfo    actvTime;
 393    Inst               inst = cell->instIdx;
 394
 395    /* Allocate memory for config Element */
 396    ret = rgSCHUtlAllocSBuf(inst, (Data **)&rgrCfgElem, sizeof(RgSchCfgElem));
 397    if ((ret != ROK) || ((U8 *)rgrCfgElem == NULLP))
 398    {
 399       return RFAILED;
 400    }
 401
 402    /* Initialize the configuration element */
 403    memcpy(rgrCfgElem->rgrCfg.transId.trans,transId.trans,
 404          sizeof(transId.trans));
 405    rgrCfgElem->rgrCfg.reg = reg;
 406    rgrCfgElem->rgrCfg.pool = pool;
 407    rgrCfgElem->rgrCfg.rgrCfgReq = rgrCfgReq;
 408    rgrCfgElem->cfgReqLstEnt.prev = NULLP;
 409    rgrCfgElem->cfgReqLstEnt.next = NULLP;
 410    rgrCfgElem->cfgReqLstEnt.node = (PTR )rgrCfgElem;
 411
 412    /* Add configuration element to current/pending cfgLst */
 413    if (((rgrCfgReq->action == RGR_RECONFIG) &&
 414             (rgrCfgReq->u.recfgInfo.recfgType == RGR_CELL_CFG) &&
 415             (rgrCfgReq->u.recfgInfo.u.cellRecfg.recfgActvTime.pres == TRUE)))
 416
 417    {
 418       actvTime =
 419          rgrCfgReq->u.recfgInfo.u.cellRecfg.recfgActvTime.actvTime;
 420
 421       /* Check if the activation time is valid */
 422       if (actvTime.sfn >= RGSCH_MAX_SFN
 423             || actvTime.slot >= RGSCH_NUM_SUB_FRAMES_5G)
 424       {
 425          RLOG_ARG4(L_ERROR,DBG_CELLID,cell->cellId, "Invalid activation time for RGR "
 426            "config request: activation sfn %d activation slot %d current "
 427            "sfn %d current slot %d", actvTime.sfn, actvTime.slot,
 428            cell->crntTime.sfn, cell->crntTime.slot);
 429          /* ccpu00117052 - MOD - Passing double pointer
 430          for proper NULLP assignment*/
 431          rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
 432          return RFAILED;
 433       }
 434
 435       sfDiff = RGSCH_CALC_SF_DIFF(actvTime, cell->crntTime);
 436
 437       if (sfDiff > (RGR_ACTV_WIN_SIZE * RGSCH_NUM_SUB_FRAMES_5G))
 438       {
 439          RLOG_ARG4(L_ERROR,DBG_CELLID,cell->cellId,"Invalid activation time for RGR"
 440               " config request: activation sfn %d activation slot %d "
 441               "current sfn %d current slot %d", actvTime.sfn,
 442               actvTime.slot, cell->crntTime.sfn, cell->crntTime.slot);
 443          /* ccpu00117052 - MOD - Passing double pointer
 444          for proper NULLP assignment*/
 445          rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
 446          return RFAILED;
 447       }
 448
 449       if (sfDiff)
 450       {
 451          /* Add to pending cfgReqLst */
 452          rgrCfgElem->actvTime = actvTime;
 453          rgSCHDbmInsPndngRgrCfgElem(cell, rgrCfgElem);
 454          /* Cfm to be sent only after applying request */
 455          return ROK;
 456       }
 457    }
 458
 459    /* Add to current cfgReq list */
 460    rgSCHDbmInsCrntRgrCfgElem(cell, rgrCfgElem);
 461    /* Cfm to be sent only after applying request */
 462    return ROK;
 463 }  /* rgSCHGomEnqCfgReq */
 464
 465
 466 /**
 467  * @brief Handler for TTI processing for configurations recieved from RRM.
 468  *
 469  * @details
 470  *
 471  *     Function: rgSCHGomTtiHndlr
 472  *
 473  *     This API does TTI processing for configurations recieved from RRM.
 474  *
 475  *     Processing Steps:
 476  *      - It dequeues config request from the current configuration list.
 477  *        For each config request in the list:
 478  *        - Processes the request. Call rgSCHGomCfgReq.
 479  *      - It dequeues config request for the current tti from the pending
 480  *        configuration list. For each config request in the list:
 481  *        - Processes the request. Call rgSCHGomCfgReq.
 482  *
 483  *  @param[in]  RgSchCellCb *cell
 484  *  @return  S16
 485  *      -# ROK
 486  *      -# RFAILED
 487  **/
 488 #ifdef ANSI
 489 S16 rgSCHGomTtiHndlr
 490 (
 491 RgSchCellCb      *cell,
 492 SpId             spId
 493 )
 494 #else
 495 S16 rgSCHGomTtiHndlr(cell, spId)
 496 RgSchCellCb      *cell;
 497 SpId             spId;
 498 #endif
 499 {
 500    RgSchCfgElem       *cfgElem;
 501    Inst               inst= cell->instIdx;
 502
 503    /* Dequeue from current config list */
 504    while ((cfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
 505    {
 506       rgSCHDbmDelCrntRgrCfgElem(cell, cfgElem);
 507       rgSCHGomCfgReq(cfgElem->rgrCfg.reg,cfgElem->rgrCfg.pool,
 508             &rgSchCb[inst], cfgElem->rgrCfg.transId,
 509             cfgElem->rgrCfg.rgrCfgReq);
 510       /* ccpu00117052 - MOD - Passing double pointer
 511       for proper NULLP assignment*/
 512       rgSCHUtlFreeSBuf(inst, (Data **)&cfgElem, sizeof(*cfgElem));
 513    }
 514
 515    /* Handle config requests from pending config list */
 516    while((cfgElem = rgSCHDbmGetPndngRgrCfgElemByKey(cell, cell->crntTime)) != NULLP)
 517    {
 518       rgSCHDbmDelPndngRgrCfgElem(cell, cfgElem);
 519       rgSCHGomCfgReq(cfgElem->rgrCfg.reg, cfgElem->rgrCfg.pool,
 520             &rgSchCb[inst], cfgElem->rgrCfg.transId,
 521             cfgElem->rgrCfg.rgrCfgReq);
 522       /* ccpu00117052 - MOD - Passing double pointer
 523       for proper NULLP assignment*/
 524       rgSCHUtlFreeSBuf(inst, (Data **)&cfgElem, sizeof(*cfgElem));
 525    }
 526
 527    return ROK;
 528 }
 529
 530
 531 /**
 532  * @brief Handler to handle configuration request from RRM to MAC.
 533  *
 534  * @details
 535  *
 536  *     Function: rgSCHGomHndlCfgReq
 537  *
 538  *     This API handles processing for configuration request from RRM to MAC.
 539  *
 540  *     - Processing Steps:
 541  *        - Validate configuration request parameters at CFG module.
 542  *          Call rgSCHCfgVldtRgrCellCfg for cell configuration.
 543  *        - If validated successfully, send configuration request to CFG.
 544  *          Call rgSCHCfgRgrCellCfg else FAIL.
 545  *
 546  *  @param[in]  RgSchCb      *instCb
 547  *  @param[in]  SpId         spId
 548  *  @param[in]  RgrCfg       *cfg
 549  *  @param[out] RgSchErrInfo *errInfo
 550  *  @return  S16
 551  *      -# ROK
 552  *      -# RFAILED
 553  **/
 554 #ifdef ANSI
 555 PRIVATE S16 rgSCHGomHndlCfgReq
 556 (
 557 RgSchCb        *instCb,
 558 SpId           spId,
 559 RgrCfg         *cfg,
 560 RgSchErrInfo   *errInfo
 561 )
 562 #else
 563 PRIVATE S16 rgSCHGomHndlCfgReq(instCb, spId, cfg, errInfo)
 564 RgSchCb        *instCb;
 565 SpId           spId;
 566 RgrCfg         *cfg;
 567 RgSchErrInfo   *errInfo;
 568 #endif
 569 {
 570    S16          ret;
 571    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
 572    Inst         inst = (instCb->rgSchInit.inst );
 573    RgSchUeCb    *ue;
 574
 575    errInfo->errType = RGSCHERR_GOM_CFG_REQ;
 576
 577    /* Validate and process the configuration request */
 578    switch (cfg->cfgType)
 579    {
 580       case RGR_CELL_CFG:
 581       {
 582          ret = rgSCHCfgVldtRgrCellCfg(inst, &cfg->u.cellCfg, cell, errInfo);
 583             if (ret != ROK)
 584             {
 585                RLOG1(L_ERROR,"Rgr Cell configuration "
 586                   "validation FAILED: Cell %d", cfg->u.cellCfg.cellId);
 587                return RFAILED;
 588             }
 589          ret = rgSCHCfgRgrCellCfg(instCb, spId, &cfg->u.cellCfg, errInfo);
 590          break;
 591       }
 592       case RGR_UE_CFG:
 593       case RGR_SCELL_UE_CFG:
 594       {
 595          ret = rgSCHCfgVldtRgrUeCfg(inst, &cfg->u.ueCfg, &cell, errInfo);
 596          if (ret != ROK)
 597          {
 598             RLOG1(L_ERROR,"Ue configuration validation"
 599                " FAILED: CRNTI:%d", cfg->u.ueCfg.crnti);
 600             return RFAILED;
 601          }
 602          ret = rgSCHCfgRgrUeCfg(cell, &cfg->u.ueCfg, errInfo);
 603          break;
 604       }
 605       case RGR_LCH_CFG:
 606       {
 607          ret = rgSCHCfgVldtRgrLcCfg(inst, &cfg->u.lchCfg, &cell, &ue, errInfo);
 608          if (ret != ROK)
 609          {
 610             RLOG1(L_ERROR,"LC configuration validation "
 611               "FAILED: LCID:%d", cfg->u.lchCfg.lcId);
 612             return RFAILED;
 613          }
 614          ret = rgSCHCfgRgrLchCfg(cell, ue, &cfg->u.lchCfg, errInfo);
 615          break;
 616       }
 617       case RGR_LCG_CFG:
 618       {
 619          ret = rgSCHCfgVldtRgrLcgCfg(inst, &cfg->u.lcgCfg, &cell, &ue, errInfo);
 620          if (ret != ROK)
 621          {
 622             RLOG1(L_ERROR,"LCG configuration validation "
 623               "FAILED: LCGID:%d", cfg->u.lcgCfg.ulInfo.lcgId);
 624             return RFAILED;
 625          }
 626          ret = rgSCHCfgRgrLcgCfg(cell, ue, &cfg->u.lcgCfg, errInfo);
 627          break;
 628       }
 629       case MAC_GNB_CFG:
 630       {
 631          ret = rgSCHCfgVldtRgrSchedEnbCfg(inst, &cfg->u.schedEnbCfg, errInfo);
 632          if (ret != ROK)
 633          {
 634             RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCH ENB configuration validation "
 635               "FAILED: \n" ));
 636             return RFAILED;
 637          }
 638          ret = rgSCHCfgRgrSchedEnbCfg(inst, spId, &cfg->u.schedEnbCfg, errInfo);
 639          break;
 640       }
 641       default:
 642       {
 643 #if(ERRCLASS & ERRCLS_INT_PAR)
 644             RLOG1(L_ERROR,"Should never come here: "
 645                 "cfgType %d", cfg->cfgType);
 646 #endif
 647             return RFAILED;
 648       }
 649    }
 650
 651    return (ret);
 652 }  /* rgSCHGomHndlCfgReq */
 653
 654 #ifdef LTE_ADV
 655 /**
 656  * @brief Handler to handle re-configuration request from RRM to MAC.
 657  *
 658  * @details
 659  *
 660  *     Function: rgSCHGomHndlSCellActDeactReq
 661  *
 662  *     This API handles processing for SCell Activation Request from RRM to SCH.
 663  *
 664  *     - Processing Steps:
 665  *        - Validate sCell Actication request parameters at CFG module.
 666  *        - If validated successfully, send configuration request to CFG.
 667  *        - call activation function for each SCells configured
 668  *
 669  *  @param[in]  RgSchCb      *instCb
 670  *  @param[in]  SpId         spId
 671  *  @param[in]  RgrSCellActDeactEvnt  *sCellActDeactEvnt
 672  *  @param[in]  U8 action
 673  *  @param[out] RgSchErrInfo *errInfo
 674  *  @return  S16
 675  *      -# ROK
 676  *      -# RFAILED
 677  **/
 678 #ifdef ANSI
 679 PRIVATE S16 rgSCHGomHndlSCellActDeactReq
 680 (
 681 RgSchCb               *instCb,
 682 SpId                   spId,
 683 RgrSCellActDeactEvnt  *sCellActDeactEvnt,
 684 RgSchErrInfo          *errInfo,
 685 U8                    action
 686 )
 687 #else
 688 PRIVATE S16 rgSCHGomHndlSCellActDeactReq(instCb, spId, sCellActDeactEvnt, errInfo, action)
 689 RgSchCb               *instCb;
 690 SpId                  spId;
 691 RgrSCellActDeactEvnt  *sCellActDeactEvnt;
 692 RgSchErrInfo          *errInfo;
 693 U8                    action;
 694 #endif
 695 {
 696    RgSchUeCb    *ue = NULLP;
 697    U16          idx = 0;
 698    U16          sCellIdx = 0;
 699    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
 700    Inst         inst = (instCb->rgSchInit.inst);
 701
 702    RGSCHDBGPRM(inst,(rgSchPBuf(inst), "Processing RGR SCell Actication request:"
 703                   "%d\n", sCellActDeactEvnt->crnti));
 704
 705    errInfo->errType = RGSCHERR_GOM_SCELL_REQ;
 706
 707    /* Fetch the Ue */
 708    if ((ue = rgSCHDbmGetUeCb(cell, sCellActDeactEvnt->crnti)) == NULLP)
 709    {
 710       RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]UE: does not exist\n",
 711             sCellActDeactEvnt->crnti));
 712       return RFAILED;
 713    }
 714
 715    for(idx = 0; idx < sCellActDeactEvnt->numOfSCells; idx++)
 716    {
 717       sCellIdx = sCellActDeactEvnt->sCellActDeactInfo[idx].sCellIdx;
 718
 719       if (ROK != (rgSCHSCellTrigActDeact(cell, ue, sCellIdx, action)))
 720       {
 721             RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCell Actication failed"
 722                      "for UE [%d] with SCellIdx [%d]\n",
 723                      sCellActDeactEvnt->crnti, idx));
 724             return RFAILED;
 725
 726       }
 727
 728    }
 729    RGSCHDBGINFO(inst,(rgSchPBuf(inst), "RGR Reconfiguration processed\n"));
 730    return ROK;
 731 }  /* rgSCHGomHndlSCellActDeactReq */
 732
 733 #endif /* LTE_ADV */
 734 /**
 735  * @brief Handler to handle re-configuration request from RRM to MAC.
 736  *
 737  * @details
 738  *
 739  *     Function: rgSCHGomHndlRecfgReq
 740  *
 741  *     This API handles processing for re-configuration request from RRM to MAC.
 742  *
 743  *     - Processing Steps:
 744  *        - Validate re-configuration request parameters at CFG module.
 745  *          Call rgSCHCfgVldtRgrCellRecfg for cell re-configuration.
 746  *        - If validated successfully, send configuration request to CFG.
 747  *          Call rgSCHCfgRgrCellRecfg else FAIL.
 748  *
 749  *  @param[in]  RgSchCb      *instCb
 750  *  @param[in]  SpId         spId
 751  *  @param[in]  RgrRecfg     *recfg
 752  *  @param[out] RgSchErrInfo *errInfo
 753  *  @return  S16
 754  *      -# ROK
 755  *      -# RFAILED
 756  **/
 757 #ifdef ANSI
 758 PRIVATE S16 rgSCHGomHndlRecfgReq
 759 (
 760 RgSchCb       *instCb,
 761 SpId          spId,
 762 RgrRecfg      *recfg,
 763 RgSchErrInfo  *errInfo
 764 )
 765 #else
 766 PRIVATE S16 rgSCHGomHndlRecfgReq(instCb, spId, recfg, errInfo)
 767 RgSchCb       *instCb;
 768 SpId          spId;
 769 RgrRecfg      *recfg;
 770 RgSchErrInfo  *errInfo;
 771 #endif
 772 {
 773    RgSchUeCb    *ue = NULLP;
 774    RgSchDlLcCb  *dlLc = NULLP; /* PURIFY_FIX:UMR */
 775    S16          ret;
 776    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
 777    Inst         inst = (instCb->rgSchInit.inst );
 778
 779    errInfo->errType = RGSCHERR_GOM_RECFG_REQ;
 780
 781    /* Validate and process the re-configuration request */
 782    switch (recfg->recfgType)
 783    {
 784       case RGR_CELL_CFG:
 785       {
 786          ret = rgSCHCfgVldtRgrCellRecfg(inst, &recfg->u.cellRecfg, &cell,
 787                errInfo);
 788          if (ret != ROK)
 789          {
 790             RLOG_ARG0(L_ERROR,DBG_CELLID,recfg->u.cellRecfg.cellId,"Rgr Cell Recfg Validation "
 791                      "FAILED");
 792             return RFAILED;
 793          }
 794          ret = rgSCHCfgRgrCellRecfg(cell, &recfg->u.cellRecfg, errInfo);
 795          break;
 796       }
 797       case RGR_UE_CFG:
 798       case RGR_SCELL_UE_CFG:
 799       {
 800          ret = rgSCHCfgVldtRgrUeRecfg(inst, &recfg->u.ueRecfg, &cell, &ue, errInfo);
 801          if ( ret != ROK)
 802          {
 803             RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.ueRecfg.cellId,"Ue Recfg Validation FAILED"
 804                       "OLD CRNTI:%d",recfg->u.ueRecfg.oldCrnti);
 805             return RFAILED;
 806          }
 807          ret = rgSCHCfgRgrUeRecfg(cell, ue, &recfg->u.ueRecfg, errInfo);
 808          break;
 809       }
 810       case RGR_LCH_CFG:
 811       {
 812          ret = rgSCHCfgVldtRgrLchRecfg(inst, &recfg->u.lchRecfg, &cell, &ue,
 813                &dlLc, errInfo);
 814          if (ret != ROK)
 815          {
 816             RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lchRecfg.cellId,"Lc Recfg Validation FAILED"
 817                       "LCID:%d",recfg->u.lchRecfg.lcId);
 818             return RFAILED;
 819          }
 820          ret = rgSCHCfgRgrLchRecfg(cell, ue, dlLc, &recfg->u.lchRecfg, errInfo);
 821          break;
 822       }
 823       case RGR_LCG_CFG:
 824       {
 825          ret = rgSCHCfgVldtRgrLcgRecfg(inst, &recfg->u.lcgRecfg, cell, &ue,
 826                errInfo);
 827          if (ret != ROK)
 828          {
 829             RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lcgRecfg.cellId, "Lcg Recfg Validation FAILED"
 830                       "LCGID:%d",recfg->u.lcgRecfg.ulRecfg.lcgId);
 831             return RFAILED;
 832          }
 833          ret = rgSCHCfgRgrLcgRecfg(cell, ue, &recfg->u.lcgRecfg, errInfo);
 834          break;
 835       }
 836       default:
 837       {
 838 #if(ERRCLASS & ERRCLS_INT_PAR)
 839          RLOG1(L_ERROR,"Should never come here: recfgType %d", recfg->recfgType);
 840 #endif
 841          return RFAILED;
 842       }
 843    }
 844
 845    return (ret);
 846 }  /* rgSCHGomHndlRecfgReq */
 847
 848 /**
 849  * @brief Handler to handle UE reset request from RRM to Scheduler.
 850  *
 851  * @details
 852  *
 853  *     Function: rgSCHGomHndlResetReq
 854  *
 855  *     This API handles processing for UE reset request from RRM to Scheduler.
 856  *
 857  *     - Processing Steps:
 858  *        - Validate UE reset request parameters at CFG module.
 859  *          Call rgSCHCfgVldtRgrUeReset for UE reset.
 860  *        - If validated successfully, send UE reset request to CFG.
 861  *          Call rgSCHCfgRgrUeReset else FAIL.
 862  *
 863  *  @param[in]  RgrRst   *rstInfo
 864  *  @param[out] RgSchErrInfo *errInfo
 865  *  @return  S16
 866  *      -# ROK
 867  *      -# RFAILED
 868  **/
 869 #ifdef ANSI
 870 PRIVATE S16 rgSCHGomHndlResetReq
 871 (
 872 RgSchCb       *instCb,
 873 SpId          spId,
 874 RgrRst        *reset,
 875 RgSchErrInfo  *errInfo
 876 )
 877 #else
 878 PRIVATE S16 rgSCHGomHndlResetReq(instCb, spId, reset, errInfo)
 879 RgSchCb       *instCb;
 880 SpId          spId;
 881 RgrRst        *reset;
 882 RgSchErrInfo  *errInfo;
 883 #endif
 884 {
 885    S16          ret;
 886    RgSchCellCb  *cell= instCb->rgrSap[spId].cell;
 887    Inst         inst = (instCb->rgSchInit.inst );
 888    RgSchUeCb    *ue = NULLP;
 889
 890    errInfo->errType = RGSCHERR_GOM_RESET_REQ;
 891
 892    /* Validate and process the UE reset request */
 893    ret = rgSCHCfgVldtRgrUeReset(inst, reset, cell, &ue, errInfo);
 894    if (ret != ROK)
 895    {
 896       RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset Validation FAILED"
 897                "CRNTI:%d",reset->crnti);
 898       return RFAILED;
 899    }
 900
 901    ret = rgSCHCfgRgrUeReset(cell, ue, reset, errInfo);
 902    if (ret != ROK)
 903    {
 904       RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset FAILED"
 905                "CRNTI:%d",reset->crnti);
 906       return RFAILED;
 907    }
 908
 909    return (ret);
 910 }  /* rgSCHGomHndlResetReq */
 911
 912
 913 /**
 914  * @brief Handler for processing Cell/Ue/Logical channel delete request
 915  * recieved from RRM.
 916  *
 917  * @details
 918  *
 919  *     Function: rgSCHGomHndlDelReq
 920  *
 921  *     This API handles processing of delete request from RRM to MAC.
 922  *
 923  *     Processing Steps:
 924  *        - Fetch corresponding control block and pass it to CFG module.
 925  *        - If control block does not exist, FAIL.
 926  *
 927  *  @param[in]  RgSchCb      *instCb
 928  *  @param[in]  SpId         spId
 929  *  @param[in]  RgrDel       *del
 930  *  @param[out] RgSchErrInfo *errInfo
 931  *  @return  S16
 932  *      -# ROK
 933  *      -# RFAILED
 934  **/
 935 #ifdef ANSI
 936 PRIVATE S16 rgSCHGomHndlDelReq
 937 (
 938 RgSchCb       *instCb,
 939 SpId          spId,
 940 RgrDel        *del,
 941 RgSchErrInfo  *errInfo
 942 )
 943 #else
 944 PRIVATE S16 rgSCHGomHndlDelReq(instCb, spId, del, errInfo)
 945 RgSchCb       *instCb;
 946 SpId          spId;
 947 RgrDel        *del;
 948 RgSchErrInfo  *errInfo;
 949 #endif
 950 {
 951
 952    S16       ret;
 953 #ifdef DEBUGP
 954    Inst      inst = (instCb->rgSchInit.inst);
 955 #endif
 956    VOLATILE U32     startTime=0;
 957
 958    errInfo->errType = RGSCHERR_GOM_DEL_REQ;
 959
 960    if(instCb->rgrSap[spId].cell == NULLP)
 961    {
 962       RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"Cell doesnt exist");
 963       return RFAILED;
 964    }
 965
 966    /* Process the delete request */
 967    switch (del->delType)
 968    {
 969       case RGR_CELL_CFG:
 970       {
 971          ret = rgSCHCfgRgrCellDel(instCb->rgrSap[spId].cell, del, errInfo);
 972          if(ret == ROK)
 973          {
 974             /* TODO::Needs to be revisited after tti flow CaDev Start */
 975             U8 idx = (U8)((instCb->rgrSap[spId].cell->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
 976             instCb->cells[idx] = NULLP;
 977             /* CaDev End */
 978             instCb->rgrSap[spId].cell = NULLP;
 979             instCb->tfuSap[spId].cell = NULLP;
 980          }
 981          break;
 982       }
 983       case RGR_UE_CFG:
 984       case RGR_SCELL_UE_CFG:
 985       {
 986
 987          /*starting Task*/
 988          SStartTask(&startTime, PID_SCH_UE_DEL);
 989
 990          ret = rgSCHCfgRgrUeDel(instCb->rgrSap[spId].cell, del, errInfo);
 991
 992          /*stoping Task*/
 993          SStopTask(startTime, PID_SCH_UE_DEL);
 994
 995          break;
 996       }
 997       case RGR_LCH_CFG:
 998       {
 999          ret = rgSCHCfgRgrLcDel(instCb->rgrSap[spId].cell, del, errInfo);
1000          break;
1001       }
1002       case RGR_LCG_CFG:
1003       {
1004          ret = rgSCHCfgRgrLcgDel(instCb->rgrSap[spId].cell, del, errInfo);
1005          break;
1006       }
1007       default:
1008       {
1009 #if(ERRCLASS & ERRCLS_INT_PAR)
1010          RLOG1(L_ERROR,"Should never come here: delType %d", del->delType);
1011 #endif
1012          return RFAILED;
1013       }
1014    }
1015
1016    return (ret);
1017 }  /* rgSCHGomHndlDelReq */
1018
1019
1020
1021
1022 /***********************************************************
1023  *
1024  *     Func : rgSCHGomGetCellIdFrmCfgReq
1025  *
1026  *
1027  *     Desc :
1028  *     - Processing Steps:
1029  *        - Retrieves the cell Id for a config request.
1030  *
1031  *  @param[in]  RgrCfgReqInfo *rgrCfgReq
1032  *  @param[out] CmLteCellId   *cellId
1033  *     Ret  : ROK on fetching cellId
1034  *            RFAILED on failure
1035  *
1036  *     Notes:
1037  *
1038  *     File : rg_sch_gom.c
1039  *
1040  **********************************************************/
1041 #ifdef ANSI
1042 PRIVATE S16 rgSCHGomGetCellIdFrmCfgReq
1043 (
1044 RgrCfgReqInfo *rgrCfgReq,
1045 CmLteCellId   *cellId
1046 )
1047 #else
1048 PRIVATE S16 rgSCHGomGetCellIdFrmCfgReq(rgrCfgReq, cellId)
1049 RgrCfgReqInfo *rgrCfgReq;
1050 CmLteCellId   *cellId;
1051 #endif
1052 {
1053
1054    /* Extract CellId depending on the action and Config Type in the Request
1055     * As of now this function is called for only re configuration so removed
1056     * othe CASES below if needed we can add them*/
1057    switch (rgrCfgReq->action)
1058    {
1059       case RGR_RECONFIG:
1060          {
1061             if (rgrCfgReq->u.recfgInfo.recfgType ==RGR_CELL_CFG)
1062             {
1063                *cellId = rgrCfgReq->u.recfgInfo.u.cellRecfg.cellId;
1064             }
1065             else if ((rgrCfgReq->u.recfgInfo.recfgType ==  RGR_SCELL_UE_CFG) ||
1066                   (rgrCfgReq->u.recfgInfo.recfgType == RGR_UE_CFG))
1067             {
1068                *cellId = rgrCfgReq->u.recfgInfo.u.ueRecfg.cellId;
1069             }
1070             else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCH_CFG)
1071             {
1072                *cellId = rgrCfgReq->u.recfgInfo.u.lchRecfg.cellId;
1073             }
1074             else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCG_CFG)
1075             {
1076                *cellId = rgrCfgReq->u.recfgInfo.u.lcgRecfg.cellId;
1077             }
1078             else
1079             {
1080                return RFAILED;
1081             }
1082             break;
1083          }
1084       default:
1085       {
1086          return RFAILED;
1087       }
1088    }  /* End of Switch */
1089
1090    return ROK;
1091 }  /* rgSCHGomGetCellIdFrmCfgReq */
1092
1093 #ifdef RGR_SI_SCH
1094 /**
1095  * @brief Handler to handle SI configuration request from RRM to MAC.
1096  *
1097  * @details
1098  *
1099  *     Function: rgSCHGomHndlSiCfg
1100  *
1101  *     This API handles processing for SI configuration request from RRM to MAC.
1102  *
1103  *     - Processing Steps:
1104  *        - Validate SI configuration request parameters at CFG module.
1105  *          Call rgSCHCfgVldtSiCfg for SI configuration.
1106  *        - If validated successfully, send configuration request to CFG.
1107  *          Call rgSCHCfgRgrCellCfg else FAIL.
1108  *
1109  *  @param[in]  Region        reg
1110  *  @param[in]  Pool          pool
1111  *  @param[in]  RgSchCb       *instCb
1112  *  @param[in]  SpId          spId
1113  *  @param[in]  RgrCfgTransId transId
1114  *  @param[in]  RgrSiCfgReqInfo *cfgReqInfo
1115  *  @return  S16
1116  *      -# ROK
1117  *      -# RFAILED
1118  **/
1119 #ifdef ANSI
1120 S16 rgSCHGomHndlSiCfg
1121 (
1122 Region        reg,
1123 Pool          pool,
1124 RgSchCb       *instCb,
1125 SpId          spId,
1126 RgrCfgTransId transId,
1127 RgrSiCfgReqInfo *cfgReqInfo
1128 )
1129 #else
1130 S16 rgSCHGomHndlSiCfg(reg, pool, instCb, spId, transId, cfgReqInfo)
1131 Region        reg;
1132 Pool          pool;
1133 RgSchCb       *instCb;
1134 SpId          spId;
1135 RgrCfgTransId transId;
1136 RgrSiCfgReqInfo *cfgReqInfo;
1137 #endif
1138 {
1139    S16          ret;
1140    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
1141    Inst         inst = (instCb->rgSchInit.inst );
1142    RgSchErrInfo    errInfo;
1143    U8           cfmStatus = RGR_CFG_CFM_NOK;
1144    MsgLen       msgLen = 0, pduLen;
1145    S32          tbSz   = 0;
1146    U8           nPrb   = 0;
1147    U8           mcs    = 0;
1148
1149
1150    /* check if cell does not exists */
1151    if (((U8 *)cell == NULLP) || (cell->cellId != cfgReqInfo->cellId))
1152    {
1153       RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Cell Control block does not exist"
1154                );
1155       RGSCH_FREE_MSG(cfgReqInfo->pdu);
1156       SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1157       cfgReqInfo = NULLP;
1158       rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1159       return RFAILED;
1160    }
1161
1162    /*Validate the received SI configuration */
1163    ret = rgSCHCfgVldtRgrSiCfg(inst, cfgReqInfo, cell, &errInfo);
1164    if (ret != ROK)
1165    {
1166       RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Rgr SI configuration "
1167                "validation FAILED");
1168       RGSCH_FREE_MSG(cfgReqInfo->pdu);
1169       SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1170       cfgReqInfo = NULLP;
1171       rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1172       return RFAILED;
1173    }
1174    /*ccpu00140789: Stopping SI scheduling*/
1175    if(RGR_SI_STOP == cfgReqInfo->cfgType)
1176    {
1177       if((cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si != NULLP)&&
1178                       (cell->siCb.siArray[cfgReqInfo->siId-1].si != NULLP))
1179       {
1180          cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
1181          RGSCH_FREE_MSG(cell->siCb.siArray[cfgReqInfo->siId-1].si);
1182          cell->siCb.siArray[cfgReqInfo->siId-1].si = NULLP;
1183          if(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si != NULLP)
1184          {
1185             RGSCH_FREE_MSG(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si);
1186             cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
1187          }
1188          SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1189          cfgReqInfo = NULLP;
1190          cfmStatus = RGR_CFG_CFM_OK;
1191          rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1192          return ROK;
1193        }
1194        else
1195        {
1196           SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1197           cfgReqInfo = NULLP;
1198           rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1199           return RFAILED;
1200        }
1201    }
1202
1203    /* Check if the pdu sent from application
1204     * matches a transport block size. if not,
1205     * add padding bytes. This is usually done
1206     * by RRC but since we are bypassing RRC,
1207     * MAC is taking over that responsibility
1208     */
1209    if ( RGR_SI_CFG_TYPE_MIB != cfgReqInfo->cfgType )
1210    {
1211       SFndLenMsg(cfgReqInfo->pdu, &msgLen);
1212
1213       /* check if the application pdu matches a tb size */
1214       tbSz = rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs);
1215
1216       if ( tbSz != (msgLen*8) )
1217       {
1218          MsgLen  nmPadBytes = 0;
1219          Data*   padding    = NULLP;
1220
1221          /* need to add padding bytes */
1222          nmPadBytes = (tbSz - (msgLen*8))/8;
1223
1224          if ( SGetSBuf(reg,pool,&padding,nmPadBytes) != ROK)
1225          {
1226             RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Rgr SI configuration "
1227                      "SGetSBuf failed for padding failed");
1228             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1229             cfgReqInfo = NULLP;
1230             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1231                                                            cfmStatus);
1232             return RFAILED;
1233          }
1234
1235          memset(padding,0,nmPadBytes);
1236
1237 #ifdef MS_MBUF_CORRUPTION
1238    MS_BUF_ADD_ALLOC_CALLER();
1239 #endif
1240          if ( SAddPstMsgMult((Data*)padding,nmPadBytes,cfgReqInfo->pdu) != ROK)
1241          {
1242             RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Rgr SI configuration "
1243                      "Failed to add padding bytes");
1244             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1245             cfgReqInfo = NULLP;
1246             SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1247             padding = NULLP;
1248             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1249                                                             cfmStatus);
1250             return RFAILED;
1251          }
1252          SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1253          padding = NULLP;
1254       }/* if (tbSz != ...*/
1255    }/* if (RGR_SI_CFG_TYPE_SI...*/
1256
1257    /*Set the received pdu at the appropriate place */
1258    switch(cfgReqInfo->cfgType)
1259    {
1260       case RGR_SI_CFG_TYPE_MIB:   /* SI CFG Type MIB */
1261          RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.mib,
1262                cell->siCb.newSiInfo.mib,
1263                cfgReqInfo->pdu, cell->siCb.siBitMask,
1264                RGSCH_SI_MIB_UPD);
1265          break;
1266
1267       case RGR_SI_CFG_TYPE_SIB1_PWS:
1268          {
1269             SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1270             ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1271             if (ret != ROK)
1272             {
1273                RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1274                      "value");
1275                RGSCH_FREE_MSG(cfgReqInfo->pdu);
1276                SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1277                cfgReqInfo = NULLP;
1278                rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1279                      cfmStatus);
1280                return RFAILED;
1281             }
1282
1283             RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1,
1284                   cell->siCb.newSiInfo.sib1Info.sib1,
1285                   cfgReqInfo->pdu, cell->siCb.siBitMask,
1286                   RGSCH_SI_SIB1_PWS_UPD);
1287          }
1288          break;
1289
1290       case RGR_SI_CFG_TYPE_SIB1:
1291          SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1292          ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1293          if (ret != ROK)
1294          {
1295             RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1296                      "value");
1297             RGSCH_FREE_MSG(cfgReqInfo->pdu);
1298             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1299             cfgReqInfo = NULLP;
1300             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1301                                                                  cfmStatus);
1302             return RFAILED;
1303          }
1304          RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1,
1305                cell->siCb.newSiInfo.sib1Info.sib1,
1306                cfgReqInfo->pdu, cell->siCb.siBitMask,
1307                RGSCH_SI_SIB1_UPD);
1308          break;
1309
1310       case RGR_SI_CFG_TYPE_SI:    /* SI CFG TYPE SI */
1311          SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1312          ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,
1313                                                      cfgReqInfo->siId);
1314          if (ret != ROK)
1315          {
1316             RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1317                      "value");
1318             RGSCH_FREE_MSG(cfgReqInfo->pdu);
1319             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1320             cfgReqInfo = NULLP;
1321             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1322                                                                  cfmStatus);
1323             return RFAILED;
1324          }
1325          /* Si recfg, where numSi changes */
1326          if (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD)
1327          {
1328             Buffer **newSiPdu = &cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si;
1329             if(*newSiPdu != NULLP)
1330             {
1331                RGSCH_FREE_MSG(*newSiPdu);
1332             }
1333             *newSiPdu = (Buffer *)cfgReqInfo->pdu;
1334             cell->siCb.siBitMask |= RGSCH_SI_SI_UPD;
1335          }
1336          else /* Initial Si cfg  or si recfg where numSi did not change */
1337          {
1338             U8 bitMask;
1339             /* Initial Si cfg */
1340             if (cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si == NULLP)
1341             {
1342                cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
1343                cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1344                bitMask = RGSCH_SI_DFLT;
1345             }
1346             else
1347             {
1348                bitMask = RGSCH_SI_SI_UPD;
1349             }
1350
1351             RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si,
1352                 cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si,
1353                 cfgReqInfo->pdu,
1354                 cell->siCb.siBitMask, bitMask);
1355          }
1356          break;
1357
1358       case RGR_SI_CFG_TYPE_SIB8_CDMA:    /* SI CFG TYPE SIB 8 CDMA */
1359          SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1360          ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,
1361                                                      cfgReqInfo->siId);
1362          if (ret != ROK)
1363          {
1364             RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1365                      "value");
1366             RGSCH_FREE_MSG(cfgReqInfo->pdu);
1367             SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1368             cfgReqInfo = NULLP;
1369             rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1370                                                                  cfmStatus);
1371             return RFAILED;
1372          }
1373          /* No need to wait for Modification period boundary */
1374          cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
1375          RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si,
1376                cfgReqInfo->pdu);
1377          cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1378          break;
1379       default:
1380          RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Invalid cfgType "
1381                   "parameter value");
1382          RGSCH_FREE_MSG(cfgReqInfo->pdu);
1383          SPutSBuf(reg, pool, (Data *)cfgReqInfo,
1384                (Size)sizeof(*cfgReqInfo));
1385          cfgReqInfo = NULLP;
1386          rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1387                cfmStatus);
1388          return RFAILED;
1389    }
1390
1391    SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1392    cfgReqInfo = NULLP;
1393    cfmStatus = RGR_CFG_CFM_OK;
1394    rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1395
1396
1397    return ROK;
1398 }  /* rgSCHGomHndlSiCfg */
1399
1400
1401 /**
1402  * @brief Handler to handle Warning SI configuration request from RRM to MAC.
1403  *
1404  * @details
1405  *
1406  *     Function: rgSCHGomHndlWarningSiCfg
1407  *
1408  *     This API handles processing for Warning SI configuration request from
1409  *     RRM to MAC.
1410  *
1411  *
1412  *  @param[in]  Region        reg
1413  *  @param[in]  Pool          pool
1414  *  @param[in]  RgSchCb       *instCb
1415  *  @param[in]  SpId          spId
1416  *  @param[in]  RgrWarningSiCfgReqInfo  *warningSiCfgReqInfo
1417  *  @return  S16
1418  *      -# ROK
1419  *      -# RFAILED
1420  **/
1421 #ifdef ANSI
1422 S16 rgSCHGomHndlWarningSiCfg
1423 (
1424 Region        reg,
1425 Pool          pool,
1426 RgSchCb       *instCb,
1427 SpId          spId,
1428 RgrCfgTransId transId,
1429 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
1430 )
1431 #else
1432 S16 rgSCHGomHndlWarningSiCfg(reg, pool, instCb, spId, transId,
1433 warningSiCfgReqInfo)
1434 Region        reg;
1435 Pool          pool;
1436 RgSchCb       *instCb;
1437 SpId          spId;
1438 RgrCfgTransId transId;
1439 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo;
1440 #endif
1441 {
1442    RgSchCellCb       *cell = instCb->rgrSap[spId].cell;
1443    U8                 cfmStatus = RGR_CFG_CFM_NOK;
1444    U16                idx;
1445    U8                 siId = warningSiCfgReqInfo->siId;
1446    U8                 j, mcs=0, nPrb=0;
1447    RgSchWarningSiSeg  *warningSiMsg;
1448    RgSchWarningSiPdu  *pduNode;
1449    CmLList            *node;
1450    MsgLen             msgLen = 0;
1451    Bool               freeNodeFound = FALSE;
1452    U16                siWinSize = 0;
1453    U16                minPeriod = 0;
1454 #ifdef EMTC_ENABLE
1455    U8                 isEmtc = warningSiCfgReqInfo->emtcEnable;
1456 #endif
1457
1458 #ifdef EMTC_ENABLE
1459    if(TRUE == isEmtc)
1460    {
1461       rgSchEmtcGetSiWinPerd(cell, &siWinSize, &minPeriod);
1462    }
1463    else
1464 #endif
1465    {
1466       siWinSize = cell->siCfg.siWinSize;
1467       minPeriod = cell->siCfg.minPeriodicity;
1468    }
1469    /* check if cell does not exists */
1470    if (((U8 *)cell == NULLP) ||
1471          (cell->cellId != warningSiCfgReqInfo->cellId) ||
1472          (warningSiCfgReqInfo->siId >
1473           ((minPeriod * 10)/siWinSize)))
1474    {
1475       RLOG_ARG2(L_ERROR,DBG_CELLID,warningSiCfgReqInfo->cellId,"Warning SI Cfg Failed for siId = %d"
1476                 "warning cellID:%d",warningSiCfgReqInfo->siId,warningSiCfgReqInfo->cellId);
1477       rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
1478       SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1479             sizeof(RgrWarningSiCfgReqInfo));
1480       warningSiCfgReqInfo = NULLP;
1481       rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
1482             cfmStatus);
1483       return RFAILED;
1484    }
1485
1486    /* Search for free index in WarningSi */
1487    for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1488    {
1489       if((cell->siCb.warningSi[idx].siId == 0 ||
1490                cell->siCb.warningSi[idx].siId == warningSiCfgReqInfo->siId))
1491       {
1492          warningSiMsg = (RgSchWarningSiSeg *)&cell->siCb.warningSi[idx].warningSiMsg;
1493
1494          /* Search for free SI node */
1495          /* ccpu00136659: CMAS ETWS design changes */
1496          if (warningSiMsg->segLstCp.first == NULLP) /* Free SI Node */
1497          {
1498             warningSiMsg->transId = transId;
1499             pduNode = (RgSchWarningSiPdu *)&cell->siCb.warningSi[idx].
1500                warningSiMsg.pduNode;
1501             CM_LLIST_FIRST_NODE(&warningSiCfgReqInfo->siPduLst, node);
1502             j = 0;
1503
1504             /* Get the PDUs one by one from the received pduLst of warning
1505              * message and calculate the MCS and nPrb of each pdu once.
1506              * Store the pdu in warningSiMsg pduLst, which will be scheduled
1507              * later while sending warning message as part of SIB11/SIB12
1508              */
1509             while((node != NULLP) && (j < RGR_MAX_WARNING_SI_SEG))
1510
1511             {
1512                pduNode[j].pdu = (Buffer *)node->node;
1513                if(pduNode[j].pdu != NULLP)
1514                {
1515                   SFndLenMsg(pduNode[j].pdu, &msgLen);
1516                   /*Get the nPrb and mcs parametr values */
1517 #ifdef EMTC_ENABLE
1518                   if (rgSCHEmtcUtlGetAllwdCchTbSzForSI(msgLen*8) != (msgLen*8))
1519 #else
1520                   if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
1521 #endif
1522
1523                   {
1524                      RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,
1525                            (ErrVal)msgLen,
1526                            "rgSCHGomHndlWarningSiCfg():msgLen does not match\
1527                            any valid TB Size.");
1528                      RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Warning SI Cfg Failed"
1529                            "for siId = %d", warningSiCfgReqInfo->siId);
1530                      rgSCHUtlFreeWarningSiSeg(reg, pool,
1531                            &warningSiCfgReqInfo->siPduLst);
1532                      SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1533                            sizeof(RgrWarningSiCfgReqInfo));
1534                      warningSiCfgReqInfo = NULLP;
1535                      rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId,
1536                            siId, transId,cfmStatus);
1537                      return RFAILED;
1538
1539                   }
1540                }
1541                pduNode[j].mcs = mcs;
1542                pduNode[j].nPrb = nPrb;
1543                pduNode[j].msgLen = msgLen;
1544                /* ccpu00136659: CMAS ETWS design changes */
1545                cmLListAdd2Tail(&warningSiMsg->segLstCp, &pduNode[j].lnk);
1546                pduNode[j].lnk.node = (PTR)&pduNode[j];
1547                j++;
1548                node = node->next;
1549             }
1550
1551             /* ccpu00132385-  nodes in received SI config linked list should
1552              * be freed after processing the config.*/
1553             while(warningSiCfgReqInfo->siPduLst.first != NULLP)
1554             {
1555                node = warningSiCfgReqInfo->siPduLst.first;
1556                cmLListDelFrm(&(warningSiCfgReqInfo->siPduLst), node);
1557                SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
1558                node = NULLP;
1559             }
1560
1561             cell->siCb.warningSi[idx].siId = warningSiCfgReqInfo->siId;
1562             cell->siCb.warningSi[idx].idx = idx;
1563 #ifdef EMTC_ENABLE
1564             if(TRUE == isEmtc)
1565             {
1566                rgSCHEmtcWarningSiCfg(cell,warningSiCfgReqInfo,idx);
1567             }
1568             else
1569 #endif
1570             {
1571                cell->siCb.siArray[warningSiCfgReqInfo->siId-1].si =
1572                   &cell->siCb.warningSi[idx];
1573                cell->siCb.siArray[warningSiCfgReqInfo->siId-1].isWarningSi =
1574                   TRUE;
1575             }
1576             freeNodeFound = TRUE;
1577             break;
1578          }
1579       }
1580    }
1581
1582    if (freeNodeFound == FALSE)
1583    {
1584       RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,"No SI Index is free");
1585       rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
1586       SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1587             sizeof(RgrWarningSiCfgReqInfo));
1588       warningSiCfgReqInfo = NULLP;
1589       rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
1590             cfmStatus);
1591       return RFAILED;
1592    }
1593
1594    SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1595          sizeof(RgrWarningSiCfgReqInfo));
1596    warningSiCfgReqInfo = NULLP;
1597    return ROK;
1598 }
1599
1600 \f
1601 /**
1602  * @brief Handler to handle SI Stop request from RRM to MAC.
1603  *
1604  * @details
1605  *
1606  *     Function: rgSCHGomHndlWarningSiStopReq
1607  *
1608  *     This API handles processing for SI stop request from RRM to MAC.
1609  *
1610  *  @param[in]  Region        reg
1611  *  @param[in]  Pool          pool
1612  *  @param[in]  RgSchCb       *instCb
1613  *  @param[in]  SpId          siId
1614  *  @return  void
1615  **/
1616 #ifdef ANSI
1617 Void rgSCHGomHndlWarningSiStopReq
1618 (
1619 Region        reg,
1620 Pool          pool,
1621 RgSchCb       *instCb,
1622 U8            siId,
1623 RgrCfgTransId transId,
1624 SpId          spId
1625 )
1626 #else
1627 Void rgSCHGomHndlWarningSiStopReq(reg, pool, instCb, siId, transId, spId)
1628 Region        reg;
1629 Pool          pool;
1630 RgSchCb       *instCb;
1631 U8            siId;
1632 RgrCfgTransId transId;
1633 SpId          spId;
1634 #endif
1635 {
1636    RgSchCellCb        *cell = instCb->rgrSap[spId].cell;
1637    U16                idx;
1638    CmLList            *node;
1639    RgSchWarningSiPdu  *warningSiPdu;
1640    Buffer             *pdu;
1641
1642    for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1643    {
1644       if(cell->siCb.warningSi[idx].siId == siId)
1645       {
1646          if ((cmMemcmp ((U8 *)&cell->siCb.warningSi[idx].warningSiMsg.transId,
1647                      (U8 *)&transId, sizeof(RgrCfgTransId))) == 0)
1648          {
1649             /* ccpu00136659: CMAS ETWS design changes */
1650             CM_LLIST_FIRST_NODE(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
1651             while(node != NULLP)
1652             {
1653                /* On receiving the warning stop message, remove one by one
1654                 * each PDU from the warning SI list
1655                 */
1656                /* ccpu00136659: CMAS ETWS design changes */
1657                node = (CmLList *)&cell->siCb.warningSi[idx].warningSiMsg.segLstCp.first;
1658                warningSiPdu = (RgSchWarningSiPdu *)node->node;
1659                pdu = warningSiPdu->pdu;
1660                cmLListDelFrm(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
1661                RGSCH_FREE_MSG(pdu);
1662                node = node->next;
1663             }
1664          }
1665       }
1666    }
1667    RETVOID;
1668 }
1669
1670 #endif/*RGR_SI_SCH */
1671 \f
1672 /* LTE_ADV_FLAG_REMOVED_START */
1673
1674 /**
1675  * @brief This function sets the Phigh range for CC users corresponding to the CC Pool
1676  * @details
1677  *
1678  *     Function: rgSchUpdtRNTPInfo
1679  *
1680  *     Invoked by: rgSCHGomHndlLoadInf
1681  *
1682  *  @param[in]  RgSchCellCb*     cell
1683  *  @param[in]  RgSubFrm*     subFrm
1684  *  @param[in]  RgrLoadInfReqInfo   *loadInfReq
1685  *  @return  S16
1686  *
1687  **/
1688 #ifdef ANSI
1689 S16 rgSchUpdtRNTPInfo
1690 (
1691  RgSchCellCb             *cell,
1692  RgSchDlSf               *sf,
1693  RgrLoadInfReqInfo       *loadInfReq
1694  )
1695 #else
1696 PRIVATE Void rgSchUpdtRNTPInfo(cell, sf)
1697    RgSchCellCb             *cell;
1698    RgSchDlSf               *sf;
1699    RgrLoadInfReqInfo       *loadInfReq;
1700
1701 #endif
1702 {
1703    /*  Initialise the variables */
1704    RgSchSFRPoolInfo *sfrCCPool;
1705    CmLListCp   *l;
1706    CmLList     *n;
1707    S16 ret = RFAILED;
1708
1709    l = &sf->sfrTotalPoolInfo.ccPool;
1710
1711    /*Get the first node from the CC Pool*/
1712    n = cmLListFirst(l);
1713    while(n)
1714    {
1715       sfrCCPool = (RgSchSFRPoolInfo*)n->node;
1716       if (sfrCCPool->poolendRB == loadInfReq->rgrCcPHighEndRb)
1717       {
1718          sfrCCPool->pwrHiCCRange.endRb   = loadInfReq->rgrCcPHighEndRb;
1719          sfrCCPool->pwrHiCCRange.startRb = loadInfReq->rgrCcPHighStartRb;
1720          return ROK;
1721       }
1722       else
1723       {
1724          n = cmLListNext(l);
1725       }
1726    }
1727    return (ret);
1728 }
1729 /**
1730  * @brief Handler to handle LOAD INF request from RRM to MAC.
1731  *
1732  * @details
1733  *
1734  *     Function: rgSCHGomHndlLoadInf
1735  *
1736  *     This API handles processing for LOAD INF request from RRM to MAC.
1737  *
1738  *     - Processing Steps:
1739  *        - Validate LOAD INF request parameters at CFG module.
1740  *          Call rgSCHCfgVldtRgrLoadInf for SI configuration.
1741  *        - If validated successfully, send configuration request.
1742  *
1743  *  @param[in]  Region            reg
1744  *  @param[in]  Pool              pool
1745  *  @param[in]  RgSchCb           *instCb
1746  *  @param[in]  SpId              spId
1747  *  @param[in]  RgrCfgTransId     transId
1748  *  @param[in]  RgrLoadInfReqInfo *loadInfReq
1749  *  @return  S16
1750  *      -# ROK
1751  *      -# RFAILED
1752  **/
1753 #ifdef ANSI
1754 S16 rgSCHGomHndlLoadInf
1755 (
1756  Region            reg,
1757  Pool              pool,
1758  RgSchCb           *instCb,
1759  SpId              spId,
1760  RgrCfgTransId     transId,
1761  RgrLoadInfReqInfo *loadInfReq
1762  )
1763 #else
1764 S16 rgSCHGomHndlLoadInf(reg, pool, instCb, spId, transId, loadInfReq)
1765    Region            reg;
1766    Pool              pool;
1767    RgSchCb           *instCb;
1768    SpId              spId;
1769    RgrCfgTransId     transId;
1770    RgrLoadInfReqInfo *loadInfReq;
1771 #endif
1772 {
1773    S16          ret;
1774    RgSchCellCb  *cell = instCb->rgrSap[spId].cell;
1775    Inst         inst  = (instCb->rgSchInit.inst );
1776    RgSchErrInfo errInfo;
1777    U16 i;
1778
1779    /* check if cell does not exists */
1780    if (((U8 *)cell == NULLP) || (cell->cellId != loadInfReq->cellId))
1781    {
1782       RLOG_ARG1(L_ERROR,DBG_CELLID,loadInfReq->cellId,"Cell Control block does not exist"
1783              "for load cellId:%d",loadInfReq->cellId);
1784       SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1785       return RFAILED;
1786    }
1787
1788    if (cell->lteAdvCb.dsfrCfg.status == RGR_DISABLE)
1789    {
1790       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHGomHndlLoadInf(): DSFR Feature not enabled");
1791       SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1792       return RFAILED;
1793    }
1794    /* Validate the received LOAD INF Configuration */
1795    ret = rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, &errInfo);
1796    if (ret != ROK)
1797    {
1798       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Rgr LOAD INF Configuration "
1799                "validation FAILED");
1800       SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1801       return RFAILED;
1802    }
1803    /* Update the RNTP info rcvd in the respective cell centre pool so that Phigh can be
1804       sent for the UEs scheduled in that particular RB range*/
1805    for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
1806    {
1807       if((rgSchUpdtRNTPInfo(cell, cell->subFrms[i], loadInfReq) != ROK))
1808       {
1809          return RFAILED;
1810       }
1811    }
1812
1813    SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1814
1815
1816    return ROK;
1817 }  /* rgSCHGomHndlLoadInf */
1818 /* LTE_ADV_FLAG_REMOVED_END */
1819 \f
1820 /**********************************************************************
1821
1822          End of file
1823 **********************************************************************/