@brief This file implements the schedulers main access to MAC layer code.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=187;
-static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
#include "common_def.h"
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnCompEff
-(
-uint8_t noPdcchSym,
-uint8_t cpType,
-uint8_t txAntIdx,
-RgSchCmnTbSzEff *effTbl
-)
-#else
-static Void rgSCHCmnCompEff(noPdcchSym, cpType, txAntIdx, effTbl)
-uint8_t noPdcchSym;
-uint8_t cpType;
-uint8_t txAntIdx;
-RgSchCmnTbSzEff *effTbl;
-#endif
+static Void rgSCHCmnCompEff(uint8_t noPdcchSym,uint8_t cpType,uint8_t txAntIdx,RgSchCmnTbSzEff *effTbl)
{
- uint8_t noResPerRb;
- uint8_t noSymPerRb;
- uint8_t resOfCrs; /* Effective REs occupied by CRS */
- uint8_t i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t resOfCrs; /* Effective REs occupied by CRS */
+ uint8_t i, j;
switch (cpType)
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnCompUlEff
-(
-uint8_t noUlRsSym,
-uint8_t cpType,
-RgSchCmnTbSzEff *effTbl
-)
-#else
-static Void rgSCHCmnCompUlEff(noUlRsSym, cpType, effTbl)
-uint8_t noUlRsSym;
-uint8_t cpType;
-RgSchCmnTbSzEff *effTbl;
-#endif
+static Void rgSCHCmnCompUlEff(uint8_t noUlRsSym,uint8_t cpType,RgSchCmnTbSzEff *effTbl)
{
- uint8_t noResPerRb;
- uint8_t noSymPerRb;
- uint8_t i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t i, j;
switch (cpType)
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmn2LyrCompEff
-(
-uint8_t noPdcchSym,
-uint8_t cpType,
-uint8_t txAntIdx,
-RgSchCmnTbSzEff *effTbl2Lyr
-)
-#else
-static Void rgSCHCmn2LyrCompEff(noPdcchSym, cpType, txAntIdx, effTbl2Lyr)
-uint8_t noPdcchSym;
-uint8_t cpType;
-uint8_t txAntIdx;
-RgSchCmnTbSzEff *effTbl2Lyr;
-#endif
+static Void rgSCHCmn2LyrCompEff(uint8_t noPdcchSym,uint8_t cpType,uint8_t txAntIdx,RgSchCmnTbSzEff *effTbl2Lyr)
{
- uint8_t noResPerRb;
- uint8_t noSymPerRb;
- uint8_t resOfCrs; /* Effective REs occupied by CRS */
- uint8_t i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t resOfCrs; /* Effective REs occupied by CRS */
+ uint8_t i, j;
switch (cpType)
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnGetDciFrmtSizes
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnGetDciFrmtSizes(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnGetDciFrmtSizes(RgSchCellCb *cell)
{
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnGetCqiDciFrmt2AggrLvl
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnGetCqiDciFrmt2AggrLvl(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnGetCqiDciFrmt2AggrLvl(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
uint8_t i;
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlInit
-(
-)
-#else
static Void rgSCHCmnDlInit()
-#endif
{
- uint8_t i;
- S16 j;
- S16 k;
- uint8_t idx;
- RgSchCmnTbSzEff *effTbl;
- RgSchCmnCqiToTbs *tbsTbl;
+ uint8_t i;
+ S16 j;
+ S16 k;
+ uint8_t idx;
+ RgSchCmnTbSzEff *effTbl;
+ RgSchCmnCqiToTbs *tbsTbl;
/* 0 corresponds to Single layer case, 1 corresponds to 2 layers case*/
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnUlInit
-(
-)
-#else
static Void rgSCHCmnUlInit()
-#endif
{
- uint8_t *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
+ uint8_t *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
RgSchCmnTbSzEff *effTbl = &rgSchCmnNorUlEff[0];
const RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
S16 i;
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnInit
-(
-)
-#else
Void rgSCHCmnInit()
-#endif
{
uint8_t idx;
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnDlRlsSubFrm
-(
-RgSchCellCb *cell,
-CmLteTimingInfo frm
-)
-#else
-Void rgSCHCmnDlRlsSubFrm(cell, frm)
-RgSchCellCb *cell;
-CmLteTimingInfo frm;
-#endif
+Void rgSCHCmnDlRlsSubFrm(RgSchCellCb *cell,CmLteTimingInfo frm)
{
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- RgSchDlSf *sf;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ RgSchDlSf *sf;
/* Get the pointer to the subframe */
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchRarAlloc
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnDlCcchRarAlloc(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnDlCcchRarAlloc(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnCcchSduAlloc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ueCb,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static S16 rgSCHCmnCcchSduAlloc(cell, ueCb, allocInfo)
-RgSchCellCb *cell;
-RgSchUeCb *ueCb;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static S16 rgSCHCmnCcchSduAlloc(RgSchCellCb *cell,RgSchUeCb *ueCb,RgSchCmnDlRbAllocInfo *allocInfo)
{
RgSchDlRbAlloc *rbAllocInfo;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
/* Return if subframe BW exhausted */
if (allocInfo->ccchSduAlloc.ccchSduDlSf->bw <=
allocInfo->ccchSduAlloc.ccchSduDlSf->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "bw<=bwAssigned for UEID:%d",ueCb->ueId);
+ DU_LOG("\nERROR --> SCH : bw<=bwAssigned for UEID:%d",ueCb->ueId);
return RFAILED;
}
if (rgSCHDhmGetCcchSduHqProc(ueCb, cellSch->dl.time, &(ueDl->proc)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
+ DU_LOG("\nERROR --> SCH : rgSCHDhmGetCcchSduHqProc failed UEID:%d",ueCb->ueId);
return RFAILED;
}
{
/* Fix : syed Minor failure handling, release hqP if Unsuccessful */
rgSCHDhmRlsHqpTb(ueDl->proc, 0, FALSE);
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
+ DU_LOG("\nERROR --> SCH : rgSCHCmnCcchSduDedAlloc failed UEID:%d",ueCb->ueId);
return RFAILED;
}
cmLListAdd2Tail(&allocInfo->ccchSduAlloc.ccchSduTxLst, &ueDl->proc->reqLnk);
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchSduTx
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchSduTx(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchSduTx(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
- CmLList *node;
- RgSchUeCb *ueCb;
- RgSchCmnDlUe *ueCmnDl;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
-
- RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
+ CmLList *node;
+ RgSchUeCb *ueCb;
+ RgSchCmnDlUe *ueCmnDl;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
node = cell->ccchSduUeLst.first;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"ERROR!! THIS SHOULD "
+ DU_LOG("\nERROR --> SCH : THIS SHOULD "
"NEVER HAPPEN for UEID:%d", ueCb->ueId);
continue;
}
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchTx
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchTx(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchTx(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
- CmLList *node;
- RgSchRaCb *raCb;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
-
+ CmLList *node;
+ RgSchRaCb *raCb;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
node = cell->raInfo.toBeSchdLst.first;
while(node)
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchSduRetx
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchSduRetx(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchSduRetx(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
RgSchDlRbAlloc *rbAllocInfo;
- CmLList *node;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- RgSchUeCb *ueCb;
- RgSchDlHqProcCb *hqP;
- uint8_t retxBw = 0;
- RgSchCmnDlUe *ueDl;
- RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
+ CmLList *node;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ RgSchUeCb *ueCb;
+ RgSchDlHqProcCb *hqP;
+ uint8_t retxBw = 0;
+ RgSchCmnDlUe *ueDl;
+ RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
node = cellSch->dl.ccchSduRetxLst.first;
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchRetx
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchRetx(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchRetx(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
CmLList *node;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchRaCb *raCb;
RgSchDlHqProcCb *hqP;
- uint8_t retxBw = 0;
+ uint8_t retxBw = 0;
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-static Void rgSCHCmnDlBcchPcch
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo,
-RgInfSfAlloc *subfrmAlloc
-)
-#else
-static Void rgSCHCmnDlBcchPcch(cell, allocInfo, subfrmAlloc)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-RgInfSfAlloc *subfrmAlloc;
-#endif
+static Void rgSCHCmnDlBcchPcch(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo,RgInfSfAlloc *subfrmAlloc)
{
CmLteTimingInfo frm;
RgSchDlSf *sf;
#endif/*RGR_SI_SCH*/
-
frm = cell->crntTime;
#ifdef LTEMAC_HDFDD
/* For HDFDD we need scheduling information at least RG_SCH_CMN_DL_DELTA
#if (ERRCLASS & ERRCLS_DEBUG)
if (bch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on BCH is not configured");
+ DU_LOG("\nERROR --> SCH : BCCH on BCH is not configured");
return;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if (bcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
+ DU_LOG("\nERROR --> SCH : BCCH on DLSCH is not configured");
return;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
if (bcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
+ DU_LOG("\nERROR --> SCH : BCCH on DLSCH is not configured");
return;
}
#endif
#ifdef ERRCLS_KW
if (pcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"PCCH on DLSCH is not configured");
+ DU_LOG("\nERROR --> SCH : PCCH on DLSCH is not configured");
return;
}
#endif
* File: rg_sch_cmn.c
*
*/
-#ifdef ANSI
-Bool rgSCHCmnChkInWin
-(
-CmLteTimingInfo frm,
-CmLteTimingInfo start,
-CmLteTimingInfo end
-)
-#else
-Bool rgSCHCmnChkInWin(frm, start, end)
-CmLteTimingInfo frm;
-CmLteTimingInfo start;
-CmLteTimingInfo end;
-#endif
+Bool rgSCHCmnChkInWin(CmLteTimingInfo frm,CmLteTimingInfo start,CmLteTimingInfo end)
{
Bool inWin = FALSE;
* File: rg_sch_cmn.c
*
*/
-#ifdef ANSI
-Bool rgSCHCmnChkPastWin
-(
-CmLteTimingInfo frm,
-CmLteTimingInfo end
-)
-#else
-Bool rgSCHCmnChkPastWin(frm, end)
-CmLteTimingInfo frm;
-CmLteTimingInfo end;
-#endif
+Bool rgSCHCmnChkPastWin(CmLteTimingInfo frm,CmLteTimingInfo end)
{
CmLteTimingInfo refFrm = end;
Bool pastWin;
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnClcAlloc
-(
-RgSchCellCb *cell,
-RgSchDlSf *sf,
-RgSchClcDlLcCb *lch,
-uint16_t rnti,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnClcAlloc(cell, sf, lch, rnti, allocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *sf;
-RgSchClcDlLcCb *lch;
-uint16_t rnti;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnClcAlloc(RgSchCellCb *cell,RgSchDlSf *sf,RgSchClcDlLcCb *lch,uint16_t rnti,RgSchCmnDlRbAllocInfo *allocInfo)
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchClcBoRpt *bo;
* exceeds the available */
if (rb > sf->bw - sf->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"BW allocation "
+ DU_LOG("\nERROR --> SCH : BW allocation "
"failed for CRNTI:%d",rnti);
return;
}
* -# NULLP when unsuccessful
*
**/
-#ifdef ANSI
-RgSchPdcch *rgSCHCmnCmnPdcchAlloc
-(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm
-)
-#else
-RgSchPdcch *rgSCHCmnCmnPdcchAlloc(cell, subFrm)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-#endif
+RgSchPdcch *rgSCHCmnCmnPdcchAlloc(RgSchCellCb *cell,RgSchDlSf *subFrm)
{
CmLteAggrLvl aggrLvl;
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- uint8_t numCce; /*store num CCEs based on
+ uint8_t numCce; /*store num CCEs based on
aggregation level */
aggrLvl = cellSch->dl.cmnChAggrLvl;
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
subFrm->isCceFailure = TRUE;
-
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u",
+ DU_LOG("\nDEBUG --> SCH : PDCCH ERR: NO PDDCH AVAIL IN COMMON SEARCH SPACE aggr:%u",
aggrLvl);
return (NULLP);
}
*
**/
#ifdef LTEMAC_SPS
-#ifdef ANSI
Void rgSCHCmnClcRbAlloc
(
-RgSchCellCb *cell,
-uint32_t bo,
-uint8_t cqi,
-uint8_t *rb,
-uint32_t *tbs,
-uint8_t *mcs,
-uint8_t *iTbs,
-Bool isSpsBo,
-RgSchDlSf *sf
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
+uint8_t *iTbs,
+Bool isSpsBo,
+RgSchDlSf *sf
)
#else
-Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
-RgSchCellCb *cell;
-uint32_t bo;
-uint8_t cqi;
-uint8_t *rb;
-uint32_t *tbs;
-uint8_t *mcs;
-uint8_t *iTbs;
-Bool isSpsBo;
-RgSchDlSf *sf;
-#endif
-#else
-#ifdef ANSI
static Void rgSCHCmnClcRbAlloc
(
-RgSchCellCb *cell,
-uint32_t bo,
-uint8_t cqi,
-uint8_t *rb,
-uint32_t *tbs,
-uint8_t *mcs,
-RgSchDlSf *sf
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
+RgSchDlSf *sf
)
-#else
-static Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, sf)
-RgSchCellCb *cell;
-uint32_t bo;
-uint8_t cqi;
-uint8_t *rb;
-uint32_t *tbs;
-uint8_t *mcs;
-RgSchDlSf *sf;
-#endif
#endif /* LTEMAC_SPS */
{
- uint8_t iTbsVal;
- RgSchCmnTbSzEff *effTbl;
- uint32_t eff;
- uint32_t noRes;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- uint8_t cfi = cellSch->dl.currCfi;
- uint32_t tmpRb=0;
+ uint8_t iTbsVal;
+ RgSchCmnTbSzEff *effTbl;
+ uint32_t eff;
+ uint32_t noRes;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint32_t tmpRb=0;
/* first get the CQI to MCS table and determine the number of RBs */
effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnMsg4Alloc
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static S16 rgSCHCmnMsg4Alloc(cell, raCb, allocInfo)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static S16 rgSCHCmnMsg4Alloc(RgSchCellCb *cell,RgSchRaCb *raCb,RgSchCmnDlRbAllocInfo *allocInfo)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- /* SR_RACH_STATS : MSG4 TO BE TXED */
+ /* SR_RACH_STATS : MSG4 TO BE TXED */
rgNumMsg4ToBeTx++;
/* Return if subframe BW exhausted */
if (allocInfo->msg4Alloc.msg4DlSf->bw <=
allocInfo->msg4Alloc.msg4DlSf->bwAssigned)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId ,
- "bw<=bwAssigned");
+ DU_LOG("\nERROR --> SCH : bw<=bwAssigned");
return RFAILED;
}
if (rgSCHDhmGetMsg4HqProc(raCb, cellSch->dl.time) != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHDhmGetMsg4HqProc failed");
+ DU_LOG("\nERROR --> SCH : rgSCHDhmGetMsg4HqProc failed");
return RFAILED;
}
{
/* Fix : syed Minor failure handling, release hqP if Unsuccessful */
rgSCHDhmRlsHqpTb(raCb->dlHqE->msg4Proc, 0, FALSE);
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnMsg4DedAlloc failed.");
+ DU_LOG("\nERROR --> SCH : rgSCHCmnMsg4DedAlloc failed.");
return RFAILED;
}
cmLListAdd2Tail(&allocInfo->msg4Alloc.msg4TxLst, &raCb->dlHqE->msg4Proc->reqLnk);
* -# NULLP when unsuccessful
*
**/
-#ifdef ANSI
-RgSchPdcch *rgSCHCmnPdcchAlloc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchDlSf *subFrm,
-uint8_t cqi,
-TfuDciFormat dciFrmt,
-Bool isDtx
-)
-#else
-RgSchPdcch *rgSCHCmnPdcchAlloc(cell, subFrm, cqi, dciFrmt, isDtx)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlSf *subFrm;
-uint8_t cqi;
-TfuDciFormat dciFrmt;
-Bool isDtx;
-#endif
+RgSchPdcch *rgSCHCmnPdcchAlloc(RgSchCellCb *cell,RgSchUeCb *ue,RgSchDlSf *subFrm,uint8_t cqi,TfuDciFormat dciFrmt,Bool isDtx)
{
CmLteAggrLvl aggrLvl;
RgSchPdcchInfo *pdcchInfo;
{
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
subFrm->isCceFailure = TRUE;
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
+ DU_LOG("\nDEBUG --> SCH : PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
return (NULLP);
/* PDCCH Allocation Failed, Mark cceFailure flag as TRUE */
subFrm->isCceFailure = TRUE;
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
+ DU_LOG("\nDEBUG --> SCH : PDCCH ERR: NO PDDCH AVAIL IN UE SEARCH SPACE :aggr(%u)",
aggrLvl);
return (NULLP);
}
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnCcchSduDedAlloc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ueCb
-)
-#else
-static S16 rgSCHCmnCcchSduDedAlloc(cell, ueCb)
-RgSchCellCb *cell;
-RgSchUeCb *ueCb;
-#endif
+static S16 rgSCHCmnCcchSduDedAlloc(RgSchCellCb *cell,RgSchUeCb *ueCb)
{
- RgSchDlHqEnt *hqE = NULLP;
- uint32_t effBo;
- RgSchDlRbAlloc *rbAllocinfo = NULLP;
- RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- uint8_t iTbs;
- uint8_t numRb;
+ RgSchDlHqEnt *hqE = NULLP;
+ uint32_t effBo;
+ RgSchDlRbAlloc *rbAllocinfo = NULLP;
+ RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
+ uint8_t iTbs;
+ uint8_t numRb;
#ifdef LTE_TDD
- uint8_t cfi = cellDl->currCfi;
+ uint8_t cfi = cellDl->currCfi;
#endif
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnMsg4DedAlloc
-(
-RgSchCellCb *cell,
-RgSchRaCb *raCb
-)
-#else
-static S16 rgSCHCmnMsg4DedAlloc(cell, raCb)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-#endif
+static S16 rgSCHCmnMsg4DedAlloc(RgSchCellCb *cell,RgSchRaCb *raCb)
{
- uint32_t effBo;
- RgSchDlRbAlloc *rbAllocinfo = &raCb->rbAllocInfo;
- uint8_t iTbs;
- uint8_t numRb;
+ uint32_t effBo;
+ RgSchDlRbAlloc *rbAllocinfo = &raCb->rbAllocInfo;
+ uint8_t iTbs;
+ uint8_t numRb;
#ifdef LTE_TDD
- RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- uint8_t cfi = cellDl->currCfi;
+ RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
+ uint8_t cfi = cellDl->currCfi;
#endif
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlRaRsp
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlRaRsp(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlRaRsp(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
CmLteTimingInfo frm;
CmLteTimingInfo schFrm;
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlRaRsp //FDD
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlRaRsp(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlRaRsp(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
- CmLteTimingInfo frm;
- CmLteTimingInfo winStartFrm;
- RgSchDlSf *subFrm;
- uint8_t winStartIdx;
- uint8_t winGap;
- uint8_t rarnti;
- uint8_t raIdx;
- RgSchCmnCell *sched;
- uint8_t i,noRaRnti=0;
+ CmLteTimingInfo frm;
+ CmLteTimingInfo winStartFrm;
+ RgSchDlSf *subFrm;
+ uint8_t winStartIdx;
+ uint8_t winGap;
+ uint8_t rarnti;
+ uint8_t raIdx;
+ RgSchCmnCell *sched;
+ uint8_t i,noRaRnti=0;
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnRaRspAlloc
-(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-uint16_t raIndex,
-uint16_t rarnti,
-uint8_t noRaRnti,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static S16 rgSCHCmnRaRspAlloc(cell,subFrm,raIndex,rarnti,noRaRnti,allocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-uint16_t raIndex;
-uint16_t rarnti;
-uint8_t noRaRnti;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static S16 rgSCHCmnRaRspAlloc(RgSchCellCb *cell,RgSchDlSf *subFrm,uint16_t raIndex,uint16_t rarnti,uint8_t noRaRnti,RgSchCmnDlRbAllocInfo *allocInfo)
{
- RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- uint16_t noBytes;
- uint32_t rb = 0;
- uint32_t tbs;
+ RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
+ RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
+ uint16_t noBytes;
+ uint32_t rb = 0;
+ uint32_t tbs;
/*ccpu00116700,ccpu00116708- Corrected the wrong type for mcs*/
- uint8_t mcs;
- CmLListCp *reqLst;
+ uint8_t mcs;
+ CmLListCp *reqLst;
/* RACH handling related changes */
- Bool isAlloc = FALSE;
- static uint8_t schdNumRapid = 0;
- uint8_t remNumRapid = 0;
- uint8_t nPrb = 0;
- S32 allwdTbSz = 0;
+ Bool isAlloc = FALSE;
+ static uint8_t schdNumRapid = 0;
+ uint8_t remNumRapid = 0;
+ uint8_t nPrb = 0;
+ S32 allwdTbSz = 0;
#ifdef LTE_TDD
- uint16_t lostRe;
- uint8_t cfi = cellDl->currCfi;
+ uint16_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
#ifndef RGR_V1
if (subFrm->bw == subFrm->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "bw == bwAssigned RARNTI:%d",rarnti);
+ DU_LOG("\nERROR --> SCH : bw == bwAssigned RARNTI:%d",rarnti);
return RFAILED;
}
reqLst = &cell->raInfo.raReqLst[raIndex];
if (reqLst->count == 0)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "reqLst Count=0 RARNTI:%d",rarnti);
+ DU_LOG("\nERROR --> SCH : reqLst Count=0 RARNTI:%d",rarnti);
return RFAILED;
}
remNumRapid = reqLst->count;
/* Allocation succeeded for 'remNumRapid' */
isAlloc = TRUE;
tbs = allwdTbSz/8;
- printf("\n!!!RAR alloc noBytes:%u,allwdTbSz:%u,tbs:%u,rb:%u\n",
+ DU_LOG("\nINFO --> SCH : RAR alloc noBytes:%u,allwdTbSz:%u,tbs:%u,rb:%u\n",
noBytes,allwdTbSz,tbs,rb);
break;
}
if (!isAlloc)
{
- RLOG_ARG0(L_INFO,DBG_CELLID,cell->cellId,"BW alloc Failed");
+ DU_LOG("\nERROR --> SCH : BW alloc Failed");
return RFAILED;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlAllocFillRbInfo
-(
-RgSchCellCb *cell,
-RgSchUlSf *sf,
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHCmnUlAllocFillRbInfo(RgSchCellCb *cell,RgSchUlSf *sf,RgSchUlAlloc *alloc)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
* @param[out] uint8_t *hqProcIdRef
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnMsg3GrntReq
(
RgSchCellCb *cell,
Bool preamGrpA,
RgSchUlHqProcCb *hqProc,
RgSchUlAlloc **ulAllocRef,
-uint8_t *hqProcIdRef
+uint8_t *hqProcIdRef
)
-#else
-static Void rgSCHCmnMsg3GrntReq(cell, rnti, preamGrpA, hqProc,
- ulAllocRef, hqProcIdRef)
-RgSchCellCb *cell;
-CmLteRnti rnti;
-Bool preamGrpA;
-RgSchUlHqProcCb *hqProc;
-RgSchUlAlloc **ulAllocRef;
-uint8_t *hqProcIdRef;
-#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
RgSchUlHole *hole;
RgSchUlAlloc *alloc;
- uint8_t iMcs;
- uint8_t numSb;
+ uint8_t iMcs;
+ uint8_t numSb;
*ulAllocRef = NULLP;
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Error! holeDb sanity check failed RNTI:%d",rnti);
+ DU_LOG("\nERROR --> SCH : holeDb sanity check failed RNTI:%d",rnti);
}
}
if (numSb <= hole->num)
alloc->forMsg3 = TRUE;
alloc->hqProc = hqProc;
rgSCHUhmNewTx(hqProc, (uint8_t)(cell->rachCfg.maxMsg3Tx - 1), alloc);
- //RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
- printf(
- "\nRNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
+ DU_LOG("\nDEBUG --> SCH : RNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
alloc->rnti,
((PTR)alloc->hqProc),
alloc->hqProc->procId,
alloc->hqProc->ulSfIdx);
- RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
- "alloc(%p)maxMsg3Tx(%d)",
- ((PTR)alloc),
+ DU_LOG("\nDEBUG --> SCH : alloc(%p)maxMsg3Tx(%d)",
+ ((void *)alloc),
cell->rachCfg.maxMsg3Tx);
}
}
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlSetUeAllocLmt
-(
-RgSchCellCb *cell,
-RgSchCmnDlUe *ueDl,
-Bool isEmtcUe
-)
-#else
-static Void rgSCHCmnDlSetUeAllocLmt(cell, ueDl, isEmtcUe)
-RgSchCellCb *cell;
-RgSchCmnDlUe *ueDl;
-Bool isEmtcUe;
-#endif
+static Void rgSCHCmnDlSetUeAllocLmt(RgSchCellCb *cell,RgSchCmnDlUe *ueDl,Bool isEmtcUe)
{
- uint8_t modOrder;
- uint32_t maxRb;
+ uint8_t modOrder;
+ uint32_t maxRb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t cfi = cellSch->dl.currCfi;
#ifdef EMTC_ENABLE
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCheckAndSetTxScheme
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCheckAndSetTxScheme(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCheckAndSetTxScheme(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue ,cell);
- uint8_t cfi = cellSch->dl.currCfi;
- uint8_t maxiTbs;
- uint8_t cqiBasediTbs;
- uint8_t actualiTbs;
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs;
+ uint8_t cqiBasediTbs;
+ uint8_t actualiTbs;
maxiTbs = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnDlSetUeAllocLmtLa
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnDlSetUeAllocLmtLa(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnDlSetUeAllocLmtLa(RgSchCellCb *cell,RgSchUeCb *ue)
{
- uint8_t modOrder;
- uint32_t maxRb;
- uint8_t reportediTbs;
+ uint8_t modOrder;
+ uint32_t maxRb;
+ uint8_t reportediTbs;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- uint8_t cfi = cellSch->dl.currCfi;
- uint8_t maxiTbs;
- uint8_t cwIdx = 0;
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs;
+ uint8_t cwIdx = 0;
maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
#ifdef RG_5GTF
ue->ue5gtfCb.mcs = ueDl->mimoInfo.cwInfo[cwIdx].iTbs[0];
/*
- printf("reportediTbs[%d] cqiBasediTbs[%d] deltaiTbs[%d] iTbsNew[%d] mcs[%d] cwIdx[%d]\n",
+ DU_LOG("\nINFO --> SCH : reportediTbs[%d] cqiBasediTbs[%d] deltaiTbs[%d] iTbsNew[%d] mcs[%d] cwIdx[%d]\n",
reportediTbs, ueDl->laCb[cwIdx].cqiBasediTbs, ueDl->laCb[cwIdx].deltaiTbs,
iTbsNew, ue->ue5gtfCb.mcs, cwIdx);
*/
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnDlHqPResetTemp
-(
-RgSchDlHqProcCb *hqP
-)
-#else
-Void rgSCHCmnDlHqPResetTemp(hqP)
-RgSchDlHqProcCb *hqP;
-#endif
+Void rgSCHCmnDlHqPResetTemp(RgSchDlHqProcCb *hqP)
{
-
/* Fix: syed having a hqP added to Lists for RB assignment rather than
* a UE, as adding UE was limiting handling some scenarios */
hqP->reqLnk.node = (PTR)NULLP;
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnDlUeResetTemp
-(
-RgSchUeCb *ue,
-RgSchDlHqProcCb *hqP
-)
-#else
-Void rgSCHCmnDlUeResetTemp(ue, hqP)
-RgSchUeCb *ue;
-RgSchDlHqProcCb *hqP;
-#endif
+Void rgSCHCmnDlUeResetTemp(RgSchUeCb *ue,RgSchDlHqProcCb *hqP)
{
RgSchDlRbAlloc *allocInfo;
- RgSchCmnDlUe *cmnUe = RG_SCH_CMN_GET_DL_UE(ue,hqP->hqE->cell);
+ RgSchCmnDlUe *cmnUe = RG_SCH_CMN_GET_DL_UE(ue,hqP->hqE->cell);
#ifdef LTE_ADV
Void *tmpCb;
#endif
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlUeResetTemp
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUlUeResetTemp(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUlUeResetTemp(RgSchCellCb *cell,RgSchUeCb *ue)
{
- RgSchCmnUlUe *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
-
+ RgSchCmnUlUe *cmnUlUe = RG_SCH_CMN_GET_UL_UE(ue,cell);
memset(&cmnUlUe->alloc, 0, sizeof(cmnUlUe->alloc));
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnFillPdcch
-(
-RgSchCellCb *cell,
-RgSchPdcch *pdcch,
-RgSchDlRbAlloc *rbAllocInfo
-)
-#else
-Void rgSCHCmnFillPdcch(cell, pdcch, rbAllocInfo)
-RgSchCellCb *cell;
-RgSchPdcch *pdcch;
-RgSchDlRbAlloc *rbAllocInfo;
-#endif
+Void rgSCHCmnFillPdcch(RgSchCellCb *cell,RgSchPdcch *pdcch,RgSchDlRbAlloc *rbAllocInfo)
{
-
/* common channel pdcch filling,
* only 1A and Local is supported */
pdcch->rnti = rbAllocInfo->rnti;
case TFU_DCI_FORMAT_B2:
{
- //printf(" RG_5GTF:: Pdcch filling with DCI format B2\n");
+ //DU_LOG("\nINFO --> SCH : RG_5GTF:: Pdcch filling with DCI format B2\n");
/* ToDo: Anoop */
break; /* case TFU_DCI_FORMAT_B2: */
}
#endif
break;
default:
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Allocator's icorrect "
+ DU_LOG("\nERROR --> SCH : Allocator's icorrect "
"dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
break;
}
* @return Bool
*
**/
-#ifdef ANSI
-static Bool rgSCHCmnIsSplSubfrm
-(
-uint8_t splfrmCnt,
-uint8_t curSubfrmIdx,
-uint8_t periodicity,
-RgSchTddSubfrmInfo *subfrmInfo
-)
-#else
-static Bool rgSCHCmnIsSplSubfrm(splfrmCnt, curSubfrmIdx, periodicity, subfrmInfo)
-uint8_t splfrmCnt;
-uint8_t curSubfrmIdx;
-uint8_t periodicity;
-RgSchTddSubfrmInfo *subfrmInfo;
-#endif
+static Bool rgSCHCmnIsSplSubfrm(uint8_t splfrmCnt,uint8_t curSubfrmIdx,uint8_t periodicity,RgSchTddSubfrmInfo *subfrmInfo)
{
uint8_t dlSfCnt = 0;
uint8_t splfrmIdx = 0;
-
if(splfrmCnt > 0)
{
if(periodicity == RG_SCH_CMN_5_MS_PRD)
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnUpdHqAndDai
-(
-RgSchDlHqProcCb *hqP,
-RgSchDlSf *subFrm,
-RgSchDlHqTbCb *tbCb,
-uint8_t tbAllocIdx
-)
-#else
-static Void rgSCHCmnUpdHqAndDai(hqP, subFrm, tbCb,tbAllocIdx)
-RgSchDlHqProcCb *hqP;
-RgSchDlSf *subFrm;
-RgSchDlHqTbCb *tbCb;
-uint8_t tbAllocIdx;
-#endif
+static Void rgSCHCmnUpdHqAndDai(RgSchDlHqProcCb *hqP,RgSchDlSf *subFrm,RgSchDlHqTbCb *tbCb,uint8_t tbAllocIdx)
{
RgSchUeCb *ue = hqP->hqE->ue;
* @return uint8_t dlDai
*
**/
-#ifdef ANSI
uint8_t rgSCHCmnUpdDai
(
-RgSchUeCb *ue,
-CmLteTimingInfo *fdbkTime,
-uint8_t m,
-Bool havePdcch,
-RgSchDlHqProcCb *hqP,
-uint8_t *ulDai
+RgSchUeCb *ue,
+CmLteTimingInfo *fdbkTime,
+uint8_t m,
+Bool havePdcch,
+RgSchDlHqProcCb *hqP,
+uint8_t *ulDai
)
-#else
-uint8_t rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
-RgSchUeCb *ue;
-CmLteTimingInfo *fdbkTime;
-uint8_t m;
-Bool havePdcch;
-RgSchDlHqProcCb *hqP;
-uint8_t *ulDai;
-#endif
{
RgSchTddANInfo *anInfo;
- uint8_t servCellIdx;
- uint8_t ackNackFdbkArrSize;
-
-
+ uint8_t servCellIdx;
+ uint8_t ackNackFdbkArrSize;
if(hqP != NULLP)
{/* Non SPS */
*
**/
#ifdef LTEMAC_SPS
-#ifdef ANSI
Void rgSCHCmnFillHqPTb
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-uint8_t tbAllocIdx,
-RgSchPdcch *pdcch
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+uint8_t tbAllocIdx,
+RgSchPdcch *pdcch
)
#else
-Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-uint8_t tbAllocIdx;
-RgSchPdcch *pdcch;
-#endif
-#else
-#ifdef ANSI
static Void rgSCHCmnFillHqPTb
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-uint8_t tbAllocIdx,
-RgSchPdcch *pdcch
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+uint8_t tbAllocIdx,
+RgSchPdcch *pdcch
)
-#else
-static Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-uint8_t tbAllocIdx;
-RgSchPdcch *pdcch;
-#endif
#endif /* LTEMAC_SPS */
{
RgSchCmnDlCell *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnFillHqPPdcchDciFrmtB1B2
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-uint8_t tpc
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+uint8_t tpc
)
-#else
-static Void rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, pdcch, tpc)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-RgSchDlHqProcCb *hqP;
-RgSchPdcch *pdcch;
-uint8_t tpc;
-#endif
{
rgSCHCmnFillHqPTb(cell, rbAllocInfo, 0, pdcch);
//Currently hardcoding values here.
- //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
+ //DU_LOG("\nINFO --> SCH : Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
switch(rbAllocInfo->dciFormat)
{
case TFU_DCI_FORMAT_B1:
break;
}
default:
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId," 5GTF_ERROR Allocator's icorrect "
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR Allocator's incorrect "
"dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
break;
}
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnFillHqPPdcch
-(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP
-)
-#else
-Void rgSCHCmnFillHqPPdcch(cell, rbAllocInfo, hqP)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-RgSchDlHqProcCb *hqP;
-#endif
+Void rgSCHCmnFillHqPPdcch(RgSchCellCb *cell,RgSchDlRbAlloc *rbAllocInfo,RgSchDlHqProcCb *hqP)
{
- RgSchCmnDlCell *cmnCell = RG_SCH_CMN_GET_DL_CELL(cell);
- RgSchPdcch *pdcch = rbAllocInfo->pdcch;
- uint8_t tpc = 1;
+ RgSchCmnDlCell *cmnCell = RG_SCH_CMN_GET_DL_CELL(cell);
+ RgSchPdcch *pdcch = rbAllocInfo->pdcch;
+ uint8_t tpc = 1;
if (hqP->hqE->ue)
addedForScell += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
addedForScell1 += (rbAllocInfo->tbInfo[0].bytesAlloc << 3);
/*
- printf (" Hqp %d cell %d addedForScell %lu addedForScell1 %lu sfn:sf %d:%d \n",
+ DU_LOG("\nINFO --> SCH : Hqp %d cell %d addedForScell %lu addedForScell1 %lu sfn:sf %d:%d \n",
hqP->procId,
hqP->hqE->cell->cellId,
addedForScell,
addedForScell += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
addedForScell2 += (rbAllocInfo->tbInfo[1].bytesAlloc << 3);
/*
- printf (" Hqp %d cell %d addedForScell %lu addedForScell2 %lu \n",
+ DU_LOG("\nINFO --> SCH : Hqp %d cell %d addedForScell %lu addedForScell2 %lu \n",
hqP->procId,
hqP->hqE->cell->cellId,
addedForScell,
(rbAllocInfo->tbInfo[1].bytesAlloc << 3);
}
/*
- printf ("add DL TPT is %lu sfn:sf %d:%d \n", hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt ,
+ DU_LOG("\nINFO --> SCH : add DL TPT is %lu sfn:sf %d:%d \n", hqP->hqE->ue->tenbStats->stats.nonPersistent.sch[RG_SCH_CELLINDEX(hqP->hqE->cell)].dlTpt ,
cell->crntTime.sfn,
cell->crntTime.slot);
*/
case TFU_DCI_FORMAT_B1:
case TFU_DCI_FORMAT_B2:
{
- // printf(" RG_5GTF:: Pdcch filling with DCI format B1/B2\n");
+ // DU_LOG("\nINFO --> SCH : RG_5GTF:: Pdcch filling with DCI format B1/B2\n");
rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, \
pdcch, tpc);
break;
}
#endif
default:
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
break;
}
return;
*
**/
-#ifdef ANSI
static Void rgSCHCmnFillHqPPdcchDciFrmt1
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-uint8_t tpc
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+uint8_t tpc
)
-#else
-static Void rgSCHCmnFillHqPPdcchDciFrmt1(cell, rbAllocInfo, hqP, pdcch, tpc)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-RgSchDlHqProcCb *hqP;
-RgSchPdcch *pdcch;
-uint8_t tpc;
-#endif
{
#ifdef LTE_TDD
- RgSchTddANInfo *anInfo;
+ RgSchTddANInfo *anInfo;
#endif
#ifdef LTEMAC_SPS
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnFillHqPPdcchDciFrmt1A
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-uint8_t tpc
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+uint8_t tpc
)
-#else
-static Void rgSCHCmnFillHqPPdcchDciFrmt1A(cell, rbAllocInfo, hqP, pdcch, tpc)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-RgSchDlHqProcCb *hqP;
-RgSchPdcch *pdcch;
-uint8_t tpc;
-#endif
{
#ifdef LTE_TDD
{
/* Fixing DAI value - ccpu00109162 */
pdcch->dci.u.format1aInfo.t.pdschInfo.dai.val = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnFillHqPPdcchDciFrmt1B
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-uint8_t tpc
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+uint8_t tpc
)
-#else
-static Void rgSCHCmnFillHqPPdcchDciFrmt1B(cell, rbAllocInfo, hqP, pdcch, tpc)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-RgSchDlHqProcCb *hqP;
-RgSchPdcch *pdcch;
-uint8_t tpc;
-#endif
{
#ifdef LTE_TDD
else
{
pdcch->dci.u.format1bInfo.dai = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnFillHqPPdcchDciFrmt2
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-uint8_t tpc
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+uint8_t tpc
)
-#else
-static Void rgSCHCmnFillHqPPdcchDciFrmt2(cell, rbAllocInfo, hqP, pdcch, tpc)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-RgSchDlHqProcCb *hqP;
-RgSchPdcch *pdcch;
-uint8_t tpc;
-#endif
{
#ifdef LTE_TDD
else
{
pdcch->dci.u.format2Info.dai = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnFillHqPPdcchDciFrmt2A
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *rbAllocInfo,
-RgSchDlHqProcCb *hqP,
-RgSchPdcch *pdcch,
-uint8_t tpc
+RgSchCellCb *cell,
+RgSchDlRbAlloc *rbAllocInfo,
+RgSchDlHqProcCb *hqP,
+RgSchPdcch *pdcch,
+uint8_t tpc
)
-#else
-static Void rgSCHCmnFillHqPPdcchDciFrmt2A(cell, rbAllocInfo, hqP, pdcch, tpc)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *rbAllocInfo;
-RgSchDlHqProcCb *hqP;
-RgSchPdcch *pdcch;
-uint8_t tpc;
-#endif
{
#ifdef LTE_TDD
RgSchTddANInfo *anInfo;
else
{
pdcch->dci.u.format2AInfo.dai = RG_SCH_MAX_DAI_IDX;
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "PDCCH is been scheduled without updating anInfo RNTI:%d",
+ DU_LOG("\nERROR --> SCH : PDCCH is been scheduled without updating anInfo RNTI:%d",
rbAllocInfo->rnti);
}
#endif
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnInitVars
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnInitVars(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnInitVars(RgSchCellCb *cell)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnUpdVars
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnUpdVars(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnUpdVars(RgSchCellCb *cell)
{
CmLteTimingInfo timeInfo;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
cellUl->idx = ((idx) % (RG_SCH_CMN_UL_NUM_SF));
#ifdef UL_ADPT_DBG
- printf("idx %d cellUl->idx %d RGSCH_NUM_SUB_FRAMES_5G %d time(%d %d) \n",idx,cellUl->idx ,RGSCH_NUM_SUB_FRAMES_5G,cell->crntTime.sfn,cell->crntTime.slot);
+ DU_LOG("\nDEBUG --> SCH : idx %d cellUl->idx %d RGSCH_NUM_SUB_FRAMES_5G %d time(%d %d) \n",idx,cellUl->idx ,RGSCH_NUM_SUB_FRAMES_5G,cell->crntTime.sfn,cell->crntTime.slot);
#endif
/* Need to scheduler for after SCHED_DELTA */
/* UL allocation has been advanced by 1 subframe
/* take care of getting the correct subframe for feedback */
idx = (cellUl->idx - TFU_CRCIND_ULDELTA + RG_SCH_CMN_UL_NUM_SF);
#ifdef UL_ADPT_DBG
- printf("Finally setting cellUl->hqFdbkIdx[0] = %d TFU_CRCIND_ULDELTA %d RG_SCH_CMN_UL_NUM_SF %d\n",idx,TFU_CRCIND_ULDELTA,RG_SCH_CMN_UL_NUM_SF);
+ DU_LOG("\nDEBUG --> SCH : Finally setting cellUl->hqFdbkIdx[0] = %d TFU_CRCIND_ULDELTA %d RG_SCH_CMN_UL_NUM_SF %d\n",idx,TFU_CRCIND_ULDELTA,RG_SCH_CMN_UL_NUM_SF);
#endif
cellUl->hqFdbkIdx[0] = (idx % (RG_SCH_CMN_UL_NUM_SF));
cellUl->reTxIdx[0] = (uint8_t) idx;
#ifdef UL_ADPT_DBG
- printf("cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
+ DU_LOG("\nDEBUG --> SCH : cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
#endif
/* RACHO: update cmn sched specific RACH variables,
* mainly the prachMaskIndex */
* @return uint8_t
*
**/
-#ifdef ANSI
-uint8_t rgSCHCmnGetPhichUlSfIdx
-(
-CmLteTimingInfo *timeInfo,
-RgSchCellCb *cell
-)
-#else
-uint8_t rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
-CmLteTimingInfo *timeInfo;
-RgSchCellCb *cell;
-#endif
+uint8_t rgSCHCmnGetPhichUlSfIdx(CmLteTimingInfo *timeInfo,RgSchCellCb *cell)
{
- RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- RgSchDlSf *dlsf;
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
- uint8_t idx;
- uint16_t numUlSf;
- uint16_t sfn;
- uint8_t subframe;
+ RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
+ RgSchDlSf *dlsf;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t idx;
+ uint16_t numUlSf;
+ uint16_t sfn;
+ uint8_t subframe;
dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
* @return uint8_t
*
**/
-#ifdef ANSI
-uint8_t rgSCHCmnGetUlSfIdx
-(
-CmLteTimingInfo *timeInfo,
-RgSchCellCb *cell
-)
-#else
-uint8_t rgSCHCmnGetUlSfIdx(timeInfo, cell)
-CmLteTimingInfo *timeInfo;
-RgSchCellCb *cell;
-#endif
+uint8_t rgSCHCmnGetUlSfIdx(CmLteTimingInfo *timeInfo,RgSchCellCb *cell)
{
- RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
- uint8_t idx = 0;
- uint16_t numUlSf;
+ RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t idx = 0;
+ uint16_t numUlSf;
/* ccpu00130980: numUlSf(uint16_t) parameter added to avoid integer
* @return uint8_t
*
**/
-#ifdef ANSI
-uint8_t rgSCHCmnGetUlHqProcIdx
-(
-CmLteTimingInfo *timeInfo,
-RgSchCellCb *cell
-)
-#else
-uint8_t rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
-CmLteTimingInfo *timeInfo;
-RgSchCellCb *cell;
-#endif
+uint8_t rgSCHCmnGetUlHqProcIdx(CmLteTimingInfo *timeInfo,RgSchCellCb *cell)
{
- uint8_t procId;
- uint32_t numUlSf;
+ uint8_t procId;
+ uint32_t numUlSf;
#ifndef LTE_TDD
numUlSf = (timeInfo->sfn * RGSCH_NUM_SUB_FRAMES_5G + timeInfo->slot);
procId = numUlSf % RGSCH_NUM_UL_HQ_PROC;
#else
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
/*ccpu00130639 - MOD - To get correct UL HARQ Proc IDs for all UL/DL Configs*/
- uint8_t numUlSfInSfn;
- S8 sfnCycle = cell->tddHqSfnCycle;
- uint8_t numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
+ uint8_t numUlSfInSfn;
+ S8 sfnCycle = cell->tddHqSfnCycle;
+ uint8_t numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
/* TRACE 5 Changes */
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlFreeAlloc
-(
-RgSchCellCb *cell,
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHCmnUlFreeAlloc(cell, alloc)
-RgSchCellCb *cell;
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHCmnUlFreeAlloc(RgSchCellCb *cell,RgSchUlAlloc *alloc)
{
RgSchUlHqProcCb *hqProc;
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlFreeAllocation
-(
-RgSchCellCb *cell,
-RgSchUlSf *sf,
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHCmnUlFreeAllocation(cell, sf, alloc)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHCmnUlFreeAllocation(RgSchCellCb *cell,RgSchUlSf *sf,RgSchUlAlloc *alloc)
{
RgSchUlHqProcCb *hqProc;
* @return RgSchPdcch *
* -# NULLP when unsuccessful
**/
-#ifdef ANSI
-RgSchPdcch *rgSCHCmnPdcchAllocCrntSf
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+RgSchPdcch *rgSCHCmnPdcchAllocCrntSf(RgSchCellCb *cell,RgSchUeCb *ue)
{
- CmLteTimingInfo frm = cell->crntTime;
- RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- RgSchDlSf *sf;
- RgSchPdcch *pdcch = NULLP;
+ CmLteTimingInfo frm = cell->crntTime;
+ RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
+ RgSchDlSf *sf;
+ RgSchPdcch *pdcch = NULLP;
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlAllocFillNdmrs
-(
-RgSchCmnUlCell *cellUl,
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHCmnUlAllocFillNdmrs(cellUl, alloc)
-RgSchCmnUlCell *cellUl;
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHCmnUlAllocFillNdmrs(RgSchCmnUlCell *cellUl,RgSchUlAlloc *alloc)
{
alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
return;
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlAllocLnkHqProc
-(
-RgSchUeCb *ue,
-RgSchUlAlloc *alloc,
-RgSchUlHqProcCb *proc,
-Bool isRetx
-)
-#else
-Void rgSCHCmnUlAllocLnkHqProc(ue, alloc, proc, isRetx)
-RgSchUeCb *ue;
-RgSchUlAlloc *alloc;
-RgSchUlHqProcCb *proc;
-Bool isRetx;
-#endif
+Void rgSCHCmnUlAllocLnkHqProc(RgSchUeCb *ue,RgSchUlAlloc *alloc,RgSchUlHqProcCb *proc,Bool isRetx)
{
if(TRUE == isRetx)
* @param[in] RgSchPdcch *pdcch
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnPdcchRlsCrntSf
-(
-RgSchCellCb *cell,
-RgSchPdcch *pdcch
-)
-#else
-Void rgSCHCmnPdcchRlsCrntSf(cell, pdcch)
-RgSchCellCb *cell;
-RgSchPdcch *pdcch;
-#endif
+Void rgSCHCmnPdcchRlsCrntSf(RgSchCellCb *cell,RgSchPdcch *pdcch)
{
- CmLteTimingInfo frm = cell->crntTime;
- RgSchDlSf *sf;
-
+ CmLteTimingInfo frm = cell->crntTime;
+ RgSchDlSf *sf;
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlFillPdcchWithAlloc
-(
-RgSchPdcch *pdcch,
-RgSchUlAlloc *alloc,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUlFillPdcchWithAlloc(pdcch, alloc, ue)
-RgSchPdcch *pdcch;
-RgSchUlAlloc *alloc;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUlFillPdcchWithAlloc(RgSchPdcch *pdcch,RgSchUlAlloc *alloc,RgSchUeCb *ue)
{
-
pdcch->ue = ue;
pdcch->rnti = alloc->rnti;
//pdcch->dci.dciFormat = TFU_DCI_FORMAT_A2;
pdcch->dci.dciFormat = alloc->grnt.dciFrmt;
//Currently hardcoding values here.
- //printf("Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
+ //DU_LOG("\nINFO --> SCH : Filling 5GTF UL DCI for rnti %d \n",alloc->rnti);
switch(pdcch->dci.dciFormat)
{
case TFU_DCI_FORMAT_A1:
break;
}
default:
- RLOG1(L_ERROR," 5GTF_ERROR UL Allocator's icorrect "
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR UL Allocator's icorrect "
"dciForamt Fill RNTI:%d",alloc->rnti);
break;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlAllocFillTpc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchUlAlloc *alloc
-)
-#else
-Void rgSCHCmnUlAllocFillTpc(cell, ue, alloc)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchUlAlloc *alloc;
-#endif
+Void rgSCHCmnUlAllocFillTpc(RgSchCellCb *cell,RgSchUeCb *ue,RgSchUlAlloc *alloc)
{
alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
return;
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnAddUeToRefreshQ
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint32_t wait
-)
-#else
-static Void rgSCHCmnAddUeToRefreshQ(cell, ue, wait)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint32_t wait;
-#endif
+static Void rgSCHCmnAddUeToRefreshQ(RgSchCellCb *cell,RgSchUeCb *ue,uint32_t wait)
{
RgSchCmnCell *sched = RG_SCH_CMN_GET_CELL(cell);
CmTmrArg arg;
* @param[in] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlUeReset
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnUlUeReset(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnUlUeReset(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- uint8_t lcgCnt=0;
+ uint8_t lcgCnt=0;
RgSchCmnLcg *lcgCmn;
CmLList *node;
RgSchCmnAllocRecord *allRcd;
* @param[in] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnResetRiCqi
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnResetRiCqi(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnResetRiCqi(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUe *ueSchCmn = RG_SCH_CMN_GET_UE(ue,cell);
* @param[in] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnDlUeReset
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnDlUeReset(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnDlUeReset(RgSchCellCb *cell,RgSchUeCb *ue)
{
- RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
+ RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
+ RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
+ RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
if (ueDl->rachInfo.poLnk.node != NULLP)
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-Void rgSCHCmnUeReset
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUeReset(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUeReset(RgSchCellCb *cell,RgSchUeCb *ue)
{
uint8_t idx;
- Pst pst;
+ Pst pst;
RgInfResetHqEnt hqEntRstInfo;
/* RACHO: remove UE from pdcch, handover and rapId assoc Qs */
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-Void rgSCHCmnActvtUlUe
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnActvtUlUe(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnActvtUlUe(RgSchCellCb *cell,RgSchUeCb *ue)
{
- RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
+ RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
/* : take care of this in UL retransmission */
cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-Void rgSCHCmnActvtDlUe
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnActvtDlUe(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnActvtDlUe(RgSchCellCb *cell,RgSchUeCb *ue)
{
- RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
+ RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
return;
*
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnHdlUlTransInd
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-CmLteTimingInfo timingInfo
-)
-#else
-Void rgSCHCmnHdlUlTransInd(cell, ue, timingInfo)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-CmLteTimingInfo timingInfo;
-#endif
+Void rgSCHCmnHdlUlTransInd(RgSchCellCb *cell,RgSchUeCb *ue,CmLteTimingInfo timingInfo)
{
/* Update the latest UL dat/sig transmission time */
* @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
-#ifdef ANSI
-static RgSchCmnRank rgSCHCmnComp4TxMode4
-(
- uint32_t *pmiBitMap
- )
-#else
-static RgSchCmnRank rgSCHCmnComp4TxMode4(pmiBitMap)
- uint32_t *pmiBitMap;
-#endif
+static RgSchCmnRank rgSCHCmnComp4TxMode4(uint32_t *pmiBitMap)
{
uint32_t bitMap0, bitMap1;
bitMap0 = pmiBitMap[0];
* @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
-#ifdef ANSI
-static RgSchCmnRank rgSCHCmnComp2TxMode4
-(
- uint32_t *pmiBitMap
- )
-#else
-static RgSchCmnRank rgSCHCmnComp2TxMode4(pmiBitMap)
- uint32_t *pmiBitMap;
-#endif
+static RgSchCmnRank rgSCHCmnComp2TxMode4(uint32_t *pmiBitMap)
{
uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
* @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
-#ifdef ANSI
-static RgSchCmnRank rgSCHCmnComp4TxMode3
-(
- uint32_t *pmiBitMap
- )
-#else
-static RgSchCmnRank rgSCHCmnComp4TxMode3(pmiBitMap)
- uint32_t *pmiBitMap;
-#endif
+static RgSchCmnRank rgSCHCmnComp4TxMode3(uint32_t *pmiBitMap)
{
uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
* @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
-#ifdef ANSI
-static RgSchCmnRank rgSCHCmnComp2TxMode3
-(
- uint32_t *pmiBitMap
- )
-#else
-static RgSchCmnRank rgSCHCmnComp2TxMode3(pmiBitMap)
- uint32_t *pmiBitMap;
-#endif
+static RgSchCmnRank rgSCHCmnComp2TxMode3(uint32_t *pmiBitMap)
{
uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
* @param[in] uint8_t numTxPorts
* @return RgSchCmnRank
**/
-#ifdef ANSI
-static RgSchCmnRank rgSCHCmnComputeRank
-(
- RgrTxMode txMode,
- uint32_t *pmiBitMap,
- uint8_t numTxPorts
- )
-#else
-static RgSchCmnRank rgSCHCmnComputeRank(txMode, pmiBitMap, numTxPorts)
- RgrTxMode txMode;
- uint32_t *pmiBitMap;
- uint8_t numTxPorts;
-#endif
+static RgSchCmnRank rgSCHCmnComputeRank(RgrTxMode txMode,uint32_t *pmiBitMap,uint8_t numTxPorts)
{
if (numTxPorts ==2 && txMode == RGR_UE_TM_3)
* @return VOID
**/
/*KWORK_FIX:Changed function return type to void */
-#ifdef ANSI
-Void rgSCHCmnDlDeInitHqEnt
-(
-RgSchCellCb *cell,
-RgSchDlHqEnt *hqE
-)
-#else
-Void rgSCHCmnDlDeInitHqEnt(cell, hqE)
-RgSchCellCb *cell;
-RgSchDlHqEnt *hqE;
-#endif
+Void rgSCHCmnDlDeInitHqEnt(RgSchCellCb *cell,RgSchDlHqEnt *hqE)
{
- RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- RgSchDlHqProcCb *hqP;
- uint8_t cnt;
- S16 ret;
-
+ RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
+ RgSchDlHqProcCb *hqP;
+ uint8_t cnt;
+ S16 ret;
ret = cellSchd->apisDl->rgSCHDlUeHqEntDeInit(cell, hqE);
/* Free only If the Harq proc are created*/
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-S16 rgSCHCmnDlInitHqEnt
-(
-RgSchCellCb *cell,
-RgSchDlHqEnt *hqEnt
-)
-#else
-S16 rgSCHCmnDlInitHqEnt(cell, hqEnt)
-RgSchCellCb *cell;
-RgSchDlHqEnt *hqEnt;
-#endif
-
+S16 rgSCHCmnDlInitHqEnt(RgSchCellCb *cell,RgSchDlHqEnt *hqEnt)
{
- RgSchDlHqProcCb *hqP;
- uint8_t cnt;
-
- RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
+ RgSchDlHqProcCb *hqP;
+ uint8_t cnt;
+ RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
{
* @return Void
*
**/
-#ifdef ANSI
-static uint8_t rgSCHCmnGetRefreshDist
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static uint8_t rgSCHCmnGetRefreshDist(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static uint8_t rgSCHCmnGetRefreshDist(RgSchCellCb *cell,RgSchUeCb *ue)
{
uint8_t refOffst;
-#ifdef DEBUGP
- Inst inst = cell->instIdx;
-#endif
for(refOffst = 0; refOffst < RGSCH_MAX_REFRESH_OFFSET; refOffst++)
{
{
cell->refreshUeCnt[refOffst]++;
ue->refreshOffset = refOffst;
- /* printf("UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst, cell->refreshUeCnt[refOffst]); */
+ /* DU_LOG("\nINFO --> SCH : UE[%d] refresh offset[%d]. Cell refresh ue count[%d].\n", ue->ueId, refOffst, cell->refreshUeCnt[refOffst]); */
return (refOffst);
}
}
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Allocation of refresh distribution failed\n"));
+ DU_LOG("\nERROR --> SCH : Allocation of refresh distribution failed\n");
/* We should not enter here normally, but incase of failure, allocating from last offset*/
cell->refreshUeCnt[refOffst-1]++;
ue->refreshOffset = refOffst-1;
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnGetRefreshPer
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint32_t *waitPer
-)
-#else
-static Void rgSCHCmnGetRefreshPer(cell, ue, waitPer)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint32_t *waitPer;
-#endif
+static Void rgSCHCmnGetRefreshPer(RgSchCellCb *cell,RgSchUeCb *ue,uint32_t *waitPer)
{
- uint32_t refreshPer;
- uint32_t crntSubFrm;
+ uint32_t refreshPer;
+ uint32_t crntSubFrm;
refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-S16 rgSCHCmnRgrSCellUeCfg
-(
-RgSchCellCb *sCell,
-RgSchUeCb *ue,
-RgrUeSecCellCfg *sCellInfoCfg,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHCmnRgrSCellUeCfg(sCell, ue, sCellInfoCfg, err)
-RgSchCellCb *sCell;
-RgSchUeCb *ue;
-RgrUeSecCellCfg *sCellInfoCfg;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHCmnRgrSCellUeCfg(RgSchCellCb *sCell,RgSchUeCb *ue,RgrUeSecCellCfg *sCellInfoCfg,RgSchErrInfo *err)
{
uint8_t i;
- S16 ret;
- uint8_t cnt;
+ S16 ret;
+ uint8_t cnt;
RgSchCmnAllocRecord *allRcd;
RgSchDlRbAlloc *allocInfo;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
if((rgSCHUtlAllocSBuf(sCell->instIdx,
(Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Memory allocation FAILED\n"));
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED\n");
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
}
if ((cellSchd->apisDl->rgSCHRgrSCellDlUeCfg(sCell, ue, err)) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "Spec Sched DL UE CFG FAILED\n"));
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE CFG FAILED\n");
return RFAILED;
}
{
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeCfg(sCell, ue, sCellInfoCfg, err)) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS UE config FAILED\n"));
+ DU_LOG("\nERROR --> SCH : DLFS UE config FAILED\n");
return RFAILED;
}
}
ret = rgSCHUhmHqEntInit(sCell, ue);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL UHM HARQ Ent Init "
+ DU_LOG("\nERROR --> SCH : SCELL UHM HARQ Ent Init "
"Failed for CRNTI:%d", ue->ueId);
return RFAILED;
}
if((rgSCHUtlAllocSBuf(sCell->instIdx,
(Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId,"SCELL Memory allocation FAILED"
+ DU_LOG("\nERROR --> SCH : SCELL Memory allocation FAILED"
"for CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
ret = rgSCHPwrUeSCellCfg(sCell, ue, sCellInfoCfg);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Could not do "
+ DU_LOG("\nERROR --> SCH : Could not do "
"power config for UE CRNTI:%d",ue->ueId);
return RFAILED;
}
{
if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
return RFAILED;
}
{
if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(sCell, ue, NULL, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,sCell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ue->ueId);
return RFAILED;
}
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @return S16
- * -# ROK
- * -# RFAILED
- **/
-#ifdef ANSI
-S16 rgSCHCmnRgrSCellUeDel
-(
-RgSchUeCellInfo *sCellInfo,
-RgSchUeCb *ue
-)
-#else
-S16 rgSCHCmnRgrSCellUeDel(sCellInfo, ue)
-RgSchUeCellInfo *sCellInfo;
-RgSchUeCb *ue;
-#endif
+ * -# ROK
+ * -# RFAILED
+ **/
+S16 rgSCHCmnRgrSCellUeDel(RgSchUeCellInfo *sCellInfo,RgSchUeCb *ue)
{
- RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
- Inst inst = ue->cell->instIdx;
+ RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
+ Inst inst = ue->cell->instIdx;
cellSchd->apisDl->rgSCHRgrSCellDlUeDel(sCellInfo, ue);
{
if ((cellSchd->apisDlfs->rgSCHDlfsSCellUeDel(sCellInfo->cell, ue)) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "DLFS Scell del FAILED\n"));
+ DU_LOG("\nERROR --> SCH : DLFS Scell del FAILED\n");
return RFAILED;
}
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-S16 rgSCHCmn5gtfUeCfg
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgrUeCfg *cfg
-)
-#else
-S16 rgSCHCmn5gtfUeCfg(cell, ue, cfg)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgrUeCfg *cfg;
-#endif
+S16 rgSCHCmn5gtfUeCfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrUeCfg *cfg)
{
RgSchUeGrp *ue5gtfGrp;
ue->ue5gtfCb.nxtCqiRiOccn.slot = 0;
ue->ue5gtfCb.rank = 1;
- printf("\nschd cfg at mac,%u,%u,%u,%u,%u\n",ue->ue5gtfCb.grpId,ue->ue5gtfCb.BeamId,ue->ue5gtfCb.numCC,
+ DU_LOG("\nINFO --> SCH : schd cfg at mac,%u,%u,%u,%u,%u\n",ue->ue5gtfCb.grpId,ue->ue5gtfCb.BeamId,ue->ue5gtfCb.numCC,
ue->ue5gtfCb.mcs,ue->ue5gtfCb.maxPrb);
ue5gtfGrp = &(cell->cell5gtfCb.ueGrp5gConf[ue->ue5gtfCb.BeamId]);
scheduling comes into picture */
if(ue5gtfGrp->beamBitMask & (1 << ue->ue5gtfCb.BeamId))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR Invalid beam id CRNTI:%d",cfg->crnti);
return RFAILED;
}
ue5gtfGrp->beamBitMask |= (1 << ue->ue5gtfCb.BeamId);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-S16 rgSCHCmnRgrUeCfg
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgrUeCfg *ueCfg,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHCmnRgrUeCfg(cell, ue, ueCfg, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgrUeCfg *ueCfg;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHCmnRgrUeCfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrUeCfg *ueCfg,RgSchErrInfo *err)
{
RgSchDlRbAlloc *allocInfo;
- S16 ret;
- RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
- RgSchCmnUe *ueSchCmn;
- RgSchCmnUlUe *ueUl;
- RgSchCmnDlUe *ueDl;
- uint8_t cnt;
+ S16 ret;
+ RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
+ RgSchCmnUe *ueSchCmn;
+ RgSchCmnUlUe *ueUl;
+ RgSchCmnDlUe *ueDl;
+ uint8_t cnt;
RgSchCmnAllocRecord *allRcd;
- uint32_t waitPer;
- uint32_t idx = (uint8_t)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
- RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
+ uint32_t waitPer;
+ uint32_t idx = (uint8_t)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
+ RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
/* 1. Allocate Common sched control block */
if((rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch)), (sizeof(RgSchCmnUe))) != ROK))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
}
*/
if((ueCfg->ueQosCfg.dlAmbr == 0) && (ueCfg->ueQosCfg.ueBr == 0))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"UL Ambr and DL Ambr are"
+ DU_LOG("\nERROR --> SCH : UL Ambr and DL Ambr are"
"configured as 0 for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
{
if ((cellSchd->apisEmtcDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisDl->rgSCHRgrDlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE CFG FAILED for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
}
if((rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(allRcd),sizeof(RgSchCmnAllocRecord)) != ROK))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED"
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED"
"for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
(Data**)&(ue->ul.lcgArr[cnt].sch), (sizeof(RgSchCmnLcg)));
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
+ DU_LOG("\nERROR --> SCH : SCH struct alloc failed for CRNTI:%d",ueCfg->crnti);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
}
ret = rgSCHPwrUeCfg(cell, ue, ueCfg);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
+ DU_LOG("\nERROR --> SCH : Could not do "
"power config for UE CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
ret = rgSCHCmnSpsUeCfg(cell, ue, ueCfg, err);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not do "
+ DU_LOG("\nERROR --> SCH : Could not do "
"SPS config for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisEmtcUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisUl->rgSCHRgrUlUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Spec Sched UL UE CFG FAILED"
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE CFG FAILED"
"for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
{
if ((cellSchd->apisDlfs->rgSCHDlfsUeCfg(cell, ue, ueCfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "DLFS UE config FAILED"
+ DU_LOG("\nERROR --> SCH : DLFS UE config FAILED"
"for CRNTI:%d",ueCfg->crnti);
return RFAILED;
}
* @return Void
**/
#ifdef TFU_UPGRADE
-#ifdef ANSI
-static Void rgSCHCmnDlHdlTxModeRecfg
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgrUeRecfg *ueRecfg,
-uint8_t numTxPorts
-)
+static Void rgSCHCmnDlHdlTxModeRecfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,uint8_t numTxPorts)
#else
-static Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, numTxPorts)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgrUeRecfg *ueRecfg;
-uint8_t numTxPorts;
-#endif
-#else
-#ifdef ANSI
-static Void rgSCHCmnDlHdlTxModeRecfg
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgrUeRecfg *ueRecfg
-)
-#else
-static Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgrUeRecfg *ueRecfg;
-#endif
+static Void rgSCHCmnDlHdlTxModeRecfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrUeRecfg *ueRecfg)
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnUpdUeMimoInfo
-(
-RgrUeCfg *ueCfg,
-RgSchCmnDlUe *ueDl,
-RgSchCellCb *cell,
-RgSchCmnCell *cellSchd
-)
-#else
-static Void rgSCHCmnUpdUeMimoInfo(ueCfg, ueDl, cell, cellSchd)
-RgrUeCfg *ueCfg;
-RgSchCmnDlUe *ueDl;
-RgSchCellCb *cell;
-RgSchCmnCell *cellSchd;
-#endif
+static Void rgSCHCmnUpdUeMimoInfo(RgrUeCfg *ueCfg,RgSchCmnDlUe *ueDl,RgSchCellCb *cell,RgSchCmnCell *cellSchd)
{
#ifdef TFU_UPGRADE
if(ueCfg->txMode.pres)
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnUpdUeUlCqiInfo
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchCmnUlUe *ueUl,
-RgSchCmnUe *ueSchCmn,
-RgSchCmnCell *cellSchd,
-Bool isEcp
-)
-#else
-static Void rgSCHCmnUpdUeUlCqiInfo(cell, ue, ueUl, ueSchCmn, cellSchd, isEcp)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchCmnUlUe *ueUl;
-RgSchCmnUe *ueSchCmn;
-RgSchCmnCell *cellSchd;
-Bool isEcp;
-#endif
+static Void rgSCHCmnUpdUeUlCqiInfo(RgSchCellCb *cell,RgSchUeCb *ue,RgSchCmnUlUe *ueUl,RgSchCmnUe *ueSchCmn,RgSchCmnCell *cellSchd,Bool isEcp)
{
-
#ifdef TFU_UPGRADE
if(ue->srsCb.srsCfg.type == RGR_SCH_SRS_SETUP)
{
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnUpdUeCatCfg
-(
-RgSchUeCb *ue,
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnUpdUeCatCfg(ue, cell)
-RgSchUeCb *ue;
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnUpdUeCatCfg(RgSchUeCb *ue,RgSchCellCb *cell)
{
RgSchDlHqEnt *hqE = NULLP;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-S16 rgSCHCmnRgrUeRecfg
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgrUeRecfg *ueRecfg,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHCmnRgrUeRecfg(cell, ue, ueRecfg, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgrUeRecfg *ueRecfg;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHCmnRgrUeRecfg(RgSchCellCb *cell,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,RgSchErrInfo *err)
{
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
- uint32_t waitPer;
+ uint32_t waitPer;
/* Basic validations */
if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
&& (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD10)
&& (ueRecfg->prdDlCqiRecfg.prdModeEnum != RGR_PRD_CQI_MOD20))
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unsupported periodic CQI "
+ DU_LOG("\nERROR --> SCH : Unsupported periodic CQI "
"reporting mode %d for old CRNIT:%d",
(int)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
{
if (rgSCHPwrUeRecfg(cell, ue, ueRecfg) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
+ DU_LOG("\nERROR --> SCH : Power Reconfiguration Failed for OLD CRNTI:%d",ueRecfg->oldCrnti);
return RFAILED;
}
}
/* Uplink Sched related Initialization */
if ((ueRecfg->ueQosRecfg.dlAmbr == 0) && (ueRecfg->ueQosRecfg.ueBr == 0))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Ul Ambr and DL Ambr "
+ DU_LOG("\nERROR --> SCH : Ul Ambr and DL Ambr "
"configured as 0 for OLD CRNTI:%d",ueRecfg->oldCrnti);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
{
if ((cellSchCmn->apisEmtcUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
if ((cellSchCmn->apisEmtcDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
}
{
if ((cellSchCmn->apisUl->rgSCHRgrUlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched UL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
if ((cellSchCmn->apisDl->rgSCHRgrDlUeRecfg(cell, ue, ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Spec Sched DL UE ReCFG FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
}
if ((cellSchCmn->apisDlfs->rgSCHDlfsUeRecfg(cell, ue, \
ueRecfg, err)) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : DLFS UE re-config FAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
}
/* Invoke re-configuration on SPS module */
if (rgSCHCmnSpsUeRecfg(cell, ue, ueRecfg, err) != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
+ DU_LOG("\nERROR --> SCH : DL SPS ReCFG FAILED for UE CRNTI:%d", ue->ueId);
return RFAILED;
}
#endif
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnUlUeDelAllocs
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnUlUeDelAllocs(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnUlUeDelAllocs(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnDelUeFrmRefreshQ
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnDelUeFrmRefreshQ(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnDelUeFrmRefreshQ(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *sched = RG_SCH_CMN_GET_CELL(cell);
CmTmrArg arg;
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnUeCcchSduDel
-(
-RgSchCellCb *cell,
-RgSchUeCb *ueCb
-)
-#else
-static Void rgSCHCmnUeCcchSduDel(cell, ueCb)
-RgSchCellCb *cell;
-RgSchUeCb *ueCb;
-#endif
+static Void rgSCHCmnUeCcchSduDel(RgSchCellCb *cell,RgSchUeCb *ueCb)
{
RgSchDlHqEnt *hqE = NULLP;
RgSchDlHqProcCb *ccchSduHqP = NULLP;
* @param[in] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnUeDel
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUeDel(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUeDel(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchDlHqEnt *hqE = NULLP;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlCnsdrCmnRt
-(
-RgSchCellCb *cell,
-RgrDlCmnCodeRateCfg *dlCmnCodeRate
-)
-#else
-static S16 rgSCHCmnDlCnsdrCmnRt(cell, dlCmnCodeRate)
-RgSchCellCb *cell;
-RgrDlCmnCodeRateCfg *dlCmnCodeRate;
-#endif
+static S16 rgSCHCmnDlCnsdrCmnRt(RgSchCellCb *cell,RgrDlCmnCodeRateCfg *dlCmnCodeRate)
{
- RgSchCmnCell *cellDl = RG_SCH_CMN_GET_CELL(cell);
- uint32_t bitsPerRb;
- uint32_t bitsPer2Rb;
- uint32_t bitsPer3Rb;
- uint8_t i, rbNum;
- uint32_t pdcchBits;
+ RgSchCmnCell *cellDl = RG_SCH_CMN_GET_CELL(cell);
+ uint32_t bitsPerRb;
+ uint32_t bitsPer2Rb;
+ uint32_t bitsPer3Rb;
+ uint8_t i, rbNum;
+ uint32_t pdcchBits;
/* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlRgrCellCfg
-(
-RgSchCellCb *cell,
-RgrCellCfg *cfg,
-RgSchErrInfo *err
-)
-#else
-static S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
-RgSchCellCb *cell;
-RgrCellCfg *cfg;
-RgSchErrInfo *err;
-#endif
+static S16 rgSCHCmnDlRgrCellCfg(RgSchCellCb *cell,RgrCellCfg *cfg,RgSchErrInfo *err)
{
RgSchCmnCell *cellSch;
- uint8_t cp;
- uint8_t sfCount;
- uint8_t numPdcchSym;
- uint8_t noSymPerSlot;
- uint8_t maxDlSubfrms = cell->numDlSubfrms;
- uint8_t splSubfrmIdx = cfg->spclSfCfgIdx;
- uint8_t swPtCnt = 0;
+ uint8_t cp;
+ uint8_t sfCount;
+ uint8_t numPdcchSym;
+ uint8_t noSymPerSlot;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t splSubfrmIdx = cfg->spclSfCfgIdx;
+ uint8_t swPtCnt = 0;
Bool isSplfrm;
RgSchTddSubfrmInfo subfrmInfo = rgSchTddMaxUlSubfrmTbl[cell->ulDlCfgIdx];
S16 ret;
- uint8_t splSfIdx;
- uint8_t antPortIdx;
- uint8_t numCrs;
- uint8_t cfi;
- uint8_t cfiIdx;
+ uint8_t splSfIdx;
+ uint8_t antPortIdx;
+ uint8_t numCrs;
+ uint8_t cfi;
+ uint8_t cfiIdx;
RgSchDlSf *sf;
- uint8_t splSfCfi;
- uint8_t mPhich;
+ uint8_t splSfCfi;
+ uint8_t mPhich;
/*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "Invalid configuration !: "
+ DU_LOG("\nERROR --> SCH : Invalid configuration !: "
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlRgrCellCfg
-(
-RgSchCellCb *cell,
-RgrCellCfg *cfg,
-RgSchErrInfo *err
-)
-#else
-static S16 rgSCHCmnDlRgrCellCfg(cell, cfg, err)
-RgSchCellCb *cell;
-RgrCellCfg *cfg;
-RgSchErrInfo *err;
-#endif
+static S16 rgSCHCmnDlRgrCellCfg(RgSchCellCb *cell,RgrCellCfg *cfg,RgSchErrInfo *err)
{
- S16 ret;
- RgSchCmnCell *cellSch;
- uint8_t cp;
- uint8_t numPdcchSym;
- uint8_t noSymPerSlot;
- uint8_t cfi;
- uint8_t cfiIdx;
+ S16 ret;
+ RgSchCmnCell *cellSch;
+ uint8_t cp;
+ uint8_t numPdcchSym;
+ uint8_t noSymPerSlot;
+ uint8_t cfi;
+ uint8_t cfiIdx;
cellSch = RG_SCH_CMN_GET_CELL(cell);
/* Fix: MUE_PERTTI_DL syed validating Cell Configuration */
if (cellSch->dl.maxUePerDlSf < cellSch->dl.maxUeNewTxPerTti)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
+ DU_LOG("\nERROR --> SCH : FAILED MaxUePerDlSf(%u) < MaxDlUeNewTxPerTti(%u)",
cellSch->dl.maxUePerDlSf,
cellSch->dl.maxUeNewTxPerTti);
return RFAILED;
/*[ccpu00138609]-ADD- Configure the Max CCCH Counter */
if (cfg->maxCcchPerDlSf > cfg->maxUePerDlSf)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid configuration !: "
+ DU_LOG("\nERROR --> SCH : Invalid configuration !: "
"maxCcchPerDlSf %u > maxUePerDlSf %u",
cfg->maxCcchPerDlSf, cfg->maxUePerDlSf );
* File :
*
**********************************************************/
-#ifdef ANSI
-uint8_t rgSCHCmnUlCalcReqRbCeil
-(
-uint32_t bytes,
-uint8_t cqi,
-RgSchCmnUlCell *cellUl
-)
-#else
-uint8_t rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
-uint32_t bytes;
-uint8_t cqi;
-RgSchCmnUlCell *cellUl;
-#endif
+uint8_t rgSCHCmnUlCalcReqRbCeil(uint32_t bytes,uint8_t cqi,RgSchCmnUlCell *cellUl)
{
uint32_t numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
return ((uint8_t)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
* File :
*
**********************************************************/
-#ifdef ANSI
-static S16 rgSCHCmnPrecompMsg3Vars
-(
-RgSchCmnUlCell *cellUl,
-uint8_t ccchCqi,
-uint16_t msgSzA,
-uint8_t sbSize,
-Bool isEcp
-)
-#else
-static S16 rgSCHCmnPrecompMsg3Vars(cellUl, ccchCqi, msgSzA, sbSize, isEcp)
-RgSchCmnUlCell *cellUl;
-uint8_t ccchCqi;
-uint16_t msgSzA;
-uint8_t sbSize;
-Bool isEcp;
-#endif
+static S16 rgSCHCmnPrecompMsg3Vars(RgSchCmnUlCell *cellUl,uint8_t ccchCqi,uint16_t msgSzA,uint8_t sbSize,Bool isEcp)
{
- uint8_t numSb;
- uint8_t ccchTbs;
- uint8_t ccchMcs;
- uint8_t numRb = 0;
- uint8_t iTbs = 0;
- uint16_t msg3GrntSz = 0;
+ uint8_t numSb;
+ uint8_t ccchTbs;
+ uint8_t ccchMcs;
+ uint8_t numRb = 0;
+ uint8_t iTbs = 0;
+ uint16_t msg3GrntSz = 0;
if (ccchCqi > cellUl->max16qamCqi)
* File :
*
**********************************************************/
-#ifdef ANSI
-static S16 rgSCHCmnUlCalcAvailBw
-(
-RgSchCellCb *cell,
-RgrCellCfg *cellCfg,
-uint8_t cfi,
-uint8_t *rbStartRef,
-uint8_t *bwAvailRef
-)
-#else
-static S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
-RgSchCellCb *cell;
-RgrCellCfg *cellCfg;
-uint8_t cfi;
-uint8_t *rbStartRef;
-uint8_t *bwAvailRef;
-#endif
+static S16 rgSCHCmnUlCalcAvailBw(RgSchCellCb *cell,RgrCellCfg *cellCfg,uint8_t cfi,uint8_t *rbStartRef,uint8_t *bwAvailRef)
{
uint8_t c = 3;
uint8_t ulBw = cell->bwCfg.ulTotalBw;
uint8_t pucchDeltaShft = cell->pucchCfg.deltaShift;
uint16_t n1Pucch = cell->pucchCfg.n1PucchAn;
uint8_t n1Cs = cell->pucchCfg.cyclicShift;
-
uint8_t n1PerRb;
uint8_t totalCce;
uint16_t n1Max;
/* Num of PUCCH RBs = puschRbStart*2 */
if (puschRbStart * 2 >= ulBw)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
+ DU_LOG("\nERROR --> SCH : No bw available for PUSCH");
return RFAILED;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-static S16 rgSCHCmnUlCalcAvailBw
-(
-RgSchCellCb *cell,
-RgrCellCfg *cellCfg,
-uint8_t cfi,
-uint8_t *rbStartRef,
-uint8_t *bwAvailRef
-)
-#else
-static S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
-RgSchCellCb *cell;
-RgrCellCfg *cellCfg;
-uint8_t cfi;
-uint8_t *rbStartRef;
-uint8_t *bwAvailRef;
-#endif
+static S16 rgSCHCmnUlCalcAvailBw(RgSchCellCb *cell,RgrCellCfg *cellCfg,uint8_t cfi,uint8_t *rbStartRef,uint8_t *bwAvailRef)
{
uint8_t c = 3;
uint8_t ulBw = cell->bwCfg.ulTotalBw;
if(gPrntPucchDet)
{
#ifndef ALIGN_64BIT
- printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%ld:%d:%d:%d:%d:%d]\n",
+ DU_LOG("\nDEBUG --> SCH : CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%ld:%d:%d:%d:%d:%d]\n",
cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
#else
- printf("CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%d:%d:%d:%d:%d:%d]\n",
+ DU_LOG("\nDEBUG --> SCH : CA_DBG:: puschRbStart:n1Rb:mixedRb:n1PerRb:totalCce:n1Max:n1RbPart:n2Rb::[%d:%d] [%d:%d:%d:%d:%d:%d:%d:%d]\n",
cell->crntTime.sfn, cell->crntTime.slot, puschRbStart, n1Rb, mixedRb,n1PerRb, totalCce, n1Max, n1RbPart, n2Rb);
#endif
}
if (puschRbStart*2 >= ulBw)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"No bw available for PUSCH");
+ DU_LOG("\nERROR --> SCH : No bw available for PUSCH");
return RFAILED;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-static S16 rgSCHCmnUlCellInit
-(
- RgSchCellCb *cell,
- RgrCellCfg *cellCfg
- )
-#else
-static S16 rgSCHCmnUlCellInit(cell, cellCfg)
- RgSchCellCb *cell;
- RgrCellCfg *cellCfg;
-#endif
+static S16 rgSCHCmnUlCellInit(RgSchCellCb *cell,RgrCellCfg *cellCfg)
{
S16 ret;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- uint8_t maxUePerUlSf = cellCfg->maxUePerUlSf;
+ uint8_t maxUePerUlSf = cellCfg->maxUePerUlSf;
#ifdef RGR_V1
/* Added configuration for maximum number of MSG3s */
- uint8_t maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
-#endif
- uint8_t maxUlBwPerUe = cellCfg->maxUlBwPerUe;
- uint8_t sbSize = cellCfg->puschSubBand.size;
- uint8_t i;
- uint8_t rbStart;
- uint8_t bwAvail;
- uint8_t cfi;
- uint8_t maxSbPerUe;
- uint8_t numSb;
+ uint8_t maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
+#endif
+ uint8_t maxUlBwPerUe = cellCfg->maxUlBwPerUe;
+ uint8_t sbSize = cellCfg->puschSubBand.size;
+ uint8_t i;
+ uint8_t rbStart;
+ uint8_t bwAvail;
+ uint8_t cfi;
+ uint8_t maxSbPerUe;
+ uint8_t numSb;
#ifdef LTE_TDD
- uint16_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint16_t ulDlCfgIdx = cell->ulDlCfgIdx;
/* [ccpu00127294]-MOD-Change the max Ul subfrms size in TDD */
- uint8_t maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx];
- uint8_t ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL * 2 */
- uint8_t maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx];
+ uint8_t ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL * 2 */
+ uint8_t maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- uint16_t subfrm;
- S8 dlIdx;
+ uint16_t subfrm;
+ S8 dlIdx;
#else
- uint8_t maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
+ uint8_t maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
#endif
#ifdef LTE_L2_MEAS
- uint8_t idx;
+ uint8_t idx;
#endif
uint8_t iTbs;
#if (defined(LTE_L2_MEAS) )
- Inst inst = cell->instIdx;
+ Inst inst = cell->instIdx;
#endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
/* Fix: MUE_PERTTI_UL syed validating Cell Configuration */
if (cellUl->maxAllocPerUlSf < cellUl->maxUeNewTxPerTti)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
+ DU_LOG("\nERROR --> SCH : FAILED: MaxUePerUlSf(%u) < MaxUlUeNewTxPerTti(%u)",
cellUl->maxAllocPerUlSf,
cellUl->maxUeNewTxPerTti);
return RFAILED;
ulUeInfo.ulAllocInfo), (cellUl->maxAllocPerUlSf * sizeof(RgInfUeUlAlloc)));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation failed ");
+ DU_LOG("\nERROR --> SCH : Memory allocation failed ");
return (ret);
}
}
if (sbSize != rgSchCmnMult235Tbl[sbSize].match)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"Invalid subband size %d", sbSize);
+ DU_LOG("\nERROR --> SCH : Invalid subband size %d", sbSize);
return RFAILED;
}
//Setting the subband size to 4 which is size of VRBG in 5GTF
maxSbPerUe = maxUlBwPerUe / sbSize;
if (maxSbPerUe == 0)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnUlCellInit(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlCellInit(): "
"maxUlBwPerUe/sbSize is zero");
return RFAILED;
}
if ((!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->ulCmnCodeRate.ccchCqi))
|| (!RG_SCH_CMN_UL_IS_CQI_VALID(cellCfg->trgUlCqi.trgCqi)))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnUlCellInit(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlCellInit(): "
"Invalid cqi");
return RFAILED;
}
* Refer to 36.213-8.6.1 */
for (i = RG_SCH_CMN_UL_NUM_CQI - 1;i > 0; --i)
{
- RLOG_ARG2(L_INFO,DBG_CELLID,cell->cellId,
- "CQI %u:iTbs %u",
- i,
+ DU_LOG("\nINFO --> SCH : CQI %u:iTbs %u",i,
rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i]);
#ifdef MAC_SCH_STATS
/* ccpu00128489 ADD Update mcs in hqFailStats here instead of at CRC
iTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend][i];
if (iTbs <= RGSCH_UL_16QAM_MAX_ITBS) /* corresponds to 16QAM */
{
- RLOG_ARG1(L_INFO,DBG_CELLID,cell->cellId,
- "16 QAM CQI %u", i);
+ DU_LOG("\nINFO --> SCH : 16 QAM CQI %u", i);
cellUl->max16qamCqi = i;
break;
}
if(0 == cell->dynCfiCb.maxCfi)
{
- RLOG_ARG3(L_ERROR,DBG_CELLID,cell->cellId,
- "Incorrect Default CFI(%u), maxCfi(%u), maxPucchRb(%d)",
+ DU_LOG("\nERROR --> SCH : Incorrect Default CFI(%u), maxCfi(%u), maxPucchRb(%d)",
cellSch->cfiCfg.cfi, cell->dynCfiCb.maxCfi,
cell->pucchCfg.maxPucchRb);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-S16 rgSCHCmnRgrCellCfg
-(
-RgSchCellCb *cell,
-RgrCellCfg *cellCfg,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHCmnRgrCellCfg(cell, cellCfg, err)
-RgSchCellCb *cell;
-RgrCellCfg *cellCfg;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHCmnRgrCellCfg(RgSchCellCb *cell,RgrCellCfg *cellCfg,RgSchErrInfo *err)
{
- S16 ret;
+ S16 ret;
RgSchCmnCell *cellSch;
/* As part of RGR cell configuration, validate the CRGCellCfg
if (((ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(cell->sc.sch), (sizeof(RgSchCmnCell)))) != ROK))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "Memory allocation FAILED");
+ DU_LOG("\nERROR --> SCH : Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
}
* @return Void
*
**/
-#ifdef ANSI
-S16 rgSCHCmnRgrCellRecfg
-(
-RgSchCellCb *cell,
-RgrCellRecfg *recfg,
-RgSchErrInfo *err
-)
-#else
-S16 rgSCHCmnRgrCellRecfg(cell, recfg, err)
-RgSchCellCb *cell;
-RgrCellRecfg *recfg;
-RgSchErrInfo *err;
-#endif
+S16 rgSCHCmnRgrCellRecfg(RgSchCellCb *cell,RgrCellRecfg *recfg,RgSchErrInfo *err)
{
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
if (!RG_SCH_CMN_UL_IS_CQI_VALID(recfg->ulCmnCodeRate.ccchCqi))
{
err->errCause = RGSCHERR_SCH_CFG;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnRgrCellRecfg(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnRgrCellRecfg(): "
"Invalid cqi");
return RFAILED;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnUlCellDeinit
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnUlCellDeinit(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnUlCellDeinit(RgSchCellCb *cell)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- uint8_t ulSfIdx;
+ uint8_t ulSfIdx;
#ifdef LTE_TDD
uint8_t maxSubfrms = cellUl->numUlSubfrms;
#endif
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnCellDel
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnCellDel(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnCellDel(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnValidateDlQos
-(
-RgrLchQosCfg *dlQos
-)
-#else
-static S16 rgSCHCmnValidateDlQos(dlQos)
-RgrLchQosCfg *dlQos;
-#endif
+static S16 rgSCHCmnValidateDlQos(RgrLchQosCfg *dlQos)
{
uint8_t qci = dlQos->qci;
-
-
if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
{
return RFAILED;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnRgrLchCfg
(
RgSchCellCb *cell,
RgrLchCfg *lcCfg,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnRgrLchCfg(cell, ue, dlLc, lcCfg, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlLcCb *dlLc;
-RgrLchCfg *lcCfg;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
(Data**)&((dlLc)->sch), (sizeof(RgSchCmnDlSvc)));
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRgrLchCfg(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnRgrLchCfg(): "
"SCH struct alloc failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
ret = rgSCHCmnValidateDlQos(&lcCfg->dlInfo.dlQos);
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"rgSchCmnCrgLcCfg(): "
+ DU_LOG("\nERROR --> SCH : rgSchCmnCrgLcCfg(): "
"DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
ret = rgSCHCmnSpsDlLcCfg(cell, ue, dlLc, lcCfg, err);
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "rgSchCmnRgrLchCfg(): "
+ DU_LOG("\nERROR --> SCH : rgSchCmnRgrLchCfg(): "
"SPS configuration failed for DL LC for CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return RFAILED;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnRgrLchRecfg
(
RgSchCellCb *cell,
RgrLchRecfg *lcRecfg,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnRgrLchRecfg(cell, ue, dlLc, lcRecfg, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlLcCb *dlLc;
-RgrLchRecfg *lcRecfg;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
+ DU_LOG("\nERROR --> SCH : DlQos validation failed for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
}
if (((RgSchCmnDlSvc *)(dlLc->sch))->qci != lcRecfg->dlRecfg.dlQos.qci)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Qci, hence lc Priority change "
+ DU_LOG("\nERROR --> SCH : Qci, hence lc Priority change "
"not supported for CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
err->errCause = RGSCHERR_SCH_CFG;
return (ret);
ret = rgSCHCmnSpsDlLcRecfg(cell, ue, dlLc, lcRecfg, err);
if (ret != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"SPS re-configuration not "
+ DU_LOG("\nERROR --> SCH : SPS re-configuration not "
"supported for dlLC Ignore this CRNTI:%d LCID:%d",ue->ueId,lcRecfg->lcId);
}
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnRgrLcgCfg
(
RgSchCellCb *cell,
RgrLcgCfg *lcgCfg,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnRgrLcgCfg(cell, ue, lcg, lcgCfg, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchLcgCb *lcg;
-RgrLcgCfg *lcgCfg;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnRgrLcgRecfg
(
RgSchCellCb *cell,
RgrLcgRecfg *reCfg,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnRgrLcgRecfg(cell, ue, lcg, reCfg, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchLcgCb *lcg;
-RgrLcgRecfg *reCfg;
-RgSchErrInfo *err;
-#endif
{
S16 ret;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
*
* File :
**********************************************************/
-#ifdef ANSI
-S16 rgSCHCmnRgrLchDel
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-CmLteLcId lcId,
-uint8_t lcgId
-)
-#else
-S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-CmLteLcId lcId;
-uint8_t lcgId;
-#endif
+S16 rgSCHCmnRgrLchDel(RgSchCellCb *cell,RgSchUeCb *ue,CmLteLcId lcId,uint8_t lcgId)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef EMTC_ENABLE
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnLcgDel
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchLcgCb *lcg
-)
-#else
-Void rgSCHCmnLcgDel(cell, ue, lcg)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchLcgCb *lcg;
-#endif
+Void rgSCHCmnLcgDel(RgSchCellCb *cell,RgSchUeCb *ue,RgSchLcgCb *lcg)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *lcgCmn = RG_SCH_CMN_GET_UL_LCG(lcg);
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnFreeDlLc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchDlLcCb *svc
-)
-#else
-Void rgSCHCmnFreeDlLc(cell, ue, svc)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlLcCb *svc;
-#endif
+Void rgSCHCmnFreeDlLc(RgSchCellCb *cell,RgSchUeCb *ue,RgSchDlLcCb *svc)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
if (svc->sch == NULLP)
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchSduRetxFnlz
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchSduRetxFnlz(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchSduRetxFnlz(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
CmLList *node;
RgSchCmnDlCell *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchRetxFnlz
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchRetxFnlz(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchRetxFnlz(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
CmLList *node;
RgSchCmnDlCell *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchSduTxFnlz
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchSduTxFnlz(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchSduTxFnlz(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
CmLList *node;
RgSchUeCb *ueCb;
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlCcchTxFnlz
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlCcchTxFnlz(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlCcchTxFnlz(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
CmLList *node;
RgSchRaCb *raCb;
* @return uint8_t
*
**/
-#ifdef ANSI
-uint8_t rgSCHCmnGetBiIndex
-(
-RgSchCellCb *cell,
-uint32_t ueCount
-)
-#else
-uint8_t rgSCHCmnGetBiIndex(cell, ueCount)
-RgSchCellCb *cell;
-uint32_t ueCount;
-#endif
+uint8_t rgSCHCmnGetBiIndex(RgSchCellCb *cell,uint32_t ueCount)
{
S16 prevVal = 0; /* To Store Intermediate Value */
uint16_t newBiVal = 0; /* To store Bi Value in millisecond */
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlRaRspFnlz
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlRaRspFnlz(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlRaRspFnlz(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
- uint32_t rarCnt = 0;
+ uint32_t rarCnt = 0;
RgSchDlRbAlloc *raRspAlloc;
RgSchDlSf *subFrm = NULLP;
RgSchRaCb *raCb;
Bool preamGrpA;
RgSchUlAlloc *ulAllocRef=NULLP;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- uint8_t allocRapidCnt = 0;
+ uint8_t allocRapidCnt = 0;
#ifdef LTE_TDD
- uint32_t msg3SchdIdx = 0;
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
- uint8_t msg3Subfrm;
+ uint32_t msg3SchdIdx = 0;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t msg3Subfrm;
#endif
/* Return the grabbed PDCCH */
rgSCHUtlPdcchPut(cell, &subFrm->pdcchInfo, raRspAlloc->pdcch);
subFrm->raRsp[rarCnt].pdcch = NULLP;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRaRspAlloc(): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnRaRspAlloc(): "
"Not even one RaReq.");
return;
}
}
- RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
- "RNTI:%d Scheduled RAR @ (%u,%u) ",
+ DU_LOG("\nDEBUG --> SCH : RNTI:%d Scheduled RAR @ (%u,%u) ",
raRspAlloc->rnti,
cell->crntTime.sfn,
cell->crntTime.slot);
* @return uint8_t
*
**/
-#ifdef ANSI
-static uint8_t rgSCHCmnDlCalcRvForBcch
-(
-RgSchCellCb *cell,
-Bool si,
-uint16_t i
-)
-#else
-static uint8_t rgSCHCmnDlCalcRvForBcch(cell, si, i)
-RgSchCellCb *cell;
-Bool si;
-uint16_t i;
-#endif
+static uint8_t rgSCHCmnDlCalcRvForBcch(RgSchCellCb *cell,Bool si,uint16_t i)
{
uint8_t k, rv;
CmLteTimingInfo frm;
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlBcchPcchFnlz
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlBcchPcchFnlz(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlBcchPcchFnlz(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlSf *subFrm;
#ifdef LTE_TDD
- uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
#else
#ifdef LTEMAC_HDFDD
- uint8_t nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
#else
- uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
#endif
#endif
pcch = rgSCHDbmGetPcch(cell);
if(pcch == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnDlBcchPcchFnlz( ): "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnDlBcchPcchFnlz( ): "
"No Pcch Present");
return;
}
*
* Invoked by: Common Scheduler
*
- * @param[out] RgSchCmnUlRbAllocInfo *allocInfo
- * @return Void
- *
- **/
-#ifdef ANSI
-static Void rgSCHCmnUlSetAllUnSched
-(
-RgSchCmnUlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnUlSetAllUnSched(allocInfo)
-RgSchCmnUlRbAllocInfo *allocInfo;
-#endif
+ * @param[out] RgSchCmnUlRbAllocInfo *allocInfo
+ * @return Void
+ *
+ **/
+static Void rgSCHCmnUlSetAllUnSched(RgSchCmnUlRbAllocInfo *allocInfo)
{
CmLList *node;
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnUlAdd2CntResLst
-(
-RgSchCmnUlRbAllocInfo *allocInfo,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUlAdd2CntResLst(allocInfo, ue)
-RgSchCmnUlRbAllocInfo *allocInfo;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUlAdd2CntResLst(RgSchCmnUlRbAllocInfo *allocInfo,RgSchUeCb *ue)
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnUlAdd2UeLst
-(
-RgSchCellCb *cell,
-RgSchCmnUlRbAllocInfo *allocInfo,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUlAdd2UeLst(cell, allocInfo, ue)
-RgSchCellCb *cell;
-RgSchCmnUlRbAllocInfo *allocInfo;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUlAdd2UeLst(RgSchCellCb *cell,RgSchCmnUlRbAllocInfo *allocInfo,RgSchUeCb *ue)
{
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,cell))->alloc);
if (ulAllocInfo->reqLnk.node == NULLP)
* @param[in] RgSchCmnUlRbAllocInfo *allocInfo
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnAllocUlRb
-(
-RgSchCellCb *cell,
-RgSchCmnUlRbAllocInfo *allocInfo
-)
-#else
-Void rgSCHCmnAllocUlRb(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnUlRbAllocInfo *allocInfo;
-#endif
+Void rgSCHCmnAllocUlRb(RgSchCellCb *cell,RgSchCmnUlRbAllocInfo *allocInfo)
{
RgSchUlSf *sf = allocInfo->sf;
* File :
*
**********************************************************/
-#ifdef ANSI
static Void rgSCHCmnUlRbAllocForLst
(
-RgSchCellCb *cell,
-RgSchUlSf *sf,
-uint32_t count,
-CmLListCp *reqLst,
-CmLListCp *schdLst,
-CmLListCp *nonSchdLst,
-Bool isNewTx
+RgSchCellCb *cell,
+RgSchUlSf *sf,
+uint32_t count,
+CmLListCp *reqLst,
+CmLListCp *schdLst,
+CmLListCp *nonSchdLst,
+Bool isNewTx
)
-#else
-static Void rgSCHCmnUlRbAllocForLst(cell, sf, count, reqLst, schdLst,
- nonSchdLst, isNewTx)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-uint32_t count;
-CmLListCp *reqLst;
-CmLListCp *schdLst;
-CmLListCp *nonSchdLst;
-Bool isNewTx;
-#endif
{
CmLList *lnk;
RgSchUlHole *hole;
* File :
*
**********************************************************/
-#ifdef ANSI
static S16 rgSCHCmnUlMdfyGrntForCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-uint32_t maxRb,
-uint32_t *numSb,
-uint8_t *iTbs,
-uint32_t hqSz,
-uint32_t stepDownItbs,
-uint32_t effTgt
+uint32_t maxRb,
+uint32_t *numSb,
+uint8_t *iTbs,
+uint32_t hqSz,
+uint32_t stepDownItbs,
+uint32_t effTgt
)
-#else
-static S16 rgSCHCmnUlMdfyGrntForCqi(cell, ue, maxRb, numSb, iTbs, hqSz, stepDownItbs, effTgt)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint32_t maxRb;
-uint32_t *numSb;
-uint8_t *iTbs;
-uint32_t hqSz;
-uint32_t stepDownItbs;
-uint32_t effTgt;
-#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(ue->cell);
uint32_t nPrb;
* File :
*
**********************************************************/
-#ifdef ANSI
static S16 rgSCHCmnUlRbAllocForUe
(
-RgSchCellCb *cell,
-RgSchUlSf *sf,
-RgSchUeCb *ue,
-uint8_t maxRb,
-RgSchUlHole *hole
+RgSchCellCb *cell,
+RgSchUlSf *sf,
+RgSchUeCb *ue,
+uint8_t maxRb,
+RgSchUlHole *hole
)
-#else
-static S16 rgSCHCmnUlRbAllocForUe(cell, sf, ue, maxRb, hole)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-RgSchUeCb *ue;
-uint8_t maxRb;
-RgSchUlHole *hole;
-#endif
{
- RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
- RgSchUlAlloc *alloc = NULLP;
- uint32_t nPrb = 0;
- uint8_t numVrbg;
- uint8_t iMcs;
- uint8_t iMcsCrnt;
+ RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
+ RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
+ RgSchUlAlloc *alloc = NULLP;
+ uint32_t nPrb = 0;
+ uint8_t numVrbg;
+ uint8_t iMcs;
+ uint8_t iMcsCrnt;
#ifndef RG_5GTF
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->schdHqProcIdx];
#else
rgSCHUhmGetAvlHqProc(cell, ue, &proc);
if (proc == NULLP)
{
- //printf("UE [%d] HQ Proc unavailable\n", ue->ueId);
+ //DU_LOG("\nINFO --> SCH : UE [%d] HQ Proc unavailable\n", ue->ueId);
return RFAILED;
}
#endif
pdcch = rgSCHCmnPdcchAllocCrntSf(cell, ue);
if(pdcch == NULLP)
{
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
+ DU_LOG("\nDEBUG --> SCH : rgSCHCmnUlRbAllocForUe(): Could not get PDCCH for CRNTI:%d",ue->ueId);
return RFAILED;
}
gUl5gtfPdcchSchd++;
if((sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart > MAX_5GTF_VRBG)
|| (sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated > MAX_5GTF_VRBG))
{
- printf("5GTF_ERROR vrbg > 25 valstart = %d valalloc %d\n", sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR vrbg > 25 valstart = %d valalloc %d\n", sf->sfBeamInfo[ue->ue5gtfCb.BeamId].vrbgStart
, sf->sfBeamInfo[ue->ue5gtfCb.BeamId].totVrbgAllocated);
int *p=NULLP;
*p = 10;
}
if (alloc == NULLP)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlRbAllocForUe(): Could not get UlAlloc %d CRNTI:%d",numVrbg,ue->ueId);
rgSCHCmnPdcchRlsCrntSf(cell, pdcch);
return RFAILED;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSCHCmnUlRbAllocAddUeToLst
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-CmLListCp *lst
-)
-#else
-Void rgSCHCmnUlRbAllocAddUeToLst(cell, ue, lst)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-CmLListCp *lst;
-#endif
+Void rgSCHCmnUlRbAllocAddUeToLst(RgSchCellCb *cell,RgSchUeCb *ue,CmLListCp *lst)
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
UNUSED(cell);
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnUlAllocFnlz
-(
-RgSchCellCb *cell,
-RgSchCmnUlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnUlAllocFnlz(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnUlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnUlAllocFnlz(RgSchCellCb *cell,RgSchCmnUlRbAllocInfo *allocInfo)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnDlAllocFnlz
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnDlAllocFnlz(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnDlAllocFnlz(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlRbAllocInfo *allocInfo = &cellSch->allocInfo;
* @param[in] RgSchUlSf *sf
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlUpdSf
-(
-RgSchCellCb *cell,
-RgSchCmnUlRbAllocInfo *allocInfo,
-RgSchUlSf *sf
-)
-#else
-static Void rgSCHCmnUlUpdSf(cell, allocInfo, sf)
-RgSchCellCb *cell;
-RgSchCmnUlRbAllocInfo *allocInfo;
-RgSchUlSf *sf;
-#endif
+static Void rgSCHCmnUlUpdSf(RgSchCellCb *cell,RgSchCmnUlRbAllocInfo *allocInfo,RgSchUlSf *sf)
{
CmLList *lnk;
* @param[in] RgSchUlAlloc *alloc
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlHndlAllocRetx
-(
-RgSchCellCb *cell,
-RgSchCmnUlRbAllocInfo *allocInfo,
-RgSchUlSf *sf,
-RgSchUlAlloc *alloc
-)
-#else
-static Void rgSCHCmnUlHndlAllocRetx(cell, allocInfo, sf, alloc)
-RgSchCellCb *cell;
-RgSchCmnUlRbAllocInfo *allocInfo;
-RgSchUlSf *sf;
-RgSchUlAlloc *alloc;
-#endif
+static Void rgSCHCmnUlHndlAllocRetx(RgSchCellCb *cell,RgSchCmnUlRbAllocInfo *allocInfo,RgSchUlSf *sf,RgSchUlAlloc *alloc)
{
- uint32_t bytes;
+ uint32_t bytes;
RgSchCmnUlUe *ueUl;
bytes = \
rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
retxAlloc = rgSCHCmnUlGetUlAlloc(cell, sf, alloc->numSb);
if (retxAlloc == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
alloc->rnti);
return;
}
* @return Void
**/
/* ccpu00132653- The definition of this function made common for TDD and FDD*/
-#ifdef ANSI
-static Void rgSCHCmnUlAlloc
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnUlAlloc(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnUlAlloc(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
}
else
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "Error! holeDb sanity check failed");
+ DU_LOG("\nERROR --> SCH : holeDb sanity check failed");
}
}
}
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnSndCnsldtInfo
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnSndCnsldtInfo(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnSndCnsldtInfo(RgSchCellCb *cell)
{
- RgInfSfAlloc *subfrmAlloc;
- Pst pst;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ RgInfSfAlloc *subfrmAlloc;
+ Pst pst;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
subfrmAlloc = &(cell->sfAllocArr[cell->crntSfIdx]);
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnCnsldtSfAlloc
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnCnsldtSfAlloc(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnCnsldtSfAlloc(RgSchCellCb *cell)
{
- RgInfSfAlloc *subfrmAlloc;
- CmLteTimingInfo frm;
- RgSchDlSf *dlSf;
- CmLListCp dlDrxInactvTmrLst;
- CmLListCp dlInActvLst;
- CmLListCp ulInActvLst;
- RgSchCmnCell *cellSch = NULLP;
+ RgInfSfAlloc *subfrmAlloc;
+ CmLteTimingInfo frm;
+ RgSchDlSf *dlSf;
+ CmLListCp dlDrxInactvTmrLst;
+ CmLListCp dlInActvLst;
+ CmLListCp ulInActvLst;
+ RgSchCmnCell *cellSch = NULLP;
cmLListInit(&dlDrxInactvTmrLst);
* @param[out] RgSchCmnDlRbAllocInfo *allocInfo
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnInitDlRbAllocInfo
-(
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnInitDlRbAllocInfo(allocInfo)
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnInitDlRbAllocInfo(RgSchCmnDlRbAllocInfo *allocInfo)
{
memset(&allocInfo->pcchAlloc, 0, sizeof(RgSchDlRbAlloc));
memset(&allocInfo->bcchAlloc, 0, sizeof(RgSchDlRbAlloc));
* @param[out] RgSchCmnUlRbAllocInfo *allocInfo
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnInitUlRbAllocInfo
-(
-RgSchCmnUlRbAllocInfo *allocInfo
-)
-#else
-Void rgSCHCmnInitUlRbAllocInfo(allocInfo)
-RgSchCmnUlRbAllocInfo *allocInfo;
-#endif
+Void rgSCHCmnInitUlRbAllocInfo(RgSchCmnUlRbAllocInfo *allocInfo)
{
allocInfo->sf = NULLP;
cmLListInit(&allocInfo->contResLst);
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnGrpPwrCntrlPucch
-(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf
-)
-#else
-static Void rgSCHCmnGrpPwrCntrlPucch(cell, dlSf)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-#endif
+static Void rgSCHCmnGrpPwrCntrlPucch(RgSchCellCb *cell,RgSchDlSf *dlSf)
{
-
rgSCHPwrGrpCntrlPucch(cell, dlSf);
-
return;
}
* @param[in] RgSchUlSf *ulSf
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnGrpPwrCntrlPusch
-(
-RgSchCellCb *cell,
-RgSchUlSf *ulSf
-)
-#else
-static Void rgSCHCmnGrpPwrCntrlPusch(cell, ulSf)
-RgSchCellCb *cell;
-RgSchUlSf *ulSf;
-#endif
+static Void rgSCHCmnGrpPwrCntrlPusch(RgSchCellCb *cell,RgSchUlSf *ulSf)
{
/*removed unused variable *cellSch*/
CmLteTimingInfo frm;
* File :
*
**********************************************************/
-#ifdef ANSI
-static S16 rgSCHCmnApplyUeRefresh
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static S16 rgSCHCmnApplyUeRefresh(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static S16 rgSCHCmnApplyUeRefresh(RgSchCellCb *cell,RgSchUeCb *ue)
{
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- uint32_t effGbrBsr = 0;
- uint32_t effNonGbrBsr = 0;
- uint32_t lcgId;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ uint32_t effGbrBsr = 0;
+ uint32_t effNonGbrBsr = 0;
+ uint32_t lcgId;
/* Reset the refresh cycle variableCAP */
* File :
*
**********************************************************/
-#ifdef ANSI
static S16 rgSCHCmnTmrExpiry
(
PTR cb, /* Pointer to timer control block */
S16 tmrEvnt /* Timer Event */
)
-#else
-static S16 rgSCHCmnTmrExpiry(cb, tmrEvnt)
-PTR cb; /* Pointer to timer control block */
-S16 tmrEvnt; /* Timer Event */
-#endif
{
RgSchUeCb *ue = (RgSchUeCb *)cb;
RgSchCellCb *cell = ue->cell;
#if (ERRCLASS & ERRCLS_DEBUG)
if (tmrEvnt != RG_SCH_CMN_EVNT_UE_REFRESH)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnTmrExpiry(): Invalid "
+ DU_LOG("\nERROR --> SCH : rgSCHCmnTmrExpiry(): Invalid "
"timer event CRNTI:%d",ue->ueId);
return RFAILED;
}
* File :
*
**********************************************************/
-#ifdef ANSI
-static S16 rgSCHCmnTmrProc
-(
-RgSchCellCb *cell
-)
-#else
-static S16 rgSCHCmnTmrProc(cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHCmnTmrProc(RgSchCellCb *cell)
{
RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSchCmnUpdCfiVal
-(
-RgSchCellCb *cell,
-uint8_t delta
-)
-#else
-static Void rgSchCmnUpdCfiVal(cell, delta)
-RgSchCellCb *cell;
-uint8_t delta;
-#endif
+static Void rgSchCmnUpdCfiVal(RgSchCellCb *cell,uint8_t delta)
{
RgSchDlSf *dlSf;
CmLteTimingInfo pdsch;
- RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- uint8_t dlIdx;
+ RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
+ uint8_t dlIdx;
#ifdef LTE_TDD
- uint8_t mPhich;
+ uint8_t mPhich;
RgSchDlSf *tddSf;
- uint8_t idx;
- uint8_t splSfCfi = 0;
+ uint8_t idx;
+ uint8_t splSfCfi = 0;
#endif
*
**********************************************************/
#ifdef LTE_TDD
-#ifdef ANSI
-static Void rgSchCmnUpdtPdcchSfIdx
-(
-RgSchCellCb *cell,
-uint8_t dlIdx,
-uint8_t sfNum
-)
-#else
-static Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, sfNum)
-RgSchCellCb *cell;
-uint8_t dlIdx;
-uint8_t sfNum;
-#endif
-#else
-#ifdef ANSI
-static Void rgSchCmnUpdtPdcchSfIdx
-(
-RgSchCellCb *cell,
-uint8_t dlIdx
-)
+static Void rgSchCmnUpdtPdcchSfIdx(RgSchCellCb *cell,uint8_t dlIdx,uint8_t sfNum)
#else
-static Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx)
-RgSchCellCb *cell;
-uint8_t dlIdx;
-#endif
+static Void rgSchCmnUpdtPdcchSfIdx(RgSchCellCb *cell,uint8_t dlIdx)
#endif
{
- uint8_t idx;
+ uint8_t idx;
/* Resetting the parameters on CFI switching */
* File :
*
**********************************************************/
-#ifdef ANSI
-Void rgSchCmnUpdCfiDb
-(
-RgSchCellCb *cell,
-uint8_t delta
-)
-#else
-Void rgSchCmnUpdCfiDb(cell, delta)
-RgSchCellCb *cell;
-uint8_t delta;
-#endif
+Void rgSchCmnUpdCfiDb(RgSchCellCb *cell,uint8_t delta)
{
- CmLteTimingInfo frm;
- RgSchDlSf *dlSf;
+ CmLteTimingInfo frm;
+ RgSchDlSf *dlSf;
#ifdef LTE_TDD
- uint8_t mPhich;
- Bool isHiDci0;
+ uint8_t mPhich;
+ Bool isHiDci0;
#endif
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- uint8_t nCceLowerCfi = 0;
- uint8_t currCfi;
- uint8_t cceFailIdx;
- uint32_t totalCce;
- uint8_t dlIdx;
- uint16_t ttiMod;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ uint8_t nCceLowerCfi = 0;
+ uint8_t currCfi;
+ uint8_t cceFailIdx;
+ uint32_t totalCce;
+ uint8_t dlIdx;
+ uint16_t ttiMod;
/* Get Downlink Subframe */
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnDlCommonChSch
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnDlCommonChSch(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnDlCommonChSch(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnUlSch
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnUlSch(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnUlSch(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnDlDedBoUpd
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchDlLcCb *svc
-)
-#else
-Void rgSCHCmnDlDedBoUpd(cell, ue, svc)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlLcCb *svc;
-#endif
+Void rgSCHCmnDlDedBoUpd(RgSchCellCb *cell,RgSchUeCb *ue,RgSchDlLcCb *svc)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
{
cellSch->apisEmtcDl->rgSCHDlDedBoUpd(cell, ue, svc);
- //printf("rgSCHEMTCDlDedBoUpd\n");
+ //DU_LOG("\nINFO --> SCH : rgSCHEMTCDlDedBoUpd\n");
}
else
#endif
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnRmvFrmTaLst
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnRmvFrmTaLst(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnRmvFrmTaLst(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnDlMsg4ProcRmvFrmRetx
-(
-RgSchCellCb *cell,
-RgSchDlHqProcCb *hqP
-)
-#else
-Void rgSCHCmnDlMsg4ProcRmvFrmRetx(cell, hqP)
-RgSchCellCb *cell;
-RgSchDlHqProcCb *hqP;
-#endif
+Void rgSCHCmnDlMsg4ProcRmvFrmRetx(RgSchCellCb *cell,RgSchDlHqProcCb *hqP)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnDlProcAddToRetx
-(
-RgSchCellCb *cell,
-RgSchDlHqProcCb *hqP
-)
-#else
-Void rgSCHCmnDlProcAddToRetx(cell, hqP)
-RgSchCellCb *cell;
-RgSchDlHqProcCb *hqP;
-#endif
+Void rgSCHCmnDlProcAddToRetx(RgSchCellCb *cell,RgSchDlHqProcCb *hqP)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlSetUeRi
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t ri,
-Bool isPer
-)
-#else
-static Void rgSCHCmnDlSetUeRi(cell, ue, ri, isPer)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t ri;
-Bool isPer;
-#endif
+static Void rgSCHCmnDlSetUeRi(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t ri,Bool isPer)
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- RgSchCmnUeInfo *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
+ RgSchCmnUeInfo *ueSchCmn = RG_SCH_CMN_GET_CMN_UE(ue);
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ue,cell);
* @return Void
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlSetUePmi
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t pmi
-)
-#else
-static S16 rgSCHCmnDlSetUePmi(cell, ue, pmi)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t pmi;
-#endif
+static S16 rgSCHCmnDlSetUePmi(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t pmi)
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
* -# RFAILED
**/
#ifdef RGR_CQI_REPT
-#ifdef ANSI
static inline Void rgSCHCmnDlProcCqiMode10
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi,
- Bool *isCqiAvail
- )
-#else
-static inline Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi, isCqiAvail)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
- Bool *isCqiAvail;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi,
+Bool *isCqiAvail
+)
#else
-#ifdef ANSI
static inline Void rgSCHCmnDlProcCqiMode10
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi
- )
-#else
-static inline Void rgSCHCmnDlProcCqiMode10(cell, ue, pucchCqi)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi
+)
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode10Info.u.ri,ue->ueId);
return;
}
* -# RFAILED
**/
#ifdef RGR_CQI_REPT
-#ifdef ANSI
static inline Void rgSCHCmnDlProcCqiMode11
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi,
- Bool *isCqiAvail,
- Bool *is2ndCwCqiAvail
- )
-#else
-static inline Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
- Bool *isCqiAvail;
- Bool *is2ndCwCqiAvail;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi,
+Bool *isCqiAvail,
+Bool *is2ndCwCqiAvail
+)
#else
-#ifdef ANSI
static inline Void rgSCHCmnDlProcCqiMode11
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi
- )
-#else
-static inline Void rgSCHCmnDlProcCqiMode11(cell, ue, pucchCqi)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi
+)
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode11Info.u.ri,ue->ueId);
return;
}
* -# RFAILED
**/
#ifdef RGR_CQI_REPT
-#ifdef ANSI
static inline Void rgSCHCmnDlProcCqiMode20
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi,
- Bool *isCqiAvail
- )
-#else
-static inline Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi, isCqiAvail )
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
- Bool *isCqiAvail;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi,
+Bool *isCqiAvail
+)
#else
-#ifdef ANSI
static inline Void rgSCHCmnDlProcCqiMode20
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi
- )
-#else
-static inline Void rgSCHCmnDlProcCqiMode20(cell, ue, pucchCqi)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi
+)
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode20Info.u.ri,ue->ueId);
return;
}
* -# RFAILED
**/
#ifdef RGR_CQI_REPT
-#ifdef ANSI
-static inline Void rgSCHCmnDlProcCqiMode21
-(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi,
- Bool *isCqiAvail,
- Bool *is2ndCwCqiAvail
- )
-#else
-static inline Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi, isCqiAvail, is2ndCwCqiAvail)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
- TfuDlCqiRpt *dlCqiRpt;
- Bool *isCqiAvail;
- Bool *is2ndCwCqiAvail;
-#endif
-#else
-#ifdef ANSI
static inline Void rgSCHCmnDlProcCqiMode21
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi
- )
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi,
+Bool *isCqiAvail,
+Bool *is2ndCwCqiAvail
+)
#else
-static inline Void rgSCHCmnDlProcCqiMode21(cell, ue, pucchCqi)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
-#endif
+static inline Void rgSCHCmnDlProcCqiMode21
+(
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi
+)
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode21Info.u.ri,ue->ueId);
return;
}
* -# RFAILED
**/
#ifdef RGR_CQI_REPT
-#ifdef ANSI
static Void rgSCHCmnDlCqiOnPucchInd
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi,
- RgrUeCqiRept *ueCqiRept,
- Bool *isCqiAvail,
- Bool *is2ndCwCqiAvail
- )
-#else
-static Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
- RgrUeCqiRept *ueCqiRept;
- Bool *isCqiAvail;
- Bool *is2ndCwCqiAvail;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi,
+RgrUeCqiRept *ueCqiRept,
+Bool *isCqiAvail,
+Bool *is2ndCwCqiAvail
+)
#else
-#ifdef ANSI
static Void rgSCHCmnDlCqiOnPucchInd
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPucch *pucchCqi
- )
-#else
-static Void rgSCHCmnDlCqiOnPucchInd(cell, ue, pucchCqi)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPucch *pucchCqi;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPucch *pucchCqi
+)
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
break;
default:
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Unknown CQI Mode %d",
+ DU_LOG("\nERROR --> SCH : Unknown CQI Mode %d of UE %d",
pucchCqi->mode,ue->ueId);
/* ccpu00117452 - MOD - Changed macro name from
RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
* -# RFAILED
**/
#ifdef RGR_CQI_REPT
-#ifdef ANSI
static Void rgSCHCmnDlCqiOnPuschInd
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPusch *puschCqi,
- RgrUeCqiRept *ueCqiRept,
- Bool *isCqiAvail,
- Bool *is2ndCwCqiAvail
- )
-#else
-static Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi, ueCqiRept, isCqiAvail, is2ndCwCqiAvail)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPusch *puschCqi;
- RgrUeCqiRept *ueCqiRept;
- Bool *isCqiAvail;
- Bool *is2ndCwCqiAvail;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPusch *puschCqi,
+RgrUeCqiRept *ueCqiRept,
+Bool *isCqiAvail,
+Bool *is2ndCwCqiAvail
+)
#else
-#ifdef ANSI
static Void rgSCHCmnDlCqiOnPuschInd
(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuDlCqiPusch *puschCqi
- )
-#else
-static Void rgSCHCmnDlCqiOnPuschInd(cell, ue, puschCqi)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuDlCqiPusch *puschCqi;
-#endif
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+TfuDlCqiPusch *puschCqi
+)
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
}
else
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Invalid RI value(%x) CRNTI:%d",
puschCqi->ri.val,ue->ueId);
return;
}
break;
default:
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Unknown CQI Mode %d CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : Unknown CQI Mode %d CRNTI:%d",
puschCqi->mode,ue->ueId);
/* CQI decoding failed revert the RI to previous value */
if ((puschCqi->ri.pres == PRSNT_NODEF) &&
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnDlCqiInd
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-Bool isPucchInfo,
-Void *dlCqi,
-CmLteTimingInfo timingInfo
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+Bool isPucchInfo,
+Void *dlCqi,
+CmLteTimingInfo timingInfo
)
-#else
-Void rgSCHCmnDlCqiInd(cell, ue, isPucchInfo, dlCqi, timingInfo)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-Bool isPucchInfo;
-Void *dlCqi;
-CmLteTimingInfo timingInfo;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
/* ccpu00117452 - MOD - Changed macro name from
* @return Wideband CQI
*
**/
-#ifdef ANSI
-static uint8_t rgSCHCmnCalcWcqiFrmSnr
-(
- RgSchCellCb *cell,
- TfuSrsRpt *srsRpt
- )
-#else
-static uint8_t rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
- RgSchCellCb *cell;
- TfuSrsRpt *srsRpt;
-#endif
+static uint8_t rgSCHCmnCalcWcqiFrmSnr(RgSchCellCb *cell, TfuSrsRpt *srsRpt)
{
uint8_t wideCqi=1; /*Calculated value from SNR*/
/*Need to map a certain SNR with a WideCQI value.
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnSrsInd
-(
- RgSchCellCb *cell,
- RgSchUeCb *ue,
- TfuSrsRpt *srsRpt,
- CmLteTimingInfo timingInfo
- )
-#else
-Void rgSCHCmnSrsInd(cell, ue, srsRpt, timingInfo)
- RgSchCellCb *cell;
- RgSchUeCb *ue;
- TfuSrsRpt *srsRpt;
- CmLteTimingInfo timingInfo;
-#endif
+Void rgSCHCmnSrsInd(RgSchCellCb *cell,RgSchUeCb *ue,TfuSrsRpt *srsRpt,CmLteTimingInfo timingInfo)
{
uint8_t wideCqi; /*Calculated value from SNR*/
uint32_t recReqTime; /*Received Time in TTI*/
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnDlTARpt
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnDlTARpt(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnDlTARpt(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
}
else
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "<TA>TA duplicate entry attempt failed: UEID:%u",
+ DU_LOG("\nERROR --> SCH : <TA>TA duplicate entry attempt failed: UEID:%u",
ue->ueId);
}
}
* @param[in] uint8_t wideCqi
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnFindUlCqiUlTxAnt
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t wideCqi
-)
-#else
-static Void rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t wideCqi;
-#endif
+static Void rgSCHCmnFindUlCqiUlTxAnt(RgSchCellCb *cell,RgSchUeCb *ue,uint8_t wideCqi)
{
ue->validTxAnt = 1;
return;
* @param[in] TfuUlCqiRpt *ulCqiInfo
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnUlCqiInd
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-TfuUlCqiRpt *ulCqiInfo
-)
-#else
-Void rgSCHCmnUlCqiInd(cell, ue, ulCqiInfo)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-TfuUlCqiRpt *ulCqiInfo;
-#endif
+Void rgSCHCmnUlCqiInd(RgSchCellCb *cell,RgSchUeCb *ue,TfuUlCqiRpt *ulCqiInfo)
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef UL_LA
- uint8_t iTbsNew;
+ uint8_t iTbsNew;
S32 previTbs;
#endif
#if (defined(SCH_STATS) || defined(TENB_STATS))
* @param[out] RgSchUlHqProcCb **procRef
* @return Void
**/
-#ifdef ANSI
Void rgSCHCmnUlHqProcForUe
(
-RgSchCellCb *cell,
-CmLteTimingInfo frm,
-RgSchUeCb *ue,
-RgSchUlHqProcCb **procRef
+RgSchCellCb *cell,
+CmLteTimingInfo frm,
+RgSchUeCb *ue,
+RgSchUlHqProcCb **procRef
)
-#else
-Void rgSCHCmnUlHqProcForUe(cell, frm, ue, procRef)
-RgSchCellCb *cell;
-CmLteTimingInfo frm;
-RgSchUeCb *ue;
-RgSchUlHqProcCb **procRef;
-#endif
{
#ifndef RG_5GTF
uint8_t procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnUpdUlHqProc
(
RgSchCellCb *cell,
RgSchUlHqProcCb *curProc,
RgSchUlHqProcCb *oldProc
)
-#else
-S16 rgSCHCmnUpdUlHqProc(cell, curProc, oldProc)
-RgSchCellCb *cell;
-RgSchUlHqProcCb *curProc;
-RgSchUlHqProcCb *oldProc;
-#endif
{
UNUSED(cell);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-S16 rgSCHCmnBsrTmrExpry
-(
-RgSchUeCb *ueCb
-)
-#else
-S16 rgSCHCmnBsrTmrExpry(ueCb)
-RgSchUeCb *ueCb;
-#endif
+S16 rgSCHCmnBsrTmrExpry(RgSchUeCb *ueCb)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ueCb->cell);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnUpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-RgSchLcgCb *ulLcg,
-uint8_t bsr,
+RgSchLcgCb *ulLcg,
+uint8_t bsr,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnUpdBsrShort(cell, ue, ulLcg, bsr, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchLcgCb *ulLcg;
-uint8_t bsr;
-RgSchErrInfo *err;
-#endif
{
uint8_t lcgCnt;
#ifdef LTE_L2_MEAS
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnUpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-RgSchLcgCb *ulLcg,
-uint8_t bsr,
+RgSchLcgCb *ulLcg,
+uint8_t bsr,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnUpdBsrTrunc(cell, ue, ulLcg, bsr, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchLcgCb *ulLcg;
-uint8_t bsr;
-RgSchErrInfo *err;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnLcg *cmnLcg = NULLP;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnUpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-uint8_t *bsArr,
+uint8_t *bsArr,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t *bsArr;
-RgSchErrInfo *err;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- uint32_t tmpBsArr[4] = {0, 0, 0, 0};
- uint32_t nonGbrBs = 0;
+ uint32_t tmpBsArr[4] = {0, 0, 0, 0};
+ uint32_t nonGbrBs = 0;
#ifdef LTE_L2_MEAS
- uint8_t idx1;
- uint8_t idx2;
+ uint8_t idx1;
+ uint8_t idx2;
#endif
- uint32_t lcgId;
-
+ uint32_t lcgId;
#ifdef LTE_L2_MEAS
for(idx1 = 1; idx1 < RGSCH_MAX_LCG_PER_UE; idx1++)
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnUpdExtPhr
(
RgSchCellCb *cell,
RgInfExtPhrCEInfo *extPhr,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnUpdExtPhr(cell, ue, extPhr, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgInfExtPhrCEInfo *extPhr;
-RgSchErrInfo *err;
-#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
RgSchCmnAllocRecord *allRcd;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-uint8_t phr,
+uint8_t phr,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t phr;
-RgSchErrInfo *err;
-#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
RgSchCmnAllocRecord *allRcd;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnContResUlGrant(cell, ue, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchErrInfo *err;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgSCHCmnSrRcvd
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
RgSchErrInfo *err
)
-#else
-S16 rgSCHCmnSrRcvd(cell, ue, frm, err)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-CmLteTimingInfo frm;
-RgSchErrInfo *err;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
* @param[in] RgSchCellCb *cell
* @return RgSchUlAlloc*
**/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHCmnFirstRcptnReq
-(
-RgSchCellCb *cell
-)
-#else
-RgSchUlAlloc *rgSCHCmnFirstRcptnReq(cell)
-RgSchCellCb *cell;
-#endif
+RgSchUlAlloc *rgSCHCmnFirstRcptnReq(RgSchCellCb *cell)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
/* ACC_TDD */
* @param[in] RgSchCellCb *cell
* @return RgSchUlAlloc*
**/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHCmnNextRcptnReq
-(
-RgSchCellCb *cell,
-RgSchUlAlloc *alloc
-)
-#else
-RgSchUlAlloc *rgSCHCmnNextRcptnReq(cell, alloc)
-RgSchCellCb *cell;
-RgSchUlAlloc *alloc;
-#endif
+RgSchUlAlloc *rgSCHCmnNextRcptnReq(RgSchCellCb *cell,RgSchUlAlloc *alloc)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
/* ACC-TDD */
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnDrxStrtInActvTmrInUl
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnDrxStrtInActvTmrInUl(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnDrxStrtInActvTmrInUl(RgSchCellCb *cell)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlSf *sf = &(cellUl->ulSfArr[cellUl->schdIdx]);
* @param[in] uint8_t idx
* @return RgSchUlAlloc*
**/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
-(
-RgSchCellCb *cell,
-uint8_t idx
-)
-#else
-RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
-RgSchCellCb *cell;
-uint8_t idx;
-#endif
+RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(RgSchCellCb *cell,uint8_t idx)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
/* ACC-TDD */
* @param[in] RgSchCellCb *cell
* @return RgSchUlAlloc*
**/
-#ifdef ANSI
-RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc
-(
-RgSchCellCb *cell,
-RgSchUlAlloc *alloc,
-uint8_t idx
-)
-#else
-RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
-RgSchCellCb *cell;
-RgSchUlAlloc *alloc;
-uint8_t idx;
-#endif
+RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(RgSchCellCb *cell,RgSchUlAlloc *alloc,uint8_t idx)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
* File :
*
**********************************************************/
-#ifdef ANSI
-uint8_t rgSCHCmnUlGetITbsFrmIMcs
-(
-uint8_t iMcs
-)
-#else
-uint8_t rgSCHCmnUlGetITbsFrmIMcs(iMcs)
-uint8_t iMcs;
-#endif
+uint8_t rgSCHCmnUlGetITbsFrmIMcs(uint8_t iMcs)
{
-
return (rgUlIMcsTbl[iMcs].iTbs);
}
* File :
*
**********************************************************/
-#ifdef ANSI
-uint8_t rgSCHCmnUlGetIMcsFrmITbs
-(
-uint8_t iTbs,
-CmLteUeCategory ueCtg
-)
-#else
-uint8_t rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
-uint8_t iTbs;
-CmLteUeCategory ueCtg;
-#endif
+uint8_t rgSCHCmnUlGetIMcsFrmITbs(uint8_t iTbs,CmLteUeCategory ueCtg)
{
uint8_t iMcs;
* File :
*
**********************************************************/
-#ifdef ANSI
-uint32_t rgSCHCmnUlMinTbBitsForITbs
-(
-RgSchCmnUlCell *cellUl,
-uint8_t iTbs
-)
-#else
-uint32_t rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
-RgSchCmnUlCell *cellUl;
-uint8_t iTbs;
-#endif
+uint32_t rgSCHCmnUlMinTbBitsForITbs(RgSchCmnUlCell *cellUl,uint8_t iTbs)
{
RGSCH_ARRAY_BOUND_CHECK(0, rgTbSzTbl[0], iTbs);
* File :
*
**********************************************************/
-#ifdef ANSI
RgSchUlAlloc *rgSCHCmnUlSbAlloc
(
-RgSchUlSf *sf,
-uint8_t numSb,
-RgSchUlHole *hole
+RgSchUlSf *sf,
+uint8_t numSb,
+RgSchUlHole *hole
)
-#else
-RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
-RgSchUlSf *sf;
-uint8_t numSb;
-RgSchUlHole *hole;
-#endif
{
- uint8_t holeSz; /* valid hole size */
+ uint8_t holeSz; /* valid hole size */
RgSchUlAlloc *alloc;
if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
* @param[out] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnUlUeFillAllocInfo
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUlUeFillAllocInfo(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUlUeFillAllocInfo(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUeUlAlloc *ulAllocInfo;
* @param[in] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUpdUlCompEffBsr
-(
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnUpdUlCompEffBsr(ue)
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnUpdUlCompEffBsr(RgSchUeCb *ue)
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,ue->cell);
CmLList *node = ueUl->ulAllocLst.last;
* @param[in] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnUlRecordUeAlloc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-Void rgSCHCmnUlRecordUeAlloc(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+Void rgSCHCmnUlRecordUeAlloc(RgSchCellCb *cell,RgSchUeCb *ue)
{
#ifdef LTE_TDD
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
* @param[in] RgSchRaCb *raCb
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnUlRecMsg3Alloc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchRaCb *raCb
-)
-#else
-Void rgSCHCmnUlRecMsg3Alloc(cell, ue, raCb)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchRaCb *raCb;
-#endif
+Void rgSCHCmnUlRecMsg3Alloc(RgSchCellCb *cell,RgSchUeCb *ue,RgSchRaCb *raCb)
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
CmLListCp *lst = &ueUl->ulAllocLst;
* @param[in] uint32_t alloc
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnUlUpdOutStndAlloc
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint32_t alloc
-)
-#else
-Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint32_t alloc;
-#endif
+Void rgSCHCmnUlUpdOutStndAlloc(RgSchCellCb *cell,RgSchUeCb *ue,uint32_t alloc)
{
- uint32_t nonLcg0Alloc=0;
+ uint32_t nonLcg0Alloc=0;
/* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
* @param[in] RgSchUeCb *ue
* @return uint8_t
**/
-#ifdef ANSI
uint8_t rgSCHCmnUlGetITbs
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-Bool isEcp
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+Bool isEcp
)
-#else
-uint8_t rgSCHCmnUlGetITbs(cell, ue, isEcp)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-Bool isEcp;
-#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
/* CQI will be capped to maxUlCqi for 16qam UEs */
CmLteUeCategory ueCtgy = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- uint8_t cqi;
+ uint8_t cqi;
#ifdef UL_LA
S32 iTbs;
- uint8_t maxiTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ueUl->maxUlCqi];
+ uint8_t maxiTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ueUl->maxUlCqi];
#endif
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlRbInfoAddUeTx
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
-#else
-static Void rgSCHCmnDlRbInfoAddUeTx(cell, allocInfo, ue, hqP)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *hqP;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlRbInfoAddUeRetx
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
-#else
-static Void rgSCHCmnDlRbInfoAddUeRetx(cell, allocInfo, ue, hqP)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *hqP;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlRbInfoAddUeRetxTx
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
-#else
-static Void rgSCHCmnDlRbInfoAddUeRetxTx(allocInfo, ue, hqP)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *hqP;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(ue->cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAdd2NonSchdRetxLst
(
RgSchCmnDlRbAllocInfo *allocInfo,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
-#else
-static Void rgSCHCmnDlAdd2NonSchdRetxLst(allocInfo, ue, hqP)
-RgSchCmnDlRbAllocInfo *allocInfo;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *hqP;
-#endif
{
CmLList *schdLnkNode;
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlANFdbkInit
-(
-RgSchCellCb *cell
-)
-#else
-static S16 rgSCHCmnDlANFdbkInit(cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHCmnDlANFdbkInit(RgSchCellCb *cell)
{
- uint8_t sfCount;
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
- uint8_t maxDlSubfrms = cell->numDlSubfrms;
- uint8_t sfNum;
- uint8_t idx;
- uint8_t dlIdx;
- uint8_t calcSfnOffset;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t idx;
+ uint8_t dlIdx;
+ uint8_t calcSfnOffset;
S8 calcSfNum;
- uint8_t ulSfCnt =0;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo;
- uint8_t maxUlSubfrms;
+ uint8_t maxUlSubfrms;
ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlKdashUlAscInit
-(
-RgSchCellCb *cell
-)
-#else
-static S16 rgSCHCmnDlKdashUlAscInit(cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHCmnDlKdashUlAscInit(RgSchCellCb *cell)
{
- uint8_t sfCount;
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
- uint8_t maxDlSubfrms = cell->numDlSubfrms;
- uint8_t sfNum;
- uint8_t dlIdx;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t dlIdx;
S8 calcSfnOffset;
S8 calcSfNum;
- uint8_t ulSfCnt =0;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
- uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
- [RGSCH_NUM_SUB_FRAMES-1];
- uint8_t dlPres = 0;
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
+ uint8_t dlPres = 0;
/* Generate ACK/NACK offset information for each DL subframe in a radio frame
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlNpValInit
-(
-RgSchCellCb *cell
-)
-#else
-static S16 rgSCHCmnDlNpValInit(cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHCmnDlNpValInit(RgSchCellCb *cell)
{
uint8_t idx;
uint16_t np;
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlCreateRachPrmLst
-(
-RgSchCellCb *cell
-)
-#else
-static S16 rgSCHCmnDlCreateRachPrmLst(cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHCmnDlCreateRachPrmLst(RgSchCellCb *cell)
{
- uint8_t raArrSz;
- S16 ret;
- uint8_t lstSize;
-
+ uint8_t raArrSz;
+ S16 ret;
+ uint8_t lstSize;
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlRachInfoInit
-(
-RgSchCellCb *cell
-)
-#else
-static S16 rgSCHCmnDlRachInfoInit(cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHCmnDlRachInfoInit(RgSchCellCb *cell)
{
uint8_t sfCount;
uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
* @return S16
*
**/
-#ifdef ANSI
-static S16 rgSCHCmnDlPhichOffsetInit
-(
-RgSchCellCb *cell
-)
-#else
-static S16 rgSCHCmnDlPhichOffsetInit(cell)
-RgSchCellCb *cell;
-#endif
+static S16 rgSCHCmnDlPhichOffsetInit(RgSchCellCb *cell)
{
- uint8_t sfCount;
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
- uint8_t maxDlSubfrms = cell->numDlSubfrms;
- uint8_t sfNum;
- uint8_t dlIdx;
- uint8_t dlPres = 0;
- uint8_t calcSfnOffset;
- uint8_t calcSfNum;
- uint8_t ulSfCnt =0;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t dlIdx;
+ uint8_t dlPres = 0;
+ uint8_t calcSfnOffset;
+ uint8_t calcSfNum;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
- uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
* @return Void
*
**/
-#ifdef ANSI
-Void rgSCHCmnUpdVars
-(
-RgSchCellCb *cell
-)
-#else
-Void rgSCHCmnUpdVars(cell)
-RgSchCellCb *cell;
-#endif
+Void rgSCHCmnUpdVars(RgSchCellCb *cell)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
CmLteTimingInfo timeInfo;
* @return uint8_t
*
**/
-#ifdef ANSI
-uint8_t rgSCHCmnGetPValFrmCCE
-(
-RgSchCellCb *cell,
-uint8_t cce
-)
-#else
-uint8_t rgSCHCmnGetPValFrmCCE(cell, cce)
-RgSchCellCb *cell;
-uint8_t cce;
-#endif
+uint8_t rgSCHCmnGetPValFrmCCE(RgSchCellCb *cell,uint8_t cce)
{
uint8_t i;
* File :
*
**********************************************************/
-#ifdef ANSI
-static Void rgSCHCmnUlAdapRetx
-(
-RgSchUlAlloc *alloc,
-RgSchUlHqProcCb *proc
-)
-#else
-static Void rgSCHCmnUlAdapRetx(alloc, proc)
-RgSchUlAlloc *alloc;
-RgSchUlHqProcCb *proc;
-#endif
+static Void rgSCHCmnUlAdapRetx(RgSchUlAlloc *alloc,RgSchUlHqProcCb *proc)
{
rgSCHUhmRetx(proc, alloc);
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnHdlUlInactUes
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnHdlUlInactUes(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnHdlUlInactUes(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp ulInactvLst;
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnHdlDlInactUes
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnHdlDlInactUes(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnHdlDlInactUes(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLListCp dlInactvLst;
* File :
*
**********************************************************/
-#ifdef ANSI
-static S16 rgSCHCmnUeIdleExdThrsld
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static S16 rgSCHCmnUeIdleExdThrsld(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static S16 rgSCHCmnUeIdleExdThrsld(RgSchCellCb *cell,RgSchUeCb *ue)
{
/* Time difference in subframes */
uint32_t sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
-
if (sfDiff > (uint32_t)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
{
return ROK;
*
* @param[in] RgSchCellCb *cell
* @return Void
- **/
-#ifdef ANSI
-static Void rgSCHCmnCfgRachDedPrm
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnCfgRachDedPrm(cell)
-RgSchCellCb *cell;
-#endif
+ **/
+static Void rgSCHCmnCfgRachDedPrm(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
- uint32_t sfDiff;
- uint8_t cnt;
+ uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
+ uint32_t sfDiff;
+ uint8_t cnt;
if (cell->macPreambleSet.pres == NOTPRSNT)
{
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUpdNxtPrchMskIdx
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnUpdNxtPrchMskIdx(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnUpdNxtPrchMskIdx(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUpdRachParam
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnUpdRachParam(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnUpdRachParam(RgSchCellCb *cell)
{
- RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
- uint32_t sfDiff;
+ RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
+ uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
+ uint32_t sfDiff;
if (cell->macPreambleSet.pres == NOTPRSNT)
{
* @param[out] uint8_t *prachMskIdx
* @return Void
**/
-#ifdef ANSI
static S16 rgSCHCmnAllocPOParam
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchUeCb *ue,
RgSchPdcch **pdcch,
-uint8_t *rapId,
-uint8_t *prachMskIdx
+uint8_t *rapId,
+uint8_t *prachMskIdx
)
-#else
-static S16 rgSCHCmnAllocPOParam(cell, dlSf, ue, pdcch, rapId, prachMskIdx)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-RgSchUeCb *ue;
-RgSchPdcch **pdcch;
-uint8_t *rapId;
-uint8_t *prachMskIdx;
-#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
* @param[in] RgSchDlSf *dlSf
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnGenPdcchOrder
-(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf
-)
-#else
-static Void rgSCHCmnGenPdcchOrder(cell, dlSf)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-#endif
+static Void rgSCHCmnGenPdcchOrder(RgSchCellCb *cell,RgSchDlSf *dlSf)
{
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- CmLList *node = cellSch->rachCfg.pdcchOdrLst.first;
- RgSchUeCb *ue;
- uint8_t rapId;
- uint8_t prachMskIdx;
- RgSchPdcch *pdcch = NULLP;
-
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ CmLList *node = cellSch->rachCfg.pdcchOdrLst.first;
+ RgSchUeCb *ue;
+ uint8_t rapId;
+ uint8_t prachMskIdx;
+ RgSchPdcch *pdcch = NULLP;
while (node)
{
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlAdd2PdcchOdrQ
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnDlAdd2PdcchOdrQ(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnDlAdd2PdcchOdrQ(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
* @return Void
*
**/
-#ifdef ANSI
-static Void rgSCHCmnDlRmvFrmPdcchOdrQ
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnDlRmvFrmPdcchOdrQ(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnDlRmvFrmPdcchOdrQ(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
-
cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = NULLP;
return;
* @param[in] uint8_t prachMskIdx
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnFillPdcchOdr2Sf
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchPdcch *pdcch,
-uint8_t rapId,
-uint8_t prachMskIdx
+uint8_t rapId,
+uint8_t prachMskIdx
)
-#else
-static Void rgSCHCmnFillPdcchOdr2Sf(ue, pdcch, rapId, prachMskIdx)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchPdcch *pdcch;
-uint8_t rapId;
-uint8_t prachMskIdx;
-#endif
{
RgSchUeACqiCb *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell);
* @param[in] RgSchUeCb *ue
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnDelRachInfo
-(
-RgSchCellCb *cell,
-RgSchUeCb *ue
-)
-#else
-static Void rgSCHCmnDelRachInfo(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
+static Void rgSCHCmnDelRachInfo(RgSchCellCb *cell,RgSchUeCb *ue)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnHdlHoPo
(
RgSchCellCb *cell,
CmLListCp *raRspLst,
RgSchRaReqInfo *raReq
)
-#else
-static Void rgSCHCmnHdlHoPo(cell, raRspLst, raReq)
-RgSchCellCb *cell;
-CmLListCp *raRspLst;
-RgSchRaReqInfo *raReq;
-#endif
{
RgSchUeCb *ue = raReq->ue;
* @return RgSchUeCb*
*
**/
-#ifdef ANSI
-RgSchUeCb* rgSCHCmnGetHoUe
-(
-RgSchCellCb *cell,
-uint16_t rapId
-)
-#else
-RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
-RgSchCellCb *cell;
-uint16_t rapId
-#endif
+RgSchUeCb* rgSCHCmnGetHoUe(RgSchCellCb *cell,uint16_t rapId)
{
- RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- CmLList *node;
- CmLListCp *ueLst;
- RgSchUeCb *ue;
- RgSchCmnDlUe *ueDl;
+ RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
+ CmLList *node;
+ CmLListCp *ueLst;
+ RgSchUeCb *ue;
+ RgSchCmnDlUe *ueDl;
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
return (NULLP);
}
-#ifdef ANSI
-static Void rgSCHCmnDelDedPreamble
-(
-RgSchCellCb *cell,
-uint8_t preambleId
-)
-#else
-static rgSCHCmnDelDedPreamble(cell, preambleId)
-RgSchCellCb *cell;
-uint8_t preambleId;
-#endif
+static Void rgSCHCmnDelDedPreamble(RgSchCellCb *cell,uint8_t preambleId)
{
- RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- CmLList *node;
- CmLListCp *ueLst;
- RgSchUeCb *ue;
- RgSchCmnDlUe *ueDl;
+ RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
+ CmLList *node;
+ CmLListCp *ueLst;
+ RgSchUeCb *ue;
+ RgSchCmnDlUe *ueDl;
ueLst = &cellSch->rachCfg.hoUeLst;
node = ueLst->first;
* @return RgSchUeCb*
*
**/
-#ifdef ANSI
RgSchUeCb* rgSCHCmnGetPoUe
(
-RgSchCellCb *cell,
-uint16_t rapId,
-CmLteTimingInfo timingInfo
+RgSchCellCb *cell,
+uint16_t rapId,
+CmLteTimingInfo timingInfo
)
-#else
-RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
-RgSchCellCb *cell;
-uint16_t rapId;
-CmLteTimingInfo timingInfo;
-#endif
{
- RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- CmLList *node;
- CmLListCp *ueLst;
- RgSchUeCb *ue;
- RgSchCmnDlUe *ueDl;
- uint8_t rapIdIdx;
+ RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
+ CmLList *node;
+ CmLListCp *ueLst;
+ RgSchUeCb *ue;
+ RgSchCmnDlUe *ueDl;
+ uint8_t rapIdIdx;
rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
* @param[in] uint8_t ueCtgy
* @return uint8_t
**/
-#ifdef ANSI
uint8_t rgSCHCmnUlGetCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteUeCategory ueCtgy
)
-#else
-uint8_t rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-CmLteUeCategory ueCtgy;
-#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
uint8_t cqi;
* File :
*
**********************************************************/
-#ifdef ANSI
static S16 rgSCHCmnUlRbAllocForPoHoUe
(
-RgSchCellCb *cell,
-RgSchUlSf *sf,
-RgSchUeCb *ue,
-uint8_t maxRb
+RgSchCellCb *cell,
+RgSchUlSf *sf,
+RgSchUeCb *ue,
+uint8_t maxRb
)
-#else
-static S16 rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, maxRb)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-RgSchUeCb *ue;
-uint8_t maxRb;
-#endif
{
- RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
+ RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
+ RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
uint8_t sbSize = cellUl->sbSize;
uint32_t maxBits = ue->ul.maxBytesPerUePerTti*8;
uint32_t bits;
- RgSchUlAlloc *alloc;
+ RgSchUlAlloc *alloc;
uint32_t nPrb;
uint8_t iTbs;
uint32_t eff;
uint8_t modOdr;
RgSchUlHole *hole;
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
- CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
+ CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
{
hole);
if (alloc == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUlRbAllocForPoHoUe(): Could not get UlAlloc");
return RFAILED;
}
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnAllocPoHoGrnt
(
-RgSchCellCb *cell,
-CmLListCp *raRspLst,
-RgSchUeCb *ue,
-RgSchRaReqInfo *raReq
+RgSchCellCb *cell,
+CmLListCp *raRspLst,
+RgSchUeCb *ue,
+RgSchRaReqInfo *raReq
)
-#else
-static Void rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq)
-RgSchCellCb *cell;
-CmLListCp *raRspLst;
-RgSchUeCb *ue;
-RgSchRaReqInfo *raReq;
-#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
/* KWork fix */
if (grnt == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_INSTID,cell->instIdx, "Failed to get"
+ DU_LOG("\nERROR --> SCH : Failed to get"
"the grant for HO/PDCCH Order. CRNTI:%d",ue->ueId);
return;
}
*
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static Void rgSCHCmnUlNonadapRetx
(
RgSchCmnUlCell *cellUl,
RgSchUlAlloc *alloc,
-uint8_t idx
+uint8_t idx
)
-#else
-static Void rgSCHCmnUlNonadapRetx(cellUl, alloc, idx)
-RgSchCmnUlCell *cellUl;
-RgSchUlAlloc *alloc;
-uint8_t idx;
-#endif
{
rgSCHUhmRetx(alloc->hqProc, alloc);
* @param[in] RgSchUlAlloc *alloc2
* @return Bool
**/
-#ifdef ANSI
-static Bool rgSCHCmnUlAllocsOvrLap
-(
-RgSchUlAlloc *alloc1,
-RgSchUlAlloc *alloc2
-)
-#else
-static Bool rgSCHCmnUlAllocsOvrLap(alloc1, alloc2)
-RgSchUlAlloc *alloc1;
-RgSchUlAlloc *alloc2;
-#endif
+static Bool rgSCHCmnUlAllocsOvrLap(RgSchUlAlloc *alloc1,RgSchUlAlloc *alloc2)
{
-
if (((alloc1->sbStart >= alloc2->sbStart) &&
(alloc1->sbStart <= alloc2->sbStart + alloc2->numSb-1)) ||
((alloc2->sbStart >= alloc1->sbStart) &&
* @param[in] RgSchUlAlloc *dstAlloc
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlCpyAllocInfo
-(
-RgSchCellCb *cell,
-RgSchUlAlloc *srcAlloc,
-RgSchUlAlloc *dstAlloc
-)
-#else
-static Void rgSCHCmnUlCpyAllocInfo(cell, srcAlloc, dstAlloc)
-RgSchCellCb *cell;
-RgSchUlAlloc *srcAlloc;
-RgSchUlAlloc *dstAlloc;
-#endif
+static Void rgSCHCmnUlCpyAllocInfo(RgSchCellCb *cell,RgSchUlAlloc *srcAlloc,RgSchUlAlloc *dstAlloc)
{
RgSchCmnUlUe *ueUl;
* @param[in] RgSchUlAlloc *srcAlloc
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnUlInsAllocFrmNewSf2OldSf
(
RgSchCellCb *cell,
RgSchUlSf *oldSf,
RgSchUlAlloc *srcAlloc
)
-#else
-static Void rgSCHCmnUlInsAllocFrmNewSf2OldSf(cell, newSf, oldSf, srcAlloc)
-RgSchCellCb *cell;
-RgSchUlSf *newSf;
-RgSchUlSf *oldSf;
-RgSchUlAlloc *srcAlloc;
-#endif
{
RgSchUlAlloc *alloc, *dstAlloc, *nxtAlloc;
/* This should never happen */
if (dstAlloc == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d "
+ DU_LOG("\nERROR --> SCH : CRNTI:%d "
"rgSCHUtlUlGetSpfcAlloc failed in rgSCHCmnUlInsAllocFrmNewSf2OldSf",
srcAlloc->rnti);
return;
* @param[in] RgSchUlSf *newSf
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlMergeSfAllocs
-(
-RgSchCellCb *cell,
-RgSchUlSf *oldSf,
-RgSchUlSf *newSf
-)
-#else
-static Void rgSCHCmnUlMergeSfAllocs(cell, oldSf, newSf)
-RgSchCellCb *cell;
-RgSchUlSf *oldSf;
-RgSchUlSf *newSf;
-#endif
+static Void rgSCHCmnUlMergeSfAllocs(RgSchCellCb *cell,RgSchUlSf *oldSf,RgSchUlSf *newSf)
{
RgSchUlAlloc *alloc, *nxtAlloc;
UNUSED(cell);
* @param[in] RgSchUlSf *newSf
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlSwapSfAllocs
-(
-RgSchCellCb *cell,
-RgSchUlSf *oldSf,
-RgSchUlSf *newSf
-)
-#else
-static Void rgSCHCmnUlSwapSfAllocs(cell, oldSf, newSf)
-RgSchCellCb *cell;
-RgSchUlSf *oldSf;
-RgSchUlSf *newSf;
-#endif
+static Void rgSCHCmnUlSwapSfAllocs(RgSchCellCb *cell,RgSchUlSf *oldSf,RgSchUlSf *newSf)
{
RgSchUlAllocDb *tempAllocDb = newSf->allocDb;
RgSchUlHoleDb *tempHoleDb = newSf->holeDb;
- uint8_t tempAvailSbs = newSf->availSubbands;
+ uint8_t tempAvailSbs = newSf->availSubbands;
UNUSED(cell);
* @param[in] uint8_t idx
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlPrcNonAdptRetx
-(
-RgSchCellCb *cell,
-RgSchUlSf *newSf,
-uint8_t idx
-)
-#else
-static Void rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx)
-RgSchCellCb *cell;
-RgSchUlSf *newSf;
-uint8_t idx;
-#endif
+static Void rgSCHCmnUlPrcNonAdptRetx(RgSchCellCb *cell,RgSchUlSf *newSf,uint8_t idx)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlAlloc *alloc, *nxtAlloc;
* @param[in] uint8_t idx
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnUlPrfmSfMerge
(
RgSchCellCb *cell,
RgSchUlSf *oldSf,
RgSchUlSf *newSf,
-uint8_t idx
+uint8_t idx
)
-#else
-static Void rgSCHCmnUlPrfmSfMerge(cell, oldSf, newSf, idx)
-RgSchCellCb *cell;
-RgSchUlSf *oldSf;
-RgSchUlSf *newSf;
-uint8_t idx;
-#endif
{
/* Preassigned resources for msg3 in newSf.
* Hence do adaptive retx for all NACKED TXs */
* @param[in] RgSchUlSf *sf
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlRmvCmpltdAllocs
-(
-RgSchCellCb *cell,
-RgSchUlSf *sf
-)
-#else
-static Void rgSCHCmnUlRmvCmpltdAllocs(cell, sf)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-#endif
+static Void rgSCHCmnUlRmvCmpltdAllocs(RgSchCellCb *cell,RgSchUlSf *sf)
{
RgSchUlAlloc *alloc, *nxtAlloc;
{
nxtAlloc = rgSCHUtlUlAllocNxt(sf, alloc);
#ifdef UL_ADPT_DBG
- printf("rgSCHCmnUlRmvCmpltdAllocs:time(%d %d) alloc->hqProc->remTx %d hqProcId(%d) \n",cell->crntTime.sfn,cell->crntTime.slot,alloc->hqProc->remTx, alloc->grnt.hqProcId);
+ DU_LOG("\nDEBUG --> SCH : rgSCHCmnUlRmvCmpltdAllocs:time(%d %d) alloc->hqProc->remTx %d hqProcId(%d) \n",cell->crntTime.sfn,cell->crntTime.slot,alloc->hqProc->remTx, alloc->grnt.hqProcId);
#endif
alloc->hqProc->rcvdCrcInd = TRUE;
if ((alloc->hqProc->rcvdCrcInd) || (alloc->hqProc->remTx == 0))
* @param[in] uint8_t idx
* @return Void
**/
-#ifdef ANSI
-Void rgSCHCmnRlsUlSf
-(
-RgSchCellCb *cell,
-uint8_t idx
-)
-#else
-Void rgSCHCmnRlsUlSf(cell, idx)
-RgSchCellCb *cell;
-uint8_t idx;
-#endif
+Void rgSCHCmnRlsUlSf(RgSchCellCb *cell,uint8_t idx)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
-
if (cellUl->hqFdbkIdx[idx] != RGSCH_INVALID_INFO)
{
RgSchUlSf *oldSf = &cellUl->ulSfArr[cellUl->hqFdbkIdx[idx]];
* @param[in] RgSchUlAlloc *alloc
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnUlUpdAllocRetx
-(
-RgSchCellCb *cell,
-RgSchUlAlloc *alloc
-)
-#else
-static Void rgSCHCmnUlUpdAllocRetx(cell, alloc)
-RgSchCellCb *cell;
-RgSchUlAlloc *alloc;
-#endif
+static Void rgSCHCmnUlUpdAllocRetx(RgSchCellCb *cell,RgSchUlAlloc *alloc)
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
-
alloc->hqProc->reTxAlloc.rnti = alloc->rnti;
alloc->hqProc->reTxAlloc.numSb = alloc->numSb;
alloc->hqProc->reTxAlloc.iMcs = alloc->grnt.iMcs;
alloc->hqProc->alloc = NULLP;
alloc->hqProc->ulSfIdx = RGSCH_INVALID_INFO;
#ifdef UL_ADPT_DBG
- printf("Adding Harq Proc Id in the retx list hqProcId %d \n",alloc->grnt.hqProcId);
+ DU_LOG("\nDEBUG --> SCH : Adding Harq Proc Id in the retx list hqProcId %d \n",alloc->grnt.hqProcId);
#endif
cmLListAdd2Tail(&cmnUlCell->reTxLst, &alloc->hqProc->reTxLnk);
alloc->hqProc->reTxLnk.node = (PTR)alloc->hqProc;
* @param[in] RgSchUlHole *hole;
* @return uint8_t
**/
-#ifdef ANSI
static Bool rgSCHCmnUlAdapRetxAlloc
(
RgSchCellCb *cell,
RgSchUlHqProcCb *proc,
RgSchUlHole *hole
)
-#else
-static Bool rgSCHCmnUlAdapRetxAlloc(cell, sf, proc, hole)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-RgSchUlHqProcCb *proc;
-RgSchUlHole *hole;
-#endif
{
- uint8_t numSb = proc->reTxAlloc.numSb;
- uint8_t iMcs = proc->reTxAlloc.iMcs;
+ uint8_t numSb = proc->reTxAlloc.numSb;
+ uint8_t iMcs = proc->reTxAlloc.iMcs;
CmLteTimingInfo frm = cell->crntTime;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchDlSf *dlSf;
if(alloc == NULLP)
{
rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "UL Alloc fail for msg3 retx for rnti: %d\n",
+ DU_LOG("\nERROR --> SCH : UL Alloc fail for msg3 retx for rnti: %d\n",
proc->reTxAlloc.rnti);
return (FALSE);
}
else /* Intg fix */
{
rgSCHUtlPdcchPut(cell, &dlSf->pdcchInfo, pdcch);
- RLOG_ARG1(L_DEBUG,DBG_CELLID,cell->cellId,
- "Num SB not suffiecient for adap retx for rnti: %d",
+ DU_LOG("\nERROR --> SCH : Num SB not suffiecient for adap retx for rnti: %d",
proc->reTxAlloc.rnti);
return (FALSE);
}
* @return uint8_t
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
-static Void rgSCHCmnUlSfRlsRetxProcs
-(
-RgSchCellCb *cell,
-RgSchUlSf *sf
-)
-#else
-static Void rgSCHCmnUlSfRlsRetxProcs(cell, sf)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-#endif
+static Void rgSCHCmnUlSfRlsRetxProcs(RgSchCellCb *cell,RgSchUlSf *sf)
{
CmLListCp *cp;
CmLList *node;
RgSchUlHqProcCb *proc;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
-
cp = &(cellUl->reTxLst);
node = cp->first;
while (node)
* @param[in] RgSchUlSf *sf
* @return uint8_t
**/
-#ifdef ANSI
-static Void rgSCHCmnUlSfReTxAllocs
-(
-RgSchCellCb *cell,
-RgSchUlSf *sf
-)
-#else
-static Void rgSCHCmnUlSfReTxAllocs(cell, sf)
-RgSchCellCb *cell;
-RgSchUlSf *sf;
-#endif
+static Void rgSCHCmnUlSfReTxAllocs(RgSchCellCb *cell,RgSchUlSf *sf)
{
CmLListCp *cp;
CmLList *node;
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnDlRbAlloc
-(
-RgSchCellCb *cell,
-RgSchCmnDlRbAllocInfo *allocInfo
-)
-#else
-static Void rgSCHCmnDlRbAlloc(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
+static Void rgSCHCmnDlRbAlloc(RgSchCellCb *cell,RgSchCmnDlRbAllocInfo *allocInfo)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
if (cellSch->dl.isDlFreqSel)
{
- printf("5GTF_ERROR DLFS SCH Enabled\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR DLFS SCH Enabled\n");
cellSch->apisDlfs->rgSCHDlfsAllocRb(cell, allocInfo);
}
else
* @param[out] RgSchBwRbgInfo *rbgInfo
* @return Void
**/
-#ifdef ANSI
Void rgSCHCmnDlGetRbgInfo
(
-uint8_t dlTotalBw,
-uint8_t dlSubsetBw,
-uint8_t maxRaType1SubsetBw,
-uint8_t rbgSize,
+uint8_t dlTotalBw,
+uint8_t dlSubsetBw,
+uint8_t maxRaType1SubsetBw,
+uint8_t rbgSize,
RgSchBwRbgInfo *rbgInfo
)
-#else
-Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
- rbgSize, rbgInfo)
-uint8_t dlTotalBw;
-uint8_t dlSubsetBw;
-uint8_t maxRaType1SubsetBw;
-uint8_t rbgSize;
-RgSchBwRbgInfo *rbgInfo;
-#endif
{
#ifdef RGSCH_SPS_UNUSED
uint8_t idx = 0;
* @return Void
**/
-#ifdef ANSI
uint8_t rgSCHCmnDlRaType0Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-uint8_t rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-uint8_t *numAllocRbs,
+uint8_t *numAllocRbs,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
-#else
-uint8_t rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
- numAllocRbs, resAllocInfo, isPartialAlloc)
-RgSchDlSfAllocInfo *allocedInfo;
-uint8_t rbsReq;
-RgSchBwRbgInfo *rbgInfo;
-uint8_t *numAllocRbs;
-RgSchDlSfAllocInfo *resAllocInfo;
-Bool isPartialAlloc;
-#endif
{
/* Note: This function atttempts allocation only full allocation */
uint32_t remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
* Number of allocated RBs
**/
-#ifdef ANSI
uint8_t rgSCHCmnDlRaType1Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-uint8_t rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-uint8_t startRbgSubset,
-uint8_t *allocRbgSubset,
+uint8_t startRbgSubset,
+uint8_t *allocRbgSubset,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
-#else
-uint8_t rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
- allocRbgSubset, resAllocInfo, isPartialAlloc)
-RgSchDlSfAllocInfo *allocedInfo;
-uint8_t rbsReq;
-RgSchBwRbgInfo *rbgInfo;
-uint8_t startRbgSubset;
-uint8_t *allocRbgSubset;
-RgSchDlSfAllocInfo *resAllocInfo;
-Bool isPartialAlloc;
-#endif
{
/* Note: This function atttempts only full allocation */
- uint8_t *rbgSubsetSzArr;
- uint8_t type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
- uint8_t offset, rbg, maskSize, bestSubsetIdx;
- uint8_t startPos = 0;
- uint8_t bestNumAvailRbs = 0;
- uint8_t numAllocRbs = 0;
- uint32_t ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
- uint32_t remNumRbs, allocedMask;
- uint8_t usedRbs = 0;
- uint8_t rbgSize = rbgInfo->rbgSize;
- uint8_t rbgSubset = startRbgSubset;
- uint32_t *rbgMask = &resAllocInfo->raType0Mask;
- uint32_t *raType1Mask = resAllocInfo->raType1Mask;
- uint32_t *raType2Mask = resAllocInfo->raType2Mask;
- uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
- uint32_t *allocMask = allocedInfo->raType1Mask;
+ uint8_t *rbgSubsetSzArr;
+ uint8_t type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
+ uint8_t offset, rbg, maskSize, bestSubsetIdx;
+ uint8_t startPos = 0;
+ uint8_t bestNumAvailRbs = 0;
+ uint8_t numAllocRbs = 0;
+ uint32_t ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
+ uint32_t remNumRbs, allocedMask;
+ uint8_t usedRbs = 0;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint8_t rbgSubset = startRbgSubset;
+ uint32_t *rbgMask = &resAllocInfo->raType0Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint32_t *allocMask = allocedInfo->raType1Mask;
/* Initialize the subset size Array */
rbgSubsetSzArr = rbgInfo->rbgSubsetSize;
* Number of allocated RBs
**/
-#ifdef ANSI
uint8_t rgSCHCmnDlRaType2Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-uint8_t rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-uint8_t *rbStart,
+uint8_t *rbStart,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
-#else
-uint8_t rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
- resAllocInfo, isPartialAlloc)
-RgSchDlSfAllocInfo *allocedInfo;
-uint8_t rbsReq;
-RgSchBwRbgInfo *rbgInfo;
-uint8_t *rbStart;
-RgSchDlSfAllocInfo *resAllocInfo;
-Bool isPartialAlloc;
-#endif
-{
- uint8_t numAllocRbs = 0;
- uint8_t rbIdx;
- uint8_t rbgSize = rbgInfo->rbgSize;
- uint32_t *rbgMask = &resAllocInfo->raType0Mask;
+{
+ uint8_t numAllocRbs = 0;
+ uint8_t rbIdx;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint32_t *rbgMask = &resAllocInfo->raType0Mask;
#ifdef RGSCH_SPS_UNUSED
- uint32_t *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
#endif
- uint32_t *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
#ifdef RGSCH_SPS_UNUSED
- uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
#endif
- uint32_t *allocedMask = allocedInfo->raType2Mask;
+ uint32_t *allocedMask = allocedInfo->raType2Mask;
/* Note: This function atttempts only full allocation */
rgSCHCmnDlGetBestFitHole(allocedMask, rbgInfo->numRbs,
* @param[in] uint8_t rbgSize
* @return uint32_t RA type 0 mask
**/
-#ifdef ANSI
-static uint32_t rgSCHCmnGetRaType0Mask
-(
-uint8_t rbIdx,
-uint8_t rbgSize
-)
-#else
-static uint32_t rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
-uint8_t rbIdx;
-uint8_t rbgSize;
-#endif
+static uint32_t rgSCHCmnGetRaType0Mask(uint8_t rbIdx,uint8_t rbgSize)
{
uint8_t rbg;
uint32_t rbgPosInRbgMask = 0;
* @param[out] uint8_t *type1Subset
* @return uint32_t RA type 1 mask
**/
-#ifdef ANSI
-static uint32_t rgSCHCmnGetRaType1Mask
-(
-uint8_t rbIdx,
-uint8_t rbgSize,
-uint8_t *type1Subset
-)
-#else
-static uint32_t rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
-uint8_t rbIdx;
-uint8_t rbgSize;
-uint8_t *type1Subset;
-#endif
+static uint32_t rgSCHCmnGetRaType1Mask(uint8_t rbIdx,uint8_t rbgSize,uint8_t *type1Subset)
{
uint8_t rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
uint32_t rbPosInSubset;
* @param[out] uint8_t *maskIdx
* @return uint32_t RA type 2 mask
**/
-#ifdef ANSI
-static uint32_t rgSCHCmnGetRaType2Mask
-(
-uint8_t rbIdx,
-uint8_t *maskIdx
-)
-#else
-static uint32_t rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
-uint8_t rbIdx;
-uint8_t *maskIdx;
-#endif
+static uint32_t rgSCHCmnGetRaType2Mask(uint8_t rbIdx,uint8_t *maskIdx)
{
uint32_t rbPosInType2;
* ROK success
* RFAILED failed
**/
-#ifdef ANSI
Bool rgSCHCmnAllocUeInSpsBw
(
RgSchDlSf *dlSf,
RgSchDlRbAlloc *rbAllocInfo,
Bool isPartialAlloc
)
-#else
-Bool rgSCHCmnAllocUeInSpsBw(dlSf, cell, ue, rbAllocInfo, isPartialAlloc)
-RgSchDlSf *dlSf;
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlRbAlloc *rbAllocInfo;
-Bool isPartialAlloc;
-#endif
{
- uint8_t rbgSize = cell->rbgSize;
- uint8_t numAllocRbs = 0;
- uint8_t numAllocRbgs = 0;
- uint8_t rbStart = 0;
- uint8_t idx, noLyr, iTbs;
- RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
- RgSchDlSfAllocInfo *dlSfAlloc = &rbAllocInfo->dlSf->dlSfAllocInfo;
- RgSchBwRbgInfo *spsRbgInfo = &cell->spsBwRbgInfo;
+ uint8_t rbgSize = cell->rbgSize;
+ uint8_t numAllocRbs = 0;
+ uint8_t numAllocRbgs = 0;
+ uint8_t rbStart = 0;
+ uint8_t idx, noLyr, iTbs;
+ RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
+ RgSchDlSfAllocInfo *dlSfAlloc = &rbAllocInfo->dlSf->dlSfAllocInfo;
+ RgSchBwRbgInfo *spsRbgInfo = &cell->spsBwRbgInfo;
/* SPS_FIX : Check if this Hq proc is scheduled */
if ((0 == rbAllocInfo->tbInfo[0].schdlngForTb) &&
* File :
*
**********************************************************/
-#ifdef ANSI
static Void rgSCHCmnDlGetBestFitHole
(
-uint32_t *allocMask,
-uint8_t numMaskRbs,
-uint32_t *crntAllocMask,
-uint8_t rbsReq,
-uint8_t *allocStart,
-uint8_t *allocNumRbs,
-Bool isPartialAlloc
+uint32_t *allocMask,
+uint8_t numMaskRbs,
+uint32_t *crntAllocMask,
+uint8_t rbsReq,
+uint8_t *allocStart,
+uint8_t *allocNumRbs,
+Bool isPartialAlloc
)
-#else
-static Void rgSCHCmnDlGetBestFitHole (allocMask, numMaskRbs,
- crntAllocMask, rbsReq, allocStart, allocNumRbs, isPartialAlloc)
-uint32_t *allocMask;
-uint8_t numMaskRbs;
-uint32_t *crntAllocMask;
-uint8_t rbsReq;
-uint8_t *allocStart;
-uint8_t *allocNumRbs;
-Bool isPartialAlloc;
-#endif
{
uint8_t maskSz = (numMaskRbs + 31)/32;
uint8_t maxMaskPos = (numMaskRbs % 32);
* @return void
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static Void rgSCHCmnFindCodeRate
(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-RgSchDlRbAlloc *allocInfo,
-uint8_t idx
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+RgSchDlRbAlloc *allocInfo,
+uint8_t idx
)
-#else
-static Void rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,idx)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-RgSchDlRbAlloc *allocInfo;
-uint8_t idx;
-#endif
{
return;
* @param[in] uint8_t *idx
* @return void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsPbchTbImcsAdj
(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *allocInfo,
-uint8_t idx,
-uint8_t rbsReq
+RgSchCellCb *cell,
+RgSchDlRbAlloc *allocInfo,
+uint8_t idx,
+uint8_t rbsReq
)
-#else
-static Void rgSCHCmnNonDlfsPbchTbImcsAdj(cell,allocInfo, idx, rbsReq)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *allocInfo;
-uint8_t idx;
-uint8_t rbsReq;
-#endif
{
- uint8_t noLyrs = 0;
- uint8_t tbs = 0;
- uint32_t origBytesReq;
- uint8_t noRbgs = 0;
- uint8_t noRbs = 0;
- RgSchDlSf *dlSf = allocInfo->dlSf;
+ uint8_t noLyrs = 0;
+ uint8_t tbs = 0;
+ uint32_t origBytesReq;
+ uint8_t noRbgs = 0;
+ uint8_t noRbs = 0;
+ RgSchDlSf *dlSf = allocInfo->dlSf;
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
noLyrs = allocInfo->tbInfo[idx].noLyr;
* @param[in] uint8_t pbchSsRsSym
* @return void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsPbchTbSizeAdj
(
-RgSchDlRbAlloc *allocInfo,
-uint8_t numOvrlapgPbchRb,
-uint8_t pbchSsRsSym,
-uint8_t idx,
-uint32_t bytesReq
+RgSchDlRbAlloc *allocInfo,
+uint8_t numOvrlapgPbchRb,
+uint8_t pbchSsRsSym,
+uint8_t idx,
+uint32_t bytesReq
)
-#else
-static Void rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,idx,bytesReq)
-RgSchDlRbAlloc *allocInfo;
-uint8_t numOvrlapgPbchRb;
-uint8_t pbchSsRsSym;
-uint8_t idx;
-uint32_t bytesReq;
-#endif
{
- uint32_t reducedTbs = 0;
- uint8_t noLyrs = 0;
- uint8_t tbs = 0;
-
+ uint32_t reducedTbs = 0;
+ uint8_t noLyrs = 0;
+ uint8_t tbs = 0;
+
noLyrs = allocInfo->tbInfo[idx].noLyr;
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
* @param[out] uint8_t addtlRbsAvl
* @return void
**/
-#ifdef ANSI
-static uint8_t rgSCHCmnFindNumAddtlRbsAvl
-(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-RgSchDlRbAlloc *allocInfo
-)
-#else
-static uint8_t rgSCHCmnFindNumAddtlRbsAvl(cell,dlSf,allocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-RgSchDlRbAlloc *allocInfo;
-#endif
+static uint8_t rgSCHCmnFindNumAddtlRbsAvl(RgSchCellCb *cell,RgSchDlSf *dlSf,RgSchDlRbAlloc *allocInfo)
{
uint8_t addtlRbsAvl = 0;
-
-
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
{
addtlRbsAvl = (((dlSf->type0End - dlSf->type2End + 1)*\
* @param[out] uint8_t* numOvrlapgPbchRb
* @return void
**/
-#ifdef ANSI
static Void rgSCHCmnFindNumPbchOvrlapRbs
(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-RgSchDlRbAlloc *allocInfo,
-uint8_t *numOvrlapgPbchRb
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+RgSchDlRbAlloc *allocInfo,
+uint8_t *numOvrlapgPbchRb
)
-#else
-static Void rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,numOvrlapgPbchRb)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-RgSchDlRbAlloc *allocInfo;
-uint8_t *numOvrlapgPbchRb;
-#endif
{
*numOvrlapgPbchRb = 0;
/*Find if we have already crossed the start boundary for PBCH 6 RBs,
* @param[in] uint8_t pbchSsRsSym
* @return void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsPbchRbAllocAdj
(
RgSchCellCb *cell,
RgSchDlRbAlloc *allocInfo,
-uint8_t pbchSsRsSym,
+uint8_t pbchSsRsSym,
Bool isBcchPcch
)
-#else
-static Void rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo,pbchSsRsSym)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *allocInfo;
-uint8_t pbchSsRsSym;
-Bool isBcchPcch;
-#endif
{
- RgSchDlSf *dlSf = allocInfo->dlSf;
- uint8_t numOvrlapgPbchRb = 0;
- uint8_t numOvrlapgAdtlPbchRb = 0;
- uint8_t totSym;
- uint8_t addtlRbsReq = 0;
- uint8_t moreAddtlRbsReq = 0;
- uint8_t addtlRbsAdd = 0;
- uint8_t moreAddtlRbsAdd = 0;
- uint8_t tbs;
- uint8_t origRbsReq = 0;
- uint32_t bytesReq;
- uint8_t noLyr;
- uint8_t divResult;
+ RgSchDlSf *dlSf = allocInfo->dlSf;
+ uint8_t numOvrlapgPbchRb = 0;
+ uint8_t numOvrlapgAdtlPbchRb = 0;
+ uint8_t totSym;
+ uint8_t addtlRbsReq = 0;
+ uint8_t moreAddtlRbsReq = 0;
+ uint8_t addtlRbsAdd = 0;
+ uint8_t moreAddtlRbsAdd = 0;
+ uint8_t tbs;
+ uint8_t origRbsReq = 0;
+ uint32_t bytesReq;
+ uint8_t noLyr;
+ uint8_t divResult;
*
* @param[in] RgSchCellCb *cell
* @param[in, out] RgSchDlRbAlloc *allocInfo
- * @return S16
- * -# ROK
- * -# RFAILED
- **/
-#ifdef ANSI
-static S16 rgSCHCmnNonDlfsCmnRbAlloc
-(
-RgSchCellCb *cell,
-RgSchDlRbAlloc *allocInfo
-)
-#else
-static S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchDlRbAlloc *allocInfo;
-#endif
+ * @return S16
+ * -# ROK
+ * -# RFAILED
+ **/
+static S16 rgSCHCmnNonDlfsCmnRbAlloc(RgSchCellCb *cell,RgSchDlRbAlloc *allocInfo)
{
#ifndef LTE_TDD
#ifdef LTEMAC_SPS
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
-static S16 rgSCHCmnNonDlfsCmnRbAllocRar
-(
- RgSchCellCb *cell,
- RgSchDlRbAlloc *allocInfo
- )
-#else
-static S16 rgSCHCmnNonDlfsCmnRbAlloc(cell, allocInfo)
- RgSchCellCb *cell;
- RgSchDlRbAlloc *allocInfo;
-#endif
+static S16 rgSCHCmnNonDlfsCmnRbAllocRar(RgSchCellCb *cell,RgSchDlRbAlloc *allocInfo)
{
RgSchDlSf *dlSf = allocInfo->dlSf;
-
if(dlSf->bwAlloced == dlSf->bw)
{
return RFAILED;
RgSchSfBeamInfo *beamInfo = &(dlSf->sfBeamInfo[0]);
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
- printf("5GTF_ERROR vrbg allocated > 25\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR vrbg allocated > 25\n");
return RFAILED;
}
allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
#endif
- printf("\n[%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
+ DU_LOG("\nINFO --> SCH : [%s],allocInfo->tbInfo[0].bytesAlloc:%u,vrbgReq:%u\n",
__func__,allocInfo->tbInfo[0].bytesAlloc,allocInfo->vrbgReq);
return ROK;
* -# FALSE
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static Bool rgSCHCmnNonDlfsSFRBwAvlbl
(
-RgSchCellCb *cell,
-RgSchSFRPoolInfo **sfrpoolInfo,
-RgSchDlSf *dlSf,
-RgSchDlRbAlloc *allocInfo,
-Bool isUeCellEdge
+RgSchCellCb *cell,
+RgSchSFRPoolInfo **sfrpoolInfo,
+RgSchDlSf *dlSf,
+RgSchDlRbAlloc *allocInfo,
+Bool isUeCellEdge
)
-#else
-static Bool rgSCHCmnNonDlfsSFRBwAvlbl(cell, sfrpoolInfo, dlSf, allocInfo, isUeCellEdge)
-RgSchCellCb *cell;
-RgSchSFRPoolInfo **sfrpoolInfo;
-RgSchDlSf *dlSf;
-RgSchDlRbAlloc *allocInfo;
-Bool isUeCellEdge;
-#endif
{
CmLListCp *l;
CmLListCp *l1;
if (dlSf->bw <= dlSf->bwAlloced)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,
- "BW is fully allocated for subframe (%d) CRNTI:%d", dlSf->sfNum,allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : BW is fully allocated for subframe (%d) CRNTI:%d", dlSf->sfNum,allocInfo->rnti);
return FALSE;
}
if (dlSf->sfrTotalPoolInfo.ccBwFull == TRUE)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "BW is fully allocated for CC Pool CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : BW is fully allocated for CC Pool CRNTI:%d",allocInfo->rnti);
return FALSE;
}
if ((dlSf->sfrTotalPoolInfo.ceBwFull == TRUE) && (isUeCellEdge))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "BW is fully allocated for CE Pool CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : BW is fully allocated for CE Pool CRNTI:%d",allocInfo->rnti);
return FALSE;
}
* -# FALSE
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static Bool rgSCHCmnNonDlfsBwAvlbl
(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-RgSchDlRbAlloc *allocInfo
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+RgSchDlRbAlloc *allocInfo
)
-#else
-static Bool rgSCHCmnNonDlfsBwAvlbl(cell, dlSf, allocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-RgSchDlRbAlloc *allocInfo;
-#endif
{
uint8_t tbs;
uint8_t noLyrs;
if (dlSf->bw <= dlSf->bwAlloced)
{
- RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId, "(%d:%d)FAILED CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : (%d:%d)FAILED CRNTI:%d",
dlSf->bw, dlSf->bwAlloced,allocInfo->rnti);
return (FALSE);
}
dlSf->lstRbgDfct = 1;
}
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "FAILED for CRNTI:%d",
+ DU_LOG("\nERROR --> SCH : FAILED for CRNTI:%d",
allocInfo->rnti);
- printf ("RB Alloc failed for LAA TB type 0\n");
+ DU_LOG("\nERROR --> SCH : RB Alloc failed for LAA TB type 0\n");
return (FALSE);
}
return (TRUE);
}
else
{
- printf ("RB Alloc failed for LAA TB type 2\n");
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : RB Alloc failed for LAA TB type 2\n");
+ DU_LOG("\nERROR --> SCH : FAILED for CRNTI:%d",allocInfo->rnti);
return (FALSE);
}
/* Fix: Number of RBs in case of RETX should be same as
return (TRUE);
}
}
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"FAILED for CRNTI:%d",allocInfo->rnti);
+ DU_LOG("\nERROR --> SCH : FAILED for CRNTI:%d",allocInfo->rnti);
return (FALSE);
}
#endif
*
* @return Void
**/
-#ifdef ANSI
Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc
(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-uint8_t rbStrt,
-uint8_t numRb
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+uint8_t rbStrt,
+uint8_t numRb
)
-#else
-Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-uint8_t rbStrt;
-uint8_t numRb;
-#endif
{
CmLListCp *l;
CmLList *n;
* @return Void
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchDlSf *dlSf,
-uint8_t rbStrt,
-uint8_t numRb
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchDlSf *dlSf,
+uint8_t rbStrt,
+uint8_t numRb
)
-#else
-static S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc(cell, ue, dlSf, rbStrt, numRb)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlSf *dlSf;
-uint8_t rbStrt;
-uint8_t numRb;
-#endif
{
CmLListCp *l;
CmLList *n;
/* KWork fix */
if (sfrCCPool1 == NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"sfrCCPool1 is NULL for CRNTI:%d",ue->ueId);
return RFAILED;
}
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, dlSf->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdDSFRTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED CRNTI:%d",ue->ueId);
return RFAILED;
}
*
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsUpdTyp2Alloc
(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-uint8_t rbStrt,
-uint8_t numRb
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+uint8_t rbStrt,
+uint8_t numRb
)
-#else
-static Void rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-uint8_t rbStrt;
-uint8_t numRb;
-#endif
{
/* Move the type2End pivot forward */
dlSf->type2End = RGSCH_CEIL((rbStrt+numRb), cell->rbgSize);
* @return Void
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static Void rgSCHCmnNonDlfsType0Alloc
(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf,
-RgSchDlRbAlloc *allocInfo,
-RgSchUeCb *ue
+RgSchCellCb *cell,
+RgSchDlSf *dlSf,
+RgSchDlRbAlloc *allocInfo,
+RgSchUeCb *ue
)
-#else
-static Void rgSCHCmnNonDlfsType0Alloc(cell, dlSf, allocInfo, dlUe)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-RgSchDlRbAlloc *allocInfo;
-RgSchUeCb *ue;
-#endif
{
uint32_t dlAllocMsk = 0;
uint8_t rbgFiller = dlSf->lstRbgDfct;
* @return Void
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static S16 rgSCHCmnBuildRntpInfo
(
-RgSchCellCb *cell,
-uint8_t *rntpPtr,
-uint8_t startRb,
-uint8_t nmbRb,
-uint16_t bw
+RgSchCellCb *cell,
+uint8_t *rntpPtr,
+uint8_t startRb,
+uint8_t nmbRb,
+uint16_t bw
)
-#else
-static S16 rgSCHCmnBuildRntpInfo(cell, rntpPtr, startRb, nmbRb, bw)
-RgSchCellCb *cell;
-uint8_t *rntpPtr;
-uint8_t startRb;
-uint8_t nmbRb;
-uint16_t bw;
-#endif
{
uint16_t rbPtrStartIdx; /* Start Index of Octete Buffer to be filled */
uint16_t rbPtrEndIdx; /* End Index of Octete Buffer to be filled */
if (rntpPtr == NULLP)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
- "rgSCHCmnBuildRntpInfo():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnBuildRntpInfo():"
"rntpPtr can't be NULLP (Memory Allocation Failed)");
return RFAILED;
}
*
* @return Void
**/
-#ifdef ANSI
static S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc
(
RgSchCellCb *cell,
-RgSchUeCb *ue,
+RgSchUeCb *ue,
RgSchDlSf *dlSf,
RgSchSFRPoolInfo *sfrPool,
-uint8_t rbStrt,
-uint8_t numRb
+uint8_t rbStrt,
+uint8_t numRb
)
-#else
-static S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrPool, rbStrt, numRb)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlSf *dlSf;
-RgSchSFRPoolInfo *sfrPool;
-uint8_t rbStrt;
-uint8_t numRb;
-#endif
{
#ifndef LTEMAC_SPS
S16 ret;
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
ret = rgSCHCmnBuildRntpInfo(cell, dlSf->rntpInfo.val, sfrPool->type2Start, numRb, dlSf->bw);
if (ret != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc():"
"rgSCHCmnBuildRntpInfo() function returned RFAILED for CRNTI:%d",ue->ueId);
return RFAILED;
}
*
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsSFRPoolType0Alloc
(
RgSchCellCb *cell,
RgSchSFRPoolInfo *poolInfo,
RgSchDlRbAlloc *allocInfo
)
-#else
-static Void rgSCHCmnNonDlfsSFRPoolType0Alloc(cell, dlSf, poolInfo, allocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-RgSchSFRPoolInfo *poolInfo;
-RgSchDlRbAlloc *allocInfo;
-#endif
{
uint32_t dlAllocMsk = 0;
uint8_t rbgFiller = 0;
* @return void
**/
-#ifdef ANSI
-static void rgSCHCmnNonDlfsDsfrRntpComp
-(
-RgSchCellCb *cell,
-RgSchDlSf *dlSf
-)
-#else
-static void rgSCHCmnNonDlfsDsfrRntpComp(cell, dlSf)
-RgSchCellCb *cell;
-RgSchDlSf *dlSf;
-#endif
+static void rgSCHCmnNonDlfsDsfrRntpComp(RgSchCellCb *cell,RgSchDlSf *dlSf)
{
static uint16_t samples = 0;
uint16_t i;
sizeof(RgrLoadInfIndInfo));
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
+ DU_LOG("\nERROR --> SCH : Could not "
"allocate memory for sending LoadInfo");
return;
}
ret = rgSCHUtlRgrLoadInfInd(cell, rgrLoadInf);
if(ret == RFAILED)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHCmnNonDlfsDsfrRntpComp():"
+ DU_LOG("\nERROR --> SCH : rgSCHCmnNonDlfsDsfrRntpComp():"
"rgSCHUtlRgrLoadInfInd() returned RFAILED");
}
* -# RFAILED
**/
#ifdef UNUSED_FUNC
-#ifdef ANSI
static S16 rgSCHCmnSFRNonDlfsUeRbAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-uint8_t *isDlBwAvail
+uint8_t *isDlBwAvail
)
-#else
-static S16 rgSCHCmnSFRNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlSf *dlSf;
-uint8_t *isDlBwAvail;
-#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *dlUe;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static S16 rgSCHCmnNonDlfsUeRbAlloc
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchDlSf *dlSf,
-uint8_t *isDlBwAvail
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchDlSf *dlSf,
+uint8_t *isDlBwAvail
)
-#else
-static S16 rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlSf *dlSf;
-uint8_t *isDlBwAvail;
-#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *dlUe;
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
- RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
- "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
ue->ueId);
- printf("5GTF_ERROR vrbg allocated > 25\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR vrbg allocated > 25\n");
return RFAILED;
}
{
/* Returning ROK since PDCCH might be available for another UE and
* further allocations could be done */
- RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
- "5GTF_ERROR : PDCCH allocation failed :ue (%u)",
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR : PDCCH allocation failed :ue (%u)",
ue->ueId);
- printf("5GTF_ERROR PDCCH allocation failed\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR PDCCH allocation failed\n");
return RFAILED;
}
#ifdef RG_5GTF
*
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsCcchSduAlloc
(
RgSchCellCb *cell,
RgSchCmnCcchSduRbAlloc *allocInfo,
uint8_t isRetx
)
-#else
-static Void rgSCHCmnNonDlfsCcchSduAlloc(cell, allocInfo, isRetx)
-RgSchCellCb *cell;
-RgSchCmnCcchSduRbAlloc *allocInfo;
-uint8_t isRetx;
-#endif
{
S16 ret;
CmLListCp *ccchSduLst = NULLP;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static S16 rgSCHCmnNonDlfsCcchSduRbAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
RgSchDlSf *dlSf
)
-#else
-static S16 rgSCHCmnNonDlfsCcchSduRbAlloc(cell, ueCb, dlSf)
-RgSchCellCb *cell;
-RgSchUeCb *ueCb;
-RgSchDlSf *dlSf;
-#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static S16 rgSCHCmnNonDlfsMsg4RbAlloc
(
RgSchCellCb *cell,
RgSchRaCb *raCb,
RgSchDlSf *dlSf
)
-#else
-static S16 rgSCHCmnNonDlfsMsg4RbAlloc(cell, raCb, dlSf)
-RgSchCellCb *cell;
-RgSchRaCb *raCb;
-RgSchDlSf *dlSf;
-#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchSfBeamInfo *beamInfo = &(dlSf->sfBeamInfo[0]);
if(beamInfo->totVrbgAllocated > MAX_5GTF_VRBG)
{
- RLOG_ARG1(L_ERROR ,DBG_CELLID,cell->cellId,
- "5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR : vrbg allocated > 25 :ue (%u)",
raCb->ue->ueId);
- printf("5GTF_ERROR vrbg allocated > 25\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR vrbg allocated > 25\n");
return RFAILED;
}
#endif
*
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsMsg4Alloc
(
RgSchCellCb *cell,
RgSchCmnMsg4RbAlloc *allocInfo,
-uint8_t isRetx
+uint8_t isRetx
)
-#else
-static Void rgSCHCmnNonDlfsMsg4Alloc(cell, allocInfo, isRetx)
-RgSchCellCb *cell;
-RgSchCmnMsg4RbAlloc *allocInfo;
-uint8_t isRetx;
-#endif
{
S16 ret;
CmLListCp *msg4Lst = NULLP;
*
* @return Void
**/
-#ifdef ANSI
Void rgSCHCmnNonDlfsDedRbAlloc
(
RgSchCellCb *cell,
CmLListCp *schdHqPLst,
CmLListCp *nonSchdHqPLst
)
-#else
-Void rgSCHCmnNonDlfsDedRbAlloc(cell, allocInfo, ueLst,
- schdHqPLst, nonSchdHqPLst)
-RgSchCellCb *cell;
-RgSchCmnUeRbAlloc *allocInfo;
-CmLListCp *ueLst;
-CmLListCp *schdHqPLst;
-CmLListCp *nonSchdHqPLst;
-#endif
{
S16 ret;
CmLList *schdLnkNode = NULLP;
cell->tenbStats->sch.dl5gtfRbAllocFail++;
#endif
/* Allocation failed : Add UE to the non-scheduled list */
- printf("5GTF_ERROR Dl rb alloc failed adding nonSchdHqPLst\n");
+ DU_LOG("\nERROR --> SCH : 5GTF_ERROR Dl rb alloc failed adding nonSchdHqPLst\n");
cmLListAdd2Tail(nonSchdHqPLst, schdLnkNode);
}
}
* @return Void
**/
-#ifdef ANSI
Void rgSCHCmnNonDlfsRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
-#else
-Void rgSCHCmnNonDlfsRbAlloc(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
{
- uint8_t raRspCnt = 0;
- RgSchDlRbAlloc *reqAllocInfo;
+ uint8_t raRspCnt = 0;
+ RgSchDlRbAlloc *reqAllocInfo;
/* Allocate for MSG4 retransmissions */
if (allocInfo->msg4Alloc.msg4RetxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc RetxLst\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc RetxLst\n");
rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), TRUE);
}
/* Assuming all the nodes in the list need allocations: rbsReq is valid */
if (allocInfo->msg4Alloc.msg4TxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc txLst\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsMsg4Alloc txLst\n");
rgSCHCmnNonDlfsMsg4Alloc(cell, &(allocInfo->msg4Alloc), FALSE);
}
#ifdef RGR_V1
* retransmissions */
if (allocInfo->ccchSduAlloc.ccchSduRetxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), TRUE);
}
/* Allocate for CCCH SDU (received after guard timer expiry) transmissions */
if (allocInfo->ccchSduAlloc.ccchSduTxLst.count)
{
- printf("5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR rgSCHCmnNonDlfsCcchSduAlloc\n");
rgSCHCmnNonDlfsCcchSduAlloc(cell, &(allocInfo->ccchSduAlloc), FALSE);
}
#endif
{
break;
}
- printf("5GTF_ERROR calling RAR rgSCHCmnNonDlfsCmnRbAlloc\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR calling RAR rgSCHCmnNonDlfsCmnRbAlloc\n");
// if ((rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo)) != ROK)
if ((rgSCHCmnNonDlfsCmnRbAllocRar(cell, reqAllocInfo)) != ROK)
{
/* Allocate for RETX+TX UEs */
if(allocInfo->dedAlloc.txRetxHqPLst.count)
{
- printf("5GTF_ERROR TX RETX rgSCHCmnNonDlfsDedRbAlloc\n");
+ DU_LOG("\nDEBUG --> SCH : 5GTF_ERROR TX RETX rgSCHCmnNonDlfsDedRbAlloc\n");
rgSCHCmnNonDlfsDedRbAlloc(cell, &(allocInfo->dedAlloc),
&(allocInfo->dedAlloc.txRetxHqPLst),
&(allocInfo->dedAlloc.schdTxRetxHqPLst),
cmnCell->dl.maxUePerDlSf)
{
#ifndef ALIGN_64BIT
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
+ DU_LOG("\nERROR --> SCH : UEs selected by"
" scheduler exceed maximumUePerDlSf(%u)tx-retx %ld retx %ld tx %ld\n",
cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
allocInfo->dedAlloc.retxHqPLst.count,
- allocInfo->dedAlloc.txHqPLst.count));
+ allocInfo->dedAlloc.txHqPLst.count);
#else
- RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"UEs selected by"
+ DU_LOG("\nERROR --> SCH : UEs selected by"
" scheduler exceed maximumUePerDlSf(%u)tx-retx %d retx %d tx %d\n",
cmnCell->dl.maxUePerDlSf, allocInfo->dedAlloc.txRetxHqPLst.count,
allocInfo->dedAlloc.retxHqPLst.count,
- allocInfo->dedAlloc.txHqPLst.count));
+ allocInfo->dedAlloc.txHqPLst.count);
#endif
}
}
/* LTE_ADV_FLAG_REMOVED_START */
if(cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
{
- printf("5GTF_ERROR RETX rgSCHCmnNonDlfsDsfrRntpComp\n");
+ DU_LOG("\nINFO --> SCH : 5GTF_ERROR RETX rgSCHCmnNonDlfsDsfrRntpComp\n");
rgSCHCmnNonDlfsDsfrRntpComp(cell, allocInfo->dedAlloc.dedDlSf);
}
/* LTE_ADV_FLAG_REMOVED_END */
*
**********************************************************/
#ifdef LTEMAC_SPS
-#ifdef ANSI
uint32_t rgSCHCmnCalcRiv
(
-uint8_t bw,
-uint8_t rbStart,
-uint8_t numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
)
#else
-uint32_t rgSCHCmnCalcRiv(bw, rbStart, numRb)
-uint8_t bw;
-uint8_t rbStart;
-uint8_t numRb;
-#endif
-#else
-#ifdef ANSI
uint32_t rgSCHCmnCalcRiv
(
-uint8_t bw,
-uint8_t rbStart,
-uint8_t numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
)
-#else
-uint32_t rgSCHCmnCalcRiv(bw, rbStart, numRb)
-uint8_t bw;
-uint8_t rbStart;
-uint8_t numRb;
-#endif
#endif
{
- uint8_t numRbMinus1 = numRb - 1;
- uint32_t riv;
+ uint8_t numRbMinus1 = numRb - 1;
+ uint32_t riv;
if (numRbMinus1 <= bw/2)
* @return S16
*
**/
-#ifdef ANSI
static S16 rgSCHCmnDlCpyRachInfo
(
-RgSchCellCb *cell,
-RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
-uint8_t raArrSz
+RgSchCellCb *cell,
+RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
+uint8_t raArrSz
)
-#else
-static S16 rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz)
-RgSchCellCb *cell;
-RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES];
-uint8_t raArrSz;
-#endif
{
- uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
- uint8_t sfNum;
- S16 sfnIdx;
- uint16_t subfrmIdx;
- uint8_t numRfs;
- uint8_t numSubfrms;
- uint8_t sfcount;
- S16 ret;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t sfNum;
+ S16 sfnIdx;
+ uint16_t subfrmIdx;
+ uint8_t numRfs;
+ uint8_t numSubfrms;
+ uint8_t sfcount;
+ S16 ret;
/* Allocate RACH response information for each DL
*
**/
#ifdef LTE_TDD
-#ifdef ANSI
static S32 rgSchCmnFetchItbs
(
-RgSchCellCb *cell,
-RgSchCmnDlUe *ueDl,
-RgSchDlSf *subFrm,
-uint8_t cqi,
-uint8_t cfi,
-uint8_t cwIdx,
-uint8_t noLyr
+RgSchCellCb *cell,
+RgSchCmnDlUe *ueDl,
+RgSchDlSf *subFrm,
+uint8_t cqi,
+uint8_t cfi,
+uint8_t cwIdx,
+uint8_t noLyr
)
#else
-static S32 rgSchCmnFetchItbs (cell, ueDl, subFrm, cqi, cfi, cwIdx, noLyr)
-RgSchCellCb *cell;
-RgSchCmnDlUe *ueDl;
-RgSchDlSf *subFrm;
-uint8_t cqi;
-uint8_t cfi;
-uint8_t cwIdx;
-uint8_t noLyr;
-#endif
-#else
-#ifdef ANSI
static S32 rgSchCmnFetchItbs
(
-RgSchCellCb *cell,
-RgSchCmnDlUe *ueDl,
-uint8_t cqi,
-uint8_t cfi,
-uint8_t cwIdx,
-uint8_t noLyr
+RgSchCellCb *cell,
+RgSchCmnDlUe *ueDl,
+uint8_t cqi,
+uint8_t cfi,
+uint8_t cwIdx,
+uint8_t noLyr
)
-#else
-static S32 rgSchCmnFetchItbs (cell, ueDl, cqi, cfi, cwIdx, noLyr)
-RgSchCellCb *cell;
-RgSchCmnDlUe *ueDl;
-uint8_t cqi;
-uint8_t cfi;
-uint8_t cwIdx;
-uint8_t noLyr;
-#endif
#endif
{
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRb1Tb1Cw
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
RgSchDlRbAlloc *allocInfo;
S16 ret;
- uint8_t numRb;
+ uint8_t numRb;
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRb1Tb1Cw
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
RgSchDlRbAlloc *allocInfo;
S16 ret;
- uint8_t numRb;
+ uint8_t numRb;
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRbTM1
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
return;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRbTM1
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRbTM1(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
return;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRbTM2
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
return;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRbTM2
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRbTM2(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
return;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRbTM3
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRbTM3
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRbTM3(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
(proc->tbInfo[1].state == HQ_TB_NACKED))
{
#ifdef LAA_DBG_LOG
- printf ("RETX RB TM3 nack for both hqp %d cell %d \n", proc->procId, proc->hqE->cell->cellId);
+ DU_LOG("\nDEBUG --> SCH : RETX RB TM3 nack for both hqp %d cell %d \n", proc->procId, proc->hqE->cell->cellId);
#endif
/* Both TBs require RETX allocation */
rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo,\
* @return TfuDciFormat
*
**/
-#ifdef ANSI
TfuDciFormat rgSCHCmnSlctPdcchFrmt
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t *raType
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint8_t *raType
)
-#else
-TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t *raType;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlTM3RetxRetx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlTM3RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- uint8_t numRb;
+ uint8_t numRb;
Bool swpFlg;
- uint8_t precInfo;
- uint8_t noTxLyrs;
- uint8_t precInfoAntIdx;
+ uint8_t precInfo;
+ uint8_t noTxLyrs;
+ uint8_t precInfoAntIdx;
ret = ROK;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlTM4RetxRetx
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlTM4RetxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- uint8_t numRb;
+ uint8_t numRb;
Bool swpFlg = FALSE;
- uint8_t precInfo;
+ uint8_t precInfo;
#ifdef FOUR_TX_ANTENNA
- uint8_t precInfoAntIdx;
+ uint8_t precInfoAntIdx;
#endif
- uint8_t noTxLyrs;
+ uint8_t noTxLyrs;
ret = ROK;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlSMGetAttrForTxRetx
(
RgSchUeCb *ue,
Bool *frthrScp,
Bool *swpFlg
)
-#else
-static Void rgSCHCmnDlSMGetAttrForTxRetx(ue, proc, retxTb, txTb, frthrScp,\
- swpFlg)
-RgSchUeCb *ue;
-RgSchDlHqProcCb *proc;
-RgSchDlHqTbCb **retxTb;
-RgSchDlHqTbCb **txTb;
-Bool *frthrScp;
-Bool *swpFlg;
-#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,proc->hqE->cell);
RgSchDlRbAlloc *allocInfo;
* @return uint8_t
*
**/
-#ifdef ANSI
static uint8_t rgSCHCmnDlTM3PrecInf2
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t numTxLyrs,
-Bool bothCwEnbld
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint8_t numTxLyrs,
+Bool bothCwEnbld
)
-#else
-static uint8_t rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t numTxLyrs;
-Bool bothCwEnbld;
-#endif
{
return (0);
* @return uint8_t
*
**/
-#ifdef ANSI
static uint8_t rgSCHCmnDlTM4PrecInf2
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t numTxLyrs,
-Bool bothCwEnbld
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint8_t numTxLyrs,
+Bool bothCwEnbld
)
-#else
-static uint8_t rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t numTxLyrs;
-Bool bothCwEnbld;
-#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
uint8_t precIdx;
* @return uint8_t
*
**/
-#ifdef ANSI
static uint8_t rgSCHCmnDlTM3PrecInf4
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t numTxLyrs,
-Bool bothCwEnbld
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint8_t numTxLyrs,
+Bool bothCwEnbld
)
-#else
-static uint8_t rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t numTxLyrs;
-Bool bothCwEnbld;
-#endif
{
- uint8_t precIdx;
+ uint8_t precIdx;
if (bothCwEnbld)
* @return uint8_t
*
**/
-#ifdef ANSI
static uint8_t rgSCHCmnDlTM4PrecInf4
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint8_t numTxLyrs,
-Bool bothCwEnbld
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint8_t numTxLyrs,
+Bool bothCwEnbld
)
-#else
-static uint8_t rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t numTxLyrs;
-Bool bothCwEnbld;
-#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- uint8_t precInfoBaseIdx, precIdx;
+ uint8_t precInfoBaseIdx, precIdx;
precInfoBaseIdx = (ue->mimoInfo.puschFdbkVld)? (16):
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlGetAttrForTM3
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchDlHqProcCb *proc,
-uint8_t *numTxLyrs,
-TfuDciFormat *dciFrmt,
-uint8_t *prcdngInf,
-RgSchDlHqTbCb **retxTb,
-RgSchDlHqTbCb **txTb,
-Bool *frthrScp,
-Bool *swpFlg,
-uint8_t *raType
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchDlHqProcCb *proc,
+uint8_t *numTxLyrs,
+TfuDciFormat *dciFrmt,
+uint8_t *prcdngInf,
+RgSchDlHqTbCb **retxTb,
+RgSchDlHqTbCb **txTb,
+Bool *frthrScp,
+Bool *swpFlg,
+uint8_t *raType
)
-#else
-static Void rgSCHCmnDlGetAttrForTM3(cell, ue, proc, numTxLyrs, dciFrmt,\
- prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *proc;
-uint8_t *numTxLyrs;
-TfuDciFormat *dciFrmt;
-uint8_t *prcdngInf;
-RgSchDlHqTbCb **retxTb;
-RgSchDlHqTbCb **txTb;
-Bool *frthrScp;
-Bool *swpFlg;
-uint8_t *raType;
-#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- uint8_t precInfoAntIdx;
+ uint8_t precInfoAntIdx;
/* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlGetAttrForTM4
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-RgSchDlHqProcCb *proc,
-uint8_t *numTxLyrs,
-TfuDciFormat *dciFrmt,
-uint8_t *prcdngInf,
-RgSchDlHqTbCb **retxTb,
-RgSchDlHqTbCb **txTb,
-Bool *frthrScp,
-Bool *swpFlg,
-uint8_t *raType
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+RgSchDlHqProcCb *proc,
+uint8_t *numTxLyrs,
+TfuDciFormat *dciFrmt,
+uint8_t *prcdngInf,
+RgSchDlHqTbCb **retxTb,
+RgSchDlHqTbCb **txTb,
+Bool *frthrScp,
+Bool *swpFlg,
+uint8_t *raType
)
-#else
-static Void rgSCHCmnDlGetAttrForTM4(cell, ue, proc, numTxLyrs, dciFrmt,\
- prcdngInf, retxTb, txTb, frthrScp, swpFlg, raType)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *proc;
-uint8_t *numTxLyrs;
-TfuDciFormat *dciFrmt;
-uint8_t *prcdngInf;
-RgSchDlHqTbCb **retxTb;
-RgSchDlHqTbCb **txTb;
-Bool *frthrScp;
-Bool *swpFlg;
-uint8_t *raType;
-#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
uint8_t precInfoAntIdx;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlTM3TxRetx
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlTM3TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- uint8_t numRb;
+ uint8_t numRb;
RgSchDlHqTbCb *retxTb, *txTb;
Bool frthrScp;
Bool swpFlg;
- uint8_t prcdngInf;
- uint8_t numTxLyrs;
+ uint8_t prcdngInf;
+ uint8_t numTxLyrs;
frthrScp = FALSE;
if (frthrScp)
{
#ifdef LAA_DBG_LOG
- printf ("TX RETX called from proc %d cell %d \n",proc->procId, cell->cellId);
+ DU_LOG("\nDEBUG --> SCH : TX RETX called from proc %d cell %d \n",proc->procId, cell->cellId);
#endif
ret = rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, retxTb, txTb,\
&numRb, effBo);
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlTM4TxRetx
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlTM4TxRetx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- uint8_t numRb;
+ uint8_t numRb;
RgSchDlHqTbCb *retxTb, *txTb;
Bool frthrScp;
Bool swpFlg;
- uint8_t prcdngInf;
- uint8_t numTxLyrs;
+ uint8_t prcdngInf;
+ uint8_t numTxLyrs;
ret = ROK;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlTM3TxTx
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- uint8_t numRb;
- uint8_t noTxLyrs;
- uint8_t precInfo;
+ uint8_t numRb;
+ uint8_t noTxLyrs;
+ uint8_t precInfo;
S16 ret;
- uint8_t precInfoAntIdx;
+ uint8_t precInfoAntIdx;
ret = ROK;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlTM4TxTx
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- uint8_t numRb;
- uint8_t precInfo;
- uint8_t noTxLyrs;
- uint8_t precInfoAntIdx;
+ uint8_t numRb;
+ uint8_t precInfo;
+ uint8_t noTxLyrs;
+ uint8_t precInfoAntIdx;
S16 ret;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRbTM4
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
/* Both TBs free for TX allocation */
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRbTM4
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRbTM4(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
if ((proc->tbInfo[0].state == HQ_TB_NACKED) &&
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRbTM5
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
#if (ERRCLASS & ERRCLS_DEBUG)
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
return;
}
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRbTM5
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
-RgSchDlHqProcCb *proc,
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+uint32_t bo,
+uint32_t *effBo,
+RgSchDlHqProcCb *proc,
+RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRbTM5(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
#if (ERRCLASS & ERRCLS_DEBUG)
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
+ DU_LOG("\nERROR --> SCH : Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
return;
}
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRbTM6
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl;
S16 ret;
- uint8_t numRb;
+ uint8_t numRb;
ret = ROK;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRbTM6
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRbTM6(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl;
S16 ret;
- uint8_t numRb;
+ uint8_t numRb;
ret = ROK;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocTxRbTM7
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocTxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
return;
* @return Void
*
**/
-#ifdef ANSI
static Void rgSCHCmnDlAllocRetxRbTM7
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-static Void rgSCHCmnDlAllocRetxRbTM7(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
return;
* @return S16
*
**/
-#ifdef ANSI
S16 rgSCHCmnDlAllocTxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-S16 rgSCHCmnDlAllocTxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
- uint32_t newSchBits = 0;
- uint32_t prevSchBits = 0;
+ uint32_t newSchBits = 0;
+ uint32_t prevSchBits = 0;
RgSchDlRbAlloc *allocInfo;
* @return Bool
*
**/
-#ifdef ANSI
Bool rgSCHCmnRetxAvoidTdd
(
RgSchDlSf *curSf,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
)
-#else
-Bool rgSCHCmnRetxAvoidTdd(curSf, cell, proc)
-RgSchDlSf *curSf;
-RgSchCellCb *cell;
-RgSchDlHqProcCb *proc;
-#endif
{
RgSchTddSfType txSfType = 0;
* @return Bool
*
**/
-#ifdef ANSI
Bool rgSCHCmnRetxAllocAvoid
(
RgSchDlSf *subFrm,
RgSchCellCb *cell,
RgSchDlHqProcCb *proc
)
-#else
-Bool rgSCHCmnRetxAllocAvoid(subFrm, cell, proc)
-RgSchDlSf *subFrm;
-RgSchCellCb *cell;
-RgSchDlHqProcCb *proc;
-#endif
{
uint8_t reqRbs;
* @return S16
*
**/
-#ifdef ANSI
S16 rgSCHCmnDlAllocRetxRb
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-uint32_t bo,
-uint32_t *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
-#else
-S16 rgSCHCmnDlAllocRetxRb(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-uint32_t bo;
-uint32_t *effBo;
-RgSchDlHqProcCb *proc;
-RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
-#endif
{
uint32_t newSchBits = 0;
RgSchDlRbAlloc *allocInfo;
* @return S16
*
**/
-#ifdef ANSI
static S16 rgSCHCmnDlAlloc1CwTxRb
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-RgSchDlHqTbCb *tbInfo,
-uint32_t bo,
-uint8_t *numRb,
-uint32_t *effBo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+RgSchDlHqTbCb *tbInfo,
+uint32_t bo,
+uint8_t *numRb,
+uint32_t *effBo
)
-#else
-static S16 rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, tbInfo, bo, numRb, effBo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-RgSchDlHqTbCb *tbInfo;
-uint32_t bo;
-uint8_t *numRb;
-uint32_t *effBo;
-#endif
-{
- uint32_t tbSz;
- uint8_t imcs;
- uint8_t iTbs;
- RgSchCmnDlUe *ueDl;
- RgSchDlRbAlloc *allocInfo;
- uint32_t oldReq;
- uint32_t reqBytes;
+{
+ uint32_t tbSz;
+ uint8_t imcs;
+ uint8_t iTbs;
+ RgSchCmnDlUe *ueDl;
+ RgSchDlRbAlloc *allocInfo;
+ uint32_t oldReq;
+ uint32_t reqBytes;
/* Correcting wrap around issue.
* This change has been done at mutliple places in this function.*/
- uint32_t tempNumRb;
+ uint32_t tempNumRb;
reqBytes = bo;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnRdcImcsTxTb
(
RgSchDlRbAlloc *allocInfo,
-uint8_t tbInfoIdx,
-uint32_t cnsmdBytes
+uint8_t tbInfoIdx,
+uint32_t cnsmdBytes
)
-#else
-Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
-RgSchDlRbAlloc *allocInfo;
-uint8_t tbInfoIdx;
-uint32_t cnsmdBytes;
-#endif
{
return;
/*The below functionality is not needed.*/
* @return Void
*
**/
-#ifdef ANSI
static S16 rgSCHCmnDlAlloc2CwTxRb
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-RgSchDlHqProcCb *proc,
-uint32_t bo,
-uint8_t *numRbRef,
-uint32_t *effBo
-)
-#else
-static S16 rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, numRbRef, effBo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *proc;
-uint32_t bo;
-uint8_t *numRbRef;
-uint32_t *effBo;
-#endif
-{
- uint32_t noRes;
- uint32_t eff1, eff2;
- uint32_t tb1Sz, tb2Sz;
- uint8_t imcs1, imcs2;
- uint8_t noLyr1, noLyr2;
- uint8_t iTbs1, iTbs2;
- RgSchCmnDlCell *cellDl;
- RgSchCmnDlUe *ueDl;
- RgSchDlRbAlloc *allocInfo;
- uint32_t oldReq;
- uint32_t reqBytes;
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+RgSchDlHqProcCb *proc,
+uint32_t bo,
+uint8_t *numRbRef,
+uint32_t *effBo
+)
+{
+ uint32_t noRes;
+ uint32_t eff1, eff2;
+ uint32_t tb1Sz, tb2Sz;
+ uint8_t imcs1, imcs2;
+ uint8_t noLyr1, noLyr2;
+ uint8_t iTbs1, iTbs2;
+ RgSchCmnDlCell *cellDl;
+ RgSchCmnDlUe *ueDl;
+ RgSchDlRbAlloc *allocInfo;
+ uint32_t oldReq;
+ uint32_t reqBytes;
/* Fix: MUE_PERTTI_DL */
- uint32_t numRb;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- uint8_t cfi = cellSch->dl.currCfi;
- S16 availBw;
- uint32_t availBits = 0;
+ uint32_t numRb;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ uint8_t cfi = cellSch->dl.currCfi;
+ S16 availBw;
+ uint32_t availBits = 0;
#ifdef LTE_ADV
- uint32_t boTmp = bo;
+ uint32_t boTmp = bo;
#endif
(allocInfo->tbInfo[1].bytesReq >= ueDl->maxTbSz/8) ||
(allocInfo->rbsReq >= ueDl->maxRb))
{
- RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
- "rgSCHCmnDlAllocRb(): UEs max allocation exceed");
+ DU_LOG("\nDEBUG --> SCH : rgSCHCmnDlAllocRb(): UEs max allocation exceed");
return RFAILED;
}
* @return Void
*
**/
-#ifdef ANSI
static S16 rgSCHCmnDlAlloc2CwTxRetxRb
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-RgSchDlHqTbCb *reTxTb,
-RgSchDlHqTbCb *txTb,
-uint8_t *numRb,
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+RgSchDlHqTbCb *reTxTb,
+RgSchDlHqTbCb *txTb,
+uint8_t *numRb,
uint32_t *effBo
)
-#else
-static S16 rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, reTxTb, txTb, numRb,\
- effBo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-RgSchDlHqTbCb *reTxTb;
-RgSchDlHqTbCb *txTb;
-uint8_t *numRb;
-uint32_t *effBo;
-#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- uint8_t imcs1, imcs2;
- uint8_t noLyr2;
- uint16_t tb2Sz;
+ uint8_t imcs1, imcs2;
+ uint8_t noLyr2;
+ uint16_t tb2Sz;
RgSchCmnDlUeCwInfo *otherCw;
S16 availBw;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- uint8_t cfi = cellDl->currCfi;
- uint8_t iTbs;
+ uint8_t cfi = cellDl->currCfi;
+ uint8_t iTbs;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
if(*numRb <= 3)
{
- RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
+ DU_LOG("\nERROR --> SCH : Number of RBs [%d] are less than or equal to 3",*numRb);
return RFAILED;
}
}
* @return Void
*
**/
-#ifdef ANSI
static S16 rgSCHCmnDlAlloc2CwRetxRb
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-RgSchDlHqProcCb *proc,
-uint8_t *numRb,
-Bool *swpFlg,
-uint32_t *effBo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+RgSchDlHqProcCb *proc,
+uint8_t *numRb,
+Bool *swpFlg,
+uint32_t *effBo
)
-#else
-static S16 rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc,\
- numRb, swpFlg, effBo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-RgSchDlHqProcCb *proc;
-uint8_t *numRb;
-Bool *swpFlg;
-uint32_t *effBo;
-#endif
{
- RgSchDlRbAlloc *allocInfo;
- uint8_t imcs1;
- uint8_t imcs2;
- RgSchDlHqTbCb *lrgTbInfo, *othrTbInfo;
+ RgSchDlRbAlloc *allocInfo;
+ uint8_t imcs1;
+ uint8_t imcs2;
+ RgSchDlHqTbCb *lrgTbInfo, *othrTbInfo;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
if(*numRb <= 3)
{
- RLOG1(L_ERROR," Number of RBs [%d] are less than or equal to 3",*numRb);
+ DU_LOG("\nERROR --> SCH : Number of RBs [%d] are less than or equal to 3",*numRb);
return RFAILED;
}
}
* @return S16
*
**/
-#ifdef ANSI
static S16 rgSCHCmnDlAlloc1CwRetxRb
(
-RgSchCellCb *cell,
-RgSchDlSf *subFrm,
-RgSchUeCb *ue,
-RgSchDlHqTbCb *tbInfo,
-uint8_t noLyr,
-uint8_t *numRb,
-uint32_t *effBo
+RgSchCellCb *cell,
+RgSchDlSf *subFrm,
+RgSchUeCb *ue,
+RgSchDlHqTbCb *tbInfo,
+uint8_t noLyr,
+uint8_t *numRb,
+uint32_t *effBo
)
-#else
-static S16 rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, tbInfo, noLyr,\
- numRb, effBo)
-RgSchCellCb *cell;
-RgSchDlSf *subFrm;
-RgSchUeCb *ue;
-RgSchDlHqTbCb *tbInfo;
-uint8_t noLyr;
-uint8_t *numRb;
-uint32_t *effBo;
-#endif
{
RgSchDlRbAlloc *allocInfo;
uint8_t imcs;
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnDlRelPdcchFbk
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isAck
)
-#else
-Void rgSCHCmnDlRelPdcchFbk(cell, ue, isAck)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-Bool isAck;
-#endif
{
rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnDlProcAck
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
-#else
-Void rgSCHCmnDlProcAck(cell, hqP)
-RgSchCellCb *cell;
-RgSchDlHqProcCb *hqP;
-#endif
{
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnHdlCrntiCE
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
-#else
-Void rgSCHCmnHdlCrntiCE(cell, ue)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-#endif
{
#ifdef RGSCH_SPS_STATS
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnUlSpsRelInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isExplRel
)
-#else
-Void rgSCHCmnUlSpsRelInd(cell, ue, isExplRel)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-Bool isExplRel;
-#endif
{
rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnUlSpsActInd
(
-RgSchCellCb *cell,
-RgSchUeCb *ue,
-uint16_t spsSduSize
+RgSchCellCb *cell,
+RgSchUeCb *ue,
+uint16_t spsSduSize
)
-#else
-Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint16_t spsSduSize;
-#endif
{
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnUlCrcInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo crcTime
)
-#else
-Void rgSCHCmnUlCrcInd(cell, ue, crcTime)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-CmLteTimingInfo crcTime;
-#endif
{
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnUlCrcFailInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo crcTime
)
-#else
-Void rgSCHCmnUlCrcFailInd(cell, ue, crcTime)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-CmLteTimingInfo crcTime;
-#endif
{
if (ue->ul.ulSpsCfg.isUlSpsEnabled == TRUE)
* @param[in] RgSchCellCb *cell
* @return Void
**/
-#ifdef ANSI
-static Void rgSCHCmnDlBcchPcchAlloc
-(
-RgSchCellCb *cell
-)
-#else
-static Void rgSCHCmnDlBcchPcchAlloc(cell)
-RgSchCellCb *cell;
-#endif
+static Void rgSCHCmnDlBcchPcchAlloc(RgSchCellCb *cell)
{
#ifdef LTE_TDD
uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
* @return Void
**/
-#ifdef ANSI
static Void rgSCHBcchPcchDlRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
-#else
-static Void rgSCHBcchPcchDlRbAlloc(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnNonDlfsBcchPcchRbAlloc
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
-#else
-static Void rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-#endif
{
RgSchDlRbAlloc *reqAllocInfo;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static Void rgSCHChkNUpdSiCfg
(
RgSchCellCb *cell
)
-#else
-static Void rgSCHChkNUpdSiCfg(cell)
-RgSchCellCb *cell;
-#endif
{
CmLteTimingInfo pdSchTmInfo;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static Void rgSCHSelectSi
(
RgSchCellCb *cell
)
-#else
-static Void rgSCHSelectSi(cell)
-RgSchCellCb *cell;
-#endif
{
- CmLteTimingInfo crntTmInfo;
- uint8_t siWinSize;
- uint16_t x;
- uint16_t windowId;
+ CmLteTimingInfo crntTmInfo;
+ uint8_t siWinSize;
+ uint16_t x;
+ uint16_t windowId;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static Void rgSCHDlSiSched
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo,
RgInfSfAlloc *subfrmAlloc
)
-#else
-static Void rgSCHDlSiSched(cell, allocInfo, subfrmAlloc)
-RgSchCellCb *cell;
-RgSchCmnDlRbAllocInfo *allocInfo;
-RgInfSfAlloc *subfrmAlloc;
-#endif
{
CmLteTimingInfo crntTimInfo;
RgSchDlSf *sf;
- uint8_t nPrb = 0;
- uint8_t mcs = 0;
+ uint8_t nPrb = 0;
+ uint8_t mcs = 0;
MsgLen msgLen = 0;
- uint32_t rb=0;
+ uint32_t rb=0;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
/* DwPTS Scheduling Changes Start */
#ifdef LTE_TDD
- uint16_t lostRe;
- uint8_t cfi = cellDl->currCfi;
+ uint16_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
/* DwPTS Scheduling Changes End */
/* LTE_ADV_FLAG_REMOVED_START */
if(cell->siCb.siCtx.retxCntRem)
{
- RGSCHLOGERROR(cell->instIdx,ERRCLS_INT_PAR,ERG011,(ErrVal)cell->siCb.siCtx.siId,
- "rgSCHDlSiSched(): SI not scheduled and window expired");
+ DU_LOG("\nERROR --> SCH : rgSCHDlSiSched(): SI not scheduled and window expired");
}
/* LTE_ADV_FLAG_REMOVED_END */
if(cell->siCb.siCtx.warningSiFlag == TRUE)
* exceeds the available */
if (rb > sf->bw - sf->bwAssigned)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDlSiSched(): "
+ DU_LOG("\nERROR --> SCH : rgSCHDlSiSched(): "
"BW allocation failed CRNTI:%d",RGSCH_SI_RNTI);
return;
}
* @return Void
*
**/
-#ifdef ANSI
static S16 rgSCHCmnUeDlPwrCtColltCqiRept
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCqiRept *ueCqiRpt
)
-#else
-static S16 rgSCHCmnUeDlPwrCtColltCqiRept(cell, ue, ueCqiRpt)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgrUeCqiRept *ueCqiRpt;
-#endif
{
uint8_t *cqiCount = NULLP;
S16 retVal;
sizeof(RgrStaIndInfo));
if (retVal != ROK)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
+ DU_LOG("\nERROR --> SCH : Could not "
"allocate memory for sending StaInd CRNTI:%d",ue->ueId);
return (retVal);
}
* @return Void
*
**/
-#ifdef ANSI
Void rgSCHCmnChkRetxAllowDtx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *proc,
Bool *reTxAllwd
)
-#else
-Void rgSCHCmnChkRetxAllowDtx(cell, ueCb, proc, reTxAllwd)
-RgSchCellCb *cell;
-RgSchUeCb *ueCb;
-RgSchDlHqProcCb *proc;
-Bool *reTxAllwd;
-#endif
{
* @param[in] uint8_t sf
* @return uint16_t siSetId
**/
-#ifdef ANSI
uint16_t rgSCHCmnGetSiSetId
(
uint16_t sfn,
uint8_t sf,
uint16_t minPeriodicity
)
-#else
-uint16_t rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
-uint16_t sfn;
-uint8_t sf
-uint16_t minPeriodicity;
-#endif
{
/* 80 is the minimum SI periodicity in sf. Also
* all other SI periodicities are multiples of 80 */
* @param[in] uint8_t cfi
* @return uint32_t tbSz
**/
-#ifdef ANSI
static uint32_t rgSCHCmnCalcDwPtsTbSz
(
-RgSchCellCb *cell,
-uint32_t bo,
-uint8_t *rb,
-uint8_t *iTbs,
-uint8_t lyr,
-uint8_t cfi
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t *rb,
+uint8_t *iTbs,
+uint8_t lyr,
+uint8_t cfi
)
-#else
-static uint32_t rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
-RgSchCellCb *cell;
-uint32_t bo;
-uint8_t *rb;
-uint8_t *iTbs;
-uint8_t lyr;
-uint8_t cfi;
-#endif
{
- uint32_t tbSz;
+ uint32_t tbSz;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
- uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
+ uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
+ uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
/* DwPts Rb cannot exceed the cell Bw */
* @return[in/out] uint32_t *tb2Sz
* @param[in] uint8_t cfi
**/
-#ifdef ANSI
static Void rgSCHCmnCalcDwPtsTbSz2Cw
(
-RgSchCellCb *cell,
-uint32_t bo,
-uint8_t *rb,
-uint8_t maxRb,
-uint8_t *iTbs1,
-uint8_t *iTbs2,
-uint8_t lyr1,
-uint8_t lyr2,
-uint32_t *tb1Sz,
-uint32_t *tb2Sz,
-uint8_t cfi
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t *rb,
+uint8_t maxRb,
+uint8_t *iTbs1,
+uint8_t *iTbs2,
+uint8_t lyr1,
+uint8_t lyr2,
+uint32_t *tb1Sz,
+uint32_t *tb2Sz,
+uint8_t cfi
)
-#else
-static Void rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, rb, maxRb, iTbs1, iTbs2,
- lyr1, lyr2, tb1Sz, tb2Sz, cfi)
-RgSchCellCb *cell;
-uint32_t bo;
-uint8_t *rb;
-uint8_t maxRb;
-uint8_t *iTbs1;
-uint8_t *iTbs2;
-uint8_t lyr1;
-uint8_t lyr2;
-uint32_t *tb1Sz;
-uint32_t *tb2Sz;
-uint8_t cfi;
-#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
- uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
+ uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
+ uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
/* DwPts Rb cannot exceed the cell Bw */
* @param[in] RgInfUeDatInd *datInd
* @return Void
**/
-#ifdef ANSI
Void rgSCHCmnUpdUeDataIndLcg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgInfUeDatInd *datInd
)
-#else
-Void rgSCHCmnUpdUeDataIndLcg(cell, ue, datInd)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-RgInfUeDatInd *datInd;
-#endif
{
uint32_t idx = 0;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
-#ifdef DEBUGP
- Inst inst = cell->instIdx;
-#endif
for (idx = 0; (idx < RGINF_MAX_LCG_PER_UE - 1); idx++)
{
if (cellSch->apisEmtcUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure");
}
}
{
if (cellSch->apisUl->rgSCHRgrUlLcgUpd(cell, ue, datInd) != ROK)
{
- RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "\n rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure"));
+ DU_LOG("\nERROR --> SCH : rgSCHCmnUpdUeDataIndLcg(): rgSCHRgrUlLcgUpd returned failure");
}
}
}
* Returns: Void
*
*/
-#ifdef ANSI
static Void rgSCHCmnInitRbAlloc
(
RgSchCellCb *cell
)
-#else
-static Void rgSCHCmnInitRbAlloc (cell)
-RgSchCellCb *cell;
-#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
- uint8_t idx;
+ uint8_t idx;
/* Initializing RgSchCmnUlRbAllocInfo structure.*/
* @param[in] uint8_t newTxMode
* @return Void
**/
-#ifdef ANSI
static Void rgSCHCmnSendTxModeInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-uint8_t newTxMode
+uint8_t newTxMode
)
-#else
-static Void rgSCHCmnSendTxModeInd(cell, ue, newTxMode)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t newTxMode;
-#endif
{
RgmTransModeInd *txModeChgInd;
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
* @param[in] uint8_t iTbs
* @return Void
**/
-#ifdef ANSI
Void rgSchCheckAndTriggerModeChange
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-uint8_t reportediTbs,
-uint8_t previTbs,
-uint8_t maxiTbs
+uint8_t reportediTbs,
+uint8_t previTbs,
+uint8_t maxiTbs
)
-#else
-Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
-RgSchCellCb *cell;
-RgSchUeCb *ue;
-uint8_t reportediTbs;
-uint8_t previTbs;
-uint8_t maxiTbs;
-#endif
{
RgrTxMode txMode; /*!< UE's Transmission Mode */
RgrTxMode modTxMode; /*!< UE's Transmission Mode */
* @param[in] RgInfUeDatInd *datInd
* @return Void
**/
-#ifdef ANSI
-Bool rgSCHCmnIsDlCsgPrio
-(
-RgSchCellCb *cell
-)
-#else
-Bool rgSCHCmnIsDlCsgPrio(cell)
-RgSchCellCb *cell;
-#endif
+Bool rgSCHCmnIsDlCsgPrio(RgSchCellCb *cell)
{
RgSchCmnDlCell *cmnDlCell = RG_SCH_CMN_GET_DL_CELL(cell);
* @param[in] RgInfUeDatInd *datInd
* @return Void
**/
-#ifdef ANSI
-Bool rgSCHCmnIsUlCsgPrio
-(
-RgSchCellCb *cell
-)
-#else
-Bool rgSCHCmnIsUlCsgPrio(cell)
-RgSchCellCb *cell;
-#endif
+Bool rgSCHCmnIsUlCsgPrio(RgSchCellCb *cell)
{
RgSchCmnUlCell *cmnUlCell = RG_SCH_CMN_GET_UL_CELL(cell);
* Returns: Void
*
*/
-#ifdef ANSI
- Void rgSchCmnPreDlSch
+Void rgSchCmnPreDlSch
(
- RgSchCellCb **cell,
- uint8_t nCell,
- RgSchCellCb **cellLst
- )
-#else
-Void rgSchCmnPreDlSch(cell, nCell, cellLst)
- RgSchCellCb **cell;
- uint8_t nCell;
- RgSchCellCb **cellLst;
-#endif
+RgSchCellCb **cell,
+uint8_t nCell,
+RgSchCellCb **cellLst
+)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell[0]);
RgSchDlSf *sf;
- uint8_t idx;
+ uint8_t idx;
if(nCell > CM_LTE_MAX_CELLS)
* Returns: Void
*
*/
-#ifdef ANSI
-Void rgSchCmnPstDlSch
-(
- RgSchCellCb *cell
-)
-#else
-Void rgSchCmnPstDlSch(cell)
- RgSchCellCb *cell
-#endif
+Void rgSchCmnPstDlSch(RgSchCellCb *cell)
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
}
}
-#ifdef ANSI
-uint8_t rgSCHCmnCalcPcqiBitSz
-(
- RgSchUeCb *ueCb,
- uint8_t numTxAnt
-)
-#else
-uint8_t rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
- RgSchUeCb *ueCb;
- uint8_t numTxAnt;
-#endif
+uint8_t rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb, uint8_t numTxAnt)
{
uint8_t confRepMode;
uint8_t pcqiSz;
* Returns: Void
*
*/
-#ifdef ANSI
-Void rgSCHCmnDlSch
-(
- RgSchCellCb *cell
- )
-#else
-Void rgSCHCmnDlSch (cell)
- RgSchCellCb *cell;
-#endif
+Void rgSCHCmnDlSch(RgSchCellCb *cell)
{
RgSchDlSf *dlSf;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
{
ul5gtfsidDlAlreadyMarkUl++;
/*
- printf("ul5gtfsidDlAlreadyMarkUl: %d, [sfn:sf] [%04d:%02d]\n",
+ DU_LOG("\nINFO --> SCH : ul5gtfsidDlAlreadyMarkUl: %d, [sfn:sf] [%04d:%02d]\n",
ul5gtfsidDlAlreadyMarkUl, cellSch->dl.time.sfn,
cellSch->dl.time.slot);
*/