static int RLOG_MODULE_ID=4096;
static int RLOG_FILE_ID=188;
/* header include files -- defines (.h) */
-#include "envopt.h" /* environment options */
-#include "envdep.h" /* environment dependent */
-#include "envind.h" /* environment independent */
-#include "gen.h" /* general layer */
-#include "ssi.h" /* system service interface */
-#include "cm_hash.h" /* common hash list */
-#include "cm_llist.h" /* common linked list library */
-#include "cm_err.h" /* common error */
-#include "cm_lte.h" /* common LTE */
-#include "cm_math.h" /* common MATH functions */
+#include "common_def.h"
#include "lrg.h"
#include "rgr.h"
#include "rgm.h"
#include "rg_sch_cmn.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer typedefs */
-#include "ssi.x" /* system services typedefs */
-#include "cm5.x" /* common timers */
-#include "cm_hash.x" /* common hash list */
-#include "cm_lib.x" /* common library */
-#include "cm_llist.x" /* common linked list */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common tokens */
-#include "cm_math.x" /* common MATH functions */
#include "tfu.x" /* RGU types */
#include "lrg.x" /* layer management typedefs for MAC */
#include "rgr.x" /* layer management typedefs for MAC */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrInit
+Void rgSCHPwrInit
(
Void
)
#else
-PUBLIC Void rgSCHPwrInit()
+Void rgSCHPwrInit()
#endif
{
U8 idx;
- TRC2(rgSCHPwrInit);
rgSchPwrCqiToPwrTbl[0] = 0; /* This should never be used anyway */
for (idx = 1; idx < RG_SCH_CMN_UL_NUM_CQI; ++idx)
U8 cqi;
#endif
{
- TRC2(rgSCHPwrGetCqiPwr);
- RETVALUE(rgSchPwrCqiToPwrTbl[cqi]);
+ return (rgSchPwrCqiToPwrTbl[cqi]);
} /* rgSCHPwrGetCqiPwr */
/***********************************************************
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrGetCqiPwrForUe);
if (!uePwr->deltaMcsEnbld)
{
- RETVALUE(0);
+ return (0);
}
- RETVALUE(rgSCHPwrGetCqiPwr(cqi));
+ return (rgSCHPwrGetCqiPwr(cqi));
} /* rgSCHPwrGetCqiPwrForUe */
/***********************************************************
{
F64 ks = 1.25; /* or F64 */
F64 tmp = cmPow(2, ks*eff/1024) - 1;
- TRC2(rgSCHPwrCalcEfficncyPwr);
if (tmp <= 0)
- RETVALUE(0);
- RETVALUE((S8)(10 * cmLog10(tmp)));
+ return (0);
+ return ((S8)(10 * cmLog10(tmp)));
} /* rgSCHPwrCalcEfficncyPwr */
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHPwrPuschTpcForUe
+U8 rgSCHPwrPuschTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSCHPwrPuschTpcForUe(cell, ue)
+U8 rgSCHPwrPuschTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue,cell);
UNUSED(cell);
- TRC2(rgSCHPwrPuschTpcForUe);
rgSCHPwrOnSchedPuschTpc(cell, ue);
- RETVALUE(uePwr->puschTpc);
+ return (uePwr->puschTpc);
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC U8 rgSCHPwrGetMaxUlRb
+U8 rgSCHPwrGetMaxUlRb
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSCHPwrGetMaxUlRb(cell, ue)
+U8 rgSCHPwrGetMaxUlRb(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrGetMaxUlRb);
rgSCHPwrPuschCntrl(cell, ue); /* This stores tpc, delta and maxRb
* in uePwr */
- RETVALUE(uePwr->maxUlRbs);
+ return (uePwr->maxUlRbs);
}
/**
UNUSED(cell);
- TRC2(rgSCHPwrPuschCntrl);
-
if (!uePwr->isPhrAvail)
{
availPwr = 60; /* setting a large value so that availPwr does
* @return U8
**/
#ifdef ANSI
-PUBLIC U8 rgSCHPwrPucchTpcForUe
+U8 rgSCHPwrPucchTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC U8 rgSCHPwrPucchTpcForUe(cell, ue)
+U8 rgSCHPwrPucchTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrPucchTpcForUe);
rgSCHPwrPucchCntrl(cell, ue);
- RETVALUE(uePwr->pucchTpc);
+ return (uePwr->pucchTpc);
}
/***********************************************************
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrGetDelta2FrmCqi);
if (uePwr->isPhrAvail)
{
if (uePwr->maxPwrDeltaByPhr < 0 && (trgCqi - crntCqi) *
RG_SCH_UL_CQI_DB_STEP_2 > 0)
{
- RETVALUE(0);
+ return (0);
}
- RETVALUE(RGSCH_MIN(uePwr->maxPwrDeltaByPhr,
+ return (RGSCH_MIN(uePwr->maxPwrDeltaByPhr,
(trgCqi - crntCqi) * RG_SCH_UL_CQI_DB_STEP_2));
} /* rgSCHPwrGetDelta2FrmCqi */
S8 *tpcDelta;
#endif
{
- TRC2(rgSCHPwrGetPuschTpc);
delta = RGSCH_MIN(delta, availPwr);
{
RgSchCmnUlCell *cellUl;
- TRC2(rgSCHPwrGetMaxRb);
-
cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
if (pwr <= 0)
{
/* Give 4 RBS so that UE can report changed power status*/
/* [ccpu00119916] Mod -return 0th index of rgSchPwrToRbTbl when pwr <=0
* Change the Macros from RGSCH_MAX_DL_BW to RGSCH_MAX_UL_BW*/
- RETVALUE(rgSchPwrToRbTbl[0]);
+ return (rgSchPwrToRbTbl[0]);
}
if (pwr > rgSchPwrRbToPwrTbl[cellUl->maxUlBwPerUe])
{
- RETVALUE(cellUl->maxUlBwPerUe);
+ return (cellUl->maxUlBwPerUe);
}
- RETVALUE(RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(U8)pwr]));
+ return (RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(U8)pwr]));
} /* rgSCHPwrGetMaxRb */
/***********************************************************
#ifndef NO_ERRCLS
RgSchCmnUlCell *cellUl;
#endif
- TRC2(rgSCHPwrRbToPwr);
#if (ERRCLASS & ERRCLS_DEBUG)
cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
if (numRb > cellUl->maxUlBwPerUe)
numRb = cellUl->maxUlBwPerUe;
}
#endif
- RETVALUE(rgSchPwrRbToPwrTbl[numRb]);
+ return (rgSchPwrRbToPwrTbl[numRb]);
} /* rgSCHPwrRbToPwr */
{
S8 delta;
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrPucchCntrl);
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, &uePwr->pucchTpc, &delta);
rgSCHPwrOnSchedPucchTpc(cell, ue, delta);
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrGrpCntrlPucch
+Void rgSCHPwrGrpCntrlPucch
(
RgSchCellCb *cell,
RgSchDlSf *dlSf
)
#else
-PUBLIC Void rgSCHPwrGrpCntrlPucch(cell, dlSf)
+Void rgSCHPwrGrpCntrlPucch(cell, dlSf)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
#endif
CmLListCp *lst;
CmLList *lnk;
RgSchPdcch *pdcch;
- TRC2(rgSCHPwrGrpCntrlPucch);
lst = &cellPwr->pucchGrpPwr;
lnk = lst->first;
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrGrpCntrlPusch
+Void rgSCHPwrGrpCntrlPusch
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchUlSf *ulSf
)
#else
-PUBLIC Void rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf)
+Void rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchUlSf *ulSf;
CmLListCp *lst;
CmLList *lnk;
RgSchPdcch *pdcch;
- TRC2(rgSCHPwrGrpCntrlPusch);
lst = &cellPwr->puschGrpPwr;
lnk = lst->first;
U8 tpc;
S8 delta;
Bool atleastOne;
- TRC2(rgSCHPwrSchedPucchRnti);
pdcch->rnti = cb->tpcRnti;
pdcch->dci.u.format3Info.isPucch = TRUE;
/* Fill TPC 1 (corresponding to no power change) initially */
- cmMemset((U8 *)tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
+ memset(tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
for (atleastOne = FALSE, lnk = lst->first; lnk; lnk = lnk->next)
{
U8 tpc;
S8 delta;
Bool atleastOne;
- TRC2(rgSCHPwrSchedPuschRnti);
pdcch->rnti = cb->tpcRnti;
tpcCmds = pdcch->dci.u.format3Info.tpcCmd;
/* Fill TPC 1 (corresponding to no power change) initially */
- cmMemset((U8 *)tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
+ memset(tpcCmds, 1, sizeof(pdcch->dci.u.format3Info.tpcCmd));
for (atleastOne = FALSE, lnk = lst->first; lnk; lnk = lnk->next)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrGetPucchFmt3TpcForUe);
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, tpc, delta);
RETVOID;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrGetPucchFmt3aTpcForUe);
rgSCHPwrGetAcc1bitTpc(uePwr->remPucchPwr, tpc, delta);
RETVOID;
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
S8 adj = RGSCH_MIN(uePwr->remPuschPwr, uePwr->phVal);
- TRC2(rgSCHPwrGetPuschFmt3TpcForUe);
rgSCHPwrGetAcc2bitTpc(adj, tpc, delta);
RETVOID;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrGetPuschFmt3aTpcForUe);
/* Don't attempt to look at headroom now, power
* adjustment is small anyway */
S8 *delta;
#endif
{
- TRC2(rgSCHPwrGetAcc1bitTpc);
/*
* TPC delta
* 0 -1
*/
U8 tpcs[3] = {1, 2, 2};
U8 deltas[3] = {0, 1, 1};
- TRC2(rgSCHPwrGetAcc2bitTpc);
if (remPwr <= -1)
{
*tpc = 0;
S8 *delta;
#endif
{
- TRC2(rgSCHPwrGetAbsTpc);
/*
* TPC delta
* 0 -4
UNUSED(cell);
- TRC2(rgSCHPwrOnPucchGrpPwrForUe);
-
uePwr->remPucchPwr -= delta;
/* UE was already scheduled for PUCCH group power
Bool rmvUe = FALSE;
UNUSED(cell);
- TRC2(rgSCHPwrOnPuschGrpPwrForUe);
uePwr->delta = delta;
uePwr->remPuschPwr -= delta;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
RgSchDlHqProcCb *proc = rgSCHDhmLastSchedHqProc(hqEnt);
- TRC2(rgSCHPwrIsDlUeSched);
-
if (proc == NULLP)
{
- RETVALUE(FALSE);
+ return (FALSE);
}
/*
* 10 subframes, which would have otherwise caused
* the check to succeed for a possibly older process.
*/
- if ((proc->tbInfo[0].timingInfo.subframe == sf->sfNum) ||
- (proc->tbInfo[1].timingInfo.subframe == sf->sfNum))
+ if ((proc->tbInfo[0].timingInfo.slot == sf->sfNum) ||
+ (proc->tbInfo[1].timingInfo.slot == sf->sfNum))
{
/*
* Later, if a proc can be scheduled without having an
* Checking for PDCCH would have to be in common proc
* the way things are now.
*/
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
- RETVALUE(FALSE);
+ return (FALSE);
}
} /* rgSCHPwrIsDlUeSched */
RgSchCmnUlCell *cmnCell = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlHqProcCb *proc = rgSCHUhmGetUlHqProc(cell, ue, cmnCell->schdHqProcIdx);
- TRC2(rgSCHPwrIsUlUeSched);
-
UNUSED(sf);
#if (ERRCLASS & ERRCLS_DEBUG)
if( proc == NULLP )
{
- RETVALUE (FALSE);
+ return (FALSE);
}
#endif
if (proc->alloc)
{
- RETVALUE(TRUE);
+ return (TRUE);
}
else
{
- RETVALUE(FALSE);
+ return (FALSE);
}
} /* rgSCHPwrIsUlUeSched */
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrPucchDeltaInd
+Void rgSCHPwrPucchDeltaInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
S8 pwrDelta
)
#else
-PUBLIC Void rgSCHPwrPucchDeltaInd(cell, ue, pwrDelta)
+Void rgSCHPwrPucchDeltaInd(cell, ue, pwrDelta)
RgSchCellCb *cell;
RgSchUeCb *ue;
S8 pwrDelta;
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgSchCmnTpcRntiCb *cb;
Bool toAdd;
- TRC2(rgSCHPwrPucchDeltaInd);
uePwr->remPucchPwr = pwrDelta;
* improved its remPwr as part of power control. */
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
Bool rmvUe = FALSE;
- TRC2(rgSCHPwrOnSchedPucchTpc);
uePwr->remPucchPwr -= delta;
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
Bool rmvUe = FALSE;
- TRC2(rgSCHPwrOnSchedPuschTpc);
/* Don't do anything for the case of absolute TPC commands */
if (!uePwr->isAccumulated)
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUpdExtPhr
+Void rgSCHPwrUpdExtPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchCmnAllocRecord *allocInfo
)
#else
-PUBLIC Void rgSCHPwrUpdExtPhr(cell, ue, extPhr, allocInfo)
+Void rgSCHPwrUpdExtPhr(cell, ue, extPhr, allocInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfExtPhrCEInfo *extPhr;
RgInfExtPhrSCellInfo *servCellPhr;
S8 pCMax;
- TRC2(rgSCHPwrUpdExtPhr);
-
for (idx = 0; idx < extPhr->numServCells; idx++)
{
servCellPhr = &extPhr->servCellPhr[idx];
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUpdPhr
+Void rgSCHPwrUpdPhr
(
RgSchCellCb *cell,
RgSchUeCb *ue,
S8 maxUePwr
)
#else
-PUBLIC Void rgSCHPwrUpdPhr(cell, ue, phr, allocInfo, maxUePwr)
+Void rgSCHPwrUpdPhr(cell, ue, phr, allocInfo, maxUePwr)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 phr;
U8 effPwr;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHPwrUpdPhr);
-
uePwr->phVal = rgSCHPwrGetPhValFromPhr(phr);
if (maxUePwr == RG_SCH_CMN_PWR_USE_CFG_MAX_PWR)
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUlCqiInd
+Void rgSCHPwrUlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHPwrUlCqiInd(cell, ue)
+Void rgSCHPwrUlCqiInd(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
#ifdef TFU_UPGRADE
S32 tmp;
#endif
- TRC2(rgSCHPwrUlCqiInd);
/*
* For absolute power cmd case, we could look at the time
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrRecordRbAlloc
+Void rgSCHPwrRecordRbAlloc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
U8 numRb
)
#else
-PUBLIC Void rgSCHPwrRecordRbAlloc(cell, ue, numRb)
+Void rgSCHPwrRecordRbAlloc(cell, ue, numRb)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 numRb;
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
UNUSED(cell);
- TRC2(rgSCHPwrRecordRbAlloc);
RETVOID;
if (uePwr->isPhrAvail)
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrCellCfg
+S16 rgSCHPwrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cfg
)
#else
-PUBLIC S16 rgSCHPwrCellCfg(cell, cfg)
+S16 rgSCHPwrCellCfg(cell, cfg)
RgSchCellCb *cell;
RgrCellCfg *cfg;
#endif
CmLteRnti startRnti;
U16 size;
Bool isFmt3a;
- TRC2(rgSCHPwrCellCfg);
/* Right now, all UEs have fixed maximum power capability. So
* we store cell wide pMax as minimum of configured pMax and
|| (cfg->pwrCfg.puschPwrFmt3.size + cfg->pwrCfg.puschPwrFmt3a.size
> RG_SCH_CMN_MAX_NUM_TPC_PUSCH_RNTI))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Now initialise TPC RNTIs */
rgSCHPwrAddRntiToPuschRntiLst(cell, rnti, isFmt3a);
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrCellRecfg
+S16 rgSCHPwrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg
)
#else
-PUBLIC S16 rgSCHPwrCellRecfg(cell, recfg)
+S16 rgSCHPwrCellRecfg(cell, recfg)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
#endif
{
UNUSED(cell);
UNUSED(recfg);
- TRC2(rgSCHPwrCellRecfg);
/* Not doing anything for power reconfig, so such structure
* in RGR */
- RETVALUE(ROK);
+ return ROK;
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrCellDel
+Void rgSCHPwrCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHPwrCellDel(cell)
+Void rgSCHPwrCellDel(cell)
RgSchCellCb *cell;
#endif
{
UNUSED(cell);
- TRC2(rgSCHPwrCellDel);
/* There is no allocated memory, so do nothing */
RETVOID;
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrUeSCellCfg
+S16 rgSCHPwrUeSCellCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeSecCellCfg *sCellInfoCfg
)
#else
-PUBLIC S16 rgSCHPwrUeSCellCfg(cell, ue, sCellInfoCfg)
+S16 rgSCHPwrUeSCellCfg(cell, ue, sCellInfoCfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeSecCellCfg *sCellInfoCfg;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHPwrUeSCellCfg);
uePwr->maxUePwr = cellPwr->pMax;
uePwr->trgCqi = cellPwr->trgUlCqi; /* Overriding with UE's happens later */
}
uePwr->p0UePusch = sCellInfoCfg->ueSCellUlDedPwrCfg.p0UePusch;
- RETVALUE(ROK);
+ return ROK;
}
#endif
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrUeCfg
+S16 rgSCHPwrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeCfg *cfg
)
#else
-PUBLIC S16 rgSCHPwrUeCfg(cell, ue, cfg)
+S16 rgSCHPwrUeCfg(cell, ue, cfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *cfg;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- TRC2(rgSCHPwrUeCfg);
-
uePwr->maxUePwr = cellPwr->pMax;
uePwr->trgCqi = cellPwr->trgUlCqi; /* Overriding with UE's happens later */
uePwr->numRb = 1;
* config happens in the function below */
ret = rgSCHPwrApplyUePwrCfg(cell, ue, &cfg->ueUlPwrCfg);
- RETVALUE(ret);
+ return (ret);
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHPwrUeRecfg
+S16 rgSCHPwrUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *recfg
)
#else
-PUBLIC S16 rgSCHPwrUeRecfg(cell, ue, recfg)
+S16 rgSCHPwrUeRecfg(cell, ue, recfg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *recfg;
S16 ret;
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgrUeUlPwrCfg *pwrCfg = &recfg->ueUlPwrRecfg;
- TRC2(rgSCHPwrUeRecfg);
if (pwrCfg->p0UePucch != uePwr->p0UePucch)
{
}
ret = rgSCHPwrApplyUePwrCfg(cell, ue, &recfg->ueUlPwrRecfg);
- RETVALUE(ret);
+ return (ret);
}
/***********************************************************
RgSchCmnTpcRntiCb *puschRntiCb = NULLP;
U8 pucchIdx = 0;
U8 puschIdx = 0;
- TRC2(rgSCHPwrApplyUePwrCfg);
/* Validate Pucch group power control config */
if (pwrCfg->uePucchPwr.pres)
rgSCHPwrGetPucchRntiCb(cell, pwrCfg->uePucchPwr.tpcRnti);
if (pucchRntiCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
pucchIdx = pwrCfg->uePucchPwr.idx;
ret = rgSCHPwrChkPucchTpcRntiIdx(pucchRntiCb, pucchIdx);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
rgSCHPwrGetPuschRntiCb(cell, pwrCfg->uePuschPwr.tpcRnti);
if (puschRntiCb == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
puschIdx = pwrCfg->uePuschPwr.idx;
ret = rgSCHPwrChkPuschTpcRntiIdx(puschRntiCb, puschIdx);
if (ret != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
uePwr->p0UePusch = pwrCfg->p0UePusch;
uePwr->p0UePucch = pwrCfg->p0UePucch;
- RETVALUE(ROK);
+ return ROK;
}
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUeDel
+Void rgSCHPwrUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHPwrUeDel(cell, ue)
+Void rgSCHPwrUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrUeDel);
if (uePwr->tpcPucchRntiCb)
{
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHPwrUeReset
+Void rgSCHPwrUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHPwrUeReset(cell, ue)
+Void rgSCHPwrUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHPwrUeReset);
rgSCHPwrUeResetPucch(cell, ue);
rgSCHPwrUeResetPusch(cell, ue);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrUeResetPucch);
uePwr->pucchTpc = 1;
uePwr->remPucchPwr = 0;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- TRC2(rgSCHPwrUeResetPusch);
uePwr->isPhrAvail = FALSE;
uePwr->phVal = 40;
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgSchCmnTpcRntiCb *cb;
Bool toAdd;
- TRC2(rgSCHPwrOnPuschPwrUpd);
if ((cb = uePwr->tpcPuschRntiCb) == NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddRntiToPucchRntiLst);
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPucchRntiLst[cellPwr->tpcPucchRntiCnt++],
rnti, isFmt3a);
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddRntiToPuschRntiLst);
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPuschRntiLst[cellPwr->tpcPuschRntiCnt++],
rnti, isFmt3a);
Bool isFmt3a;
#endif
{
- TRC2(rgSCHPwrInitTpcRntiCb);
- cmMemset((U8 *)cb, 0, sizeof(*cb));
+ memset(cb, 0, sizeof(*cb));
cb->tpcRnti = rnti;
cb->isFmt3a = isFmt3a;
/* Not initialising lists as memset 0 takes care of it */
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
U16 idx;
- TRC2(rgSCHPwrGetPucchRntiCb);
if (!cellPwr->tpcPucchRntiCnt)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
for (idx = 0; idx < cellPwr->tpcPucchRntiCnt; ++idx)
{
if (cellPwr->tpcPucchRntiLst[idx].tpcRnti == tpcRnti)
{
- RETVALUE(&cellPwr->tpcPucchRntiLst[idx]);
+ return (&cellPwr->tpcPucchRntiLst[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
/***********************************************************
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
U16 idx;
- TRC2(rgSCHPwrGetPuschRntiCb);
if (!cellPwr->tpcPuschRntiCnt)
{
- RETVALUE(NULLP);
+ return (NULLP);
}
for (idx = 0; idx < cellPwr->tpcPuschRntiCnt; ++idx)
{
if (cellPwr->tpcPuschRntiLst[idx].tpcRnti == tpcRnti)
{
- RETVALUE(&cellPwr->tpcPuschRntiLst[idx]);
+ return (&cellPwr->tpcPuschRntiLst[idx]);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
UNUSED(cell);
- TRC2(rgSCHPwrAddUeToPucchTpcRntiCb);
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->pucchGrpLnk);
uePwr->pucchGrpLnk.node = (PTR)ue;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrDelUeFrmPucchTpcRntiCb);
rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->pucchGrpLnk);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb);
if (uePwr->schdPucchGrpLnk.node == NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeOnlyFrmPucchTpcRntiCb);
if (uePwr->schdPucchGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrRmvSchdPucchTpcRntiCb);
if (cb->schdLnk.node == NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrAddSchdUeToPucchTpcRntiCb);
if (uePwr->schdPucchGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddSchdPucchTpcRntiCb);
cmLListAdd2Tail(&cellPwr->pucchGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrAddUeToPuschTpcRntiCb);
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->puschGrpLnk);
uePwr->puschGrpLnk.node = (PTR)ue;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrAddSchdUeToPuschTpcRntiCb);
if (uePwr->schdPuschGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrDelUeFrmPuschTpcRntiCb);
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->puschGrpLnk);
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb);
if (uePwr->schdPuschGrpLnk.node == NULLP)
{
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
- TRC2(rgSCHPwrRmvSchdUeOnlyFrmPuschTpcRntiCb);
if (uePwr->schdPuschGrpLnk.node != NULLP)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrAddSchdPuschTpcRntiCb);
cmLListAdd2Tail(&cellPwr->puschGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- TRC2(rgSCHPwrRmvSchdPuschTpcRntiCb);
if (cb->schdLnk.node == NULLP)
{
U8 idx;
#endif
{
- TRC2(rgSCHPwrChkPucchTpcRntiIdx);
if (rgSCHPwrChkTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHPwrChkUniqPucchTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
U8 idx;
#endif
{
- TRC2(rgSCHPwrChkPuschTpcRntiIdx);
if (rgSCHPwrChkTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if (rgSCHPwrChkUniqPuschTpcRntiIdx(cb, idx) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
#endif
{
CmLList *lnk;
- TRC2(rgSCHPwrChkUniqPucchTpcRntiIdx);
for (lnk = cb->cfgdUes.first; lnk; lnk = lnk->next)
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
if (uePwr->pucchIdx == idx)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
#endif
{
CmLList *lnk;
- TRC2(rgSCHPwrChkUniqPuschTpcRntiIdx);
for (lnk = cb->cfgdUes.first; lnk; lnk = lnk->next)
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
if (uePwr->puschIdx == idx)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/***********************************************************
U8 idx;
#endif
{
- TRC2(rgSCHPwrChkTpcRntiIdx);
-
if (cb->isFmt3a)
{
if (idx >= TFU_MAX_1BIT_TPC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
{
if (idx >= TFU_MAX_2BIT_TPC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
- RETVALUE(ROK);
+ return ROK;
}
/* Warning Fix: Commenting out as not used */
U8 pCMax;
#endif
{
- TRC2(rgSCHPwrGetPCMaxValFromPCMax);
- RETVALUE((pCMax & 63) - 30);
+ return ((pCMax & 63) - 30);
}
U8 phr;
#endif
{
- TRC2(rgSCHPwrGetPhValFromPhr);
- RETVALUE((phr & 63) - 23);
+ return ((phr & 63) - 23);
}