RgSchCellCb *cell,
CmLListCp *ueTxLst,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 *remUe
+uint8_t *remUe
));
PRIVATE Void rgSCHSc1DlProcRmvFrmRetx ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
));
-PUBLIC Void rgSCHSc1DlScanUpdPdbPrio ARGS((
+Void rgSCHSc1DlScanUpdPdbPrio ARGS((
RgSchCellCb *cell
));
-PUBLIC S16 rgSCHSc1DlFillFlowCntrlInfo ARGS((
+S16 rgSCHSc1DlFillFlowCntrlInfo ARGS((
RgSchCellCb *cell,
RgInfSfAlloc *sfAlloc
));
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlUeReset
+Void rgSCHSc1DlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlUeReset(cell, ue)
+Void rgSCHSc1DlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHSc1DlUeReset);
rgSCHSc1DlSuspendUe(cell, ue);
- RETVOID;
+ return;
}
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlActvtUe
+Void rgSCHSc1DlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlActvtUe(cell, ue)
+Void rgSCHSc1DlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
CmLList *node;
RgSchDlHqProcCb *hqP;
RgSchDlLcCb *svc;
- U8 idx;
- TRC2(rgSCHSc1DlActvtUe);
+ uint8_t idx;
/* Add UE's HqProcs From UERetxLst to CellRetxLst */
lst = &ueDl->retxHqProcs;
rgSCHSc1DlUeAddToSchd(cell, ue);
}
- RETVOID;
+ return;
}
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlUeRefresh
+Void rgSCHSc1DlUeRefresh
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlUeRefresh(cell, ue)
+Void rgSCHSc1DlUeRefresh(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
CmLListCp *lst;
CmLList *node;
RgSchDlLcCb *svc;
- TRC2(rgSCHSc1DlUeRefresh);
if (ue->dl.ambrCfgd)
{
/* Update the SVC's positioning in the Queue */
rgSCHSc1DlMngGbrSvcPosn(cell, ue, svc);
}
- RETVOID;
+ return;
}
\f
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
RgSchCmnDlHqProc *hqProcDl = RG_SCH_CMN_GET_DL_HQP(hqP);
- TRC2(rgSCHSc1DlProcRmvFrmCellRetx);
if (hqProcDl->retxLnk.node != NULLP)
{
(hqProcDl->schSpfc))->prio], &(hqProcDl->retxLnk));
hqProcDl->retxLnk.node = NULLP;
}
- RETVOID;
+ return;
}
\f
RgSchSc1DlUe *sc1Ue = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlHqProc *hqProcDl = RG_GET_SC1_HQP_DL(hqP);
- TRC2(rgSCHSc1DlProcRmvFrmUeRetx);
if (hqProcDl->retxLnkUe.node != NULLP)
{
&(hqProcDl->retxLnkUe));
hqProcDl->retxLnkUe.node = NULLP;
}
- RETVOID;
+ return;
}
\f
RgSchSc1DlUe *sc1Ue = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlHqProc *cmnHqDl = RG_GET_SC1_HQP_DL(hqP);
- TRC2(rgSCHSc1DlProcAddToUeRetx);
cmLListAdd2Tail(&sc1Ue->retxHqProcs,
&(cmnHqDl->retxLnkUe));
cmnHqDl->retxLnkUe.node = (PTR)hqP;
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlProcAddToCellRetx
+Void rgSCHSc1DlProcAddToCellRetx
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHSc1DlProcAddToCellRetx(cell, hqP)
+Void rgSCHSc1DlProcAddToCellRetx(cell, hqP)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
#endif
RgSchSc1DlCell *sc1CellDl = RG_GET_SC1_CELL_DL(cell);
RgSchCmnDlHqProc *cmnHqDl = RG_SCH_CMN_GET_DL_HQP(hqP);
- TRC2(rgSCHSc1DlProcAddToCellRetx);
if (!RG_SCH_CMN_DL_IS_UE_ACTIVE(hqP->hqE->ue))
{
rgSCHSc1DlProcAddToUeRetx(cell, hqP->hqE->ue, hqP);
- RETVOID;
+ return;
}
cmLListAdd2Tail(&sc1CellDl->retxLst[((RgSchSc1DlHqProc *)\
(cmnHqDl->schSpfc))->prio], &(cmnHqDl->retxLnk));
cmnHqDl->retxLnk.node = (PTR)hqP;
- RETVOID;
+ return;
}
\f
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- U8 i;
+ uint8_t i;
CmLListCp *retxLst;
CmLList *node;
RgSchDlHqProcCb *hqP;
#if (defined(LTEMAC_SPS) || (!defined(LTE_TDD)))
CmLteTimingInfo schdTime;
#endif
- U32 effBo;
+ uint32_t effBo;
RgSchUeCb *ue = NULLP;
#ifdef LTEMAC_HDFDD
Bool dlAllowed = FALSE;
#endif
RgSchDlRbAlloc *dlAllocCb;
- TRC2(rgSCHSc1DlRetxAlloc);
sc1CellDl = RG_GET_SC1_CELL_DL(cell);
#if (defined(LTEMAC_SPS) || (!defined(LTE_TDD)))
ROK)
{
/* SF/RETX Bandwidth expired */
- RETVOID;
+ return;
}
if (effBo == 0)
{
&& (hqP->tbInfo[1].state == HQ_TB_ACKED))
{
rgSCHSc1DlProcRmvFrmCellRetx(cell, hqP);
- RETVOID;
+ return;
}
cmnUeDl->proc = hqP;
/*rgSCHCmnDlRbInfoAddUeRetx(allocInfo, ue);*/
}
}
- RETVOID;
+ return;
}
/***********************************************************
RgSchDlHqProcCb *hqProc;
#endif
{
- TRC2(rgSCHSc1RlsHqProc)
rgSCHDhmRlsHqProc(hqProc);
- RETVOID;
+ return;
}
\f
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchDlLcCb *svc
- * @param[in] U32 bo
+ * @param[in] uint32_t bo
* @param[in] RgSchCmnDlRbAllocInfo *allocInfo
* @return S16
*
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchDlLcCb *svc,
-U32 bo,
+uint32_t bo,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchDlLcCb *svc;
-U32 bo;
+uint32_t bo;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
- U16 rlcHdrEstmt;
- U32 effBo;
+ uint16_t rlcHdrEstmt;
+ uint32_t effBo;
RgSchCmnDlCell *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
RgSchSc1DlSvc *svcSc1;
#endif
S16 ret;
- TRC2(rgSCHSc1DlDedSvcAlloc);
/* Get the UE to which this service belongs to */
ue = svc->ue;
rgSCHCmnHdFddChkDlAllow ( cell, ue, &dlAllowed);
if (dlAllowed == FALSE)
{
- RETVALUE(ROK);
+ return ROK;
}
}
#endif
RGSCH_INCR_SUB_FRAME(schdTime, RG_SCH_CMN_DL_DELTA);
if (RG_SCH_CMN_IS_UE_SPS_SCHDLD(ue, cell, schdTime))
{
- RETVALUE(ROK);
+ return ROK;
}
#endif
if (RG_SCH_CMN_IS_UE_SCHDLD(ue, cell))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d rgSCHSc1DlDedSvcAlloc():"
"Ue retransmitting",ue->ueId);
- RETVALUE(ROK);
+ return ROK;
}
/* UE is scheduled for either other services or TA */
sc1HqDl = RG_GET_SC1_HQP_DL(proc);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "CRNTI:%d rgSCHSc1DlDedSvcAlloc():"
" No HARQ Proc available", ue->ueId);
- RETVALUE(ROK);
+ return ROK;
}
sc1HqDl = RG_GET_SC1_HQP_DL(proc);
cmnHqDl = RG_SCH_CMN_GET_DL_HQP(proc);
/* ccpu00126519: proc should be set to NULLP in UE's DL scratch pad info as well. */
ueDl->proc = NULLP;
}
- RETVALUE(ret);
+ return (ret);
}
svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
svcSc1->hdrEstimate = rlcHdrEstmt;
rgSCHSc1DlAdd2UeSchdSvcs(cell, ue, svc);
/* 3.1 MIMO moving this call to cmn scheduler */
/*rgSCHCmnDlRbInfoAddUeTx(allocInfo, ue); */
- RETVALUE(ROK);
+ return ROK;
}
/**
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchSc1DlUe *ueSc1 = RG_GET_SC1_UE_DL(ue, cell);
- TRC2(rgSCHSc1DlAdd2UeSchdSvcs);
/* checking SVC's presence in this lst is unnecessary */
cmLListAdd2Tail(&ueSc1->schdSvcs, &svcSc1->schdSvcLnk);
svcSc1->schdSvcLnk.node = (PTR)svc;
- RETVOID;
+ return;
}
\f
CmLList *node;
RgSchUeCb *ue = NULLP;
RgSchDlLcCb *svc;
- U8 i;
+ uint8_t i;
RgSchSc1DlSvc *svcSc1;
RgSchSc1DlUe *ueDl;
RgSchSc1DlCell *sc1CellDl = RG_GET_SC1_CELL_DL(cell);
- TRC2(rgSCHSc1DlDedTx);
/* Process the first queue that is for RRC signalling and is of */
/* highest priority. */
if (rgSCHSc1DlDedSvcAlloc(cell, subFrm, svc, svcSc1->bo, allocInfo) != ROK)
{
/* sf bw expired */
- RETVOID;
+ return;
}
}
if (rgSCHSc1DlDedSvcAlloc(cell, subFrm, svc, svcSc1->effMbr, allocInfo) != ROK)
{
/* sf bw expired */
- RETVOID;
+ return;
}
}
}
if (rgSCHSc1DlDedSvcAlloc(cell, subFrm, svc, ueDl->effAmbr, allocInfo) != ROK)
{
/* sf bw expired */
- RETVOID;
+ return;
}
}
}
- RETVOID;
+ return;
}
/**
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1DlPreSchd(cell)
+Void rgSCHSc1DlPreSchd(cell)
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHSc1DlPreSchd);
- RETVOID;
+ return;
}
/**
* @brief scheduling for a cell
Inst schInst
)
#else
-PUBLIC Void rgSCHSc1DlPstSchd(schInst)
+Void rgSCHSc1DlPstSchd(schInst)
Inst schInst
#endif
{
- TRC2(rgSCHSc1DlPstSchd);
- RETVOID;
+ return;
}
\f
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHSc1DlDedNewTx);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "rgSCHSc1DlDedNewTx\n"));
/* Now perform the new UE selections */
rgSCHSc1DlDedTx(cell, subFrm, allocInfo);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
/**
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
- TRC2(rgSCHSc1DlDedRetx);
RGSCHDBGPRM(inst, (rgSchPBuf(inst), "rgSCHSc1DlDedRetx\n"));
rgSCHSc1DlRetxAlloc(cell, subFrm, allocInfo);
- RETVOID;
+ return;
}
RgSchSc1DlCell *sc1CellDl = RG_GET_SC1_CELL_DL(cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcAddToSchd);
svcSc1 = RG_GET_SC1_SVC_DL(svc->ue,svc,cell);
/* The service is already in the scheduler */
if (svcSc1->prioLnk.node != NULLP)
{
- RETVOID;
+ return;
}
/* If the priority = 0, it is the highest priority with infinite */
/* If a svc is put in to cell wide priority Qs
* then add the same to UE's lcsWithData List */
rgSCHSc1DlAdd2UeLcsWithData(cell, svc->ue, svc);
- RETVOID;
+ return;
}
/* Handle GBR services. We have them of next importance */
if (svcCmn->prio <= RG_SCH_SC1_DL_GBR_PRIO_END)
{
if (!RG_SC1_SVC_HAS_DATA(svc,cell))
- RETVOID;
+ return;
lst = &(sc1CellDl->prioLst[svcCmn->prio]);
node = lst->first;
while(node)
* then add the same to UE's lcsWithData List */
rgSCHSc1DlAdd2UeLcsWithData(cell, svc->ue, svc);
}
- RETVOID;
+ return;
}
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
CmLListCp *lst;
- TRC2(rgSCHSc1DlUeRmvFrmSchd);
lst = &cellDl->prioLst[ueDl->prio];
if (ueDl->prioLnk.node != NULLP)
* then remove the same from UE's lcsWithData List */
rgSCHSc1DlRmFrmUeLcsWithData(cell, ue, ueDl->ambrSvc);
}
- RETVOID;
+ return;
}
\f
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
CmLListCp *lst;
- TRC2(rgSCHSc1DlSvcRmvFrmUeAmbrLst);
-
lst = &ueDl->ambrLst;
if (svcSc1->prioLnk.node != NULLP)
{
cmLListDelFrm(lst, &svcSc1->prioLnk);
svcSc1->prioLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
\f
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcAddToUeAmbrLst);
/* If svc already present in AMBR List return */
if (svcSc1->prioLnk.node != NULLP)
- RETVOID;
+ return;
node = ueDl->ambrLst.first;
while(node)
svcSc1->prioLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
CmLListCp *lst;
- TRC2(rgSCHSc1DlSvcRmvFrmSchd);
lst = &(cellDl->prioLst[svcCmn->prio]);
if (svcDl->prioLnk.node != NULLP)
* then remove the same from UE's lcsWithData List */
rgSCHSc1DlRmFrmUeLcsWithData(cell, svc->ue, svc);
}
- RETVOID;
+ return;
}
\f
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcAdd);
UNUSED(cfg);
cmLListAdd2Tail(&ueDl->gbrSvcs, &svcSc1->gbrLnk);
svcSc1->gbrLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlLcRmv
+Void rgSCHSc1DlLcRmv
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHSc1DlLcRmv(cell, ue, svc)
+Void rgSCHSc1DlLcRmv(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlLcRmv);
if (svcSc1 == NULLP)
{
- RETVOID;
+ return;
}
ueDl = RG_GET_SC1_UE_DL(ue, cell);
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(RG_SCH_CMN_GET_LC_SCH_SPFC(ue,svc,cell))), (sizeof(RgSchSc1DlSvc)));
- RETVOID;
+ return;
}
/**
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
- TRC2(rgSCHSc1DlSvcMod);
if (RG_SCH_CMN_SVC_IS_GBR(svc))
{
svcSc1->gbr = svcCmn->gbr;
svcSc1->mbr = svcCmn->mbr;
}
- RETVOID;
+ return;
}
/**
CmLList *node;
CmLListCp *lst;
RgSchUeCb *nodeUe = NULLP;
- TRC2(rgSCHSc1DlUeAddToSchd);
ueDl->prio = ((RgSchCmnDlSvc *)(ueDl->ambrSvc->sch))->prio;
lst = &cellDl->prioLst[ueDl->prio];
/* If a svc is put in to cell wide priority Qs
* then add the same to UE's lcsWithData List */
rgSCHSc1DlAdd2UeLcsWithData(cell, ue, ueDl->ambrSvc);
- RETVOID;
+ return;
}
\f
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlMngAmbrSvcPosn);
-
if (svcSc1->bo == 0)
{
if (ueDl->ambrSvc == svc)
rgSCHSc1DlUeRmvFrmSchd(cell, ue);
}
}
- RETVOID;
+ return;
}
rgSCHSc1DlSvcAddToUeAmbrLst(cell, ue, svc);
/* Current ambr svc is always the first node of ambrLst.*/
}
}
}
- RETVOID;
+ return;
}
\f
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlLcBoUpd
+Void rgSCHSc1DlLcBoUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlLcCb *svc
)
#else
-PUBLIC Void rgSCHSc1DlLcBoUpd(cell, ue, svc)
+Void rgSCHSc1DlLcBoUpd(cell, ue, svc)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *svc;
#endif
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlLcBoUpd);
if (svcSc1->bo == svc->bo)
{
- RETVOID;
+ return;
}
svcSc1->bo = svc->bo;
if (!RG_SCH_CMN_DL_IS_UE_ACTIVE(ue))
{
- RETVOID;
+ return;
}
rgSCHSc1DlMngSvcPosn(cell, ue, svc);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
#endif
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlMngPrio0SvcPosn);
/* In this priority, we just add or remove to the queue */
if (svcSc1->bo > 0)
{
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
}
- RETVOID;
+ return;
}
\f
#endif
{
RgSchSc1DlSvc *svcSc1 = RG_GET_SC1_SVC_DL(ue,svc,cell);
- TRC2(rgSCHSc1DlMngGbrSvcPosn);
/* Handle a GBR service. */
svcSc1->effGbr = RGSCH_MIN(svcSc1->bo, svcSc1->gbr);
/* Adjust the SVC priority within the queue */
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
rgSCHSc1DlSvcAddToSchd(cell, svc);
- RETVOID;
+ return;
}
\f
{
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
- TRC2(rgSCHSc1DlMngSvcPosn);
(cellDl->svcMngFunc[svcCmn->prio])(cell, ue, svc);
- RETVOID;
+ return;
}
/*--------------------------*
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrDlCellCfg
+S16 rgSCHSc1RgrDlCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrDlCellCfg(cell, cellCfg, err)
+S16 rgSCHSc1RgrDlCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
S16 ret;
RgSchSc1DlCell *cellDl;
- TRC2(rgSCHSc1RgrDlCellCfg);
if((ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(((RgSchCmnCell*)((cell)->sc.sch))->dl.schSpfc), \
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_SC1_DL_CFG;
- RETVALUE(ret);
+ return (ret);
}
cellDl = RG_GET_SC1_CELL_DL(cell);
/* Now perform downlink Queues related initializations */
rgSCHSc1DlInitQueues(cellDl);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrDlCellCfg */
/***********************************************************
RgSchSc1DlCell *cellDl;
#endif
{
- U8 i;
- TRC2(rgSCHSc1DlDeinitQueues);
+ uint8_t i;
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
cmLListInit(&cellDl->prioLst[i]);
cmLListInit(&cellDl->retxLst[i]);
}
- RETVOID;
+ return;
}
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlCellDel
+Void rgSCHSc1DlCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1DlCellDel(cell)
+Void rgSCHSc1DlCellDel(cell)
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHSc1DlCellDel);
if (((RgSchSc1DlCell *)((RgSchCmnCell*)((cell)->sc.sch))->dl.schSpfc) \
== NULLP)
{
- RETVOID;
+ return;
}
/* Perform the deinit for the DL scheduler */
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(((RgSchCmnCell*)((cell)->sc.sch))->dl.schSpfc)),
(sizeof(RgSchSc1DlCell)));
- RETVOID;
+ return;
} /* rgSCHSc1DlCellDel */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrDlUeCfg
+S16 rgSCHSc1RgrDlUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrDlUeCfg(cell, ue, ueCfg, err)
+S16 rgSCHSc1RgrDlUeCfg(cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
Inst inst = cell->instIdx;
RgSchSc1DlUe *ueDl;
- TRC2(rgSCHSc1RgrDlUeCfg);
if((rgSCHUtlAllocSBuf(inst,
(Data**)&(ueSchCmn->dl.schSpfc), (sizeof(RgSchSc1DlUe))) != ROK))
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Memory allocation FAILED"
"CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_SC1_DL_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
ueDl = (RgSchSc1DlUe *)ueSchCmn->dl.schSpfc;
if (ue->dl.ambrCfgd)
cmLListInit(&ueDl->ambrLst);
cmLListInit(&ueDl->schdSvcs);
cmLListInit(&ueDl->retxHqProcs);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrDlUeCfg */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1DlUeHqEntInit
+S16 rgSCHSc1DlUeHqEntInit
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqEnt
)
#else
-PUBLIC S16 rgSCHSc1DlUeHqEntInit(cell, hqEnt)
+S16 rgSCHSc1DlUeHqEntInit(cell, hqEnt)
RgSchCellCb *cell;
RgSchDlHqEnt *hqEnt
#endif
{
RgSchSc1DlHqProc *hqSpcSch;
RgSchDlHqProcCb *hqP;
- U8 cnt;
- TRC2(rgSCHSc1DlUeHqEntInit);
+ uint8_t cnt;
/* making use of hqE->sch for one shot allocation
* of RgSchSc1DlHqProc structures */
if (rgSCHUtlAllocSBuf(cell->instIdx,
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED CRNTI:%d",hqEnt->ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqSpcSch = (RgSchSc1DlHqProc *)(hqEnt->sch);
for(cnt = 0; cnt < hqEnt->numHqPrcs; cnt++)
((RgSchCmnDlHqProc *)((hqP)->sch))->schSpfc = \
hqSpcSch++;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1DlUeHqEntDeInit
+S16 rgSCHSc1DlUeHqEntDeInit
(
RgSchCellCb *cell,
RgSchDlHqEnt *hqE
)
#else
-PUBLIC S16 rgSCHSc1DlUeHqEntDeInit(cell, hqE)
+S16 rgSCHSc1DlUeHqEntDeInit(cell, hqE)
RgSchCellCb *cell;
RgSchDlHqEnt *hqE;
#endif
{
- TRC2(rgSCHSc1DlUeHqEntDeInit);
if(hqE->sch)
{
}
else
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief UE reconfiguration for scheduler
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrDlUeRecfg
+S16 rgSCHSc1RgrDlUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrDlUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHSc1RgrDlUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
RgSchCmnDlUe *ueCmnDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
/*cell added as part of CA dev*/
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
- TRC2(rgSCHSc1RgrDlUeRecfg);
if (ue->dl.ambrCfgd)
{
RgSchDlHqProcCb *hqP;
Pst pst;
RgInfRlsHqInfo *rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
- U8 i;
+ uint8_t i;
/* Prepare TB2 release information to be sent to MAC */
rlsHqBufs->numUes = 0;
RgSchMacRlsHq (&pst, rlsHqBufs);
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrDlUeRecfg */
/**
{
RgSchSc1DlUe *sc1Ue;
RgSchDlLcCb *svc;
- U32 idx;
+ uint32_t idx;
- TRC2(rgSCHSc1DlRmvUeFrmPrioQs);
sc1Ue = RG_GET_SC1_UE_DL(ue, cell);
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
}
- RETVOID;
+ return;
} /* rgSCHSc1DlRmvUeFrmPrioQs */
/**
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
RgSchDlHqProcCb *hqP;
RgSchCmnDlHqProc *hqProcDl;
- U8 i;
+ uint8_t i;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
- TRC2(rgSCHSc1DlInactvtUe);
/* ccpu00130170: UE related HARQ Procs are cleared only
if UE's Re-establishment procedure is not in progress*/
rgSCHSc1DlRmvUeFrmPrioQs(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1DlInactvtUe */
#endif
{
RgSchDlHqProcCb *hqP;
- U8 i;
- U8 j;
+ uint8_t i;
+ uint8_t j;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
- TRC2(rgSCHSc1DlSuspendUe);
/* remove all in use HARQ processes from the subframes.
* Store them in UEs hqProc Lst. Add back to cell's
}
rgSCHSc1DlRmvUeFrmPrioQs(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1DlSuspendUe */
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlScanUpdPdbPrio
+Void rgSCHSc1DlScanUpdPdbPrio
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1DlScanUpdPdbPrio (cell)
+Void rgSCHSc1DlScanUpdPdbPrio (cell)
RgSchCellCb *cell;
#endif
{
- TRC2(rgSCHSc1DlScanUpdPdbPrio);
- RETVOID;
+ return;
}
/**
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1DlFillFlowCntrlInfo
+S16 rgSCHSc1DlFillFlowCntrlInfo
(
RgSchCellCb *cell,
RgInfSfAlloc *sfAlloc
)
#else
-PUBLIC S16 rgSCHSc1DlFillFlowCntrlInfo(cell,sfAlloc)
+S16 rgSCHSc1DlFillFlowCntrlInfo(cell,sfAlloc)
RgSchCellCb *cell;
RgInfSfAlloc *sfAlloc;
#endif
{
- TRC2(rgSCHSc1DlFillFlowCntrlInfo);
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief UE deletion for scheduler
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlUeDel
+Void rgSCHSc1DlUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1DlUeDel(cell, ue)
+Void rgSCHSc1DlUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
RgSchSc1DlUe *sc1DlUe = RG_GET_SC1_UE_DL(ue, cell);
- TRC2(rgSCHSc1DlUeDel);
if (sc1DlUe == NULLP)
{
- RETVOID;
+ return;
}
if( hqEnt)
{
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data**)(&sc1DlUe), (sizeof(RgSchSc1DlUe)));
- RETVOID;
+ return;
} /* rgSCHSc1DlUeDel */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcCfg
+S16 rgSCHSc1RgrLcCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcCfg(cell, ue, dlLc, lcCfg, err)
+S16 rgSCHSc1RgrLcCfg(cell, ue, dlLc, lcCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
#endif
{
S16 ret;
- TRC2(rgSCHSc1RgrLcCfg);
ret = rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(RG_SCH_CMN_GET_LC_SCH_SPFC(ue,dlLc,cell)), \
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHSc1CrgLcCfg():"
"SCH struct alloc failed CRNTI:%d LCID:%d",ue->ueId,lcCfg->lcId);
err->errCause = RGSCHERR_SCH_SC1_DL_CFG;
- RETVALUE(ret);
+ return (ret);
}
rgSCHSc1DlSvcAdd(cell, ue, dlLc, &lcCfg->dlInfo);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcCfg */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcRecfg
+S16 rgSCHSc1RgrLcRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcRecfg(cell, ue, dlLc, lcRecfg, err)
+S16 rgSCHSc1RgrLcRecfg(cell, ue, dlLc, lcRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrLcRecfg);
UNUSED(err);
rgSCHSc1DlSvcMod(cell,ue,dlLc, lcRecfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcRecfg */
\f
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1DlUeReset);
- RETVALUE(ROK);
+ return ROK;
}
CmLList *node;
RgSchDlHqProcCb *proc;
RgSchUeCb *ue;
- U32 effBo;
+ uint32_t effBo;
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *cmnUeDl;
RgSchSc1DlUe *ueDl;
#ifdef LTEMAC_HDFDD
Bool dlAllowed = FALSE;
#endif
- TRC2(rgSCHSc1DlTaCmd);
lst = &cellCmnDl->taLst;
node = lst->first;
/* 3.1 MIMO moving this call to cmn scheduler */
/*rgSCHCmnDlRbInfoAddUeTx(allocInfo, ue);*/
}
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlHndlInActUes
+Void rgSCHSc1DlHndlInActUes
(
RgSchCellCb *cell,
CmLListCp *inactvLst
)
#else
-PUBLIC Void rgSCHSc1DlHndlInActUes(cell, inactvLst)
+Void rgSCHSc1DlHndlInActUes(cell, inactvLst)
RgSchCellCb *cell;
CmLListCp *inactvLst;
#endif
CmLList *node;
RgSchUeCb *ue;
- TRC2(rgSCHSc1DlHndlInActUes);
node = inactvLst->first;
while(node)
* till it is activated again. */
rgSCHSc1DlInactvtUe(cell, ue);
}
- RETVOID;
+ return;
}
\f
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlInit
+Void rgSCHSc1DlInit
(
RgDlSchdApis *rgSchDlApis
)
#else
-PUBLIC Void rgSCHSc1DlInit(rgSchDlApis)
+Void rgSCHSc1DlInit(rgSchDlApis)
RgDlSchdApis *rgSchDlApis;
#endif
{
- TRC2(rgSCHSc1DlInit);
/* Init the function pointers */
rgSchDlApis->rgSCHRgrDlUeCfg = rgSCHSc1RgrDlUeCfg;
rgSchDlApis->rgSCHRgrDlUeRecfg = rgSCHSc1RgrDlUeRecfg;
rgSchDlApis->rgSCHDlTickForPdbTrkng = rgSCHSc1DlScanUpdPdbPrio;
rgSchDlApis->rgSCHDlFillFlwCtrlInfo = rgSCHSc1DlFillFlowCntrlInfo;
- RETVOID;
+ return;
}
RgSchSc1DlCell *cellDl;
#endif
{
- U8 i;
- TRC2(rgSCHSc1DlInitQueues);
+ uint8_t i;
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
{
cellDl->svcMngFunc[i] = rgSCHSc1DlMngAmbrSvcPosn;
}
- RETVOID;
+ return;
}
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
RgSchDlRbAlloc *dlAllocCb = NULLP;
- TRC2(rgSCHSc1DlRetxAllocFnlz);
node = allocInfo->dedAlloc.schdRetxHqPLst.first;
while(node)
/* reset the UE allocation Information */
rgSCHCmnDlUeResetTemp(ue, hqP);
}
- RETVOID;
+ return;
}
/* 3.1 MIMO Alloc distribution functions being performed
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 *effAlloc,
+uint32_t *effAlloc,
CmLList **node
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U32 *effAlloc;
+uint32_t *effAlloc;
CmLList **node;
#endif
{
RgSchDlLcCb *svc;
RgSchSc1DlSvc *svcSc1;
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
- U32 bytes;
+ uint32_t bytes;
RgSchLchAllocInfo lchSchdData;
- U32 effBo;
- U32 rlcHdrEstmt;
+ uint32_t effBo;
+ uint32_t rlcHdrEstmt;
- TRC2(rgSCHSc1DlSprTxTbDstn);
while((*node) && (*effAlloc > 0))
{
lchSchdData.schdData = bytes;
rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, tbInfo);
}
- RETVOID;
+ return;
}
\f
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 *effAlloc,
+uint32_t *effAlloc,
CmLList **node
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U32 *effAlloc;
+uint32_t *effAlloc;
CmLList **node;
#endif
{
RgSchDlLcCb *svc;
RgSchSc1DlSvc *svcSc1 = NULLP;
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
- U32 bytes;
+ uint32_t bytes;
RgSchLchAllocInfo lchSchdData;
CmLList *prev = NULLP;
- TRC2(rgSCHSc1DlNewTxTbDstn);
if (ueDl->taReqBytes)
{
rgSCHSc1DlSprTxTbDstn(cell, ue, tbInfo, effAlloc,
&ueDl->lcsWithData.first);
*node = NULLP;
- RETVOID;
+ return;
}
/* make sure node points to the svc not completely
* satisfied.
* make sure if not served completely then
* the other TB allocation accomodates the same */
*node = prev;
- RETVOID;
+ return;
}
/*cell added as part of CA dev*/
/* 3.1 MIMO Distribute data of each TB across services */
RgSchDlRbAlloc *dlAllocCb = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
- U32 remTb1Bytes = dlAllocCb->tbInfo[0].bytesAlloc;
- U32 remTb2Bytes = dlAllocCb->tbInfo[1].bytesAlloc;
- U32 effAlloc = 0;
+ uint32_t remTb1Bytes = dlAllocCb->tbInfo[0].bytesAlloc;
+ uint32_t remTb2Bytes = dlAllocCb->tbInfo[1].bytesAlloc;
+ uint32_t effAlloc = 0;
/*ccpu00120365-ADD-added to code to check if second TB is utilized */
- U32 tb2Bytes = 0;
+ uint32_t tb2Bytes = 0;
- TRC2(rgSCHSc1DlNewTxUeFnlz);
/* 3.1 MIMO Consider the allocation of New TX TB for distribution */
rgSCHUtlPdcchPut(cell, &dlAllocCb->dlSf->pdcchInfo,
dlAllocCb->pdcch);
rgSCHSc1RlsHqProc(cmnUeDl->proc);
- RETVOID;
+ return;
}
/* Fill PDCCH and assign it to HqP */
rgSCHCmnFillHqPPdcch(cell, dlAllocCb, cmnUeDl->proc);
- RETVOID;
+ return;
}
\f
RgSchUeCb *ue;
RgSchCmnDlUe *cmnUeDl;
RgSchDlHqProcCb *hqP;
- TRC2(rgSCHSc1DlNewTxAllocFnlz);
node = allocInfo->dedAlloc.schdTxHqPLst.first;
while(node)
cmLListInit(&((RgSchSc1DlUe *)(cmnUeDl->schSpfc))->schdSvcs);
rgSCHCmnDlUeResetTemp(ue, hqP);
}
- RETVOID;
+ return;
}
/* 3.1 Added new function to handle TX+RETX alloc fnlz'n */
RgSchSc1DlUe *sc1DlUe;
RgSchDlHqProcCb *hqP;
RgSchDlHqTbCb *newTxTbInfo;
- U32 effAlloc;
- U32 remTbBytes;
+ uint32_t effAlloc;
+ uint32_t remTbBytes;
RgSchDlRbAlloc *ueAllocInfo;
RgSchDlRbAlloc *dlAllocCb;
- TRC2(rgSCHSc1DlRetxNewTxAllocFnlz);
node = cellAllocInfo->dedAlloc.schdTxRetxHqPLst.first;
while(node)
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlAllocFnlz
+Void rgSCHSc1DlAllocFnlz
(
RgSchCellCb *cell,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHSc1DlAllocFnlz(cell, allocInfo)
+Void rgSCHSc1DlAllocFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHSc1DlAllocFnlz);
rgSCHSc1DlRetxAllocFnlz(cell, allocInfo);
/*3.1 MIMO new Function added to handle TX+RETX
* harq process scheduling finalization */
rgSCHSc1DlRetxNewTxAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlCqiInd
+Void rgSCHSc1DlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Void *dlCqi
)
#else
-PUBLIC Void rgSCHSc1DlCqiInd(cell, ue, isPucchInfo, dlCqi)
+Void rgSCHSc1DlCqiInd(cell, ue, isPucchInfo, dlCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isPucchInfo;
Void *dlCqi;
#endif
{
- TRC2(rgSCHSc1DlCqiInd);
- RETVOID;
+ return;
}
\f
RgSchSc1DlUe *sc1DlUe = RG_GET_SC1_UE_DL(ue, cell);
RgSchCmnDlSvc *cmnDlLstSvc;
- TRC2(rgSCHSc1DlAdd2UeLcsWithData);
lst = &(sc1DlUe->lcsWithData);
node = lst->first;
cmLListInsCrnt(lst, &sc1DlSvc->lcWithDataLnk);
sc1DlSvc->lcWithDataLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
RgSchSc1DlSvc *sc1DlSvc = RG_GET_SC1_SVC_DL(ue,svc,cell);
RgSchSc1DlUe *sc1DlUe = RG_GET_SC1_UE_DL(ue, cell);
- TRC2(rgSCHSc1DlRmFrmUeLcsWithData);
cmLListDelFrm(&(sc1DlUe->lcsWithData), &sc1DlSvc->lcWithDataLnk);
sc1DlSvc->lcWithDataLnk.node = NULLP;
- RETVOID;
+ return;
}
/***************** SC1 DL SCHEDULER FUNCTION DEFNs END HERE ****************/
* @return S16
* -# ROK
**/
-PUBLIC S16 rgSCHSc1UlLchCfg
+S16 rgSCHSc1UlLchCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
{
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief UE Lc Reconfig for RR
* @return S16
* -# ROK
**/
-PUBLIC S16 rgSCHSc1UlLchRecfg
+S16 rgSCHSc1UlLchRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
{
- RETVALUE(ROK);
+ return ROK;
}
/**
* @brief LC deletion for PFS
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1UlLchDel
+S16 rgSCHSc1UlLchDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
)
#else
-PUBLIC S16 rgSCHRrUlLchDel(cell, ue, lcId, lcgId)
+S16 rgSCHRrUlLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
-U8 lcgId;
+uint8_t lcgId;
#endif
{
- RETVALUE (ROK);
+ return (ROK);
}
\f
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlInit
+Void rgSCHSc1UlInit
(
RgUlSchdApis *rgSchUlApis
)
#else
-PUBLIC Void rgSCHSc1UlInit(rgSchUlApis)
+Void rgSCHSc1UlInit(rgSchUlApis)
RgUlSchdApis *rgSchUlApis;
#endif
{
- TRC2(rgSCHSc1UlInit);
/* Init the function pointers */
rgSchUlApis->rgSCHRgrUlUeCfg = rgSCHSc1RgrUlUeCfg;
rgSchUlApis->rgSCHRgrUlUeRecfg = rgSCHSc1RgrUlUeRecfg;
rgSchUlApis->rgSCHUlActvtUe = rgSCHSc1UlActvtUe;
rgSchUlApis->rgSCHUlUeReset = rgSCHSc1UlUeReset;
rgSchUlApis->rgSCHRgrUlLcgUpd = rgSCHSc1UlLcgUpd;
- RETVOID;
+ return;
}
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlUeCfg
+S16 rgSCHSc1RgrUlUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlUeCfg(cell, ue, ueCfg, err)
+S16 rgSCHSc1RgrUlUeCfg(cell, ue, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeCfg *ueCfg;
{
RgSchCmnUe *ueSchCmn = RG_SCH_CMN_GET_UE(ue, cell);
- TRC2(rgSCHSc1RgrUlUeCfg);
if(rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(ueSchCmn->ul.schSpfc), (sizeof(RgSchSc1UlUe))) != ROK)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED CRNTI:%d",ue->ueId);
err->errCause = RGSCHERR_SCH_SC1_UL_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrUlUeCfg */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlUeRecfg
+S16 rgSCHSc1RgrUlUeRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlUeRecfg(cell, ue, ueRecfg, err)
+S16 rgSCHSc1RgrUlUeRecfg(cell, ue, ueRecfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrUlUeRecfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrUeRecfg */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlUeDel
+Void rgSCHSc1UlUeDel
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlUeDel(cell, ue)
+Void rgSCHSc1UlUeDel(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
RgSchSc1UlUe *ueUl = RG_GET_SC1_UE_UL(ue, cell);
- TRC2(rgSCHSc1UlUeDel);
if (ueUl == NULLP)
{
- RETVOID;
+ return;
}
if(ueUl->txLnk.node)
{
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(ueUl)), (sizeof(RgSchSc1UlUe)));
- RETVOID;
+ return;
} /* rgSCHSc1UlUeDel */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlUeReset
+Void rgSCHSc1UlUeReset
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlUeReset(cell, ue)
+Void rgSCHSc1UlUeReset(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
RgSchSc1UlUe *ueUl = RG_GET_SC1_UE_UL(ue, cell);
- TRC2(rgSCHSc1UlUeReset);
ueUl->srRcvd = FALSE;
cmLListDelFrm(&(cellUl->contResLst), &(ueUl->contResLnk));
ueUl->contResLnk.node = NULLP;
}
- RETVOID;
+ return;
} /* rgSCHSc1UlUeReset */
\f
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlCellCfg
+S16 rgSCHSc1RgrUlCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlCellCfg(cell, cellCfg, err)
+S16 rgSCHSc1RgrUlCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
{
RgSchSc1UlCell *cellUl;
- TRC2(rgSCHSc1RgrUlCellCfg);
if((rgSCHUtlAllocSBuf(cell->instIdx,
(Data**)&(((RgSchCmnCell*)((cell)->sc.sch))->ul.schSpfc), \
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,
"Memory allocation FAILED");
err->errCause = RGSCHERR_SCH_SC1_UL_CFG;
- RETVALUE(RFAILED);
+ return RFAILED;
}
cellUl = RG_GET_SC1_CELL_UL(cell);
cmLListInit(&cellUl->contResLst);
cmLListInit(&cellUl->ueTxLst[0]);
cmLListInit(&cellUl->ueTxLst[1]);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrUlCellCfg */
\f
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrUlCellRecfg
+S16 rgSCHSc1RgrUlCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *recfg,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrUlCellRecfg(cell, recfg, err)
+S16 rgSCHSc1RgrUlCellRecfg(cell, recfg, err)
RgSchCellCb *cell;
RgrCellRecfg *recfg;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrUlCellRecfg);
- RETVALUE(ROK);
+ return ROK;
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlCellDel
+Void rgSCHSc1UlCellDel
(
RgSchCellCb *cell
)
#else
-PUBLIC Void rgSCHSc1UlCellDel(cell)
+Void rgSCHSc1UlCellDel(cell)
RgSchCellCb *cell;
#endif
{
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1UlCellDel);
if (cellUl == NULLP)
{
- RETVOID;
+ return;
}
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(cellUl)), (sizeof(RgSchSc1UlCell)));
- RETVOID;
+ return;
} /* rgSCHSc1UlCellDel */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcgCfg
+S16 rgSCHSc1RgrLcgCfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcgCfg(cell, ue, lcg, lcgCfg, err)
+S16 rgSCHSc1RgrLcgCfg(cell, ue, lcg, lcgCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrLcgCfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcgCfg */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1RgrLcgRecfg
+S16 rgSCHSc1RgrLcgRecfg
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHSc1RgrLcgRecfg(cell, ue, lcg, reCfg, err)
+S16 rgSCHSc1RgrLcgRecfg(cell, ue, lcg, reCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHSc1RgrLcgRecfg);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHSc1RgrLcgRecfg */
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1LcgDel
+Void rgSCHSc1LcgDel
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg
)
#else
-PUBLIC Void rgSCHSc1LcgDel(cell, ue, lcg)
+Void rgSCHSc1LcgDel(cell, ue, lcg)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
#endif
{
- TRC2(rgSCHSc1LcgDel);
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
/*cell added as part of CA dev*/
RgSchSc1UlUe *ulUe = RG_GET_SC1_UE_UL(ue, cell);
- TRC2(rgSCHSc1UlSchdUe);
if(ulUe->srRcvd == TRUE)
{
cmnUlUe->alloc.reqBytes = RGSCH_MAX(RG_SCH_CMN_UL_SR_BYTES, \
ue->ul.effBsr);
- RETVOID;
+ return;
}
cmnUlUe->alloc.reqBytes = ue->ul.effBsr;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[out] RgSchCmnUlRbAllocInfo *allocInfo
- * @param[in] U8 remUe
+ * @param[in] uint8_t remUe
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 remUe
+uint8_t remUe
)
#else
PRIVATE Void rgSCHSc1UlSchdForDataTrans(cell, allocInfo, remUe)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
-U8 remUe;
+uint8_t remUe;
#endif
{
RgSchSc1UlCell *sc1UlCell = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1UlSchdForDataTrans);
if (remUe == 0)
{
- RETVOID;
+ return;
}
/* Allocate UEs with LCG0 data pending */
rgSCHSc1UlSchdUeTxLst(cell, &sc1UlCell->ueTxLst[0], allocInfo, &remUe);
if (remUe == 0)
{
- RETVOID;
+ return;
}
/* Allocate UEs with other LCGs data pending */
rgSCHSc1UlSchdUeTxLst(cell, &sc1UlCell->ueTxLst[1], allocInfo, &remUe);
- RETVOID;
+ return;
}
/**
*
* @param[in] CmLListCp *ueTxLst
* @param[out] RgSchCmnUlRbAllocInfo *allocInfo
- * @param[in] U8 *remUe
+ * @param[in] uint8_t *remUe
* @return Void
**/
#ifdef ANSI
RgSchCellCb *cell,
CmLListCp *ueTxLst,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 *remUe
+uint8_t *remUe
)
#else
PRIVATE Void rgSCHSc1UlSchdUeTxLst(cell, ueTxLst, allocInfo, remUe)
RgSchCellCb *cell;
CmLListCp *ueTxLst;
RgSchCmnUlRbAllocInfo *allocInfo;
-U8 *remUe;
+uint8_t *remUe;
#endif
{
RgSchUeCb *ue;
Bool ulAllowed = FALSE;
#endif
- TRC2(rgSCHSc1UlSchdUeTxLst);
node = ueTxLst->first;
while ((node) && (*remUe))
--(*remUe);
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[out] RgSchCmnUlRbAllocInfo *allocInfo
- * @param[out] U8 *remUe
+ * @param[out] uint8_t *remUe
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 *remUe
+uint8_t *remUe
)
#else
PRIVATE Void rgSCHSc1UlSchdForContRes(cell, allocInfo, remUe)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
-U8 *remUe;
+uint8_t *remUe;
#endif
{
RgSchSc1UlCell *sc1UlCell = RG_GET_SC1_CELL_UL(cell);
Bool ulAllowed = FALSE;
#endif
- TRC2(rgSCHSc1UlSchdForContRes);
node = sc1UlCell->contResLst.first;
while ((node) && (*remUe))
/* Node removal deferred to ULAllocFinalization */
}
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 remUe = cellUl->maxUeNewTxPerTti;
+ uint8_t remUe = cellUl->maxUeNewTxPerTti;
- TRC2(rgSCHSc1UlNewTx);
rgSCHSc1UlSchdForContRes(cell, allocInfo, &remUe);
rgSCHSc1UlSchdForDataTrans(cell, allocInfo, remUe);
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlSched
+Void rgSCHSc1UlSched
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHSc1UlSched(cell, allocInfo)
+Void rgSCHSc1UlSched(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHSc1UlSched);
rgSCHSc1UlNewTx(cell, allocInfo);
- RETVOID;
+ return;
}
/**
RgSchUeCb *lUe;
CmLList *node;
- TRC2(rgSCHSc1UlInsUeInQ);
node = lst->first;
while(node)
ueUl->txLnk.node = (PTR)ue;
}
- RETVOID;
+ return;
}
/**
* @brief UEs Buffer Status Has changed so reposition it.
RgSchCmnLcg *cmnLcg0 = RG_SCH_CMN_GET_UL_LCG(&ue->ul.lcgArr[0]);
CmLListCp *lst;
- TRC2(rgSCHSc1UlPosnUeInQ);
if (!RG_SCH_CMN_UL_IS_UE_ACTIVE(ue))
{
- RETVOID;
+ return;
}
/* Remove the UE from its existing position */
}
#endif
- RETVOID;
+ return;
}
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *lcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UpdBsrShort
+Void rgSCHSc1UpdBsrShort
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
)
#else
-PUBLIC Void rgSCHSc1UpdBsrShort(cell, ue, lcg, bsr)
+Void rgSCHSc1UpdBsrShort(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
-U8 bsr;
+uint8_t bsr;
#endif
{
- TRC2(rgSCHSc1UpdBsrShort);
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1UpdBsrShort */
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *lcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UpdBsrTrunc
+Void rgSCHSc1UpdBsrTrunc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
)
#else
-PUBLIC Void rgSCHSc1UpdBsrTrunc(cell, ue, lcg, bsr)
+Void rgSCHSc1UpdBsrTrunc(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
-U8 bsr;
+uint8_t bsr;
#endif
{
- TRC2(rgSCHSc1UpdBsrTrunc);
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1UpdBsrTrunc */
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 bsArr[]
+ * @param[in] uint8_t bsArr[]
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UpdBsrLong
+Void rgSCHSc1UpdBsrLong
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *bsArr
+uint8_t *bsArr
)
#else
-PUBLIC Void rgSCHSc1UpdBsrLong(cell, ue, bsArr)
+Void rgSCHSc1UpdBsrLong(cell, ue, bsArr)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 *bsArr;
+uint8_t *bsArr;
#endif
{
- TRC2(rgSCHSc1UpdBsrLong);
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1UpdBsrLong */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1ContResUlGrant
+Void rgSCHSc1ContResUlGrant
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1ContResUlGrant(cell, ue)
+Void rgSCHSc1ContResUlGrant(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchSc1UlUe *ueUl = RG_GET_SC1_UE_UL(ue, cell);
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1ContResUlGrant);
if (ueUl->contResLnk.node)
{
- RETVOID;
+ return;
}
/* Remove the UE from other Qs */
cmLListAdd2Tail(&cellUl->contResLst, &ueUl->contResLnk);
ueUl->contResLnk.node = (PTR)ue;
- RETVOID;
+ return;
} /* rgSCHSc1ContResUlGrant */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1SrRcvd
+Void rgSCHSc1SrRcvd
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1SrRcvd(cell, ue)
+Void rgSCHSc1SrRcvd(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchSc1UlUe *ulUe = RG_GET_SC1_UE_UL(ue, cell);
RgSchSc1UlCell *ulCell = RG_GET_SC1_CELL_UL(cell);
- TRC2(rgSCHSc1SrRcvd);
ulUe->srRcvd = TRUE;
if (ulUe->qId == 0)
{
/* Already present in lcg0 Q */
- RETVOID;
+ return;
}
cmLListDelFrm(&(ulCell->ueTxLst[ulUe->qId]), &(ulUe->txLnk));
}
ulUe->txLnk.node = (PTR)ue;
ulUe->qId = 0;
- RETVOID;
+ return;
} /* rgSCHSc1SrRcvd */
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlCqiInd
+Void rgSCHSc1UlCqiInd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo
)
#else
-PUBLIC Void rgSCHSc1UlCqiInd(cell, ue, ulCqiInfo)
+Void rgSCHSc1UlCqiInd(cell, ue, ulCqiInfo)
RgSchCellCb *cell;
RgSchUeCb *ue;
TfuUlCqiRpt *ulCqiInfo;
#endif
{
- TRC2(rgSCHSc1UlCqiInd);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
* @return S16
**/
#ifdef ANSI
-PUBLIC S16 rgSCHSc1UlLcgUpd
+S16 rgSCHSc1UlLcgUpd
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgInfUeDatInd *datInd
)
#else
-PUBLIC S16 rgSCHSc1UlLcgUpd(cell, ue)
+S16 rgSCHSc1UlLcgUpd(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgInfUeDatInd *datInd;
#endif
{
- TRC2(rgSCHSc1UlLcgUpd);
- RETVALUE(ROK);
+ return ROK;
}
\f
*
**********************************************************/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlUeRefresh
+Void rgSCHSc1UlUeRefresh
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlUeRefresh(cell, ue)
+Void rgSCHSc1UlUeRefresh(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHSc1UlUeRefresh);
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
CmLList *node;
RgSchDrxUeCb *drxUe = NULLP;
CmLListCp ulInactvLst; /* list of UE's becoming UL-inactive */
- TRC2(rgSCHSc1UlDatTransAllocFnlz);
cmLListInit(&ulInactvLst);
node = allocInfo->schdUeLst.first;
rgSCHCmnUlUeResetTemp(cell, ue);
}
- RETVOID;
+ return;
}
/**
RgSchSc1UlUe *ueUl;
RgSchUeCb *ue;
CmLList *node;
- TRC2(rgSCHSc1UlContResAllocFnlz);
node = allocInfo->schdContResLst.first;
while(node)
rgSCHCmnUlUeResetTemp(cell, ue);
}
- RETVOID;
+ return;
}
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlAllocFnlz
+Void rgSCHSc1UlAllocFnlz
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo
)
#else
-PUBLIC Void rgSCHSc1UlAllocFnlz(cell, allocInfo)
+Void rgSCHSc1UlAllocFnlz(cell, allocInfo)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
#endif
{
- TRC2(rgSCHSc1UlAllocFnlz);
rgSCHSc1UlContResAllocFnlz(cell, allocInfo);
rgSCHSc1UlDatTransAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
\f
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlActvtUe
+Void rgSCHSc1UlActvtUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PUBLIC Void rgSCHSc1UlActvtUe(cell, ue)
+Void rgSCHSc1UlActvtUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
- TRC2(rgSCHSc1UlActvtUe);
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
* @return Void
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1UlHndlInActUes
+Void rgSCHSc1UlHndlInActUes
(
RgSchCellCb *cell,
CmLListCp *inactvLst
)
#else
-PUBLIC Void rgSCHSc1UlHndlInActUes(cell, inactvLst)
+Void rgSCHSc1UlHndlInActUes(cell, inactvLst)
RgSchCellCb *cell;
CmLListCp *inactvLst;
#endif
RgSchSc1UlCell *cellUl = RG_GET_SC1_CELL_UL(cell);
CmLList *node = inactvLst->first;
- TRC2(rgSCHSc1UlHndlInActUes);
while (node)
{
}
/* Do not remove UE from contResLst */
}
- RETVOID;
+ return;
}
/**
* @brief Scheduler invocation
**/
#ifdef ANSI
-PUBLIC Void rgSCHSc1DlProcRmvFrmRetx(
+Void rgSCHSc1DlProcRmvFrmRetx(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHSc1DlProcRmvFrmRetx(cell, ue, hqP)
+Void rgSCHSc1DlProcRmvFrmRetx(cell, ue, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHSc1DlProcRmvFrmRetx);
+
/* Remove the HqP from retx Queue.
Release HqP.*/
rgSCHSc1DlProcRmvFrmCellRetx(cell, hqP);
rgSCHSc1DlProcRmvFrmUeRetx(cell, ue, hqP);
- RETVOID;
+ return;
}
Code Review / o-du / l2.git / blobdiff