X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Frg_sch.c;fp=src%2F5gnrsch%2Frg_sch.c;h=5cf8f4653b80acaf017e851313a2d0c7a6df6882;hb=3235ecfc7414aa0b72d0ad50db63ae8b5626045b;hp=0000000000000000000000000000000000000000;hpb=997e3f26d55352586a1d4d0c46c41a98452af88a;p=o-du%2Fl2.git diff --git a/src/5gnrsch/rg_sch.c b/src/5gnrsch/rg_sch.c new file mode 100755 index 000000000..5cf8f4653 --- /dev/null +++ b/src/5gnrsch/rg_sch.c @@ -0,0 +1,3083 @@ +/******************************************************************************* +################################################################################ +# Copyright (c) [2017-2019] [Radisys] # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +################################################################################ +*******************************************************************************/ + +/************************************************************************ + + Name: LTE-MAC layer + + Type: C source file + + Desc: C source code for Entry point fucntions + + File: rg_sch.c + +**********************************************************************/ + +/** @file rg_sch.c +@brief This file implements the schedulers main access to MAC layer code. +*/ + +static const char* RLOG_MODULE_NAME="MAC"; +static int RLOG_FILE_ID=185; +static int RLOG_MODULE_ID=4096; + +/* header include files -- defines (.h) */ +#include "envopt.h" /* environment options */ +#include "envdep.h" /* environment dependent */ +#include "envind.h" /* environment independent */ +#include "gen.h" /* general layer */ +#include "ssi.h" /* system service interface */ +#include "cm_hash.h" /* common hash list */ +#include "cm_llist.h" /* common linked list library */ +#include "cm_err.h" /* common error */ +#include "cm_lte.h" /* common LTE */ +#include "lrg.h" +#include "rgr.h" +#include "tfu.h" +#include "rgm.h" +#include "rg_env.h" +#include "rg_sch_inf.h" +#include "rg_sch.h" +#include "rg_sch_err.h" +#include "rg_sch_cmn.h" +#include "rl_interface.h" +#include "rl_common.h" + +/* header/extern include files (.x) */ +#include "gen.x" /* general layer typedefs */ +#include "ssi.x" /* system services typedefs */ +#include "cm5.x" /* common timers */ +#include "cm_hash.x" /* common hash list */ +#include "cm_lib.x" /* common library */ +#include "cm_llist.x" /* common linked list */ +#include "cm_mblk.x" /* memory management */ +#include "cm_tkns.x" /* common tokens */ +#include "cm_lte.x" /* common tokens */ +#include "tfu.x" /* TFU types */ +#include "lrg.x" /* layer management typedefs for MAC */ +#include "rgr.x" /* layer management typedefs for MAC */ +#include "rgm.x" /* layer management typedefs for MAC */ +#include "rg_sch_inf.x" /* typedefs for Scheduler */ +#include "rg_sch.x" /* typedefs for Scheduler */ +#include "rg_sch_cmn.x" + +#ifdef EMTC_ENABLE +EXTERN S16 rgEmtcMacSchUeDelInd ARGS((RgSchCellCb *cell,RgInfUeDelInd *ueDelInd)); +EXTERN S16 rgSCHGomEmtcHndlSiCfg ARGS(( +Region reg, +Pool pool, +RgSchCb *instCb, +SpId spId, +RgrCfgTransId transId, +RgrSiCfgReqInfo *cfgReqInfo +)); +EXTERN S16 rgSCHGomEmtcHndlWarningSiCfg ARGS(( +Region reg, +Pool pool, +RgSchCb *instCb, +SpId spId, +RgrCfgTransId transId, +RgrWarningSiCfgReqInfo *warningSiCfgReqInfo +)); +#endif +/* local defines */ +/************** LRG Interface ****************/ +/** + * @brief Layer Manager Configuration request handler. + * + * @details + * + * Function : HandleSchGenCfgReq + * + * This function handles the configuration + * request received at scheduler instance from the Layer Manager. + * -# Based on the cfg->hdr.elmId.elmnt value it invokes one of the + * functions rgHdlGenCfg() or rgHdlSapCfg(). + * -# Invokes RgMiLrgSchCfgCfm() to send back the confirmation to the LM. + * + * @param[in] Pst *pst, the post structure + * @param[in] RgMngmt *cfg, the configuration parameter's structure + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 HandleSchGenCfgReq +( +Pst *pst, /* post structure */ +RgMngmt *cfg /* config structure */ +) +#else +PUBLIC S16 HandleSchGenCfgReq(pst, cfg) +Pst *pst; /* post structure */ +RgMngmt *cfg; /* config structure */ +#endif +{ + U16 ret = LCM_PRIM_OK; + U16 reason = LCM_REASON_NOT_APPL; + RgMngmt cfm; + Pst cfmPst; +#ifdef DEBUGP + Inst inst = (pst->dstInst - SCH_INST_START); +#endif + + TRC3(HandleSchGenCfgReq) + + + if(pst->dstInst < SCH_INST_START) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Invalid inst ID"); + RLOG_ARG2(L_DEBUG,DBG_INSTID,inst, "HandleSchGenCfgReq(): " + "pst->dstInst=%d SCH_INST_START=%d", pst->dstInst,SCH_INST_START); + RETVALUE(ROK); + } + printf("\nReceived scheduler gen config"); + /* Fill the post structure for sending the confirmation */ + SchFillCfmPst(pst, &cfmPst, cfg); + + /* Initialize the cfg cfm structure + if (SGetSBuf(cfmPst.region, cfmPst.pool, (Data **)&cfm, sizeof(RgMngmt)) + != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Memory Unavailable for Confirmation"); + RETVALUE(ROK); + } */ + cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt)); + +#ifdef LMINT3 + cfm.hdr.transId = + cfg->hdr.transId; +#endif + + cfm.hdr.elmId.elmnt = cfg->hdr.elmId.elmnt; + switch(cfg->hdr.elmId.elmnt) + { + case STSCHINST: + reason = SchInstCfg(&cfg->t.cfg,pst->dstInst ); + break; + default: + ret = LCM_PRIM_NOK; + reason = LCM_REASON_INVALID_ELMNT; + RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "Invalid Elmnt=%d", cfg->hdr.elmId.elmnt); + break; + } + + if (reason != LCM_REASON_NOT_APPL) + { + ret = LCM_PRIM_NOK; + } + + cfm.cfm.status = ret; + cfm.cfm.reason = reason; + + SchSendCfgCfm(&cfmPst, &cfm); + /* SPutSBuf(pst->region, pst->pool, (Data *)cfg, sizeof(RgMngmt)); */ + + RETVALUE(ROK); +}/*-- HandleSchGenCfgReq --*/ + + +/** + * @brief Layer Manager Control request handler. + * + * @details + * + * Function : RgMiLrgSchCntrlReq + * + * This function handles the control + * request received from the Layer Manager. + * -# Based on cntrl->hdr.elmId.elmnt, cntrl->t.cntrl.action + * and cntrl->t.cntrl.subAction, it performs the appropriate control action + * of SAP (enable/disable) and layer shutdown. + * -# Invokes the RgMiLrgSchCntrlCfm to send back the confirmation to LM. + * + * @param[in] Pst *pst, the post structure + * @param[in] RgMngmt *cntrl, the control parameter's structure + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMiLrgSchCntrlReq +( +Pst *pst, /* post structure */ +RgMngmt *cntrl /* control structure */ +) +#else +PUBLIC S16 RgMiLrgSchCntrlReq(pst, cntrl) +Pst *pst; /* post structure */ +RgMngmt *cntrl; /* control structure */ +#endif +{ + S16 ret = ROK; /* return value */ + Pst cfmPst; + RgMngmt cfm; + + Inst inst = (pst->dstInst - SCH_INST_START); /* Scheduler instance Id */ + TRC3(RgMiLrgSchCntrlReq) + + + /* Fill the post structure for sending the confirmation */ + SchFillCfmPst(pst, &cfmPst, cntrl); + + /* Initialize the cfg cfm structure + if (SGetSBuf(cfmPst.region, cfmPst.pool, (Data **)&cfm, sizeof(RgMngmt)) + != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Memory Unavailable for Confirmation"); + SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); + RETVALUE(ROK); + } */ + cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt)); + +#ifdef LMINT3 + cfm.hdr.transId = + cntrl->hdr.transId; +#endif + + cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt; + cfm.t.cntrl.action = cntrl->t.cntrl.action; + cfm.t.cntrl.subAction = cntrl->t.cntrl.subAction; + + /* Check if General Config Done*/ + if(rgSchCb[inst].rgSchInit.cfgDone != TRUE) + { + cfm.cfm.status = LCM_PRIM_NOK; + cfm.cfm.reason = LCM_REASON_GENCFG_NOT_DONE; + cfm.hdr.elmId.elmnt = cntrl->hdr.elmId.elmnt; + RgMiLrgSchCntrlCfm(&cfmPst, &cfm); + RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Gen Cfg not done."); + /* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */ + RETVALUE(ROK); + } + + /* General Config done, process the Control request */ + switch(cntrl->hdr.elmId.elmnt) + { + case STGEN: + rgSCHLmmGenCntrl(cntrl, &cfm, &cfmPst); + break; + case STTFUSAP: + case STRGRSAP: + rgSCHLmmSapCntrl(cntrl, &cfm, &cfmPst); + break; + default: + cfm.cfm.status = LCM_PRIM_NOK; + cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL; + RgMiLrgSchCntrlCfm(&cfmPst, &cfm); + RLOG_ARG1(L_ERROR,DBG_INSTID,inst, "invalid elmnt=%d", + cntrl->hdr.elmId.elmnt); + break; + } + /* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */ + RETVALUE(ret); +}/*-- RgMiLrgSchCntrlReq --*/ + +#ifdef LTE_L2_MEAS +/** + * @brief Layer Manager L2 Measurement request handler. + * + * @details + * + * Function : RgMiLrgSchL2MeasReq + * + * This function handles the control + * measurement request received from the Layer Manager. + * + * @param[in] Pst *pst, the post structure + * @param[in] LrgSchMeasReqInfo *measInfo, measurement request info + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMiLrgSchL2MeasReq +( +Pst *pst, /* post structure */ +LrgSchMeasReqInfo *measInfo /* Meas Req Info */ +) +#else +PUBLIC S16 RgMiLrgSchL2MeasReq(pst, measInfo) + Pst *pst; /* post structure */ + LrgSchMeasReqInfo *measInfo; /* Meas Req Info */ +#endif +{ + Pst cfmPst; + RgSchCellCb *cell; + RgSchErrInfo err; + S16 ret = ROK; + RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)]; +#if (ERRCLASS & ERRCLS_ADD_RES) + CmLList *lnk; +#endif + U32 idx; + RgSchL2MeasCb *measCb = NULLP; +#ifdef DEBUGP + Inst inst = (pst->dstInst - SCH_INST_START); /* Scheduler instance Id */ +#endif + + err.errType = 0; + err.errCause = 0; + + TRC3(RgMiLrgSchL2MeasReq) + + + /* Find the cellCb using cellId in measInfo. Iterate through all cells + * in rgrsapCb in RgschCb */ + cell = NULLP; + for (idx = 0; idx < instCb->numSaps; idx++) + { + if ( instCb->rgrSap[idx].cell->cellId == measInfo->cellId) + { + /* got the cell break the loop */ + cell = instCb->rgrSap[idx].cell; + break; + } + } + /* If no cellCb return Err with Invalid Cell Id */ + if (cell == NULLP) + { + rgSchL2mFillCfmPst(pst, &cfmPst, measInfo); + RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_INVALID_CELLID); + rgSchL2mSndCfm(&cfmPst, NULLP, measInfo, TRUE); + RLOG_ARG2(L_ERROR,DBG_INSTID,inst, + "Meas req Failed.Invalid Cell Id errType(%d) errCause(%d)", + err.errType, err.errCause); + RETVALUE(RFAILED); + } + /* Validate for Meas Types */ + if ( (ret = rgSCHUtlValidateMeasReq(cell, measInfo, &err)) != ROK) + { + rgSchL2mFillCfmPst(pst, &cfmPst, measInfo); + RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_INVALID_MEASTYPE); + rgSchL2mSndCfm(&cfmPst, NULLP, measInfo, TRUE); + RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, + "Meas req Failed.Invalid Measurement Type" + "errCasue(%d) errType(%d)", err.errType, err.errCause); + RETVALUE(RFAILED); + } + /* Iterate through all meas requests in l2mList in cellCb */ +#if (ERRCLASS & ERRCLS_ADD_RES) + lnk = cell->l2mList.first; + while(lnk != NULLP) + { + /* Get the MeasCb : RgSchL2MeasCb */ + measCb = (RgSchL2MeasCb *)lnk->node; + lnk = lnk->next; + if (measCb->measReq.hdr.transId == measInfo->hdr.transId) + { + rgSchL2mFillCfmPst(pst, &cfmPst, measInfo); + RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_DUP_TRANSID); + rgSchL2mSndCfm(&cfmPst, measCb, measInfo, TRUE); + RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, + "Meas req Failed.Dublicate TransId" + "errType(%d) errCause(%d)", err.errType, err.errCause); + RETVALUE(RFAILED); + } + } +#endif + /* Call L2M Function to store Meas req */ + ret = rgSchL2mMeasReq(cell, measInfo, err); + if (ret != ROK) + { + rgSchL2mFillCfmPst(pst, &cfmPst, measInfo); + RGSCHFILLERR(err, RGSCHERR_L2M_MEASREQ, RGSCHERR_SCH_L2MEAS_FAILED); + rgSchL2mSndCfm(&cfmPst, measCb, measInfo, TRUE); + RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, + "Meas req Failed.errType(%d) errCause(%d)", + err.errType, err.errCause); + RETVALUE(RFAILED); + } + RETVALUE(ret); +} /* -- RRgMiLrgSchL2MeasReq-- */ + +/** + * @brief Layer Manager L2 Measurement Stop request handler. + * + * @details + * + * Function : RgMiLrgSchL2MeasStopReq + * + * This function handles the control + * measurement stop request received from the Layer Manager. + * + * @param[in] Pst *pst, the post structure + * @param[in] LrgSchMeasReqInfo *measInfo, measurement stop request info + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMiLrgSchL2MeasStopReq +( +Pst *pst, /* post structure */ +LrgSchMeasStopReqInfo *measInfo /* Meas Req Info */ +) +#else +PUBLIC S16 RgMiLrgSchL2MeasStopReq(pst, measInfo) + Pst *pst; /* post structure */ + LrgSchMeasStopReqInfo *measInfo; /* Meas Req Info */ +#endif +{ + S16 ret = ROK; + RgSchCellCb *cell = NULLP; + RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)]; + CmLList *node = NULLP; + RgSchL2MeasCb *measCb = NULLP; + LrgSchMeasCfmInfo measCfm; + U8 idx; + + + TRC3(RgMiLrgSchL2MeasStopReq) + + + for (idx = 0; idx < instCb->numSaps; idx++) + { + if ( instCb->rgrSap[idx].cell->cellId == measInfo->cellId) + { + /* got the cell break the loop */ + cell = instCb->rgrSap[idx].cell; + break; + } + } + if (cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId, + "Stop req Failed.Invalid Cell Id "); + RETVALUE(RFAILED); + } + cmMemset((U8 *)&measCfm, 0, sizeof(LrgSchMeasCfmInfo)); + node = cell->l2mList.first; + while(node != NULLP) + { + measCb = (RgSchL2MeasCb *)(node)->node; + + node = (node)->next; + cmLListDelFrm(&cell->l2mList, &measCb->measLnk); + rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb, + sizeof(RgSchL2MeasCb)); + } + + if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL) + { + RgInfL2MeasStopReq measStopReq; + Pst pstMac; + cmMemset((U8 *)&measStopReq, 0, sizeof(RgInfL2MeasStopReq)); + measStopReq.transId = measInfo->hdr.transId; + measStopReq.measType = measInfo->measType; + /* measReq.timePrd = measInfo->timePrd; */ + measStopReq.cellId = measInfo->cellId; + rgSCHUtlGetPstToLyr(&pstMac, &rgSchCb[cell->instIdx], cell->macInst); + RgSchMacL2MeasStop(&pstMac,&measStopReq); + } + else + { + RgMiLrgSchL2MeasStopCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst), + &measCfm); + } + RETVALUE(ret); +}/*RgMiLrgSchL2MeasStopReq*/ +/** + * @brief Layer Manager L2 Measurement request handler. + * for Send l2 measurement req + * @details + * + * Function : RgMiLrgSchL2MeasSendReq + * + * This function handles the control + * measurement send request received from the Layer Manager. + * + * @param[in] Pst *pst, the post structure + * @param[in] LrgSchMeasReqInfo *measInfo, measurement stop request info + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMiLrgSchL2MeasSendReq +( +Pst *pst, /* post structure */ +LrgSchMeasSndReqInfo *measInfo /* Meas Req Info */ +) +#else +PUBLIC S16 RgMiLrgSchL2MeasSendReq(pst, measInfo) + Pst *pst; /* post structure */ + LrgSchMeasSndReqInfo *measInfo; /* Meas Req Info */ +#endif +{ + S16 ret = ROK; + RgSchCellCb *cell; + RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)]; + U8 idx; + + TRC3(RgMiLrgSchL2MeasSendReq) + + + + cell = NULLP; + for (idx = 0; idx < instCb->numSaps; idx++) + { + if ( instCb->rgrSap[idx].cell->cellId == measInfo->cellId) + { + /* got the cell break the loop */ + cell = instCb->rgrSap[idx].cell; + break; + } + } + if (cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId, + "Send req Failed.Invalid Cell Id"); + RETVALUE(RFAILED); + } + + if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL) + { + RgInfL2MeasSndReq measSndReq; + Pst pstMac; + cmMemset((U8 *)&measSndReq, 0, sizeof(RgInfL2MeasSndReq)); + measSndReq.transId = measInfo->hdr.transId; + measSndReq.measType = measInfo->measType; + measSndReq.timePrd = measInfo->timePrd; + measSndReq.cellId = measInfo->cellId; + rgSCHUtlGetPstToLyr(&pstMac, &rgSchCb[cell->instIdx], cell->macInst); + RgSchMacL2MeasSend(&pstMac, &measSndReq); + } + else + { + cell->sndL2Meas = TRUE; + } + + RETVALUE(ret); +}/*RgMiLrgSchL2MeasSendReq*/ +#endif /* LTE_L2_MEAS */ + + + + +/************* RGR Interface ****************/ +/** + * @brief API for bind request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgrBndReq + * + * This API is invoked by RRM towards MAC to bind RGR SAP. + * These API validates the Pst, spId, suId and sends the bind confirm to + * RRM. + * + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] SpId spId + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgrBndReq +( + Pst *pst, + SuId suId, + SpId spId + ) +#else +PUBLIC S16 RgUiRgrBndReq(pst, suId, spId) + Pst *pst; + SuId suId; + SpId spId; +#endif +{ + S16 ret = ROK; + Pst tmpPst; /* Temporary Post Structure */ + Inst instId = pst->dstInst-SCH_INST_START; + RgUstaDgn dgn; /* Alarm diagnostics structure */ + + TRC3(RgUiRgrBndReq) + + + tmpPst.prior = pst->prior; + tmpPst.route = pst->route; + tmpPst.selector = pst->selector; + tmpPst.region = rgSchCb[instId].rgSchInit.region; + tmpPst.pool = rgSchCb[instId].rgSchInit.pool; + tmpPst.srcProcId = rgSchCb[instId].rgSchInit.procId; + tmpPst.srcEnt = rgSchCb[instId].rgSchInit.ent; + tmpPst.srcInst = rgSchCb[instId].rgSchInit.inst + SCH_INST_START; + tmpPst.event = EVTNONE; + tmpPst.dstProcId = pst->srcProcId; + tmpPst.dstEnt = pst->srcEnt; + tmpPst.dstInst = pst->srcInst; + + if(spId < rgSchCb[instId].numSaps) + { + /* Check the state of the SAP */ + switch (rgSchCb[instId].rgrSap[spId].sapSta.sapState) + { + /* This case might not be needed if SAP not configured then it will go + * to else of above if condition */ + case LRG_UNBND: /* SAP is not bound */ + RLOG0(L_DEBUG,"SAP Not yet bound"); + rgSchCb[instId].rgrSap[spId].sapSta.sapState = LRG_BND; + rgSchCb[instId].rgrSap[spId].sapCfg.suId = suId; + /* Send Bind Confirm with status as SUCCESS */ + ret = rgSCHUtlRgrBndCfm(instId, suId, CM_BND_OK); + /*Indicate to Layer manager */ + rgSCHUtlFillDgnParams(instId, &dgn, LRG_USTA_DGNVAL_MEM); + ret = rgSCHLmmStaInd(instId, LCM_CATEGORY_INTERFACE, + LRG_EVENT_RGRSAP_ENB, LCM_CAUSE_UNKNOWN, &dgn); + break; + case LRG_BND: /* SAP is already bound*/ + RLOG0(L_DEBUG,"SAP is already bound"); + ret = rgSCHUtlRgrBndCfm(instId, suId, CM_BND_OK); + break; + default: /* Should Never Enter here */ +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG001, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP State:RgUiRrgBndReq failed\n"); +#endif + ret = rgSCHUtlRgrBndCfm(instId, suId, CM_BND_NOK); + break; + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + /* ccpu00117035 - MOD - Changed ErrVal argument from accessing sap state + to spId to avoid seg fault due to invalid sapID */ + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG002, + (ErrVal)spId, "Invalid SAP Id:RgUiRrgBndReq failed\n"); +#endif + ret = RgUiRgrBndCfm(&tmpPst, suId, CM_BND_NOK); + } + RETVALUE(ret); +} /* RgUiRgrBndReq */ + +/** + * @brief API for unbind request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgrUbndReq + * + * This API is invoked by RRM towards MAC to unbind RGR SAP. + * These API validates the Pst, spId, suId and transfers the unbind request + * specific information to corresponding ownership module (GOM) API. + * + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] Reason reason + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgrUbndReq +( + Pst *pst, + SpId spId, + Reason reason + ) +#else +PUBLIC S16 RgUiRgrUbndReq(pst, spId, reason) + Pst *pst; + SpId spId; + Reason reason; +#endif +{ + Inst instId = pst->dstInst-SCH_INST_START; + TRC3(RgUiRgrUbndReq) + + + /* SAP Id validation */ + if (spId < rgSchCb[instId].numSaps) + { + switch(rgSchCb[instId].rgrSap[spId].sapSta.sapState) + { + case LRG_BND: /* SAP is already bound*/ + RLOG0(L_DEBUG,"SAP is already bound"); + /* setting SAP state to UN BOUND */ + rgSchCb[instId].rgrSap[spId].sapSta.sapState = LRG_UNBND; + break; + default: +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG003, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP State: RgUiRgrUbndReq failed\n"); +#endif + RETVALUE(RFAILED); + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId,ERRCLS_INT_PAR, ERG004, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP Id:RgUiRgrUbndReq failed\n"); +#endif + RETVALUE(RFAILED); + } + RETVALUE(ROK); +} /* RgUiRgrUbndReq */ + +/** + * @brief API for configuration request from RRM towards MAC. + * + * @details + * + * Function: HandleSchCfgReq + * + * This API is invoked by RRM towards MAC to configure MAC. + * These API validates the Pst, spId, suId and transfers the config request + * specific information to corresponding ownership module (GOM) API. + * + * + * @param[in] Pst *pst + * @param[in] RgrCfgTransId transId + * @param[in] RgrCfgReqInfo *cfgReqInfo + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 HandleSchCfgReq +( + Pst *pst, + RgrCfgTransId transId, + RgrCfgReqInfo *cfgReqInfo + ) +#else +PUBLIC S16 HandleSchCfgReq(pst, transId, cfgReqInfo) + Pst *pst; + RgrCfgTransId transId; + RgrCfgReqInfo *cfgReqInfo; +#endif +{ + + SpId spId = 0; + S16 ret = ROK; + U8 cfmStatus = 0x00ff; + U8 prntTrans[RGR_CFG_TRANSID_SIZE+1]; + Inst instId = pst->dstInst-SCH_INST_START; + + TRC3(HandleSchCfgReq); + + cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE); + prntTrans[RGR_CFG_TRANSID_SIZE] = '\0'; + + + if (cfgReqInfo == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Input Message Buffer is NULL"); + schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus); + RETVALUE(RFAILED); + } +#if 0 + if (spId < rgSchCb[instId].numSaps) + { + switch(rgSchCb[instId].rgrSap[spId].sapSta.sapState) + { + case LRG_BND: /* SAP is already bound */ + RLOG0(L_DEBUG,"SAP is already bound"); + break; + default: /* Should never reach here */ +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG005, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP State: HandleSchCfgReq failed\n"); +#endif + SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, + (Size)sizeof(*cfgReqInfo)); + schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus); + RETVALUE(RFAILED); + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG006, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapCfg.spId, + "Invalid SAP Id:HandleSchCfgReq failed\n"); +#endif + SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, + (Size)sizeof(*cfgReqInfo)); + schSendCfgCfm(pst->region, pst->pool, transId, cfmStatus); + RETVALUE(RFAILED); + } +#endif + /* Handle configuration */ + ret = rgSCHGomHndlCfg(pst, &rgSchCb[instId], + transId, cfgReqInfo); + if (ret != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Configuration Request Handling Failed"); + RETVALUE(RFAILED); + } + + RETVALUE(ROK); +} /* HandleSchCfgReq */ + +#ifdef RGR_SI_SCH +/** + * @brief API for SI configuration request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgrSiCfgReq + * + * This API is invoked by RRM towards MAC to configure SI at MAC. + * These API validates the Pst, spId, suId and transfers the + * config request specific information to corresponding ownership + * module (GOM) API. + * + * + * @param[in] Pst *pst + * @param[in] SpId spId + * @param[in] RgrCfgTransId transId + * @param[in] RgrSiCfgReqInfo *cfgReqInfo + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgrSiCfgReq +( +Pst *pst, +SpId spId, +RgrCfgTransId transId, +RgrSiCfgReqInfo *cfgReqInfo +) +#else +PUBLIC S16 RgUiRgrSiCfgReq(pst, spId, transId, cfgReqInfo) +Pst *pst; +SpId spId; +RgrCfgTransId transId; +RgrSiCfgReqInfo *cfgReqInfo; +#endif +{ + S16 ret = ROK; + U8 cfmStatus = RGR_CFG_CFM_NOK; + U8 prntTrans[RGR_CFG_TRANSID_SIZE+1]; + Inst instId = pst->dstInst-SCH_INST_START; + + TRC2(RgUiRgrSiCfgReq); + + cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE); + prntTrans[RGR_CFG_TRANSID_SIZE] = '\0'; + + + if (cfgReqInfo == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Input Message Buffer " + "is NULL"); + rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus); + RETVALUE(RFAILED); + } + + if (spId < rgSchCb[instId].numSaps) + { + if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState) + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG007, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP State: RgUiRgrSiCfgReq failed\n"); +#endif + SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, + (Size)sizeof(*cfgReqInfo)); + rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus); + RETVALUE(RFAILED); + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG008, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapCfg.spId, + "Invalid SAP Id:RgUiRgrSiCfgReq failed\n"); +#endif + SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, + (Size)sizeof(*cfgReqInfo)); + rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus); + RETVALUE(RFAILED); + } + + /* Handle configuration */ +#ifdef EMTC_ENABLE +if(rgSchCb[instId].rgrSap[spId].cell->emtcEnable) +{ + ret = rgSCHGomEmtcHndlSiCfg(pst->region, pst->pool, + &rgSchCb[instId], spId, transId, + cfgReqInfo); +} +else +{ + ret = rgSCHGomHndlSiCfg(pst->region, pst->pool, + &rgSchCb[instId], spId, transId, + cfgReqInfo); +} + #else + ret = rgSCHGomHndlSiCfg(pst->region, pst->pool, + &rgSchCb[instId], spId, transId, + cfgReqInfo); + #endif + if (ret != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"RgUiRgrSiCfgReq:" + "Configuration Request Handling Failed"); + RETVALUE(RFAILED); + } + + RETVALUE(ROK); +} /* RgUiRgrSiCfgReq */ + + +/** + * @brief API for Warning SI configuration request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgrWarningSiCfgReq + * + * This API is invoked by RRM towards MAC to configure SI at MAC. + * These API validates the Pst, spId, suId and transfers the + * config request specific information to corresponding ownership + * module (GOM) API. + * + * + * @param[in] Pst *pst + * @param[in] SpId spId + * @param[in] RgrCfgTransId transId + * @param[in] RgrWarningSiCfgReqInfo *warningSiCfgReqInfo + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgrWarningSiCfgReq +( +Pst *pst, +SpId spId, +RgrCfgTransId transId, +RgrWarningSiCfgReqInfo *warningSiCfgReqInfo +) +#else +PUBLIC S16 RgUiRgrWarningSiCfgReq(pst, spId, transId, warningSiCfgReqInfo) +Pst *pst; +SpId spId; +RgrCfgTransId transId; +RgrWarningSiCfgReqInfo *warningSiCfgReqInfo; +#endif +{ + Inst instId = pst->dstInst-SCH_INST_START; + S16 ret = ROK; + U8 cfmStatus = RGR_CFG_CFM_NOK; + U8 prntTrans[RGR_CFG_TRANSID_SIZE+1]; + + TRC2(RgUiRgrWarningSiCfgReq); + + cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE); + prntTrans[RGR_CFG_TRANSID_SIZE] = '\0'; + + + + if (warningSiCfgReqInfo == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Input Message Buffer " + "is NULL"); + rgSCHUtlRgrWarningSiCfgCfm(instId, spId, 0, transId, cfmStatus); + RETVALUE(RFAILED); + } + + if (spId < rgSchCb[instId].numSaps) + { + if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState) + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG023, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP State: warningSiCfgReqInfo failed\n"); +#endif + rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool, + &warningSiCfgReqInfo->siPduLst); + SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, + sizeof(RgrWarningSiCfgReqInfo)); + rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId, + transId, cfmStatus); + RETVALUE(RFAILED); + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG024, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapCfg.spId, + "Invalid SAP Id:warningSiCfgReqInfo failed\n"); +#endif + rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool, + &warningSiCfgReqInfo->siPduLst); + SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo, + sizeof(RgrWarningSiCfgReqInfo)); + rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId, + transId, cfmStatus); + RETVALUE(RFAILED); + } + + /* Handle configuration */ +#ifdef EMTC_ENABLE +if(rgSchCb[instId].rgrSap[spId].cell->emtcEnable) +{ + ret = rgSCHGomEmtcHndlWarningSiCfg(pst->region, pst->pool, + &rgSchCb[instId], spId, transId, warningSiCfgReqInfo); +} +else +{ + ret = rgSCHGomHndlWarningSiCfg(pst->region, pst->pool, + &rgSchCb[instId], spId, transId, warningSiCfgReqInfo); +} +#else + ret = rgSCHGomHndlWarningSiCfg(pst->region, pst->pool, + &rgSchCb[instId], spId, transId, warningSiCfgReqInfo); +#endif + if(ret != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId, + "Configuration Request Handling Failed"); + RETVALUE(RFAILED); + } + + RETVALUE(ROK); +} + + +/** + * @brief API for Warning SI Stop request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgrWarningSiStopReq + * + * This API is invoked by RRM towards MAC to Stop warning SI at MAC. + * These API validates the Pst, spId, suId and transfers the + * stop request specific information to corresponding ownership + * module (GOM) API. + * + * + * @param[in] Pst *pst + * @param[in] SpId spId + * @param[in] RgrWarningSiCfgReqInfo *warningSiCfgReqInfo + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgrWarningSiStopReq +( +Pst *pst, +SpId spId, +RgrCfgTransId transId, +U8 siId +) +#else +PUBLIC S16 RgUiRgrWarningSiStopReq(pst,spId, transId, siId) +Pst *pst; +SpId spId; +RgrCfgTransId transId; +U8 siId; +#endif +{ + Inst instId = pst->dstInst-SCH_INST_START; + + TRC3(RgUiRgrWarningSiStopReq) + + + + if (spId < rgSchCb[instId].numSaps) + { + if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState) + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG025, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP State: RgUiRgrWarningSiStopReq failed\n"); +#endif + RETVALUE(RFAILED); + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG026, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapCfg.spId, + "Invalid SAP Id:RgUiRgrWarningSiStopReq failed\n"); +#endif + RETVALUE(RFAILED); + } + + rgSCHGomHndlWarningSiStopReq(pst->region, pst->pool, + &rgSchCb[instId], siId, transId, spId); + + RETVALUE(ROK); +} +#endif /*RGR_SI_SCH */ + +/* LTE_ADV_FLAG_REMOVED_START */ + +/** + * @brief API for LOAD INF request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgrLoadInfReq + * + * This API is invoked by RRM towards MAC to configure LOAD INF Parameters at MAC. + * These API validates the Pst, spId, suId and transfers the + * LOAD INF request to corresponding ownership + * module (GOM) API. + * + * + * @param[in] Pst *pst + * @param[in] SpId spId + * @param[in] RgrCfgTransId transId + * @param[in] RgrLoadInfReqInfo *loadInfReq + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgrLoadInfReq +( + Pst *pst, + SpId spId, + RgrCfgTransId transId, + RgrLoadInfReqInfo *loadInfReq + ) +#else +PUBLIC S16 RgUiRgrLoadInfReq(pst, spId, transId, loadInfReq) + Pst *pst; + SpId spId; + RgrCfgTransId transId; + RgrLoadInfReqInfo *loadInfReq; +#endif +{ + S16 ret = ROK; + U8 prntTrans[RGR_CFG_TRANSID_SIZE+1]; + Inst instId = pst->dstInst-SCH_INST_START; + + TRC2(RgUiRgrLoadInfReq); + + cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE); + prntTrans[RGR_CFG_TRANSID_SIZE] = '\0'; + + + if (loadInfReq == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"Input Message Buffer " + "is NULL"); + RETVALUE(RFAILED); + } + + if (spId < rgSchCb[instId].numSaps) + { + if(LRG_BND != rgSchCb[instId].rgrSap[spId].sapSta.sapState) + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG007, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapSta.sapState, + "Invalid SAP State: RgUiRgrLoadInfReq failed\n"); +#endif + SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, + (Size)sizeof(*loadInfReq)); + RETVALUE(RFAILED); + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG008, + (ErrVal)rgSchCb[instId].rgrSap[spId].sapCfg.spId, + "Invalid SAP Id:RgUiRgrLoadInfReq failed\n"); +#endif + SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq, + (Size)sizeof(*loadInfReq)); + RETVALUE(RFAILED); + } + + /* Handle configuration */ + ret = rgSCHGomHndlLoadInf(pst->region, pst->pool, + &rgSchCb[(pst->dstInst - SCH_INST_START)], spId, transId, + loadInfReq); + if (ret != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId, + "Configuration Request Handling Failed"); + RETVALUE(RFAILED); + } + + RETVALUE(ROK); +} /* RgUiRgrLoadInfReq */ +/* LTE_ADV_FLAG_REMOVED_END */ + +/************** MAC SCH Interface **************/ +/** + * @brief Function for updating dedicated channel BO at scheduler from MAC. + * + * @details + * + * Function : rgMacSchDedBoUpdtReq + * + * This function shall be invoked whenever MAC gets staRsp from RLC + * Scheduler shall update BO in its dedicated logical channel control block. + * + * @param[in] Pst* pst + * @param[in] S16 cellSapId + * @param[in] RgInfDedBoRpt *boRpt + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMacSchDedBoUpdtReq +( +Pst* pst, +RgInfDedBoRpt *boRpt +) +#else +PUBLIC S16 RgMacSchDedBoUpdtReq(pst, boRpt) +Pst* pst; +RgInfDedBoRpt *boRpt; +#endif +{ + RgSchCellCb *cell; + RgSchUeCb *ue; +#ifdef SCH_STATS + RgSchCmnDlUe *dlUe; +#endif + + + Inst inst = (pst->dstInst - SCH_INST_START); + S16 cellSapId = boRpt->cellSapId; + + TRC3(RgMacSchDedBoUpdtReq) +/* + RLOG_ARG2(L_DEBUG,DBG_CELLID,boRpt->cellId,"rgMacSchDedBoUpdtReq():" + " boRpt->rnti = %u boRpt->lcId = %u",boRpt->rnti, boRpt->lcId); +*/ + /* No need to chk for cell being NULL as MAC wouldn't have found instance if + * it doesnt exist */ + cell = rgSchCb[inst].rgrSap[cellSapId].cell; + +#ifndef NO_ERRCLS + if (cell->cellId != boRpt->cellId) + { + /* Handle Cell fetch failure */ + RGSCHLOGERROR(inst, ERRCLS_INT_PAR,ERG009,(ErrVal)boRpt->cellId, + "rgMacSchDedBoUpdtReq(): Invalid cell Id"); + RETVALUE(RFAILED); + } +#endif + + /* Update Bo in the given logical channel of the UE */ + if ((ue = rgSCHDbmGetUeCb(cell, boRpt->rnti)) != NULLP) + { + RgSchDlLcCb *dlLc; + /* Honor BO Reports only from PCELL */ +#ifdef LTE_ADV + if (cell != ue->cell) + { + RETVALUE(RFAILED); + } +#endif + if ((dlLc = rgSCHDbmGetDlDedLcCb(ue, boRpt->lcId)) != NULLP) + { +#ifdef LTE_L2_MEAS + if(dlLc->lcType == CM_LTE_LCH_DTCH) + { + if((dlLc->bo == 0) &&(boRpt->bo != 0)) + { + /* UE is active */ + if(!(ue->qciActiveLCs[dlLc->qciCb->qci])) + { + dlLc->qciCb->dlUeCount++; + } + ue->qciActiveLCs[dlLc->qciCb->qci]++; + } + else if((dlLc->bo != 0) && (boRpt->bo == 0) && (dlLc->qciCb->dlUeCount)) + { + /* UE is inactive */ + if (ue->qciActiveLCs[dlLc->qciCb->qci]) + { + ue->qciActiveLCs[dlLc->qciCb->qci]--; + if (!(ue->qciActiveLCs[dlLc->qciCb->qci])) + { + dlLc->qciCb->dlUeCount--; + } + } + } + } +#endif +#ifdef SCH_STATS + dlUe = RG_SCH_CMN_GET_DL_UE(ue, cell); + if (boRpt->bo > dlLc->bo) + { + dlUe->boReported += (boRpt->bo - dlLc->bo); + } +#endif +#ifdef TENB_STATS + if (boRpt->bo > dlLc->bo) + { + ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(cell)].dlBo += ((boRpt->bo - dlLc->bo)<<3); + } +#endif + /* RLC provides cumulative BO for each LC. + * Reduce the left out unscheduled bo from total bo and + * update the new BO to the total bo */ + if(ue->totalBo >= dlLc->bo) + { + ue->totalBo -= dlLc->bo; + } + else + { + ue->totalBo = 0; /* this case should not arise + * Resetting for safety */ + } + + ue->totalBo += boRpt->bo; + dlLc->bo = boRpt->bo; + dlLc->oldestSduArrTime = boRpt->oldestSduArrTime; + dlLc->staPduBo = boRpt->staPduBo; + + dlLc->setMaxUlPrio = boRpt->setMaxUlPrio; + dlLc->setMaxDlPrio = boRpt->setMaxDlPrio; + /* Update the scheduler */ + rgSCHUtlDlDedBoUpd(cell, ue, dlLc); + RETVALUE(ROK); + } + } + RETVALUE(RFAILED); + +} /* end of rgMacSchDedBoUpdtReq */ + + +/** + * @brief Function for updating common channel BO at scheduler from MAC. + * + * @details + * + * Function : RgMacSchCmnBoUpdtReq + * + * This function shall be invoked whenever MAC gets staRsp from RLC + * Scheduler shall update BO in its common logical channel control block. + * + * @param[in] Pst* pst + * @param[in] S16 cellSapId + * @param[in] RgInfCmnBoRpt *boRpt + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMacSchCmnBoUpdtReq +( +Pst* pst, +RgInfCmnBoRpt *boRpt +) +#else +PUBLIC S16 RgMacSchCmnBoUpdtReq(pst, boRpt) +Pst* pst; +RgInfCmnBoRpt *boRpt; +#endif +{ + RgSchCellCb *cell; + Inst inst = (pst->dstInst - SCH_INST_START); + S16 cellSapId = boRpt->cellSapId; + + TRC3(RgMacSchCmnBoUpdtReq) + + /* No need to chk for cell being NULL as MAC would not have found instance if + * it doesnt exist */ + cell = rgSchCb[inst].rgrSap[cellSapId].cell; + if (cell->cellId != boRpt->cellId) + { + RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,"RgMacSchCmnBoUpdtReq():" + "Invalid boRpt cell Id:%d",boRpt->cellId); + RETVALUE(RFAILED); + } + + /* handle status response on CCCH */ + if(boRpt->lcId == cell->dlCcchId) + { + RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,"RgMacSchCmnBoUpdtReq():" + " BO update for CCCH"); + rgSCHUtlHndlCcchBoUpdt(cell, boRpt); + } + else + { + rgSCHUtlHndlBcchPcchBoUpdt(cell, boRpt); + } + + RETVALUE(ROK); +} /* end of RgMacSchCmnBoUpdtReq */ +/*Fix: start: Inform UE delete to scheduler*/ +/** + * @brief This API is used to send data indication to Scheduler instance from MAC. + * + * @details + * + * Function : rgMacSchUeDelInd + * + * This function shall be invoked whenever MAC gets Ue delete request. + * + * + * @param[in] Pst* pst + * @param[in] RgInfUeDelInd *ueDelInd + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMacSchUeDelInd +( +Pst* pst, +RgInfUeDelInd *ueDelInd +) +#else +PUBLIC S16 RgMacSchUeDelInd(pst, ueDelInd) +Pst* pst; +RgInfUeDelInd *ueDelInd; +#endif +{ + RgSchCellCb *cell; + Inst inst = (pst->dstInst - SCH_INST_START); + S16 cellSapId = ueDelInd->cellSapId; + CmLList *tmp; + RgSchRntiLnk *rntiLnk=NULL; + + TRC3(RgMacSchUeDelInd) + + if (rgSchCb[inst].rgrSap == NULLP || rgSchCb[inst].rgrSap[cellSapId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_CELLID,ueDelInd->cellId,"rgrSap or cell is not configured"); + RETVALUE(ROK); + } + cell = rgSchCb[inst].rgrSap[cellSapId].cell; +#ifndef NO_ERRCLS + if (cell->cellId != ueDelInd->cellId) + { + /* Handle Cell fetch failure */ + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, + "rgMacSchUeDelInd(): Invalid ueDelInd cell Id:%d", + ueDelInd->cellId); + RETVALUE(ROK); + } +#endif + + CM_LLIST_FIRST_NODE(&cell->rntiDb.rntiGuardPool, tmp); + + while(tmp) + { + rntiLnk = (RgSchRntiLnk *)(tmp->node); + if(rntiLnk->rnti == ueDelInd->rnti) + { + cmLListDelFrm(&cell->rntiDb.rntiGuardPool, tmp); + tmp->node = NULLP; + rgSCHDbmRlsRnti(cell, rntiLnk); + RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId, + "RNTI:%d Released from the Guard pool(%ld)", + ueDelInd->rnti, cell->rntiDb.rntiGuardPool.count); + + break; + } + CM_LLIST_NEXT_NODE(&cell->rntiDb.rntiGuardPool, tmp); + } + +#ifdef EMTC_ENABLE + rgEmtcMacSchUeDelInd(cell,ueDelInd); +#endif + + if(tmp == NULLP) + { + /* Fix : syed HO UE does not have a valid ue->rntiLnk */ + RLOG_ARG2(L_INFO,DBG_CELLID,ueDelInd->cellId,"HO CRNTI:%d not present in the" + "Guard Pool:%ld", ueDelInd->rnti, cell->rntiDb.rntiGuardPool.count); + } + + RETVALUE(ROK); +} /* rgMacSchUeDelInd */ +/*Fix: end: Inform UE delete to scheduler*/ +/** + * @brief This API is used to send data indication to Scheduler instance from MAC. + * + * @details + * + * Function : rgMacSchSfRecpInd + * + * This function shall be invoked whenever MAC gets datInd on TFU + * Scheduler shall act on the CEs and data that are received as part of + * datInd. + * + * @param[in] Pst* pst + * @param[in] S16 cellSapId + * @param[in] CmLteRnti rnti + * @param[in] DatIndInfo *datInd + * @return S16 + * -# ROK + **/ +#ifdef ANSI +PUBLIC S16 RgMacSchSfRecpInd +( +Pst* pst, +RgInfSfDatInd *subfrmInfo +) +#else +PUBLIC S16 RgMacSchSfRecpInd(pst, subfrmInfo) +Pst* pst; +RgInfSfDatInd *subfrmInfo; +#endif +{ + S16 ret = RFAILED; + RgSchErrInfo err; + RgSchUeCb *ue; + RgInfUeDatInd *datInd; + RgSchCellCb *cell; + Inst inst = (pst->dstInst - SCH_INST_START); + CmLteRnti rnti; + CmLListCp *lnkLst; + CmLList *tmp; + S16 cellSapId = subfrmInfo->cellSapId; + RgrUeStaIndInfo *ueStaInd; +#ifdef RG_UNUSED +//#ifdef LTEMAC_SPS + RgSchCmnUlUeSpsInfo *ulSpsUe ; +#endif + /* RRM_RBC_X */ + U32 idx; + /* RRM_RBC_Y */ + +#ifdef LTE_L2_MEAS + U8 qci; + U16 datIndActQci = 0; + U16 combDatIndActQci = 0; /* Prev and Latest Dat Ind combined */ + U16 tempUeActQci = 0; /* UE specific Active QCIs */ + U16 diffBits = 0; + U8 lcCount; +#endif + TRC3(RgMacSchSfRecpInd) + + /* No need to chk for cell being NULL as MAC wouldn't have found instance if + * it doesnt exist */ + cell = rgSchCb[inst].rgrSap[cellSapId].cell; + + /* lnkLst assignment */ + lnkLst = &(subfrmInfo->ueLst); + + CM_LLIST_FIRST_NODE(lnkLst, tmp); + + while((NULLP != tmp) && ((RgInfUeDatInd *)tmp->node != NULLP)) + { + ue = NULLP; +#ifdef LTE_L2_MEAS + qci = 0; +#endif + datInd = (RgInfUeDatInd *)tmp->node; + rnti = datInd->rnti; + + /* We shall try and find + * out the RaCb based on the following - + * 1. If the incoming PDU contained a CCCH SDU i.e. this is message 3. + * 2. If the incoming PDU contained a CRNTI control element, i.e. we should + * have a ueCb also for this + */ + + /* It could be that a non-msg3 pdu contains a CRNTI Control element. We + * should check for CRNTI CE and if it exists the UECb must exist, also an + * if the CRNTI in the CE and the one with which the message came in are + * different we shall look for an raCb as well. + */ + if (datInd->ceInfo.bitMask & RGSCH_CRNTI_CE_PRSNT) + { + /* SR_RACH_STATS : CRNTI CE*/ + rgNumMsg3CrntiCE++; + + if (datInd->ceInfo.bitMask & RGSCH_CCCH_SDU_PRSNT) + { + RGSCH_FREE_MEM(subfrmInfo); + err.errType = RGSCHERR_TOM_DATIND; + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, + "Received MSG3 with CRNTI:%d and also CCCH ", + datInd->ceInfo.ces.cRnti); + RETVALUE(RFAILED); + } + ue = rgSCHDbmGetUeCb (cell, datInd->ceInfo.ces.cRnti); + if (ue == NULLP) + { + /* SR_RACH_STATS : CRNTI CE UECB NOT FOUND*/ + rgNumCrntiCeCrntiNotFound++; + /* ccpu00141318 - Removed condition for SPS rnti checking*/ + RGSCH_FREE_MEM(subfrmInfo); + err.errType = RGSCHERR_TOM_DATIND; + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Received MSG3 " + "with CRNTI:%d unable to find ueCb", + datInd->ceInfo.ces.cRnti); + RETVALUE(RFAILED); + } + + if ((ret = rgSCHUtlProcMsg3 (subfrmInfo, cell, ue, + rnti, datInd, &err)) != ROK) + { + RGSCH_FREE_MEM(subfrmInfo); + err.errType = RGSCHERR_TOM_DATIND; + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Processing for MSG3 failed for CRNTI:%d", + datInd->rnti); + RETVALUE(RFAILED); + } + +#ifdef LTEMAC_SPS + rgSCHUtlHdlCrntiCE (cell, ue); +#endif + ret = rgSCHUtlAllocSBuf (cell->instIdx,(Data**)&ueStaInd, + sizeof(RgrUeStaIndInfo)); + if(ret == ROK) + { + ueStaInd->status = RGR_UESTA_MAC_CRNTI_CE_RECVD; +#ifdef RG_UNUSED +//#ifdef LTEMAC_SPS + ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue); + if(ulSpsUe->isUlSpsActv) + { + ueStaInd->status = RGR_UESTA_MAC_CRNTI_CE_RECVD_IN_SPS_ACTIVE; + ue->ul.ulSpsCfg.isLcSRMaskEnab = FALSE; + } +#endif + ret = rgSCHUtlFillSndUeStaInd(cell, ue, ueStaInd); + if(ret != ROK) + { + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, + "Could not Send Ue Sta Ind UEID:%d",ue->ueId); + } + } + CM_LLIST_NEXT_NODE(lnkLst, tmp); + continue; + } /* end of CRNTI based message */ + else if (datInd->ceInfo.bitMask & RGSCH_CCCH_SDU_PRSNT) + { + /* SR_RACH_STATS : CCCH SDU */ + rgNumMsg3CCCHSdu++; + /* SR_RACH_STATS : CCCH SDU RACB NOT FOUND*/ + if (NULLP == rgSCHDbmGetRaCb (cell, rnti)) + { + rgNumCCCHSduCrntiNotFound++; + } + + if ((ret = rgSCHUtlProcMsg3 (subfrmInfo, cell, ue, + rnti, datInd, &err)) != ROK) + { + RGSCH_FREE_MEM(subfrmInfo); + err.errType = RGSCHERR_TOM_DATIND; + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Processing for MSG3 failed for CRNTI:%d", + datInd->rnti); + RETVALUE(RFAILED); + } + /* fix */ + CM_LLIST_NEXT_NODE(lnkLst, tmp); + continue; + } /* end of Msg3 processing */ + + if (ue == NULLP) + { + ue = rgSCHDbmGetUeCb (cell, datInd->rnti); + if (ue == NULLP) + { +#ifdef LTEMAC_SPS + if((ue = rgSCHDbmGetSpsUeCb (cell, datInd->rnti)) == NULLP) +#endif + { + RGSCH_FREE_MEM(subfrmInfo); + err.errType = RGSCHERR_TOM_DATIND; + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the UE CB for CRNTI:%d", + datInd->rnti); + RETVALUE(RFAILED); + } + } + } +/* L2_COUNTERS */ +#ifdef LTE_L2_MEAS + /* The LCs for which data is received at MAC is provided to SCH. + This information is used to estimate the Active LCs at UE + since estimates based on only BSR is not accurate */ + if (datInd->ceInfo.bitMask & RGSCH_ACTIVE_LC_PRSNT) + { + + /* Compose a Bitmask with for the QCI's for which Data + is received */ + for (lcCount = 0; lcCount < RGINF_MAX_NUM_DED_LC; lcCount++) + { + if ((datInd->ceInfo.ulActLCs[lcCount] == TRUE) && (TRUE == ue->ul.lcCb[lcCount].isValid)) + { + datIndActQci |= (1 << (ue->ul.lcCb[lcCount].qciCb->qci -1)); + } + } + if (ue->ulActiveLCs && ue->lastDatIndLCs) + { + /* Combine previous Dat Ind and current Dat Ind to + estimate active LCs at UE */ + combDatIndActQci = ue->lastDatIndLCs | datIndActQci; + tempUeActQci = ue->ulActiveLCs; + ue->ulActiveLCs = combDatIndActQci; + diffBits = combDatIndActQci ^ tempUeActQci; + while (diffBits) + { + qci++; + if (0x1 & diffBits) + { + if (0x1 & tempUeActQci) + { + /* An active QCI has become inactive */ + cell->qciArray[qci].ulUeCount--; + } + else + { + /* An Inactive QCI has become active */ + cell->qciArray[qci].ulUeCount++; + } + } + diffBits >>= 1; + tempUeActQci >>= 1; + } + } + ue->lastDatIndLCs = datIndActQci; + + } + +#endif /* LTE_L2_MEAS */ + /* Just copy the timing information from the dat indication into the one + * stored in the UE CB, will be later utilized to handle Timing advance + */ + + if ((ret = rgSCHUtlUpdSch (subfrmInfo, cell, ue, datInd, &err)) != ROK) + { + RGSCH_FREE_MEM(subfrmInfo); + err.errType = RGSCHERR_TOM_DATIND; + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to handle Data" + " Indication for UEID:%d",ue->ueId); + RETVALUE(RFAILED); + } + + CM_LLIST_NEXT_NODE(lnkLst, tmp); + } + /* RRM_RBC_X */ + /* update the UL PRB usage for all GBR QCIs*/ + for (idx = 0; idx < RGM_MAX_QCI_REPORTS; idx++) + { + cell->prbUsage.qciPrbRpts[idx].ulTotPrbUsed += subfrmInfo->qcisUlPrbCnt[idx]; + } + /* RRM_RBC_Y */ + + /* chk if Sch needs to dealloc datInd after unpk */ + RGSCH_FREE_MEM(subfrmInfo); + RETVALUE(ret); +} /* rgMacSchSfRecpInd */ + +#ifdef LTEMAC_SPS +/** + * @brief Function to handle relInd from MAC for a UE + * + * @details + * + * Function: RgMacSchSpsRelInd + * + * Handler for processing relInd for UL SPS of a UE + * + * Invoked by: + * MAC + * + * Processing Steps: + * + * @param[in] Pst *pst + * @param[in] RgInfSpsRelInfo *relInfo + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgMacSchSpsRelInd +( +Pst *pst, +RgInfSpsRelInfo *relInfo +) +#else +PUBLIC S16 RgMacSchSpsRelInd(pst, relInfo) +Pst *pst; +RgInfSpsRelInfo *relInfo; +#endif +{ + RgSchUeCb *ue; + RgSchCellCb *cell; + Inst inst = (pst->dstInst - SCH_INST_START); + + TRC2(RgMacSchSpsRelInd); + + /* No need to chk for cell being NULL as MAC wouldn't have found instance if + * it doesnt exist */ + cell = rgSchCb[inst].rgrSap[relInfo->cellSapId].cell; + + if ((ue = rgSCHDbmGetUeCb(cell, relInfo->cRnti)) == NULLP) + { + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, + "No Ue exists with CRNTI:%d",relInfo->cRnti); + RETVALUE(RFAILED); + } + + if ((rgSCHUtlSpsRelInd(cell, ue, relInfo->isExplRel)) != ROK) + { + RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, + "RelInd processing for CRNTI:%d failed",relInfo->cRnti); + RETVALUE(RFAILED); + } + RETVALUE(ROK); +} /* end of RgMacSchSpsRelInd */ +#endif /* LTEMAC_SPS */ + +#ifdef LTE_L2_MEAS + +/** + * @brief Function to handle L2MeasCfm from MAC + * + * @details + * + * Function: RgMacSchL2MeasCfm + * + * Handler for processing L2 measurement confirm + * + * Invoked by: + * MAC + * + * Processing Steps: + * + * @param[in] Pst *pst + * @param[in] RgInfL2MeasCfm *measCfm + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgMacSchL2MeasCfm +( +Pst *pst, +RgInfL2MeasCfm *measCfm +) +#else +PUBLIC S16 RgMacSchL2MeasCfm(pst, measCfm) +Pst *pst; +RgInfL2MeasCfm *measCfm; +#endif +{ + RgSchCellCb *cell = NULLP; + Inst inst = (pst->dstInst - SCH_INST_START); + CmLList *lnk; + RgSchL2MeasCb *measCb = NULLP; + RgSchCb *instCb = &rgSchCb[inst]; + U32 idx; + LrgSchMeasCfmInfo schMeasCfm; + U8 qciVal; + U8 idx1; /*LTE_L2_MEAS_PHASE2*/ + U8 qciVal1; + TRC2(RgMacSchL2MeasCfm); + + /* Find the cellCb using cellId in measInfo. Iterate through all cells + * in rgrsapCb in RgschCb */ + for (idx = 0; idx < instCb->numSaps; idx++) + { + if ( instCb->rgrSap[idx].cell->cellId == measCfm->cellId) + { + /* got the cell break the loop */ + cell = instCb->rgrSap[idx].cell; + break; + } + } + /* If no cellCb return Err with Invalid Cell Id */ + if (cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_CELLID,measCfm->cellId, + "Meas Cfm Failed.Invalid Cell Id"); + RETVALUE(RFAILED); + } + + + /* Iterate through all meas requests in l2mList in cellCb */ + lnk = cell->l2mList.first; + while(lnk != NULLP) + { + /* Get the MeasCb : RgSchL2MeasCb */ + measCb = (RgSchL2MeasCb *)lnk->node; + lnk = lnk->next; + if (measCb->measReq.hdr.transId == measCfm->transId) + { + break; + } + } + if ( measCb == NULLP ) + { + RETVALUE( RFAILED ); + } + + + if(measCfm->cfm.status != LCM_PRIM_OK) + { + for (idx = 0; idx < measCb->measReq.avgPrbQciUl.numQci; idx++) + { + qciVal = measCb->measReq.avgPrbQciUl.qci[idx]; + cell->qciArray[qciVal].qci = 0; + } + /* Delete this measCb, send the negative confirmation to + * stack manager */ + cmLListDelFrm(&cell->l2mList, &measCb->measLnk); + /* ccpu00117052 - MOD - Passing double pointer + for proper NULLP assignment*/ + rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb, sizeof(RgSchL2MeasCb)); + cmMemset((U8 *)&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo)); + schMeasCfm.measType = measCfm->measType; + schMeasCfm.cfm = measCfm->cfm; + schMeasCfm.hdr.transId = measCfm->transId; + schMeasCfm.cellId = measCfm->cellId; + RgMiLrgSchL2MeasCfm(&(instCb->rgSchInit.lmPst), &schMeasCfm); + RETVALUE(ROK); + } + for(idx = 0; idx < measCfm->u.prbCfm.numQci; idx++) + { + measCb->avgPrbQciUl.prbUsage[idx].prbUsage = measCfm->u.prbCfm.prbUsage[idx].prbUsage; + measCb->avgPrbQciUl.prbUsage[idx].qciValue = measCfm->u.prbCfm.prbUsage[idx].qciValue; + /*LTE_L2_MEAS_PHASE2*/ + qciVal1 = measCfm->u.prbCfm.prbUsage[idx].qciValue; + for(idx1=0;idx1measReq.avgPrbQciUl.numQci;idx1++) + { + if(measCb->measReq.avgPrbQciUl.qci[idx1] == qciVal1) + { + break; + } + } + if(idx1 == measCb->measReq.avgPrbQciUl.numQci) + { + measCb->measReq.avgPrbQciUl.qci[measCb->measReq.avgPrbQciUl.numQci++] = qciVal1; + } + } + measCb->avgPrbQciUl.numQci = measCfm->u.prbCfm.numQci; + measCb->cfmRcvd = TRUE; + cell->sndL2Meas = TRUE; + RETVALUE(ROK); +} /* end of RgMacSchL2MeasCfm */ + +/** + * @brief Function to handle L2MeasStopCfm from MAC + * + * @details + * + * Function: RgMacSchL2MeasStopCfm + * + * Handler for processing L2 measurement confirm + * + * Invoked by: + * MAC + * + * Processing Steps: + * + * @param[in] Pst *pst + * @param[in] RgInfL2MeasCfm *measCfm + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgMacSchL2MeasStopCfm +( +Pst *pst, +RgInfL2MeasCfm *measCfm +) +#else +PUBLIC S16 RgMacSchL2MeasStopCfm(pst, measCfm) +Pst *pst; +RgInfL2MeasCfm *measCfm; +#endif +{ + LrgSchMeasCfmInfo schMeasCfm; + Inst inst = (pst->dstInst - SCH_INST_START); + RgSchCb *instCb = &rgSchCb[inst]; + + TRC2(RgMacSchL2MeasStopCfm); + + cmMemset((U8 *)&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo)); + schMeasCfm.measType = measCfm->measType; + schMeasCfm.cfm = measCfm->cfm; + schMeasCfm.hdr.transId = measCfm->transId; + schMeasCfm.cellId = measCfm->cellId; + RgMiLrgSchL2MeasStopCfm(&(instCb->rgSchInit.lmPst), &schMeasCfm); + RETVALUE(ROK); +} +#endif + +/************** TFU Interface *************/ + +/** + * @brief Bind confirm API for TFU SAP on scheduler instance. + * + * @details + * + * Function : RgLiTfuSchBndCfm + * + * This API is invoked by PHY to confirm TFU SAP bind. + * + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] U8 status + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuSchBndCfm +( +Pst *pst, +SuId suId, +U8 status +) +#else +PUBLIC S16 RgLiTfuSchBndCfm(pst, suId, status) +Pst *pst; +SuId suId; +U8 status; +#endif +{ + S16 ret; + RgSchLowSapCb *tfuSap; + Inst instId = pst->dstInst - SCH_INST_START; + + TRC3(RgLiTfuSchBndCfm); + + + if(suId >= rgSchCb[instId].numSaps) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,instId, "Incorrect SuId"); + RETVALUE(RFAILED); + } + /* Lets validate suId first */ + tfuSap = &(rgSchCb[instId].tfuSap[suId]); + + if (suId != tfuSap->sapCfg.suId) + { + RLOG_ARG2(L_ERROR,DBG_INSTID,instId, "Incorrect SuId. Configured (%d)" + "Recieved (%d)", tfuSap->sapCfg.suId, suId); + RETVALUE(RFAILED); + } + ret = rgSCHLmmBndCfm (pst, suId, status); + RETVALUE(ret); +} /* RgLiTfuSchBndCfm */ + +/** + * @brief Random Access Request indication from PHY. + * + * @details + * + * Function : RgLiTfuRaReqInd + * + * This API is invoked by PHY to send Random Access Request to Scheduler. + * This API contains information for Random Access Request including + * raRnti, list of associated RAPIDs and related information. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuRaReqIndInfo *raReqInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuRaReqInd +( +Pst *pst, +SuId suId, +TfuRaReqIndInfo *raReqInd +) +#else +PUBLIC S16 RgLiTfuRaReqInd(pst, suId, raReqInd) +Pst *pst; +SuId suId; +TfuRaReqIndInfo *raReqInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuRaReqInd); + + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG1(L_ERROR,DBG_INSTID,inst,"SAP Validation failed SuId(%d)", suId); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(raReqInd); + RETVALUE(ret); + } + + if(raReqInd == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"Invalid input pointer for raReqInd Failed"); + RETVALUE(RFAILED); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_CELLID,raReqInd->cellId,"No cell exists"); + RETVALUE(RFAILED); + } + + ret = rgSCHTomRaReqInd(rgSchCb[inst].tfuSap[suId].cell, raReqInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(raReqInd); + /*SPutSBuf (pst->region, pst->pool, (Data *)raReqInd, + sizeof(TfuRaReqIndInfo)); */ + RETVALUE(ret); +} /* RgLiTfuRaReqInd */ + +/** + * @brief Uplink CQI indication from PHY. + * + * @details + * + * Function : RgLiTfuUlCqiInd + * + * This API is invoked by PHY to send Uplink CQI to Scheduler. + * This API contains Uplink CQI information reported per UE. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuUlCqiIndInfo *ulCqiInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuUlCqiInd +( +Pst *pst, +SuId suId, +TfuUlCqiIndInfo *ulCqiInd +) +#else +PUBLIC S16 RgLiTfuUlCqiInd(pst, suId, ulCqiInd) +Pst *pst; +SuId suId; +TfuUlCqiIndInfo *ulCqiInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuUlCqiInd); + + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(ulCqiInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(ulCqiInd); + RETVALUE(RFAILED); + } + ret = rgSCHTomUlCqiInd (rgSchCb[inst].tfuSap[suId].cell, ulCqiInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(ulCqiInd); + RETVALUE(ret); +} /* RgLiTfuUlCqiInd */ + +/** + * @brief PUCCH power adjustment indication. + * + * @details + * + * Function : RgLiTfuPucchDeltaPwrInd + * + * This API is invoked by PHY to send PUCCH power adjustment + * indication. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuPucchDeltaPwrIndInfo *pucchDeltaPwr + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuPucchDeltaPwrInd +( +Pst *pst, +SuId suId, +TfuPucchDeltaPwrIndInfo *pucchDeltaPwr +) +#else +PUBLIC S16 RgLiTfuPucchDeltaPwrInd(pst, suId, pucchDeltaPwr) +Pst *pst; +SuId suId; +TfuPucchDeltaPwrIndInfo *pucchDeltaPwr; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuPucchDeltaPwrInd); + + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(pucchDeltaPwr); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } + ret = rgSCHTomPucchDeltaPwrInd (rgSchCb[inst].tfuSap[suId].cell, pucchDeltaPwr); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(pucchDeltaPwr); + RETVALUE(ret); +} /* RgLiTfuPucchDeltaPwrInd */ + + +/** + * @brief HARQ ACK indication from PHY for Downlink transmissions. + * + * @details + * + * Function : RgLiTfuHqInd + * + * This API is invoked by PHY to send HARQ ACK information to Scheduler + * on recieving HARQ ACK/NACK from UEs. + * This API contains HARQ ACK information recieved by PHY for downlink + * transmissions. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuHqIndInfo *harqAckInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuHqInd +( +Pst *pst, +SuId suId, +TfuHqIndInfo *harqAckInd +) +#else +PUBLIC S16 RgLiTfuHqInd(pst, suId, harqAckInd) +Pst *pst; +SuId suId; +TfuHqIndInfo *harqAckInd; +#endif +{ + S16 ret; + Inst inst = (pst->dstInst - SCH_INST_START); + + TRC3(RgLiTfuHqInd); + +#ifndef NO_ERRCLS + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + RGSCH_FREE_MEM(harqAckInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } +#endif + + /* Now call the TOM (Tfu ownership module) primitive to process further */ + ret = rgSCHTomHarqAckInd (rgSchCb[inst].tfuSap[suId].cell, harqAckInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(harqAckInd); + RETVALUE(ret); +} /* RgLiTfuHqInd */ + + +/** + * @brief Scheduling request(SR) indication from PHY for an UE. + * + * @details + * + * Function : RgLiTfuSrInd + * + * This API is invoked by PHY to send Scheduling request information to + * Scheduler on recieving SR from a list of UEs. + * This API contains scheduling request information recieved by PHY for UEs. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuSrIndInfo *srInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuSrInd +( +Pst *pst, +SuId suId, +TfuSrIndInfo *srInd +) +#else +PUBLIC S16 RgLiTfuSrInd(pst, suId, srInd) +Pst *pst; +SuId suId; +TfuSrIndInfo *srInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuSrInd); + +#ifndef NO_ERRCLS + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"() SAP Validation failed"); + RGSCH_FREE_MEM(srInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"RgLiTfuSrInd()No cell exists"); + RETVALUE(RFAILED); + } +#endif + /* Now call the TOM (Tfu ownership module) primitive to process further */ + ret = rgSCHTomSrInd (rgSchCb[inst].tfuSap[suId].cell, srInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(srInd); + RETVALUE(ret); +} /* RgLiTfuSrInd */ + + +/** + * @brief Downlink CQI indication from PHY for an UE. + * + * @details + * + * Function : RgLiTfuDlCqiInd + * + * This API is invoked by PHY to send Downlink CQI indication to Scheduler + * on recieving downlink CQI from UE. + * This API contains downlink CQI information recieved by PHY for an UE. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuDlCqiIndInfo *dlCqiInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuDlCqiInd +( +Pst *pst, +SuId suId, +TfuDlCqiIndInfo *dlCqiInd +) +#else +PUBLIC S16 RgLiTfuDlCqiInd(pst, suId, dlCqiInd) +Pst *pst; +SuId suId; +TfuDlCqiIndInfo *dlCqiInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuDlCqiInd); + + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst," SAP Validation failed"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(dlCqiInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } + ret = rgSCHTomDlCqiInd (rgSchCb[inst].tfuSap[suId].cell, dlCqiInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(dlCqiInd); + RETVALUE(ret); +} /* RgLiTfuDlCqiInd */ +#ifdef TFU_UPGRADE + +/** + * @brief Raw CQI indication from PHY for an UE. + * + * @details + * + * Function : RgLiTfuRawCqiInd + * + * This API is invoked by PHY to send Raw CQI indication to Scheduler + * on receiving Raw CQI from UE. + * This API contains Raw CQI information recieved by PHY for an UE. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuRawCqiIndInfo *rawCqiInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuRawCqiInd +( +Pst *pst, +SuId suId, +TfuRawCqiIndInfo *rawCqiInd +) +#else +PUBLIC S16 RgLiTfuRawCqiInd(pst, suId, rawCqiInd) +Pst *pst; +SuId suId; +TfuRawCqiIndInfo *rawCqiInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuRawCqiInd); + +#ifdef NO_ERRCLS + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(rawCqiInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst," No cell exists"); + RETVALUE(RFAILED); + } +#endif + ret = rgSCHTomRawCqiInd (rgSchCb[inst].tfuSap[suId].cell, rawCqiInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(rawCqiInd); + RETVALUE(ret); +} /* RgLiTfuRawCqiInd */ + +/** + * @brief SRS indication from PHY for an UE. + * + * @details + * + * Function : RgLiTfuSrsInd + * + * This API is invoked by PHY to send UL SRS indication to Scheduler + * on receiving a SRS from UE. + * This API contains SRS information recieved by PHY for an UE. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuSrsIndInfo *srsInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuSrsInd +( +Pst *pst, +SuId suId, +TfuSrsIndInfo *srsInd +) +#else +PUBLIC S16 RgLiTfuSrsInd(pst, suId, srsInd) +Pst *pst; +SuId suId; +TfuSrsIndInfo *srsInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuSrsInd); + + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst," SAP Validation failed"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(srsInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } + ret = rgSCHTomSrsInd (rgSchCb[inst].tfuSap[suId].cell, srsInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(srsInd); + RETVALUE(ret); +} /* RgLiTfuSrsInd */ + +#endif + +/** + * @brief DOA indication from PHY for an UE. + * + * @details + * + * Function : RgLiTfuDoaInd + * + * This API is invoked by PHY to send Direction Of Arrival to Scheduler + * on calculating DOA at PHYSICAL LAYER for an UE. + * This API contains DOA information calculated by PHY for an UE. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuDoaIndInfo *doaInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuDoaInd +( +Pst *pst, +SuId suId, +TfuDoaIndInfo *doaInd +) +#else +PUBLIC S16 RgLiTfuDoaInd(pst, suId, doaInd) +Pst *pst; +SuId suId; +TfuDoaIndInfo *doaInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC2(RgLiTfuDoaInd); + + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(doaInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } + ret = rgSCHTomDoaInd (rgSchCb[inst].tfuSap[suId].cell, doaInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(doaInd); + RETVALUE(ret); +} /* RgLiTfuDlCqiInd */ + +/** + * @brief CRC indication from PHY. + * + * @details + * + * Function : RgLiTfuCrcInd + * + * This API is invoked by PHY to give CRC indication to scheduler. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuCrcIndInfo *crcInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuCrcInd +( +Pst *pst, +SuId suId, +TfuCrcIndInfo *crcInd +) +#else +PUBLIC S16 RgLiTfuCrcInd (pst, suId, crcInd) +Pst *pst; +SuId suId; +TfuCrcIndInfo *crcInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuCrcInd); +#ifdef XEON_SPECIFIC_CHANGES +struct timeval start6, end6; +gettimeofday(&start6, NULL); +#endif +#ifndef NO_ERRCLS + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + RGSCH_FREE_MEM(crcInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } +#endif + + /* Now call the TOM (Tfu ownership module) primitive to process further */ + ret = rgSCHTomCrcInd(rgSchCb[inst].tfuSap[suId].cell, crcInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(crcInd); +#ifdef XEON_SPECIFIC_CHANGES +gettimeofday(&end6, NULL); +#endif + RETVALUE(ret); +} /* RgLiTfuCrcInd */ + +/** + * @brief Timing Advance indication from PHY. + * + * @details + * + * Function : RgLiTfuTimingAdvInd + * + * This API is invoked by PHY to indicate timing advance to Scheduler for + * an UE. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuTimingAdvIndInfo *timingAdvInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuTimingAdvInd +( +Pst *pst, +SuId suId, +TfuTimingAdvIndInfo *timingAdvInd +) +#else +PUBLIC S16 RgLiTfuTimingAdvInd(pst, suId, timingAdvInd) +Pst *pst; +SuId suId; +TfuTimingAdvIndInfo *timingAdvInd; +#endif +{ + S16 ret; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuTimingAdvInd); + + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(timingAdvInd); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } + /* Now call the TOM (Tfu ownership module) primitive to process further */ + ret = rgSCHTomTimingAdvInd(rgSchCb[inst].tfuSap[suId].cell, timingAdvInd); + /* Free up the memory for the request structure */ + RGSCH_FREE_MEM(timingAdvInd); + RETVALUE(ret); +} /* RgLiTfuTimingAdvInd */ + + +/** + * @brief Transmission time interval indication from PHY. + * + * @details + * + * Function : RgLiTfuSchTtiInd + * + * This API is invoked by PHY to indicate TTI indication to Scheduler for + * a cell. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuTtiIndInfo *ttiInd + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuSchTtiInd +( +Pst *pst, +SuId suId, +TfuTtiIndInfo *ttiInd +) +#else +PUBLIC S16 RgLiTfuSchTtiInd(pst, suId, ttiInd) +Pst *pst; +SuId suId; +TfuTtiIndInfo *ttiInd; +#endif +{ + S16 ret = ROK; + Inst inst = pst->dstInst-SCH_INST_START; + + TRC3(RgLiTfuSchTtiInd); + + + /* Removing the validation with every TTI - for optimization */ +#ifndef NO_ERRCLS + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + RETVALUE(ret); + } +#endif + /* Moved check for cell outside ERRCLS*/ + + /* Now call the TOM (Tfu ownership module) primitive to process further */ + rgSCHTomTtiInd(ttiInd, inst); + + RETVALUE(ret); +} /* RgLiTfuSchTtiInd */ + +/************* RGM Interface ****************/ +/** + * @brief API for bind request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgmBndReq + * + * This API is invoked by RRM towards MAC to bind RGM SAP. + * These API validates the Pst, spId, suId and sends the bind confirm to + * RRM. + * + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] SpId spId + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgmBndReq +( +Pst *pst, +SuId suId, +SpId spId +) +#else +PUBLIC S16 RgUiRgmBndReq(pst, suId, spId) +Pst *pst; +SuId suId; +SpId spId; +#endif +{ + S16 ret = ROK; + Pst tmpPst; /* Temporary Post Structure */ + Inst instId = pst->dstInst-SCH_INST_START; + + TRC3(RgUiRgmBndReq) + + + tmpPst.prior = pst->prior; + tmpPst.route = pst->route; + tmpPst.selector = pst->selector; + tmpPst.region = rgSchCb[instId].rgSchInit.region; + tmpPst.pool = rgSchCb[instId].rgSchInit.pool; + + tmpPst.srcProcId = rgSchCb[instId].rgSchInit.procId; + tmpPst.srcEnt = rgSchCb[instId].rgSchInit.ent; + tmpPst.srcInst = rgSchCb[instId].rgSchInit.inst + SCH_INST_START; + + tmpPst.event = EVTNONE; + + tmpPst.dstProcId = pst->srcProcId; + tmpPst.dstEnt = pst->srcEnt; + tmpPst.dstInst = pst->srcInst; + + /*TODO remove follo statement*/ + rgSchCb[instId].rgmSap[spId].sapSta.sapState = LRG_UNBND; + + if(spId < rgSchCb[instId].numSaps) + { + /* Check the state of the SAP */ + switch (rgSchCb[instId].rgmSap[spId].sapSta.sapState) + { + /* This case might not be needed if SAP not configured then it will go + * to else of above if condition */ + case LRG_UNBND: /* SAP is not bound */ + RLOG0(L_DEBUG,"SAP is not yet bound"); + rgSchCb[instId].rgmSap[spId].sapSta.sapState = LRG_BND; + rgSchCb[instId].rgmSap[spId].sapCfg.suId = suId; + /* Send Bind Confirm with status as SUCCESS */ + ret = rgSCHUtlRgmBndCfm(instId, suId, CM_BND_OK); + /*Indicate to Layer manager */ + break; + case LRG_BND: /* SAP is already bound*/ + RLOG0(L_DEBUG,"SAP is already bound"); + ret = rgSCHUtlRgmBndCfm(instId, suId, CM_BND_OK); + break; + default: /* Should Never Enter here */ +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG001, + (ErrVal)rgSchCb[instId].rgmSap[spId].sapSta.sapState, + "Invalid SAP State:RgUiRgmBndReq failed\n"); +#endif + ret = rgSCHUtlRgmBndCfm(instId, suId, CM_BND_NOK); + break; + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) +/* ccpu00117035 - MOD - Changed ErrVal argument from accessing sap state + to spId to avoid seg fault due to invalid sapID */ + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG002, + (ErrVal)spId, "Invalid SAP Id:RgUiRrmBndReq failed\n"); +#endif + ret = RgUiRgmBndCfm(&tmpPst, suId, CM_BND_NOK); + } + RETVALUE(ret); +} /* RgUiRgmBndReq */ + +/** + * @brief API for unbind request from RRM towards MAC. + * + * @details + * + * Function: RgUiRgmUbndReq + * + * This API is invoked by RRM towards MAC to unbind RGM SAP. + * These API validates the Pst, spId, suId and transfers the unbind request + * specific information to corresponding ownership module (GOM) API. + * + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] Reason reason + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgmUbndReq +( +Pst *pst, +SpId spId, +Reason reason +) +#else +PUBLIC S16 RgUiRgmUbndReq(pst, spId, reason) +Pst *pst; +SpId spId; +Reason reason; +#endif +{ + Inst instId = pst->dstInst-SCH_INST_START; + TRC3(RgUiRgmUbndReq) + + + /* SAP Id validation */ + if (spId < rgSchCb[instId].numSaps) + { + switch(rgSchCb[instId].rgmSap[spId].sapSta.sapState) + { + case LRG_BND: /* SAP is already bound*/ + /* setting SAP state to UN BOUND */ + RLOG0(L_DEBUG,"SAP is already bound"); + rgSchCb[instId].rgmSap[spId].sapSta.sapState = LRG_UNBND; + break; + default: +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId, ERRCLS_INT_PAR, ERG003, + (ErrVal)rgSchCb[instId].rgmSap[spId].sapSta.sapState, + "Invalid SAP State: RgUiRgmUbndReq failed\n"); +#endif + RETVALUE(RFAILED); + } + } + else + { +#if (ERRCLASS & ERRCLS_ADD_RES) + RGSCHLOGERROR(instId,ERRCLS_INT_PAR, ERG004, + (ErrVal)rgSchCb[instId].rgmSap[spId].sapSta.sapState, + "Invalid SAP Id:RgUiRgmUbndReq failed\n"); +#endif + RETVALUE(RFAILED); + } + RETVALUE(ROK); +} /* RgUiRgmUbndReq */ + + +/** + * @brief API for start or stop PRB reporting from RRM towards MAC. + * + * @details + * + * Function: RgUiRgmCfgPrbRprt + * + * This API is invoked by RRM towards MAC to start or stop calculating + * Average PRB usage in downlink and uplink. The average PRB usage will + * be reported to RRM based on confiured periodicity. + * + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] SpId spId + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgUiRgmCfgPrbRprt +( +Pst *pst, +SpId spId, +RgmPrbRprtCfg *prbRprtCfg +) +#else +PUBLIC S16 RgUiRgmCfgPrbRprt(pst, spId, prbRprtCfg) +Pst *pst; +SpId spId; +RgmPrbRprtCfg *prbRprtCfg; +#endif +{ +/* Initalize*/ + RgSchCellCb *cell; + RgSchPrbUsage *prbUsage; + Inst inst = (pst->dstInst - SCH_INST_START); + + TRC2(RgUiRgmCfgPrbRprt); + cell = rgSchCb[inst].rgmSap[spId].cell; + prbUsage = &cell->prbUsage; + prbUsage->prbRprtEnabld = prbRprtCfg->bConfigType; + prbUsage->rprtPeriod = prbRprtCfg->usPrbAvgPeriodicty; + RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, prbUsage->startTime, 1); + + /* clear the qciPrbRpts for all GBR QCIs */ + cmMemset((U8*)&prbUsage->qciPrbRpts[0], 0, + (RGM_MAX_QCI_REPORTS * sizeof(RgSchQciPrbUsage))); + + RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId, + "RgUiRgmCfgPrbRprt config type %d with the report period %d", + prbUsage->prbRprtEnabld,prbUsage->rprtPeriod); + + /* ccpu00134393 : mem leak fix */ + SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg)); + + RETVALUE(ROK); +} +/** + * @brief ERROR INDICATION from PHY for the i failed unlicensed Scell transmission. + * + * @details + * + * Function : RgLiTfuErrInd + * + * This API is invoked by PHY to send ERROR INDICATION to scheduler + * Currently invoked in the cases when the Unlicensed SCell transmission + * fails. + * This API contains the Cell and subframe information for which the + * transmission failed. + * + * @param[in] Pst *pst + * @param[in] SuId suId + * @param[in] TfuErrIndInfo *errIndInfo + * @return S16 + * -# ROK + * -# RFAILED + **/ +#ifdef ANSI +PUBLIC S16 RgLiTfuErrInd +( +Pst *pst, +SuId suId, +TfuErrIndInfo *errInd +) +#else +PUBLIC S16 RgLiTfuErrInd(pst, suId, errInd) +Pst *pst; +SuId suId; +TfuErrIndInfo *errInd; +#endif +{ + S16 ret = ROK; +#ifdef LTE_ADV + Inst inst = (pst->dstInst - SCH_INST_START); +#endif + + TRC3(RgLiTfuErrInd); + +#ifndef NO_ERRCLS + if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK) + { + + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed"); + RETVALUE(ret); + } + + if (rgSchCb[inst].tfuSap[suId].cell == NULLP) + { + RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists"); + RETVALUE(RFAILED); + } +#endif + +#ifdef LTE_ADV + /* Now call the TOM (Tfu ownership module) primitive to process further */ + ret = rgSCHLaaErrInd(rgSchCb[inst].tfuSap[suId].cell, errInd); +#endif + RETVALUE(ret); +} /* RgLiTfuErrInd */ + + + +/********************************************************************** + + End of file +**********************************************************************/