U8 pointToChar,pointToEnd, loop;
U8 size = endPos - startPos;
F64 result = 0;
- TRC2(rgSCHUtlParse);
pointToEnd = (startPos)%8;
for ( loop=0; loop<size; loop++)
{
S16 ret;
U16 offsetStepMask;
- TRC2(rgSCHUtlPdcchAvail);
-
/* V5G_213 : 10.1 */
offset = 0;
byte = &pdcchInfo->map[0];
U8 offset;
uint16_t mask;
- TRC2(rgSCHUtlPdcchPut);
-
switch(pdcch->aggrLvl)
{
case CM_LTE_AGGR_LVL2:
U8 extraBits;
U32 cceMapSz;
- TRC2(rgSCHUtlPdcchInit);
-
pdcchInfo = &subFrm->pdcchInfo;
while(pdcchInfo->pdcchs.first != NULLP)
{
}
}
- cmMemset(subFrm->pdcchInfo.map, 0, cceMapSz);
+ memset(subFrm->pdcchInfo.map, 0, cceMapSz);
/* If nCce is not exactly same as the bitMap size(no of bits allocated
* to represent the Cce's, then mark the extra bits as unavailable
extra bits = (((pdcchInfo->nCce + 7) >> 3)*8) - pdcchInfo->nCce
{
CmLListCp *l;
CmLList *n;
- TRC2(rgSchSFRTotalPoolFree);
/*Deinitialise if these cc pools and ce pools are already existent*/
l = &sfrTotalPoolInfo->ccPool;
CmLList *temp = NULLP;
S16 ret = 0;
- TRC2(rgSchSFRTotalPoolInit);
-
rgSchSFRTotalPoolFree(&sf->sfrTotalPoolInfo, cell);
sf->sfrTotalPoolInfo.CCPool1BwAvlbl = 0;
sf->sfrTotalPoolInfo.CCPool2BwAvlbl = 0;
Inst inst = cell->instIdx;
U16 len;
- TRC2(rgSchDSFRRntpInfoInit);
-
rntpPtr->pres = PRSNT_NODEF;
len = (bw % 8 == 0) ? (bw/8) : (bw/8 + 1);
Inst inst = cell->instIdx;
U16 len;
- TRC2(rgSchDSFRRntpInfoFree);
-
len = (bw % 8 == 0) ? (bw/8) : (bw/8 + 1);
if(rntpPtr->pres == PRSNT_NODEF)
#endif
{
- TRC2(rgSchSFRResetPoolVariables);
pool->bwAlloced = 0;
/*type0end will be the last RBG in pool with all available RBs*/
CmLList *node = NULLP;
RgSchSFRPoolInfo *tempPool = NULLP;
- TRC2(rgSCHSFRUtlTotalPoolReset);
-
totalPoolInfo->ccBwFull = FALSE;
totalPoolInfo->ceBwFull = FALSE;
totalPoolInfo->isUeCellEdge = FALSE;
RgSchPhich *phich;
RgSchDlSf *dlSf;
Inst inst = cell->instIdx;
- TRC2(rgSCHUtlAddPhich);
dlSf = rgSCHUtlSubFrmGet(cell, frm);
RGSCH_PHICH_ALLOC(inst, phich,sizeof(RgSchPhich), ret);
UNUSED(cell);
- TRC2(rgSCHUtlPhichReset);
-
phichInfo = &subFrm->phichInfo;
while(phichInfo->phichs.first != NULLP)
{
RgSchDlSf *sf;
U8 dlIdx;
- TRC2(rgSCHUtlSubFrmGet);
-
#ifdef LTE_TDD
dlIdx = rgSCHUtlGetDlSfIdx(cell, &frm);
//RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, cell->subFrms, dlIdx);
U8 i;
U8 noRaRsps;
- TRC2(rgSCHUtlSubFrmPut);
-
#ifdef LTE_TDD
/* Release all the held PDCCH information */
rgSCHUtlPdcchInit(cell, sf, sf->nCce);
}
sf->spsAllocdBw = 0;
sf->type2Start = sf->bwAlloced;
- cmMemset((U8*) &sf->dlSfAllocInfo, 0, sizeof(RgSchDlSfAllocInfo));
+ memset( &sf->dlSfAllocInfo, 0, sizeof(RgSchDlSfAllocInfo));
#else
sf->bwAlloced = 0;
/* Fix for ccpu00123918*/
/* dsfr_pal_fixes ** 21-March-2013 ** SKS */
if (cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
{
- cmMemset((U8*) sf->rntpInfo.val, 0, sf->rntpInfo.len);
+ memset(sf->rntpInfo.val, 0, sf->rntpInfo.len);
}
/* LTE_ADV_FLAG_REMOVED_END */
#endif
S16 i;
U8 ret = 0;
- TRC2(rgSCHUtlLog32bitNbase2)
-
for (i=4; i >= 0; i--)
{
if (n & b[i])
U8 isAck;
#endif
{
- TRC2(rgSCHUtlDlRelPdcchFbk);
cell->sc.apis->rgSCHDlRelPdcchFbk(cell, ue, isAck);
RETVOID;
}
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHUtlDlProcAck);
cell->sc.apis->rgSCHDlProcAck(cell, hqP);
RETVOID;
}
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlHdlCrntiCE);
cell->sc.apis->rgSCHHdlCrntiCE(cell, ue);
RETVOID;
#endif
{
U16 regs = 0;
- TRC2(rgSCHUtlCalcTotalRegs);
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
U8 ng6;
#endif
{
- TRC2(rgSCHUtlCalcPhichRegs);
/* ccpu00115330: Corrected the calculation for number of PHICH groups*/
return (RGSCH_CEIL((bw * ng6) ,(8 * 6)) * RGSCH_NUM_REG_PER_PHICH_GRP);
}
U16 phichRegs;
U16 cceRegs;
U8 ng6;
- TRC2(rgSCHUtlCalcNCce);
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
U16 phichRegs;
U16 cceRegs;
U8 ng6;
- TRC2(rgSCHUtlCalcNCce);
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
/* ACC-TDD */
S16 ret = RFAILED;
- TRC2(rgSCHUtlGetPhichInfo);
-
if ((hqProc != NULLP) && (hqProc->alloc != NULLP))
{
*rbStartRef = hqProc->alloc->grnt.rbStart;
* min(4,modulation order in grant). Please refer to 36.213-8.6.1*/
CmLteUeCategory ueCtgy;
- TRC2(rgSCHUtlAllocRcptInfo);
#if (ERRCLASS & ERRCLS_DEBUG)
if ((alloc == NULLP) || (alloc->hqProc == NULLP))
{
TfuUeUlSchRecpInfo *recpReq;
#endif
{
- TRC2(rgSCHUtlAllocRcptInfo);
#if (ERRCLASS & ERRCLS_DEBUG)
if ((alloc == NULLP) || (alloc->hqProc == NULLP))
{
U8 startIdx;
U8 endIdx;
- TRC2(rgSCHUtlUpdPrachOcc)
-
/* In the 1st half frame */
if(cellCfg->halfFrm == 0)
{
U8 subfrmIdx;
U8 splFrm;
- TRC2(rgSCHUtlPrachCfgInit)
if(cellCfg->prachRscInfo.numRsc <= 0)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid"
S16 ret = ROK;
U16 bw; /*!< Number of RBs in the cell */
- TRC2(rgSCHUtlRgrCellCfg);
-
- cmMemset((U8 *)&frm,0,sizeof(CmLteTimingInfo));
+ memset(&frm,0,sizeof(CmLteTimingInfo));
/* ccpu00132657-MOD- Determining DLSF array size independent of DELTAS */
maxDlslots = rgSchTddNumDlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
{
break;
}
- cmMemset((U8 *)sf, 0, sizeof(*sf));
+ memset(sf, 0, sizeof(*sf));
#ifdef LTE_ADV
if (ROK != rgSCHLaaInitDlSfCb(cell, sf))
U16 len;
len = (U16)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /*KW fix for LTE_ADV */
/* LTE_ADV_FLAG_REMOVED_END */
- TRC2(rgSCHUtlRgrCellCfg);
- cmMemset((U8 *)&frm,0,sizeof(CmLteTimingInfo));
+ memset(&frm,0,sizeof(CmLteTimingInfo));
/* determine the RBG size and no of RBGs for the configured
* DL BW */
{
break;
}
- cmMemset((U8 *)sf, 0, sizeof(*sf));
+ memset(sf, 0, sizeof(*sf));
#ifdef LTE_ADV
if (ROK != rgSCHLaaInitDlSfCb(cell, sf))
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrCellRecfg);
return (cell->sc.apis->rgSCHRgrCellRecfg(cell, recfg, err));
}
RgSchRaReqInfo *raReqInfo;
U8 idx;
#endif
- TRC2(rgSCHUtlFreeCell);
#ifdef LTE_TDD
maxslots = cell->numDlSubfrms;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrUeCfg);
/* Assign TM 1 as UE's default TM */
ue->mimoInfo.txMode = RGR_UE_TM_1;
#endif
ue->csgMmbrSta = cfg->csgMmbrSta;
#ifdef RG_PFS_STATS
- cmMemset((U8 *)&ue->pfsStats, 0, sizeof(RgSchPfsStats));
+ memset(&ue->pfsStats, 0, sizeof(RgSchPfsStats));
#endif
/* Call the handler of the scheduler based on cell configuration */
return (cell->sc.apis->rgSCHRgrUeCfg(cell, ue, cfg, err));
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHUtlRgrLcCfg);
return (cell->sc.apis->rgSCHRgrLchCfg(cell, ue, dlLc, cfg, errInfo));
}
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrLcRecfg);
return (cell->sc.apis->rgSCHRgrLchRecfg(cell, ue, dlLc, recfg, err));
}
U8 lcgId;
#endif
{
- TRC2(rgSCHUtlRgrLcDel);
cell->sc.apis->rgSCHRgrLchDel(cell, ue, lcId, lcgId);
return (ROK);
RgSchErrInfo *errInfo;
#endif
{
- TRC2(rgSCHUtlRgrLcgCfg);
return (cell->sc.apis->rgSCHRgrLcgCfg(cell, ue, &(ue->ul.lcgArr[cfg->ulInfo.lcgId]), cfg, errInfo));
}
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlRgrLcgRecfg);
return (cell->sc.apis->rgSCHRgrLcgRecfg(cell, ue, &(ue->ul.lcgArr[recfg->ulRecfg.lcgId]), recfg, err));
} /* rgSCHUtlRgrLcRecfg */
U8 lcgId;
#endif
{
- TRC2(rgSCHUtlRgrLcgDel);
cell->sc.apis->rgSCHFreeLcg(cell, ue, &ue->ul.lcgArr[lcgId]);
/* Stack Crash problem for TRACE5 changes. added the return below . */
TfuDoaRpt *doaRpt;
#endif
{
- TRC2(rgSCHUtlDoaInd);
ue->mimoInfo.doa.pres = PRSNT_NODEF;
ue->mimoInfo.doa.val = doaRpt->doa;
RETVOID;
#endif
{
RgSchCellCb *sCellCb = NULLP;
- TRC2(rgSCHUtlDlCqiInd);
if (dlCqiRpt->isPucchInfo)
{
sCellCb = ue->cellInfo[dlCqiRpt->dlCqiInfo.pucchCqi.cellIdx]->cell;
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlSrsInd);
cell->sc.apis->rgSCHSrsInd(cell, ue, srsRpt, timingInfo);
RETVOID;
}
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlDlTARpt);
cell->sc.apis->rgSCHDlTARpt(cell, ue);
RETVOID;
}
CmLteTimingInfo subFrm;
#endif
{
- TRC2(rgSCHUtlDlRlsSubFrm);
cell->sc.apis->rgSCHDlRlsSubFrm(cell, subFrm);
RETVOID;
}
U8 sIdx = 0;
#endif
- TRC2(rgSCHUtlUpdACqiTrigWt);
-
if (isAck == TFU_HQFDB_ACK)
{
cellInfo->acqiCb.aCqiTrigWt += RG_APER_CQI_ACK_WGT;
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlHdlUlTransInd);
cell->sc.apis->rgSCHHdlUlTransInd(cell, ue, timingInfo);
RETVOID;
}
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlHdlCrcFail);
cell->sc.apis->rgSCHUlCrcInd(cell, ue, timingInfo);
RETVOID;
} /* end of rgSCHUtlHdlCrcFailInd */
CmLteTimingInfo timingInfo;
#endif
{
- TRC2(rgSCHUtlHdlCrcFail);
cell->sc.apis->rgSCHUlCrcFailInd(cell, ue, timingInfo);
RETVOID;
} /* end of rgSCHUtlHdlCrcFailInd */
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHUtlDlProcAddToRetx);
cell->sc.apis->rgSCHDlProcAddToRetx(cell, hqP);
RETVOID;
}
RgSchCellCb *cellCb = NULLP;
U8 strtCellId;
- TRC2(rgSchUtlGetCellCb);
-
strtCellId = rgSchCb[inst].genCfg.startCellId;
cellCb = rgSchCb[inst].cells[cellId - strtCellId];
U8 servCellIdx;
U16 strtCellId;
- TRC2(rgSchUtlGetCellCb);
-
strtCellId = rgSchCb[inst].genCfg.startCellId;
servCellIdx = ue->cellIdToCellIdxMap[cellId - strtCellId];
{
U8 strtCellId;
- TRC2(rgSchUtlVldtCellId);
-
strtCellId = rgSchCb[inst].genCfg.startCellId;
if((cellId >= strtCellId) && ((cellId - strtCellId) < CM_LTE_MAX_CELLS))
{
/* Changes for UE Category Reconfiguration feature addition */
RgSchCmnUe *ueSch = RG_SCH_CMN_GET_UE(ue, cell);
- TRC2(rgSCHUtlRgrUeRecfg);
-
/* Changes for UE Category Reconfiguration feature addition */
if (ueRecfg->ueRecfgTypes & RGR_UE_UECAT_RECFG)
{
RgSchDlLcCb *svc;
#endif
{
- TRC2(rgSCHUtlFreeDlLc);
cell->sc.apis->rgSCHFreeDlLc(cell, ue, svc);
/* Stack Crash problem for TRACE5 changes. added the return below . */
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlFreeUe);
#ifdef LTE_TDD
rgSCHUtlDelUeANFdbkInfo(ue,RGSCH_PCELL_INDEX);
#endif
RgSchDlLcCb *lc;
#endif
{
- TRC2(rgSCHUtlDlDedBoUpd);
cell->sc.apis->rgSCHDlDedBoUpd(cell, ue, lc);
RETVOID;
}
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHUtlRecMsg3Alloc)
cell->sc.apis->rgSCHUlRecMsg3Alloc(cell, ue, raCb);
RETVOID;
RgSchUlHqProcCb *oldProc;
#endif
{
- TRC2(rgSCHUtlUpdUlHqProc);
return (cell->sc.apis->rgSCHUpdUlHqProc(cell, curProc, oldProc));
} /* rgSCHUtlUpdUlHqProc */
#endif
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlContResUlGrant);
-
ue->isMsg4PdcchWithCrnti = TRUE;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlSrRcvd);
return (cell->sc.apis->rgSCHSrRcvd(cell, ue, frm, err));
} /* rgSCHUtlSrRcvd */
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdBsrShort);
cell->sc.apis->rgSCHUpdBsrShort(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
RETVOID;
} /* rgSCHUtlUpdBsrShort */
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdBsrTrunc);
cell->sc.apis->rgSCHUpdBsrTrunc(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
RETVOID;
} /* rgSCHUtlUpdBsrTrunc */
#endif
{
U8 bsArr[4];
- TRC2(rgSCHUtlUpdBsrLong);
bsArr[0] = bsr0;
bsArr[1] = bsr1;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdExtPhr);
return (cell->sc.apis->rgSCHUpdExtPhr(cell, ue, extPhr, err));
} /* rgSCHUtlUpdExtPhr */
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHUtlUpdPhr);
return (cell->sc.apis->rgSCHUpdPhr(cell, ue, phr, err));
} /* rgSCHUtlUpdPhr */
TfuUlCqiRpt *ulCqiInfo;
#endif
{
- TRC2(rgSCHUtlUlCqiInd);
cell->sc.apis->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
RETVOID;
} /* rgSCHUtlUlCqiInd */
S8 delta;
#endif
{
- TRC2(rgSCHUtlPucchDeltaPwrInd);
cell->sc.apis->rgSCHPucchDeltaPwrInd(cell, ue, delta);
RETVOID;
} /* rgSCHUtlPucchDeltaPwrInd */
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlUeReset);
ue->remBoCnt = 0;
cell->sc.apis->rgSCHUeReset(cell, ue);
RETVOID;
RgSchUlHqProcCb **procRef;
#endif
{
- TRC2(rgSCHUtlUlHqProcForUe);
cell->sc.apis->rgSCHUlHqProcForUe(cell, frm, ue, procRef);
/* Stack Crash problems for TRACE5 changes. added the return below */
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHUtlFirstRcptnReq);
return (cell->sc.apis->rgSCHFirstRcptnReq(cell));
}
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlNextRcptnReq);
return (cell->sc.apis->rgSCHNextRcptnReq(cell, alloc));
}
U8 idx;
#endif
{
- TRC2(rgSCHUtlFirstHqFdbkAlloc);
return (cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
}
U8 idx;
#endif
{
- TRC2(rgSCHUtlNextHqFdbkAlloc);
return (cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
}
S16 ret;
RgSchLowSapCb *tfuSap;
Pst pst;
- TRC2(rgSCHUtlTfuBndReq);
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[instId].tfuSap[suId]);
- (Void)cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuSchBndReq (&pst, suId, spId)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,instId,"rgSCHUtlTfuBndReq() Call to RgLiTfuBndReq()"
S16 ret;
Pst pst;
- TRC2(rgSCHUtlTfuUBndReq);
-
/* Get the lower SAP control block from the layer control block. */
- cmMemcpy ((U8*)&pst, (U8*)&(sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuSchUbndReq (&pst, sapCfg.spId, reason)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst,"rgSCHUtlTfuUBndReq() Call to"
Bool restAlloc;
#endif
{
- TRC2(rgSCHUtlResetSfAlloc);
if(TRUE == restAlloc)
{
if(sfAlloc->ueInfo.numUes)
{
- cmMemset((U8 *)sfAlloc->ueInfo.allocInfo,0x00,
+ memset(sfAlloc->ueInfo.allocInfo,0x00,
(sizeof(RgInfUeAlloc)*sfAlloc->ueInfo.numUes));
}
sfAlloc->ueInfo.numUes = 0;
{
U8 idx = 0;
Inst inst = cell->instIdx;
- TRC2(rgSCHUtlGetRlsHqAlloc);
for(idx=0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
{
cell->rlsHqArr[idx].cellId = cell->cellId;
{
U8 idx = 0;
Inst inst = cell->instIdx;
- TRC2(rgSCHUtlPutRlsHqAlloc);
for(idx=0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
{
U8 indx;
Inst inst = cell->instIdx;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHUtlGetSfAlloc);
#ifdef LTE_TDD
for(idx=0; idx < RGSCH_SF_ALLOC_SIZE; idx++)
U8 indx;
Inst inst = cell->instIdx;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHUtlPutSfAlloc);
#ifdef LTE_TDD
for(idx=0; idx < RGSCH_SF_ALLOC_SIZE; idx++)
{
/* Moving alarm diagnostics to available scope */
- TRC2(rgSCHUtlAllocSBuf)
-
/* Initialize the param to NULLP */
*pData = NULLP;
/* zero out the allocated memory */
- cmMemset((U8 *)*pData, 0x00, size);
+ memset(*pData, 0x00, size);
return ROK;
S16 ret;
- TRC2(rgSCHUtlFreeSBuf)
-
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
RETVOID;
CmLList *node;
Buffer *pdu;
- TRC2(rgSCHUtlFreeWarningSiSeg)
-
while (siPduLst->first != NULLP)
{
node = siPduLst->first;
RgSchWarningSiInfo *warningSi;
RgSchWarningSiPdu *warningSiPdu;
- TRC2(rgSCHUtlFreeWarningSiPdu)
-
warningSi = (RgSchWarningSiInfo *) cell->siCb.\
siArray[cell->siCb.siCtx.siId-1].si;
/* ccpu00136659: CMAS ETWS design changes */
Buffer *pdu;
CmLList *node;
- TRC2(rgSCHUtlGetWarningSiPdu)
-
- warningSi = (RgSchWarningSiInfo *) cell->siCb.
- siArray[cell->siCb.siCtx.siId-1].si;
+ warningSi = (RgSchWarningSiInfo *) cell->siCb.
+ siArray[cell->siCb.siCtx.siId-1].si;
/* ccpu00136659: CMAS ETWS design changes */
CM_LLIST_FIRST_NODE(&warningSi->warningSiMsg.segLstCp, node);
if (node != NULLP)
RgSchWarningSiPdu *warningSiPdu;
CmLList *node;
- TRC2(rgSCHUtlGetMcsAndNPrb)
-
if(cell->siCb.siCtx.warningSiFlag == FALSE)
{
*mcs = cell->siCb.crntSiInfo.siInfo[cell->siCb.siCtx.siId-1].mcs;
U8 mcs = 0;
U8 nPrb = 0;
- TRC2(rgSCHUtlCalMcsAndNPrb)
-
/*Get the nPrb and mcs parametr values */
if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
{
#endif
{
- TRC2(rgSCHUtlFillDgnParams)
-
switch(dgnType)
{
case LRG_USTA_DGNVAL_MEM:
Inst macInst;
#endif
{
- TRC2(rgSCHUtlGetPstToLyr);
/* Only the needed params are filled */
pst->region = schCb->rgSchInit.region;
Bool sendInd;
#endif
{
- TRC2(rgSCHUtlFillRgInfCmnLcInfo);
if((sf->bch.tbSize)&&
!(sfAlloc->cmnLcInfo.bitMask & RGINF_BCH_INFO))
U8 noRaRsps;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- TRC2(rgSCHUtlFillRgInfRarInfo);
-
#ifdef LTE_TDD
noRaRsps = RGSCH_MAX_TDD_RA_RSP_ALLOC;
#else
TfuDciInfo *pdcchDci;
#endif
{
- TRC2(rgSCHUtlFillPdschDciInfo)
#ifdef EMTC_ENABLE
S16 ret = ROK;
CmLListCp *l;
CmLList *n;
- TRC2(rgSchDSFRPwrCheck);
-
l = &sf->sfrTotalPoolInfo.ccPool;
n = cmLListFirst(l);
while(n)
{
S16 ret;
- TRC2(rgSCHUtlUpdSch);
#ifdef LTEMAC_SPS
if (RGSCH_UL_SPS_ACT_PRSENT & pdu->ceInfo.bitMask)
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb, cell);
RgSchDlHqProcCb *hqP = (RgSchDlHqProcCb *)ueDl->proc;
- TRC2(rgSCHUtlAddUeToCcchSduLst);
/* Temp Guard: For back to back CCCH SDU BO
* twice. Hence an extra guard. If already added to scheduling
#endif
{
RgSchUeCb *ueCb;
- TRC2(rgSCHUtlUpdtBo)
-
if ((ueCb = rgSCHDbmGetUeCb(cell, staRsp->u.rnti)) == NULLP)
{
RgSchRaCb *raCb;
RgSchUeCb *ueCb;
- TRC2(rgSCHUtlHndlCcchBoUpdt);
-
if ((raCb = rgSCHDbmGetRaCb(cell, boRpt->u.rnti)) == NULLP)
{
#ifdef RGR_V1
S32 cn;
S32 rt;
- TRC2(rgSCHUtlGetAllwdCchTbSz);
-
for (lt = 0, rt = 43; lt <= rt;)
{
cn = (lt + rt)/2;
U8 nPrb=0;
U8 mcs=0;
- TRC2(rgSCHUtlHndlBcchPcchBoUpdt);
-
dlLc = rgSCHDbmGetBcchOnBch(cell);
if (dlLc == NULLP)
{
{
S16 ret = ROK;
- TRC2(rgSCHUtlRgrBndCfm)
-
-
ret = RgUiRgrBndCfm(&rgSchCb[instId].rgrSap[suId].sapCfg.sapPst, rgSchCb[instId].rgrSap[suId].sapCfg.suId, status);
if (ret != ROK)
{
{
S16 ret = ROK;
- TRC2(rgSCHUtlRgmBndCfm)
-
-
ret = RgUiRgmBndCfm(&rgSchCb[instId].rgmSap[suId].sapCfg.sapPst, rgSchCb[instId].rgmSap[suId].sapCfg.suId, status);
if (ret != ROK)
{
Pst cfmPst;
Inst inst = 0;
- TRC2(schSendCfgCfm)
- cmMemset((U8 *)(&cfmPst), 0, sizeof(Pst));
+ memset((&cfmPst), 0, sizeof(Pst));
cfmPst.srcEnt = (Ent)ENTDUAPP;
cfmPst.srcInst = (Inst) 0;
extern Void mtTmrHdlrPublic(void);
#endif
- TRC2(rgSCHUtlRgrTtiInd)
-
-
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
S16 ret;
RgSchRaCb *raCb;
- TRC2(rgSCHUtlProcMsg3)
-
-
/* must have an raCb for this case */
raCb = rgSCHDbmGetRaCb (cellCb, rnti);
if (raCb == NULLP)
Bool isExplRel;
#endif
{
- TRC2(rgSCHUtlSpsRelInd);
cellCb->sc.apis->rgSCHUlSpsRelInd(cellCb, ueCb, isExplRel);
return ROK;
} /* end of rgSCHUtlSpsRelInd */
U16 spsSduSize;
#endif
{
- TRC2(rgSCHUtlSpsActInd);
cellCb->sc.apis->rgSCHUlSpsActInd(cellCb, ueCb, spsSduSize);
return ROK;
} /* end of rgSCHUtlSpsActInd */
RgSchLowSapCb *tfuSap;
Pst pst;
- TRC2(rgSCHUtlTfuGrpPwrCntrlReq);
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[inst].tfuSap[sapId]);
"rgSCHUtlTfuGrpPwrCntrlReq() Lower SAP not bound (%d) ",tfuSap->sapSta.sapState);
return RFAILED;
}
- cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
+ memcpy (&pst, &(tfuSap->sapCfg.sapPst), sizeof(Pst));
if((ret = RgLiTfuGrpPwrCntrlReq (&pst, tfuSap->sapCfg.spId, grpPwrCntrlReq)) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,grpPwrCntrlReq->cellId,
S16 ret;
RgSchLowSapCb *tfuSap;
- TRC2(rgSCHUtlTfuCntrlReq)
-
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[inst].tfuSap[sapId]);
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlDlActvtUe);
cell->sc.apis->rgSCHActvtDlUe(cell, ue);
return ROK;
}
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHUtlUlActvtUe);
cell->sc.apis->rgSCHActvtUlUe(cell, ue);
return ROK;
}
S16 ret;
RgSchLowSapCb *tfuSap;
- TRC2(rgSCHUtlTfuRecpReq)
/* Get the lower SAP control block from the layer control block. */
tfuSap = &(rgSchCb[inst].tfuSap[sapId]);
{
RgSchLowSapCb *tfuSap;
- TRC2(rgSCHUtlValidateTfuSap)
-
if(suId >= rgSchCb[inst].numSaps)
{
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "Incorrect SuId");
Mem sMem;
VOLATILE U32 startTime=0;
- TRC2(rgSCHUtlAllocEventMem)
-
sMem.region = rgSchCb[inst].rgSchInit.region;
sMem.pool = rgSchCb[inst].rgSchInit.pool;
{
S16 ret;
- TRC2(rgSCHUtlGetEventMem)
#ifdef TFU_ALLOC_EVENT_NO_INIT
ret = cmGetMemNoInit(memCp, len, (Ptr *)ptr);
#else
{
U8 idx;
- TRC2(rgSCHUtlAllocUeANFdbkInfo);
-
if (rgSCHUtlAllocSBuf(ue->cell->instIdx,
(Data **) &(ue->cellInfo[servCellIdx]->anInfo), sizeof(RgSchTddANInfo) * \
ue->cell->ackNackFdbkArrSize) != ROK)
U8 servCellIdx;
#endif
{
- TRC2(rgSCHUtlDelUeANFdbkInfo);
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
RgSchTddANInfo *anFdInfo;
#endif
{
- TRC2(rgSCHUtlInitUeANFdbkInfo);
anFdInfo->sfn = RGSCH_MAX_SFN+1; /* defensively setting invalid sfn */
anFdInfo->slot = 0;
{
U8 idx;
- TRC2(rgSCHUtlGetUeANFdbkInfo);
-
for (idx = 0; idx < ueCb->cell->ackNackFdbkArrSize; ++idx)
{
if( (timeInfo->sfn == ueCb->cellInfo[servCellIdx]->anInfo[idx].sfn) &&
#endif
{
U16 idx = 0;
- TRC2(rgSCHUtlGetDlSfIdx);
idx = RGSCH_NUM_SUB_FRAMES - \
rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
{
U16 idx = curDlTime.slot;
U8 count = 0;
- TRC2(rgSCHUtlGetNxtDlSfInfo);
while(TRUE)
{
{
S16 idx = curDlTime.slot;
U8 count = 0;
- TRC2(rgSCHUtlGetPrevDlSfInfo);
do
{
#endif
{
S16 ret=ROK;
- TRC2(rgSCHUtlUlSfInit);
sf->idx = idx;
#ifdef RG_5GTF
RgSchUlSf *sf;
#endif
{
- TRC2(rgSCHUtlUlSfDeinit);
if (sf->allocDb)
{
rgSCHUtlUlAllocDbDeinit(cell, sf->allocDb);
#endif
{
S16 ret = rgSCHUtlUlAllocMemInit(cell, &allocDb->mem, maxAllocs);
- TRC2(rgSCHUtlUlAllocDbInit);
if (ret != ROK)
{
return (ret);
RgSchUlAllocDb *allocDb;
#endif
{
- TRC2(rgSCHUtlUlAllocDbDeinit);
rgSCHUtlUlAllocMemDeinit(cell, &allocDb->mem);
allocDb->count = 0;
allocDb->first = NULLP;
{
S16 ret;
RgSchUlHole *hole = NULLP;
- TRC2(rgSCHUtlUlHoleDbInit);
ret = rgSCHUtlUlHoleMemInit(cell, &holeDb->mem, maxHoles, &hole);
if (ret != ROK)
RgSchUlHoleDb *holeDb;
#endif
{
- TRC2(rgSCHUtlUlHoleDbDeinit);
rgSCHUtlUlHoleMemDeinit(cell, &holeDb->mem);
holeDb->count = 0;
holeDb->first = NULLP;
RgSchUlHole *hole;
#endif
{
- TRC2(rgSCHUtlUlAllocGetHole);
if (numSb < hole->num)
{
return (rgSCHUtlUlAllocGetPartHole(sf, numSb, hole));
* updated, causing another check for prv */
RgSchUlAlloc *prv = hole->prvAlloc;
RgSchUlAlloc *nxt = hole->nxtAlloc;
- TRC2(rgSCHUtlUlAllocGetCompHole);
if (prv)
{
/* Calling rgSchCmnUlAllocGetAndIns is ok, but prv alloc needs to have nxtHole
* updated, causing another check for prv */
RgSchUlAlloc *prv = hole->prvAlloc;
- TRC2(rgSCHUtlUlAllocGetPartHole);
if (prv)
{
RgSchUlSf *sf;
#endif
{
- TRC2(rgSCHUtlUlAllocFirst);
return (sf->allocDb->first);
}
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlAllocNxt);
UNUSED(sf);
return (alloc->nxt);
}
{
RgSchUlAlloc *alloc = rgSCHUtlUlAllocMemGet(&db->mem);
RgSchUlAlloc *nxt = prv->nxt;
- TRC2(rgSCHUtlUlAllocGetAdjNxt);
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
{
RgSchUlAlloc *alloc = rgSCHUtlUlAllocMemGet(&db->mem);
RgSchUlAlloc *nxt = db->first;
- TRC2(rgSCHUtlUlAllocGetFirst);
#if (ERRCLASS & ERRCLS_DEBUG)
if ( alloc == NULLP )
RgSchUlHoleDb *db = alloc->holeDbRef;
RgSchUlHole *prv = alloc->prvHole;
RgSchUlHole *nxt = alloc->nxtHole;
- TRC2(rgSCHUtlUlHoleAddAllocation);
if (prv)
{
RgSchUlAllocDb *allocDb = alloc->allocDbRef;
RgSchUlAlloc *prv = alloc->prv;
RgSchUlAlloc *nxt = alloc->nxt;
- TRC2(rgSCHUtlUlAllocRelease);
alloc->ue = NULLP;
alloc->raCb = NULLP;
RgSchUlAllocDb *allocDb = sf->allocDb;
RgSchUlAlloc *prv = alloc->prv;
RgSchUlAlloc *nxt = alloc->nxt;
- TRC2(rgSCHUtlUlAllocRls);
alloc->ue = NULLP;
alloc->raCb = NULLP;
RgSchUlSf *sf;
#endif
{
- TRC2(rgSCHUtlUlHoleFirst);
return (sf->holeDb->first);
}
RgSchUlHole *hole;
#endif
{
- TRC2(rgSCHUtlUlHoleNxt);
UNUSED(sf);
return (hole->nxt);
}
RgSchUlHoleDb *db = sf->holeDb;
RgSchUlHole *prv = alloc->prvHole;
RgSchUlHole *nxt = alloc->nxtHole;
- TRC2(rgSCHUtlUlHoleAddAlloc);
if (prv)
{
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlHoleJoin);
prv->num += alloc->numSb + nxt->num;
rgSCHUtlUlHoleRls(db, nxt);
rgSCHUtlUlHoleIncr(db, prv);
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlHoleExtndRight);
prv->num += alloc->numSb;
rgSCHUtlUlHoleIncr(db, prv);
rgSCHUtlUlHoleUpdAllocLnks(prv, alloc->prv, alloc->nxt);
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlHoleExtndLeft);
nxt->num += alloc->numSb;
nxt->start = alloc->sbStart;
rgSCHUtlUlHoleIncr(db, nxt);
RETVOID;
}
#endif
- TRC2(rgSCHUtlUlHoleNew);
hole->start = alloc->sbStart;
hole->num = alloc->numSb;
++db->count;
RgSchUlAlloc *nxtAlloc;
#endif
{
- TRC2(rgSCHUtlUlHoleUpdAllocLnks);
if (prvAlloc)
{
prvAlloc->nxtHole = hole;
#endif
{
RgSchUlHole *cur;
- TRC2(rgSCHUtlUlHoleIns);
if ((cur = db->first) != NULLP)
{
#endif
{
RgSchUlHole *cur;
- TRC2(rgSCHUtlUlHoleIncr);
if ((cur = hole->prv) != NULLP)
{
#endif
{
RgSchUlHole *cur;
- TRC2(rgSCHUtlUlHoleDecr);
if ((cur = hole->nxt) != NULLP)
{
{
RgSchUlHole *prv = hole->prv;
RgSchUlHole *nxt = hole->nxt;
- TRC2(rgSCHUtlUlHoleRls);
--db->count;
if (prv)
{
S16 ret;
RgSchUlAlloc *allocs;
- TRC2(rgSCHUtlUlAllocMemInit);
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&allocs,
maxAllocs * sizeof(*allocs));
RgSchUlAllocMem *mem;
#endif
{
- TRC2(rgSCHUtlUlAllocMemDeinit);
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(mem->allocs)),
{
S16 ret;
RgSchUlHole *holes;
- TRC2(rgSCHUtlUlHoleMemInit);
ret = rgSCHUtlAllocSBuf(cell->instIdx, (Data **)&holes,
maxHoles * sizeof(*holes));
RgSchUlHoleMem *mem;
#endif
{
- TRC2(rgSCHUtlUlHoleMemDeinit);
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(mem->holes)),
#endif
{
RgSchUlAlloc *alloc;
- TRC2(rgSCHUtlUlAllocMemGet);
#if (ERRCLASS & ERRCLS_DEBUG)
if (mem->firstFree == NULLP)
RgSchUlAlloc *alloc;
#endif
{
- TRC2(rgSCHUtlUlAllocMemRls);
alloc->prv = NULLP;
alloc->nxt = mem->firstFree;
#endif
{
RgSchUlHole *hole;
- TRC2(rgSCHUtlUlHoleMemGet);
#if (ERRCLASS & ERRCLS_DEBUG)
if (mem->firstFree == NULLP)
RgSchUlHole *hole;
#endif
{
- TRC2(rgSCHUtlUlHoleMemRls);
hole->prv = NULLP;
hole->nxt = mem->firstFree;
{
RgSchUlHole *hole, *nxtHole;
RgSchUlAlloc *alloc = NULLP;
- TRC2(rgSCHUtlUlGetSpfcAlloc);
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
U8 qciIdx;
U8 qciVal;
- TRC3(rgSCHUtlValidateQci)
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
{
U16 measType;
S16 ret;
- TRC3(rgSCHUtlValidateMeasReq)
measType = schL2MeasInfo->measType;
{
U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
- TRC2(rgSCHUtlRgrSiCfgCfm)
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
{
U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
- TRC2(rgSCHUtlRgrWarningSiCfgCfm)
- cmMemcpy((U8 *)prntTrans, (U8 *)transId.trans, RGR_CFG_TRANSID_SIZE);
+ memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
{
U8 idx = 0;
U32 sizeOfSiInfo = 0;
- TRC2(rgSCHUtlPutSiInfo)
/*Free the buffers in crntSiInfo*/
RGSCH_FREE_MSG(cell->siCb.crntSiInfo.mib)
RGSCH_FREE_MSG(cell->siCb.crntSiInfo.sib1Info.sib1)
idxStart = ue->schCqiInfo.cqiCount - numCqiRept;
- cmMemcpy ((U8*)&(staInfo->ueCqiInfo.cqiRept),
- (U8*)&(ue->schCqiInfo.cqiRept[idxStart]),
+ memcpy (&(staInfo->ueCqiInfo.cqiRept),
+ &(ue->schCqiInfo.cqiRept[idxStart]),
numCqiRept * sizeof(RgrUeCqiRept));
staInfo->ueCqiInfo.numCqiRept = numCqiRept;
S16 ret = ROK;
RgSchUpSapCb *rgrSap; /*!< RGR SAP Control Block */
- TRC2(rgSCHUtlRgrStaInd)
rgrSap = cell->rgrSap;
Inst inst = cell->instIdx;
RgInfRlsRnti rntiInfo;
- TRC2(rgSCHUtlIndRntiRls2Mac)
/* Copy the info to rntiInfo */
rntiInfo.cellId = cell->cellId;
S16 ret = ROK;
RgSchUpSapCb *rgrSap; /*!< RGR SAP Control Block */
- TRC2(rgSCHUtlRgrLoadInfInd)
-
-
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
#endif
{
- TRC2(rgSCHUtlRlsRnti)
U8 isLegacy = 0;
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
S16 ret = ROK;
RgSchUpSapCb *rgrSap; /*!< RGR SAP Control Block */
- TRC2(rgSCHUtlRgrStaInd)
-
-
rgrSap = cell->rgrSap;
if (rgrSap->sapSta.sapState != LRG_BND)
{
count++;
#endif
- TRC2(rgSCHUtlUpdAvgPrbUsage);
-
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
return RFAILED;
}
- cmMemset((U8 *) &prbRprtInd->stQciPrbRpts[0],
+ memset(&prbRprtInd->stQciPrbRpts[0],
0,
(RGM_MAX_QCI_REPORTS * sizeof(RgmPrbRptPerQci)));
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHUtlReTxTa)
/* If TA Timer is running. Stop it */
if (ueCb->taTmr.tmrEvnt != TMR_NONE)
U32 crntTimeInSubFrms = 0;
U32 boUpdTimeInSubFrms = 0;
U32 distance = 0;
- TRC2(rgSCHChkBoUpdate);
crntTimeInSubFrms = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) + cell->crntTime.slot +
RG_SCH_CMN_DL_DELTA + 2; /* As bo received will scheduled in next TTI
RgSchUlSf *ulSf;
U8 ulSF; /* UL SF in the TDD frame */
- TRC2(rgSchUtlCfg0ReTxIdx);
-
ulSf = &cellUl->ulSfArr[hqFdbkIdx];
ulSF = ulSf->ulSfIdx;
U8 iTbs;
U8 cfi = dlCell->currCfi;
- TRC2(rgSchUtlDlCalc1CwPrb);
-
iTbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
eff = (*(RgSchCmnTbSzEff *)(dlCell->cqiToEffTbl[0][cfi]))[iTbs];
U8 iTbs1, iTbs2;
U8 cfi = dlCell->currCfi;
- TRC2(rgSchUtlDlCalc2CwPrb);
-
if ((dlUe->mimoInfo.forceTD) ||/* Transmit Diversity (TD) */
(dlUe->mimoInfo.ri < 2))/* 1 layer precoding */
{
U32 *prbReqrd;
#endif
{
- TRC2(rgSchUtlCalcTotalPrbReq);
-
/* Call TM specific Prb calculation routine */
(dlCalcPrbFunc[ue->mimoInfo.txMode - 1])(cell, ue, bo, prbReqrd);
U8 ri;
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cell);
- TRC3(rgSCHUtlFetchPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
(ueCb->mimoInfo.txMode != RGR_UE_TM_4))
Pst pst;
RgInfLcgRegReq lcgRegReq;
- TRC3(rgSCHUtlBuildNSendLcgReg);
-
- cmMemset((U8*)&pst, (U8)0, sizeof(Pst));
+ memset(&pst, 0, sizeof(Pst));
lcgRegReq.isGbr = isGbr;
lcgRegReq.cellId = cell->cellId;
lcgRegReq.crnti = crnti;
TfuAckNackMode mode = TFU_UCI_FORMAT_1A_1B;
- TRC2(rgSchUtlGetFdbkMode);
-
switch(fdbkType)
{
case RG_SCH_UCI_FORMAT_NON_CA:
Inst inst = cell->instIdx;
RgInfRlsRnti rntiInfo;
- TRC2(rgSCHUtlSndUeSCellDel2Mac)
-
RGSCHDBGINFONEW(inst,(rgSchPBuf(inst),"RNTI Release IND for UE(%d)\n", rnti));
/* Copy the info to rntiInfo */
rntiInfo.cellId = cell->cellId;
{
U8 maxTbCount;
- TRC2(rgSCHUtlGetMaxTbSupp);
-
/* Primary Cell */
switch(txMode)
{
U32 tptDelta;
- TRC3(rgSCHUtlCpuOvrLdAdjItbsCap)
-
if ((cell->cpuOvrLdCntrl.cpuOvrLdIns) & (RGR_CPU_OVRLD_DL_TPT_UP |
RGR_CPU_OVRLD_DL_TPT_DOWN))
{
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
U8 idx;
- TRC3(rgSCHUtlResetCpuOvrLdState)
-
#ifdef CPU_OL_DBG_PRINTS
printf("\n CPU OVR LD Ins Rcvd = %d\n", (int)crntCpuOvrLdIns);
#endif
Code Review / o-du / l2.git / blobdiff