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