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