static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system services */
-#include "cm5.h" /* common timers defines */
-#include "cm_hash.h" /* common hash list defines */
-#include "cm_llist.h" /* common linked list defines */
-#include "cm_mblk.h" /* memory management */
-#include "cm_tkns.h" /* common tokens */
-#include "cm_lte.h" /* common tokens */
+#include "common_def.h"
#include "tfu.h" /* RGU defines */
#include "lrg.h" /* layer management defines for LTE-MAC */
#include "rgr.h" /* layer management defines for LTE-MAC */
/* header/extern include files (.x) */
-#include "gen.x" /* general layer typedefs */
-#include "ssi.x" /* system services typedefs */
-#include "cm5.x" /* common timers */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lib.x" /* common library */
-#include "cm_llist.x" /* common linked list */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common tokens */
#include "tfu.x" /* RGU types */
#include "lrg.x" /* layer management typedefs for MAC */
#include "rgr.x" /* layer management typedefs for MAC */
#ifdef EMTC_ENABLE
#include "rg_sch_emtc_ext.x"
#endif
+U8 rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb,U8 numTxAnt);
+S16 rgSCHDhm5gtfHqFdbkInd(RgSchUeCb *ue,RgSchCellCb *cell,CmLteTimingInfo timingInfo,TfuHqFdbk fdbk,RgSchErrInfo *err);
/* local defines */
#ifdef EMTC_ENABLE
EXTERN Bool rgSCHEmtcChkEmtcUe ARGS(
U16 rapId,
CmLteTimingInfo timingInfo
);
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
+S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
(
RgSchCellCb *cell,
U8 cqiReq,
U16 validIdx
));
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
+S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
));
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
+S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
));
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
+S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
Bool hqPres
));
-PUBLIC void schFillCrntTime(
+void schFillCrntTime(
SlotIndInfo slotInd,
Inst schInst);
#endif
/* local typedefs */
-PUBLIC U32 rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
-PUBLIC U32 rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
+U32 rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
+U32 rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
/* local externs */
/* rg006.201: [ccpu000111706, ccpu00112394]: Separated UL and DL TTI
#endif
#ifdef TFU_UPGRADE
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq ARGS
+S16 rgSCHTomFillOnlySrsRecpReq ARGS
((
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
Bool isDatPresOnSecCell
));
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
+S16 rgSCHTomUtlFillRiBitWidthInfo ARGS
((
RgSchUeCb *ueCb
));
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz ARGS
+U8 rgSCHTomUtlFetchPcqiBitSz ARGS
((
RgSchUeCb *ueCb,
U8 numTxAnt,
U8 *ri
));
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
+U8 rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
((
RgSchUeCb *ueCb,
TfuCqiPucchMode21 *mode21Info,
U8 *ri
));
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion ARGS
+S16 rgSCHTomUtlMoveNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
));
#endif
#ifdef LTEMAC_SPS
-EXTERN PUBLIC Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
+EXTERN Void rgSCHCmnDlSpsSch (RgSchCellCb *cell);
#ifndef LTE_TDD
#ifdef UNUSED_FUNC
#ifdef TFU_UPGRADE
#endif/*LTE_ADV*/
#endif/*LTE_TDD*/
-PUBLIC U32 rgDlCqiRptCnt[16], rgTotDlCqiRpt;
+U32 rgDlCqiRptCnt[16], rgTotDlCqiRpt;
#ifdef RG_5GTF
U32 rgSch5gtfCqi2Mcs[15] =
/*HARQ Feedback interpretation in accordance with Femto Forum.
Note: There is no value as '0' in Femto Forum Spec but in order to retain
the existing usage in MAC (and its Acceptance), its being considered*/
-CONSTANT PRIVATE U8 rgSchTomHqFbkMap[8] = {0,1,0,0,4,4,4,4};
+//CONSTANT PRIVATE U8 rgSchTomHqFbkMap[8] = {0,1,0,0,4,4,4,4};
/*added #defines instead of magic numbers*/
-CONSTANT PRIVATE U32 rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
+/*CONSTANT PRIVATE U32 rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28},
{0,1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,276,300,325,351,378},
{0,0,1,4,10,20,35,56,84,120,165,220,286,364,455,560,680,816,969,1140,1330,1540,1771,2024,2300,2600,2925,3276},
{0,0,0,0,1,6,21,56,126,252,462,792,1287,2002,3003,4368,6188,8568,11628,15504,20349,26334,33649,42504,53130,65780,80730,98280},
{0,0,0,0,0,1,7,28,84,210,462,924,1716,3003,5005,8008,12376,18564,27132,38760,54264,74613,100947,134596,177100,230230,296010,376740}
};
-
+*/
/*ccpu00116923 - ADD - SRS present support*/
/*Tables Derived from 3GPP TS 36.211 Section 5.5.3.3 */
/* Table 5.5.3.3-1 */
#ifndef LTE_TDD
-CONSTANT PUBLIC RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
+CONSTANT RgSchFddCellSpSrsSubfrmTbl rgSchFddCellSpSrsSubfrmTbl = {
{TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE},
{TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE, FALSE, TRUE},
};
#else
/* Table 5.5.3.3-2 */
-CONSTANT PUBLIC RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
+CONSTANT RgSchTddCellSpSrsSubfrmTbl rgSchTddCellSpSrsSubfrmTbl = {
{FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE},
{FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE},
{FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE},
{FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE}
};
#endif
-PUBLIC S8 rgSchCmnAper20n22DiffCqi[4] = {1, 2, 3, 4};
-PUBLIC S8 rgSchCmnAper30n31DiffCqi[4] = {0, 1, 2, -1};
+S8 rgSchCmnAper20n22DiffCqi[4] = {1, 2, 3, 4};
+S8 rgSchCmnAper30n31DiffCqi[4] = {0, 1, 2, -1};
#endif
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHGetDedPrmUe
+S16 rgSCHGetDedPrmUe
(
RgSchCellCb *cell,
U16 rapId,
RgSchUeCb **ue
)
#else
-PUBLIC S16 rgSCHGetDedPrmUe(cell, rapId, timingInfo, ue)
+S16 rgSCHGetDedPrmUe(cell, rapId, timingInfo, ue)
RgSchCellCb *cell;
U16 rapId;
CmLteTimingInfo timingInfo;
*ue = rgSCHCmnGetPoUe(cell, rapId, timingInfo);
printf(" ==== inding UE from PDCCH Order Mapping\n");
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief Handler for processing Random Access request indication
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomRaReqInd
+S16 rgSCHTomRaReqInd
(
RgSchCellCb *cell,
TfuRaReqIndInfo *raReqInd
)
#else
-PUBLIC S16 rgSCHTomRaReqInd(cell, raReqInd)
+S16 rgSCHTomRaReqInd(cell, raReqInd)
RgSchCellCb *cell;
TfuRaReqIndInfo *raReqInd;
#endif
U16 rapId;
RgSchUeCb *ue = NULLP;
- TRC2(rgSCHTomRaReqInd);
-
if(cell->cellId != raReqInd->cellId)
{
err.errType = RGSCHERR_TOM_RAREQIND;
RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHTomRaReqInd(): No cell found with raReq cellId = (%d) errorType (%d)"
" errorCause(%d)",raReqInd->cellId, err.errType, err.errCause);
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (raRntiCnt = 0; raRntiCnt < raReqInd->nmbOfRaRnti; raRntiCnt++)
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomRaReqInd */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUlCqiInd
+S16 rgSCHTomUlCqiInd
(
RgSchCellCb *cell,
TfuUlCqiIndInfo *ulCqiInd
)
#else
-PUBLIC S16 rgSCHTomUlCqiInd(cell, ulCqiInd)
+S16 rgSCHTomUlCqiInd(cell, ulCqiInd)
RgSchCellCb *cell;
TfuUlCqiIndInfo *ulCqiInd;
#endif
RgSchUeCb *ue;
CmLList *node;
TfuUlCqiRpt *ulCqiInfo;
- TRC2(rgSCHTomUlCqiInd);
node = ulCqiInd->ulCqiRpt.first;
if(cell->cellId != ulCqiInd->cellId)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHTomUlCqiInd() Unable to get the ulCqiInd cell with id(%d)",
ulCqiInd->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
for (;node; node=node->next)
/* wideband cqi is directly reported now. and also isTxPort0 */
rgSCHUtlUlCqiInd(cell, ue, ulCqiInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUlCqiInd */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomPucchDeltaPwrInd
+S16 rgSCHTomPucchDeltaPwrInd
(
RgSchCellCb *cell,
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr
)
#else
-PUBLIC S16 rgSCHTomPucchDeltaPwrInd(cell, pucchDeltaPwr)
+S16 rgSCHTomPucchDeltaPwrInd(cell, pucchDeltaPwr)
RgSchCellCb *cell;
TfuPucchDeltaPwrIndInfo *pucchDeltaPwr;
#endif
CmLList *node;
TfuPucchDeltaPwr *ueElem;
- TRC2(rgSCHTomPucchDeltaPwrInd);
-
if(cell->cellId != pucchDeltaPwr->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHTomPucchDeltaPwrInd() Unable to get the pucchDeltaPwr cell with id(%d)",
pucchDeltaPwr->cellId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
node = pucchDeltaPwr->pucchDeltaPwrLst.first;
}
rgSCHUtlPucchDeltaPwrInd(cell, ue, ueElem->pucchDeltaPwr);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomPucchDeltaPwrInd */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomHarqAckInd
+S16 rgSCHTomHarqAckInd
(
RgSchCellCb *cell,
TfuHqIndInfo *harqAckInd
)
#else
-PUBLIC S16 rgSCHTomHarqAckInd(cell, harqAckInd)
+S16 rgSCHTomHarqAckInd(cell, harqAckInd)
RgSchCellCb *cell;
TfuHqIndInfo *harqAckInd;
#endif
U32 cellIdx;
RgSchCellCb *iterCellP;
- TRC2(rgSCHTomHarqAckInd);
-
if(cell->cellId != harqAckInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomHarqAckInd() Unable to get"
" the cell for cellId (%d)", harqAckInd->cellId);
err.errType = RGSCHERR_TOM_HARQACKIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
#ifdef RG_5GTF
node = harqAckInd->hqIndLst.first;
for (;node; node=node->next)
}
}
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomHarqAckInd */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomSrInd
+S16 rgSCHTomSrInd
(
RgSchCellCb *cell,
TfuSrIndInfo *srInd
)
#else
-PUBLIC S16 rgSCHTomSrInd(cell, srInd)
+S16 rgSCHTomSrInd(cell, srInd)
RgSchCellCb *cell;
TfuSrIndInfo *srInd;
#endif
CmLList *node;
TfuSrInfo *srInfo;
- TRC2(rgSCHTomSrInd);
-
if(cell->cellId != srInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for srcInd cellId"
":%d ", srInd->cellId);
err.errType = RGSCHERR_TOM_SRIND;
err.errCause = RGSCHERR_TOM_INV_CELL_ID;
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = srInd->srLst.first;
continue;
}
}
- RETVALUE(ret);
+ return ROK;
} /* end of rgSCHTomSrInd */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomDoaInd
+S16 rgSCHTomDoaInd
(
RgSchCellCb *cell,
TfuDoaIndInfo *doaInd
)
#else
-PUBLIC S16 rgSCHTomDoaInd(cell, doaInd )
+S16 rgSCHTomDoaInd(cell, doaInd )
RgSchCellCb *cell;
TfuDoaIndInfo *doaInd;
#endif
RgSchUeCb *ue;
CmLList *node;
TfuDoaRpt *doaInfo;
- TRC2(rgSCHTomDoaInd);
if(cell->cellId != doaInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for doaInd cellId"
":%d", doaInd->cellId);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = doaInd->doaRpt.first;
}
rgSCHUtlDoaInd(cell, ue, doaInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomDoaInd */
/**
* @brief Handler for processing downlink CQI indication recieved from
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomDlCqiInd
+S16 rgSCHTomDlCqiInd
(
RgSchCellCb *cell,
TfuDlCqiIndInfo *dlCqiInd
)
#else
-PUBLIC S16 rgSCHTomDlCqiInd(cell, dlCqiInd)
+S16 rgSCHTomDlCqiInd(cell, dlCqiInd)
RgSchCellCb *cell;
TfuDlCqiIndInfo *dlCqiInd;
#endif
RgSchUeCb *ue;
CmLList *node;
TfuDlCqiRpt *dlCqiInfo;
- TRC2(rgSCHTomDlCqiInd);
if(cell->cellId != dlCqiInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
":%d", dlCqiInd->cellId);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = dlCqiInd->dlCqiRptsLst.first;
rgSCHUtlDlCqiInd(cell, ue, dlCqiInfo, dlCqiInd->timingInfo);
rgSCHUtlHdlUlTransInd(cell, ue, dlCqiInd->timingInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomDlCqiInd */
/**
U16 cqiIdx = 0;
CmLteTimingInfo timingInfo;
- TRC2(rgSCHTomUtlMovePcqiNxtOccasion);
if(cqiCb->cqiCfg.cqiSetup.cqiRepType == RGR_UE_PCQI_SB_REP)
{
rgSCHUtlSCellHndlCqiCollsn(cqiCb);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMovePcqiNxtOccasion */
/**
U16 crntTime;
U16 tempIdx;
- TRC2(rgSCHTomUtlMovePriNxtOccasion);
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cell->crntTime.slot);
#ifdef XEON_SPECIFIC_CHANGES
#ifdef LTE_ADV
rgSCHUtlSCellHndlRiCollsn(riCb);
#endif
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMovePriNxtOccasion */
/**
{
U16 srIdx = 0;
- TRC2(rgSCHTomUtlMoveSrNxtOccasion);
-
/* Compute Next Transmission Instance */
srIdx = ue->srCb.peri + ue->srCb.nSrTrIdx;
srIdx = srIdx%RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
cmLListAdd2Tail(&cell->pCqiSrsSrLst[ue->srCb.nSrTrIdx].srLst,
&ue->srCb.srLstEnt);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMoveSrNxtOccasion */
/**
U16 crntTime;
- TRC2(rgSCHTomUtlMoveSrsNxtOccasion);
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cell->crntTime.slot);
}
ue->srsCb.nSrsTrIdx = srsIdx;
ue->srsCb.srsDist = srsDist;
-
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMoveSrsNxtOccasion */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomRawCqiInd
+S16 rgSCHTomRawCqiInd
(
RgSchCellCb *cell,
TfuRawCqiIndInfo *rawCqiInd
)
#else
-PUBLIC S16 rgSCHTomRawCqiInd(cell, rawCqiInd)
+S16 rgSCHTomRawCqiInd(cell, rawCqiInd)
RgSchCellCb *cell;
TfuRawCqiIndInfo *rawCqiInd;
#endif
RgSchRaCb *raCb;
TfuHqInfo hqInfo;
- TRC2(rgSCHTomRawCqiInd);
-
if(cell->cellId != rawCqiInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
":%d", rawCqiInd->cellId);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = rawCqiInd->rawCqiRpt.first;
rlsHqBufs->numUes = 0;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomRawCqiInd */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomSrsInd
+S16 rgSCHTomSrsInd
(
RgSchCellCb *cell,
TfuSrsIndInfo *srsInd
)
#else
-PUBLIC S16 rgSCHTomSrsInd(cell, srsInd)
+S16 rgSCHTomSrsInd(cell, srsInd)
RgSchCellCb *cell;
TfuSrsIndInfo *srsInd;
#endif
CmLList *node;
TfuSrsRpt* srsInfo;
- TRC2(rgSCHTomSrsInd);
-
if(cell->cellId != srsInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
":%d", srsInd->cellId);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = srsInd->srsRpt.first;
for (;node; node=node->next)
rgSCHUtlSrsInd(cell, ue, srsInfo, srsInd->timingInfo);
rgSCHUtlHdlUlTransInd(cell, ue, srsInd->timingInfo);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomSrsInd */
/*
xmin = idx+1;
label = label-binCoe;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlGenIndices*/
#endif
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomCrcInd
+S16 rgSCHTomCrcInd
(
RgSchCellCb *cell,
TfuCrcIndInfo *crcInd
)
#else
-PUBLIC S16 rgSCHTomCrcInd(cell, crcInd)
+S16 rgSCHTomCrcInd(cell, crcInd)
RgSchCellCb *cell;
TfuCrcIndInfo *crcInd;
#endif
RgSchUlHqProcCb *ulHqProc;
#endif
- TRC2(rgSCHTomCrcInd);
-
if(cell->cellId != crcInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
":%d", crcInd->cellId);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
#ifdef RG_ULSCHED_AT_CRC
#ifndef LTE_ADV
{
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate TfuCntrlReqInfo "
"for cell");
- RETVALUE(ret);
+ return ret;
}
rgSCHCmnUlSch(cell);
#ifdef LTE_L2_MEAS
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomCrcInd() Unable to process"
" downlink subframe for cellId %d", crcInd->cellId);
err.errType = RGSCHERR_TOM_TTIIND;
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
#endif /* RG_ULSCHED_AT_CRC */
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomCrcInd */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomTimingAdvInd
+S16 rgSCHTomTimingAdvInd
(
RgSchCellCb *cell,
TfuTimingAdvIndInfo *timingAdvInd
)
#else
-PUBLIC S16 rgSCHTomTimingAdvInd(cell, timingAdvInd)
+S16 rgSCHTomTimingAdvInd(cell, timingAdvInd)
RgSchCellCb *cell;
TfuTimingAdvIndInfo *timingAdvInd;
#endif
CmLList *node;
TfuTimingAdvInfo *timingAdvInfo;
-
- TRC2(rgSCHTomTimingAdvInd);
-
if(cell->cellId != timingAdvInd->cellId)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to get the cell for cellId"
"=(%d)", timingAdvInd->cellId);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
node = timingAdvInd->timingAdvLst.first;
}
rgSCHDhmUpdTa (cell, ue, timingAdvInfo->timingAdv);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomTimingAdvInd */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHTomTtiInd
+Void rgSCHTomTtiInd
(
SlotIndInfo *slotInd,
Inst schInst
)
#else
-PUBLIC Void rgSCHTomTtiInd(slotInd, schInst)
+Void rgSCHTomTtiInd(slotInd, schInst)
SlotIndInfo *slotInd;
Inst schInst;
#endif
RgSchCellCb *cell[CM_LTE_MAX_CELLS];
RgSchCellCb *cellLst[CM_LTE_MAX_CELLS];
- TRC2(rgSCHTomTtiInd);
-
#ifdef LTE_L2_MEAS
glblTtiCnt++;
#endif
#endif
Inst inst = cell->instIdx;
- TRC2(rgSCHTomUtlProcUlSf)
-
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate TfuRecpReqInfo "
"for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
recpReqInfo->cellId = cell->cellId;
cmLListInit(&recpReqInfo->ueRecpReqLst);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to fill Data recption "
"requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
- RETVALUE(ret);
+ return ret;
}
/* Filling HARQ Reception requests */
ret = rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, validIdx,err);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to fill Harq Feedback "
"reception requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
- RETVALUE(ret);
+ return ret;
}
/* sending the RecpReq to Phy */
if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info for cell");
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlProcUlSf */
#ifdef LTE_TDD
U16 validIdx; /* Index computed from recreq's timing info*/
Inst inst = cell->instIdx;
- TRC2(rgSCHTomUtlPrcUlTddSpclSf)
-
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
sizeof(TfuRecpReqInfo))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to "
"Allocate TfuRecpReqInfo for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
recpReqInfo->cellId = cell->cellId;
cmLListInit(&recpReqInfo->ueRecpReqLst);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to fill"
" SRS recption requests for cell");;
RGSCH_FREE_MEM(recpReqInfo);
- RETVALUE(ret);
+ return ret;
}
/* sending the RecpReq to Phy */
if (rgSCHUtlTfuRecpReq(inst, cell->tfuSap->sapCfg.suId, recpReqInfo) != ROK)
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to send "
"Cntrl info for cell");
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlPrcUlTddSpclSf */
#endif
#endif
S16 ret;
U8 sfTyp = 1; /* Dl Subframe */
- TRC2(rgSCHTomUtlProcDlSf);
-
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
cmLListInit(&cntrlInfo->ulPdcchLst);
RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PHICH info "
"for cellId (%d)\n", cell->cellId));
RGSCH_FREE_MEM(cntrlInfo);
- RETVALUE(ret);
+ return ret;
}
if ((ret = rgSCHTomUtlFillUlPdcch (cell, cntrlInfo, ulSf, err)) !=
ROK)
RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PDCCH info "
"for cellId (%d)\n", cell->cellId));
RGSCH_FREE_MEM(cntrlInfo);
- RETVALUE(ret);
+ return ret;
}
}
#ifdef EMTC_ENABLE
RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to send PDCCH info "
"for cellId (%d)\n", cell->cellId));
RGSCH_FREE_MEM(cntrlInfo);
- RETVALUE(ret);
+ return ret;
}
rgBwAlloInfo[dlSf->sfNum] += dlSf->bwAssigned;
rgBwAlcnt[dlSf->sfNum] ++;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send Cntrl info "
"for cell");
}
+ return ROK;
- RETVALUE(ROK);
}
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
#endif
- TRC2(rgSCHTomUtlFillPhich)
ret = ROK;
/* Traversing the list of Phichs */
node = dlSf->phichInfo.phichs.first;
&(cntrlInfo->memCp))) != ROK)
{
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
harqAck->txPower = 0;
harqAck->lnk.node = (PTR)harqAck;
node = node->next;
} /* end of while */
- RETVALUE(ret);
+ return ret;
} /* end of */
U8 isDcivld = FALSE;
U8 numUePerTti = 0;
- TRC2(rgSCHTomUtlFillDlPdcch)
ret = ROK;
/* Traversing the scheduled Harq processes */
node = dlSf->pdcchInfo.pdcchs.first;
&(cntrlInfo->memCp))) != ROK)
{
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef LTEMAC_SPS
tfuPdcch->crnti = pdcch->crnti;
gDlNumUePerTti[numUePerTti-1]++;
}
}
- RETVALUE(ret);
+ return ret;
} /* end of rgSCHTomUtlFillDlPdcch*/
#ifdef RGSCH_SPS_STATS
TfuPdcchInfo *tfuPdcch;
U8 isDcivld = FALSE;
- TRC2(rgSCHTomUtlFillUlPdcch)
ret = ROK;
/* Traversing the scheduled Harq processes */
node = dlSf->pdcchInfo.pdcchs.first;
&(cntrlInfo->memCp))) != ROK)
{
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
tfuPdcch->rnti = pdcch->rnti;
#ifdef LTE_ADV
// abort();
}
#endif
- RETVALUE(ret);
+ return ret;
} /* end of rgSCHTomUtlFillUlPdcch*/
/** @brief This function does the processing for Timing adjustment.
CmLList *node;
RgSchUeCb *ue;
- TRC2(rgSCHTomUtlProcTA);
-
node = cell->taUeLst.first;
while (node)
{
ue->dl.taCb.numRemSf--;
}
} /* end of taUeLst */
-
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlProcTA */
/** @brief This function handles filling of Hq reception request to
*/
#ifdef TFU_UPGRADE
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo
+S16 rgSCHTomUtlFillHqFdbkInfo
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, validIdx, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
+S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, validIdx, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
U16 validIdx;
#endif
#else
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo
+S16 rgSCHTomUtlFillHqFdbkInfo
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
+S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
RgSchDlHqProcCb *hqCb;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for cell");
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
if ((hqCb->hqE->ue != NULLP) /*&&
break;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkInfo */
#ifdef RG_5GTF
Inst inst = cell->instIdx;
#endif
S16 ret;
- CmLList *hqPNode;
RgSchUeCb *ue;
TfuUePucchRecpReq *pucchReqInfo = NULLP;
- hqPNode = dlSfHqInfo->hqPLst.first;
ue = (RgSchUeCb*)dlSfHqInfo->dlSfUeLnk.node;
if (ue == NULLP)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
"TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchRecpInfo->rnti = ue->ueId; /* Even for Rel pdcch also setting CRNTI
cmLListAdd2Tail(&recpReqInfo->ueRecpReqLst, &(pucchRecpInfo->lnk));
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkForFrmt1B */
#endif
if (ue == NULLP)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
"TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchRecpInfo->rnti = ue->ueId; /* Even for Rel pdcch also setting CRNTI
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = ue->f1bCsAVal;
- cmMemset((U8 *)pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
#ifdef LTEMAC_SPS
/* Two Resources needs to be configured if the
* serving cell is in mimo mode else single
#endif/*TFU_UPGRADE*/
cmLListAdd2Tail(&recpReqInfo->ueRecpReqLst, &(pucchRecpInfo->lnk));
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkForFrmt1B */
/** @brief This function handles filling of Hq reception request to
* Per Hq Proc.
if (ue == NULLP)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ret = rgSCHUtlGetEventMem((Ptr *)&pucchRecpInfo,
sizeof(TfuUeRecpReqInfo), &(recpReqInfo->memCp));
if (ret != ROK)
RGSCHDBGERRNEW(inst,(rgSchPBuf(inst),"Unable to Allocate "
"TfuUeRecpReqInfo for cellId=%d \n", cell->cellId));
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchRecpInfo->rnti = ue->ueId; /* Even for Rel pdcch also setting CRNTI
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = 1;
- cmMemset((U8 *)pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
#endif/*TFU_UPGRADE*/
pucchReqInfo->hqInfo.hqRes[0] = dlSfHqInfo->n3ScellPucch.n3PucchIdx;
#ifdef TFU_UPGRADE
#endif/*TFU_UPGRADE*/
cmLListAdd2Tail(&recpReqInfo->ueRecpReqLst, &(pucchRecpInfo->lnk));
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillHqFdbkForFrmt3 */
#endif/*LTE_ADV*/
RgSchUeCb *ue;
RgSchDlHqProcCb *prvHqCb=NULLP;
- TRC2(rgSCHTomUtlFillHqFdbkRecpReq);
-
#ifdef CA_DBG
{
gF1bCsPres = FALSE;
/* Check with TDD Code */
/* FOR ACK NACK REP */
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlFillHqFdbkRecpReq */
#ifdef TFU_UPGRADE
/** @brief This function handles filling of SR reception request to
#endif
- TRC2(rgSCHTomUtlFillSrRecpReq);
-
isAddToLst = FALSE;
node = cell->pCqiSrsSrLst[validIdx].srLst.first;
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
/*Fill SR params*/
}
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillSrRecpReq */
#endif
#endif
Bool *willueRprtCqiRi;
#endif
{
- TRC2(rgSCHTomUtlWillUeRprtCqiRi);
-
/* Intialising Reporting probability as TRUE */
*willueRprtCqiRi = TRUE;
{/*onDuration NOT running, do not expect cqi/pmi/ri*/
*willueRprtCqiRi = FALSE;
}
- RETVALUE(ROK);
- }
+ return ROK;
+ }
#endif /*end of LTEMAC_R9*/
/* ccpu00134258: Fix for CQI DRX issue*/
if(ue->drxCb->onDurTmrLen > 2)
}
}
}/*ue->isDrxEnabled*/
-
- RETVALUE(ROK);
+ return ROK;
} /*End of rgSCHTomUtlWillUeRprtCqiRi*/
/** @brief This function handles filling of RI reception request to
Bool willUeRprtCqi; /* Flag set due to CQI Mask
and UE inactive state (DRX) */
RgSchUePCqiCb *riCb = NULLP;
- TRC2(rgSCHTomUtlFillRiRecpReq);
node = cell->pCqiSrsSrLst[validIdx].riLst.first;
while(node)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for cell RNTI:%d",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
/*Fill RI params*/
riCb->riDist--;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillRiRecpReq */
#endif
#ifdef RG_5GTF
RgSchUeCb *ue = NULLP;
U16 ret;
- TRC2(rgSCHTomUtlFillCqiRiRecpReq);
-
while ((ue = rgSCHDbmGetNextUeCb(cell, ue)) != NULLP)
{
if (RGSCH_TIMEINFO_SAME (recpReqInfo->timingInfo, ue->ue5gtfCb.nxtCqiRiOccn))
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
pucchRecpInfo->rnti = ue->ueId;
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
}
}
-
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillCqiRiRecpReq */
#endif
#endif
RgSchUePCqiCb *cqiCb = NULLP;
Bool isAddToLst = FALSE;
- TRC2(rgSCHTomUtlFillPcqiRecpReq);
-
node = cell->pCqiSrsSrLst[validIdx].cqiLst.first;
while(node)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for cell RNTI:%d ", ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
#endif
}
pucchRecpInfo->lnk.node = (PTR)pucchRecpInfo;
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillPcqiRecpReq */
/** @brief This function handles filling of SRS reception request to
* PHY.
S16 ret;
RgSchUeCb *ue;
- TRC2(rgSCHTomUtlFillSrsRecpReq);
-
node = cell->pCqiSrsSrLst[validIdx].srsLst.first;
while(node)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for RNTI:%d ",ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
ue->srsCb.srsDist--;
}
}
- RETVALUE(ROK);
+ return ROK;
}/* end of rgSCHTomUtlFillSrsRecpReq */
#endif
#ifndef TFU_UPGRADE
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
- TRC2(rgSCHTomUtlFillDatRecpReq)
/* processing steps are
* - Run through the UL allocations going out in this subframe.
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for RNTI:%d ", alloc->ue->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
if (!alloc->forMsg3)
{
alloc = rgSCHUtlNextRcptnReq (cell, alloc);
} /* end of while */
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlFillDatRecpReq */
#else
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
- Bool hqPres; /*Set when HARQ Rec Req is present*/
Bool isAperiodic = FALSE; /*Set when Aperiodic CQI is expected */
U8 numUePerTti = 0;
- TRC2(rgSCHTomUtlFillDatRecpReq);
-
if((0 == (recpReqInfo->timingInfo.sfn % 30)) && (0 == recpReqInfo->timingInfo.slot))
{
//printf("5GTF_CHECK rgSCHTomUtlFillDatRecpReq (%d : %d)\n", recpReqInfo->timingInfo.sfn, recpReqInfo->timingInfo.slot);
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Allocate "
"TfuUeRecpReqInfo for RNTI:%d ", alloc->rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
#ifdef TFU_ALLOC_EVENT_NO_INIT
datRecpInfo->t.puschRecpReq.initialNSrs.pres = FALSE;
datRecpInfo->t.puschRecpReq.initialNumRbs.pres = FALSE;
#endif
datRecpInfo->type = TFU_RECP_REQ_PUSCH;
- /* ccpu00131944 - Intializing hqPres in each iteration*/
- hqPres = FALSE;
/* Check if this if for MSG3 - no scope for feedback along with it. */
if ((FALSE == alloc->forMsg3))
{
cell->ulNumUeSchedPerTti[numUePerTti-1]++;
gUlNumUePerTti[numUePerTti - 1]++;
}
- RETVALUE(ROK);
+ return ROK;
} /* end of rgSCHTomUtlFillDatRecpReq */
#endif
/* rg009.201. Added changes of TFU_UPGRADE */
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo
+S16 rgSCHTomUtlFillRiBitWidthInfo
(
RgSchUeCb *ueCb
)
#else
-PUBLIC S16 rgSCHTomUtlFillRiBitWidthInfo(ueCb)
+S16 rgSCHTomUtlFillRiBitWidthInfo(ueCb)
RgSchUeCb *ueCb;
#endif
{
RgSchUePCqiCb *riCb = ueCb->nPRiCb;
- TRC2(rgSCHTomUtlFillRiBitWidthInfo);
if (ueCb->mimoInfo.txMode != RGR_UE_TM_3 &&
ueCb->mimoInfo.txMode != RGR_UE_TM_4)
{
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
ueCb->rawCqiBitW[ueCb->cqiRiWritIdx].type = TFU_RECP_REQ_PUCCH;
ueCb->rawCqiBitW[ueCb->cqiRiWritIdx].u.pucch.pucchRawCqiInfo.mode=
}
RG_SCH_INCR_CQIRI_INDEX(ueCb->cqiRiWritIdx);
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz
+U8 rgSCHTomUtlFetchPcqiBitSz
(
RgSchUeCb *ueCb,
U8 numTxAnt,
U8 *ri
)
#else
-PUBLIC U8 rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
+U8 rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
RgSchUeCb *ueCb;
U8 numTxAnt;
U8 *ri;
TfuCqiPucchMode21 *mode21Info;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
- TRC3(rgSCHTomUtlFetchPcqiBitSz);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
if((ueCb->mimoInfo.txMode != RGR_UE_TM_3) &&
}
RG_SCH_INCR_CQIRI_INDEX(ueCb->cqiRiWritIdx);
- RETVALUE(pcqiSz);
+ return pcqiSz;
}
*
**********************************************************/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlPcqiSbCalcBpIdx
+S16 rgSCHTomUtlPcqiSbCalcBpIdx
(
CmLteTimingInfo crntTimInfo,
RgSchUeCb *ueCb,
RgSchUePCqiCb *cqiCb
)
#else
-PUBLIC S16 rgSCHTomUtlPcqiSbCalcBpIdx(crntTimInfo, ueCb, cqiCb)
+S16 rgSCHTomUtlPcqiSbCalcBpIdx(crntTimInfo, ueCb, cqiCb)
CmLteTimingInfo crntTimInfo;
RgSchUeCb *ueCb;
RgSchUePCqiCb *cqiCb;
U16 tti = (crntTimInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTimInfo.slot);
U16 prdNum = tti/cqiCb->cqiPeri;
- TRC2(rgSCHTomUtlPcqiSbCalcBpIdx);
if((prdNum % cqiCb->h) == 0)
{
cqiCb->isWb = TRUE;
cqiCb->prioLvl = RG_SCH_CQI_PRIO_LVL_0;
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion
+S16 rgSCHTomUtlMoveNxtOccasion
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlMoveNxtOccasion(cell, ue, validIdx)
+S16 rgSCHTomUtlMoveNxtOccasion(cell, ue, validIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
U16 validIdx;
{
RgSchUePCqiCb *cqiCb = ue->nPCqiCb;
RgSchUePCqiCb *riCb = ue->nPRiCb;
- TRC2(rgSCHTomUtlMoveNxtOccasion);
/* ccpu00140578::Skip the UE if already RI recpetion
* is processed in the same subframe */
{
rgSCHTomUtlMoveSrNxtOccasion(cell, ue);
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlMoveNxtOccasion */
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHTomPrepareAcqiRecp
+Void rgSCHTomPrepareAcqiRecp
(
RgSchUeCb *ueCb,
RgSchCellCb *cell,
U8 ccIdx
)
#else
-PUBLIC Void rgSCHTomPrepareAcqiRecp(ueCb, cell, cqiRecpReqInfo, ccIdx)
+ Void rgSCHTomPrepareAcqiRecp(ueCb, cell, cqiRecpReqInfo, ccIdx)
RgSchUeCb *ueCb;
RgSchCellCb *cell;
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
U8 numOfCells = 0;
RgSchUeACqiCb *acqiCb = &ueCb->cellInfo[sCellIdx]->acqiCb;
- TRC2(rgSCHTomPrepareAcqiRecp);
-
/* Fill TFU Recp */
cqiRecpReqInfo->reportType = TFU_APERIODIC_CQI_TYPE; /* Aperiodic */
if (ueCb->mimoInfo.txMode == RGR_UE_TM_3 ||
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq
+S16 rgSCHTomUtlFillDatAperRecpReq
(
RgSchCellCb *cell,
U8 cqiReq,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatAperRecpReq(cell, cqiReq, alloc, datRecpInfo, timeInfo, hqPres, validIdx)
+S16 rgSCHTomUtlFillDatAperRecpReq(cell, cqiReq, alloc, datRecpInfo, timeInfo, hqPres, validIdx)
RgSchCellCb *cell;
U8 cqiReq;
RgSchUlAlloc *alloc;
U8 triggerSet = 0;
U8 sIdx = 0;
#endif
- TRC2(rgSCHTomUtlFillDatAperRecpReq);
/*Fill RI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatAperRecpReq */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq
+S16 rgSCHTomUtlFillDatPriRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatPriRecpReq(cell, alloc, datRecpInfo, timeInfo,
+S16 rgSCHTomUtlFillDatPriRecpReq(cell, alloc, datRecpInfo, timeInfo,
hqPres, validIdx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
#endif
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- TRC2(rgSCHTomUtlFillDatPriRecpReq);
/*Fill RI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatPriRecpReq */
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq
+S16 rgSCHTomUtlFillDatPCqiRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
U16 validIdx
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatPCqiRecpReq(cell, alloc, datRecpInfo,
+S16 rgSCHTomUtlFillDatPCqiRecpReq(cell, alloc, datRecpInfo,
timeInfo, hqPres, validIdx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
U8 cqiPmiSz; /*Raw CQI/PMI Size*/
U8 ri;
- TRC2(rgSCHTomUtlFillDatPCqiRecpReq);
-
-
/*Fill CQI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
#ifdef TFU_ALLOC_EVENT_NO_INIT
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Unable to Fill "
"CqiPmi size RNTI:%d",alloc->rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fill only the first RI index since Periodic can come
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatPCqiRecpReq */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq
+S16 rgSCHTomUtlFillDatSrsRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
Bool hqPres
)
#else
-PUBLIC S16 rgSCHTomUtlFillDatSrsRecpReq(cell, alloc, datRecpInfo, timeInfo,
+S16 rgSCHTomUtlFillDatSrsRecpReq(cell, alloc, datRecpInfo, timeInfo,
hqPres)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
Bool hqPres;
#endif
{
- TRC2(rgSCHTomUtlFillDatSrsRecpReq);
datRecpInfo->rnti = alloc->rnti;
rgSCHTomFillOnlySrsRecpReq(cell,alloc, datRecpInfo);
if(hqPres)
datRecpInfo->rnti = alloc->rnti;
rgSCHUtlAllocRcptInfo (cell, alloc, timeInfo,
&datRecpInfo->t.puschRecpReq.ulSchInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillDatSrsRecpReq */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq
+S16 rgSCHTomFillOnlySrsRecpReq
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
TfuUeRecpReqInfo *datRecpInfo
)
#else
-PUBLIC S16 rgSCHTomFillOnlySrsRecpReq(cell, alloc, datRecpInfo)
+S16 rgSCHTomFillOnlySrsRecpReq(cell, alloc, datRecpInfo)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
#endif
{
TfuUePuschSrsRecpInfo *srsRecpReqInfo;
- TRC2(rgSCHTomFillOnlySrsRecpReq);
srsRecpReqInfo = &datRecpInfo->t.puschRecpReq.srsInfo;
srsRecpReqInfo->srsBw = (TfuUlSrsBwInfo)alloc->ue->srsCb.srsCfg.srsSetup.srsBw;
* Refer Section 5.2.2.6 of TS 36.212 V8.5.0*/
datRecpInfo->t.puschRecpReq.ulSchInfo.nSrs = 1;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomFillOnlySrsRecpReq */
/**
RgSchEmtcUeInfo *emtcUe = NULLP;
#endif
- TRC2(rgSCHTomUtlFillCqiSrSrsWithHq);
-
if(ue)
{
/*Changes for PUCCH Format3 */
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d "
"Unable to Fill CqiPmi size", ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(pucchRecpInfo->t.pucchRecpReq.uciInfo == TFU_PUCCH_HARQ_SR)
{
}
}
UNUSED(dropCqi);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillCqiSrSrsWithHq */
/**
U8 ri; /*To fetch RI value*/
Bool willUeRprtCqi; /* Flag set due to CQI Mask and
UE Inactive state (DRX)*/
- TRC2(rgSCHTomUtlFillCqiSrsWithSr);
-
riCb = ue->nPRiCb;
cqiCb = ue->nPCqiCb;
rgSCHTomUtlWillUeRprtCqiRi(ue, &willUeRprtCqi);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"RNTI:%d"
" Unable to Fill CqiPmi size", ue->ueId);
- RETVALUE(RFAILED);
- }
+ return RFAILED;
+ }
pucchRecpInfo->t.pucchRecpReq.uciInfo = TFU_PUCCH_SR_CQI;
}
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHTomUtlFillCqiSrsWithSr */
#endif
RgSchDlHqTbCb *tbCb;
RgSchDlHqProcCb *prvHqCb = NULLP;
- TRC2(rgSCHTomUtlFillSfRepHqFdbk)
-
node = dlSf->ackNakRepQ.first;
while (node)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to"
"Allocate TfuUeRecpReqInfo for RNTI:%d ", ueCb->ueId);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
pucchRecpInfo->rnti = ueCb->ueId;
#ifndef TFU_UPGRADE
/* Go to the next node */
node = node->next;
}
-
- RETVALUE(ROK);
+ return ROK;
}
/** @brief This function handles filling of HARQ feedback recption request
U8 hqSz = 0;
U32 idx = 0;
- TRC2(rgSCHTomUtlFillSfHqFdbkInfo)
-
#ifndef TFU_UPGRADE
RG_SCH_ADD_TO_CRNT_TIME(cellCb->crntTime, futTime, TFU_RECPREQ_DLDELTA);
#endif
if((anInfo == NULLP) ||
(anInfo->latestMIdx != dlSf->dlFdbkInfo.m))
{
- RETVALUE(ROK);
- }
+ return ROK;
+ }
}
else
{
}
else
{
- RETVALUE(ROK);
+ return ROK;
}
/* Do not proceed if PUSCH
n1PucchTkn, &alloc, hqSz);
if (ret != ROK)
{
- RETVALUE(ret);
+ return ret;
}
/* TODO:: In case of F1BCS and CSI in same subframe
* UE shall drop the CSI if there was at least one
prvHqCb = hqCb;
}
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef LTE_ADV
default:
break;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to "
"Allocate TfuUeRecpReqInfo for cell RNTI:%d",rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
alloc = TRUE;
#ifdef TFU_ALLOC_EVENT_NO_INIT
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCb->cellId,"Unable to "
"Allocate TfuUeRecpReqInfo for cell RNTI:%d",rnti);
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
- RETVALUE(ret);
+ return ret;
}
- cmMemset((U8 *)pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
#ifdef TFU_ALLOC_EVENT_NO_INIT
- cmMemset((U8 *)&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
+ memset(&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
#endif
pucchInfo->pucchRecpInfo->type = TFU_RECP_REQ_PUCCH;
pucchInfo->pucchRecpInfo->rnti = rnti;
because of kworks*/
RGSCHDBGERRNEW(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),
"ANInfo should not be NULL for cellId=%d \n", cellCb->cellId));
- RETVALUE(RFAILED);
-
+ return RFAILED;
}
#endif
}
{/* This needs to be revisited while
adding support for PUCCH format 3 */
RGSCHDBGERRNEW(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),"Invalid Pucch format configured.."));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
*pucchInfoRef = pucchInfo;
*allocRef = alloc;
- RETVALUE(ROK);
+ return ROK;
}
#endif
Inst inst = cell->instIdx;
S16 ret;
- TRC2(rgSCHTomUtlProcDlSfAtCrc);
-
-
cntrlInfo->numDlActvUes = 0;
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send PHICH info for "
"cell");
RGSCH_FREE_MEM(cntrlInfo);
- RETVALUE(ret);
+ return ret;
}
/* Fill UL Pdcch */
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Unable to send PDCCH info for "
"cell");
RGSCH_FREE_MEM(cntrlInfo);
- RETVALUE(ret);
+ return ret;
}
#ifdef EMTC_ENABLE
{
RGSCH_FREE_MEM(cntrlInfo);
}
-
- RETVALUE(ROK);
+ return ROK;
} /* end of */
#endif /* #ifdef RG_ULSCHED_AT_CRC*/
{
RgrTtiIndInfo *rgrTtiInd;
- TRC2(rgSCHTomUtlSendSfnTick);
-
/* TTI to be sent to RRM only once per system frame */
/* Added support for period = 0 to disable tick to RRM */
if ((cell->rrmTtiIndPrd != 0) &&
* Function: rgSCHDynTDDMrkCrntSfIdx
* Purpose: update the dyn tdd sunframe index
* @param[in] Inst schInst
- * @RETVALUE None
+ * @return None
*/
#ifdef UNUSED_FUNC
#ifdef ANSI
{
RgSchDynTddCb *rgSchDynTddInfo = &(rgSchCb[schInst].rgSchDynTdd);
- TRC2(rgSCHDynTDDMrkCrntSfIdx)
RG_SCH_DYN_TDD_MARKTYPE(rgSchDynTddInfo, rgSchDynTddInfo->crntDTddSfIdx,
RG_SCH_DYNTDD_NOTDEF);
CmLteTimingInfo frm;
- TRC2 (rgSchTomFillCellTtiInfo);
-
if (CM_LTE_MAX_CELLS < ttiInd->numCells)
{
RETVOID;
#endif
{
- TRC2(rgSchTomTtiUlAndDlCmnChSch);
-
cell->rlsHqArr[cell->crntHqIdx].numUes = 0;
cell->crntHqIdx++;
cell->crntHqIdx = cell->crntHqIdx % RGSCH_NUM_SUB_FRAMES;
{
U8 suId = cell->tfuSap->sapCfg.suId;
- TRC2(rgSchTomTtiMiscFunctions);
-
/* Invoke RAM Tti Handler */
rgSCHRamTtiHndlr(cell);
RgSchCellCb *cell;
#endif
{
- TRC2(rgSchTomTtiDlSch);
if (cell->isDlDataAllwd && (cell->stopDlSch == FALSE))
{
dlSf = rgSCHUtlSubFrmGet(cell, cellSch->dl.time);
- TRC2(rgSchTomTtiCnsldtSfAlloc);
-
/* Prepare Subframe allocation info and send to MAC */
rgSCHCmnCnsldtSfAlloc(cell);
RgSchDlSf *ulSf = rgSCHUtlSubFrmGet (cell, cell->hiDci0Time);
RgSchErrInfo err;
- TRC2(rgSchTomTtiL1DlAndUlCfg);
-
rgSCHTomUtlProcDlSf (dlSf, ulSf, cell, cntrlInfo, &err);
/* Mark this frame as sent */
dlSf->txDone = TRUE;
RgSchCellCb *cell;
#endif
{
- TRC2(rgSchTomUtlTddRlsSfAndHarq);
/* ccpu00132341-MOD- rgSchTddRlsDlSubfrmTbl is dependent on DELTA(=2).
* Instead rgSchTddDlAscSetIdxKTbl can be used as the K set gives proper
{
RgSchErrInfo err;
- TRC2(rgSCHTomUtlProcTddUlSf);
-
if(rgSchTddUlDlSubfrmTbl[cell->ulDlCfgIdx]
[cell->rcpReqTime.subframe] == RG_SCH_TDD_UL_SUBFRAME)
{
Code Review / o-du / l2.git / blobdiff