1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
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 #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
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 *******************************************************************************/
19 /************************************************************************
25 Desc: C source code for Entry point fucntions
29 **********************************************************************/
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.
36 static const char* RLOG_MODULE_NAME="MAC";
37 static int RLOG_MODULE_ID=4096;
38 static int RLOG_FILE_ID=164;
40 /* header include files -- defines (.h) */
41 #include "common_def.h"
46 #include "rg_sch_inf.h"
48 #include "rg_sch_err.h"
49 #include "rl_interface.h"
50 #include "rl_common.h"
52 /* header/extern include files (.x) */
56 #include "rg_sch_inf.x"
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));
75 static S16 rgSCHGomHndlSCellActDeactReq ARGS((RgSchCb *instCb, SpId spId,
76 RgrSCellActDeactEvnt *sCellActDeactEvnt, RgSchErrInfo *errInfo, uint8_t action));
79 S16 rgSchEmtcGetSiWinPerd ARGS((
84 extern S16 rgSCHEmtcUtlCalMcsAndNPrb
92 S32 rgSCHEmtcUtlGetAllwdCchTbSzForSI ARGS(
97 Void rgSCHEmtcWarningSiCfg ARGS(
100 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo,
110 /* forward references */
115 * @brief Handler for config request from RRM to Schedular.
119 * Function: rgSCHGomHndlCfg
121 * This API is called from schedulers UIM and it handles config request
122 * from RRM to Scheduler.
125 * - If the request is for the inactive cell,
126 * - Handle request.Call rgSCHGomCfgReq.
128 * - Enqueue the request. Call rgSCHGomEnqCfgReq.
130 * @param[in] Pst *pst
131 * @param[in] RgSchCb *instCb
132 * @param[in] RgrCfgTransId transId
133 * @param[in] RgrCfgReqInfo *cfgReqInfo
138 S16 rgSCHGomHndlCfg(Pst *pst,RgSchCb *instCb,RgrCfgTransId transId,RgrCfgReqInfo *cfgReqInfo)
143 RgSchCellCb *cell = NULLP;
144 uint8_t cfmStatus = RGR_CFG_CFM_NOK;
146 Inst inst = (instCb->rgSchInit.inst );
149 /* Apply the configuration for Cell Configuration or Delete */
150 if (cfgReqInfo->action != RGR_RECONFIG)
152 ret = rgSCHGomCfgReq (pst->region, pst->pool, instCb,
153 transId, cfgReqInfo);
157 /* Fetch the cell Id for the recieved request */
158 if((rgSCHGomGetCellIdFrmCfgReq(cfgReqInfo, &cellId)) != ROK)
160 RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Action.Config Type Error");
162 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
163 (Size)sizeof(*cfgReqInfo));
165 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
168 /* Extract the cell and Enquee Config Request */
169 if(NULLP != instCb->rgrSap[spId].cell)
171 if(cellId != instCb->rgrSap[spId].cell->cellId)
173 RLOG_ARG2(L_ERROR,DBG_CELLID,cellId, "Cell with Id %d already exists "
174 "on sap %d", instCb->rgrSap[spId].cell->cellId, spId);
176 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
177 (Size)sizeof(*cfgReqInfo));
179 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
182 cell = instCb->rgrSap[spId].cell;
184 /* Enqueue the configuration */
185 ret = rgSCHGomEnqCfgReq(pst->region, pst->pool, cell, transId, cfgReqInfo);
188 RLOG_ARG0(L_ERROR,DBG_CELLID,cellId, "rgSCHGomHndlCfg: Enqueuing CfgReq "
191 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
192 (Size)sizeof(*cfgReqInfo));
194 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
200 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
201 (Size)sizeof(*cfgReqInfo));
203 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
206 }/* rgSCHGomHndlCfg */
210 * @brief Handler to handle config request from RRM to Scheduler.
214 * Function: rgSCHGomCfgReq
216 * This API handles processing for config request from RRM to Scheduler.
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.
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
233 static S16 rgSCHGomCfgReq(Region reg,Pool pool,RgSchCb *instCb,RgrCfgTransId transId,RgrCfgReqInfo *cfgReqInfo)
236 uint8_t cfmStatus = RGR_CFG_CFM_OK;
238 RgSchErrInfo errInfo;
240 Inst inst = (instCb->rgSchInit.inst );
243 printf("\n AT MAC rgSCHGomCfgReq \n");
246 /* Process Config/Reconfig/Delete request from RRM */
247 switch (cfgReqInfo->action)
251 ret = rgSCHGomHndlCfgReq(instCb, spId,
252 &cfgReqInfo->u.cfgInfo, &errInfo);
257 ret = rgSCHGomHndlRecfgReq(instCb, spId,
258 &cfgReqInfo->u.recfgInfo, &errInfo);
263 ret = rgSCHGomHndlResetReq(instCb, spId,
264 &cfgReqInfo->u.rstInfo, &errInfo);
269 ret = rgSCHGomHndlDelReq(instCb, spId,
270 &cfgReqInfo->u.delInfo, &errInfo);
275 case RGR_SCELL_DEACT:
276 case RGR_SCELL_READY:
278 ret = rgSCHGomHndlSCellActDeactReq(instCb, spId,
279 &cfgReqInfo->u.sCellActDeactEvnt, &errInfo, cfgReqInfo->action);
285 RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "Invalid configuration "
286 "action %d", cfgReqInfo->action);
289 } /* End of switch */
293 cfmStatus = RGR_CFG_CFM_NOK;
296 SPutSBuf(reg, pool, (Data *)cfgReqInfo,
297 (Size)sizeof(*cfgReqInfo));
300 printf("\n AT MAC sending RGR cfg cfm \n");
303 /* Send back confirmation status to RRM */
304 schSendCfgCfm(reg, pool, transId, cfmStatus);
306 printf("\n AT MAC RGR cfg cfm sent\n");
310 } /* rgSCHGomCfgReq */
314 * @brief Handler to enqueuing config request from RRM to Scheduler.
318 * Function: rgSCHGomEnqCfgReq
320 * This API enqueues config request from RRM to MAC.
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
330 * - Enqueue the request in pndngRgrCfgLst of the cell.
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
341 static S16 rgSCHGomEnqCfgReq(Region reg,Pool pool,RgSchCellCb *cell,RgrCfgTransId transId,RgrCfgReqInfo *rgrCfgReq)
345 RgSchCfgElem *rgrCfgElem = NULLP;
346 CmLteTimingInfo actvTime;
347 Inst inst = cell->instIdx;
349 /* Allocate memory for config Element */
350 ret = rgSCHUtlAllocSBuf(inst, (Data **)&rgrCfgElem, sizeof(RgSchCfgElem));
351 if ((ret != ROK) || ((uint8_t *)rgrCfgElem == NULLP))
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;
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)))
373 rgrCfgReq->u.recfgInfo.u.cellRecfg.recfgActvTime.actvTime;
375 /* Check if the activation time is valid */
376 if (actvTime.sfn >= RGSCH_MAX_SFN
377 || actvTime.slot >= RGSCH_NUM_SUB_FRAMES_5G)
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));
389 sfDiff = RGSCH_CALC_SF_DIFF(actvTime, cell->crntTime);
391 if (sfDiff > (RGR_ACTV_WIN_SIZE * RGSCH_NUM_SUB_FRAMES_5G))
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));
405 /* Add to pending cfgReqLst */
406 rgrCfgElem->actvTime = actvTime;
407 rgSCHDbmInsPndngRgrCfgElem(cell, rgrCfgElem);
408 /* Cfm to be sent only after applying request */
413 /* Add to current cfgReq list */
414 rgSCHDbmInsCrntRgrCfgElem(cell, rgrCfgElem);
415 /* Cfm to be sent only after applying request */
417 } /* rgSCHGomEnqCfgReq */
421 * @brief Handler for TTI processing for configurations recieved from RRM.
425 * Function: rgSCHGomTtiHndlr
427 * This API does TTI processing for configurations recieved from RRM.
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.
437 * @param[in] RgSchCellCb *cell
442 S16 rgSCHGomTtiHndlr(RgSchCellCb *cell,SpId spId)
444 RgSchCfgElem *cfgElem;
445 Inst inst= cell->instIdx;
447 /* Dequeue from current config list */
448 while ((cfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
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));
459 /* Handle config requests from pending config list */
460 while((cfgElem = rgSCHDbmGetPndngRgrCfgElemByKey(cell, cell->crntTime)) != NULLP)
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));
476 * @brief Handler to handle configuration request from RRM to MAC.
480 * Function: rgSCHGomHndlCfgReq
482 * This API handles processing for configuration request from RRM to MAC.
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.
490 * @param[in] RgSchCb *instCb
491 * @param[in] SpId spId
492 * @param[in] RgrCfg *cfg
493 * @param[out] RgSchErrInfo *errInfo
498 static S16 rgSCHGomHndlCfgReq(RgSchCb *instCb,SpId spId,RgrCfg *cfg,RgSchErrInfo *errInfo)
501 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
502 Inst inst = (instCb->rgSchInit.inst );
505 errInfo->errType = RGSCHERR_GOM_CFG_REQ;
507 /* Validate and process the configuration request */
508 switch (cfg->cfgType)
512 ret = rgSCHCfgVldtRgrCellCfg(inst, &cfg->u.cellCfg, cell, errInfo);
515 RLOG1(L_ERROR,"Rgr Cell configuration "
516 "validation FAILED: Cell %d", cfg->u.cellCfg.cellId);
519 ret = rgSCHCfgRgrCellCfg(instCb, spId, &cfg->u.cellCfg, errInfo);
523 case RGR_SCELL_UE_CFG:
525 ret = rgSCHCfgVldtRgrUeCfg(inst, &cfg->u.ueCfg, &cell, errInfo);
528 RLOG1(L_ERROR,"Ue configuration validation"
529 " FAILED: CRNTI:%d", cfg->u.ueCfg.crnti);
532 ret = rgSCHCfgRgrUeCfg(cell, &cfg->u.ueCfg, errInfo);
537 ret = rgSCHCfgVldtRgrLcCfg(inst, &cfg->u.lchCfg, &cell, &ue, errInfo);
540 RLOG1(L_ERROR,"LC configuration validation "
541 "FAILED: LCID:%d", cfg->u.lchCfg.lcId);
544 ret = rgSCHCfgRgrLchCfg(cell, ue, &cfg->u.lchCfg, errInfo);
549 ret = rgSCHCfgVldtRgrLcgCfg(inst, &cfg->u.lcgCfg, &cell, &ue, errInfo);
552 RLOG1(L_ERROR,"LCG configuration validation "
553 "FAILED: LCGID:%d", cfg->u.lcgCfg.ulInfo.lcgId);
556 ret = rgSCHCfgRgrLcgCfg(cell, ue, &cfg->u.lcgCfg, errInfo);
561 ret = rgSCHCfgVldtRgrSchedEnbCfg(inst, &cfg->u.schedEnbCfg, errInfo);
564 RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCH ENB configuration validation "
568 ret = rgSCHCfgRgrSchedEnbCfg(inst, spId, &cfg->u.schedEnbCfg, errInfo);
573 #if(ERRCLASS & ERRCLS_INT_PAR)
574 RLOG1(L_ERROR,"Should never come here: "
575 "cfgType %d", cfg->cfgType);
582 } /* rgSCHGomHndlCfgReq */
586 * @brief Handler to handle re-configuration request from RRM to MAC.
590 * Function: rgSCHGomHndlSCellActDeactReq
592 * This API handles processing for SCell Activation Request from RRM to SCH.
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
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
608 static S16 rgSCHGomHndlSCellActDeactReq(RgSchCb *instCb,SpId spId,RgrSCellActDeactEvnt *sCellActDeactEvnt,RgSchErrInf *errInfo,uint8_t action)
610 RgSchUeCb *ue = NULLP;
612 uint16_t sCellIdx = 0;
613 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
614 Inst inst = (instCb->rgSchInit.inst);
616 RGSCHDBGPRM(inst,(rgSchPBuf(inst), "Processing RGR SCell Actication request:"
617 "%d\n", sCellActDeactEvnt->crnti));
619 errInfo->errType = RGSCHERR_GOM_SCELL_REQ;
622 if ((ue = rgSCHDbmGetUeCb(cell, sCellActDeactEvnt->crnti)) == NULLP)
624 RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]UE: does not exist\n",
625 sCellActDeactEvnt->crnti));
629 for(idx = 0; idx < sCellActDeactEvnt->numOfSCells; idx++)
631 sCellIdx = sCellActDeactEvnt->sCellActDeactInfo[idx].sCellIdx;
633 if (ROK != (rgSCHSCellTrigActDeact(cell, ue, sCellIdx, action)))
635 RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCell Actication failed"
636 "for UE [%d] with SCellIdx [%d]\n",
637 sCellActDeactEvnt->crnti, idx));
643 RGSCHDBGINFO(inst,(rgSchPBuf(inst), "RGR Reconfiguration processed\n"));
645 } /* rgSCHGomHndlSCellActDeactReq */
649 * @brief Handler to handle re-configuration request from RRM to MAC.
653 * Function: rgSCHGomHndlRecfgReq
655 * This API handles processing for re-configuration request from RRM to MAC.
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.
663 * @param[in] RgSchCb *instCb
664 * @param[in] SpId spId
665 * @param[in] RgrRecfg *recfg
666 * @param[out] RgSchErrInfo *errInfo
671 static S16 rgSCHGomHndlRecfgReq(RgSchCb *instCb,SpId spId,RgrRecfg *recfg,RgSchErrInfo *errInfo)
673 RgSchUeCb *ue = NULLP;
674 RgSchDlLcCb *dlLc = NULLP; /* PURIFY_FIX:UMR */
676 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
677 Inst inst = (instCb->rgSchInit.inst );
679 errInfo->errType = RGSCHERR_GOM_RECFG_REQ;
681 /* Validate and process the re-configuration request */
682 switch (recfg->recfgType)
686 ret = rgSCHCfgVldtRgrCellRecfg(inst, &recfg->u.cellRecfg, &cell,
690 RLOG_ARG0(L_ERROR,DBG_CELLID,recfg->u.cellRecfg.cellId,"Rgr Cell Recfg Validation "
694 ret = rgSCHCfgRgrCellRecfg(cell, &recfg->u.cellRecfg, errInfo);
698 case RGR_SCELL_UE_CFG:
700 ret = rgSCHCfgVldtRgrUeRecfg(inst, &recfg->u.ueRecfg, &cell, &ue, errInfo);
703 RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.ueRecfg.cellId,"Ue Recfg Validation FAILED"
704 "OLD CRNTI:%d",recfg->u.ueRecfg.oldCrnti);
707 ret = rgSCHCfgRgrUeRecfg(cell, ue, &recfg->u.ueRecfg, errInfo);
712 ret = rgSCHCfgVldtRgrLchRecfg(inst, &recfg->u.lchRecfg, &cell, &ue,
716 RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lchRecfg.cellId,"Lc Recfg Validation FAILED"
717 "LCID:%d",recfg->u.lchRecfg.lcId);
720 ret = rgSCHCfgRgrLchRecfg(cell, ue, dlLc, &recfg->u.lchRecfg, errInfo);
725 ret = rgSCHCfgVldtRgrLcgRecfg(inst, &recfg->u.lcgRecfg, cell, &ue,
729 RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lcgRecfg.cellId, "Lcg Recfg Validation FAILED"
730 "LCGID:%d",recfg->u.lcgRecfg.ulRecfg.lcgId);
733 ret = rgSCHCfgRgrLcgRecfg(cell, ue, &recfg->u.lcgRecfg, errInfo);
738 #if(ERRCLASS & ERRCLS_INT_PAR)
739 RLOG1(L_ERROR,"Should never come here: recfgType %d", recfg->recfgType);
746 } /* rgSCHGomHndlRecfgReq */
749 * @brief Handler to handle UE reset request from RRM to Scheduler.
753 * Function: rgSCHGomHndlResetReq
755 * This API handles processing for UE reset request from RRM to Scheduler.
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.
763 * @param[in] RgrRst *rstInfo
764 * @param[out] RgSchErrInfo *errInfo
769 static S16 rgSCHGomHndlResetReq(RgSchCb *instCb,SpId spId,RgrRst *reset,RgSchErrInfo *errInfo)
772 RgSchCellCb *cell= instCb->rgrSap[spId].cell;
773 Inst inst = (instCb->rgSchInit.inst );
774 RgSchUeCb *ue = NULLP;
776 errInfo->errType = RGSCHERR_GOM_RESET_REQ;
778 /* Validate and process the UE reset request */
779 ret = rgSCHCfgVldtRgrUeReset(inst, reset, cell, &ue, errInfo);
782 RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset Validation FAILED"
783 "CRNTI:%d",reset->crnti);
787 ret = rgSCHCfgRgrUeReset(cell, ue, reset, errInfo);
790 RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset FAILED"
791 "CRNTI:%d",reset->crnti);
796 } /* rgSCHGomHndlResetReq */
800 * @brief Handler for processing Cell/Ue/Logical channel delete request
805 * Function: rgSCHGomHndlDelReq
807 * This API handles processing of delete request from RRM to MAC.
810 * - Fetch corresponding control block and pass it to CFG module.
811 * - If control block does not exist, FAIL.
813 * @param[in] RgSchCb *instCb
814 * @param[in] SpId spId
815 * @param[in] RgrDel *del
816 * @param[out] RgSchErrInfo *errInfo
821 static S16 rgSCHGomHndlDelReq(RgSchCb *instCb,SpId spId,RgrDel *del,RgSchErrInfo *errInfo)
826 Inst inst = (instCb->rgSchInit.inst);
828 volatile uint32_t startTime=0;
830 errInfo->errType = RGSCHERR_GOM_DEL_REQ;
832 if(instCb->rgrSap[spId].cell == NULLP)
834 RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"Cell doesnt exist");
838 /* Process the delete request */
839 switch (del->delType)
843 ret = rgSCHCfgRgrCellDel(instCb->rgrSap[spId].cell, del, errInfo);
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;
850 instCb->rgrSap[spId].cell = NULLP;
851 instCb->tfuSap[spId].cell = NULLP;
856 case RGR_SCELL_UE_CFG:
860 SStartTask(&startTime, PID_SCH_UE_DEL);
862 ret = rgSCHCfgRgrUeDel(instCb->rgrSap[spId].cell, del, errInfo);
865 SStopTask(startTime, PID_SCH_UE_DEL);
871 ret = rgSCHCfgRgrLcDel(instCb->rgrSap[spId].cell, del, errInfo);
876 ret = rgSCHCfgRgrLcgDel(instCb->rgrSap[spId].cell, del, errInfo);
881 #if(ERRCLASS & ERRCLS_INT_PAR)
882 RLOG1(L_ERROR,"Should never come here: delType %d", del->delType);
889 } /* rgSCHGomHndlDelReq */
894 /***********************************************************
896 * Func : rgSCHGomGetCellIdFrmCfgReq
900 * - Processing Steps:
901 * - Retrieves the cell Id for a config request.
903 * @param[in] RgrCfgReqInfo *rgrCfgReq
904 * @param[out] CmLteCellId *cellId
905 * Ret : ROK on fetching cellId
910 * File : rg_sch_gom.c
912 **********************************************************/
913 static S16 rgSCHGomGetCellIdFrmCfgReq(RgrCfgReqInfo *rgrCfgReq,CmLteCellId *cellId)
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)
923 if (rgrCfgReq->u.recfgInfo.recfgType ==RGR_CELL_CFG)
925 *cellId = rgrCfgReq->u.recfgInfo.u.cellRecfg.cellId;
927 else if ((rgrCfgReq->u.recfgInfo.recfgType == RGR_SCELL_UE_CFG) ||
928 (rgrCfgReq->u.recfgInfo.recfgType == RGR_UE_CFG))
930 *cellId = rgrCfgReq->u.recfgInfo.u.ueRecfg.cellId;
932 else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCH_CFG)
934 *cellId = rgrCfgReq->u.recfgInfo.u.lchRecfg.cellId;
936 else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCG_CFG)
938 *cellId = rgrCfgReq->u.recfgInfo.u.lcgRecfg.cellId;
950 } /* End of Switch */
953 } /* rgSCHGomGetCellIdFrmCfgReq */
957 * @brief Handler to handle SI configuration request from RRM to MAC.
961 * Function: rgSCHGomHndlSiCfg
963 * This API handles processing for SI configuration request from RRM to MAC.
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.
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
981 S16 rgSCHGomHndlSiCfg(Region reg,Pool pool,RgSchCb *instCb,SpId spId,RgrCfgTransId transId,RgrSiCfgReqInfo *cfgReqInfo)
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;
994 /* check if cell does not exists */
995 if (((uint8_t *)cell == NULLP) || (cell->cellId != cfgReqInfo->cellId))
997 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Cell Control block does not exist"
999 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1000 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1002 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1006 /*Validate the received SI configuration */
1007 ret = rgSCHCfgVldtRgrSiCfg(inst, cfgReqInfo, cell, &errInfo);
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));
1015 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1018 /*ccpu00140789: Stopping SI scheduling*/
1019 if(RGR_SI_STOP == cfgReqInfo->cfgType)
1021 if((cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si != NULLP)&&
1022 (cell->siCb.siArray[cfgReqInfo->siId-1].si != NULLP))
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)
1029 RGSCH_FREE_MSG(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si);
1030 cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
1032 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1034 cfmStatus = RGR_CFG_CFM_OK;
1035 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1040 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1042 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
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
1053 if ( RGR_SI_CFG_TYPE_MIB != cfgReqInfo->cfgType )
1055 SFndLenMsg(cfgReqInfo->pdu, &msgLen);
1057 /* check if the application pdu matches a tb size */
1058 tbSz = rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs);
1060 if ( tbSz != (msgLen*8) )
1062 MsgLen nmPadBytes = 0;
1063 Data* padding = NULLP;
1065 /* need to add padding bytes */
1066 nmPadBytes = (tbSz - (msgLen*8))/8;
1068 if ( SGetSBuf(reg,pool,&padding,nmPadBytes) != ROK)
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));
1074 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1079 memset(padding,0,nmPadBytes);
1081 #ifdef MS_MBUF_CORRUPTION
1082 MS_BUF_ADD_ALLOC_CALLER();
1084 if ( SAddPstMsgMult((Data*)padding,nmPadBytes,cfgReqInfo->pdu) != ROK)
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));
1090 SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1092 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1096 SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1098 }/* if (tbSz != ...*/
1099 }/* if (RGR_SI_CFG_TYPE_SI...*/
1101 /*Set the received pdu at the appropriate place */
1102 switch(cfgReqInfo->cfgType)
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,
1111 case RGR_SI_CFG_TYPE_SIB1_PWS:
1113 SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1114 ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1117 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1119 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1120 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1122 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
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);
1134 case RGR_SI_CFG_TYPE_SIB1:
1135 SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1136 ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1139 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1141 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1142 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1144 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1148 RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1,
1149 cell->siCb.newSiInfo.sib1Info.sib1,
1150 cfgReqInfo->pdu, cell->siCb.siBitMask,
1154 case RGR_SI_CFG_TYPE_SI: /* SI CFG TYPE SI */
1155 SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1156 ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,
1160 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1162 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1163 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1165 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1169 /* Si recfg, where numSi changes */
1170 if (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD)
1172 Buffer **newSiPdu = &cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si;
1173 if(*newSiPdu != NULLP)
1175 RGSCH_FREE_MSG(*newSiPdu);
1177 *newSiPdu = (Buffer *)cfgReqInfo->pdu;
1178 cell->siCb.siBitMask |= RGSCH_SI_SI_UPD;
1180 else /* Initial Si cfg or si recfg where numSi did not change */
1183 /* Initial Si cfg */
1184 if (cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si == NULLP)
1186 cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
1187 cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1188 bitMask = RGSCH_SI_DFLT;
1192 bitMask = RGSCH_SI_SI_UPD;
1195 RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si,
1196 cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si,
1198 cell->siCb.siBitMask, bitMask);
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,
1208 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1210 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1211 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1213 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
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,
1221 cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1224 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Invalid cfgType "
1226 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1227 SPutSBuf(reg, pool, (Data *)cfgReqInfo,
1228 (Size)sizeof(*cfgReqInfo));
1230 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1235 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1237 cfmStatus = RGR_CFG_CFM_OK;
1238 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1242 } /* rgSCHGomHndlSiCfg */
1246 * @brief Handler to handle Warning SI configuration request from RRM to MAC.
1250 * Function: rgSCHGomHndlWarningSiCfg
1252 * This API handles processing for Warning SI configuration request from
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
1265 S16 rgSCHGomHndlWarningSiCfg
1271 RgrCfgTransId transId,
1272 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
1275 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
1276 uint8_t cfmStatus = RGR_CFG_CFM_NOK;
1278 uint8_t siId = warningSiCfgReqInfo->siId;
1279 uint8_t j, mcs=0, nPrb=0;
1280 RgSchWarningSiSeg *warningSiMsg;
1281 RgSchWarningSiPdu *pduNode;
1284 Bool freeNodeFound = FALSE;
1285 uint16_t siWinSize = 0;
1286 uint16_t minPeriod = 0;
1288 uint8_t isEmtc = warningSiCfgReqInfo->emtcEnable;
1294 rgSchEmtcGetSiWinPerd(cell, &siWinSize, &minPeriod);
1299 siWinSize = cell->siCfg.siWinSize;
1300 minPeriod = cell->siCfg.minPeriodicity;
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)))
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,
1319 /* Search for free index in WarningSi */
1320 for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1322 if((cell->siCb.warningSi[idx].siId == 0 ||
1323 cell->siCb.warningSi[idx].siId == warningSiCfgReqInfo->siId))
1325 warningSiMsg = (RgSchWarningSiSeg *)&cell->siCb.warningSi[idx].warningSiMsg;
1327 /* Search for free SI node */
1328 /* ccpu00136659: CMAS ETWS design changes */
1329 if (warningSiMsg->segLstCp.first == NULLP) /* Free SI Node */
1331 warningSiMsg->transId = transId;
1332 pduNode = (RgSchWarningSiPdu *)&cell->siCb.warningSi[idx].
1333 warningSiMsg.pduNode;
1334 CM_LLIST_FIRST_NODE(&warningSiCfgReqInfo->siPduLst, node);
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
1342 while((node != NULLP) && (j < RGR_MAX_WARNING_SI_SEG))
1345 pduNode[j].pdu = (Buffer *)node->node;
1346 if(pduNode[j].pdu != NULLP)
1348 SFndLenMsg(pduNode[j].pdu, &msgLen);
1349 /*Get the nPrb and mcs parametr values */
1351 if (rgSCHEmtcUtlGetAllwdCchTbSzForSI(msgLen*8) != (msgLen*8))
1353 if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
1357 RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,
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);
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];
1384 /* ccpu00132385- nodes in received SI config linked list should
1385 * be freed after processing the config.*/
1386 while(warningSiCfgReqInfo->siPduLst.first != NULLP)
1388 node = warningSiCfgReqInfo->siPduLst.first;
1389 cmLListDelFrm(&(warningSiCfgReqInfo->siPduLst), node);
1390 SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
1394 cell->siCb.warningSi[idx].siId = warningSiCfgReqInfo->siId;
1395 cell->siCb.warningSi[idx].idx = idx;
1399 rgSCHEmtcWarningSiCfg(cell,warningSiCfgReqInfo,idx);
1404 cell->siCb.siArray[warningSiCfgReqInfo->siId-1].si =
1405 &cell->siCb.warningSi[idx];
1406 cell->siCb.siArray[warningSiCfgReqInfo->siId-1].isWarningSi =
1409 freeNodeFound = TRUE;
1415 if (freeNodeFound == FALSE)
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,
1427 SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1428 sizeof(RgrWarningSiCfgReqInfo));
1429 warningSiCfgReqInfo = NULLP;
1435 * @brief Handler to handle SI Stop request from RRM to MAC.
1439 * Function: rgSCHGomHndlWarningSiStopReq
1441 * This API handles processing for SI stop request from RRM to MAC.
1443 * @param[in] Region reg
1444 * @param[in] Pool pool
1445 * @param[in] RgSchCb *instCb
1446 * @param[in] SpId siId
1449 Void rgSCHGomHndlWarningSiStopReq(Region reg,Pool pool,RgSchCb *instCb,uint8_t siId,RgrCfgTransId transId,SpId spId)
1451 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
1454 RgSchWarningSiPdu *warningSiPdu;
1457 for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1459 if(cell->siCb.warningSi[idx].siId == siId)
1461 if ((cmMemcmp ((uint8_t *)&cell->siCb.warningSi[idx].warningSiMsg.transId,
1462 (uint8_t *)&transId, sizeof(RgrCfgTransId))) == 0)
1464 /* ccpu00136659: CMAS ETWS design changes */
1465 CM_LLIST_FIRST_NODE(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
1466 while(node != NULLP)
1468 /* On receiving the warning stop message, remove one by one
1469 * each PDU from the warning SI list
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);
1485 #endif/*RGR_SI_SCH */
1487 /* LTE_ADV_FLAG_REMOVED_START */
1490 * @brief This function sets the Phigh range for CC users corresponding to the CC Pool
1493 * Function: rgSchUpdtRNTPInfo
1495 * Invoked by: rgSCHGomHndlLoadInf
1497 * @param[in] RgSchCellCb* cell
1498 * @param[in] RgSubFrm* subFrm
1499 * @param[in] RgrLoadInfReqInfo *loadInfReq
1503 S16 rgSchUpdtRNTPInfo(RgSchCellCb *cell,RgSchDlSf *sf,RgrLoadInfReqInfo *loadInfReq)
1505 /* Initialise the variables */
1506 RgSchSFRPoolInfo *sfrCCPool;
1511 l = &sf->sfrTotalPoolInfo.ccPool;
1513 /*Get the first node from the CC Pool*/
1514 n = cmLListFirst(l);
1517 sfrCCPool = (RgSchSFRPoolInfo*)n->node;
1518 if (sfrCCPool->poolendRB == loadInfReq->rgrCcPHighEndRb)
1520 sfrCCPool->pwrHiCCRange.endRb = loadInfReq->rgrCcPHighEndRb;
1521 sfrCCPool->pwrHiCCRange.startRb = loadInfReq->rgrCcPHighStartRb;
1532 * @brief Handler to handle LOAD INF request from RRM to MAC.
1536 * Function: rgSCHGomHndlLoadInf
1538 * This API handles processing for LOAD INF request from RRM to MAC.
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.
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
1555 S16 rgSCHGomHndlLoadInf(Region reg,Pool pool,RgSchCb *instCb,SpId spId,RgrCfgTransId transId,RgrLoadInfReqInfo *loadInfReq)
1558 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
1559 Inst inst = (instCb->rgSchInit.inst );
1560 RgSchErrInfo errInfo;
1563 /* check if cell does not exists */
1564 if (((uint8_t *)cell == NULLP) || (cell->cellId != loadInfReq->cellId))
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));
1572 if (cell->lteAdvCb.dsfrCfg.status == RGR_DISABLE)
1574 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHGomHndlLoadInf(): DSFR Feature not enabled");
1575 SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1578 /* Validate the received LOAD INF Configuration */
1579 ret = rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, &errInfo);
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));
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++)
1591 if((rgSchUpdtRNTPInfo(cell, cell->subFrms[i], loadInfReq) != ROK))
1597 SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1601 } /* rgSCHGomHndlLoadInf */
1602 /* LTE_ADV_FLAG_REMOVED_END */
1604 /**********************************************************************
1607 **********************************************************************/