RgSchCellCb *cell,
CmLListCp *ueTxLst,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 *remUe
+uint8_t *remUe
));
PRIVATE Void rgSCHSc1DlProcRmvFrmRetx ARGS((
RgSchCellCb *cell,
rgSCHSc1DlSuspendUe(cell, ue);
- RETVOID;
+ return;
}
\f
CmLList *node;
RgSchDlHqProcCb *hqP;
RgSchDlLcCb *svc;
- U8 idx;
+ uint8_t idx;
/* Add UE's HqProcs From UERetxLst to CellRetxLst */
lst = &ueDl->retxHqProcs;
rgSCHSc1DlUeAddToSchd(cell, ue);
}
- RETVOID;
+ return;
}
\f
/* Update the SVC's positioning in the Queue */
rgSCHSc1DlMngGbrSvcPosn(cell, ue, svc);
}
- RETVOID;
+ return;
}
\f
(hqProcDl->schSpfc))->prio], &(hqProcDl->retxLnk));
hqProcDl->retxLnk.node = NULLP;
}
- RETVOID;
+ return;
}
\f
&(hqProcDl->retxLnkUe));
hqProcDl->retxLnkUe.node = NULLP;
}
- RETVOID;
+ return;
}
\f
cmLListAdd2Tail(&sc1Ue->retxHqProcs,
&(cmnHqDl->retxLnkUe));
cmnHqDl->retxLnkUe.node = (PTR)hqP;
- RETVOID;
+ return;
}
\f
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;
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;
}
/***********************************************************
#endif
{
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;
/* 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);
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;
}
/**
#endif
{
- RETVOID;
+ return;
}
/**
* @brief scheduling for a cell
#endif
{
- RETVOID;
+ return;
}
\f
rgSCHSc1DlDedTx(cell, subFrm, allocInfo);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
/**
rgSCHSc1DlRetxAlloc(cell, subFrm, allocInfo);
- RETVOID;
+ return;
}
/* 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;
}
* then remove the same from UE's lcsWithData List */
rgSCHSc1DlRmFrmUeLcsWithData(cell, ue, ueDl->ambrSvc);
}
- RETVOID;
+ return;
}
\f
cmLListDelFrm(lst, &svcSc1->prioLnk);
svcSc1->prioLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
\f
/* 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
* then remove the same from UE's lcsWithData List */
rgSCHSc1DlRmFrmUeLcsWithData(cell, svc->ue, svc);
}
- RETVOID;
+ return;
}
\f
cmLListAdd2Tail(&ueDl->gbrSvcs, &svcSc1->gbrLnk);
svcSc1->gbrLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
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;
}
/**
svcSc1->gbr = svcCmn->gbr;
svcSc1->mbr = svcCmn->mbr;
}
- RETVOID;
+ return;
}
/**
/* 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
rgSCHSc1DlUeRmvFrmSchd(cell, ue);
}
}
- RETVOID;
+ return;
}
rgSCHSc1DlSvcAddToUeAmbrLst(cell, ue, svc);
/* Current ambr svc is always the first node of ambrLst.*/
}
}
}
- RETVOID;
+ return;
}
\f
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;
}
{
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
}
- RETVOID;
+ return;
}
\f
/* Adjust the SVC priority within the queue */
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
rgSCHSc1DlSvcAddToSchd(cell, svc);
- RETVOID;
+ return;
}
\f
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
(cellDl->svcMngFunc[svcCmn->prio])(cell, ue, svc);
- RETVOID;
+ return;
}
/*--------------------------*
RgSchSc1DlCell *cellDl;
#endif
{
- U8 i;
+ uint8_t i;
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
cmLListInit(&cellDl->prioLst[i]);
cmLListInit(&cellDl->retxLst[i]);
}
- RETVOID;
+ return;
}
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 */
/**
{
RgSchSc1DlHqProc *hqSpcSch;
RgSchDlHqProcCb *hqP;
- U8 cnt;
+ uint8_t cnt;
/* making use of hqE->sch for one shot allocation
* of RgSchSc1DlHqProc structures */
if (rgSCHUtlAllocSBuf(cell->instIdx,
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;
{
RgSchSc1DlUe *sc1Ue;
RgSchDlLcCb *svc;
- U32 idx;
+ uint32_t idx;
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);
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);
}
rgSCHSc1DlRmvUeFrmPrioQs(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1DlSuspendUe */
/***********************************************************
#endif
{
- RETVOID;
+ return;
}
/**
if (sc1DlUe == NULLP)
{
- RETVOID;
+ return;
}
if( hqEnt)
{
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data**)(&sc1DlUe), (sizeof(RgSchSc1DlUe)));
- RETVOID;
+ return;
} /* rgSCHSc1DlUeDel */
/**
CmLList *node;
RgSchDlHqProcCb *proc;
RgSchUeCb *ue;
- U32 effBo;
+ uint32_t effBo;
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *cmnUeDl;
RgSchSc1DlUe *ueDl;
/* 3.1 MIMO moving this call to cmn scheduler */
/*rgSCHCmnDlRbInfoAddUeTx(allocInfo, ue);*/
}
- RETVOID;
+ return;
}
/**
* till it is activated again. */
rgSCHSc1DlInactvtUe(cell, ue);
}
- RETVOID;
+ return;
}
\f
/**
rgSchDlApis->rgSCHDlTickForPdbTrkng = rgSCHSc1DlScanUpdPdbPrio;
rgSchDlApis->rgSCHDlFillFlwCtrlInfo = rgSCHSc1DlFillFlowCntrlInfo;
- RETVOID;
+ return;
}
RgSchSc1DlCell *cellDl;
#endif
{
- U8 i;
+ uint8_t i;
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
{
cellDl->svcMngFunc[i] = rgSCHSc1DlMngAmbrSvcPosn;
}
- RETVOID;
+ return;
}
/* 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;
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;
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;
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
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;
/*3.1 MIMO new Function added to handle TX+RETX
* harq process scheduling finalization */
rgSCHSc1DlRetxNewTxAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
Void *dlCqi;
#endif
{
- RETVOID;
+ return;
}
\f
cmLListInsCrnt(lst, &sc1DlSvc->lcWithDataLnk);
sc1DlSvc->lcWithDataLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
cmLListDelFrm(&(sc1DlUe->lcsWithData), &sc1DlSvc->lcWithDataLnk);
sc1DlSvc->lcWithDataLnk.node = NULLP;
- RETVOID;
+ return;
}
/***************** SC1 DL SCHEDULER FUNCTION DEFNs END HERE ****************/
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
)
#else
S16 rgSCHRrUlLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
-U8 lcgId;
+uint8_t lcgId;
#endif
{
return (ROK);
rgSchUlApis->rgSCHUlActvtUe = rgSCHSc1UlActvtUe;
rgSchUlApis->rgSCHUlUeReset = rgSCHSc1UlUeReset;
rgSchUlApis->rgSCHRgrUlLcgUpd = rgSCHSc1UlLcgUpd;
- RETVOID;
+ return;
}
/**
if (ueUl == NULLP)
{
- RETVOID;
+ return;
}
if(ueUl->txLnk.node)
{
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(ueUl)), (sizeof(RgSchSc1UlUe)));
- RETVOID;
+ return;
} /* rgSCHSc1UlUeDel */
/**
cmLListDelFrm(&(cellUl->contResLst), &(ueUl->contResLnk));
ueUl->contResLnk.node = NULLP;
}
- RETVOID;
+ return;
} /* rgSCHSc1UlUeReset */
\f
if (cellUl == NULLP)
{
- RETVOID;
+ return;
}
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(cellUl)), (sizeof(RgSchSc1UlCell)));
- RETVOID;
+ return;
} /* rgSCHSc1UlCellDel */
/**
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
{
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);
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;
--(*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);
/* 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;
rgSCHSc1UlSchdForContRes(cell, allocInfo, &remUe);
rgSCHSc1UlSchdForDataTrans(cell, allocInfo, remUe);
- RETVOID;
+ return;
}
/**
#endif
{
rgSCHSc1UlNewTx(cell, allocInfo);
- RETVOID;
+ return;
}
/**
ueUl->txLnk.node = (PTR)ue;
}
- RETVOID;
+ return;
}
/**
* @brief UEs Buffer Status Has changed so reposition it.
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
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
)
#else
Void rgSCHSc1UpdBsrShort(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
-U8 bsr;
+uint8_t bsr;
#endif
{
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
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
)
#else
Void rgSCHSc1UpdBsrTrunc(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
-U8 bsr;
+uint8_t bsr;
#endif
{
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
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *bsArr
+uint8_t *bsArr
)
#else
Void rgSCHSc1UpdBsrLong(cell, ue, bsArr)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 *bsArr;
+uint8_t *bsArr;
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1UpdBsrLong */
/**
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 */
/**
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 */
/**
{
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
rgSCHCmnUlUeResetTemp(cell, ue);
}
- RETVOID;
+ return;
}
/**
rgSCHCmnUlUeResetTemp(cell, ue);
}
- RETVOID;
+ return;
}
/**
rgSCHSc1UlContResAllocFnlz(cell, allocInfo);
rgSCHSc1UlDatTransAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
\f
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
}
/* Do not remove UE from contResLst */
}
- RETVOID;
+ return;
}
/**
* @brief Scheduler invocation
Release HqP.*/
rgSCHSc1DlProcRmvFrmCellRetx(cell, hqP);
rgSCHSc1DlProcRmvFrmUeRetx(cell, ue, hqP);
- RETVOID;
+ return;
}
Code Review / o-du / l2.git / blobdiff