PRIVATE S16 rgTOMUtlProcDlSf ARGS(( RgDlSf *dlSf, RgCellCb *cellCb,
RgErrInfo *err));
#else
-PUBLIC S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
+S16 rgTOMUtlProcDlSf ARGS((RgDlSf *dlSf, RgCellCb *cellCb,
RgErrInfo *err));
#endif
PRIVATE S16 rgTOMProcCrntiCEInDatInd ARGS((
U16 slot
));
-PUBLIC S16 rgHndlFlowCntrl
+S16 rgHndlFlowCntrl
(
RgCellCb *cell,
RgInfSfAlloc *sfInfo
}
/* global variables */
-PUBLIC U32 rgUlrate_tfu;
+U32 rgUlrate_tfu;
#ifdef EMTC_ENABLE
EXTERN U32 grgUlrate_tfu;
#endif
U8 idx;
Inst inst = cellCb->macInst - RG_INST_START;
- TRC2(rgTOMUtlFillDatReqPdus)
/* first lets send the BCCH data down to PHY */
if (dlSf->bcch.tb != NULLP)
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion ");
- RETVALUE(ret);
+ return (ret);
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
#ifndef L2_OPTMZ
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",datReq->rnti);
- RETVALUE(ret);
+ return (ret);
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
#ifndef L2_OPTMZ
err->errCause = RGERR_TOM_MEM_EXHAUST;
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Memory Exhaustion CRNTI:%d",
datReq->rnti);
- RETVALUE(ret);
+ return (ret);
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
#ifndef L2_OPTMZ
} /* end of while */
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgTOMUtlFillDatReqPdus*/
/** @brief This function does all the processing related to a single downlink
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgTOMUtlProcDlSf
+S16 rgTOMUtlProcDlSf
(
RgDlSf *dlSf,
RgCellCb *cellCb,
RgErrInfo *err
)
#else
-PUBLIC S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
+S16 rgTOMUtlProcDlSf (dlSf, cellCb, err)
RgDlSf *dlSf;
RgCellCb *cellCb;
RgErrInfo *err;
TfuDatReqInfo *datInfo;
Inst inst = cellCb->macInst - RG_INST_START;
- TRC2(rgTOMUtlProcDlSf);
/* Fill Data Request Info from scheduler to PHY */
if ((ret = rgAllocEventMem(inst,(Ptr *)&datInfo,
sizeof(TfuDatReqInfo))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to Allocate TfuDatReqInfo");
- RETVALUE(ret);
+ return (ret);
}
else
{
if ((ret = rgTOMEmtcUtlFillDatReqPdus(datInfo, dlSf, cellCb, err)) != ROK)
{
RG_FREE_MEM(datInfo);
- RETVALUE(ret);
+ return (ret);
}
#endif
/* Fill the DLSCH PDUs of BCCH, PCCH and Dedicated Channels */
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to send data for cell");
RG_FREE_MEM(datInfo);
- RETVALUE(ret);
+ return (ret);
}
if((datInfo->pdus.count) || (datInfo->bchDat.pres == TRUE))
{
RG_FREE_MEM(datInfo);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* end of */
U32 rgMacGT;
RgUstaDgn dgn; /* Alarm diagnostics structure */
VOLATILE U32 startTime=0;
- TRC2(rgTOMUtlAllocPduEvnt);
evntMem.region = rgCb[inst].rgInit.region;
evntMem.pool = rgCb[inst].rgInit.pool;
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RLOG0(L_ERROR,"Allocation of DUX event failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*stoping Task*/
SStopTask(startTime, PID_TOMUTL_CMALLCEVT);
- RETVALUE(ROK);
+ return ROK;
} /* end of */
/** @brief This function frees up the RgMacPdu structure that has been
RgMacSdu *sdu;
CmLList *node;
- TRC2(rgTOMUtlFreePduEvnt);
/* Steps of freeing up the PDU.
* 1. loop through the subHdrLst and free up all the buffers.
* 2. free up the whole event
RgUstaDgn dgn; /* Alarm diagnostics structure */
VOLATILE U32 startTime=0;
- TRC2(rgTOMInfAllocPduEvnt);
evntMem.region = rgCb[inst].rgInit.region;
evntMem.pool = rgCb[inst].rgInit.pool;
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
RLOG0(L_ERROR,"Allocation failed");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*stoping Task*/
SStopTask(startTime, PID_TOMINF_CMALLCEVT);
- RETVALUE(ROK);
+ return ROK;
} /* end of */
/** @brief This function frees up the RgMacPdu structure that has been
RgInfSfDatInd *sfInfo;
#endif
{
- TRC2(rgTOMInfFreePduEvnt);
RG_FREE_MEM(sfInfo);
RETVOID;
U8 lcId;
U8 lcgId;
U8 loop;
- TRC2(rgTomUtlPrepareL2MUlThrpInfo);
dDatInd->burstInd = RGU_L2M_UL_BURST_END;
for(loop=0;loop<dDatInd->numLch;loop++)
}
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
ulLcCb = NULLP;
- TRC2(rgTOMUtlProcMsg)
#ifndef LTE_L2_MEAS
UNUSED(slot);
/* code for common channel dat indications */
if ((ret = rgAllocShrablSBuf (inst,(Data**)&cDatInd, sizeof(RgRguCmnDatInd))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
cDatInd->cellId = cellCb->cellId;
cDatInd->rnti = ueCb->ueId;
#endif
sdu->mBuf = NULLP;
rgUIMSndCmnDatInd(inst,cellCb->rguUlSap,cDatInd);
- RETVALUE(ROK);
+ return ROK;
} /* end of common channel processing */
#ifndef SS_RBUF
if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
glblueCb5 = ueCb;
elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
if (NULLP == elem)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
dDatInd = (RgRguDedDatInd *)elem;
- cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
+ memset(dDatInd, 0x00, sizeof(RgRguDedDatInd));
#endif
dDatInd->cellId = cellCb->cellId;
dDatInd->rnti = ueCb->ueId;
}
#ifdef RLC_STA_PROC_IN_MAC/* RLC Status PDU Processing */
{
- extern S16 kwProcDlStatusPdu(Pst *udxPst,SuId suId,
+ extern S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
CmLteCellId cellId,CmLteRnti rnti,CmLteLcId lcId,Buffer *rlcSdu);
- if(ROK == kwProcDlStatusPdu(&(cellCb->rguDlSap->sapCfg.sapPst),
+ if(ROK == rlcProcDlStatusPdu(&(cellCb->rguDlSap->sapCfg.sapPst),
cellCb->rguDlSap->sapCfg.suId,
cellCb->cellId,ueCb->ueId,sdu->lcId,sdu->mBuf))
{
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
- RETVALUE(ret);
+ return (ret);
}
#ifndef SS_RBUF
if ((ret = rgAllocShrablSBuf (inst,(Data**)&dDatInd, sizeof(RgRguDedDatInd))) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
elem = SRngGetWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
if (NULLP == elem)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
dDatInd = (RgRguDedDatInd *)elem;
- cmMemset((U8 *)dDatInd, 0x00, sizeof(RgRguDedDatInd));
+ memset(dDatInd, 0x00, sizeof(RgRguDedDatInd));
#endif
dDatInd->cellId = cellCb->cellId;
dDatInd->rnti = ueCb->ueId;
{
ueCb->ul.explRelCntr = 0;
/* Indicate scheduler for explicit release */
- cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
+ memset(&schPst1, 0, sizeof(Pst));
rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
//TODO: commented for compilation without SCH
#if 0
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"Failed to send datIndication to RGU CRNTI:%d",ueCb->ueId);
- RETVALUE(ret);
+ return (ret);
}
}
#ifndef SS_RBUF
rgFreeSharableSBuf(inst,(Data **)&dDatInd,sizeof(RgRguDedDatInd));
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* end of */
/** @brief This function frees up the RgMacPdu structure that has been
U32 lcgId = 0;
U32 idx = 0;
- TRC2(rgTOMUtlInsSchInfo);
RG_TOM_INF_ALLOC(sfInfo, sizeof(RgInfUeDatInd), ueInfo, ret);
if(ROK != ret)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueInfo->rnti = rnti;
}
}
cmLListAdd2Tail(&sfInfo->ueLst, &ueInfo->ueLstEnt);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgTOMUtlInsSchInfo */
#include <stdlib.h>
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgTOMDatInd
+S16 rgTOMDatInd
(
Inst inst,
TfuDatIndInfo *datInd
)
#else
-PUBLIC S16 rgTOMDatInd(inst,datInd)
+S16 rgTOMDatInd(inst,datInd)
Inst inst;
TfuDatIndInfo *datInd;
#endif
U32 lcgBytes[RGINF_MAX_LCG_PER_UE];
- TRC2(rgTOMDatInd);
#ifdef STUB_TTI_HANDLING_5GTF
node = datInd->datIndLst.first;
for (;node; node=node->next)
return(RFAILED);
#endif
- cmMemset((U8 *)&lcgBytes, 0, sizeof(lcgBytes));
+ memset(&lcgBytes, 0, sizeof(lcgBytes));
tfuSap = &(rgCb[inst].tfuSap);
ueCb = NULLP;
{
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to get the cellCb for cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Avoiding memset as all the fields are getting initialized further */
err.errType = RGERR_TOM_DATIND;
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
node = datInd->datIndLst.first;
- RETVALUE(RFAILED);
+ return RFAILED;
}
cmLListInit(&sfInfo->ueLst);
sfInfo->cellId = datInd->cellId;
err.errType = RGERR_TOM_DATIND;
RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"Unable to Allocate PDU for DUX cell");
rgTOMInfFreePduEvnt (sfInfo);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ret = rgDUXDemuxData (inst,pdu, &ceInfo,
if (ueCb->ul.implRelCntr == ueCb->ul.implRelCnt)
{
/* Indicate scheduler for implicit release */
- cmMemset((U8*)&schPst1, (U8)0, sizeof(Pst));
+ memset(&schPst1, 0, sizeof(Pst));
rgGetPstToInst(&schPst1,inst, cellCb->schInstMap.schInst);
ueCb->ul.implRelCntr = 0;
{
rgTOMInfFreePduEvnt (sfInfo);
rgTOMUtlFreePduEvnt (pdu, FALSE);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* free up the PDU memory */
rgTOMUtlFreePduEvnt (pdu, FALSE);
#endif
/* RRM_RBC_X */
/* Update PRB used for all GBR QCIs to scheduler */
- cmMemcpy((U8*) &sfInfo->qcisUlPrbCnt[0],
- (U8*) &cellCb->qcisUlPrbCnt[0],
+ memcpy( &sfInfo->qcisUlPrbCnt[0],
+ &cellCb->qcisUlPrbCnt[0],
(RGM_MAX_QCI_REPORTS * sizeof(U32)));
/* clear the cellCb ul prb value */
- cmMemset((U8*)&cellCb->qcisUlPrbCnt[0], 0,
+ memset(&cellCb->qcisUlPrbCnt[0], 0,
(RGM_MAX_QCI_REPORTS * sizeof(U32)));
/* RRM_RBC_Y */
rgGetPstToInst(&schPst, inst,cellCb->schInstMap.schInst);
sfInfo->cellSapId = cellCb->schInstMap.cellSapId;
//TODO: commented for compilation without SCH RgMacSchSfRecp(&schPst, sfInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgTOMDatInd */
/**
RgDlSf *dlSf;
Inst inst = cell->macInst - RG_INST_START;
- TRC2(rgHndlCmnChnl)
dlSf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
#if (ERRCLASS & ERRCLS_DEBUG)
if(NULLP == (bch = rgDBMGetBcchOnBch(cell)))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cmnLcInfo->bchInfo.lcId != bch->lcId)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
staInd->cellId = cell->cellId;
staInd->rnti = RG_INVALID_RNTI;
#endif
if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
/*Store the received BCH Data in the scheduled subframe*/
#if (ERRCLASS & ERRCLS_DEBUG)
if(NULLP == (pcch = rgDBMGetPcch(cell)))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(cmnLcInfo->pcchInfo.lcId != pcch->lcId)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
if (rgAllocShrablSBuf (inst,(Data**)&staInd, sizeof(RguCStaIndInfo)) != ROK)
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
staInd->cellId = cell->cellId;
staInd->rnti = RG_INVALID_RNTI;
*/
if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(NULLP ==
(bcch=rgDBMGetBcchOnDlsch(cell,cmnLcInfo->bcchInfo.lcId)))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(TRUE == cmnLcInfo->bcchInfo.sndStatInd)
{
sizeof(RguCStaIndInfo)) != ROK)
{
err->errCause = RGERR_TOM_MEM_EXHAUST;
- RETVALUE(RFAILED);
+ return RFAILED;
}
staInd->cellId = cell->cellId;
staInd->rnti = RG_INVALID_RNTI;
#endif
if (rgUIMSndCmnStaInd (inst,cell->rguDlSap,staInd) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
#endif/*RGR_SI_SCH*/
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgHndlCmnChnl */
/**
#endif
{
- TRC2(rgHndlSchdUe);
if(NULLP == ueInfo->allocInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgHndlSchdUe */
#ifdef LTE_L2_MEAS
RgUlSf *ulSf;
S16 ret;
- TRC2(rgHndlUlUeInfo)
ulSf = &cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)];
if((ret = rgAllocSBuf(inst,(Data**)&(cell->ulSf[(timingInfo.slot % RGSCH_NUM_SUB_FRAMES)].
ueUlAllocInfo), ueInfo->numUes * sizeof(RgUeUlAlloc))) != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
#ifdef XEON_SPECIFIC_CHANGES
}
}
RGCPYTIMEINFO(timingInfo, ulSf->schdTime);
- RETVALUE(ROK);
+ return ROK;
} /* end of rgHndlUlUeInfo */
#endif
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC Void rgTOMRlsSf
+Void rgTOMRlsSf
(
Inst inst,
RgDlSf *dlSf
)
#else
-PUBLIC Void rgTOMRlsSf(dlSf)
+Void rgTOMRlsSf(dlSf)
Inst inst;
RgDlSf *dlSf;
#endif
{
U8 idx;
- TRC2(rgTOMRlsSf)
if(dlSf->txDone == FALSE)
{
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgHndlFlowCntrl
+S16 rgHndlFlowCntrl
(
RgCellCb *cell,
RgInfSfAlloc *sfInfo
)
#else
-PUBLIC S16 rgHndlFlowCntrl(cell, sfInfo)
+S16 rgHndlFlowCntrl(cell, sfInfo)
RgCellCb *cell;
RgInfSfAlloc *sfInfo;
#endif
Pst *pst;
U32 ueIdx;
U32 lcIdx;
- TRC3(rgHndlFlowCntrl);
pst = &cell->rguDlSap->sapCfg.sapPst;
/* flowCntrlInd is alloced in cell init time and will be re-used throughout */
}
}
RgUiRguFlowCntrlInd(pst, cell->rguDlSap->sapCfg.spId,flowCntrlInd); /* TODO: Rishi confirm if the suId and pst pointer is correct */
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Function is called by the scheduler once it has completed the
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacSfAllocReq
+S16 RgSchMacSfAllocReq
(
Pst *pst,
RgInfSfAlloc *sfInfo
)
#else
-PUBLIC S16 RgSchMacSfAllocReq(pst, sfInfo)
+S16 RgSchMacSfAllocReq(pst, sfInfo)
Pst *pst;
RgInfSfAlloc *sfInfo;
#endif
VOLATILE U32 startTime=0;
Inst inst;
- TRC2(RgSchMacSfAllocReq)
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
if(NULLP == sfInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cell = rgCb[inst].cell) == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,sfInfo->cellId, "No cellCb found with cell");
- RETVALUE(RFAILED);
+ return RFAILED;
}
dlSf = &cell->subFrms[(sfInfo->timingInfo.slot % RG_NUM_SUB_FRAMES)];
if(rgHndlUlUeInfo(cell, sfInfo->ulUeInfo.timingInfo,
&sfInfo->ulUeInfo) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
#endif
#ifdef XEON_SPECIFIC_CHANGES
}
/*stoping Task*/
SStopTask(startTime, PID_MAC_SF_ALLOC_REQ);
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacSfAllocReq */
/**
* @brief Handler for processing data indication recieved from PHY for UEs.
U16 sduSize;
#endif
- TRC2(rgTOMProcCrntiCEInDatInd)
#ifndef LTE_L2_MEAS
UNUSED(slot);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
prevUeCb = rgDBMGetUeCb (cellCb, ceInfo->ces.cRnti);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Received MSG3 with CRNTI,unable to find ueCb", ceInfo->ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
"CRNTI CE(%d) received through tmpCrnti(%d)",
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Processing for MSG3 failed",datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for processing data indication recieved from PHY for UEs.
#endif
- TRC2(rgTOMProcCCCHSduInDatInd)
#ifndef LTE_L2_MEAS
UNUSED(slot);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"CRNTI:%d Received MSG3 with CCCH",ceInfo->ces.cRnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueCb = rgDBMGetUeCbFromRachLst (cellCb, datInfo->rnti);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,
"RNTI:%d Processing for MSG3 failed", datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fix: syed Drop any duplicate Msg3(CCCH Sdu) */
if (ueCb->dl.hqEnt.numHqProcs)
/* HqE is already initialized by a previuos Msg3 */
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed. Duplicate "
"MSG3 received. Dropping", datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(rgDHMHqEntInit(inst,&ueCb->dl.hqEnt,
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Harq Initialization failed ",
datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
"CCCH SDU received through tmpCrnti(%d)",datInfo->rnti);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"RNTI:%d Processing for MSG3 failed",
datInfo->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_L2_MEAS
{
U8 lcgId;
U8 bsr;
- TRC2(rgTOMUtlL2MStoreBufSz);
if(ceInfo->bitMask & RG_TRUNC_BSR_CE_PRSNT)
{
ueCb->ul.lcgArr[2].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs3];
ueCb->ul.lcgArr[3].lcgBsInfo.outStndngBs = rgLwrBsrTbl[ceInfo->ces.bsr.longBsr.bs4];
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgTOMUtlL2MStoreBufSz*/
/** @brief : Compiles list of LCs received in UL data for DTCH RBs
RgMacSdu *sdu;
RgUlLcCb *ulLcCb;
- TRC2(rgTOML2MCompileActiveLCs)
node = pdu->sduLst.first;
while (node)
Code Review / o-du / l2.git / blobdiff