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 "envopt.h" /* environment options */
42 #include "envdep.h" /* environment dependent */
43 #include "envind.h" /* environment independent */
44 #include "gen.h" /* general layer */
45 #include "ssi.h" /* system service interface */
46 #include "cm_hash.h" /* common hash list */
47 #include "cm_mblk.h" /* common memory link list library */
48 #include "cm_llist.h" /* common linked list library */
49 #include "cm_err.h" /* common error */
50 #include "cm_lte.h" /* common LTE */
55 #include "rg_sch_inf.h"
57 #include "rg_sch_err.h"
58 #include "rl_interface.h"
59 #include "rl_common.h"
61 /* header/extern include files (.x) */
62 #include "gen.x" /* general layer */
63 #include "ssi.x" /* system service interface */
64 #include "cm5.x" /* common timers */
65 #include "cm_lib.x" /* common library */
66 #include "cm_hash.x" /* common hash list */
67 #include "cm_llist.x" /* common linked list library */
68 #include "cm_mblk.x" /* memory management */
69 #include "cm_tkns.x" /* common tokens */
70 #include "cm_lte.x" /* common LTE */
74 #include "rg_sch_inf.x"
78 PRIVATE S16 rgSCHGomHndlCfgReq ARGS((RgSchCb *instCb, SpId spId,
79 RgrCfg *cfg, RgSchErrInfo *errInfo));
80 PRIVATE S16 rgSCHGomHndlRecfgReq ARGS((RgSchCb *instCb, SpId spId,
81 RgrRecfg *recfg, RgSchErrInfo *errInfo));
82 PRIVATE S16 rgSCHGomHndlResetReq ARGS((RgSchCb *instCb,SpId spId,RgrRst *reset,
83 RgSchErrInfo *errInfo));
84 PRIVATE S16 rgSCHGomGetCellIdFrmCfgReq ARGS((RgrCfgReqInfo *rgrCfgReq,
85 CmLteCellId *cellId));
86 PRIVATE S16 rgSCHGomCfgReq ARGS((Region reg, Pool pool, RgSchCb *instCb,
87 RgrCfgTransId transId, RgrCfgReqInfo *cfgReqInfo));
88 PRIVATE S16 rgSCHGomEnqCfgReq ARGS((Region reg, Pool pool, RgSchCellCb *cell,
89 RgrCfgTransId transId, RgrCfgReqInfo *rgrCfgReq));
90 PRIVATE S16 rgSCHGomHndlDelReq ARGS((RgSchCb *instCb,SpId spId,
91 RgrDel *del,RgSchErrInfo *errInfo));
93 PRIVATE S16 rgSCHGomHndlSCellActDeactReq ARGS((RgSchCb *instCb, SpId spId,
94 RgrSCellActDeactEvnt *sCellActDeactEvnt, RgSchErrInfo *errInfo, U8 action));
97 EXTERN S16 rgSchEmtcGetSiWinPerd ARGS((
102 extern S16 rgSCHEmtcUtlCalMcsAndNPrb
110 EXTERN S32 rgSCHEmtcUtlGetAllwdCchTbSzForSI ARGS(
115 EXTERN Void rgSCHEmtcWarningSiCfg ARGS(
118 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo,
128 /* forward references */
133 * @brief Handler for config request from RRM to Schedular.
137 * Function: rgSCHGomHndlCfg
139 * This API is called from schedulers UIM and it handles config request
140 * from RRM to Scheduler.
143 * - If the request is for the inactive cell,
144 * - Handle request.Call rgSCHGomCfgReq.
146 * - Enqueue the request. Call rgSCHGomEnqCfgReq.
148 * @param[in] Pst *pst
149 * @param[in] RgSchCb *instCb
150 * @param[in] RgrCfgTransId transId
151 * @param[in] RgrCfgReqInfo *cfgReqInfo
157 PUBLIC S16 rgSCHGomHndlCfg
161 RgrCfgTransId transId,
162 RgrCfgReqInfo *cfgReqInfo
165 PUBLIC S16 rgSCHGomHndlCfg(pst, instCb, transId, cfgReqInfo)
168 RgrCfgTransId transId;
169 RgrCfgReqInfo *cfgReqInfo;
175 RgSchCellCb *cell = NULLP;
176 U8 cfmStatus = RGR_CFG_CFM_NOK;
178 Inst inst = (instCb->rgSchInit.inst );
181 TRC2(rgSCHGomHndlCfg);
182 /* Apply the configuration for Cell Configuration or Delete */
183 if (cfgReqInfo->action != RGR_RECONFIG)
185 ret = rgSCHGomCfgReq (pst->region, pst->pool, instCb,
186 transId, cfgReqInfo);
190 /* Fetch the cell Id for the recieved request */
191 if((rgSCHGomGetCellIdFrmCfgReq(cfgReqInfo, &cellId)) != ROK)
193 RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Action.Config Type Error");
195 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
196 (Size)sizeof(*cfgReqInfo));
198 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
201 /* Extract the cell and Enquee Config Request */
202 if(NULLP != instCb->rgrSap[spId].cell)
204 if(cellId != instCb->rgrSap[spId].cell->cellId)
206 RLOG_ARG2(L_ERROR,DBG_CELLID,cellId, "Cell with Id %d already exists "
207 "on sap %d", instCb->rgrSap[spId].cell->cellId, spId);
209 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
210 (Size)sizeof(*cfgReqInfo));
212 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
215 cell = instCb->rgrSap[spId].cell;
217 /* Enqueue the configuration */
218 ret = rgSCHGomEnqCfgReq(pst->region, pst->pool, cell, transId, cfgReqInfo);
221 RLOG_ARG0(L_ERROR,DBG_CELLID,cellId, "rgSCHGomHndlCfg: Enqueuing CfgReq "
224 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
225 (Size)sizeof(*cfgReqInfo));
227 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
233 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
234 (Size)sizeof(*cfgReqInfo));
236 schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus);
239 }/* rgSCHGomHndlCfg */
243 * @brief Handler to handle config request from RRM to Scheduler.
247 * Function: rgSCHGomCfgReq
249 * This API handles processing for config request from RRM to Scheduler.
252 * - If Configuration request, call rgSCHGomHndlCfgReq.
253 * - Else if Reconfiguration request, call rgSCHGomHndlRecfgReq.
254 * - If successful, send configuration confirm to RRM.
255 * Call schSendCfgCfm else FAIL.
257 * @param[in] Region reg
258 * @param[in] Pool pool
259 * @param[in] RgSchCb *instCb
260 * @param[in] RgrCfgTransId transId
261 * @param[in] RgrCfgReqInfo *cfgReqInfo
267 PRIVATE S16 rgSCHGomCfgReq
272 RgrCfgTransId transId,
273 RgrCfgReqInfo *cfgReqInfo
276 PRIVATE S16 rgSCHGomCfgReq(reg, pool, instCb, transId, cfgReqInfo)
280 RgrCfgTransId transId;
281 RgrCfgReqInfo *cfgReqInfo;
285 U8 cfmStatus = RGR_CFG_CFM_OK;
287 RgSchErrInfo errInfo;
289 Inst inst = (instCb->rgSchInit.inst );
291 TRC2(rgSCHGomCfgReq);
293 printf("\n AT MAC rgSCHGomCfgReq \n");
296 /* Process Config/Reconfig/Delete request from RRM */
297 switch (cfgReqInfo->action)
301 ret = rgSCHGomHndlCfgReq(instCb, spId,
302 &cfgReqInfo->u.cfgInfo, &errInfo);
307 ret = rgSCHGomHndlRecfgReq(instCb, spId,
308 &cfgReqInfo->u.recfgInfo, &errInfo);
313 ret = rgSCHGomHndlResetReq(instCb, spId,
314 &cfgReqInfo->u.rstInfo, &errInfo);
319 ret = rgSCHGomHndlDelReq(instCb, spId,
320 &cfgReqInfo->u.delInfo, &errInfo);
325 case RGR_SCELL_DEACT:
326 case RGR_SCELL_READY:
328 ret = rgSCHGomHndlSCellActDeactReq(instCb, spId,
329 &cfgReqInfo->u.sCellActDeactEvnt, &errInfo, cfgReqInfo->action);
335 RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "Invalid configuration "
336 "action %d", cfgReqInfo->action);
339 } /* End of switch */
343 cfmStatus = RGR_CFG_CFM_NOK;
346 SPutSBuf(reg, pool, (Data *)cfgReqInfo,
347 (Size)sizeof(*cfgReqInfo));
350 printf("\n AT MAC sending RGR cfg cfm \n");
353 /* Send back confirmation status to RRM */
354 schSendCfgCfm(reg, pool, transId, cfmStatus);
356 printf("\n AT MAC RGR cfg cfm sent\n");
360 } /* rgSCHGomCfgReq */
364 * @brief Handler to enqueuing config request from RRM to Scheduler.
368 * Function: rgSCHGomEnqCfgReq
370 * This API enqueues config request from RRM to MAC.
373 * - Allocate the configuration request element.
374 * - Copy the contents of the recieved configuration to config request
375 * element and free the recieved configuration pointer.
376 * - If the configuration is without activation time,
377 * - Enqueue the request in crntRgrCfgLst of the cell at the end of
380 * - Enqueue the request in pndngRgrCfgLst of the cell.
382 * @param[in] Region reg,
383 * @param[in] Pool pool
384 * @param[in] RgSchCellCb *cell
385 * @param[in] RgrCfgTransId transId
386 * @param[in] RgrCfgReqInfo *rgrCfgReq
392 PRIVATE S16 rgSCHGomEnqCfgReq
397 RgrCfgTransId transId,
398 RgrCfgReqInfo *rgrCfgReq
401 PRIVATE S16 rgSCHGomEnqCfgReq(reg, pool, cell, transId, rgrCfgReq)
405 RgrCfgTransId transId;
406 RgrCfgReqInfo *rgrCfgReq;
411 RgSchCfgElem *rgrCfgElem = NULLP;
412 CmLteTimingInfo actvTime;
413 Inst inst = cell->instIdx;
415 TRC2(rgSCHGomEnqCfgReq);
417 /* Allocate memory for config Element */
418 ret = rgSCHUtlAllocSBuf(inst, (Data **)&rgrCfgElem, sizeof(RgSchCfgElem));
419 if ((ret != ROK) || ((U8 *)rgrCfgElem == NULLP))
424 /* Initialize the configuration element */
425 cmMemcpy((U8*)rgrCfgElem->rgrCfg.transId.trans,(U8*)transId.trans,
426 sizeof(transId.trans));
427 rgrCfgElem->rgrCfg.reg = reg;
428 rgrCfgElem->rgrCfg.pool = pool;
429 rgrCfgElem->rgrCfg.rgrCfgReq = rgrCfgReq;
430 rgrCfgElem->cfgReqLstEnt.prev = NULLP;
431 rgrCfgElem->cfgReqLstEnt.next = NULLP;
432 rgrCfgElem->cfgReqLstEnt.node = (PTR )rgrCfgElem;
434 /* Add configuration element to current/pending cfgLst */
435 if (((rgrCfgReq->action == RGR_RECONFIG) &&
436 (rgrCfgReq->u.recfgInfo.recfgType == RGR_CELL_CFG) &&
437 (rgrCfgReq->u.recfgInfo.u.cellRecfg.recfgActvTime.pres == TRUE)))
441 rgrCfgReq->u.recfgInfo.u.cellRecfg.recfgActvTime.actvTime;
443 /* Check if the activation time is valid */
444 if (actvTime.sfn >= RGSCH_MAX_SFN
445 || actvTime.slot >= RGSCH_NUM_SUB_FRAMES_5G)
447 RLOG_ARG4(L_ERROR,DBG_CELLID,cell->cellId, "Invalid activation time for RGR "
448 "config request: activation sfn %d activation slot %d current "
449 "sfn %d current slot %d", actvTime.sfn, actvTime.slot,
450 cell->crntTime.sfn, cell->crntTime.slot);
451 /* ccpu00117052 - MOD - Passing double pointer
452 for proper NULLP assignment*/
453 rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
457 sfDiff = RGSCH_CALC_SF_DIFF(actvTime, cell->crntTime);
459 if (sfDiff > (RGR_ACTV_WIN_SIZE * RGSCH_NUM_SUB_FRAMES_5G))
461 RLOG_ARG4(L_ERROR,DBG_CELLID,cell->cellId,"Invalid activation time for RGR"
462 " config request: activation sfn %d activation slot %d "
463 "current sfn %d current slot %d", actvTime.sfn,
464 actvTime.slot, cell->crntTime.sfn, cell->crntTime.slot);
465 /* ccpu00117052 - MOD - Passing double pointer
466 for proper NULLP assignment*/
467 rgSCHUtlFreeSBuf(inst, (Data **)&rgrCfgElem, sizeof(*rgrCfgElem));
473 /* Add to pending cfgReqLst */
474 rgrCfgElem->actvTime = actvTime;
475 rgSCHDbmInsPndngRgrCfgElem(cell, rgrCfgElem);
476 /* Cfm to be sent only after applying request */
481 /* Add to current cfgReq list */
482 rgSCHDbmInsCrntRgrCfgElem(cell, rgrCfgElem);
483 /* Cfm to be sent only after applying request */
485 } /* rgSCHGomEnqCfgReq */
489 * @brief Handler for TTI processing for configurations recieved from RRM.
493 * Function: rgSCHGomTtiHndlr
495 * This API does TTI processing for configurations recieved from RRM.
498 * - It dequeues config request from the current configuration list.
499 * For each config request in the list:
500 * - Processes the request. Call rgSCHGomCfgReq.
501 * - It dequeues config request for the current tti from the pending
502 * configuration list. For each config request in the list:
503 * - Processes the request. Call rgSCHGomCfgReq.
505 * @param[in] RgSchCellCb *cell
511 PUBLIC S16 rgSCHGomTtiHndlr
517 PUBLIC S16 rgSCHGomTtiHndlr(cell, spId)
522 RgSchCfgElem *cfgElem;
523 Inst inst= cell->instIdx;
524 TRC2(rgSCHGomTtiHndlr);
526 /* Dequeue from current config list */
527 while ((cfgElem = rgSCHDbmGetNextCrntRgrCfgElem(cell, NULLP)) != NULLP)
529 rgSCHDbmDelCrntRgrCfgElem(cell, cfgElem);
530 rgSCHGomCfgReq(cfgElem->rgrCfg.reg,cfgElem->rgrCfg.pool,
531 &rgSchCb[inst], cfgElem->rgrCfg.transId,
532 cfgElem->rgrCfg.rgrCfgReq);
533 /* ccpu00117052 - MOD - Passing double pointer
534 for proper NULLP assignment*/
535 rgSCHUtlFreeSBuf(inst, (Data **)&cfgElem, sizeof(*cfgElem));
538 /* Handle config requests from pending config list */
539 while((cfgElem = rgSCHDbmGetPndngRgrCfgElemByKey(cell, cell->crntTime)) != NULLP)
541 rgSCHDbmDelPndngRgrCfgElem(cell, cfgElem);
542 rgSCHGomCfgReq(cfgElem->rgrCfg.reg, cfgElem->rgrCfg.pool,
543 &rgSchCb[inst], cfgElem->rgrCfg.transId,
544 cfgElem->rgrCfg.rgrCfgReq);
545 /* ccpu00117052 - MOD - Passing double pointer
546 for proper NULLP assignment*/
547 rgSCHUtlFreeSBuf(inst, (Data **)&cfgElem, sizeof(*cfgElem));
555 * @brief Handler to handle configuration request from RRM to MAC.
559 * Function: rgSCHGomHndlCfgReq
561 * This API handles processing for configuration request from RRM to MAC.
563 * - Processing Steps:
564 * - Validate configuration request parameters at CFG module.
565 * Call rgSCHCfgVldtRgrCellCfg for cell configuration.
566 * - If validated successfully, send configuration request to CFG.
567 * Call rgSCHCfgRgrCellCfg else FAIL.
569 * @param[in] RgSchCb *instCb
570 * @param[in] SpId spId
571 * @param[in] RgrCfg *cfg
572 * @param[out] RgSchErrInfo *errInfo
578 PRIVATE S16 rgSCHGomHndlCfgReq
583 RgSchErrInfo *errInfo
586 PRIVATE S16 rgSCHGomHndlCfgReq(instCb, spId, cfg, errInfo)
590 RgSchErrInfo *errInfo;
594 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
595 Inst inst = (instCb->rgSchInit.inst );
598 TRC2(rgSCHGomHndlCfgReq);
600 errInfo->errType = RGSCHERR_GOM_CFG_REQ;
602 /* Validate and process the configuration request */
603 switch (cfg->cfgType)
607 ret = rgSCHCfgVldtRgrCellCfg(inst, &cfg->u.cellCfg, cell, errInfo);
610 RLOG1(L_ERROR,"Rgr Cell configuration "
611 "validation FAILED: Cell %d", cfg->u.cellCfg.cellId);
614 ret = rgSCHCfgRgrCellCfg(instCb, spId, &cfg->u.cellCfg, errInfo);
618 case RGR_SCELL_UE_CFG:
620 ret = rgSCHCfgVldtRgrUeCfg(inst, &cfg->u.ueCfg, &cell, errInfo);
623 RLOG1(L_ERROR,"Ue configuration validation"
624 " FAILED: CRNTI:%d", cfg->u.ueCfg.crnti);
627 ret = rgSCHCfgRgrUeCfg(cell, &cfg->u.ueCfg, errInfo);
632 ret = rgSCHCfgVldtRgrLcCfg(inst, &cfg->u.lchCfg, &cell, &ue, errInfo);
635 RLOG1(L_ERROR,"LC configuration validation "
636 "FAILED: LCID:%d", cfg->u.lchCfg.lcId);
639 ret = rgSCHCfgRgrLchCfg(cell, ue, &cfg->u.lchCfg, errInfo);
644 ret = rgSCHCfgVldtRgrLcgCfg(inst, &cfg->u.lcgCfg, &cell, &ue, errInfo);
647 RLOG1(L_ERROR,"LCG configuration validation "
648 "FAILED: LCGID:%d", cfg->u.lcgCfg.ulInfo.lcgId);
651 ret = rgSCHCfgRgrLcgCfg(cell, ue, &cfg->u.lcgCfg, errInfo);
656 ret = rgSCHCfgVldtRgrSchedEnbCfg(inst, &cfg->u.schedEnbCfg, errInfo);
659 RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCH ENB configuration validation "
663 ret = rgSCHCfgRgrSchedEnbCfg(inst, spId, &cfg->u.schedEnbCfg, errInfo);
668 #if(ERRCLASS & ERRCLS_INT_PAR)
669 RLOG1(L_ERROR,"Should never come here: "
670 "cfgType %d", cfg->cfgType);
677 } /* rgSCHGomHndlCfgReq */
681 * @brief Handler to handle re-configuration request from RRM to MAC.
685 * Function: rgSCHGomHndlSCellActDeactReq
687 * This API handles processing for SCell Activation Request from RRM to SCH.
689 * - Processing Steps:
690 * - Validate sCell Actication request parameters at CFG module.
691 * - If validated successfully, send configuration request to CFG.
692 * - call activation function for each SCells configured
694 * @param[in] RgSchCb *instCb
695 * @param[in] SpId spId
696 * @param[in] RgrSCellActDeactEvnt *sCellActDeactEvnt
697 * @param[in] U8 action
698 * @param[out] RgSchErrInfo *errInfo
704 PRIVATE S16 rgSCHGomHndlSCellActDeactReq
708 RgrSCellActDeactEvnt *sCellActDeactEvnt,
709 RgSchErrInfo *errInfo,
713 PRIVATE S16 rgSCHGomHndlSCellActDeactReq(instCb, spId, sCellActDeactEvnt, errInfo, action)
716 RgrSCellActDeactEvnt *sCellActDeactEvnt;
717 RgSchErrInfo *errInfo;
721 RgSchUeCb *ue = NULLP;
724 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
725 Inst inst = (instCb->rgSchInit.inst);
727 TRC2(rgSCHGomHndlSCellActDeactReq);
728 RGSCHDBGPRM(inst,(rgSchPBuf(inst), "Processing RGR SCell Actication request:"
729 "%d\n", sCellActDeactEvnt->crnti));
731 errInfo->errType = RGSCHERR_GOM_SCELL_REQ;
734 if ((ue = rgSCHDbmGetUeCb(cell, sCellActDeactEvnt->crnti)) == NULLP)
736 RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "[%d]UE: does not exist\n",
737 sCellActDeactEvnt->crnti));
741 for(idx = 0; idx < sCellActDeactEvnt->numOfSCells; idx++)
743 sCellIdx = sCellActDeactEvnt->sCellActDeactInfo[idx].sCellIdx;
745 if (ROK != (rgSCHSCellTrigActDeact(cell, ue, sCellIdx, action)))
747 RGSCHDBGERR(inst,(rgSchPBuf(inst), "SCell Actication failed"
748 "for UE [%d] with SCellIdx [%d]\n",
749 sCellActDeactEvnt->crnti, idx));
755 RGSCHDBGINFO(inst,(rgSchPBuf(inst), "RGR Reconfiguration processed\n"));
757 } /* rgSCHGomHndlSCellActDeactReq */
761 * @brief Handler to handle re-configuration request from RRM to MAC.
765 * Function: rgSCHGomHndlRecfgReq
767 * This API handles processing for re-configuration request from RRM to MAC.
769 * - Processing Steps:
770 * - Validate re-configuration request parameters at CFG module.
771 * Call rgSCHCfgVldtRgrCellRecfg for cell re-configuration.
772 * - If validated successfully, send configuration request to CFG.
773 * Call rgSCHCfgRgrCellRecfg else FAIL.
775 * @param[in] RgSchCb *instCb
776 * @param[in] SpId spId
777 * @param[in] RgrRecfg *recfg
778 * @param[out] RgSchErrInfo *errInfo
784 PRIVATE S16 rgSCHGomHndlRecfgReq
789 RgSchErrInfo *errInfo
792 PRIVATE S16 rgSCHGomHndlRecfgReq(instCb, spId, recfg, errInfo)
796 RgSchErrInfo *errInfo;
799 RgSchUeCb *ue = NULLP;
800 RgSchDlLcCb *dlLc = NULLP; /* PURIFY_FIX:UMR */
802 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
803 Inst inst = (instCb->rgSchInit.inst );
805 TRC2(rgSCHGomHndlRecfgReq);
807 errInfo->errType = RGSCHERR_GOM_RECFG_REQ;
809 /* Validate and process the re-configuration request */
810 switch (recfg->recfgType)
814 ret = rgSCHCfgVldtRgrCellRecfg(inst, &recfg->u.cellRecfg, &cell,
818 RLOG_ARG0(L_ERROR,DBG_CELLID,recfg->u.cellRecfg.cellId,"Rgr Cell Recfg Validation "
822 ret = rgSCHCfgRgrCellRecfg(cell, &recfg->u.cellRecfg, errInfo);
826 case RGR_SCELL_UE_CFG:
828 ret = rgSCHCfgVldtRgrUeRecfg(inst, &recfg->u.ueRecfg, &cell, &ue, errInfo);
831 RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.ueRecfg.cellId,"Ue Recfg Validation FAILED"
832 "OLD CRNTI:%d",recfg->u.ueRecfg.oldCrnti);
835 ret = rgSCHCfgRgrUeRecfg(cell, ue, &recfg->u.ueRecfg, errInfo);
840 ret = rgSCHCfgVldtRgrLchRecfg(inst, &recfg->u.lchRecfg, &cell, &ue,
844 RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lchRecfg.cellId,"Lc Recfg Validation FAILED"
845 "LCID:%d",recfg->u.lchRecfg.lcId);
848 ret = rgSCHCfgRgrLchRecfg(cell, ue, dlLc, &recfg->u.lchRecfg, errInfo);
853 ret = rgSCHCfgVldtRgrLcgRecfg(inst, &recfg->u.lcgRecfg, cell, &ue,
857 RLOG_ARG1(L_ERROR,DBG_CELLID,recfg->u.lcgRecfg.cellId, "Lcg Recfg Validation FAILED"
858 "LCGID:%d",recfg->u.lcgRecfg.ulRecfg.lcgId);
861 ret = rgSCHCfgRgrLcgRecfg(cell, ue, &recfg->u.lcgRecfg, errInfo);
866 #if(ERRCLASS & ERRCLS_INT_PAR)
867 RLOG1(L_ERROR,"Should never come here: recfgType %d", recfg->recfgType);
874 } /* rgSCHGomHndlRecfgReq */
877 * @brief Handler to handle UE reset request from RRM to Scheduler.
881 * Function: rgSCHGomHndlResetReq
883 * This API handles processing for UE reset request from RRM to Scheduler.
885 * - Processing Steps:
886 * - Validate UE reset request parameters at CFG module.
887 * Call rgSCHCfgVldtRgrUeReset for UE reset.
888 * - If validated successfully, send UE reset request to CFG.
889 * Call rgSCHCfgRgrUeReset else FAIL.
891 * @param[in] RgrRst *rstInfo
892 * @param[out] RgSchErrInfo *errInfo
898 PRIVATE S16 rgSCHGomHndlResetReq
903 RgSchErrInfo *errInfo
906 PRIVATE S16 rgSCHGomHndlResetReq(instCb, spId, reset, errInfo)
910 RgSchErrInfo *errInfo;
914 RgSchCellCb *cell= instCb->rgrSap[spId].cell;
915 Inst inst = (instCb->rgSchInit.inst );
916 RgSchUeCb *ue = NULLP;
918 TRC2(rgSCHGomHndlResetReq);
921 errInfo->errType = RGSCHERR_GOM_RESET_REQ;
923 /* Validate and process the UE reset request */
924 ret = rgSCHCfgVldtRgrUeReset(inst, reset, cell, &ue, errInfo);
927 RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset Validation FAILED"
928 "CRNTI:%d",reset->crnti);
932 ret = rgSCHCfgRgrUeReset(cell, ue, reset, errInfo);
935 RLOG_ARG1(L_ERROR,DBG_CELLID,reset->cellId,"Rgr UE Reset FAILED"
936 "CRNTI:%d",reset->crnti);
941 } /* rgSCHGomHndlResetReq */
945 * @brief Handler for processing Cell/Ue/Logical channel delete request
950 * Function: rgSCHGomHndlDelReq
952 * This API handles processing of delete request from RRM to MAC.
955 * - Fetch corresponding control block and pass it to CFG module.
956 * - If control block does not exist, FAIL.
958 * @param[in] RgSchCb *instCb
959 * @param[in] SpId spId
960 * @param[in] RgrDel *del
961 * @param[out] RgSchErrInfo *errInfo
967 PRIVATE S16 rgSCHGomHndlDelReq
972 RgSchErrInfo *errInfo
975 PRIVATE S16 rgSCHGomHndlDelReq(instCb, spId, del, errInfo)
979 RgSchErrInfo *errInfo;
985 Inst inst = (instCb->rgSchInit.inst);
987 VOLATILE U32 startTime=0;
989 TRC2(rgSCHGomHndlDelReq);
991 errInfo->errType = RGSCHERR_GOM_DEL_REQ;
993 if(instCb->rgrSap[spId].cell == NULLP)
995 RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"Cell doesnt exist");
999 /* Process the delete request */
1000 switch (del->delType)
1004 ret = rgSCHCfgRgrCellDel(instCb->rgrSap[spId].cell, del, errInfo);
1007 /* TODO::Needs to be revisited after tti flow CaDev Start */
1008 U8 idx = (U8)((instCb->rgrSap[spId].cell->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
1009 instCb->cells[idx] = NULLP;
1011 instCb->rgrSap[spId].cell = NULLP;
1012 instCb->tfuSap[spId].cell = NULLP;
1017 case RGR_SCELL_UE_CFG:
1021 SStartTask(&startTime, PID_SCH_UE_DEL);
1023 ret = rgSCHCfgRgrUeDel(instCb->rgrSap[spId].cell, del, errInfo);
1026 SStopTask(startTime, PID_SCH_UE_DEL);
1032 ret = rgSCHCfgRgrLcDel(instCb->rgrSap[spId].cell, del, errInfo);
1037 ret = rgSCHCfgRgrLcgDel(instCb->rgrSap[spId].cell, del, errInfo);
1042 #if(ERRCLASS & ERRCLS_INT_PAR)
1043 RLOG1(L_ERROR,"Should never come here: delType %d", del->delType);
1050 } /* rgSCHGomHndlDelReq */
1055 /***********************************************************
1057 * Func : rgSCHGomGetCellIdFrmCfgReq
1061 * - Processing Steps:
1062 * - Retrieves the cell Id for a config request.
1064 * @param[in] RgrCfgReqInfo *rgrCfgReq
1065 * @param[out] CmLteCellId *cellId
1066 * Ret : ROK on fetching cellId
1067 * RFAILED on failure
1071 * File : rg_sch_gom.c
1073 **********************************************************/
1075 PRIVATE S16 rgSCHGomGetCellIdFrmCfgReq
1077 RgrCfgReqInfo *rgrCfgReq,
1081 PRIVATE S16 rgSCHGomGetCellIdFrmCfgReq(rgrCfgReq, cellId)
1082 RgrCfgReqInfo *rgrCfgReq;
1083 CmLteCellId *cellId;
1087 TRC2(rgSCHGomGetCellIdFrmCfgReq);
1090 /* Extract CellId depending on the action and Config Type in the Request
1091 * As of now this function is called for only re configuration so removed
1092 * othe CASES below if needed we can add them*/
1093 switch (rgrCfgReq->action)
1097 if (rgrCfgReq->u.recfgInfo.recfgType ==RGR_CELL_CFG)
1099 *cellId = rgrCfgReq->u.recfgInfo.u.cellRecfg.cellId;
1101 else if ((rgrCfgReq->u.recfgInfo.recfgType == RGR_SCELL_UE_CFG) ||
1102 (rgrCfgReq->u.recfgInfo.recfgType == RGR_UE_CFG))
1104 *cellId = rgrCfgReq->u.recfgInfo.u.ueRecfg.cellId;
1106 else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCH_CFG)
1108 *cellId = rgrCfgReq->u.recfgInfo.u.lchRecfg.cellId;
1110 else if (rgrCfgReq->u.recfgInfo.recfgType == RGR_LCG_CFG)
1112 *cellId = rgrCfgReq->u.recfgInfo.u.lcgRecfg.cellId;
1124 } /* End of Switch */
1127 } /* rgSCHGomGetCellIdFrmCfgReq */
1131 * @brief Handler to handle SI configuration request from RRM to MAC.
1135 * Function: rgSCHGomHndlSiCfg
1137 * This API handles processing for SI configuration request from RRM to MAC.
1139 * - Processing Steps:
1140 * - Validate SI configuration request parameters at CFG module.
1141 * Call rgSCHCfgVldtSiCfg for SI configuration.
1142 * - If validated successfully, send configuration request to CFG.
1143 * Call rgSCHCfgRgrCellCfg else FAIL.
1145 * @param[in] Region reg
1146 * @param[in] Pool pool
1147 * @param[in] RgSchCb *instCb
1148 * @param[in] SpId spId
1149 * @param[in] RgrCfgTransId transId
1150 * @param[in] RgrSiCfgReqInfo *cfgReqInfo
1156 PUBLIC S16 rgSCHGomHndlSiCfg
1162 RgrCfgTransId transId,
1163 RgrSiCfgReqInfo *cfgReqInfo
1166 PUBLIC S16 rgSCHGomHndlSiCfg(reg, pool, instCb, spId, transId, cfgReqInfo)
1171 RgrCfgTransId transId;
1172 RgrSiCfgReqInfo *cfgReqInfo;
1176 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
1177 Inst inst = (instCb->rgSchInit.inst );
1178 RgSchErrInfo errInfo;
1179 U8 cfmStatus = RGR_CFG_CFM_NOK;
1180 MsgLen msgLen = 0, pduLen;
1185 TRC2(rgSCHGomHndlSiCfg);
1188 /* check if cell does not exists */
1189 if (((U8 *)cell == NULLP) || (cell->cellId != cfgReqInfo->cellId))
1191 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Cell Control block does not exist"
1193 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1194 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1196 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1200 /*Validate the received SI configuration */
1201 ret = rgSCHCfgVldtRgrSiCfg(inst, cfgReqInfo, cell, &errInfo);
1204 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Rgr SI configuration "
1205 "validation FAILED");
1206 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1207 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1209 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1212 /*ccpu00140789: Stopping SI scheduling*/
1213 if(RGR_SI_STOP == cfgReqInfo->cfgType)
1215 if((cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si != NULLP)&&
1216 (cell->siCb.siArray[cfgReqInfo->siId-1].si != NULLP))
1218 cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
1219 RGSCH_FREE_MSG(cell->siCb.siArray[cfgReqInfo->siId-1].si);
1220 cell->siCb.siArray[cfgReqInfo->siId-1].si = NULLP;
1221 if(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si != NULLP)
1223 RGSCH_FREE_MSG(cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si);
1224 cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si = NULLP;
1226 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1228 cfmStatus = RGR_CFG_CFM_OK;
1229 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1234 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1236 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1241 /* Check if the pdu sent from application
1242 * matches a transport block size. if not,
1243 * add padding bytes. This is usually done
1244 * by RRC but since we are bypassing RRC,
1245 * MAC is taking over that responsibility
1247 if ( RGR_SI_CFG_TYPE_MIB != cfgReqInfo->cfgType )
1249 SFndLenMsg(cfgReqInfo->pdu, &msgLen);
1251 /* check if the application pdu matches a tb size */
1252 tbSz = rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs);
1254 if ( tbSz != (msgLen*8) )
1256 MsgLen nmPadBytes = 0;
1257 Data* padding = NULLP;
1259 /* need to add padding bytes */
1260 nmPadBytes = (tbSz - (msgLen*8))/8;
1262 if ( SGetSBuf(reg,pool,&padding,nmPadBytes) != ROK)
1264 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Rgr SI configuration "
1265 "SGetSBuf failed for padding failed");
1266 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1268 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1273 cmMemset((U8*)padding,(U8)0,nmPadBytes);
1275 #ifdef MS_MBUF_CORRUPTION
1276 MS_BUF_ADD_ALLOC_CALLER();
1278 if ( SAddPstMsgMult((Data*)padding,nmPadBytes,cfgReqInfo->pdu) != ROK)
1280 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Rgr SI configuration "
1281 "Failed to add padding bytes");
1282 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1284 SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1286 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1290 SPutSBuf(reg, pool, (Data* )padding,(Size)nmPadBytes);
1292 }/* if (tbSz != ...*/
1293 }/* if (RGR_SI_CFG_TYPE_SI...*/
1295 /*Set the received pdu at the appropriate place */
1296 switch(cfgReqInfo->cfgType)
1298 case RGR_SI_CFG_TYPE_MIB: /* SI CFG Type MIB */
1299 RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.mib,
1300 cell->siCb.newSiInfo.mib,
1301 cfgReqInfo->pdu, cell->siCb.siBitMask,
1305 case RGR_SI_CFG_TYPE_SIB1_PWS:
1307 SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1308 ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1311 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1313 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1314 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1316 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1321 RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1,
1322 cell->siCb.newSiInfo.sib1Info.sib1,
1323 cfgReqInfo->pdu, cell->siCb.siBitMask,
1324 RGSCH_SI_SIB1_PWS_UPD);
1328 case RGR_SI_CFG_TYPE_SIB1:
1329 SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1330 ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,0);
1333 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1335 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1336 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1338 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1342 RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.sib1Info.sib1,
1343 cell->siCb.newSiInfo.sib1Info.sib1,
1344 cfgReqInfo->pdu, cell->siCb.siBitMask,
1348 case RGR_SI_CFG_TYPE_SI: /* SI CFG TYPE SI */
1349 SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1350 ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,
1354 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1356 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1357 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1359 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1363 /* Si recfg, where numSi changes */
1364 if (cell->siCb.siBitMask & RGSCH_SI_SICFG_UPD)
1366 Buffer **newSiPdu = &cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si;
1367 if(*newSiPdu != NULLP)
1369 RGSCH_FREE_MSG(*newSiPdu);
1371 *newSiPdu = (Buffer *)cfgReqInfo->pdu;
1372 cell->siCb.siBitMask |= RGSCH_SI_SI_UPD;
1374 else /* Initial Si cfg or si recfg where numSi did not change */
1377 /* Initial Si cfg */
1378 if (cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si == NULLP)
1380 cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
1381 cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1382 bitMask = RGSCH_SI_DFLT;
1386 bitMask = RGSCH_SI_SI_UPD;
1389 RGSCHCHKNUPDSIPDU(cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si,
1390 cell->siCb.newSiInfo.siInfo[cfgReqInfo->siId-1].si,
1392 cell->siCb.siBitMask, bitMask);
1396 case RGR_SI_CFG_TYPE_SIB8_CDMA: /* SI CFG TYPE SIB 8 CDMA */
1397 SFndLenMsg(cfgReqInfo->pdu, &pduLen);
1398 ret = rgSCHUtlCalMcsAndNPrb(cell, cfgReqInfo->cfgType, pduLen,
1402 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Failed to get MCS and NPRB"
1404 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1405 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1407 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1411 /* No need to wait for Modification period boundary */
1412 cell->siCb.siArray[cfgReqInfo->siId-1].si = cfgReqInfo->pdu;
1413 RGSCH_SET_SI_INFO(cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si,
1415 cell->siCb.siArray[cfgReqInfo->siId-1].isWarningSi = FALSE;
1418 RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Invalid cfgType "
1420 RGSCH_FREE_MSG(cfgReqInfo->pdu);
1421 SPutSBuf(reg, pool, (Data *)cfgReqInfo,
1422 (Size)sizeof(*cfgReqInfo));
1424 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId,
1429 SPutSBuf(reg, pool, (Data *)cfgReqInfo, (Size)sizeof(*cfgReqInfo));
1431 cfmStatus = RGR_CFG_CFM_OK;
1432 rgSCHUtlRgrSiCfgCfm(instCb->rgSchInit.inst, spId, transId, cfmStatus);
1436 } /* rgSCHGomHndlSiCfg */
1440 * @brief Handler to handle Warning SI configuration request from RRM to MAC.
1444 * Function: rgSCHGomHndlWarningSiCfg
1446 * This API handles processing for Warning SI configuration request from
1450 * @param[in] Region reg
1451 * @param[in] Pool pool
1452 * @param[in] RgSchCb *instCb
1453 * @param[in] SpId spId
1454 * @param[in] RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
1460 PUBLIC S16 rgSCHGomHndlWarningSiCfg
1466 RgrCfgTransId transId,
1467 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
1470 PUBLIC S16 rgSCHGomHndlWarningSiCfg(reg, pool, instCb, spId, transId,
1471 warningSiCfgReqInfo)
1476 RgrCfgTransId transId;
1477 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo;
1480 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
1481 U8 cfmStatus = RGR_CFG_CFM_NOK;
1483 U8 siId = warningSiCfgReqInfo->siId;
1484 U8 j, mcs=0, nPrb=0;
1485 RgSchWarningSiSeg *warningSiMsg;
1486 RgSchWarningSiPdu *pduNode;
1489 Bool freeNodeFound = FALSE;
1493 U8 isEmtc = warningSiCfgReqInfo->emtcEnable;
1496 TRC2(rgSCHGomHndlWarningSiCfg);
1501 rgSchEmtcGetSiWinPerd(cell, &siWinSize, &minPeriod);
1506 siWinSize = cell->siCfg.siWinSize;
1507 minPeriod = cell->siCfg.minPeriodicity;
1509 /* check if cell does not exists */
1510 if (((U8 *)cell == NULLP) ||
1511 (cell->cellId != warningSiCfgReqInfo->cellId) ||
1512 (warningSiCfgReqInfo->siId >
1513 ((minPeriod * 10)/siWinSize)))
1515 RLOG_ARG2(L_ERROR,DBG_CELLID,warningSiCfgReqInfo->cellId,"Warning SI Cfg Failed for siId = %d"
1516 "warning cellID:%d",warningSiCfgReqInfo->siId,warningSiCfgReqInfo->cellId);
1517 rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
1518 SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1519 sizeof(RgrWarningSiCfgReqInfo));
1520 warningSiCfgReqInfo = NULLP;
1521 rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
1526 /* Search for free index in WarningSi */
1527 for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1529 if((cell->siCb.warningSi[idx].siId == 0 ||
1530 cell->siCb.warningSi[idx].siId == warningSiCfgReqInfo->siId))
1532 warningSiMsg = (RgSchWarningSiSeg *)&cell->siCb.warningSi[idx].warningSiMsg;
1534 /* Search for free SI node */
1535 /* ccpu00136659: CMAS ETWS design changes */
1536 if (warningSiMsg->segLstCp.first == NULLP) /* Free SI Node */
1538 warningSiMsg->transId = transId;
1539 pduNode = (RgSchWarningSiPdu *)&cell->siCb.warningSi[idx].
1540 warningSiMsg.pduNode;
1541 CM_LLIST_FIRST_NODE(&warningSiCfgReqInfo->siPduLst, node);
1544 /* Get the PDUs one by one from the received pduLst of warning
1545 * message and calculate the MCS and nPrb of each pdu once.
1546 * Store the pdu in warningSiMsg pduLst, which will be scheduled
1547 * later while sending warning message as part of SIB11/SIB12
1549 while((node != NULLP) && (j < RGR_MAX_WARNING_SI_SEG))
1552 pduNode[j].pdu = (Buffer *)node->node;
1553 if(pduNode[j].pdu != NULLP)
1555 SFndLenMsg(pduNode[j].pdu, &msgLen);
1556 /*Get the nPrb and mcs parametr values */
1558 if (rgSCHEmtcUtlGetAllwdCchTbSzForSI(msgLen*8) != (msgLen*8))
1560 if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
1564 RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,
1566 "rgSCHGomHndlWarningSiCfg():msgLen does not match\
1567 any valid TB Size.");
1568 RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Warning SI Cfg Failed"
1569 "for siId = %d", warningSiCfgReqInfo->siId);
1570 rgSCHUtlFreeWarningSiSeg(reg, pool,
1571 &warningSiCfgReqInfo->siPduLst);
1572 SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1573 sizeof(RgrWarningSiCfgReqInfo));
1574 warningSiCfgReqInfo = NULLP;
1575 rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId,
1576 siId, transId,cfmStatus);
1581 pduNode[j].mcs = mcs;
1582 pduNode[j].nPrb = nPrb;
1583 pduNode[j].msgLen = msgLen;
1584 /* ccpu00136659: CMAS ETWS design changes */
1585 cmLListAdd2Tail(&warningSiMsg->segLstCp, &pduNode[j].lnk);
1586 pduNode[j].lnk.node = (PTR)&pduNode[j];
1591 /* ccpu00132385- nodes in received SI config linked list should
1592 * be freed after processing the config.*/
1593 while(warningSiCfgReqInfo->siPduLst.first != NULLP)
1595 node = warningSiCfgReqInfo->siPduLst.first;
1596 cmLListDelFrm(&(warningSiCfgReqInfo->siPduLst), node);
1597 SPutSBuf(reg, pool, (Data *)node,sizeof(CmLList));
1601 cell->siCb.warningSi[idx].siId = warningSiCfgReqInfo->siId;
1602 cell->siCb.warningSi[idx].idx = idx;
1606 rgSCHEmtcWarningSiCfg(cell,warningSiCfgReqInfo,idx);
1611 cell->siCb.siArray[warningSiCfgReqInfo->siId-1].si =
1612 &cell->siCb.warningSi[idx];
1613 cell->siCb.siArray[warningSiCfgReqInfo->siId-1].isWarningSi =
1616 freeNodeFound = TRUE;
1622 if (freeNodeFound == FALSE)
1624 RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,"No SI Index is free");
1625 rgSCHUtlFreeWarningSiSeg(reg, pool, &warningSiCfgReqInfo->siPduLst);
1626 SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1627 sizeof(RgrWarningSiCfgReqInfo));
1628 warningSiCfgReqInfo = NULLP;
1629 rgSCHUtlRgrWarningSiCfgCfm(instCb->rgSchInit.inst, spId, siId, transId,
1634 SPutSBuf(reg, pool, (Data *)warningSiCfgReqInfo,
1635 sizeof(RgrWarningSiCfgReqInfo));
1636 warningSiCfgReqInfo = NULLP;
1642 * @brief Handler to handle SI Stop request from RRM to MAC.
1646 * Function: rgSCHGomHndlWarningSiStopReq
1648 * This API handles processing for SI stop request from RRM to MAC.
1650 * @param[in] Region reg
1651 * @param[in] Pool pool
1652 * @param[in] RgSchCb *instCb
1653 * @param[in] SpId siId
1657 PUBLIC Void rgSCHGomHndlWarningSiStopReq
1663 RgrCfgTransId transId,
1667 PUBLIC Void rgSCHGomHndlWarningSiStopReq(reg, pool, instCb, siId, transId, spId)
1672 RgrCfgTransId transId;
1676 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
1679 RgSchWarningSiPdu *warningSiPdu;
1682 TRC3(rgSCHGomHndlWarningSiStopReq)
1684 for(idx = 0; idx < RGR_MAX_NUM_WARNING_SI; idx++)
1686 if(cell->siCb.warningSi[idx].siId == siId)
1688 if ((cmMemcmp ((U8 *)&cell->siCb.warningSi[idx].warningSiMsg.transId,
1689 (U8 *)&transId, sizeof(RgrCfgTransId))) == 0)
1691 /* ccpu00136659: CMAS ETWS design changes */
1692 CM_LLIST_FIRST_NODE(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
1693 while(node != NULLP)
1695 /* On receiving the warning stop message, remove one by one
1696 * each PDU from the warning SI list
1698 /* ccpu00136659: CMAS ETWS design changes */
1699 node = (CmLList *)&cell->siCb.warningSi[idx].warningSiMsg.segLstCp.first;
1700 warningSiPdu = (RgSchWarningSiPdu *)node->node;
1701 pdu = warningSiPdu->pdu;
1702 cmLListDelFrm(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
1703 RGSCH_FREE_MSG(pdu);
1712 #endif/*RGR_SI_SCH */
1714 /* LTE_ADV_FLAG_REMOVED_START */
1717 * @brief This function sets the Phigh range for CC users corresponding to the CC Pool
1720 * Function: rgSchUpdtRNTPInfo
1722 * Invoked by: rgSCHGomHndlLoadInf
1724 * @param[in] RgSchCellCb* cell
1725 * @param[in] RgSubFrm* subFrm
1726 * @param[in] RgrLoadInfReqInfo *loadInfReq
1731 PUBLIC S16 rgSchUpdtRNTPInfo
1735 RgrLoadInfReqInfo *loadInfReq
1738 PRIVATE Void rgSchUpdtRNTPInfo(cell, sf)
1741 RgrLoadInfReqInfo *loadInfReq;
1745 /* Initialise the variables */
1746 RgSchSFRPoolInfo *sfrCCPool;
1751 TRC2(rgSchUpdtRNTPInfo);
1753 l = &sf->sfrTotalPoolInfo.ccPool;
1755 /*Get the first node from the CC Pool*/
1756 n = cmLListFirst(l);
1759 sfrCCPool = (RgSchSFRPoolInfo*)n->node;
1760 if (sfrCCPool->poolendRB == loadInfReq->rgrCcPHighEndRb)
1762 sfrCCPool->pwrHiCCRange.endRb = loadInfReq->rgrCcPHighEndRb;
1763 sfrCCPool->pwrHiCCRange.startRb = loadInfReq->rgrCcPHighStartRb;
1774 * @brief Handler to handle LOAD INF request from RRM to MAC.
1778 * Function: rgSCHGomHndlLoadInf
1780 * This API handles processing for LOAD INF request from RRM to MAC.
1782 * - Processing Steps:
1783 * - Validate LOAD INF request parameters at CFG module.
1784 * Call rgSCHCfgVldtRgrLoadInf for SI configuration.
1785 * - If validated successfully, send configuration request.
1787 * @param[in] Region reg
1788 * @param[in] Pool pool
1789 * @param[in] RgSchCb *instCb
1790 * @param[in] SpId spId
1791 * @param[in] RgrCfgTransId transId
1792 * @param[in] RgrLoadInfReqInfo *loadInfReq
1798 PUBLIC S16 rgSCHGomHndlLoadInf
1804 RgrCfgTransId transId,
1805 RgrLoadInfReqInfo *loadInfReq
1808 PUBLIC S16 rgSCHGomHndlLoadInf(reg, pool, instCb, spId, transId, loadInfReq)
1813 RgrCfgTransId transId;
1814 RgrLoadInfReqInfo *loadInfReq;
1818 RgSchCellCb *cell = instCb->rgrSap[spId].cell;
1819 Inst inst = (instCb->rgSchInit.inst );
1820 RgSchErrInfo errInfo;
1823 TRC2(rgSCHGomHndlLoadInf);
1826 /* check if cell does not exists */
1827 if (((U8 *)cell == NULLP) || (cell->cellId != loadInfReq->cellId))
1829 RLOG_ARG1(L_ERROR,DBG_CELLID,loadInfReq->cellId,"Cell Control block does not exist"
1830 "for load cellId:%d",loadInfReq->cellId);
1831 SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1835 if (cell->lteAdvCb.dsfrCfg.status == RGR_DISABLE)
1837 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHGomHndlLoadInf(): DSFR Feature not enabled");
1838 SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1841 /* Validate the received LOAD INF Configuration */
1842 ret = rgSCHCfgVldtRgrLoadInf(inst, loadInfReq, cell, &errInfo);
1845 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Rgr LOAD INF Configuration "
1846 "validation FAILED");
1847 SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1850 /* Update the RNTP info rcvd in the respective cell centre pool so that Phigh can be
1851 sent for the UEs scheduled in that particular RB range*/
1852 for(i = 0; i < RGSCH_NUM_DL_slotS; i++)
1854 if((rgSchUpdtRNTPInfo(cell, cell->subFrms[i], loadInfReq) != ROK))
1860 SPutSBuf(reg, pool, (Data *)loadInfReq, (Size)sizeof(*loadInfReq));
1864 } /* rgSCHGomHndlLoadInf */
1865 /* LTE_ADV_FLAG_REMOVED_END */
1867 /**********************************************************************
1870 **********************************************************************/