@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 "common_def.h"
#include "lrg.h"
#include "rgr.h"
#include "tfu.h"
#include "rg_sch.h"
#include "rg_sch_err.h"
#include "rg_sch_cmn.h"
-#include "rl_interface.h"
-#include "rl_common.h"
+#include "sch_utils.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 "rg_sch_inf.x" /* typedefs for Scheduler */
#include "rg_sch.x" /* typedefs for Scheduler */
#include "rg_sch_cmn.x"
+#include "mac_sch_interface.h"
#ifdef EMTC_ENABLE
-EXTERN S16 rgEmtcMacSchUeDelInd ARGS((RgSchCellCb *cell,RgInfUeDelInd *ueDelInd));
-EXTERN S16 rgSCHGomEmtcHndlSiCfg ARGS((
+S16 rgEmtcMacSchUeDelInd ARGS((RgSchCellCb *cell,RgInfUeDelInd *ueDelInd));
+S16 rgSCHGomEmtcHndlSiCfg ARGS((
Region reg,
Pool pool,
RgSchCb *instCb,
RgrCfgTransId transId,
RgrSiCfgReqInfo *cfgReqInfo
));
-EXTERN S16 rgSCHGomEmtcHndlWarningSiCfg ARGS((
+S16 rgSCHGomEmtcHndlWarningSiCfg ARGS((
Region reg,
Pool pool,
RgSchCb *instCb,
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMiLrgSchCntrlReq
+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)
+ SCH_ALLOC(cfm, sizeof(RgMngmt));
+ if(cfm == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Memory Unavailable for Confirmation");
- SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt));
- RETVALUE(ROK);
+ DU_LOG("\nERROR --> SCH : Memory Unavailable for Confirmation");
+ SCH_FREE(pst->region, pst->pool, cntrl, sizeof(RgMngmt));
+ return ROK;
} */
- cmMemset((U8 *)&cfm, 0, sizeof(RgMngmt));
+ memset(&cfm, 0, sizeof(RgMngmt));
#ifdef LMINT3
cfm.hdr.transId =
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);
+ DU_LOG("\nERROR --> SCH : Gen Cfg not done.");
+ /* SCH_FREE(pst->region, pst->pool, cntrl, sizeof(RgMngmt)); */
+ return ROK;
}
/* General Config done, process the Control request */
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",
+ DU_LOG("\nERROR --> SCH : invalid elmnt=%d",
cntrl->hdr.elmId.elmnt);
break;
}
- /* SPutSBuf(pst->region, pst->pool, (Data *)cntrl, sizeof(RgMngmt)); */
- RETVALUE(ret);
+ /* SCH_FREE(pst->region, pst->pool, cntrl, sizeof(RgMngmt)); */
+ return (ret);
}/*-- RgMiLrgSchCntrlReq --*/
#ifdef LTE_L2_MEAS
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasReq
+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;
#if (ERRCLASS & ERRCLS_ADD_RES)
CmLList *lnk;
#endif
- U32 idx;
+ uint32_t idx;
RgSchL2MeasCb *measCb = NULLP;
#ifdef DEBUGP
Inst inst = (pst->dstInst - SCH_INST_START); /* Scheduler instance Id */
err.errType = 0;
err.errCause = 0;
- TRC3(RgMiLrgSchL2MeasReq)
-
/* Find the cellCb using cellId in measInfo. Iterate through all cells
* in rgrsapCb in RgschCb */
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)",
+ DU_LOG("\nERROR --> SCH : Meas req Failed.Invalid Cell Id errType(%d) errCause(%d)",
err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return 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"
+ DU_LOG("\nERROR --> SCH : Meas req Failed.Invalid Measurement Type"
"errCasue(%d) errType(%d)", err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Iterate through all meas requests in l2mList in cellCb */
#if (ERRCLASS & ERRCLS_ADD_RES)
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"
+ DU_LOG("\nERROR --> SCH : Meas req Failed Duplicate TransId"
"errType(%d) errCause(%d)", err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
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)",
+ DU_LOG("\nERROR --> SCH : Meas req Failed.errType(%d) errCause(%d)",
err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ret);
+ return (ret);
} /* -- RRgMiLrgSchL2MeasReq-- */
/**
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasStopReq
+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;
+ 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)
-
+ uint8_t idx;
for (idx = 0; idx < instCb->numSaps; idx++)
{
}
if (cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
- "Stop req Failed.Invalid Cell Id ");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : Stop req Failed.Invalid Cell Id ");
+ return RFAILED;
}
- cmMemset((U8 *)&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ memset(&measCfm, 0, sizeof(LrgSchMeasCfmInfo));
node = cell->l2mList.first;
while(node != NULLP)
{
{
RgInfL2MeasStopReq measStopReq;
Pst pstMac;
- cmMemset((U8 *)&measStopReq, 0, sizeof(RgInfL2MeasStopReq));
+ memset(&measStopReq, 0, sizeof(RgInfL2MeasStopReq));
measStopReq.transId = measInfo->hdr.transId;
measStopReq.measType = measInfo->measType;
/* measReq.timePrd = measInfo->timePrd; */
RgMiLrgSchL2MeasStopCfm(&(rgSchCb[cell->instIdx].rgSchInit.lmPst),
&measCfm);
}
- RETVALUE(ret);
+ return (ret);
}/*RgMiLrgSchL2MeasStopReq*/
/**
* @brief Layer Manager L2 Measurement request handler.
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMiLrgSchL2MeasSendReq
+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)
-
-
+ uint8_t idx;
cell = NULLP;
for (idx = 0; idx < instCb->numSaps; idx++)
}
if (cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,measInfo->cellId,
- "Send req Failed.Invalid Cell Id");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : Send req Failed.Invalid Cell Id");
+ return RFAILED;
}
if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
{
RgInfL2MeasSndReq measSndReq;
Pst pstMac;
- cmMemset((U8 *)&measSndReq, 0, sizeof(RgInfL2MeasSndReq));
+ memset(&measSndReq, 0, sizeof(RgInfL2MeasSndReq));
measSndReq.transId = measInfo->hdr.transId;
measSndReq.measType = measInfo->measType;
measSndReq.timePrd = measInfo->timePrd;
cell->sndL2Meas = TRUE;
}
- RETVALUE(ret);
+ return (ret);
}/*RgMiLrgSchL2MeasSendReq*/
#endif /* LTE_L2_MEAS */
* -# 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 RgUiRgrBndReq(Pst *pst, SuId suId, SpId spId)
{
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;
/* 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");
+ DU_LOG("\nDEBUG --> SCH : 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 */
LRG_EVENT_RGRSAP_ENB, LCM_CAUSE_UNKNOWN, &dgn);
break;
case LRG_BND: /* SAP is already bound*/
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nDEBUG --> SCH : 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State:RgUiRrgBndReq failed\n");
#endif
ret = rgSCHUtlRgrBndCfm(instId, suId, CM_BND_NOK);
break;
#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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRrgBndReq failed\n");
#endif
ret = RgUiRgrBndCfm(&tmpPst, suId, CM_BND_NOK);
}
- RETVALUE(ret);
+ return (ret);
} /* RgUiRgrBndReq */
/**
* -# 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
+S16 RgUiRgrUbndReq(Pst *pst,SpId spId,Reason reason)
{
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");
+ DU_LOG("\nDEBUG --> SCH : 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State RgUiRgrUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id RgUiRgrUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgrUbndReq */
#ifdef RGR_SI_SCH
* -# 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 RgUiRgrSiCfgReq(Pst *pst, SpId spId,RgrCfgTransId transId,RgrSiCfgReqInfo *cfgReqInfo)
{
S16 ret = ROK;
- U8 cfmStatus = RGR_CFG_CFM_NOK;
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t cfmStatus = RGR_CFG_CFM_NOK;
+ uint8_t 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);
+ memcpy(prntTrans, 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");
+ DU_LOG("\nERROR --> SCH : Input Message Buffer is NULL");
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrSiCfgReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
- (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrSiCfgReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
- (Size)sizeof(*cfgReqInfo));
+ SCH_FREE(cfgReqInfo, (Size)sizeof(*cfgReqInfo));
rgSCHUtlRgrSiCfgCfm(instId, spId, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Handle configuration */
#endif
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"RgUiRgrSiCfgReq:"
+ DU_LOG("\nERROR --> SCH : RgUiRgrSiCfgReq:"
"Configuration Request Handling Failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgrSiCfgReq */
\f
* -# 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
+S16 RgUiRgrWarningSiCfgReq(Pst *pst, SpId spId,RgrCfgTransId transId,RgrWarningSiCfgReqInfo *warningSiCfgReqInfo)
{
Inst instId = pst->dstInst-SCH_INST_START;
S16 ret = ROK;
- U8 cfmStatus = RGR_CFG_CFM_NOK;
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t cfmStatus = RGR_CFG_CFM_NOK;
+ uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
- TRC2(RgUiRgrWarningSiCfgReq);
-
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, 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 "
+ DU_LOG("\nERROR --> SCH : Input Message Buffer "
"is NULL");
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, 0, transId, cfmStatus);
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State: warningSiCfgReqInfo failed\n");
#endif
rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool,
&warningSiCfgReqInfo->siPduLst);
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
- sizeof(RgrWarningSiCfgReqInfo));
+ SCH_FREE(warningSiCfgReqInfo, sizeof(RgrWarningSiCfgReqInfo));
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
transId, cfmStatus);
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id:warningSiCfgReqInfo failed\n");
#endif
rgSCHUtlFreeWarningSiSeg(pst->region, pst->pool,
&warningSiCfgReqInfo->siPduLst);
- SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
- sizeof(RgrWarningSiCfgReqInfo));
+ SCH_FREE(warningSiCfgReqInfo,sizeof(RgrWarningSiCfgReqInfo));
rgSCHUtlRgrWarningSiCfgCfm(instId, spId, warningSiCfgReqInfo->siId,
transId, cfmStatus);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Handle configuration */
#endif
if(ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,instId,
- "Configuration Request Handling Failed");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : Configuration Request Handling Failed");
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
\f
* -# 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
+S16 RgUiRgrWarningSiStopReq(Pst *pst,SpId spId,RgrCfgTransId transId,uint8_t siId)
{
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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrWarningSiStopReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrWarningSiStopReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgSCHGomHndlWarningSiStopReq(pst->region, pst->pool,
&rgSchCb[instId], siId, transId, spId);
- RETVALUE(ROK);
+ return ROK;
}
#endif /*RGR_SI_SCH */
* -# 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 RgUiRgrLoadInfReq(Pst *pst, SpId spId, RgrCfgTransId transId,RgrLoadInfReqInfo *loadInfReq)
{
S16 ret = ROK;
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t 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);
+ memcpy(prntTrans, 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 "
+ DU_LOG("\nERROR --> SCH : Input Message Buffer "
"is NULL");
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgrLoadInfReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
- (Size)sizeof(*loadInfReq));
- RETVALUE(RFAILED);
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgrLoadInfReq failed\n");
#endif
- SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
- (Size)sizeof(*loadInfReq));
- RETVALUE(RFAILED);
+ SCH_FREE(loadInfReq, (Size)sizeof(*loadInfReq));
+ return RFAILED;
}
/* Handle configuration */
loadInfReq);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,instId,
- "Configuration Request Handling Failed");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : Configuration Request Handling Failed");
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgrLoadInfReq */
/* LTE_ADV_FLAG_REMOVED_END */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMacSchDedBoUpdtReq
-(
-Pst* pst,
-RgInfDedBoRpt *boRpt
-)
-#else
-PUBLIC S16 RgMacSchDedBoUpdtReq(pst, boRpt)
-Pst* pst;
-RgInfDedBoRpt *boRpt;
-#endif
+S16 RgMacSchDedBoUpdtReq(Pst* pst,RgInfDedBoRpt *boRpt)
{
RgSchCellCb *cell;
RgSchUeCb *ue;
#ifdef SCH_STATS
- RgSchCmnDlUe *dlUe;
+ 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():"
+ DU_LOG("\nDEBUG --> SCH : 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
if (cell->cellId != boRpt->cellId)
{
/* Handle Cell fetch failure */
- RGSCHLOGERROR(inst, ERRCLS_INT_PAR,ERG009,(ErrVal)boRpt->cellId,
- "rgMacSchDedBoUpdtReq(): Invalid cell Id");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : rgMacSchDedBoUpdtReq(): Invalid cell Id");
+ return RFAILED;
}
#endif
#ifdef LTE_ADV
if (cell != ue->cell)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if ((dlLc = rgSCHDbmGetDlDedLcCb(ue, boRpt->lcId)) != NULLP)
dlLc->setMaxDlPrio = boRpt->setMaxDlPrio;
/* Update the scheduler */
rgSCHUtlDlDedBoUpd(cell, ue, dlLc);
- RETVALUE(ROK);
+ return ROK;
}
}
- RETVALUE(RFAILED);
+ return RFAILED;
} /* end of rgMacSchDedBoUpdtReq */
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMacSchCmnBoUpdtReq
-(
-Pst* pst,
-RgInfCmnBoRpt *boRpt
-)
-#else
-PUBLIC S16 RgMacSchCmnBoUpdtReq(pst, boRpt)
-Pst* pst;
-RgInfCmnBoRpt *boRpt;
-#endif
+S16 RgMacSchCmnBoUpdtReq(Pst* pst,RgInfCmnBoRpt *boRpt)
{
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():"
+ DU_LOG("\nERROR --> SCH : RgMacSchCmnBoUpdtReq():"
"Invalid boRpt cell Id:%d",boRpt->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* handle status response on CCCH */
if(boRpt->lcId == cell->dlCcchId)
{
- RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,"RgMacSchCmnBoUpdtReq():"
+ DU_LOG("\nDEBUG --> SCH : RgMacSchCmnBoUpdtReq():"
" BO update for CCCH");
rgSCHUtlHndlCcchBoUpdt(cell, boRpt);
}
rgSCHUtlHndlBcchPcchBoUpdt(cell, boRpt);
}
- RETVALUE(ROK);
+ return ROK;
} /* end of RgMacSchCmnBoUpdtReq */
/*Fix: start: Inform UE delete to scheduler*/
/**
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMacSchUeDelInd
-(
-Pst* pst,
-RgInfUeDelInd *ueDelInd
-)
-#else
-PUBLIC S16 RgMacSchUeDelInd(pst, ueDelInd)
-Pst* pst;
-RgInfUeDelInd *ueDelInd;
-#endif
+S16 RgMacSchUeDelInd(Pst* pst,RgInfUeDelInd *ueDelInd)
{
RgSchCellCb *cell;
Inst inst = (pst->dstInst - SCH_INST_START);
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);
+ DU_LOG("\nERROR --> SCH : rgrSap or cell is not configured");
+ return 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",
+ DU_LOG("\nERROR --> SCH : rgMacSchUeDelInd(): Invalid ueDelInd cell Id:%d",
ueDelInd->cellId);
- RETVALUE(ROK);
+ return ROK;
}
#endif
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)",
+ DU_LOG("\nDEBUG --> SCH : RNTI:%d Released from the Guard pool(%d)",
ueDelInd->rnti, cell->rntiDb.rntiGuardPool.count);
break;
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);
+ DU_LOG("\nINFO --> SCH : HO CRNTI:%d not present in the"
+ "Guard Pool:%d", ueDelInd->rnti, cell->rntiDb.rntiGuardPool.count);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgMacSchUeDelInd */
/*Fix: end: Inform UE delete to scheduler*/
/**
* @return S16
* -# ROK
**/
-#ifdef ANSI
-PUBLIC S16 RgMacSchSfRecpInd
-(
-Pst* pst,
-RgInfSfDatInd *subfrmInfo
-)
-#else
-PUBLIC S16 RgMacSchSfRecpInd(pst, subfrmInfo)
-Pst* pst;
-RgInfSfDatInd *subfrmInfo;
-#endif
+S16 RgMacSchSfRecpInd(Pst* pst,RgInfSfDatInd *subfrmInfo)
{
S16 ret = RFAILED;
RgSchErrInfo err;
RgSchCmnUlUeSpsInfo *ulSpsUe ;
#endif
/* RRM_RBC_X */
- U32 idx;
+ uint32_t 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;
+ uint8_t qci;
+ uint16_t datIndActQci = 0;
+ uint16_t combDatIndActQci = 0; /* Prev and Latest Dat Ind combined */
+ uint16_t tempUeActQci = 0; /* UE specific Active QCIs */
+ uint16_t diffBits = 0;
+ uint8_t lcCount;
#endif
- TRC3(RgMacSchSfRecpInd)
/* No need to chk for cell being NULL as MAC wouldn't have found instance if
* it doesnt exist */
{
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 ",
+ DU_LOG("\nDEBUG --> SCH : Received MSG3 with CRNTI:%d and also CCCH ",
datInd->ceInfo.ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ue = rgSCHDbmGetUeCb (cell, datInd->ceInfo.ces.cRnti);
if (ue == NULLP)
/* 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 "
+ DU_LOG("\nERROR --> SCH : Received MSG3 "
"with CRNTI:%d unable to find ueCb",
datInd->ceInfo.ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ret = rgSCHUtlProcMsg3 (subfrmInfo, cell, ue,
{
RGSCH_FREE_MEM(subfrmInfo);
err.errType = RGSCHERR_TOM_DATIND;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Processing for MSG3 failed for CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Processing for MSG3 failed for CRNTI:%d",
datInd->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifdef LTEMAC_SPS
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);
+ DU_LOG("\nERROR --> SCH : Could not Send Ue Sta Ind UEID:%d",ue->ueId);
}
}
CM_LLIST_NEXT_NODE(lnkLst, tmp);
{
RGSCH_FREE_MEM(subfrmInfo);
err.errType = RGSCHERR_TOM_DATIND;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Processing for MSG3 failed for CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Processing for MSG3 failed for CRNTI:%d",
datInd->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* fix */
CM_LLIST_NEXT_NODE(lnkLst, tmp);
{
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",
+ DU_LOG("\nERROR --> SCH : Unable to get the UE CB for CRNTI:%d",
datInd->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
}
{
RGSCH_FREE_MEM(subfrmInfo);
err.errType = RGSCHERR_TOM_DATIND;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to handle Data"
+ DU_LOG("\nERROR --> SCH : Unable to handle Data"
" Indication for UEID:%d",ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
CM_LLIST_NEXT_NODE(lnkLst, tmp);
/* chk if Sch needs to dealloc datInd after unpk */
RGSCH_FREE_MEM(subfrmInfo);
- RETVALUE(ret);
+ return (ret);
} /* rgMacSchSfRecpInd */
#ifdef LTEMAC_SPS
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 RgMacSchSpsRelInd
-(
-Pst *pst,
-RgInfSpsRelInfo *relInfo
-)
-#else
-PUBLIC S16 RgMacSchSpsRelInd(pst, relInfo)
-Pst *pst;
-RgInfSpsRelInfo *relInfo;
-#endif
+S16 RgMacSchSpsRelInd(Pst *pst,RgInfSpsRelInfo *relInfo)
{
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 */
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);
+ DU_LOG("\nERROR --> SCH : No Ue exists with CRNTI:%d",relInfo->cRnti);
+ return 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);
+ DU_LOG("\nERROR --> SCH : RelInd processing for CRNTI:%d failed",relInfo->cRnti);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of RgMacSchSpsRelInd */
#endif /* LTEMAC_SPS */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 RgMacSchL2MeasCfm
-(
-Pst *pst,
-RgInfL2MeasCfm *measCfm
-)
-#else
-PUBLIC S16 RgMacSchL2MeasCfm(pst, measCfm)
-Pst *pst;
-RgInfL2MeasCfm *measCfm;
-#endif
+S16 RgMacSchL2MeasCfm(Pst *pst, RgInfL2MeasCfm *measCfm)
{
RgSchCellCb *cell = NULLP;
Inst inst = (pst->dstInst - SCH_INST_START);
CmLList *lnk;
RgSchL2MeasCb *measCb = NULLP;
RgSchCb *instCb = &rgSchCb[inst];
- U32 idx;
+ uint32_t idx;
LrgSchMeasCfmInfo schMeasCfm;
- U8 qciVal;
- U8 idx1; /*LTE_L2_MEAS_PHASE2*/
- U8 qciVal1;
- TRC2(RgMacSchL2MeasCfm);
+ uint8_t qciVal;
+ uint8_t idx1; /*LTE_L2_MEAS_PHASE2*/
+ uint8_t qciVal1;
/* Find the cellCb using cellId in measInfo. Iterate through all cells
* in rgrsapCb in RgschCb */
/* 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);
+ DU_LOG("\nERROR --> SCH : Meas Cfm Failed.Invalid Cell Id");
+ return RFAILED;
}
}
if ( measCb == NULLP )
{
- RETVALUE( RFAILED );
+ return ( RFAILED );
}
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)&measCb, sizeof(RgSchL2MeasCb));
- cmMemset((U8 *)&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ memset(&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);
+ return ROK;
}
for(idx = 0; idx < measCfm->u.prbCfm.numQci; idx++)
{
measCb->avgPrbQciUl.numQci = measCfm->u.prbCfm.numQci;
measCb->cfmRcvd = TRUE;
cell->sndL2Meas = TRUE;
- RETVALUE(ROK);
+ return ROK;
} /* end of RgMacSchL2MeasCfm */
/**
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-PUBLIC S16 RgMacSchL2MeasStopCfm
-(
-Pst *pst,
-RgInfL2MeasCfm *measCfm
-)
-#else
-PUBLIC S16 RgMacSchL2MeasStopCfm(pst, measCfm)
-Pst *pst;
-RgInfL2MeasCfm *measCfm;
-#endif
+S16 RgMacSchL2MeasStopCfm(Pst *pst,RgInfL2MeasCfm *measCfm)
{
LrgSchMeasCfmInfo schMeasCfm;
Inst inst = (pst->dstInst - SCH_INST_START);
RgSchCb *instCb = &rgSchCb[inst];
- TRC2(RgMacSchL2MeasStopCfm);
-
- cmMemset((U8 *)&schMeasCfm, 0, sizeof(LrgSchMeasCfmInfo));
+ memset(&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);
+ return ROK;
}
#endif
*
* @param[in] Pst *pst
* @param[in] SuId suId
- * @param[in] U8 status
+ * @param[in] uint8_t 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 RgLiTfuSchBndCfm (Pst *pst,SuId suId, uint8_t status)
{
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);
+ DU_LOG("\nERROR --> SCH : Incorrect SuId");
+ return 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)"
+ DU_LOG("\nERROR --> SCH : Incorrect SuId. Configured (%d)"
"Recieved (%d)", tfuSap->sapCfg.suId, suId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHLmmBndCfm (pst, suId, status);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuSchBndCfm */
/**
* -# 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 RgLiTfuRaReqInd(Pst *pst,SuId suId, TfuRaReqIndInfo *raReqInd)
{
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);
+ DU_LOG("\nERROR --> SCH : SAP Validation failed SuId(%d)", suId);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(raReqInd);
- RETVALUE(ret);
+ return (ret);
}
if(raReqInd == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"Invalid input pointer for raReqInd Failed");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : Invalid input pointer for raReqInd Failed");
+ return RFAILED;
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,raReqInd->cellId,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return 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,
+ /*SCH_FREE(pst->region, pst->pool, (Data *)raReqInd,
sizeof(TfuRaReqIndInfo)); */
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuRaReqInd */
/**
* -# 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 RgLiTfuUlCqiInd(Pst *pst, SuId suId, TfuUlCqiIndInfo *ulCqiInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(ulCqiInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
+ DU_LOG("\nERROR --> SCH : No cell exists");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(ulCqiInd);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ret = rgSCHTomUlCqiInd (rgSchCb[inst].tfuSap[suId].cell, ulCqiInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(ulCqiInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuUlCqiInd */
/**
* -# 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 RgLiTfuPucchDeltaPwrInd(Pst *pst,SuId suId,TfuPucchDeltaPwrIndInfo *pucchDeltaPwr)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(pucchDeltaPwr);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
ret = rgSCHTomPucchDeltaPwrInd (rgSchCb[inst].tfuSap[suId].cell, pucchDeltaPwr);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(pucchDeltaPwr);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuPucchDeltaPwrInd */
* -# 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 RgLiTfuHqInd(Pst *pst, SuId suId, TfuHqIndInfo *harqAckInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
RGSCH_FREE_MEM(harqAckInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
#endif
ret = rgSCHTomHarqAckInd (rgSchCb[inst].tfuSap[suId].cell, harqAckInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(harqAckInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuHqInd */
* -# 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 RgLiTfuSrInd(Pst *pst, SuId suId, TfuSrIndInfo *srInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
RGSCH_FREE_MEM(srInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"RgLiTfuSrInd()No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : RgLiTfuSrInd()No cell exists");
+ return 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);
+ return (ret);
} /* RgLiTfuSrInd */
* -# 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 RgLiTfuDlCqiInd(Pst *pst, SuId suId, TfuDlCqiIndInfo *dlCqiInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(dlCqiInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
ret = rgSCHTomDlCqiInd (rgSchCb[inst].tfuSap[suId].cell, dlCqiInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(dlCqiInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuDlCqiInd */
#ifdef TFU_UPGRADE
* -# 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 RgLiTfuRawCqiInd(Pst *pst, SuId suId, TfuRawCqiIndInfo *rawCqiInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(rawCqiInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst," No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
#endif
ret = rgSCHTomRawCqiInd (rgSchCb[inst].tfuSap[suId].cell, rawCqiInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(rawCqiInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuRawCqiInd */
/**
* -# 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 RgLiTfuSrsInd(Pst *pst, SuId suId, TfuSrsIndInfo *srsInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(srsInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
ret = rgSCHTomSrsInd (rgSchCb[inst].tfuSap[suId].cell, srsInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(srsInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuSrsInd */
#endif
* -# 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 RgLiTfuDoaInd(Pst *pst, SuId suId, TfuDoaIndInfo *doaInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(doaInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
ret = rgSCHTomDoaInd (rgSchCb[inst].tfuSap[suId].cell, doaInd);
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(doaInd);
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuDlCqiInd */
/**
* -# 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 RgLiTfuCrcInd(Pst *pst, SuId suId, TfuCrcIndInfo *crcInd)
{
S16 ret;
Inst inst = pst->dstInst-SCH_INST_START;
- TRC3(RgLiTfuCrcInd);
#ifdef XEON_SPECIFIC_CHANGES
struct timeval start6, end6;
gettimeofday(&start6, NULL);
#ifndef NO_ERRCLS
if ((ret = rgSCHUtlValidateTfuSap (inst, suId)) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"SAP Validation failed");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
RGSCH_FREE_MEM(crcInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
#endif
#ifdef XEON_SPECIFIC_CHANGES
gettimeofday(&end6, NULL);
#endif
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuCrcInd */
/**
* -# 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 RgLiTfuTimingAdvInd(Pst *pst, SuId suId, TfuTimingAdvIndInfo *timingAdvInd)
{
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");
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
/* Free up the memory for the request structure */
RGSCH_FREE_MEM(timingAdvInd);
- RETVALUE(ret);
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return 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);
+ return (ret);
} /* RgLiTfuTimingAdvInd */
/************* RGM Interface ****************/
* -# 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 RgUiRgmBndReq(Pst *pst,SuId suId,SpId spId)
{
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;
/* 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");
+ DU_LOG("\nDEBUG --> SCH : 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 */
/*Indicate to Layer manager */
break;
case LRG_BND: /* SAP is already bound*/
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nDEBUG --> SCH : 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State:RgUiRgmBndReq failed\n");
#endif
ret = rgSCHUtlRgmBndCfm(instId, suId, CM_BND_NOK);
break;
#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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRrmBndReq failed\n");
#endif
ret = RgUiRgmBndCfm(&tmpPst, suId, CM_BND_NOK);
}
- RETVALUE(ret);
+ return (ret);
} /* RgUiRgmBndReq */
/**
* -# 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
+S16 RgUiRgmUbndReq(Pst *pst,SpId spId,Reason reason)
{
Inst instId = pst->dstInst-SCH_INST_START;
- TRC3(RgUiRgmUbndReq)
-
/* SAP Id validation */
if (spId < rgSchCb[instId].numSaps)
{
case LRG_BND: /* SAP is already bound*/
/* setting SAP state to UN BOUND */
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nDEBUG --> SCH : 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP State: RgUiRgmUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return 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");
+ DU_LOG("\nERROR --> SCH : Invalid SAP Id:RgUiRgmUbndReq failed\n");
#endif
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* RgUiRgmUbndReq */
* -# 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
+S16 RgUiRgmCfgPrbRprt(Pst *pst, SpId spId,RgmPrbRprtCfg *prbRprtCfg)
{
/* 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;
RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, prbUsage->startTime, 1);
/* clear the qciPrbRpts for all GBR QCIs */
- cmMemset((U8*)&prbUsage->qciPrbRpts[0], 0,
+ memset(&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",
+ DU_LOG("\nDEBUG --> SCH : 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));
+ SCH_FREE(prbRprtCfg, sizeof(RgmPrbRprtCfg));
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief ERROR INDICATION from PHY for the i failed unlicensed Scell transmission.
* -# 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 RgLiTfuErrInd(Pst *pst, SuId suId, TfuErrIndInfo *errInd)
{
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);
+ DU_LOG("\nERROR --> SCH : SAP Validation failed");
+ return (ret);
}
if (rgSchCb[inst].tfuSap[suId].cell == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"No cell exists");
- RETVALUE(RFAILED);
+ DU_LOG("\nERROR --> SCH : No cell exists");
+ return RFAILED;
}
#endif
/* Now call the TOM (Tfu ownership module) primitive to process further */
ret = rgSCHLaaErrInd(rgSchCb[inst].tfuSap[suId].cell, errInd);
#endif
- RETVALUE(ret);
+ return (ret);
} /* RgLiTfuErrInd */
Code Review / o-du / l2.git / blobdiff