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 **********************************************************************/
32 @brief This file implements the schedulers main access to MAC layer code.
36 /* header include files -- defines (.h) */
37 #include "common_def.h"
43 #include "rg_sch_inf.h"
45 #include "rg_sch_err.h"
46 #include "rg_sch_cmn.h"
47 #include "rl_interface.h"
48 #include "rl_common.h"
50 /* header/extern include files (.x) */
51 #include "tfu.x" /* TFU types */
52 #include "lrg.x" /* layer management typedefs for MAC */
53 #include "rgr.x" /* layer management typedefs for MAC */
54 #include "rgm.x" /* layer management typedefs for MAC */
55 #include "rg_sch_inf.x" /* typedefs for Scheduler */
56 #include "rg_sch.x" /* typedefs for Scheduler */
57 #include "rg_sch_cmn.x"
60 S16 rgEmtcMacSchUeDelInd ARGS((RgSchCellCb *cell,RgInfUeDelInd *ueDelInd));
61 S16 rgSCHGomEmtcHndlSiCfg ARGS((
66 RgrCfgTransId transId,
67 RgrSiCfgReqInfo *cfgReqInfo
69 S16 rgSCHGomEmtcHndlWarningSiCfg ARGS((
74 RgrCfgTransId transId,
75 RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
79 /************** LRG Interface ****************/
82 * @brief Layer Manager Control request handler.
86 * Function : RgMiLrgSchCntrlReq
88 * This function handles the control
89 * request received from the Layer Manager.
90 * -# Based on cntrl->hdr.elmId.elmnt, cntrl->t.cntrl.action
91 * and cntrl->t.cntrl.subAction, it performs the appropriate control action
92 * of SAP (enable/disable) and layer shutdown.
93 * -# Invokes the RgMiLrgSchCntrlCfm to send back the confirmation to LM.
95 * @param[in] Pst *pst, the post structure
96 * @param[in] RgMngmt *cntrl, the control parameter's structure
100 S16 RgMiLrgSchCntrlReq
102 Pst *pst, /* post structure */
103 RgMngmt *cntrl /* control structure */
106 S16 ret = ROK; /* return value */
110 Inst inst = (pst->dstInst - SCH_INST_START); /* Scheduler instance Id */
112 /* Fill the post structure for sending the confirmation */
113 SchFillCfmPst(pst, &cfmPst, cntrl);
115 /* Initialize the cfg cfm structure
116 if (SGetSBuf(cfmPst.region, cfmPst.pool, (Data **)&cfm, sizeof(RgMngmt))
119 DU_LOG("\nERROR --> SCH : Memory Unavailable for Confirmation");
120 SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt));
123 memset(&cfm, 0, sizeof(RgMngmt));
130 cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt;
131 cfm.t.cntrl.action = cntrl->t.cntrl.action;
132 cfm.t.cntrl.subAction = cntrl->t.cntrl.subAction;
134 /* Check if General Config Done*/
135 if(rgSchCb[inst].rgSchInit.cfgDone != TRUE)
137 cfm.cfm.status = LCM_PRIM_NOK;
138 cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
139 cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt;
140 RgMiLrgSchCntrlCfm(&cfmPst, &cfm);
141 DU_LOG("\nERROR --> SCH : Gen Cfg not done.");
142 /* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */
146 /* General Config done, process the Control request */
147 switch(cntrl->hdr.elmId.elmnt)
150 rgSCHLmmGenCntrl(cntrl, &cfm, &cfmPst);
154 rgSCHLmmSapCntrl(cntrl, &cfm, &cfmPst);
157 cfm.cfm.status = LCM_PRIM_NOK;
158 cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
159 RgMiLrgSchCntrlCfm(&cfmPst, &cfm);
160 DU_LOG("\nERROR --> SCH : invalid elmnt=%d",
161 cntrl->hdr.elmId.elmnt);
164 /* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */
166 }/*-- RgMiLrgSchCntrlReq --*/
170 * @brief Layer Manager L2 Measurement request handler.
174 * Function : RgMiLrgSchL2MeasReq
176 * This function handles the control
177 * measurement request received from the Layer Manager.
179 * @param[in] Pst *pst, the post structure
180 * @param[in] LrgSchMeasReqInfo *measInfo, measurement request info
184 S16 RgMiLrgSchL2MeasReq
186 Pst *pst, /* post structure */
187 LrgSchMeasReqInfo *measInfo /* Meas Req Info */
194 RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)];
195 #if (ERRCLASS & ERRCLS_ADD_RES)
199 RgSchL2MeasCb *measCb = NULLP;
201 Inst inst = (pst->dstInst - SCH_INST_START); /* Scheduler instance Id */
208 /* Find the cellCb using cellId in measInfo. Iterate through all cells
209 * in rgrsapCb in RgschCb */
211 for (idx = 0; idx < instCb->numSaps; idx++)
213 if ( instCb->rgrSap[idx].cell->cellId == measInfo->cellId)
215 /* got the cell break the loop */
216 cell = instCb->rgrSap[idx].cell;
220 /* If no cellCb return Err with Invalid Cell Id */
223 rgSchL2mFillCfmPst(pst, &cfmPst, measInfo);
224 RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_INVALID_CELLID);
225 rgSchL2mSndCfm(&cfmPst, NULLP, measInfo, TRUE);
226 DU_LOG("\nERROR --> SCH : Meas req Failed.Invalid Cell Id errType(%d) errCause(%d)",
227 err.errType, err.errCause);
230 /* Validate for Meas Types */
231 if ( (ret = rgSCHUtlValidateMeasReq(cell, measInfo, &err)) != ROK)
233 rgSchL2mFillCfmPst(pst, &cfmPst, measInfo);
234 RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_INVALID_MEASTYPE);
235 rgSchL2mSndCfm(&cfmPst, NULLP, measInfo, TRUE);
236 DU_LOG("\nERROR --> SCH : Meas req Failed.Invalid Measurement Type"
237 "errCasue(%d) errType(%d)", err.errType, err.errCause);
240 /* Iterate through all meas requests in l2mList in cellCb */
241 #if (ERRCLASS & ERRCLS_ADD_RES)
242 lnk = cell->l2mList.first;
245 /* Get the MeasCb : RgSchL2MeasCb */
246 measCb = (RgSchL2MeasCb *)lnk->node;
248 if (measCb->measReq.hdr.transId == measInfo->hdr.transId)
250 rgSchL2mFillCfmPst(pst, &cfmPst, measInfo);
251 RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_DUP_TRANSID);
252 rgSchL2mSndCfm(&cfmPst, measCb, measInfo, TRUE);
253 DU_LOG("\nERROR --> SCH : Meas req Failed Duplicate TransId"
254 "errType(%d) errCause(%d)", err.errType, err.errCause);
259 /* Call L2M Function to store Meas req */
260 ret = rgSchL2mMeasReq(cell, measInfo, err);
263 rgSchL2mFillCfmPst(pst, &cfmPst, measInfo);
264 RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_L2MEAS_FAILED);
265 rgSchL2mSndCfm(&cfmPst, measCb, measInfo, TRUE);
266 DU_LOG("\nERROR --> SCH : Meas req Failed.errType(%d) errCause(%d)",
267 err.errType, err.errCause);
271 } /* -- RRgMiLrgSchL2MeasReq-- */
274 * @brief Layer Manager L2 Measurement Stop request handler.
278 * Function : RgMiLrgSchL2MeasStopReq
280 * This function handles the control
281 * measurement stop request received from the Layer Manager.
283 * @param[in] Pst *pst, the post structure
284 * @param[in] LrgSchMeasReqInfo *measInfo, measurement stop request info
288 S16 RgMiLrgSchL2MeasStopReq
290 Pst *pst, /* post structure */
291 LrgSchMeasStopReqInfo *measInfo /* Meas Req Info */
295 RgSchCellCb *cell = NULLP;
296 RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)];
297 CmLList *node = NULLP;
298 RgSchL2MeasCb *measCb = NULLP;
299 LrgSchMeasCfmInfo measCfm;
302 for (idx = 0; idx < instCb->numSaps; idx++)
304 if ( instCb->rgrSap[idx].cell->cellId == measInfo->cellId)
306 /* got the cell break the loop */
307 cell = instCb->rgrSap[idx].cell;
313 DU_LOG("\nERROR --> SCH : Stop req Failed.Invalid Cell Id ");
316 memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
317 node = cell->l2mList.first;
320 measCb = (RgSchL2MeasCb *)(node)->node;
323 cmLListDelFrm(&cell->l2mList, &measCb->measLnk);
324 rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb,
325 sizeof(RgSchL2MeasCb));
328 if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
330 RgInfL2MeasStopReq measStopReq;
332 memset(&measStopReq, 0, sizeof(RgInfL2MeasStopReq));
333 measStopReq.transId = measInfo->hdr.transId;
334 measStopReq.measType = measInfo->measType;
335 /* measReq.timePrd = measInfo->timePrd; */
336 measStopReq.cellId = measInfo->cellId;
337 rgSCHUtlGetPstToLyr(&pstMac, &rgSchCb[cell->instIdx], cell->macInst);
338 RgSchMacL2MeasStop(&pstMac,&measStopReq);
342 RgMiLrgSchL2MeasStopCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst),
346 }/*RgMiLrgSchL2MeasStopReq*/
348 * @brief Layer Manager L2 Measurement request handler.
349 * for Send l2 measurement req
352 * Function : RgMiLrgSchL2MeasSendReq
354 * This function handles the control
355 * measurement send request received from the Layer Manager.
357 * @param[in] Pst *pst, the post structure
358 * @param[in] LrgSchMeasReqInfo *measInfo, measurement stop request info
362 S16 RgMiLrgSchL2MeasSendReq
364 Pst *pst, /* post structure */
365 LrgSchMeasSndReqInfo *measInfo /* Meas Req Info */
370 RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)];
374 for (idx = 0; idx < instCb->numSaps; idx++)
376 if ( instCb->rgrSap[idx].cell->cellId == measInfo->cellId)
378 /* got the cell break the loop */
379 cell = instCb->rgrSap[idx].cell;
385 DU_LOG("\nERROR --> SCH : Send req Failed.Invalid Cell Id");
389 if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
391 RgInfL2MeasSndReq measSndReq;
393 memset(&measSndReq, 0, sizeof(RgInfL2MeasSndReq));
394 measSndReq.transId = measInfo->hdr.transId;
395 measSndReq.measType = measInfo->measType;
396 measSndReq.timePrd = measInfo->timePrd;
397 measSndReq.cellId = measInfo->cellId;
398 rgSCHUtlGetPstToLyr(&pstMac, &rgSchCb[cell->instIdx], cell->macInst);
399 RgSchMacL2MeasSend(&pstMac, &measSndReq);
403 cell->sndL2Meas = TRUE;
407 }/*RgMiLrgSchL2MeasSendReq*/
408 #endif /* LTE_L2_MEAS */
413 /************* RGR Interface ****************/
415 * @brief API for bind request from RRM towards MAC.
419 * Function: RgUiRgrBndReq
421 * This API is invoked by RRM towards MAC to bind RGR SAP.
422 * These API validates the Pst, spId, suId and sends the bind confirm to
426 * @param[in] Pst *pst
427 * @param[in] SuId suId
428 * @param[in] SpId spId
433 S16 RgUiRgrBndReq(Pst *pst, SuId suId, SpId spId)
436 Pst tmpPst; /* Temporary Post Structure */
437 Inst instId = pst->dstInst-SCH_INST_START;
438 RgUstaDgn dgn; /* Alarm diagnostics structure */
440 tmpPst.prior = pst->prior;
441 tmpPst.route = pst->route;
442 tmpPst.selector = pst->selector;
443 tmpPst.region = rgSchCb[instId].rgSchInit.region;
444 tmpPst.pool = rgSchCb[instId].rgSchInit.pool;
445 tmpPst.srcProcId = rgSchCb[instId].rgSchInit.procId;
446 tmpPst.srcEnt = rgSchCb[instId].rgSchInit.ent;
447 tmpPst.srcInst = rgSchCb[instId].rgSchInit.inst + SCH_INST_START;
448 tmpPst.event = EVTNONE;
449 tmpPst.dstProcId = pst->srcProcId;
450 tmpPst.dstEnt = pst->srcEnt;
451 tmpPst.dstInst = pst->srcInst;
453 if(spId < rgSchCb[instId].numSaps)
455 /* Check the state of the SAP */
456 switch (rgSchCb[instId].rgrSap[spId].sapSta.sapState)
458 /* This case might not be needed if SAP not configured then it will go
459 * to else of above if condition */
460 case LRG_UNBND: /* SAP is not bound */
461 DU_LOG("\nDEBUG --> SCH : SAP Not yet bound");
462 rgSchCb[instId].rgrSap[spId].sapSta.sapState = LRG_BND;
463 rgSchCb[instId].rgrSap[spId].sapCfg.suId = suId;
464 /* Send Bind Confirm with status as SUCCESS */
465 ret = rgSCHUtlRgrBndCfm(instId, suId, CM_BND_OK);
466 /*Indicate to Layer manager */
467 rgSCHUtlFillDgnParams(instId, &dgn, LRG_USTA_DGNVAL_MEM);
468 ret = rgSCHLmmStaInd(instId, LCM_CATEGORY_INTERFACE,
469 LRG_EVENT_RGRSAP_ENB, LCM_CAUSE_UNKNOWN, &dgn);
471 case LRG_BND: /* SAP is already bound*/
472 DU_LOG("\nDEBUG --> SCH : SAP is already bound");
473 ret = rgSCHUtlRgrBndCfm(instId, suId, CM_BND_OK);
475 default: /* Should Never Enter here */
476 #if (ERRCLASS & ERRCLS_ADD_RES)
477 DU_LOG("\nERROR --> SCH : Invalid SAP State:RgUiRrgBndReq failed\n");
479 ret = rgSCHUtlRgrBndCfm(instId, suId, CM_BND_NOK);
485 #if (ERRCLASS & ERRCLS_ADD_RES)
486 /* ccpu00117035 - MOD - Changed ErrVal argument from accessing sap state
487 to spId to avoid seg fault due to invalid sapID */
488 DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRrgBndReq failed\n");
490 ret = RgUiRgrBndCfm(&tmpPst, suId, CM_BND_NOK);
493 } /* RgUiRgrBndReq */
496 * @brief API for unbind request from RRM towards MAC.
500 * Function: RgUiRgrUbndReq
502 * This API is invoked by RRM towards MAC to unbind RGR SAP.
503 * These API validates the Pst, spId, suId and transfers the unbind request
504 * specific information to corresponding ownership module (GOM) API.
507 * @param[in] Pst *pst
508 * @param[in] SuId suId
509 * @param[in] Reason reason
514 S16 RgUiRgrUbndReq(Pst *pst,SpId spId,Reason reason)
516 Inst instId = pst->dstInst-SCH_INST_START;
518 /* SAP Id validation */
519 if (spId < rgSchCb[instId].numSaps)
521 switch(rgSchCb[instId].rgrSap[spId].sapSta.sapState)
523 case LRG_BND: /* SAP is already bound*/
524 DU_LOG("\nDEBUG --> SCH : SAP is already bound");
525 /* setting SAP state to UN BOUND */
526 rgSchCb[instId].rgrSap[spId].sapSta.sapState = LRG_UNBND;
529 #if (ERRCLASS & ERRCLS_ADD_RES)
530 DU_LOG("\nERROR --> SCH : Invalid SAP State RgUiRgrUbndReq failed\n");
537 #if (ERRCLASS & ERRCLS_ADD_RES)
538 DU_LOG("\nERROR --> SCH : Invalid SAP Id RgUiRgrUbndReq failed\n");
543 } /* RgUiRgrUbndReq */
547 * @brief API for SI configuration request from RRM towards MAC.
551 * Function: RgUiRgrSiCfgReq
553 * This API is invoked by RRM towards MAC to configure SI at MAC.
554 * These API validates the Pst, spId, suId and transfers the
555 * config request specific information to corresponding ownership
559 * @param[in] Pst *pst
560 * @param[in] SpId spId
561 * @param[in] RgrCfgTransId transId
562 * @param[in] RgrSiCfgReqInfo *cfgReqInfo
567 S16 RgUiRgrSiCfgReq(Pst *pst, SpId spId,RgrCfgTransId transId,RgrSiCfgReqInfo *cfgReqInfo)
570 uint8_t cfmStatus = RGR_CFG_CFM_NOK;
571 uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
572 Inst instId = pst->dstInst-SCH_INST_START;
574 memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
575 prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
578 if (cfgReqInfo == NULLP)
580 DU_LOG("\nERROR --> SCH : Input Message Buffer is NULL");
581 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
585 if (spId < rgSchCb[instId].numSaps)
587 if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState)
589 #if (ERRCLASS & ERRCLS_ADD_RES)
590 DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrSiCfgReq failed\n");
592 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
593 (Size)sizeof(*cfgReqInfo));
594 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
600 #if (ERRCLASS & ERRCLS_ADD_RES)
601 DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrSiCfgReq failed\n");
603 SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
604 (Size)sizeof(*cfgReqInfo));
605 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
609 /* Handle configuration */
611 if(rgSchCb[instId].rgrSap[spId].cell->emtcEnable)
613 ret = rgSCHGomEmtcHndlSiCfg(pst->region, pst->pool,
614 &rgSchCb[instId], spId, transId,
619 ret = rgSCHGomHndlSiCfg(pst->region, pst->pool,
620 &rgSchCb[instId], spId, transId,
624 ret = rgSCHGomHndlSiCfg(pst->region, pst->pool,
625 &rgSchCb[instId], spId, transId,
630 DU_LOG("\nERROR --> SCH : RgUiRgrSiCfgReq:"
631 "Configuration Request Handling Failed");
636 } /* RgUiRgrSiCfgReq */
640 * @brief API for Warning SI configuration request from RRM towards MAC.
644 * Function: RgUiRgrWarningSiCfgReq
646 * This API is invoked by RRM towards MAC to configure SI at MAC.
647 * These API validates the Pst, spId, suId and transfers the
648 * config request specific information to corresponding ownership
652 * @param[in] Pst *pst
653 * @param[in] SpId spId
654 * @param[in] RgrCfgTransId transId
655 * @param[in] RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
660 S16 RgUiRgrWarningSiCfgReq(Pst *pst, SpId spId,RgrCfgTransId transId,RgrWarningSiCfgReqInfo *warningSiCfgReqInfo)
662 Inst instId = pst->dstInst-SCH_INST_START;
664 uint8_t cfmStatus = RGR_CFG_CFM_NOK;
665 uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
667 memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
668 prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
670 if (warningSiCfgReqInfo == NULLP)
672 DU_LOG("\nERROR --> SCH : Input Message Buffer "
674 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, 0, transId, cfmStatus);
678 if (spId < rgSchCb[instId].numSaps)
680 if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState)
682 #if (ERRCLASS & ERRCLS_ADD_RES)
683 DU_LOG("\nERROR --> SCH : Invalid SAP State: warningSiCfgReqInfo failed\n");
685 rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool,
686 &warningSiCfgReqInfo->siPduLst);
687 SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
688 sizeof(RgrWarningSiCfgReqInfo));
689 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
696 #if (ERRCLASS & ERRCLS_ADD_RES)
697 DU_LOG("\nERROR --> SCH : Invalid SAP Id:warningSiCfgReqInfo failed\n");
699 rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool,
700 &warningSiCfgReqInfo->siPduLst);
701 SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
702 sizeof(RgrWarningSiCfgReqInfo));
703 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
708 /* Handle configuration */
710 if(rgSchCb[instId].rgrSap[spId].cell->emtcEnable)
712 ret = rgSCHGomEmtcHndlWarningSiCfg(pst->region, pst->pool,
713 &rgSchCb[instId], spId, transId, warningSiCfgReqInfo);
717 ret = rgSCHGomHndlWarningSiCfg(pst->region, pst->pool,
718 &rgSchCb[instId], spId, transId, warningSiCfgReqInfo);
721 ret = rgSCHGomHndlWarningSiCfg(pst->region, pst->pool,
722 &rgSchCb[instId], spId, transId, warningSiCfgReqInfo);
726 DU_LOG("\nERROR --> SCH : Configuration Request Handling Failed");
735 * @brief API for Warning SI Stop request from RRM towards MAC.
739 * Function: RgUiRgrWarningSiStopReq
741 * This API is invoked by RRM towards MAC to Stop warning SI at MAC.
742 * These API validates the Pst, spId, suId and transfers the
743 * stop request specific information to corresponding ownership
747 * @param[in] Pst *pst
748 * @param[in] SpId spId
749 * @param[in] RgrWarningSiCfgReqInfo *warningSiCfgReqInfo
754 S16 RgUiRgrWarningSiStopReq(Pst *pst,SpId spId,RgrCfgTransId transId,uint8_t siId)
756 Inst instId = pst->dstInst-SCH_INST_START;
758 if (spId < rgSchCb[instId].numSaps)
760 if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState)
762 #if (ERRCLASS & ERRCLS_ADD_RES)
763 DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrWarningSiStopReq failed\n");
770 #if (ERRCLASS & ERRCLS_ADD_RES)
771 DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrWarningSiStopReq failed\n");
776 rgSCHGomHndlWarningSiStopReq(pst->region, pst->pool,
777 &rgSchCb[instId], siId, transId, spId);
781 #endif /*RGR_SI_SCH */
783 /* LTE_ADV_FLAG_REMOVED_START */
786 * @brief API for LOAD INF request from RRM towards MAC.
790 * Function: RgUiRgrLoadInfReq
792 * This API is invoked by RRM towards MAC to configure LOAD INF Parameters at MAC.
793 * These API validates the Pst, spId, suId and transfers the
794 * LOAD INF request to corresponding ownership
798 * @param[in] Pst *pst
799 * @param[in] SpId spId
800 * @param[in] RgrCfgTransId transId
801 * @param[in] RgrLoadInfReqInfo *loadInfReq
806 S16 RgUiRgrLoadInfReq(Pst *pst, SpId spId, RgrCfgTransId transId,RgrLoadInfReqInfo *loadInfReq)
809 uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
810 Inst instId = pst->dstInst-SCH_INST_START;
812 memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
813 prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
816 if (loadInfReq == NULLP)
818 DU_LOG("\nERROR --> SCH : Input Message Buffer "
823 if (spId < rgSchCb[instId].numSaps)
825 if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState)
827 #if (ERRCLASS & ERRCLS_ADD_RES)
828 DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrLoadInfReq failed\n");
830 SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
831 (Size)sizeof(*loadInfReq));
837 #if (ERRCLASS & ERRCLS_ADD_RES)
838 DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrLoadInfReq failed\n");
840 SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
841 (Size)sizeof(*loadInfReq));
845 /* Handle configuration */
846 ret = rgSCHGomHndlLoadInf(pst->region, pst->pool,
847 &rgSchCb[(pst->dstInst - SCH_INST_START)], spId, transId,
851 DU_LOG("\nERROR --> SCH : Configuration Request Handling Failed");
856 } /* RgUiRgrLoadInfReq */
857 /* LTE_ADV_FLAG_REMOVED_END */
859 /************** MAC SCH Interface **************/
861 * @brief Function for updating dedicated channel BO at scheduler from MAC.
865 * Function : rgMacSchDedBoUpdtReq
867 * This function shall be invoked whenever MAC gets staRsp from RLC
868 * Scheduler shall update BO in its dedicated logical channel control block.
870 * @param[in] Pst* pst
871 * @param[in] S16 cellSapId
872 * @param[in] RgInfDedBoRpt *boRpt
876 S16 RgMacSchDedBoUpdtReq(Pst* pst,RgInfDedBoRpt *boRpt)
884 Inst inst = (pst->dstInst - SCH_INST_START);
885 S16 cellSapId = boRpt->cellSapId;
887 DU_LOG("\nDEBUG --> SCH : rgMacSchDedBoUpdtReq():"
888 " boRpt->rnti = %u boRpt->lcId = %u",boRpt->rnti, boRpt->lcId);
890 /* No need to chk for cell being NULL as MAC wouldn't have found instance if
892 cell = rgSchCb[inst].rgrSap[cellSapId].cell;
895 if (cell->cellId != boRpt->cellId)
897 /* Handle Cell fetch failure */
898 DU_LOG("\nERROR --> SCH : rgMacSchDedBoUpdtReq(): Invalid cell Id");
903 /* Update Bo in the given logical channel of the UE */
904 if ((ue = rgSCHDbmGetUeCb(cell, boRpt->rnti)) != NULLP)
907 /* Honor BO Reports only from PCELL */
909 if (cell != ue->cell)
914 if ((dlLc = rgSCHDbmGetDlDedLcCb(ue, boRpt->lcId)) != NULLP)
917 if(dlLc->lcType == CM_LTE_LCH_DTCH)
919 if((dlLc->bo == 0) &&(boRpt->bo != 0))
922 if(!(ue->qciActiveLCs[dlLc->qciCb->qci]))
924 dlLc->qciCb->dlUeCount++;
926 ue->qciActiveLCs[dlLc->qciCb->qci]++;
928 else if((dlLc->bo != 0) && (boRpt->bo == 0) && (dlLc->qciCb->dlUeCount))
931 if (ue->qciActiveLCs[dlLc->qciCb->qci])
933 ue->qciActiveLCs[dlLc->qciCb->qci]--;
934 if (!(ue->qciActiveLCs[dlLc->qciCb->qci]))
936 dlLc->qciCb->dlUeCount--;
943 dlUe = RG_SCH_CMN_GET_DL_UE(ue, cell);
944 if (boRpt->bo > dlLc->bo)
946 dlUe->boReported += (boRpt->bo - dlLc->bo);
950 if (boRpt->bo > dlLc->bo)
952 ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlBo += ((boRpt->bo - dlLc->bo)<<3);
955 /* RLC provides cumulative BO for each LC.
956 * Reduce the left out unscheduled bo from total bo and
957 * update the new BO to the total bo */
958 if(ue->totalBo >= dlLc->bo)
960 ue->totalBo -= dlLc->bo;
964 ue->totalBo = 0; /* this case should not arise
965 * Resetting for safety */
968 ue->totalBo += boRpt->bo;
969 dlLc->bo = boRpt->bo;
970 dlLc->oldestSduArrTime = boRpt->oldestSduArrTime;
971 dlLc->staPduBo = boRpt->staPduBo;
973 dlLc->setMaxUlPrio = boRpt->setMaxUlPrio;
974 dlLc->setMaxDlPrio = boRpt->setMaxDlPrio;
975 /* Update the scheduler */
976 rgSCHUtlDlDedBoUpd(cell, ue, dlLc);
982 } /* end of rgMacSchDedBoUpdtReq */
986 * @brief Function for updating common channel BO at scheduler from MAC.
990 * Function : RgMacSchCmnBoUpdtReq
992 * This function shall be invoked whenever MAC gets staRsp from RLC
993 * Scheduler shall update BO in its common logical channel control block.
995 * @param[in] Pst* pst
996 * @param[in] S16 cellSapId
997 * @param[in] RgInfCmnBoRpt *boRpt
1001 S16 RgMacSchCmnBoUpdtReq(Pst* pst,RgInfCmnBoRpt *boRpt)
1004 Inst inst = (pst->dstInst - SCH_INST_START);
1005 S16 cellSapId = boRpt->cellSapId;
1008 /* No need to chk for cell being NULL as MAC would not have found instance if
1009 * it doesnt exist */
1010 cell = rgSchCb[inst].rgrSap[cellSapId].cell;
1011 if (cell->cellId != boRpt->cellId)
1013 DU_LOG("\nERROR --> SCH : RgMacSchCmnBoUpdtReq():"
1014 "Invalid boRpt cell Id:%d",boRpt->cellId);
1018 /* handle status response on CCCH */
1019 if(boRpt->lcId == cell->dlCcchId)
1021 DU_LOG("\nDEBUG --> SCH : RgMacSchCmnBoUpdtReq():"
1022 " BO update for CCCH");
1023 rgSCHUtlHndlCcchBoUpdt(cell, boRpt);
1027 rgSCHUtlHndlBcchPcchBoUpdt(cell, boRpt);
1031 } /* end of RgMacSchCmnBoUpdtReq */
1032 /*Fix: start: Inform UE delete to scheduler*/
1034 * @brief This API is used to send data indication to Scheduler instance from MAC.
1038 * Function : rgMacSchUeDelInd
1040 * This function shall be invoked whenever MAC gets Ue delete request.
1043 * @param[in] Pst* pst
1044 * @param[in] RgInfUeDelInd *ueDelInd
1048 S16 RgMacSchUeDelInd(Pst* pst,RgInfUeDelInd *ueDelInd)
1051 Inst inst = (pst->dstInst - SCH_INST_START);
1052 S16 cellSapId = ueDelInd->cellSapId;
1054 RgSchRntiLnk *rntiLnk=NULL;
1056 if (rgSchCb[inst].rgrSap == NULLP || rgSchCb[inst].rgrSap[cellSapId].cell == NULLP)
1058 DU_LOG("\nERROR --> SCH : rgrSap or cell is not configured");
1061 cell = rgSchCb[inst].rgrSap[cellSapId].cell;
1063 if (cell->cellId != ueDelInd->cellId)
1065 /* Handle Cell fetch failure */
1066 DU_LOG("\nERROR --> SCH : rgMacSchUeDelInd(): Invalid ueDelInd cell Id:%d",
1072 CM_LLIST_FIRST_NODE(&cell->rntiDb.rntiGuardPool, tmp);
1076 rntiLnk = (RgSchRntiLnk *)(tmp->node);
1077 if(rntiLnk->rnti == ueDelInd->rnti)
1079 cmLListDelFrm(&cell->rntiDb.rntiGuardPool, tmp);
1081 rgSCHDbmRlsRnti(cell, rntiLnk);
1082 DU_LOG("\nDEBUG --> SCH : RNTI:%d Released from the Guard pool(%d)",
1083 ueDelInd->rnti, cell->rntiDb.rntiGuardPool.count);
1087 CM_LLIST_NEXT_NODE(&cell->rntiDb.rntiGuardPool, tmp);
1091 rgEmtcMacSchUeDelInd(cell,ueDelInd);
1096 /* Fix : syed HO UE does not have a valid ue->rntiLnk */
1097 DU_LOG("\nINFO --> SCH : HO CRNTI:%d not present in the"
1098 "Guard Pool:%d", ueDelInd->rnti, cell->rntiDb.rntiGuardPool.count);
1102 } /* rgMacSchUeDelInd */
1103 /*Fix: end: Inform UE delete to scheduler*/
1105 * @brief This API is used to send data indication to Scheduler instance from MAC.
1109 * Function : rgMacSchSfRecpInd
1111 * This function shall be invoked whenever MAC gets datInd on TFU
1112 * Scheduler shall act on the CEs and data that are received as part of
1115 * @param[in] Pst* pst
1116 * @param[in] S16 cellSapId
1117 * @param[in] CmLteRnti rnti
1118 * @param[in] DatIndInfo *datInd
1122 S16 RgMacSchSfRecpInd(Pst* pst,RgInfSfDatInd *subfrmInfo)
1127 RgInfUeDatInd *datInd;
1129 Inst inst = (pst->dstInst - SCH_INST_START);
1133 S16 cellSapId = subfrmInfo->cellSapId;
1134 RgrUeStaIndInfo *ueStaInd;
1137 RgSchCmnUlUeSpsInfo *ulSpsUe ;
1145 uint16_t datIndActQci = 0;
1146 uint16_t combDatIndActQci = 0; /* Prev and Latest Dat Ind combined */
1147 uint16_t tempUeActQci = 0; /* UE specific Active QCIs */
1148 uint16_t diffBits = 0;
1152 /* No need to chk for cell being NULL as MAC wouldn't have found instance if
1153 * it doesnt exist */
1154 cell = rgSchCb[inst].rgrSap[cellSapId].cell;
1156 /* lnkLst assignment */
1157 lnkLst = &(subfrmInfo->ueLst);
1159 CM_LLIST_FIRST_NODE(lnkLst, tmp);
1161 while((NULLP != tmp) && ((RgInfUeDatInd *)tmp->node != NULLP))
1167 datInd = (RgInfUeDatInd *)tmp->node;
1168 rnti = datInd->rnti;
1170 /* We shall try and find
1171 * out the RaCb based on the following -
1172 * 1. If the incoming PDU contained a CCCH SDU i.e. this is message 3.
1173 * 2. If the incoming PDU contained a CRNTI control element, i.e. we should
1174 * have a ueCb also for this
1177 /* It could be that a non-msg3 pdu contains a CRNTI Control element. We
1178 * should check for CRNTI CE and if it exists the UECb must exist, also an
1179 * if the CRNTI in the CE and the one with which the message came in are
1180 * different we shall look for an raCb as well.
1182 if (datInd->ceInfo.bitMask & RGSCH_CRNTI_CE_PRSNT)
1184 /* SR_RACH_STATS : CRNTI CE*/
1187 if (datInd->ceInfo.bitMask & RGSCH_CCCH_SDU_PRSNT)
1189 RGSCH_FREE_MEM(subfrmInfo);
1190 err.errType = RGSCHERR_TOM_DATIND;
1191 DU_LOG("\nDEBUG --> SCH : Received MSG3 with CRNTI:%d and also CCCH ",
1192 datInd->ceInfo.ces.cRnti);
1195 ue = rgSCHDbmGetUeCb (cell, datInd->ceInfo.ces.cRnti);
1198 /* SR_RACH_STATS : CRNTI CE UECB NOT FOUND*/
1199 rgNumCrntiCeCrntiNotFound++;
1200 /* ccpu00141318 - Removed condition for SPS rnti checking*/
1201 RGSCH_FREE_MEM(subfrmInfo);
1202 err.errType = RGSCHERR_TOM_DATIND;
1203 DU_LOG("\nERROR --> SCH : Received MSG3 "
1204 "with CRNTI:%d unable to find ueCb",
1205 datInd->ceInfo.ces.cRnti);
1209 if ((ret = rgSCHUtlProcMsg3 (subfrmInfo, cell, ue,
1210 rnti, datInd, &err)) != ROK)
1212 RGSCH_FREE_MEM(subfrmInfo);
1213 err.errType = RGSCHERR_TOM_DATIND;
1214 DU_LOG("\nERROR --> SCH : Processing for MSG3 failed for CRNTI:%d",
1220 rgSCHUtlHdlCrntiCE (cell, ue);
1222 ret = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&ueStaInd,
1223 sizeof(RgrUeStaIndInfo));
1226 ueStaInd->status = RGR_UESTA_MAC_CRNTI_CE_RECVD;
1229 ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue);
1230 if(ulSpsUe->isUlSpsActv)
1232 ueStaInd->status = RGR_UESTA_MAC_CRNTI_CE_RECVD_IN_SPS_ACTIVE;
1233 ue->ul.ulSpsCfg.isLcSRMaskEnab = FALSE;
1236 ret = rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInd);
1239 DU_LOG("\nERROR --> SCH : Could not Send Ue Sta Ind UEID:%d",ue->ueId);
1242 CM_LLIST_NEXT_NODE(lnkLst, tmp);
1244 } /* end of CRNTI based message */
1245 else if (datInd->ceInfo.bitMask & RGSCH_CCCH_SDU_PRSNT)
1247 /* SR_RACH_STATS : CCCH SDU */
1249 /* SR_RACH_STATS : CCCH SDU RACB NOT FOUND*/
1250 if (NULLP == rgSCHDbmGetRaCb (cell, rnti))
1252 rgNumCCCHSduCrntiNotFound++;
1255 if ((ret = rgSCHUtlProcMsg3 (subfrmInfo, cell, ue,
1256 rnti, datInd, &err)) != ROK)
1258 RGSCH_FREE_MEM(subfrmInfo);
1259 err.errType = RGSCHERR_TOM_DATIND;
1260 DU_LOG("\nERROR --> SCH : Processing for MSG3 failed for CRNTI:%d",
1265 CM_LLIST_NEXT_NODE(lnkLst, tmp);
1267 } /* end of Msg3 processing */
1271 ue = rgSCHDbmGetUeCb (cell, datInd->rnti);
1275 if((ue = rgSCHDbmGetSpsUeCb (cell, datInd->rnti)) == NULLP)
1278 RGSCH_FREE_MEM(subfrmInfo);
1279 err.errType = RGSCHERR_TOM_DATIND;
1280 DU_LOG("\nERROR --> SCH : Unable to get the UE CB for CRNTI:%d",
1288 /* The LCs for which data is received at MAC is provided to SCH.
1289 This information is used to estimate the Active LCs at UE
1290 since estimates based on only BSR is not accurate */
1291 if (datInd->ceInfo.bitMask & RGSCH_ACTIVE_LC_PRSNT)
1294 /* Compose a Bitmask with for the QCI's for which Data
1296 for (lcCount = 0; lcCount < RGINF_MAX_NUM_DED_LC; lcCount++)
1298 if ((datInd->ceInfo.ulActLCs[lcCount] == TRUE) && (TRUE == ue->ul.lcCb[lcCount].isValid))
1300 datIndActQci |= (1 << (ue->ul.lcCb[lcCount].qciCb->qci -1));
1303 if (ue->ulActiveLCs && ue->lastDatIndLCs)
1305 /* Combine previous Dat Ind and current Dat Ind to
1306 estimate active LCs at UE */
1307 combDatIndActQci = ue->lastDatIndLCs | datIndActQci;
1308 tempUeActQci = ue->ulActiveLCs;
1309 ue->ulActiveLCs = combDatIndActQci;
1310 diffBits = combDatIndActQci ^ tempUeActQci;
1316 if (0x1 & tempUeActQci)
1318 /* An active QCI has become inactive */
1319 cell->qciArray[qci].ulUeCount--;
1323 /* An Inactive QCI has become active */
1324 cell->qciArray[qci].ulUeCount++;
1331 ue->lastDatIndLCs = datIndActQci;
1335 #endif /* LTE_L2_MEAS */
1336 /* Just copy the timing information from the dat indication into the one
1337 * stored in the UE CB, will be later utilized to handle Timing advance
1340 if ((ret = rgSCHUtlUpdSch (subfrmInfo, cell, ue, datInd, &err)) != ROK)
1342 RGSCH_FREE_MEM(subfrmInfo);
1343 err.errType = RGSCHERR_TOM_DATIND;
1344 DU_LOG("\nERROR --> SCH : Unable to handle Data"
1345 " Indication for UEID:%d",ue->ueId);
1349 CM_LLIST_NEXT_NODE(lnkLst, tmp);
1352 /* update the UL PRB usage for all GBR QCIs*/
1353 for (idx = 0; idx < RGM_MAX_QCI_REPORTS; idx++)
1355 cell->prbUsage.qciPrbRpts[idx].ulTotPrbUsed += subfrmInfo->qcisUlPrbCnt[idx];
1359 /* chk if Sch needs to dealloc datInd after unpk */
1360 RGSCH_FREE_MEM(subfrmInfo);
1362 } /* rgMacSchSfRecpInd */
1366 * @brief Function to handle relInd from MAC for a UE
1370 * Function: RgMacSchSpsRelInd
1372 * Handler for processing relInd for UL SPS of a UE
1379 * @param[in] Pst *pst
1380 * @param[in] RgInfSpsRelInfo *relInfo
1385 S16 RgMacSchSpsRelInd(Pst *pst,RgInfSpsRelInfo *relInfo)
1389 Inst inst = (pst->dstInst - SCH_INST_START);
1392 /* No need to chk for cell being NULL as MAC wouldn't have found instance if
1393 * it doesnt exist */
1394 cell = rgSchCb[inst].rgrSap[relInfo->cellSapId].cell;
1396 if ((ue = rgSCHDbmGetUeCb(cell, relInfo->cRnti)) == NULLP)
1398 DU_LOG("\nERROR --> SCH : No Ue exists with CRNTI:%d",relInfo->cRnti);
1402 if ((rgSCHUtlSpsRelInd(cell, ue, relInfo->isExplRel)) != ROK)
1404 DU_LOG("\nERROR --> SCH : RelInd processing for CRNTI:%d failed",relInfo->cRnti);
1408 } /* end of RgMacSchSpsRelInd */
1409 #endif /* LTEMAC_SPS */
1414 * @brief Function to handle L2MeasCfm from MAC
1418 * Function: RgMacSchL2MeasCfm
1420 * Handler for processing L2 measurement confirm
1427 * @param[in] Pst *pst
1428 * @param[in] RgInfL2MeasCfm *measCfm
1433 S16 RgMacSchL2MeasCfm(Pst *pst, RgInfL2MeasCfm *measCfm)
1435 RgSchCellCb *cell = NULLP;
1436 Inst inst = (pst->dstInst - SCH_INST_START);
1438 RgSchL2MeasCb *measCb = NULLP;
1439 RgSchCb *instCb = &rgSchCb[inst];
1441 LrgSchMeasCfmInfo schMeasCfm;
1443 uint8_t idx1; /*LTE_L2_MEAS_PHASE2*/
1446 /* Find the cellCb using cellId in measInfo. Iterate through all cells
1447 * in rgrsapCb in RgschCb */
1448 for (idx = 0; idx < instCb->numSaps; idx++)
1450 if ( instCb->rgrSap[idx].cell->cellId == measCfm->cellId)
1452 /* got the cell break the loop */
1453 cell = instCb->rgrSap[idx].cell;
1457 /* If no cellCb return Err with Invalid Cell Id */
1460 DU_LOG("\nERROR --> SCH : Meas Cfm Failed.Invalid Cell Id");
1465 /* Iterate through all meas requests in l2mList in cellCb */
1466 lnk = cell->l2mList.first;
1469 /* Get the MeasCb : RgSchL2MeasCb */
1470 measCb = (RgSchL2MeasCb *)lnk->node;
1472 if (measCb->measReq.hdr.transId == measCfm->transId)
1477 if ( measCb == NULLP )
1483 if(measCfm->cfm.status != LCM_PRIM_OK)
1485 for (idx = 0; idx < measCb->measReq.avgPrbQciUl.numQci; idx++)
1487 qciVal = measCb->measReq.avgPrbQciUl.qci[idx];
1488 cell->qciArray[qciVal].qci = 0;
1490 /* Delete this measCb, send the negative confirmation to
1492 cmLListDelFrm(&cell->l2mList, &measCb->measLnk);
1493 /* ccpu00117052 - MOD - Passing double pointer
1494 for proper NULLP assignment*/
1495 rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb, sizeof(RgSchL2MeasCb));
1496 memset(&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
1497 schMeasCfm.measType = measCfm->measType;
1498 schMeasCfm.cfm = measCfm->cfm;
1499 schMeasCfm.hdr.transId = measCfm->transId;
1500 schMeasCfm.cellId = measCfm->cellId;
1501 RgMiLrgSchL2MeasCfm(&(instCb->rgSchInit.lmPst), &schMeasCfm);
1504 for(idx = 0; idx < measCfm->u.prbCfm.numQci; idx++)
1506 measCb->avgPrbQciUl.prbUsage[idx].prbUsage = measCfm->u.prbCfm.prbUsage[idx].prbUsage;
1507 measCb->avgPrbQciUl.prbUsage[idx].qciValue = measCfm->u.prbCfm.prbUsage[idx].qciValue;
1508 /*LTE_L2_MEAS_PHASE2*/
1509 qciVal1 = measCfm->u.prbCfm.prbUsage[idx].qciValue;
1510 for(idx1=0;idx1<measCb->measReq.avgPrbQciUl.numQci;idx1++)
1512 if(measCb->measReq.avgPrbQciUl.qci[idx1] == qciVal1)
1517 if(idx1 == measCb->measReq.avgPrbQciUl.numQci)
1519 measCb->measReq.avgPrbQciUl.qci[measCb->measReq.avgPrbQciUl.numQci++] = qciVal1;
1522 measCb->avgPrbQciUl.numQci = measCfm->u.prbCfm.numQci;
1523 measCb->cfmRcvd = TRUE;
1524 cell->sndL2Meas = TRUE;
1526 } /* end of RgMacSchL2MeasCfm */
1529 * @brief Function to handle L2MeasStopCfm from MAC
1533 * Function: RgMacSchL2MeasStopCfm
1535 * Handler for processing L2 measurement confirm
1542 * @param[in] Pst *pst
1543 * @param[in] RgInfL2MeasCfm *measCfm
1548 S16 RgMacSchL2MeasStopCfm(Pst *pst,RgInfL2MeasCfm *measCfm)
1550 LrgSchMeasCfmInfo schMeasCfm;
1551 Inst inst = (pst->dstInst - SCH_INST_START);
1552 RgSchCb *instCb = &rgSchCb[inst];
1554 memset(&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
1555 schMeasCfm.measType = measCfm->measType;
1556 schMeasCfm.cfm = measCfm->cfm;
1557 schMeasCfm.hdr.transId = measCfm->transId;
1558 schMeasCfm.cellId = measCfm->cellId;
1559 RgMiLrgSchL2MeasStopCfm(&(instCb->rgSchInit.lmPst), &schMeasCfm);
1564 /************** TFU Interface *************/
1567 * @brief Bind confirm API for TFU SAP on scheduler instance.
1571 * Function : RgLiTfuSchBndCfm
1573 * This API is invoked by PHY to confirm TFU SAP bind.
1576 * @param[in] Pst *pst
1577 * @param[in] SuId suId
1578 * @param[in] uint8_t status
1583 S16 RgLiTfuSchBndCfm (Pst *pst,SuId suId, uint8_t status)
1586 RgSchLowSapCb *tfuSap;
1587 Inst instId = pst->dstInst - SCH_INST_START;
1589 if(suId >= rgSchCb[instId].numSaps)
1591 DU_LOG("\nERROR --> SCH : Incorrect SuId");
1594 /* Lets validate suId first */
1595 tfuSap = &(rgSchCb[instId].tfuSap[suId]);
1597 if (suId != tfuSap->sapCfg.suId)
1599 DU_LOG("\nERROR --> SCH : Incorrect SuId. Configured (%d)"
1600 "Recieved (%d)", tfuSap->sapCfg.suId, suId);
1603 ret = rgSCHLmmBndCfm (pst, suId, status);
1605 } /* RgLiTfuSchBndCfm */
1608 * @brief Random Access Request indication from PHY.
1612 * Function : RgLiTfuRaReqInd
1614 * This API is invoked by PHY to send Random Access Request to Scheduler.
1615 * This API contains information for Random Access Request including
1616 * raRnti, list of associated RAPIDs and related information.
1618 * @param[in] Pst *pst
1619 * @param[in] SuId suId
1620 * @param[in] TfuRaReqIndInfo *raReqInd
1625 S16 RgLiTfuRaReqInd(Pst *pst,SuId suId, TfuRaReqIndInfo *raReqInd)
1628 Inst inst = pst->dstInst-SCH_INST_START;
1630 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1632 DU_LOG("\nERROR --> SCH : SAP Validation failed SuId(%d)", suId);
1633 /* Free up the memory for the request structure */
1634 RGSCH_FREE_MEM(raReqInd);
1638 if(raReqInd == NULLP)
1640 DU_LOG("\nERROR --> SCH : Invalid input pointer for raReqInd Failed");
1644 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1646 DU_LOG("\nERROR --> SCH : No cell exists");
1650 ret = rgSCHTomRaReqInd(rgSchCb[inst].tfuSap[suId].cell, raReqInd);
1651 /* Free up the memory for the request structure */
1652 RGSCH_FREE_MEM(raReqInd);
1653 /*SPutSBuf (pst->region, pst->pool, (Data *)raReqInd,
1654 sizeof(TfuRaReqIndInfo)); */
1656 } /* RgLiTfuRaReqInd */
1659 * @brief Uplink CQI indication from PHY.
1663 * Function : RgLiTfuUlCqiInd
1665 * This API is invoked by PHY to send Uplink CQI to Scheduler.
1666 * This API contains Uplink CQI information reported per UE.
1668 * @param[in] Pst *pst
1669 * @param[in] SuId suId
1670 * @param[in] TfuUlCqiIndInfo *ulCqiInd
1675 S16 RgLiTfuUlCqiInd(Pst *pst, SuId suId, TfuUlCqiIndInfo *ulCqiInd)
1678 Inst inst = pst->dstInst-SCH_INST_START;
1680 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1682 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1683 /* Free up the memory for the request structure */
1684 RGSCH_FREE_MEM(ulCqiInd);
1688 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1690 DU_LOG("\nERROR --> SCH : No cell exists");
1691 /* Free up the memory for the request structure */
1692 RGSCH_FREE_MEM(ulCqiInd);
1695 ret = rgSCHTomUlCqiInd (rgSchCb[inst].tfuSap[suId].cell, ulCqiInd);
1696 /* Free up the memory for the request structure */
1697 RGSCH_FREE_MEM(ulCqiInd);
1699 } /* RgLiTfuUlCqiInd */
1702 * @brief PUCCH power adjustment indication.
1706 * Function : RgLiTfuPucchDeltaPwrInd
1708 * This API is invoked by PHY to send PUCCH power adjustment
1711 * @param[in] Pst *pst
1712 * @param[in] SuId suId
1713 * @param[in] TfuPucchDeltaPwrIndInfo *pucchDeltaPwr
1718 S16 RgLiTfuPucchDeltaPwrInd(Pst *pst,SuId suId,TfuPucchDeltaPwrIndInfo *pucchDeltaPwr)
1721 Inst inst = pst->dstInst-SCH_INST_START;
1723 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1725 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1726 /* Free up the memory for the request structure */
1727 RGSCH_FREE_MEM(pucchDeltaPwr);
1731 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1733 DU_LOG("\nERROR --> SCH : No cell exists");
1736 ret = rgSCHTomPucchDeltaPwrInd (rgSchCb[inst].tfuSap[suId].cell, pucchDeltaPwr);
1737 /* Free up the memory for the request structure */
1738 RGSCH_FREE_MEM(pucchDeltaPwr);
1740 } /* RgLiTfuPucchDeltaPwrInd */
1744 * @brief HARQ ACK indication from PHY for Downlink transmissions.
1748 * Function : RgLiTfuHqInd
1750 * This API is invoked by PHY to send HARQ ACK information to Scheduler
1751 * on recieving HARQ ACK/NACK from UEs.
1752 * This API contains HARQ ACK information recieved by PHY for downlink
1755 * @param[in] Pst *pst
1756 * @param[in] SuId suId
1757 * @param[in] TfuHqIndInfo *harqAckInd
1762 S16 RgLiTfuHqInd(Pst *pst, SuId suId, TfuHqIndInfo *harqAckInd)
1765 Inst inst = (pst->dstInst - SCH_INST_START);
1769 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1771 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1772 RGSCH_FREE_MEM(harqAckInd);
1776 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1778 DU_LOG("\nERROR --> SCH : No cell exists");
1783 /* Now call the TOM (Tfu ownership module) primitive to process further */
1784 ret = rgSCHTomHarqAckInd (rgSchCb[inst].tfuSap[suId].cell, harqAckInd);
1785 /* Free up the memory for the request structure */
1786 RGSCH_FREE_MEM(harqAckInd);
1788 } /* RgLiTfuHqInd */
1792 * @brief Scheduling request(SR) indication from PHY for an UE.
1796 * Function : RgLiTfuSrInd
1798 * This API is invoked by PHY to send Scheduling request information to
1799 * Scheduler on recieving SR from a list of UEs.
1800 * This API contains scheduling request information recieved by PHY for UEs.
1802 * @param[in] Pst *pst
1803 * @param[in] SuId suId
1804 * @param[in] TfuSrIndInfo *srInd
1809 S16 RgLiTfuSrInd(Pst *pst, SuId suId, TfuSrIndInfo *srInd)
1812 Inst inst = pst->dstInst-SCH_INST_START;
1815 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1817 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1818 RGSCH_FREE_MEM(srInd);
1822 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1824 DU_LOG("\nERROR --> SCH : RgLiTfuSrInd()No cell exists");
1828 /* Now call the TOM (Tfu ownership module) primitive to process further */
1829 ret = rgSCHTomSrInd (rgSchCb[inst].tfuSap[suId].cell, srInd);
1830 /* Free up the memory for the request structure */
1831 RGSCH_FREE_MEM(srInd);
1833 } /* RgLiTfuSrInd */
1837 * @brief Downlink CQI indication from PHY for an UE.
1841 * Function : RgLiTfuDlCqiInd
1843 * This API is invoked by PHY to send Downlink CQI indication to Scheduler
1844 * on recieving downlink CQI from UE.
1845 * This API contains downlink CQI information recieved by PHY for an UE.
1847 * @param[in] Pst *pst
1848 * @param[in] SuId suId
1849 * @param[in] TfuDlCqiIndInfo *dlCqiInd
1854 S16 RgLiTfuDlCqiInd(Pst *pst, SuId suId, TfuDlCqiIndInfo *dlCqiInd)
1857 Inst inst = pst->dstInst-SCH_INST_START;
1859 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1861 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1862 /* Free up the memory for the request structure */
1863 RGSCH_FREE_MEM(dlCqiInd);
1867 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1869 DU_LOG("\nERROR --> SCH : No cell exists");
1872 ret = rgSCHTomDlCqiInd (rgSchCb[inst].tfuSap[suId].cell, dlCqiInd);
1873 /* Free up the memory for the request structure */
1874 RGSCH_FREE_MEM(dlCqiInd);
1876 } /* RgLiTfuDlCqiInd */
1880 * @brief Raw CQI indication from PHY for an UE.
1884 * Function : RgLiTfuRawCqiInd
1886 * This API is invoked by PHY to send Raw CQI indication to Scheduler
1887 * on receiving Raw CQI from UE.
1888 * This API contains Raw CQI information recieved by PHY for an UE.
1890 * @param[in] Pst *pst
1891 * @param[in] SuId suId
1892 * @param[in] TfuRawCqiIndInfo *rawCqiInd
1897 S16 RgLiTfuRawCqiInd(Pst *pst, SuId suId, TfuRawCqiIndInfo *rawCqiInd)
1900 Inst inst = pst->dstInst-SCH_INST_START;
1903 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1905 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1906 /* Free up the memory for the request structure */
1907 RGSCH_FREE_MEM(rawCqiInd);
1911 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1913 DU_LOG("\nERROR --> SCH : No cell exists");
1917 ret = rgSCHTomRawCqiInd (rgSchCb[inst].tfuSap[suId].cell, rawCqiInd);
1918 /* Free up the memory for the request structure */
1919 RGSCH_FREE_MEM(rawCqiInd);
1921 } /* RgLiTfuRawCqiInd */
1924 * @brief SRS indication from PHY for an UE.
1928 * Function : RgLiTfuSrsInd
1930 * This API is invoked by PHY to send UL SRS indication to Scheduler
1931 * on receiving a SRS from UE.
1932 * This API contains SRS information recieved by PHY for an UE.
1934 * @param[in] Pst *pst
1935 * @param[in] SuId suId
1936 * @param[in] TfuSrsIndInfo *srsInd
1941 S16 RgLiTfuSrsInd(Pst *pst, SuId suId, TfuSrsIndInfo *srsInd)
1944 Inst inst = pst->dstInst-SCH_INST_START;
1946 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1948 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1949 /* Free up the memory for the request structure */
1950 RGSCH_FREE_MEM(srsInd);
1954 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
1956 DU_LOG("\nERROR --> SCH : No cell exists");
1959 ret = rgSCHTomSrsInd (rgSchCb[inst].tfuSap[suId].cell, srsInd);
1960 /* Free up the memory for the request structure */
1961 RGSCH_FREE_MEM(srsInd);
1963 } /* RgLiTfuSrsInd */
1968 * @brief DOA indication from PHY for an UE.
1972 * Function : RgLiTfuDoaInd
1974 * This API is invoked by PHY to send Direction Of Arrival to Scheduler
1975 * on calculating DOA at PHYSICAL LAYER for an UE.
1976 * This API contains DOA information calculated by PHY for an UE.
1978 * @param[in] Pst *pst
1979 * @param[in] SuId suId
1980 * @param[in] TfuDoaIndInfo *doaInd
1985 S16 RgLiTfuDoaInd(Pst *pst, SuId suId, TfuDoaIndInfo *doaInd)
1988 Inst inst = pst->dstInst-SCH_INST_START;
1990 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
1992 DU_LOG("\nERROR --> SCH : SAP Validation failed");
1993 /* Free up the memory for the request structure */
1994 RGSCH_FREE_MEM(doaInd);
1998 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
2000 DU_LOG("\nERROR --> SCH : No cell exists");
2003 ret = rgSCHTomDoaInd (rgSchCb[inst].tfuSap[suId].cell, doaInd);
2004 /* Free up the memory for the request structure */
2005 RGSCH_FREE_MEM(doaInd);
2007 } /* RgLiTfuDlCqiInd */
2010 * @brief CRC indication from PHY.
2014 * Function : RgLiTfuCrcInd
2016 * This API is invoked by PHY to give CRC indication to scheduler.
2018 * @param[in] Pst *pst
2019 * @param[in] SuId suId
2020 * @param[in] TfuCrcIndInfo *crcInd
2025 S16 RgLiTfuCrcInd(Pst *pst, SuId suId, TfuCrcIndInfo *crcInd)
2028 Inst inst = pst->dstInst-SCH_INST_START;
2030 #ifdef XEON_SPECIFIC_CHANGES
2031 struct timeval start6, end6;
2032 gettimeofday(&start6, NULL);
2035 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
2037 DU_LOG("\nERROR --> SCH : SAP Validation failed");
2038 RGSCH_FREE_MEM(crcInd);
2042 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
2044 DU_LOG("\nERROR --> SCH : No cell exists");
2049 /* Now call the TOM (Tfu ownership module) primitive to process further */
2050 ret = rgSCHTomCrcInd(rgSchCb[inst].tfuSap[suId].cell, crcInd);
2051 /* Free up the memory for the request structure */
2052 RGSCH_FREE_MEM(crcInd);
2053 #ifdef XEON_SPECIFIC_CHANGES
2054 gettimeofday(&end6, NULL);
2057 } /* RgLiTfuCrcInd */
2060 * @brief Timing Advance indication from PHY.
2064 * Function : RgLiTfuTimingAdvInd
2066 * This API is invoked by PHY to indicate timing advance to Scheduler for
2069 * @param[in] Pst *pst
2070 * @param[in] SuId suId
2071 * @param[in] TfuTimingAdvIndInfo *timingAdvInd
2076 S16 RgLiTfuTimingAdvInd(Pst *pst, SuId suId, TfuTimingAdvIndInfo *timingAdvInd)
2079 Inst inst = pst->dstInst-SCH_INST_START;
2081 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
2083 DU_LOG("\nERROR --> SCH : SAP Validation failed");
2084 /* Free up the memory for the request structure */
2085 RGSCH_FREE_MEM(timingAdvInd);
2089 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
2091 DU_LOG("\nERROR --> SCH : No cell exists");
2094 /* Now call the TOM (Tfu ownership module) primitive to process further */
2095 ret = rgSCHTomTimingAdvInd(rgSchCb[inst].tfuSap[suId].cell, timingAdvInd);
2096 /* Free up the memory for the request structure */
2097 RGSCH_FREE_MEM(timingAdvInd);
2099 } /* RgLiTfuTimingAdvInd */
2101 /************* RGM Interface ****************/
2103 * @brief API for bind request from RRM towards MAC.
2107 * Function: RgUiRgmBndReq
2109 * This API is invoked by RRM towards MAC to bind RGM SAP.
2110 * These API validates the Pst, spId, suId and sends the bind confirm to
2114 * @param[in] Pst *pst
2115 * @param[in] SuId suId
2116 * @param[in] SpId spId
2121 S16 RgUiRgmBndReq(Pst *pst,SuId suId,SpId spId)
2124 Pst tmpPst; /* Temporary Post Structure */
2125 Inst instId = pst->dstInst-SCH_INST_START;
2127 tmpPst.prior = pst->prior;
2128 tmpPst.route = pst->route;
2129 tmpPst.selector = pst->selector;
2130 tmpPst.region = rgSchCb[instId].rgSchInit.region;
2131 tmpPst.pool = rgSchCb[instId].rgSchInit.pool;
2133 tmpPst.srcProcId = rgSchCb[instId].rgSchInit.procId;
2134 tmpPst.srcEnt = rgSchCb[instId].rgSchInit.ent;
2135 tmpPst.srcInst = rgSchCb[instId].rgSchInit.inst + SCH_INST_START;
2137 tmpPst.event = EVTNONE;
2139 tmpPst.dstProcId = pst->srcProcId;
2140 tmpPst.dstEnt = pst->srcEnt;
2141 tmpPst.dstInst = pst->srcInst;
2143 /*TODO remove follo statement*/
2144 rgSchCb[instId].rgmSap[spId].sapSta.sapState = LRG_UNBND;
2146 if(spId < rgSchCb[instId].numSaps)
2148 /* Check the state of the SAP */
2149 switch (rgSchCb[instId].rgmSap[spId].sapSta.sapState)
2151 /* This case might not be needed if SAP not configured then it will go
2152 * to else of above if condition */
2153 case LRG_UNBND: /* SAP is not bound */
2154 DU_LOG("\nDEBUG --> SCH : SAP is not yet bound");
2155 rgSchCb[instId].rgmSap[spId].sapSta.sapState = LRG_BND;
2156 rgSchCb[instId].rgmSap[spId].sapCfg.suId = suId;
2157 /* Send Bind Confirm with status as SUCCESS */
2158 ret = rgSCHUtlRgmBndCfm(instId, suId, CM_BND_OK);
2159 /*Indicate to Layer manager */
2161 case LRG_BND: /* SAP is already bound*/
2162 DU_LOG("\nDEBUG --> SCH : SAP is already bound");
2163 ret = rgSCHUtlRgmBndCfm(instId, suId, CM_BND_OK);
2165 default: /* Should Never Enter here */
2166 #if (ERRCLASS & ERRCLS_ADD_RES)
2167 DU_LOG("\nERROR --> SCH : Invalid SAP State:RgUiRgmBndReq failed\n");
2169 ret = rgSCHUtlRgmBndCfm(instId, suId, CM_BND_NOK);
2175 #if (ERRCLASS & ERRCLS_ADD_RES)
2176 /* ccpu00117035 - MOD - Changed ErrVal argument from accessing sap state
2177 to spId to avoid seg fault due to invalid sapID */
2178 DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRrmBndReq failed\n");
2180 ret = RgUiRgmBndCfm(&tmpPst, suId, CM_BND_NOK);
2183 } /* RgUiRgmBndReq */
2186 * @brief API for unbind request from RRM towards MAC.
2190 * Function: RgUiRgmUbndReq
2192 * This API is invoked by RRM towards MAC to unbind RGM SAP.
2193 * These API validates the Pst, spId, suId and transfers the unbind request
2194 * specific information to corresponding ownership module (GOM) API.
2197 * @param[in] Pst *pst
2198 * @param[in] SuId suId
2199 * @param[in] Reason reason
2204 S16 RgUiRgmUbndReq(Pst *pst,SpId spId,Reason reason)
2206 Inst instId = pst->dstInst-SCH_INST_START;
2208 /* SAP Id validation */
2209 if (spId < rgSchCb[instId].numSaps)
2211 switch(rgSchCb[instId].rgmSap[spId].sapSta.sapState)
2213 case LRG_BND: /* SAP is already bound*/
2214 /* setting SAP state to UN BOUND */
2215 DU_LOG("\nDEBUG --> SCH : SAP is already bound");
2216 rgSchCb[instId].rgmSap[spId].sapSta.sapState = LRG_UNBND;
2219 #if (ERRCLASS & ERRCLS_ADD_RES)
2220 DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgmUbndReq failed\n");
2227 #if (ERRCLASS & ERRCLS_ADD_RES)
2228 DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgmUbndReq failed\n");
2233 } /* RgUiRgmUbndReq */
2237 * @brief API for start or stop PRB reporting from RRM towards MAC.
2241 * Function: RgUiRgmCfgPrbRprt
2243 * This API is invoked by RRM towards MAC to start or stop calculating
2244 * Average PRB usage in downlink and uplink. The average PRB usage will
2245 * be reported to RRM based on confiured periodicity.
2248 * @param[in] Pst *pst
2249 * @param[in] SuId suId
2250 * @param[in] SpId spId
2255 S16 RgUiRgmCfgPrbRprt(Pst *pst, SpId spId,RgmPrbRprtCfg *prbRprtCfg)
2259 RgSchPrbUsage *prbUsage;
2260 Inst inst = (pst->dstInst - SCH_INST_START);
2262 cell = rgSchCb[inst].rgmSap[spId].cell;
2263 prbUsage = &cell->prbUsage;
2264 prbUsage->prbRprtEnabld = prbRprtCfg->bConfigType;
2265 prbUsage->rprtPeriod = prbRprtCfg->usPrbAvgPeriodicty;
2266 RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, prbUsage->startTime, 1);
2268 /* clear the qciPrbRpts for all GBR QCIs */
2269 memset(&prbUsage->qciPrbRpts[0], 0,
2270 (RGM_MAX_QCI_REPORTS * sizeof(RgSchQciPrbUsage)));
2271 DU_LOG("\nDEBUG --> SCH : RgUiRgmCfgPrbRprt config type %d with the report period %d",
2272 prbUsage->prbRprtEnabld,prbUsage->rprtPeriod);
2274 /* ccpu00134393 : mem leak fix */
2275 SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
2280 * @brief ERROR INDICATION from PHY for the i failed unlicensed Scell transmission.
2284 * Function : RgLiTfuErrInd
2286 * This API is invoked by PHY to send ERROR INDICATION to scheduler
2287 * Currently invoked in the cases when the Unlicensed SCell transmission
2289 * This API contains the Cell and subframe information for which the
2290 * transmission failed.
2292 * @param[in] Pst *pst
2293 * @param[in] SuId suId
2294 * @param[in] TfuErrIndInfo *errIndInfo
2299 S16 RgLiTfuErrInd(Pst *pst, SuId suId, TfuErrIndInfo *errInd)
2303 Inst inst = (pst->dstInst - SCH_INST_START);
2307 if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
2310 DU_LOG("\nERROR --> SCH : SAP Validation failed");
2314 if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
2316 DU_LOG("\nERROR --> SCH : No cell exists");
2322 /* Now call the TOM (Tfu ownership module) primitive to process further */
2323 ret = rgSCHLaaErrInd(rgSchCb[inst].tfuSap[suId].cell, errInd);
2326 } /* RgLiTfuErrInd */
2330 /**********************************************************************
2333 **********************************************************************/