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