U8 resOfCrs; /* Effective REs occupied by CRS */
U8 i, j;
- TRC2(rgSCHCmnCompEff);
switch (cpType)
{
U8 noSymPerRb;
U8 i, j;
- TRC2(rgSCHCmnCompUlEff);
switch (cpType)
{
U8 resOfCrs; /* Effective REs occupied by CRS */
U8 i, j;
- TRC2(rgSCHCmn2LyrCompEff);
switch (cpType)
{
#endif
{
- TRC2(rgSCHCmnGetDciFrmtSizes);
/* DCI Format 0 size determination */
rgSchCmnDciFrmtSizes[0] = 1 +
U8 i;
U8 j;
- TRC2(rgSCHCmnGetCqiDciFrmt2AggrLvl);
for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
{
RgSchCmnTbSzEff *effTbl;
RgSchCmnCqiToTbs *tbsTbl;
- TRC2(rgSCHCmnDlInit);
/* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
/* Init Efficiency table for normal cyclic prefix */
CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
S16 i;
S16 j;
- TRC2(rgSCHCmnUlInit);
/* Initaializing new variable added for UL eff */
rgSchCmnUlEffTbl[RG_SCH_CMN_NOR_CP] = &rgSchCmnNorUlEff[0];
#endif
{
U8 idx;
- TRC2(rgSCHCmnInit);
rgSCHCmnDlInit();
rgSCHCmnUlInit();
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *sf;
- TRC2(rgSCHCmnDlRlsSubFrm);
/* Get the pointer to the subframe */
sf = rgSCHUtlSubFrmGet(cell, frm);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCcchRarAlloc);
rgSCHCmnDlCcchRetx(cell, &cellSch->allocInfo);
/* LTE_ADV_FLAG_REMOVED_START */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnCcchSduAlloc);
/* Return if subframe BW exhausted */
if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduTx);
node = cell->ccchSduUeLst.first;
while(node)
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchTx);
node = cell->raInfo.toBeSchdLst.first;
while(node)
RgSchCmnDlUe *ueDl;
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
- TRC2(rgSCHCmnDlCcchSduRetx);
node = cellSch->dl.ccchSduRetxLst.first;
while(node)
U8 retxBw = 0;
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
- TRC2(rgSCHCmnDlCcchRetx);
node = cellSch->dl.msg4RetxLst.first;
while(node)
#endif/*RGR_SI_SCH*/
- TRC2(rgSCHCmnDlBcchPcch);
frm = cell->crntTime;
#ifdef LTEMAC_HDFDD
{
Bool inWin = FALSE;
- TRC2(rgSCHCmnChkInWin);
if (end.sfn > start.sfn)
{
CmLteTimingInfo refFrm = end;
Bool pastWin;
- TRC2(rgSCHCmnChkPastWin);
RGSCH_INCR_FRAME(refFrm.sfn);
RGSCH_INCR_SUB_FRAME(end, 1);
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnClcAlloc);
bo = (RgSchClcBoRpt *)(lch->boLst.first->node);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 numCce; /*store num CCEs based on
aggregation level */
- TRC2(rgSCHCmnCmnPdcchAlloc);
aggrLvl = cellSch->dl.cmnChAggrLvl;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi = cellSch->dl.currCfi;
U32 tmpRb=0;
- TRC2(rgSCHCmnClcRbAlloc);
/* first get the CQI to MCS table and determine the number of RBs */
effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnMsg4Alloc);
/* SR_RACH_STATS : MSG4 TO BE TXED */
rgNumMsg4ToBeTx++;
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
- TRC2(rgSCHCmnPdcchAlloc);
/* 3.1 consider the selected DCI format size in determining the
* aggregation level */
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnCcchSduDedAlloc);
rbAllocinfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb, cell);
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnMsg4DedAlloc);
effBo = raCb->dlCcchInfo.bo + RGSCH_MSG4_HDRSIZE + RGSCH_CONT_RESID_SIZE;
U8 sfnIdx;
U8 subfrmIdx;
U16 rntiIdx=0;
- TRC2(rgSCHCmnDlRaRsp);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
U8 raIdx;
RgSchCmnCell *sched;
U8 i,noRaRnti=0;
- TRC2(rgSCHCmnDlRaRsp);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
U8 cfi = cellDl->currCfi;
#endif
- TRC2(rgSCHCmnRaRspAlloc);
#ifndef RGR_V1
UNUSED(cellUl);
#endif
U8 cfi = cellDl->currCfi;
- TRC2(rgSCHCmnUlAllocFillRbInfo);
alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) +
cell->dynCfiCb.bwInfo[cfi].startRb;
U8 iMcs;
U8 numSb;
- TRC2(rgSCHCmnMsg3GrntReq);
*ulAllocRef = NULLP;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi = cellSch->dl.currCfi;
- TRC2(rgSCHCmnDlSetUeAllocLmt);
#ifdef EMTC_ENABLE
if(TRUE == isEmtcUe)
U8 cqiBasediTbs;
U8 actualiTbs;
- TRC2(rgSCHCheckAndSetTxScheme);
maxiTbs = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
[RG_SCH_CMN_MAX_CQI - 1];
U8 maxiTbs;
U8 cwIdx = 0;
- TRC2(rgSCHCmnDlSetUeAllocLmtLa);
maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
if(ueDl->cqiFlag == TRUE)
#endif
{
- TRC2(rgSCHCmnDlHqPResetTemp);
/* Fix: syed having a hqP added to Lists for RB assignment rather than
* a UE, as adding UE was limiting handling some scenarios */
Void *tmpCb;
#endif
- TRC2(rgSCHCmnDlUeResetTemp);
/* Fix : syed check for UE's existence was useless.
* Instead we need to check that reset is done only for the
#ifdef LTE_ADV
tmpCb = allocInfo->laaCb;
#endif
- cmMemset((U8 *)allocInfo, (U8)0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo, 0, sizeof(RgSchDlRbAlloc));
allocInfo->rnti = ue->ueId;
#ifdef LTE_ADV
allocInfo->laaCb = tmpCb;
{
RgSchCmnUlUe *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlUeResetTemp);
- cmMemset((U8 *)&cmnUlUe->alloc, (U8)0, sizeof(cmnUlUe->alloc));
+ memset(&cmnUlUe->alloc, 0, sizeof(cmnUlUe->alloc));
RETVOID;
} /* rgSCHCmnUlUeResetTemp */
#endif
{
- TRC2(rgSCHCmnFillPdcch);
/* common channel pdcch filling,
* only 1A and Local is supported */
U8 dlSfCnt = 0;
U8 splfrmIdx = 0;
- TRC2(rgSCHCmnIsSplSubfrm);
if(splfrmCnt > 0)
{
{
RgSchUeCb *ue = hqP->hqE->ue;
- TRC2(rgSCHCmnUpdHqAndDai);
if(subFrm != NULLP)
{
U8 ackNackFdbkArrSize;
- TRC2(rgSCHCmnUpdDai);
if(hqP != NULLP)
{/* Non SPS */
RgSchDlHqTbCb *tbInfo = tbAllocInfo->tbCb;
RgSchDlHqProcCb *hqP = tbInfo->hqP;
- TRC2(rgSCHCmnFillHqPTb);
/*ccpu00120365-ADD-if tb is disabled, set mcs=0,rv=1.
* Relevant for DCI format 2 & 2A as per 36.213-7.1.7.2
#endif
{
- TRC2(rgSCHCmnFillHqPPdcchDciFrmtB1B2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
//Currently hardcoding values here.
RgSchPdcch *pdcch = rbAllocInfo->pdcch;
U8 tpc = 1;
- TRC2(rgSCHCmnFillHqPPdcch);
if (hqP->hqE->ue)
{
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1Info.tpcCmd = tpc;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1aInfo.isPdcchOrder = FALSE;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt1B)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
pdcch->dci.u.format1bInfo.tpcCmd = tpc;
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
#endif
- TRC2(rgSCHCmnFillHqPPdcchDciFrmt2A)
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
/*ccpu00120365:-ADD-call also if tb is disabled */
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnInitVars);
cellUl->idx = RGSCH_INVALID_INFO;
cellUl->schdIdx = RGSCH_INVALID_INFO;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
U16 idx;
- TRC2(rgSCHCmnUpdVars);
idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
cellUl->idx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
U16 sfn;
U8 subframe;
- TRC2(rgSCHCmnGetPhichUlSfIdx);
dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
U8 idx = 0;
U16 numUlSf;
- TRC2(rgSCHCmnGetUlSfIdx);
/* ccpu00130980: numUlSf(U16) parameter added to avoid integer
* wrap case such that idx will be proper*/
U8 numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
/* TRACE 5 Changes */
- TRC2(rgSCHCmnGetUlHqProcIdx);
/* Calculate the number of UL SF in one SFN */
numUlSfInSfn = RGSCH_NUM_SUB_FRAMES -
#endif
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
{
RgSchUlHqProcCb *hqProc;
- TRC2(rgSCHCmnUlFreeAllocation);
if (alloc->forMsg3)
{
RgSchDlSf *sf;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnPdcchAllocCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillNdmrs);
alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
RETVOID;
}
Bool isRetx;
#endif
{
- TRC2(rgSCHCmnUlAllocLnkHqProc);
if(TRUE == isRetx)
{
CmLteTimingInfo frm = cell->crntTime;
RgSchDlSf *sf;
- TRC2(rgSCHCmnPdcchRlsCrntSf);
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
#endif
{
- TRC2(rgSCHCmnUlFillPdcchWithAlloc);
pdcch->ue = ue;
pdcch->rnti = alloc->rnti;
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHCmnUlAllocFillTpc);
alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
RETVOID;
}
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnAddUeToRefreshQ);
UNUSED(cell);
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
RgSchCmnLcg *lcgCmn;
CmLList *node;
RgSchCmnAllocRecord *allRcd;
- TRC2(rgSCHCmnUlUeReset);
ue->ul.minReqBytes = 0;
ue->ul.totalBsr = 0;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnResetRiCqi);
rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd,
cell->isCpUlExtend);
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlUeReset);
if (ueDl->rachInfo.poLnk.node != NULLP)
{
Pst pst;
RgInfResetHqEnt hqEntRstInfo;
- TRC2(rgSCHCmnUeReset);
/* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
rgSCHCmnDelRachInfo(cell, ue);
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtUlUe);
/* : take care of this in UL retransmission */
cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
#endif
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnActvtDlUe);
cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
RETVOID;
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHCmnHdlUlTransInd);
/* Update the latest UL dat/sig transmission time */
RGSCHCPYTIMEINFO(timingInfo, ue->ul.ulTransTime);
#endif
{
U32 bitMap0, bitMap1;
- TRC2(rgSCHCmnComp4TxMode4);
bitMap0 = pmiBitMap[0];
bitMap1 = pmiBitMap[1];
if((bitMap1) & 0xFFFF)
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode4);
bitMap0 = pmiBitMap[0];
if((bitMap0>>26)& 0x0F)
{
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp4TxMode3);
bitMap0 = pmiBitMap[0];
if((bitMap0>>28)& 1)
{
#endif
{
U32 bitMap0;
- TRC2(rgSCHCmnComp2TxMode3);
bitMap0 = pmiBitMap[0];
if((bitMap0>>30)& 1)
{
U8 numTxPorts;
#endif
{
- TRC2(rgSCHCmnComputeRank);
if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
{
U8 cnt;
S16 ret;
- TRC2(rgSCHCmnDlDeInitHqEnt);
ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
/* Free only If the Harq proc are created*/
U8 cnt;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlInitHqEnt);
for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
{
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnGetRefreshDist);
for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
{
U32 refreshPer;
U32 crntSubFrm;
- TRC2(rgSCHCmnGetRefreshPer);
refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
crntSubFrm = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot;
Inst inst = ue->cell->instIdx;
#endif
U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
- TRC2(rgSCHCmnRgrSCellUeCfg);
pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
pCellUeDl = &pCellUeSchCmn->dl;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
Inst inst = ue->cell->instIdx;
- TRC2(rgSCHCmnRgrSCellUeDel);
cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
RgrUeCfg *cfg;
#endif
{
- TRC2(rgSCHCmnRgrUeCfg);
RgSchUeGrp *ue5gtfGrp;
ue->ue5gtfCb.grpId = cfg->ue5gtfCfg.grpId;
U32 waitPer;
U32 idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
- TRC2(rgSCHCmnRgrUeCfg);
/* 1. Allocate Common sched control block */
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlHdlTxModeRecfg);
if (ueRecfg->txMode.pres != PRSNT_NODEF)
{
RgSchCmnCell *cellSchd;
#endif
{
- TRC2(rgSCHCmnUpdUeMimoInfo)
#ifdef TFU_UPGRADE
if(ueCfg->txMode.pres)
{
#endif
{
- TRC2(rgSCHCmnUpdUeUlCqiInfo)
#ifdef TFU_UPGRADE
if(ue->srsCb.srsCfg.type == RGR_SCH_SRS_SETUP)
RgSchCmnUe *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUpdUeCatCfg)
ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
U32 waitPer;
- TRC2(rgSCHCmnRgrUeRecfg);
/* Basic validations */
if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
{
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUlUeDelAllocs);
for (i = 0; i < ueUl->hqEnt.numHqPrcs; ++i)
{
CmTmrArg arg;
RgSchCmnUeInfo *ueSchd = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDelUeFrmRefreshQ);
#ifdef RGL_SPECIFIC_CHANGES
if(ue->refreshOffset < RGSCH_MAX_REFRESH_GRPSZ)
#endif
- cmMemset((U8 *)&arg, 0, sizeof(arg));
+ memset(&arg, 0, sizeof(arg));
arg.tqCp = &sched->tmrTqCp;
arg.tq = sched->tmrTq;
arg.timers = &ueSchd->tmr;
RgSchDlHqProcCb *ccchSduHqP = NULLP;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUeCcchSduDel);
hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
if (hqE == NULLP)
U8 cnt;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
U32 idx = 0;
- TRC2(rgSCHCmnUeDel);
if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
{
U8 i, rbNum;
U32 pdcchBits;
- TRC2(rgSCHCmnDlCnsdrCmnRt);
/* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
* bits per 1024/2 REs */
U8 splSfCfi;
U8 mPhich;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
U8 cfi;
U8 cfiIdx;
- TRC2(rgSCHCmnDlRgrCellCfg);
cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
{
U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
- TRC2(rgSCHCmnUlCalcReqRbCeil);
return ((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
}
U8 iTbs = 0;
U16 msg3GrntSz = 0;
- TRC2(rgSCHCmnPrecompMsg3Vars);
if (ccchCqi > cellUl->max16qamCqi)
{
/* Maximum value of M as per Table 10.1-1 */
U8 M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
- TRC2(rgSCHCmnUlCalcAvailBw);
if (cell->isCpUlExtend)
{
#endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUlCellInit);
cellUl->maxUeNewTxPerTti = cellCfg->maxUlUeNewTxPerTti;
if (maxUePerUlSf == 0)
{
S16 ret;
RgSchCmnCell *cellSch;
- TRC2(rgSCHCmnRgrCellCfg);
/* As part of RGR cell configuration, validate the CRGCellCfg
* There is no trigger for crgCellCfg from SC1 */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnRgrCellRecfg);
if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
{
CmLList *lnk = NULLP;
RgSchL2MeasCb *measCb;
#endif
- TRC2(rgSCHCmnUlCellDeinit);
#ifdef LTE_L2_MEAS
#ifdef LTE_TDD
for(ulSfIdx = 0; ulSfIdx < RGSCH_SF_ALLOC_SIZE; ulSfIdx++)
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnCellDel);
#ifdef LTE_L2_MEAS
glblTtiCnt = 0;
{
U8 qci = dlQos->qci;
- TRC2(rgSCHCmnValidateDlQos);
if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchCfg);
ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchRecfg)
if(dlLc->lcType != CM_LTE_LCH_DCCH)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[lcgCfg->ulInfo.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgCfg);
ulLcg->cfgdGbr = (lcgCfg->ulInfo.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *ulLcg = ((RgSchCmnLcg *)(ue->ul.lcgArr[reCfg->ulRecfg.lcgId].sch));
- TRC2(rgSCHCmnRgrLcgRecfg);
ulLcg->cfgdGbr = (reCfg->ulRecfg.gbr * RG_SCH_CMN_REFRESH_TIME)/100;
ulLcg->effGbr = ulLcg->cfgdGbr;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnRgrLchDel);
#ifdef EMTC_ENABLE
if(TRUE == ue->isEmtcUe)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
- TRC2(rgSCHCmnLcgDel);
if (lcgCmn == NULLP)
{
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnFreeDlLc);
if (svc->sch == NULLP)
{
RETVOID;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchUeCb *ue;
- TRC2(rgSCHCmnDlCcchSduRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduRetxLst.first;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchRaCb *raCb;
- TRC2(rgSCHCmnDlCcchRetxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4RetxLst.first;
hqP->tbInfo[0].ccchSchdInfo.retxLnk.node = (PTR)NULLP;
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
/* Fix: syed dlAllocCb reset should be performed.
hqP = (RgSchDlHqProcCb *)(node->node);
raCb = hqP->hqE->raCb;
node = node->next;
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
RETVOID;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchSduTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->ccchSduAlloc.schdCcchSduTxLst.first;
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchLchAllocInfo lchSchdData;
- TRC2(rgSCHCmnDlCcchTxFnlz);
/* Traverse through the Scheduled Retx List */
node = allocInfo->msg4Alloc.schdMsg4TxLst.first;
}
/* Fix: syed dlAllocCb reset should be performed.
* zombie info in dlAllocCb leading to crash rbNum wraparound */
- cmMemset((U8 *)&raCb->rbAllocInfo, (U8)0, sizeof(raCb->rbAllocInfo));
+ memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
node = allocInfo->msg4Alloc.nonSchdMsg4TxLst.first;
/*Fix: Removing releasing of TB1 as it will not exist for MSG4 and hence caused a crash*/
/* rgSCHDhmRlsHqpTb(hqP, 1, FALSE);*/
/* reset the UE allocation Information */
- cmMemset((U8 *)rbAllocInfo, (U8)0, sizeof(*rbAllocInfo));
+ memset(rbAllocInfo, 0, sizeof(*rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
U8 idx = 0;
U16 timeDiff = 0;
- TRC2(rgSCHCmnGetBiIndex)
if (cell->biInfo.prevBiTime != 0)
{
U8 msg3Subfrm;
#endif
- TRC2(rgSCHCmnDlRaRspFnlz);
for (rarCnt=0; rarCnt<RG_SCH_CMN_MAX_CMN_PDCCH; rarCnt++)
{
{
U8 k, rv;
CmLteTimingInfo frm;
- TRC2(rgSCHCmnDlCalcRvForBcch);
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
#endif
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnDlBcchPcchFnlz);
/* handle PCCH */
rbAllocInfo = &allocInfo->pcchAlloc;
{
CmLList *node;
- TRC2(rgSCHCmnUlSetAllUnSched);
node = allocInfo->contResLst.first;
while (node)
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
- TRC2(rgSCHCmnUlAdd2CntResLst);
cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
ulAllocInfo->reqLnk.node = (PTR)ue;
RETVOID;
#endif
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
- TRC2(rgSCHCmnUlAdd2UeLst);
if (ulAllocInfo->reqLnk.node == NULLP)
{
cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
#endif
{
RgSchUlSf *sf = allocInfo->sf;
- TRC2(rgSCHCmnAllocUlRb);
/* Schedule for new transmissions */
rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
CmLteTimingInfo timeInfo;
#endif
#endif
- TRC2(rgSCHCmnUlRbAllocForLst);
if(schdLst->count == 0)
{
Bool mdfyiTbsFlg = FALSE;
U8 resiTbs = *iTbs;
- TRC2(rgSCHCmnUlMdfyGrntForCqi)
do
U8 numLyr;
#endif
- TRC2(rgSCHCmnUlRbAllocForUe);
#ifdef RG_5GTF
rgSCHUhmGetAvlHqProc(cell, ue, &proc);
if (proc == NULLP)
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- TRC2(rgSCHCmnUlRbAllocAddUeToLst);
UNUSED(cell);
gUl5gtfUeRbAllocDone++;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlAllocFnlz);
/* call scheduler specific Finalization */
cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlAllocFnlz);
rgSCHCmnDlCcchRetxFnlz(cell, allocInfo);
rgSCHCmnDlCcchTxFnlz(cell, allocInfo);
#endif
{
CmLList *lnk;
- TRC2(rgSCHCmnUlUpdSf);
while ((lnk = sf->allocs.first))
{
{
U32 bytes;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlHndlAllocRetx);
bytes = \
rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
[alloc->grnt.numRb-1]/8;
#endif
- TRC2(rgSCHCmnUlAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure */
rgSCHCmnInitUlRbAllocInfo(allocInfoRef);
Pst pst;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSndCnsldtInfo);
subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
CmLListCp ulInActvLst;
RgSchCmnCell *cellSch = NULLP;
- TRC2(rgSCHCmnCnsldtSfAlloc);
cmLListInit(&dlDrxInactvTmrLst);
cmLListInit(&dlInActvLst);
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitDlRbAllocInfo);
- cmMemset((U8 *)&allocInfo->pcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)&allocInfo->bcchAlloc, (U8)0, sizeof(RgSchDlRbAlloc));
- cmMemset((U8 *)allocInfo->raRspAlloc, (U8)0,
+ memset(&allocInfo->pcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(&allocInfo->bcchAlloc, 0, sizeof(RgSchDlRbAlloc));
+ memset(allocInfo->raRspAlloc, 0,
RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
allocInfo->msg4Alloc.msg4DlSf = NULLP;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHCmnInitUlRbAllocInfo);
allocInfo->sf = NULLP;
cmLListInit(&allocInfo->contResLst);
cmLListInit(&allocInfo->schdContResLst);
RgSchDlSf *dlSf;
#endif
{
- TRC2(rgSCHCmnGrpPwrCntrlPucch);
rgSCHPwrGrpCntrlPucch(cell, dlSf);
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
- TRC2(rgSCHCmnGrpPwrCntrlPusch);
/* Got to pass DL SF corresponding to UL SF, so get that first.
* There is no easy way of getting dlSf by having the RgSchUlSf*,
U32 effNonGbrBsr = 0;
U32 lcgId;
- TRC2(rgSCHCmnApplyUeRefresh);
/* Reset the refresh cycle variableCAP */
ue->ul.effAmbr = ue->ul.cfgdAmbr;
#if (ERRCLASS & ERRCLS_DEBUG)
#endif
- TRC2(rgSCHCmnTmrExpiry);
#if (ERRCLASS & ERRCLS_DEBUG)
if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
/* Moving the assignment of scheduler pointer
to available scope for optimization */
- TRC2(rgSCHCmnTmrProc);
if ((cell->crntTime.slot % RGSCH_NUM_SUB_FRAMES_5G) == 0)
{
U8 splSfCfi = 0;
#endif
- TRC2(rgSchCmnUpdCfiVal);
pdsch = cell->crntTime;
RGSCH_INCR_SUB_FRAME(pdsch, delta);
{
U8 idx;
- TRC2(rgSchCmnUpdtPdcchSfIdx);
/* Resetting the parameters on CFI switching */
cell->dynCfiCb.cceUsed = 0;
U8 dlIdx;
U16 ttiMod;
- TRC2(rgSchCmnUpdCfiDb);
/* Get Downlink Subframe */
frm = cell->crntTime;
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlCommonChSch);
cellSch->apisDl->rgSCHDlTickForPdbTrkng(cell);
rgSchCmnUpdCfiVal(cell, RG_SCH_CMN_DL_DELTA);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnUlSch);
#ifdef LTE_ADV
/* LAA_SCELL: */
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlDedBoUpd);
/* RACHO : if UEs idle time exceeded and a BO update
* is received, then add UE to the pdcch Order Q */
#endif
{
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnRmvFrmTaLst);
#ifdef EMTC_ENABLE
if(cell->emtcEnable && ue->isEmtcUe)
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlMsg4ProcRmvFrmRetx);
if (hqP->tbInfo[0].ccchSchdInfo.retxLnk.node)
{
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlProcAddToRetx);
if (hqP->hqE->msg4Proc == hqP) /* indicating msg4 transmission */
{
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnUeInfo *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
- TRC2(rgSCHCmnDlSetUeRi);
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlSetUePmi);
if (ue->txModeTransCmplt == FALSE)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode10);
if (pucchCqi->u.mode10Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode11);
if (pucchCqi->u.mode11Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode20);
if (pucchCqi->u.mode20Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlProcCqiMode21);
if (pucchCqi->u.mode21Info.type == TFU_RPT_CQI)
{
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlCqiOnPucchInd);
/* ccpu00117452 - MOD - Changed
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U32 prevRiVal = 0;
- TRC2(rgSCHCmnDlCqiOnPuschInd);
if (puschCqi->ri.pres == PRSNT_NODEF)
{
if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
Bool is2ndCwCqiAvail = FALSE;
#endif
- TRC2(rgSCHCmnDlCqiInd);
#ifdef RGR_CQI_REPT
if (isPucchInfo)
#endif
{
U8 wideCqi=1; /*Calculated value from SNR*/
- TRC2(rgSCHCmnCalcWcqiFrmSnr);
/*Need to map a certain SNR with a WideCQI value.
* The CQI calculation is still primitive. Further, need to
* use a improvized method for calculating WideCQI from SNR*/
{
U8 wideCqi; /*Calculated value from SNR*/
U32 recReqTime; /*Received Time in TTI*/
- TRC2(rgSCHCmnSrsInd);
recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.slot;
ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
CmLListCp poInactvLst;
- TRC2(rgSCHCmnDlTARpt);
/* RACHO: If UE idle time is more than threshold, then
* set its poInactv pdcch order inactivity */
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
#endif
- TRC2(rgSCHCmnUlCqiInd);
/* consider inputs from SRS handlers about SRS occassions
* in determining the UL TX Antenna selection */
ueUl->crntUlCqi[0] = ulCqiInfo->wideCqi;
#ifndef RG_5GTF
U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
#endif
- TRC2(rgSCHCmnUlHqProcForUe);
#ifndef RG_5GTF
*procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
#else
RgSchUlHqProcCb *oldProc;
#endif
{
- TRC2(rgSCHCmnUpdUlHqProc);
UNUSED(cell);
UNUSED(oldProc);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
- TRC2(rgSCHCmnBsrTmrExpry)
ueCb->isSrGrant = TRUE;
#ifdef LTE_L2_MEAS
U8 idx;
#endif
- TRC2(rgSCHCmnUpdBsrShort);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
U8 idx;
#endif
- TRC2(rgSCHCmnUpdBsrTrunc);
if (!RGSCH_LCG_ISCFGD(ulLcg))
{
#endif
U32 lcgId;
- TRC2(rgSCHCmnUpdBsrLong);
#ifdef LTE_L2_MEAS
for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdExtPhr);
UNUSED(err);
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
- TRC2(rgSCHCmnUpdPhr);
UNUSED(err);
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnContResUlGrant);
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
CmLList *node = ueUl->ulAllocLst.last;
- TRC2(rgSCHCmnSrRcvd);
#ifdef EMTC_ENABLE
emtcStatsUlTomSrInd++;
/* ACC_TDD */
RgSchUlAlloc* alloc = NULLP;
- TRC2(rgSCHCmnFirstRcptnReq);
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
/* ACC-TDD */
//RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->rcpReqIdx];
- TRC2(rgSCHCmnNextRcptnReq);
/* ACC-TDD */
if (cellUl->rcpReqIdx != RGSCH_INVALID_INFO)
{
RgSchUeCb *ueCb;
- TRC2(rgSCHCmnDrxStrtInActvTmrInUl);
-
cmLListInit(&ulUeLst);
while(alloc)
/* ACC-TDD */
RgSchUlAlloc *alloc = NULLP;
- TRC2(rgSCHCmnFirstHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnNextHqFdbkAlloc);
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
U8 iMcs;
#endif
{
- TRC2(rgSCHCmnUlGetITbsFrmIMcs);
return (rgUlIMcsTbl[iMcs].iTbs);
}
#endif
{
U8 iMcs;
- TRC2(rgSCHCmnUlGetIMcsFrmITbs);
if (iTbs <= 10)
{
U8 iTbs;
#endif
{
- TRC2(rgSCHCmnUlMinTbBitsForITbs);
RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs);
{
U8 holeSz; /* valid hole size */
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlSbAlloc);
if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
{
RgSchCmnUeUlAlloc *ulAllocInfo;
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlUeFillAllocInfo);
ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
ulAllocInfo = &ueUl->alloc;
U32 nonLcg0Bsr=0;
U8 lcgId;
RgSchCmnLcg *cmnLcg = NULLP;
- TRC2(rgSCHCmnUpdUlCompEffBsr);
while (node)
{
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
RgSchCmnUeUlAlloc *ulAllocInfo = &ueUl->alloc;
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRecordUeAlloc);
cmLListDelFrm(lst, &allRcd->lnk);
#ifndef LTE_TDD
RgSchCmnAllocRecord *allRcd = (RgSchCmnAllocRecord *)(node->node);
/* Stack Crash problem for TRACE5 changes */
- TRC2(rgSCHCmnUlRecMsg3Alloc);
cmLListDelFrm(lst, node);
allRcd->allocTime = raCb->msg3AllocTime;
#endif
{
U32 nonLcg0Alloc=0;
- TRC2(rgSCHCmnUlUpdOutStndAlloc);
/* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
U8 maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi];
#endif
- TRC2(rgSCHCmnUlGetITbs);
/* #ifdef RG_SCH_CMN_EXT_CP_SUP For ECP pick index 1 */
#ifdef TFU_UPGRADE
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbInfoAddUeTx);
if (hqP->reqLnk.node == NULLP)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetx);
if (cellSch->dl.isDlFreqSel)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
- TRC2(rgSCHCmnDlRbInfoAddUeRetxTx);
if (cellSch->dl.isDlFreqSel)
{
{
CmLList *schdLnkNode;
- TRC2(rgSCHCmnDlAdd2NonSchdRetxLst);
#ifdef LTEMAC_SPS
if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) &&
RgSchTddSubfrmInfo ulSubfrmInfo;
U8 maxUlSubfrms;
- TRC2(rgSCHCmnDlANFdbkInit);
ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
[RGSCH_NUM_SUB_FRAMES-1];
U8 dlPres = 0;
- TRC2(rgSCHCmnDlKdashUlAscInit);
/* Generate ACK/NACK offset information for each DL subframe in a radio frame
* Calculate this information based on K` in UL Association Set table */
{
U8 idx;
U16 np;
- TRC2(rgSCHCmnDlNpValInit);
/* Always Np is 0 for p=0 */
cell->rgSchTddNpValTbl[0] = 0;
S16 ret;
U8 lstSize;
- TRC2(rgSCHCmnDlCreateRachPrmLst);
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
S8 sfnOffset;
U8 numSubfrms;
- TRC2(rgSCHCmnDlRachInfoInit);
- cmMemset((U8 *)rachRspLst, 0, sizeof(rachRspLst));
+ memset(rachRspLst, 0, sizeof(rachRspLst));
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- TRC2(rgSCHCmnDlPhichOffsetInit);
/* Generate PHICH offset information for each DL subframe in a radio frame
* Calculate this information based on K in PHICH table */
U8 ulDlCfgIdx = cell->ulDlCfgIdx;
U8 msg3Subfrm;
U8 Mval;
- TRC2(rgSCHCmnUpdVars);
/* ccpu00132654-ADD- Initializing all the indices in every subframe*/
rgSCHCmnInitVars(cell);
#endif
{
U8 i;
- TRC2(rgSCHCmnGetPValFrmCCE);
for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
{
RgSchUlHqProcCb *proc;
#endif
{
- TRC2(rgSCHCmnUlAdapRetx);
rgSCHUhmRetx(proc, alloc);
#ifndef RG_5GTF
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp ulInactvLst;
- TRC2(rgSCHCmnHdlUlInactUes);
/* Get a List of Inactv UEs for UL*/
cmLListInit(&ulInactvLst);
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp dlInactvLst;
- TRC2(rgSCHCmnHdlDlInactUes);
/* Get a List of Inactv UEs for DL */
cmLListInit(&dlInactvLst);
/* Time difference in subframes */
U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
- TRC2(rgSCHCmnUeIdleExdThrsld);
if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
{
U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
U32 sfDiff;
U8 cnt;
- TRC2(rgSCHCmnCfgRachDedPrm);
if (cell->macPreambleSet.pres == NOTPRSNT)
{
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- TRC2(rgSCHCmnUpdNxtPrchMskIdx);
/* Determine the next prach mask Index */
if (cellSch->rachCfg.prachMskIndx == cell->rachCfg.raOccasion.size - 1)
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
U32 sfDiff;
- TRC2(rgSCHCmnUpdRachParam);
if (cell->macPreambleSet.pres == NOTPRSNT)
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnAllocPOParam);
if (cell->macPreambleSet.pres == PRSNT_NODEF)
{
U8 prachMskIdx;
RgSchPdcch *pdcch = NULLP;
- TRC2(rgSCHCmnGenPdcchOrder);
while (node)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlAdd2PdcchOdrQ);
if (ueDl->rachInfo.poLnk.node == NULLP)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnDlRmvFrmPdcchOdrQ);
cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = NULLP;
{
RgSchUeACqiCb *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell);
- TRC2(rgSCHCmnFillPdcchOdr2Sf);
pdcch->rnti = ue->ueId;
pdcch->dci.dciFormat = TFU_DCI_FORMAT_1A;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 rapIdIdx;
- TRC2(rgSCHCmnDelRachInfo);
if (ueDl->rachInfo.poLnk.node)
{
#endif
{
RgSchUeCb *ue = raReq->ue;
- TRC2(rgSCHCmnHdlHoPo);
if ( ue->isDrxEnabled )
{
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnGetHoUe);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- TRC2(rgSCHCmnDelDedPreamble);
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
U8 rapIdIdx;
- TRC2(rgSCHCmnGetPoUe);
rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
U8 cqi;
- TRC2(rgSCHCmnUlGetCqi);
cqi = ueUl->maxUlCqi;
#ifdef TFU_UPGRADE
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- TRC2(rgSCHCmnUlRbAllocForPoHoUe);
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
return RFAILED;
RgSchUlGrnt *grnt;
RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
- TRC2(rgSCHCmnAllocPoHoGrnt);
/* Clearing previous allocs if any*/
rgSCHCmnUlUeDelAllocs(cell, ue);
U8 idx;
#endif
{
- TRC2(rgSCHCmnUlNonadapRetx);
rgSCHUhmRetx(alloc->hqProc, alloc);
/* Update alloc to retx */
#endif
{
- TRC2(rgSCHCmnUlAllocsOvrLap);
if (((alloc1->sbStart >= alloc2->sbStart) &&
(alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
#endif
{
RgSchCmnUlUe *ueUl;
- TRC2(rgSCHCmnUlCpyAllocInfo);
dstAlloc->grnt = srcAlloc->grnt;
dstAlloc->hqProc = srcAlloc->hqProc;
/* MS_WORKAROUND ccpu00120827 */
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
U8 remAllocs;
- TRC2(rgSCHCmnUlInsAllocFrmNewSf2OldSf);
if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
{
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlMergeSfAllocs);
UNUSED(cell);
/* Merge each alloc of newSf in to oldSf
RgSchUlHoleDb *tempHoleDb = newSf->holeDb;
U8 tempAvailSbs = newSf->availSubbands;
- TRC2(rgSCHCmnUlSwapSfAllocs);
UNUSED(cell);
newSf->allocDb = oldSf->allocDb;
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlPrcNonAdptRetx);
/* perform non-adaptive retx allocation(adjustment) */
if ((alloc = rgSCHUtlUlAllocFirst(newSf)) != NULLP)
U8 idx;
#endif
{
- TRC2(rgSCHCmnUlPrfmSfMerge);
/* Preassigned resources for msg3 in newSf.
* Hence do adaptive retx for all NACKED TXs */
rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf);
#endif
{
RgSchUlAlloc *alloc, *nxtAlloc;
- TRC2(rgSCHCmnUlRmvCmpltdAllocs);
if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
{
U8 idx;
#endif
{
- TRC2(rgSCHCmnRlsUlSf);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlUpdAllocRetx);
alloc->hqProc->reTxAlloc.rnti = alloc->rnti;
alloc->hqProc->reTxAlloc.numSb = alloc->numSb;
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
RgSchUlAlloc *alloc;
- TRC2(rgSCHCmnUlAdapRetxAlloc);
/* Fetch PDCCH for msg3 */
/* ccpu00116293 - Correcting relation between UL subframe and DL subframe based on RG_UL_DELTA*/
RgSchUlHqProcCb *proc;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfRlsRetxProcs);
cp = &(cellUl->reTxLst);
node = cp->first;
RgSchUeCb *ue;
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnUlSfReTxAllocs);
cp = &(cellUl->reTxLst);
node = cp->first;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
{
rbgInfo->lastRbgSize = rbgSize -
(dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
#ifdef RGSCH_SPS_UNUSED
- cmMemcpy((U8 *)rbgInfo->rbgSubsetSize, (U8 *) subsetSize, 4 * sizeof(U8));
+ memcpy(rbgInfo->rbgSubsetSize, subsetSize, 4 * sizeof(U8));
#endif
rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
dlTotalBw:(rbgInfo->numRbgs * rbgSize);
{
bestAvailNumRbs = numAvailRbs;
bestStartPos = startPos;
- cmMemcpy((U8 *)bestMask, (U8 *) tmpMask, 4 * sizeof(U32));
+ memcpy(bestMask, tmpMask, 4 * sizeof(U32));
}
numAvailRbs = 0;
startPos = -1;
- cmMemset((U8 *)tmpMask, 0, 4 * sizeof(U32));
+ memset(tmpMask, 0, 4 * sizeof(U32));
}
}
if (*allocNumRbs == rbsReq)
if (*allocNumRbs == rbsReq)
{
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) tmpMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, tmpMask, 4 * sizeof(U32));
RETVOID;
}
else
*allocStart = (U8)bestStartPos;
*allocNumRbs = bestAvailNumRbs;
/* Convert the hole into allocation */
- cmMemcpy((U8 *)crntAllocMask, (U8 *) bestMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, bestMask, 4 * sizeof(U32));
}
}
{
U8 addtlRbsAvl = 0;
- TRC2(rgSCHCmnFindNumAddtlRbsAvl)
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
{
#endif
{
*numOvrlapgPbchRb = 0;
- TRC2(rgSCHCmnFindNumPbchOvrlapRbs)
/*Find if we have already crossed the start boundary for PBCH 6 RBs,
* if yes then lets find the number of RBs which are getting overlapped
* with this allocation.*/
U8 divResult;
- TRC2(rgSCHCmnNonDlfsPbchRbAllocAdj);
origRbsReq = allocInfo->rbsReq;
U8 spsRbsAlloc = 0;
RgSchDlSfAllocInfo *dlSfAlloc = &allocInfo->dlSf->dlSfAllocInfo;
#endif
- TRC2(rgSCHCmnNonDlfsCmnRbAlloc);
allocInfo->tbInfo[0].noLyr = 1;
/* Note: Initialize the masks to 0, this might not be needed since alloInfo
* is initialized to 0 at the beginning of allcoation */
allocInfo->resAllocInfo.raType0Mask = 0;
- cmMemset((U8*)allocInfo->resAllocInfo.raType1Mask, 0,
+ memset(allocInfo->resAllocInfo.raType1Mask, 0,
RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (U32));
- cmMemset((U8*)allocInfo->resAllocInfo.raType2Mask, 0,
+ memset(allocInfo->resAllocInfo.raType2Mask, 0,
RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (U32));
if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
#endif
{
RgSchDlSf *dlSf = allocInfo->dlSf;
- TRC2(rgSCHCmnNonDlfsCmnRbAllocRar);
if(dlSf->bwAlloced == dlSf->bw)
U8 noLyrs;
U8 ignoredDfctRbg = FALSE;
- TRC2(rgSCHCmnNonDlfsBwAvlbl);
if (dlSf->bw <= dlSf->bwAlloced)
{
RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
CmLListCp *l;
CmLList *n;
RgSchSFRPoolInfo *sfrPool;
- TRC2(rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc);
l = &dlSf->sfrTotalPoolInfo.ccPool;
RgSchSFRPoolInfo *sfrCCPool2 = NULL;
S16 ret = RFAILED;
- TRC2(rgSCHCmnNonDlfsUpdDSFRTyp2Alloc);
/* Move the type2End pivot forward */
U8 numRb;
#endif
{
- TRC2(rgSCHCmnNonDlfsUpdTyp2Alloc);
/* Move the type2End pivot forward */
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
//#ifndef LTEMAC_SPS
U32 tb2BytesAlloc = 0;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnNonDlfsType0Alloc);
//if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
/* Fix for ccpu00123919*/
U16 rbBitLoc; /* Bit Location to be set as 1 in the current Byte */
U16 nmbRbPerByte; /* PRB's to be set in the current Byte (in case of multiple Bytes) */
- TRC2(rgSCHCmnBuildRntpInfo);
rbPtrStartIdx = (startRb)/8;
rbPtrEndIdx = (startRb + nmbRb)/8;
S16 ret;
#endif
- TRC2(rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc);
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
sfrPool->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
U8 noLyr;
U8 iTbs;
- TRC2(rgSCHCmnNonDlfsSFRPoolType0Alloc);
if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
{
U16 len;
U16 ret = ROK;
- TRC2(rgSCHCmnNonDlfsDsfrRntpComp);
len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
"rgSCHUtlRgrLoadInfInd() returned RFAILED");
}
- cmMemset(cell->rntpAggrInfo.val,0,len);
+ memset(cell->rntpAggrInfo.val,0,len);
samples = 0;
}
}
Bool isUECellEdge;
RgSchSFRPoolInfo *sfrpoolInfo = NULLP;
- TRC2(rgSCHCmnSFRNonDlfsUeRbAlloc);
isUECellEdge = RG_SCH_CMN_IS_UE_CELL_EDGE(ue);
#ifdef LAA_DBG
U32 dbgRbsReq = 0;
#endif
- TRC2(rgSCHCmnNonDlfsUeRbAlloc);
#ifdef RG_5GTF
RgSch5gtfUeCb *ue5gtfCb = &(ue->ue5gtfCb);
RgSchDlSf *dlSf = allocInfo->ccchSduDlSf;
RgSchUeCb *ueCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsCcchSduAlloc);
if (isRetx)
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
- TRC2(rgSCHCmnNonDlfsCcchSduRbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ueCb,cell);
#endif
{
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnNonDlfsMsg4RbAlloc);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_RACB(raCb);
RgSchDlSf *dlSf = allocInfo->msg4DlSf;
RgSchRaCb *raCb = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- TRC2(rgSCHCmnNonDlfsMsg4Alloc);
if (isRetx)
{
RgSchUeCb *ue = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
U8 isDlBwAvail;
- TRC2(rgSCHCmnNonDlfsDedRbAlloc);
/* Perform allocaations for the list */
{
U8 raRspCnt = 0;
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsRbAlloc);
/* Allocate for MSG4 retransmissions */
if (allocInfo->msg4Alloc.msg4RetxLst.count)
U8 numRbMinus1 = numRb - 1;
U32 riv;
- TRC2(rgSCHCmnCalcRiv);
if (numRbMinus1 <= bw/2)
{
U8 sfcount;
S16 ret;
- TRC2(rgSCHCmnDlCpyRachInfo);
/* Allocate RACH response information for each DL
* subframe in a radio frame */
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
S32 iTbs = 0;
- TRC2(rgSchCmnFetchItbs);
#ifdef LTE_TDD
/* Special Handling for Spl Sf when CFI is 3 as
RgSchDlRbAlloc *allocInfo;
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocTxRb1Tb1Cw);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchDlRbAlloc *allocInfo;
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocRetxRb1Tb1Cw);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM1);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM1);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM2);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM2);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM3);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM3);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHCmnSlctPdcchFrmt);
/* ccpu00140894- Selective DCI Format and RA type should be selected only
* after TX Mode transition is completed*/
U8 noTxLyrs;
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
#endif
U8 noTxLyrs;
- TRC2(rgSCHCmnDlTM4RetxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlSMGetAttrForTxRetx);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
Bool bothCwEnbld;
#endif
{
- TRC2(rgSCHCmnDlTM3PrecInf2);
return (0);
}
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf2);
if (ueDl->mimoInfo.ri == numTxLyrs)
{
{
U8 precIdx;
- TRC2(rgSCHCmnDlTM3PrecInf4);
if (bothCwEnbld)
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoBaseIdx, precIdx;
- TRC2(rgSCHCmnDlTM4PrecInf4);
precInfoBaseIdx = (ue->mimoInfo.puschFdbkVld)? (16):
(ueDl->mimoInfo.pmi);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM3);
/* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with
HQP */
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlGetAttrForTM4);
*frthrScp = FALSE;
/* Integration_fix: SPS Proc shall always have only one Cw */
U8 prcdngInf;
U8 numTxLyrs;
- TRC2(rgSCHCmnDlTM3TxRetx);
frthrScp = FALSE;
ret = ROK;
U8 prcdngInf;
U8 numTxLyrs;
- TRC2(rgSCHCmnDlTM4TxRetx);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
S16 ret;
U8 precInfoAntIdx;
- TRC2(rgSCHCmnDlTM3TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 precInfoAntIdx;
S16 ret;
- TRC2(rgSCHCmnDlTM4TxTx);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM4);
/* Both TBs free for TX allocation */
rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM4);
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
(proc->tbInfo[1].state == HQ_TB_NACKED))
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM5);
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocTxRbTM6);
ret = ROK;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
S16 ret;
U8 numRb;
- TRC2(rgSCHCmnDlAllocRetxRbTM6);
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocTxRbTM7);
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- TRC2(rgSCHCmnDlAllocRetxRbTM7);
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
RETVOID;
}
U32 prevSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocTxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
{
RgSchTddSfType txSfType = 0;
- TRC2(rgSCHCmnRetxAvoidTdd);
/* Get the RBs of TB that will be retransmitted */
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
U8 reqRbs;
- TRC2(rgSCHCmnRetxAllocAvoid);
if (proc->tbInfo[0].state == HQ_TB_NACKED)
{
U32 newSchBits = 0;
RgSchDlRbAlloc *allocInfo;
- TRC2(rgSCHCmnDlAllocRetxRb);
if ( !RGSCH_TIMEINFO_SAME((cell->crntTime),(ue->dl.lstSchTime) ))
{
/* Correcting wrap around issue.
* This change has been done at mutliple places in this function.*/
U32 tempNumRb;
- TRC2(rgSCHCmnDlAlloc1CwTxRb);
reqBytes = bo;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
U8 iTbs;
U16 numRb;
- TRC2(rgSCHCmnRdcImcsTxTb);
iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
noLyr = allocInfo->tbInfo[tbInfoIdx].noLyr;
U32 boTmp = bo;
#endif
- TRC2(rgSCHCmnDlAlloc2CwTxRb);
reqBytes = bo;
cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
U8 cfi = cellDl->currCfi;
U8 iTbs;
- TRC2(rgSCHCmnDlAlloc2CwTxRetxRb);
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
U8 imcs2;
RgSchDlHqTbCb *lrgTbInfo, *othrTbInfo;
- TRC2(rgSCHCmnDlAlloc2CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
RgSchDlRbAlloc *allocInfo;
U8 imcs;
- TRC2(rgSCHCmnDlAlloc1CwRetxRb);
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
#endif
{
- TRC2(rgSCHCmnDlRelPdcchFbk);
rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
RETVOID;
#endif
{
- TRC2(rgSCHCmnDlProcAck);
if (RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP))
{
#endif
{
- TRC2(rgSCHCmnHdlCrntiCE);
#ifdef RGSCH_SPS_STATS
rgSchStatCrntiCeRcvCnt++;
#endif
#endif
{
- TRC2(rgSCHCmnUlSpsRelInd);
rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
RETVOID;
#endif
{
- TRC2(rgSCHCmnUlSpsActInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
#endif
{
- TRC2(rgSCHCmnUlCrcInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
#endif
{
- TRC2(rgSCHCmnUlCrcFailInd);
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
{
rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
- TRC2(rgSCHCmnDlBcchPcchAlloc);
/*Reset the bitmask for BCCH/PCCH*/
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSCHBcchPcchDlRbAlloc);
if (cellSch->dl.isDlFreqSel)
{
RgSchDlRbAlloc *reqAllocInfo;
- TRC2(rgSCHCmnNonDlfsBcchPcchRbAlloc);
/* 143473 */
/* Allocate for PCCH */
{
CmLteTimingInfo pdSchTmInfo;
- TRC2(rgSCHChkNUpdSiCfg);
pdSchTmInfo = cell->crntTime;
U16 x;
U16 windowId;
- TRC2(rgSCHSelectSi);
crntTmInfo = cell->crntTime;
#endif
/* DwPTS Scheduling Changes End */
- TRC2(rgSCHDlSiSched);
crntTimInfo = cell->crntTime;
S16 retVal;
RgrStaIndInfo *staInfo = NULLP;
- TRC2(rgSCHCmnUeDlPwrCtColltCqiRept)
/* Step 1: Store the CQI in collation array */
/* Step 2: Increament the tracking count */
Bool *reTxAllwd;
#endif
{
- TRC3(rgSCHCmnChkRetxAllowDtx)
*reTxAllwd = TRUE;
U32 numRE = *rb * cellDl->noResPerRb[cfi];
U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, cellDl->maxDlBwPerUe);
U32 numRE = *rb * cellDl->noResPerRb[cfi];
U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
- TRC2(rgSCHCmnCalcDwPtsTbSz2Cw);
/* DwPts Rb cannot exceed the cell Bw */
numDwPtsRb = RGSCH_MIN(numDwPtsRb, maxRb);
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHCmnUpdUeDataIndLcg);
for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
{
RgSchDlSf *dlSf;
U8 idx;
- TRC2(rgSCHCmnInitRbAlloc);
/* Initializing RgSchCmnUlRbAllocInfo structure.*/
rgSCHCmnInitDlRbAllocInfo(&cellSch->allocInfo);
RgmTransModeInd *txModeChgInd;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- TRC2(rgSCHCmnSendTxModeInd);
if(!(ueDl->mimoInfo.forceTD & RG_SCH_CMN_TD_TXMODE_RECFG))
{
RgrTxMode txMode; /*!< UE's Transmission Mode */
RgrTxMode modTxMode; /*!< UE's Transmission Mode */
- TRC2(rgSchCheckAndTriggerModeChange);
txMode = ue->mimoInfo.txMode;
RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHCmnIsDlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
{
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHCmnIsUlCsgPrio)
/* Calculating the percentage resource allocated */
if(RGR_CELL_ACCS_HYBRID != rgSchCb[cell->instIdx].rgrSchedEnbCfg.accsMode)
RgSchDlSf *sf;
U8 idx;
- TRC2(rgSchCmnPreDlSch);
if(nCell > CM_LTE_MAX_CELLS)
{
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- TRC2(rgSchCmnPstDlSch);
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
{
U8 ri;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
- TRC3(rgSCHCmnCalcPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
U16 dlCntrlSfIdx;
#endif
- TRC2(rgSCHCmnDlSch);
dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
#ifdef RG_5GTF
Code Review / o-du / l2.git / blobdiff