/* This table maps a given number of RBs (given by array index)
* to the power in dB that these many RBs map to. */
-CONSTANT U8 rgSchPwrRbToPwrTbl[111] = { 0, /* First entry is dummy */
+CONSTANT uint8_t rgSchPwrRbToPwrTbl[111] = { 0, /* First entry is dummy */
0, 3, 4, 6, 7, 7, 8, 9, 9, 10,
10, 10, 11, 11, 11, 12, 12, 12, 12, 13,
13, 13, 13, 13, 14, 14, 14, 14, 14, 14,
/* This table maps power (in dB) to number of RBs */
/* The array size comes from max power in rgSchPwrRbToPwrTbl */
-CONSTANT U8 rgSchPwrToRbTbl[20+1] = {
+CONSTANT uint8_t rgSchPwrToRbTbl[20+1] = {
1, 1, 2, 2, 3, 4, 5, 6, 7, 9, 11,
13, 17, 21, 26, 33, 41, 52, 65, 82, 103
};
PRIVATE S8 rgSCHPwrGetCqiPwr ARGS((
- U8 cqi
+ uint8_t cqi
));
PRIVATE S8 rgSCHPwrGetCqiPwrForUe ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U8 cqi
+ uint8_t cqi
));
PRIVATE S8 rgSCHPwrCalcEfficncyPwr ARGS((
- U32 eff
+ uint32_t eff
));
PRIVATE S8 rgSCHPwrGetDelta2FrmCqi ARGS((
- U8 crntCqi,
- U8 trgCqi,
+ uint8_t crntCqi,
+ uint8_t trgCqi,
RgSchUeCb *ue,
RgSchCellCb *cell
));
PRIVATE Void rgSCHPwrGetPuschTpc ARGS((
- U8 isAcc,
+ uint8_t isAcc,
S8 delta,
S8 availPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *tpcDelta
));
-PRIVATE U8 rgSCHPwrGetMaxRb ARGS((
+PRIVATE uint8_t rgSCHPwrGetMaxRb ARGS((
RgSchCellCb *cell,
S8 pwr
));
-PRIVATE U8 rgSCHPwrRbToPwr ARGS((
+PRIVATE uint8_t rgSCHPwrRbToPwr ARGS((
RgSchCellCb *cell,
- U8 numRb
+ uint8_t numRb
));
PRIVATE Void rgSCHPwrSchedPucchRnti ARGS((
RgSchCellCb *cell,
));
PRIVATE Void rgSCHPwrGetPucchFmt3TpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetPucchFmt3aTpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetPuschFmt3TpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetPuschFmt3aTpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetAcc1bitTpc ARGS((
S8 remPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetAcc2bitTpc ARGS((
S8 remPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetAbsTpc ARGS((
S8 remPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrOnPucchGrpPwrForUe ARGS((
));
PRIVATE S16 rgSCHPwrChkPucchTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkPuschTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkUniqPucchTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkUniqPuschTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S8 rgSCHPwrGetPhValFromPhr ARGS((
- U8 phr
+ uint8_t phr
));
PRIVATE S8 rgSCHPwrGetPCMaxValFromPCMax ARGS((
- U8 pCMax
+ uint8_t pCMax
));
/* local defines */
Void rgSCHPwrInit()
#endif
{
- U8 idx;
+ uint8_t idx;
rgSchPwrCqiToPwrTbl[0] = 0; /* This should never be used anyway */
for (idx = 1; idx < RG_SCH_CMN_UL_NUM_CQI; ++idx)
{
rgSchPwrCqiToPwrTbl[idx] = rgSCHPwrCalcEfficncyPwr(rgSchCmnUlCqiTbl[idx].eff);
}
- RETVOID;
+ return;
}
/***********************************************************
* Desc : Returns power corresponding to coding efficiency
* when beta pusch is assumed 1.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetCqiPwr
(
-U8 cqi
+uint8_t cqi
)
#else
PRIVATE S8 rgSCHPwrGetCqiPwr(cqi)
-U8 cqi;
+uint8_t cqi;
#endif
{
* Desc : If MCS control is enabled for UE, returns
* power corresponding to CQI, else 0.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 cqi
+uint8_t cqi
)
#else
PRIVATE S8 rgSCHPwrGetCqiPwrForUe(cell, ue, cqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 cqi;
+uint8_t cqi;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
* Desc : Computes power corresponding to a coding
* efficiency.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes: Assumes beta pusch to be 1
*
#ifdef ANSI
PRIVATE S8 rgSCHPwrCalcEfficncyPwr
(
-U32 eff
+uint32_t eff
)
#else
PRIVATE S8 rgSCHPwrCalcEfficncyPwr(eff)
-U32 eff;
+uint32_t eff;
#endif
{
F64 ks = 1.25; /* or F64 */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHPwrPuschTpcForUe
+uint8_t rgSCHPwrPuschTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-U8 rgSCHPwrPuschTpcForUe(cell, ue)
+uint8_t rgSCHPwrPuschTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-U8 rgSCHPwrGetMaxUlRb
+uint8_t rgSCHPwrGetMaxUlRb
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-U8 rgSCHPwrGetMaxUlRb(cell, ue)
+uint8_t rgSCHPwrGetMaxUlRb(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
S8 delta;
#ifdef TFU_UPGRADE
- U8 cqi = ueUl->validUlCqi;
+ uint8_t cqi = ueUl->validUlCqi;
S32 tmp;
#else
- U8 cqi = ueUl->crntUlCqi[0];
+ uint8_t cqi = ueUl->crntUlCqi[0];
#endif
Bool isAcc = uePwr->isAccumulated;
- U8 tpc;
+ uint8_t tpc;
S8 availPwr;
- U8 maxRb;
+ uint8_t maxRb;
UNUSED(cell);
uePwr->delta = delta;
uePwr->maxUlRbs = maxRb;
uePwr->puschTpc = tpc;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHPwrPucchTpcForUe
+uint8_t rgSCHPwrPucchTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-U8 rgSCHPwrPucchTpcForUe(cell, ue)
+uint8_t rgSCHPwrPucchTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetDelta2FrmCqi
(
-U8 crntCqi,
-U8 trgCqi,
+uint8_t crntCqi,
+uint8_t trgCqi,
RgSchUeCb *ue,
RgSchCellCb *cell
)
#else
PRIVATE S8 rgSCHPwrGetDelta2FrmCqi(crntCqi, trgCqi)
-U8 crntCqi;
-U8 trgCqi;
+uint8_t crntCqi;
+uint8_t trgCqi;
RgSchUeCb *ue;
RgSchCellCb *cell;
#endif
#ifdef ANSI
PRIVATE Void rgSCHPwrGetPuschTpc
(
-U8 isAcc,
+uint8_t isAcc,
S8 delta,
S8 availPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *tpcDelta
)
#else
PRIVATE Void rgSCHPwrGetPuschTpc(isAcc, delta, availPwr, tpc, tpcDelta)
-U8 isAcc;
+uint8_t isAcc;
S8 delta;
S8 availPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *tpcDelta;
#endif
{
{
rgSCHPwrGetAbsTpc(delta, tpc, tpcDelta);
}
- RETVOID;
+ return;
} /* rgSCHPwrGetPuschTpc */
/***********************************************************
* expected to be supported by the passed
* power headroom.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
*
**********************************************************/
#ifdef ANSI
-PRIVATE U8 rgSCHPwrGetMaxRb
+PRIVATE uint8_t rgSCHPwrGetMaxRb
(
RgSchCellCb *cell,
S8 pwr
)
#else
-PRIVATE U8 rgSCHPwrGetMaxRb(cell, pwr)
+PRIVATE uint8_t rgSCHPwrGetMaxRb(cell, pwr)
RgSchCellCb *cell;
S8 pwr;
#endif
{
return (cellUl->maxUlBwPerUe);
}
- return (RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(U8)pwr]));
+ return (RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(uint8_t)pwr]));
} /* rgSCHPwrGetMaxRb */
/***********************************************************
*
* Desc : Get the power corresponding to number of RBs
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
*
**********************************************************/
#ifdef ANSI
-PRIVATE U8 rgSCHPwrRbToPwr
+PRIVATE uint8_t rgSCHPwrRbToPwr
(
RgSchCellCb *cell,
-U8 numRb
+uint8_t numRb
)
#else
-PRIVATE U8 rgSCHPwrRbToPwr(cell,numRb)
+PRIVATE uint8_t rgSCHPwrRbToPwr(cell,numRb)
RgSchCellCb *cell;
-U8 numRb;
+uint8_t numRb;
#endif
{
#ifndef NO_ERRCLS
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, &uePwr->pucchTpc, &delta);
rgSCHPwrOnSchedPucchTpc(cell, ue, delta);
- RETVOID;
+ return;
}
/**
* be scheduled again */
}
- RETVOID;
+ return;
}
/**
* be scheduled again */
}
- RETVOID;
+ return;
}
/***********************************************************
{
CmLListCp *lst;
CmLList *lnk;
- U8 *tpcCmds;
- U8 tpc;
+ uint8_t *tpcCmds;
+ uint8_t tpc;
S8 delta;
Bool atleastOne;
rgSCHPwrRmvSchdPucchTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
} /* rgSCHPwrSchedPucchRnti */
/***********************************************************
{
CmLListCp *lst;
CmLList *lnk;
- U8 *tpcCmds;
- U8 tpc;
+ uint8_t *tpcCmds;
+ uint8_t tpc;
S8 delta;
Bool atleastOne;
rgSCHPwrRmvSchdPuschTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
} /* rgSCHPwrSchedPuschRnti */
/***********************************************************
PRIVATE Void rgSCHPwrGetPucchFmt3TpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPucchFmt3TpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPucchFmt3TpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetPucchFmt3aTpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPucchFmt3aTpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
rgSCHPwrGetAcc1bitTpc(uePwr->remPucchPwr, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPucchFmt3aTpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetPuschFmt3TpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPuschFmt3TpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
S8 adj = RGSCH_MIN(uePwr->remPuschPwr, uePwr->phVal);
rgSCHPwrGetAcc2bitTpc(adj, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPuschFmt3TpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetPuschFmt3aTpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPuschFmt3aTpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
/* Don't attempt to look at headroom now, power
* adjustment is small anyway */
rgSCHPwrGetAcc1bitTpc(uePwr->remPuschPwr, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPuschFmt3aTpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetAcc1bitTpc
(
S8 remPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetAcc1bitTpc(remPwr, tpc, delta)
S8 remPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
*delta = 1;
*tpc = 1;
}
- RETVOID;
+ return;
} /* rgSCHPwrGetAcc1bitTpc */
/***********************************************************
PRIVATE Void rgSCHPwrGetAcc2bitTpc
(
S8 remPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetAcc2bitTpc(remPwr, tpc, delta)
S8 remPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
* 2 1
* 3 3
*/
- U8 tpcs[3] = {1, 2, 2};
- U8 deltas[3] = {0, 1, 1};
+ uint8_t tpcs[3] = {1, 2, 2};
+ uint8_t deltas[3] = {0, 1, 1};
if (remPwr <= -1)
{
*tpc = 0;
}
else
{
- *tpc = tpcs[(U8)remPwr];
- *delta = deltas[(U8)remPwr];
+ *tpc = tpcs[(uint8_t)remPwr];
+ *delta = deltas[(uint8_t)remPwr];
}
- RETVOID;
+ return;
} /* rgSCHPwrGetAcc2bitTpc */
/***********************************************************
PRIVATE Void rgSCHPwrGetAbsTpc
(
S8 remPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetAbsTpc(remPwr, tpc, delta)
S8 remPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
*tpc = 3;
*delta = 4;
}
- RETVOID;
+ return;
} /* rgSCHPwrGetAbsTpc */
/***********************************************************
* this will happen in the caller once this
* function is called for every UE scheduled. */
}
- RETVOID;
+ return;
}
/***********************************************************
* this will happen in the caller once this
* function is called for every UE scheduled. */
}
- RETVOID;
+ return;
}
/***********************************************************
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 pwrDelta
+ * @param[in] uint8_t pwrDelta
* @return Void
**/
#ifdef ANSI
if ((cb = uePwr->tpcPucchRntiCb) == NULLP)
{
- RETVOID;
+ return;
}
toAdd = FALSE;
rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb(cell, cb, ue);
}
- RETVOID;
+ return;
}
/**
if (uePwr->schdPucchGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
/* UE was scheduled for TPC, sent TPC may
rgSCHPwrRmvSchdPucchTpcRntiCb(cell, uePwr->tpcPucchRntiCb);
}
}
- RETVOID;
+ return;
}
/* Don't do anything for the case of absolute TPC commands */
if (!uePwr->isAccumulated)
{
- RETVOID;
+ return;
}
uePwr->remPuschPwr -= uePwr->delta;
if (uePwr->schdPuschGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
/* UE was scheduled for pusch TPC, sent TPC may
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, uePwr->tpcPuschRntiCb, ue);
}
- RETVOID;
+ return;
}
/**
RgSchCmnAllocRecord *allocInfo;
#endif
{
- U8 idx;
+ uint8_t idx;
RgInfExtPhrSCellInfo *servCellPhr;
S8 pCMax;
rgSCHPwrUpdPhr(ue->cellInfo[servCellPhr->sCellIdx]->cell,
ue, servCellPhr->phr, allocInfo, pCMax);
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[in] RgSchCmnAllocRecord allocInfo
- * @param[in] U8 maxUePwr
+ * @param[in] uint8_t maxUePwr
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 phr,
+uint8_t phr,
RgSchCmnAllocRecord *allocInfo,
S8 maxUePwr
)
Void rgSCHPwrUpdPhr(cell, ue, phr, allocInfo, maxUePwr)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 phr;
+uint8_t phr;
RgSchCmnAllocRecord *allocInfo;
S8 maxUePwr;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- U8 rbPwr;
- U8 effPwr;
+ uint8_t rbPwr;
+ uint8_t effPwr;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
uePwr->phVal = rgSCHPwrGetPhValFromPhr(phr);
allocInfo->cqi,
allocInfo->numRb,
uePwr->pwrPerRb);
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numRb
+ * @param[in] uint8_t numRb
* @return Void
**/
#ifdef ANSI
}
#endif
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numRb
+ * @param[in] uint8_t numRb
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numRb
+uint8_t numRb
)
#else
Void rgSCHPwrRecordRbAlloc(cell, ue, numRb)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numRb;
+uint8_t numRb;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
UNUSED(cell);
- RETVOID;
+ return;
if (uePwr->isPhrAvail)
{
uePwr->phVal = RGSCH_MIN(40, uePwr->phVal);
}
uePwr->numRb = numRb;
- RETVOID;
+ return;
}
/**
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
CmLteRnti rnti;
CmLteRnti startRnti;
- U16 size;
+ uint16_t size;
Bool isFmt3a;
/* Right now, all UEs have fixed maximum power capability. So
UNUSED(cell);
/* There is no allocated memory, so do nothing */
- RETVOID;
+ return;
}
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgSchCmnTpcRntiCb *pucchRntiCb = NULLP;
RgSchCmnTpcRntiCb *puschRntiCb = NULLP;
- U8 pucchIdx = 0;
- U8 puschIdx = 0;
+ uint8_t pucchIdx = 0;
+ uint8_t puschIdx = 0;
/* Validate Pucch group power control config */
if (pwrCfg->uePucchPwr.pres)
#ifndef ALIGN_64BIT
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"<GRP_PWR>PucchRntiCb cfgdUes(%ld %lu %lu) UEID:%d",
- pucchRntiCb->cfgdUes.count,((U32)pucchRntiCb->cfgdUes.first),
- ((U32)pucchRntiCb->cfgdUes.last),ue->ueId);
+ pucchRntiCb->cfgdUes.count,((uint32_t)pucchRntiCb->cfgdUes.first),
+ ((uint32_t)pucchRntiCb->cfgdUes.last),ue->ueId);
RLOG_ARG3(L_UNUSED,DBG_CELLID,cell->cellId,
"UEID:%d isFmt3a(%u) ueNode(%ld)",
ue->ueId,pucchRntiCb->isFmt3a,
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"toBeSchdUes(%ld %lu %lu) tpcRnti(%u)",
pucchRntiCb->toBeSchdUes.count,
- ((U32)pucchRntiCb->toBeSchdUes.first),
- ((U32)pucchRntiCb->toBeSchdUes.last),
+ ((uint32_t)pucchRntiCb->toBeSchdUes.first),
+ ((uint32_t)pucchRntiCb->toBeSchdUes.last),
pucchRntiCb->tpcRnti);
#else
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"<GRP_PWR>PucchRntiCb cfgdUes(%ld %lu %lu) UEID:%d",
- pucchRntiCb->cfgdUes.count,((U64)pucchRntiCb->cfgdUes.first),
- ((U64)pucchRntiCb->cfgdUes.last),ue->ueId);
+ pucchRntiCb->cfgdUes.count,((uint64_t)pucchRntiCb->cfgdUes.first),
+ ((uint64_t)pucchRntiCb->cfgdUes.last),ue->ueId);
RLOG_ARG3(L_UNUSED,DBG_CELLID,cell->cellId,
"UEID:%d isFmt3a(%u) ueNode(%ld)",
ue->ueId,pucchRntiCb->isFmt3a,
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"toBeSchdUes(%ld %lu %lu) tpcRnti(%u)",
pucchRntiCb->toBeSchdUes.count,
- ((U64)pucchRntiCb->toBeSchdUes.first),
- ((U64)pucchRntiCb->toBeSchdUes.last),
+ ((uint64_t)pucchRntiCb->toBeSchdUes.first),
+ ((uint64_t)pucchRntiCb->toBeSchdUes.last),
pucchRntiCb->tpcRnti);
#endif
rgSCHPwrDelUeFrmPuschTpcRntiCb(cell, uePwr->tpcPuschRntiCb, ue);
uePwr->tpcPuschRntiCb = NULLP;
}
- RETVOID;
+ return;
}
/**
rgSCHPwrUeResetPucch(cell, ue);
rgSCHPwrUeResetPusch(cell, ue);
- RETVOID;
+ return;
}
/***********************************************************
}
/* Stack Crash problem for TRACE5 changes. Added the line below */
- RETVOID;
+ return;
}
{
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, uePwr->tpcPuschRntiCb, ue);
}
- RETVOID;
+ return;
}
/***********************************************************
if ((cb = uePwr->tpcPuschRntiCb) == NULLP)
{
- RETVOID;
+ return;
}
/* Not checking for uwPwr->isPhrAvail as uePwr->phVal
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, cb, ue);
}
- RETVOID;
+ return;
}
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPucchRntiLst[cellPwr->tpcPucchRntiCnt++],
rnti, isFmt3a);
- RETVOID;
+ return;
}
/***********************************************************
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPuschRntiLst[cellPwr->tpcPuschRntiCnt++],
rnti, isFmt3a);
- RETVOID;
+ return;
}
/***********************************************************
cb->isFmt3a = isFmt3a;
/* Not initialising lists as memset 0 takes care of it */
/* cb->schdLnk.node is set when this rnti is to be scheduled */
- RETVOID;
+ return;
}
/***********************************************************
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- U16 idx;
+ uint16_t idx;
if (!cellPwr->tpcPucchRntiCnt)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- U16 idx;
+ uint16_t idx;
if (!cellPwr->tpcPuschRntiCnt)
{
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->pucchGrpLnk);
uePwr->pucchGrpLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/***********************************************************
rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->pucchGrpLnk);
uePwr->pucchGrpLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPucchGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
rgSCHPwrRmvSchdUeOnlyFrmPucchTpcRntiCb(cell, cb, ue);
if (!cb->toBeSchdUes.count)
{
rgSCHPwrRmvSchdPucchTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListDelFrm(&cb->toBeSchdUes, &uePwr->schdPucchGrpLnk);
uePwr->schdPucchGrpLnk.node = NULLP;
}
- RETVOID;
+ return;
}
/***********************************************************
if (cb->schdLnk.node == NULLP)
{
- RETVOID;
+ return;
}
cmLListDelFrm(&cellPwr->pucchGrpPwr, &cb->schdLnk);
cb->schdLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPucchGrpLnk.node != NULLP)
{
/* UE is already in the list */
- RETVOID;
+ return;
}
cmLListAdd2Tail(&cb->toBeSchdUes, &uePwr->schdPucchGrpLnk);
uePwr->schdPucchGrpLnk.node = (PTR)ue;
* for scheduling */
rgSCHPwrAddSchdPucchTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListAdd2Tail(&cellPwr->pucchGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
- RETVOID;
+ return;
}
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->puschGrpLnk);
uePwr->puschGrpLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPuschGrpLnk.node != NULLP)
{
/* UE is already in the list */
- RETVOID;
+ return;
}
cmLListAdd2Tail(&cb->toBeSchdUes, &uePwr->schdPuschGrpLnk);
uePwr->schdPuschGrpLnk.node = (PTR)ue;
* for scheduling */
rgSCHPwrAddSchdPuschTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->puschGrpLnk);
uePwr->puschGrpLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPuschGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
rgSCHPwrRmvSchdUeOnlyFrmPuschTpcRntiCb(cell, cb, ue);
if (!cb->toBeSchdUes.count)
{
rgSCHPwrRmvSchdPuschTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListDelFrm(&cb->toBeSchdUes, &uePwr->schdPuschGrpLnk);
uePwr->schdPuschGrpLnk.node = NULLP;
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListAdd2Tail(&cellPwr->puschGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
- RETVOID;
+ return;
}
/***********************************************************
if (cb->schdLnk.node == NULLP)
{
- RETVOID;
+ return;
}
cmLListDelFrm(&cellPwr->puschGrpPwr, &cb->schdLnk);
cb->schdLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
PRIVATE S16 rgSCHPwrChkPucchTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkPucchTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
PRIVATE S16 rgSCHPwrChkPuschTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkPuschTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
PRIVATE S16 rgSCHPwrChkUniqPucchTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkUniqPucchTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
CmLList *lnk;
PRIVATE S16 rgSCHPwrChkUniqPuschTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkUniqPuschTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
CmLList *lnk;
PRIVATE S16 rgSCHPwrChkTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
if (cb->isFmt3a)
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetPCMaxValFromPCMax
(
-U8 pCMax
+uint8_t pCMax
)
#else
PRIVATE S8 rgSCHPwrGetPCMaxValFromPCMax(pCMax)
-U8 pCMax;
+uint8_t pCMax;
#endif
{
return ((pCMax & 63) - 30);
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetPhValFromPhr
(
-U8 phr
+uint8_t phr
)
#else
PRIVATE S8 rgSCHPwrGetPhValFromPhr(phr)
-U8 phr;
+uint8_t phr;
#endif
{
return ((phr & 63) - 23);