static int RLOG_MODULE_ID=4096;
/* 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 "cm5.h" /* common timers */
-#include "cm_hash.h" /* common hash list */
-#include "cm_mblk.h" /* common memory link list library */
-#include "cm_llist.h" /* common linked list library */
-#include "cm_err.h" /* common error */
-#include "cm_lte.h" /* common LTE */
+#include "common_def.h"
#include "lrg.h"
#include "rgr.h"
#include "rgm.h"
#include "rl_common.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer */
-#include "ssi.x" /* system service interface */
-#include "cm5.x" /* common timers */
-#include "cm_lib.x" /* common library */
-#include "cm_hash.x" /* common hash list */
-#include "cm_llist.x" /* common linked list library */
-#include "cm_mblk.x" /* memory management */
-#include "cm_tkns.x" /* common tokens */
-#include "cm_lte.x" /* common LTE */
#include "lrg.x"
#include "rgr.x"
#include "rgm.x"
#include "rg_sch_cmn.x"
#ifdef RGSCH_SPS_STATS
-extern U32 rgNumSPSSchedDropMaxRetx;
-extern U32 rgNumActDtx;
+extern uint32_t rgNumSPSSchedDropMaxRetx;
+extern uint32_t rgNumActDtx;
#endif
-PUBLIC U32 nackSf[10];
+uint32_t nackSf[10];
#ifdef MAC_SCH_STATS
-PUBLIC RgSchNackAckStats hqFailStats;
-PUBLIC RgSchHqRetxStats hqRetxStats;
+RgSchNackAckStats hqFailStats;
+RgSchHqRetxStats hqRetxStats;
#endif /* MAC_SCH_STATS */
//Chandan Stats Collection
#ifdef DLHQ_STATS
-U32 statsCnt;
+uint32_t statsCnt;
RgSchDlHqStats dlHqStats[10000] = {{0,0,0}};
#endif
* The below table is based on Table 7.3-X from 36.213 and
* table 79 from FAPIv1.1 doc
*/
-U8 rgSchNumOfAcksToAckNack[RG_SCH_MAX_NUM_EXPECTED_ACKS][RG_SCH_NUM_FDBK_VALUE] = {
+uint8_t rgSchNumOfAcksToAckNack[RG_SCH_MAX_NUM_EXPECTED_ACKS][RG_SCH_NUM_FDBK_VALUE] = {
{TFU_HQFDB_ACK, TFU_HQFDB_NACK, TFU_HQFDB_NACK},
{TFU_HQFDB_NACK, TFU_HQFDB_ACK, TFU_HQFDB_NACK},
{TFU_HQFDB_NACK, TFU_HQFDB_NACK, TFU_HQFDB_ACK},
/* local externs */
-PRIVATE Void rgSCHDhmFdbkIndHndlTa ARGS((RgSchDlHqProcCb *hqP, U8 tbIdx, U8 fdbk,
+PRIVATE Void rgSCHDhmFdbkIndHndlTa ARGS((RgSchDlHqProcCb *hqP, uint8_t tbIdx, uint8_t fdbk,
Bool maxHqRetxReached));
-PUBLIC void rgEmtcsetNullSubFrm ARGS((RgSchDlHqProcCb *hqP));
+void rgEmtcsetNullSubFrm ARGS((RgSchDlHqProcCb *hqP));
#ifndef LTE_TDD
PRIVATE S16 rgSCHDhmProcHqFdbkAckNackRep ARGS((
RgSchDlHqProcCb *hqP,
RgSchDlSf *sf,
-U8 tbCnt,
-U8 *isAck
+uint8_t tbCnt,
+uint8_t *isAck
));
#endif
#ifdef DL_LA
PRIVATE S16 rgSCHDhmUpdateAckNackHistory ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
- U8 hqfdbk,
- U8 tbCnt
+ uint8_t hqfdbk,
+ uint8_t tbCnt
));
#endif
#ifdef LTE_TDD
PRIVATE Void rgSCHDhmPrcSplBundlFdbk ARGS((
RgSchCellCb *cell,
TfuHqInfo *fdbk,
- U8 hqCnt
+ uint8_t hqCnt
));
#ifdef LTE_ADV
PRIVATE Void rgSchGetHqFdbkPosForM1 ARGS((
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo
));
PRIVATE Void rgSchGetHqFdbkPosForM234 ARGS((
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo,
- U8 M,
+ uint8_t M,
CmLteTimingInfo timeInfo
));
#endif/*LTE_ADV*/
/* Freeing up the HARQ proc blocked for
* indefinite time in case of Retx */
-PUBLIC S16 rgSCHDhmDlRetxAllocFail ARGS((
+S16 rgSCHDhmDlRetxAllocFail ARGS((
RgSchUeCb *ue,
RgSchDlHqProcCb *proc
));
#endif
#ifdef CA_DBG
-extern U32 gPCellTb1AckCount,gPCellTb2AckCount,gPCellTb1NackCount,gPCellTb2NackCount;
-extern U32 gSCellSchedCount,gPrimarySchedCount;
-extern U32 gSCellTb1AckCount,gSCellTb2AckCount,gSCellTb1NackCount,gSCellTb2NackCount;
-extern U32 gPCellTb1DtxCount, gPCellTb2DtxCount, gSCellTb1DtxCount, gSCellTb2DtxCount;
-extern U32 gHqFdbkCount;
+extern uint32_t gPCellTb1AckCount,gPCellTb2AckCount,gPCellTb1NackCount,gPCellTb2NackCount;
+extern uint32_t gSCellSchedCount,gPrimarySchedCount;
+extern uint32_t gSCellTb1AckCount,gSCellTb2AckCount,gSCellTb1NackCount,gSCellTb2NackCount;
+extern uint32_t gPCellTb1DtxCount, gPCellTb2DtxCount, gSCellTb1DtxCount, gSCellTb2DtxCount;
+extern uint32_t gHqFdbkCount;
#endif
#ifdef EMTC_ENABLE
(
RgSchEmtcDlSf *subFrm,
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
+uint8_t tbIdx,
Bool isRepeting
);
EXTERN RgSchEmtcDlSf* rgSCHEmtcUtlSubFrmGet
**/
/*MS_WORKAROUND for ccpu00122893*/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqEntReset
+Void rgSCHDhmHqEntReset
(
RgSchDlHqEnt *hqE
)
#else
-PUBLIC Void rgSCHDhmHqEntReset(hqE)
+Void rgSCHDhmHqEntReset(hqE)
RgSchDlHqEnt *hqE;
#endif
{
RgSchDlHqProcCb *hqP;
- U8 i;
- TRC2(rgSCHDhmHqEntReset)
+ uint8_t i;
cmLListInit(&hqE->inUse);
cmLListInit(&hqE->free);
for (i=0; i < hqE->numHqPrcs; i++)
rgSCHLaaResetDlHqProcCb(hqP);
#endif
}
- RETVOID;
+ return;
} /* rgSCHDhmHqEntReset */
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmAssgnUeHqEntFrmRaCb
+Void rgSCHDhmAssgnUeHqEntFrmRaCb
(
RgSchUeCb *ue,
RgSchRaCb *raCb
)
#else
-PUBLIC Void rgSCHDhmAssgnUeHqEntFrmRaCb(ue, raCb)
+Void rgSCHDhmAssgnUeHqEntFrmRaCb(ue, raCb)
RgSchUeCb *ue;
RgSchRaCb *raCb;
#endif
{
- TRC2(rgSCHDhmAssgnUeHqEntFrmRaCb)
ue->cellInfo[0]->hqEnt = raCb->dlHqE;
ue->cellInfo[0]->hqEnt->ue = ue;
ue->ul.ulInactvMask &= ~(RG_HQENT_INACTIVE);
rgSCHCmnDlInitHqEnt(ue->cell, ue->cellInfo[0]->hqEnt);
- RETVOID;
+ return;
}
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmDelHqEnt
+Void rgSCHDhmDelHqEnt
(
RgSchCellCb *cell,
RgSchDlHqEnt **hqE
)
#else
-PUBLIC Void rgSCHDhmDelHqEnt(cell, hqE)
+Void rgSCHDhmDelHqEnt(cell, hqE)
RgSchCellCb *cell;
RgSchDlHqEnt **hqE;
#endif
{
- TRC2(rgSCHDhmDelHqEnt)
if (!(*hqE))
{
- RETVOID;
+ return;
}
rgSCHCmnDlDeInitHqEnt(cell, *hqE);
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)hqE,
sizeof(RgSchDlHqEnt));
- RETVOID;
+ return;
}
#ifdef ANSI
-PUBLIC RgSchDlHqEnt *rgSCHDhmHqEntInit
+RgSchDlHqEnt *rgSCHDhmHqEntInit
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchDlHqEnt *rgSCHDhmHqEntInit(cell)
+RgSchDlHqEnt *rgSCHDhmHqEntInit(cell)
RgSchCellCb *cell;
#endif
{
RgSchDlHqEnt *hqE;
Inst inst = cell->instIdx;
- TRC2(rgSCHDhmHqEntInit)
-
/* Init the HARQ data structure */
if (rgSCHUtlAllocSBuf(inst, (Data **)&hqE, sizeof(RgSchDlHqEnt)) != ROK)
{
RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHDhmHqEntInit hqE alloc fail");
- RETVALUE(NULLP);
+ return (NULLP);
}
#ifdef LTE_TDD
/* Init the HARQ processes */
{
RLOG_ARG0(L_DEBUG,DBG_CELLID,cell->cellId,
"rgSCHDhmHqEntInit hqP alloc fail in hqE");
- RETVALUE(NULLP);
+ return (NULLP);
}
#else
hqE->numHqPrcs = RGSCH_NUM_DL_HQ_PROC;
hqE->cell = cell;
/* CA Dev End*/
- RETVALUE(hqE);
+ return (hqE);
} /* rgSCHDhmHqEntInit */
/**
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetAvlHqProc
+S16 rgSCHDhmGetAvlHqProc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHDhmGetAvlHqProc (cell, ue, timingInfo, hqP)
+S16 rgSCHDhmGetAvlHqProc (cell, ue, timingInfo, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
RgSchDlHqEnt *hqE = NULLP;
RgSchDlHqProcCb *tmpHqProc;
CmLList *tmp;
- TRC2(rgSCHDhmGetAvlHqProc);
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDhmGetAvlHqProc hqE NULL ue %d"
, ue->ueId);
- RETVALUE(RFAILED);
+ return RFAILED;
}
"rgSCHDhmGetAvlHqProc free %ld inUse %ld ue %d"
, hqE->free.count, hqE->inUse.count, ue->ueId);
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
tmpHqProc = (RgSchDlHqProcCb *)(tmp->node);
if (!tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
#endif
tmpHqProc->itbsAtEstimate[1] = 0;
tmpHqProc->prbAtEstimate = 0;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetAvlHqProc */
* @param[in] RgSchDlHqEnt *hqE
* @param[in] CmLteTimingInfo timingInfo
* @param[out] RgDlHqProc *hqP
- * @param[in] U8 tbIdx
+ * @param[in] uint8_t tbIdx
* @return Void
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqTbRetx
+Void rgSCHDhmHqTbRetx
(
RgSchDlHqEnt *hqE,
CmLteTimingInfo timingInfo,
RgSchDlHqProcCb *hqP,
-U8 tbIdx
+uint8_t tbIdx
)
#else
-PUBLIC Void rgSCHDhmHqTbRetx(hqE, timingInfo, hqP, tbIdx)
+Void rgSCHDhmHqTbRetx(hqE, timingInfo, hqP, tbIdx)
RgSchDlHqEnt *hqE;
CmLteTimingInfo timingInfo;
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
+uint8_t tbIdx;
#endif
{
- U8 othrTbIdx = tbIdx ^ 1;
- TRC2(rgSCHDhmHqTbRetx)
+ uint8_t othrTbIdx = tbIdx ^ 1;
hqP->tbInfo[tbIdx].timingInfo = timingInfo;
if (hqE->msg4Proc == hqP)
{
- RETVOID;
+ return;
}
/* fix for ccpu00118633 No Hq proc Avl end*/
hqP->tbInfo[tbIdx].cntrRetxAllocFail = 0;
- RETVOID;
+ return;
} /* rgSCHDhmHqTbRetx */
/**
*
**/
#ifdef ANSI
-PUBLIC RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc
+RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc
(
RgSchDlHqEnt *hqE
)
#else
-PUBLIC RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc(hqE)
+RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc(hqE)
RgSchDlHqEnt *hqE;
#endif
{
- TRC2(rgSCHDhmLastSchedHqProc);
/* GRPPWR_CNTRL Fix: UE context will not hold a valid hqE,
* until RACH procedure is completed */
if ((hqE == NULLP) || (hqE->inUse.last == NULLP))
{
- RETVALUE(NULLP);
+ return (NULLP);
}
- RETVALUE((RgSchDlHqProcCb *)hqE->inUse.last->node);
+ return ((RgSchDlHqProcCb *)hqE->inUse.last->node);
} /* rgSCHDhmLastSchedHqProc */
#ifdef RGR_V1
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetCcchSduHqProc
+S16 rgSCHDhmGetCcchSduHqProc
(
RgSchUeCb *ueCb,
CmLteTimingInfo timingInfo,
RgSchDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHDhmGetCcchSduHqProc (ueCb, timingInfo, hqP)
+S16 rgSCHDhmGetCcchSduHqProc (ueCb, timingInfo, hqP)
RgSchUeCb *ueCb;
CmLteTimingInfo timingInfo;
RgSchDlHqProcCb **hqP;
CmLList *tmp;
RgSchDlHqEnt *hqE;
- TRC2(rgSCHDhmGetCcchSduHqProc)
-
hqE = ueCb->cellInfo[0]->hqEnt;
CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
if (NULLP == tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Remove the element from the free Queue and */
//cmLListAdd2Tail(&hqE->inUse, &tmpHqProc->lnk);
rgSCHDhmHqPAdd2InUseLst(tmpHqProc);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetCcchSduHqProc */
#endif
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetMsg4HqProc
+S16 rgSCHDhmGetMsg4HqProc
(
RgSchRaCb *raCb,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC S16 rgSCHDhmGetMsg4HqProc (raCb, timingInfo)
+S16 rgSCHDhmGetMsg4HqProc (raCb, timingInfo)
RgSchRaCb *raCb;
CmLteTimingInfo timingInfo;
#endif
CmLList *tmp;
RgSchDlHqEnt *hqE;
- TRC2(rgSCHDhmGetMsg4HqProc)
-
hqE = raCb->dlHqE;
CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
if (NULLP == tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Remove the element from the free Queue and */
tmpHqProc->tbInfo[0].timingInfo = timingInfo;
hqE->msg4Proc = tmpHqProc;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetMsg4HqProc */
/**
* Invoked by: scheduler and HARQ processing
*
* @param[in] RgDlHqProc *hqP
- * @param[in] U8 tbIdx
+ * @param[in] uint8_t tbIdx
* @param[in] Bool togNdi
* @return Void
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRlsHqpTb
+Void rgSCHDhmRlsHqpTb
(
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
+uint8_t tbIdx,
Bool togNdi
)
#else
-PUBLIC Void rgSCHDhmRlsHqpTb(hqP, tbIdx, togNdi)
+Void rgSCHDhmRlsHqpTb(hqP, tbIdx, togNdi)
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
+uint8_t tbIdx;
Bool togNdi;
#endif
{
RgSchDlHqEnt *hqE;
- U8 othrTbIdx = tbIdx ^ 1;
+ uint8_t othrTbIdx = tbIdx ^ 1;
#ifdef LTEMAC_SPS
RgSchCmnDlHqProc *cmnHqDl;
#endif
/* L2_COUNTERS */
#ifdef LTE_L2_MEAS
RgSchDlLcCb* lcCb = NULLP;
- U8 numLch = 0;
+ uint8_t numLch = 0;
#endif
- TRC2(rgSCHDhmRlsHqpTb)
-
/* Reset all tbInfo values */
hqE = hqP->hqE;
RgSchUeCb *ueCb = hqP->hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 cqi = dlUe->mimoInfo.cwInfo[0].cqi;
+ uint8_t cqi = dlUe->mimoInfo.cwInfo[0].cqi;
/* to get retransmission, decreasing transmission counter */
- U16 numDlRetx = hqP->tbInfo[0].txCntr-1;
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
- static U32 retxCnt1 = 0;
+ uint16_t numDlRetx = hqP->tbInfo[0].txCntr-1;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ static uint32_t retxCnt1 = 0;
RG_SCH_CMN_DL_TBS_TO_MCS(tbs, \
hqRetxStats.dlCqiStat[(cqi - 1)].mcs);
/* Add the proc to the free list */
//cmLListAdd2Tail(&hqE->free, &hqP->lnk);
rgSCHDhmHqPAdd2FreeLst(hqP);
- RETVOID;
+ return;
}
#ifdef RGR_V1
/* MS_WORKAROUND : syed The check (hqE->ccchSduProc != NULLP)
/* Add the proc to the free list */
//cmLListAdd2Tail(&hqE->free, &hqP->lnk);
rgSCHDhmHqPAdd2FreeLst(hqP);
- RETVOID;
+ return;
}
#endif
hqP->tbInfo[tbIdx].cntrRetxAllocFail = 0;
- RETVOID;
+ return;
} /* rgSCHDhmRlsHqpTb */
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRlsHqProc
+Void rgSCHDhmRlsHqProc
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmRlsHqProc(hqP)
+Void rgSCHDhmRlsHqProc(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmRlsHqProc)
-
#ifdef MAC_SCH_STATS
/* THIS FUNCTION IS NOT CALLED */
RgSchUeCb *ueCb = hqP->hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 cqi = dlUe->mimoInfo.cwInfo[0].cqi;
+ uint8_t cqi = dlUe->mimoInfo.cwInfo[0].cqi;
/* to get retransmission, decreasing transmission counter */
- U16 numDlRetx = hqP->tbInfo[0].txCntr-1;
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ uint16_t numDlRetx = hqP->tbInfo[0].txCntr-1;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
RG_SCH_CMN_DL_TBS_TO_MCS(tbs, hqRetxStats.dlCqiStat[(cqi - 1)].mcs);
hqP->tbCnt = 0;
#endif
- RETVOID;
+ return;
} /* rgSCHDhmRlsHqProc */
#ifdef LTEMAC_SPS
* Invoked by: ROM
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @param[in] RgDlHqProc **hqP
* @return S16
* -# ROK if successful
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetHqProcFrmId
+S16 rgSCHDhmGetHqProcFrmId
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 idx,
+uint8_t idx,
RgSchDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHDhmGetHqProcFrmId(cell, ue, idx, hqP)
+S16 rgSCHDhmGetHqProcFrmId(cell, ue, idx, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 idx;
+uint8_t idx;
RgSchDlHqProcCb **hqP;
#endif
{
RgSchDlHqEnt *hqE;
- TRC2(rgSCHDhmGetHqProcFrmId)
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
/* Pick the proc based on the index provided */
*hqP = &(hqE->procs[idx]);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmGetHqProcFrmId */
/**
*
**/
#ifdef ANSI
-PUBLIC RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc
+RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc(cell, ue, timingInfo)
+RgSchDlHqProcCb* rgSCHDhmSpsDlGetHqProc(cell, ue, timingInfo)
RgSchCellCb *cell,
RgSchUeCb *ue;
CmLteTimingInfo timingInfo;
#endif
{
RgSchDlHqEnt *hqE;
- U8 idx;
+ uint8_t idx;
RgSchDlHqProcCb *hqProc = NULLP;
CmLList *tmp = NULLP;
- TRC2(rgSCHDhmSpsDlGetHqProc);
-
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
CM_LLIST_FIRST_NODE(&(hqE->free), tmp);
if (NULLP == tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(NULLP);
+ return (NULLP);
}
idx = ((timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + timingInfo.slot)/
if (!tmp)
{
/* No Harq Process available in the free queue. */
- RETVALUE(NULLP);
+ return (NULLP);
}
hqProc->tbInfo[0].timingInfo = timingInfo;
rgSCHLaaResetDlHqProcCb(hqProc);
#endif
- RETVALUE(hqProc);
+ return (hqProc);
} /* rgSCHDhmSpsDlGetHqProc */
#endif /* LTEMAC_SPS */
* feedback indication received.
*
* @param[in] RgSchDlHqProcCb *hqP
- * @param[in] U8 tbIdx
- * @param[in] U8 fdbk
+ * @param[in] uint8_t tbIdx
+ * @param[in] uint8_t fdbk
* @return Void
* -# None.
**/
PRIVATE Void rgSCHDhmFdbkIndHndlTa
(
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
-U8 fdbk,
+uint8_t tbIdx,
+uint8_t fdbk,
Bool maxHqRetxReached
)
#else
PRIVATE Void rgSCHDhmFdbkIndHndlTa(hqP, tbIdx, fdbk,maxHqRetxReached)
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
-U8 fdbk;
+uint8_t tbIdx;
+uint8_t fdbk;
Bool maxHqRetxReached;
#endif
{
RgSchUeCb *ueCb;
RgSchCellCb *cell;
- TRC2(rgSCHDhmFdbkIndHndlTa)
-
ueCb = hqP->hqE->ue;
cell = ueCb->cell;
switch(fdbk)
break;
}
- RETVOID;
+ return;
} /* rgSCHDhmFdbkIndHndlTa */
/* 3.1 MIMO: TA cmd details at TB level rather than Hq Level */
* -# None.
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmSchdTa
+Void rgSCHDhmSchdTa
(
RgSchUeCb *ueCb,
RgSchDlHqTbCb *tbInfo
)
#else
-PUBLIC Void rgSCHDhmSchdTa(ueCb, tbInfo)
+Void rgSCHDhmSchdTa(ueCb, tbInfo)
RgSchUeCb *ueCb;
RgSchDlHqTbCb *tbInfo;
#endif
{
- TRC2(rgSCHDhmSchdTa)
-
ueCb->dl.taCb.state = RGSCH_TA_SCHEDULED;
ueCb->dl.taCb.numRemSf = 2;
tbInfo->schdTa.pres = PRSNT_NODEF;
tbInfo->schdTa.val = ueCb->dl.taCb.ta;
- RETVOID;
+ return;
} /* rgSCHDhmSchdTa */
#ifdef LTE_TDD
* @param[in] CmLteTimingInfo timeInfo
* @param[in] Bool *isMsg4
* @param[out] RgSchDlHqProcCb **hqPrcs
- * @param[out] U8 *numTbs
+ * @param[out] uint8_t *numTbs
* @param[out] S8 *tbStrtIdx
- * @param[out] U8 *cntHqPrcs
+ * @param[out] uint8_t *cntHqPrcs
* @return S16
**/
#ifdef ANSI
CmLteTimingInfo timeInfo,
Bool *isMsg4,
RgSchDlHqProcCb **hqPrcs,
-U8 *numTbs,
+uint8_t *numTbs,
S8 *tbStrtIdx,
-U8 *cntHqPrcs,
+uint8_t *cntHqPrcs,
RgSchCellCb *cell
)
#else
CmLteTimingInfo timeInfo;
Bool *isMsg4;
RgSchDlHqProcCb **hqPrcs;
-U8 *numTbs;
+uint8_t *numTbs;
S8 *tbStrtIdx;
-U8 *cntHqPrcs;
+uint8_t *cntHqPrcs;
RgSchCellCb *cell;
#endif
{
RgSchDlHqProcCb *hqP;
CmLteTimingInfo schdSfTime;
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
- U8 i;
- U8 idx;
- U8 dlIdx;
+ uint8_t noFdbks;
+ uint8_t i;
+ uint8_t idx;
+ uint8_t dlIdx;
CmLListCp *lnk;
CmLList *node;
tbStrtIdx[*cntHqPrcs] = 0;
numTbs[*cntHqPrcs] = 1;
(*cntHqPrcs)++;
- RETVALUE(ROK);
+ return ROK;
}
}
ascIdx = rgSchTddDlAscSetIdxKTbl[cell->ulDlCfgIdx][timeInfo.slot];
}
- RETVALUE(ROK);
+ return ROK;
}
#else /* LTE_TDD */
/** * @brief Handler for fetching Harq Proc given the timming information.
* @param[in] RgSchDlHqEnt *hqE
* @param[in] CmLteTimingInfo timeInfo
* @param[in] Bool *isMsg4
- * @param[out] U8 *numTbs
+ * @param[out] uint8_t *numTbs
* @param[out] S8 *tbStrtIdx
* @return RgSchDlHqProcCb*
* -# RgSchDlHqProcCb*
* -# NULLP
**/
#ifdef ANSI
-PUBLIC RgSchDlHqProcCb *rgSCHDhmHqProcByTime
+RgSchDlHqProcCb *rgSCHDhmHqProcByTime
(
RgSchDlHqEnt *hqE,
CmLteTimingInfo timeInfo,
RgSchDlSf *sf
)
#else
-PUBLIC RgSchDlHqProcCb *rgSCHDhmHqProcByTime(hqE, timeInfo,
+RgSchDlHqProcCb *rgSCHDhmHqProcByTime(hqE, timeInfo,
isMsg4,sf)
RgSchDlHqEnt *hqE;
CmLteTimingInfo timeInfo;
if (RGSCH_TIMEINFO_SAME(hqE->msg4Proc->tbInfo[0].timingInfo, timeInfo))
{
*isMsg4 = TRUE;
- RETVALUE(hqE->msg4Proc);
+ return (hqE->msg4Proc);
}
}
- RETVALUE(NULLP);
+ return (NULLP);
}
#endif
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlHqProcCb *hqP
- * @param[in] U8 tbCnt
+ * @param[in] uint8_t tbCnt
* @param[out] Bool *isMaxRetx
* @return Void
* -#None.
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqTbTrnsFail
+Void rgSCHDhmHqTbTrnsFail
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
-U8 tbCnt,
+uint8_t tbCnt,
Bool *isMaxRetx
)
#else
-PUBLIC Void rgSCHDhmHqTbTrnsFail(cell, hqP, tbCnt, isMaxRetx)
+Void rgSCHDhmHqTbTrnsFail(cell, hqP, tbCnt, isMaxRetx)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
-U8 tbCnt;
+uint8_t tbCnt;
Bool *isMaxRetx;
#endif
{
RgSchDlHqEnt *hqE;
- U8 maxHqTx;
-
- TRC2(rgSCHDhmHqTbTrnsFail)
+ uint8_t maxHqTx;
hqE = hqP->hqE;
"rgSCHDhmHqTbTrnsFail contRes exp(): tmpCRNTI = %u",
hqP->hqE->raCb->tmpCrnti);
rgSCHRamMsg4Done(cell, (RgSchRaCb *)hqP->hqE->raCb);
- RETVOID;
+ return;
}
#endif
maxHqTx = cell->dlHqCfg.maxMsg4HqTx;
RgSchUeCb *ueCb = hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
- static U32 retxCnt = 0;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ static uint32_t retxCnt = 0;
{
++retxCnt;
/* CA Dev End*/
break;
}
- RETVOID;
+ return;
}
/* extra:check if already removed as part of other TB processing
* then donot remove from InUse Q */
*isMaxRetx = TRUE;
}
- RETVOID;
+ return;
} /* rgSCHDhmHqTbTrnsFail */
-PUBLIC U32 rgHqRvStats[2][4][2] = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
+uint32_t rgHqRvStats[2][4][2] = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
{{0, 0}, {0, 0}, {0, 0}, {0, 0}}};
#ifdef LTE_TDD
#ifdef LTE_ADV
*
* @param[in] RgSchUeCb *ue,
* @param[in] RgSchDlHqProcCb *hqP,
- * @param[in] U8 *isAck,
+ * @param[in] uint8_t *isAck,
* @param[in] RgTfuHqInfo *fdbk,
- * @param[in] U8 tbIdx,
+ * @param[in] uint8_t tbIdx,
* @param[in] RgSchTddANInfo *anInfo;
- * @return RETVOID
+ * @return void
**/
#ifdef ANSI
PRIVATE Void rgSchGetHqFdbkPosForM1
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo
)
#else
PRIVATE Void rgSchGetHqFdbkPosForM1(ue,hqP,isAck,fdbk,tbIdx,anInfo)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
- U8 *isAck;
+ uint8_t *isAck;
RgTfuHqInfo *fdbk;
- U8 tbIdx;
+ uint8_t tbIdx;
RgSchTddANInfo *anInfo;
#endif
{
{
if(RG_SCH_IS_CELL_SEC(ue,hqP->hqE->cell))
{
- U8 cellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t cellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
break;
}
}
- RETVOID;
+ return;
}/* End of rgSchGetHqFdbkPosForM1 */
/** * @brief Function to decode the position of HarqFb for M>=2 cases.
*
* @param[in] RgSchUeCb *ue,
* @param[in] RgSchDlHqProcCb *hqP,
- * @param[in] U8 *isAck,
+ * @param[in] uint8_t *isAck,
* @param[in] RgTfuHqInfo *fdbk,
- * @param[in] U8 tbIdx,
+ * @param[in] uint8_t tbIdx,
* @param[in] RgSchTddANInfo *anInfo;
* @param[in] CmLteTimingInfo timeInfo;
- * @return RETVOID
+ * @return void
**/
#ifdef ANSI
PRIVATE Void rgSchGetHqFdbkPosForM234
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo,
- U8 M,
+ uint8_t M,
CmLteTimingInfo timeInfo
)
#else
PRIVATE Void rgSchGetHqFdbkPosForM234(ue,hqP,isAck,fdbk,tbIdx,anInfo,M,timeInfo)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
- U8 *isAck;
+ uint8_t *isAck;
RgTfuHqInfo *fdbk;
- U8 tbIdx;
+ uint8_t tbIdx;
RgSchTddANInfo *anInfo;
- U8 M;
+ uint8_t M;
CmLteTimingInfo timeInfo;
#endif
{
- U8 fdbkIdx;
+ uint8_t fdbkIdx;
Bool isSCell;
RgSchTddANInfo *pCellAnInfo;
- U8 incr = 0;
+ uint8_t incr = 0;
if(NULLP != ue)
{
dlHqStats[statsCnt].sf = hqP->tbInfo[tbIdx].timingInfo.slot;
dlHqStats[statsCnt].ack = *isAck;
dlHqStats[statsCnt].fdbkIdx = fdbkIdx;
- dlHqStats[statsCnt].ue = hqP->hqE->ue->ueId;;
+ dlHqStats[statsCnt].ue = hqP->hqE->ue->ueId;
if (anInfo)
dlHqStats[statsCnt].ulDai = incr;
if(TRUE == fdbk->isPusch)
}
#endif
}/*ue*/
- RETVOID;
+ return;
}/*rgSchGetHqFdbkPosForM234*/
#endif/*LTE_ADV*/
*
*
* @param[in] Void *cb
- * @param[in] U8 cbType
+ * @param[in] uint8_t cbType
* @param[in] RgSchCellCb cellCb
* @param[in] CmLteTimingInfo timeInfo
* @param[in] TfuHqInfo *fdbk
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmHqFdbkInd
+S16 rgSCHDhmHqFdbkInd
(
Void *cb,
-U8 cbType,
+uint8_t cbType,
RgSchCellCb *cellCb,
CmLteTimingInfo timeInfo,
TfuHqInfo *fdbk,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhmHqFdbkInd(cb, cbType, cellCb, timeInfo, fdbk, rlsHqBufs, err)
+S16 rgSCHDhmHqFdbkInd(cb, cbType, cellCb, timeInfo, fdbk, rlsHqBufs, err)
Void *cb;
-U8 cbType;
+uint8_t cbType;
RgSchCellCb *cellCb;
CmLteTimingInfo timeInfo;
TfuHqInfo *fdbk;
RgSchDlSf *sf;
Bool isMsg4 = FALSE;
RgSchRaCb *raCb = NULLP;
- U16 rnti=0;
+ uint16_t rnti=0;
/* Maximum possible HARQ processes in UL-DL configuration 5 that is
* given feedback at a time */
RgSchDlHqProcCb *hqPrcs[(RGSCH_NUM_SUB_FRAMES-1)*5]; /*MAX 5 Cells*/
- U8 numTb[(RGSCH_NUM_SUB_FRAMES-1)*5];
+ uint8_t numTb[(RGSCH_NUM_SUB_FRAMES-1)*5];
S8 tbStrtIdx[(RGSCH_NUM_SUB_FRAMES-1)*5];
- U8 hqCnt;
- U8 idx;
+ uint8_t hqCnt;
+ uint8_t idx;
RgSchTddANInfo *anInfo = NULLP;
- U8 isAck = 0;
- U8 tbCnt;
+ uint8_t isAck = 0;
+ uint8_t tbCnt;
RgrTddAckNackMode ackNackMode;
Bool hqRls = FALSE;
RgSchDlSf *nxtDlsf = NULLP;
- /* U8 rcvCnt = 0; */
+ /* uint8_t rcvCnt = 0; */
CmLteTimingInfo nxtfrm = {0,0};
Bool anUpd = FALSE;
Bool maxHqRetxReached;
#if ((defined LTEMAC_SPS_AN_MUX) || (defined LTE_ADV))
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
+ uint8_t noFdbks;
#endif
#ifdef LTEMAC_SPS_AN_MUX
Bool isPusch = FALSE;
- U8 tmpIdx;
- U8 hIdx;
+ uint8_t tmpIdx;
+ uint8_t hIdx;
/* Subframes in which transmissions are scheduled and whose feedback can come
* in this subframe. Used only for Multiplexing mode */
CmLteTimingInfo schdSfTime[RGSCH_TDD_MAX_FDBK];
#endif
#endif
#ifdef LTE_ADV
- U8 sCellActCePres = 0;
+ uint8_t sCellActCePres = 0;
#endif
/* LTEMAC_SPS_AN_MUX*/
RgrSchFrmt1b3TypEnum uciFrmtTyp = RG_SCH_UCI_FORMAT1A_1B;
- TRC2(rgSCHDhmHqFdbkInd)
if (cbType == RGSCH_HQ_FDB_IND_CB_TYPE_RA_CB)
{
{
err->errType = RGSCHERR_DHM_FDBK_IND;
err->errCause = RGSCHERR_DHM_FDBK_IND_INVALID_CB;
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* ccpu00147469 : This code is moved below as here this code always try to
if(ue)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqPrcs[idx]->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqPrcs[idx]->hqE->cell->instIdx,
hqPrcs[idx]->hqE->cell->cellId,ue);
if(ue->cellInfo[servCellIdx]->sCellState != RG_SCH_SCELL_ACTIVE)
{
RGSCHDBGINFO(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),
"Ack Rcvd. No Ack/Nack feedback available \n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
if(ackNackMode == RGR_TDD_ACKNACK_MODE_MULT)
{
CmLteTimingInfo txTime;
- U8 ulDlCfgIdx = 0;
- U8 maxFdbks = 0;
- U8 itr = 0;
+ uint8_t ulDlCfgIdx = 0;
+ uint8_t maxFdbks = 0;
+ uint8_t itr = 0;
ulDlCfgIdx = cellCb->ulDlCfgIdx;
ue->ueId,timeInfo.sfn, timeInfo.slot);
err->errType = RGSCHERR_DHM_FDBK_IND;
err->errCause = RGSCHERR_DHM_FDBK_IND_INVALID_CB;
- RETVALUE(RFAILED);
+ return RFAILED;
}
*/
}/*if(hqCnt==0)*/
#endif
}
- RETVALUE(ROK);
+ return ROK;
}
//#endif /* LTEMAC_SPS */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmPrcFdbkForTb
+S16 rgSCHDhmPrcFdbkForTb
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
RgSchDlSf *sf,
Bool isMsg4,
-U16 rnti,
-U8 tbCnt,
+uint16_t rnti,
+uint8_t tbCnt,
CmLteTimingInfo timingInfo,
-U8 isAck,
+uint8_t isAck,
RgInfRlsHqInfo *rlsHqBufs,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhmPrcFdbkForTb(cell, ue, hqP, sf, isMsg4, rnti, tbCnt, timingInfo, isAck, rlsHqBufs, err)
+S16 rgSCHDhmPrcFdbkForTb(cell, ue, hqP, sf, isMsg4, rnti, tbCnt, timingInfo, isAck, rlsHqBufs, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
RgSchDlSf *sf;
Bool isMsg4;
-U16 rnti;
-U8 tbCnt;
+uint16_t rnti;
+uint8_t tbCnt;
CmLteTimingInfo timingInfo;
-U8 isAck;
+uint8_t isAck;
RgInfRlsHqInfo *rlsHqBufs;
RgSchErrInfo *err;
#endif
CmLteTimingInfo frm = timingInfo;
#endif
- TRC2(rgSCHDhmPrcFdbkForTb)
if (ue)
{
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
{
if((rgSCHDhmProcHqFdbkAckNackRep(hqP,sf,tbCnt,&isAck)) != ROK)
{
- RETVALUE(ret);
+ return (ret);
}
}
else
{
rgSCHDhmFdbkIndHndlTa(hqP, tbCnt, isAck, maxHqRetxReached);
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDhmPrcFdbkForTb */
/** * @brief Function to decode the position of HarqFb for eachCell.
*
* @param[in] RgrSchFrmt1b3TypEnum uciFrmtTyp,
* @param[in] Bool *isAck,
* @param[in] RgTfuHqInfo *fdbk,
- * @return RETVOID
+ * @return void
**/
#ifdef ANSI
-PUBLIC Void rgSchGetHqFdbkPos
+Void rgSchGetHqFdbkPos
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
RgrSchFrmt1b3TypEnum uciFrmtTyp,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk
)
#else
-PUBLIC Void rgSchGetHqFdbkPos(cell,ue,hqP,uciFrmtTyp,isAck,fdbk)
+Void rgSchGetHqFdbkPos(cell,ue,hqP,uciFrmtTyp,isAck,fdbk)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
RgrSchFrmt1b3TypEnum uciFrmtTyp;
- U8 *isAck;
+ uint8_t *isAck;
RgTfuHqInfo *fdbk;
#endif
{
{
isAck[0] = fdbk->isAck[0];
isAck[1] = fdbk->isAck[1];
- RETVOID;
+ return;
}
#ifdef LTE_ADV
/* LAA Making all ack for LAA CELL */
{
isAck[0] = TRUE;
isAck[1] = TRUE;
- RETVOID;
+ return;
}
if((ue != NULLP))
if(RG_SCH_IS_CELL_SEC(ue,hqP->hqE->cell))
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
ue);
}
}
#endif
- RETVOID;
+ return;
}/* End of rgSchGetHqFdbkPos */
#ifdef LTE_ADV
#ifdef ANSI
-PUBLIC Void rgSchGetHqFdbkPosFormat3
+Void rgSchGetHqFdbkPosFormat3
(
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
TfuHqFdbk *fdbk
)
#else
-PUBLIC Void rgSchGetHqFdbkPosFormat3(hqP,isAck,fdbk)
+Void rgSchGetHqFdbkPosFormat3(hqP,isAck,fdbk)
RgSchDlHqProcCb *hqP;
- U8 *isAck;
+ uint8_t *isAck;
TfuHqFdbk *fdbk;
#endif
{
- U8 cellIdx = RG_SCH_CMN_GET_CELL_IDX_FROM_HQP(hqP);
- isAck[0] = (U8)fdbk[cellIdx];
- isAck[1] = (U8)fdbk[cellIdx + 1];
+ uint8_t cellIdx = RG_SCH_CMN_GET_CELL_IDX_FROM_HQP(hqP);
+ isAck[0] = (uint8_t)fdbk[cellIdx];
+ isAck[1] = (uint8_t)fdbk[cellIdx + 1];
}
#endif
/** * @brief Handler for HARQ feedback received for DL transmission.
*
*
* @param[in] Void *cb
- * @param[in] U8 cbType
+ * @param[in] uint8_t cbType
* @param[in] RgSchCellCb *cell
* @param[in] RgTfuHarqAckIndInfo *fdbk
* @param[in] RgInfRlsHqInfo *rlsHqBufs
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhm5gtfHqFdbkInd
+S16 rgSCHDhm5gtfHqFdbkInd
(
RgSchUeCb *ue,
RgSchCellCb *cell,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhm5gtfHqFdbkInd(ue, cell, timingInfo, fdbk, err)
+S16 rgSCHDhm5gtfHqFdbkInd(ue, cell, timingInfo, fdbk, err)
RgSchUeCb *ue;
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
S16 ret = ROK;
RgSchDlSf *sf;
Bool isMsg4 = FALSE;
- U16 rnti=0;
- U16 procId=0;
- U8 hqPCount = 0;
+ uint16_t rnti=0;
+ uint16_t procId=0;
+ uint8_t hqPCount = 0;
RgInfRlsHqInfo *rlsHqBufs = NULLP;
- TRC2(rgSCHDhm5gtfHqFdbkInd)
-
RGSCHDECRFRMCRNTTIME(timingInfo, timingInfo, 4);
sf = rgSCHUtlSubFrmGet(cell, timingInfo);
{
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].rnti = rnti;
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].hqProcId =
- (U8)procId;
+ (uint8_t)procId;
rlsHqBufs->numUes++;
}
hqPCount--;
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDhm5gtfHqFdbkInd */
/** * @brief Handler for HARQ feedback received for DL transmission.
*
*
* @param[in] Void *cb
- * @param[in] U8 cbType
+ * @param[in] uint8_t cbType
* @param[in] RgSchCellCb *cell
* @param[in] RgTfuHarqAckIndInfo *fdbk
* @param[in] RgInfRlsHqInfo *rlsHqBufs
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmHqFdbkInd
+S16 rgSCHDhmHqFdbkInd
(
Void *cb,
-U8 cbType,
+uint8_t cbType,
RgSchCellCb *cell,
CmLteTimingInfo timingInfo,
RgTfuHqInfo *fdbk,
RgSchErrInfo *err
)
#else
-PUBLIC S16 rgSCHDhmHqFdbkInd(cb, cbType, cell, timingInfo, fdbk, rlsHqBufs, err)
+S16 rgSCHDhmHqFdbkInd(cb, cbType, cell, timingInfo, fdbk, rlsHqBufs, err)
Void *cb;
-U8 cbType;
+uint8_t cbType;
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
RgTfuHqInfo *fdbk;
RgSchDlSf *sf;
Bool isMsg4 = FALSE;
RgSchRaCb *raCb = NULLP;
- U16 rnti=0;
+ uint16_t rnti=0;
/* Added Insure Fixes Of UR.Initialized procId */
- U16 procId=0;
- /* DTX Change: Bool is converted into U8*/
- U8 isAck[2]={0}; /*Changed to Array of 2*/
- U8 tbCnt;
- U8 hqPCount = 0;
+ uint16_t procId=0;
+ /* DTX Change: Bool is converted into uint8_t*/
+ uint8_t isAck[2]={0}; /*Changed to Array of 2*/
+ uint8_t tbCnt;
+ uint8_t hqPCount = 0;
#ifdef LTEMAC_SPS
CmLteTimingInfo fdbkRcptTime = timingInfo;
#endif
RgrSchFrmt1b3TypEnum uciFrmtTyp = RG_SCH_UCI_FORMAT1A_1B;
- TRC2(rgSCHDhmHqFdbkInd)
-
/* Get the subframe associated with the feedback */
/* ccpu00133109: Removed RGSCHSUBFRMCRNTTIME as it is not giving proper output
* if diff is more than 10. Instead using RGSCHDECRFRMCRNTTIME() as it is
RgSchUeCb *ueCb = hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
- static U32 retxCnt = 0;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ static uint32_t retxCnt = 0;
if (fdbk->isAck[0] == TFU_HQFDB_ACK)
{
"CRNTI:%d NO HARQ proc available for feedback: TimingInfo: "
"sfn %d slot %d", ue->ueId, timingInfo.sfn,
timingInfo.slot);
- RETVALUE(RFAILED);
+ return RFAILED;
}
isAck[0] = fdbk->isAck[0];
/* Remove release PDCCH from the subframe */
rgSCHUtlPdcchPut(cell, &sf->pdcchInfo, sf->relPdcch);
sf->relPdcch = NULLP;
- RETVALUE(ROK);
+ return ROK;
}
}
}
{
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].rnti = rnti;
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].hqProcId =
- (U8)procId;
+ (uint8_t)procId;
rlsHqBufs->numUes++;
}
hqPCount--;
{
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].rnti = rnti;
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].hqProcId =
- (U8)procId;
+ (uint8_t)procId;
rlsHqBufs->numUes++;
}
hqPCount--;
node = node->next;
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDhmHqFdbkInd */
#endif /* LTE_FDD */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRgrUeCfg
+Void rgSCHDhmRgrUeCfg
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHDhmRgrUeCfg(cell, ueCb, ueCfg, err)
+Void rgSCHDhmRgrUeCfg(cell, ueCb, ueCfg, err)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
RgrUeCfg *ueCfg;
RgSchErrInfo *err;
#endif
{
- TRC2(rgSCHDhmRgrUeCfg)
UNUSED(err);
}
rgSCHTmrStartTmr (cell, ueCb, RG_SCH_TMR_TA, ueCb->dl.taCb.cfgTaTmr);
}
- RETVOID;
+ return;
} /* rgSCHDhmRgrUeCfg */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRgrCellCfg
+Void rgSCHDhmRgrCellCfg
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHDhmRgrCellCfg(cell, cellCfg, err)
+Void rgSCHDhmRgrCellCfg(cell, cellCfg, err)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
RgSchErrInfo *err;
PTR pUeCb;/* previous UE Control block */
PTR nUeCb;/* next UE control block */
S16 ret;
- U8 idx;
-
- TRC2(rgSCHDhmRgrCellCfg)
+ uint8_t idx;
UNUSED(err);
cell->tq[idx].first = NULLP;
cell->tq[idx].tail = NULLP;
}
- RETVOID;
+ return;
} /* rgSCHDhmRgrCellCfg */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRgrCellRecfg
+Void rgSCHDhmRgrCellRecfg
(
RgSchCellCb *cell,
RgrCellRecfg *cellRecfg,
RgSchErrInfo *err
)
#else
-PUBLIC Void rgSCHDhmRgrCellRecfg(cell, cellRecfg, err)
+Void rgSCHDhmRgrCellRecfg(cell, cellRecfg, err)
RgSchCellCb *cell;
RgrCellRecfg *cellRecfg;
RgSchErrInfo *err;
PTR nUeCb;/* next UE control block */
S16 ret;
- TRC2(rgSCHDhmRgrCellRecfg)
-
UNUSED(err);
pUeCb = NULLP;
}
}
}
- RETVOID;
+ return;
} /* rgSCHDhmRgrCellRecfg */
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmFreeUe
+Void rgSCHDhmFreeUe
(
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDhmFreeUe(ueCb)
+Void rgSCHDhmFreeUe(ueCb)
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHDhmFreeUe)
-
/* If TA Timer is running. Stop it */
if (ueCb->taTmr.tmrEvnt != TMR_NONE)
{
rgSCHCmnRmvFrmTaLst(ueCb->cell, ueCb);
}
- RETVOID;
+ return;
} /* rgSCHDhmFreeUe */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ueCb
- * @param[in] U8 ta
+ * @param[in] uint8_t ta
*
* @return None.
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmUpdTa
+Void rgSCHDhmUpdTa
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 ta
+uint8_t ta
)
#else
-PUBLIC Void rgSCHDhmUpdTa(cell, ueCb, ta)
+Void rgSCHDhmUpdTa(cell, ueCb, ta)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 ta;
+uint8_t ta;
#endif
{
- TRC2(rgSCHDhmUpdTa)
if (ueCb->dl.taCb.state == RGSCH_TA_IDLE)
{
ueCb->dl.taCb.outStndngTaval = ta;
}
- RETVOID;
+ return;
} /* rgSCHDhmUpdTa */
/** @brief This function handles the TA timer expiry.
* -#None.
*/
#ifdef ANSI
-PUBLIC Void rgSCHDhmProcTAExp
+Void rgSCHDhmProcTAExp
(
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDhmProcTAExp (ueCb)
+Void rgSCHDhmProcTAExp (ueCb)
RgSchUeCb *ueCb;
#endif
{
- TRC2(rgSCHDhmProcTAExp);
-
/* Ask scheduler to schedule this UE */
ueCb->dl.taCb.state = RGSCH_TA_TOBE_SCHEDULED;
rgSCHUtlDlTARpt(ueCb->cell, ueCb);
- RETVOID;
+ return;
} /* end of rgSCHDhmProcTAExp */
/* 3.1 MIMO: LC details at TB level rather than Hq Level */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmAddLcData
+S16 rgSCHDhmAddLcData
(
Inst inst,
RgSchLchAllocInfo *lchData,
RgSchDlHqTbCb *tbInfo
)
#else
-PUBLIC S16 rgSCHDhmAddLcData(inst, lchData, tbInfo)
+S16 rgSCHDhmAddLcData(inst, lchData, tbInfo)
Inst inst;
RgSchLchAllocInfo *lchData;
RgSchDlHqTbCb *tbInfo;
#endif
{
- TRC2(rgSCHDhmAddLcData)
-
if(tbInfo->numLch >= RGSCH_MAX_NUM_DED_LC)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
tbInfo->lchSchdDataArr[tbInfo->numLch] = *lchData;
tbInfo->numLch++;
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmAddLcData */
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmTddRlsSubFrm
+S16 rgSCHDhmTddRlsSubFrm
(
RgSchCellCb *cellCb,
CmLteTimingInfo uciTimingInfo
)
#else
-PUBLIC S16 rgSCHDhmTddRlsSubFrm(cellCb, uciTimingInfo)
+S16 rgSCHDhmTddRlsSubFrm(cellCb, uciTimingInfo)
RgSchCellCb *cellCb;
CmLteTimingInfo uciTimingInfo;
#endif
{
CmLteTimingInfo dlSfTime;
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
- U8 i;
-
- TRC2(rgSCHDhmTddRlsSubFrm)
+ uint8_t noFdbks;
+ uint8_t i;
ascIdx =
rgSchTddDlAscSetIdxKTbl[cellCb->ulDlCfgIdx][uciTimingInfo.slot];
RGSCHDECRFRMCRNTTIME(uciTimingInfo, dlSfTime, ascIdx.subfrmNum[i]);
rgSCHUtlDlRlsSubFrm(cellCb, dlSfTime);
}
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHDhmTddRlsSubFrm */
#ifdef TFU_TDD
-U32 macDtx = 0;
+uint32_t macDtx = 0;
#endif
/**
* @brief Handler for Removing the HARQ process from a dlsf.
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc
+S16 rgSCHDhmRlsDlsfHqProc
(
RgSchCellCb *cellCb,
CmLteTimingInfo uciTimingInfo
)
#else
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc(cellCb, uciTimingInfo)
+S16 rgSCHDhmRlsDlsfHqProc(cellCb, uciTimingInfo)
RgSchCellCb *cellCb;
CmLteTimingInfo uciTimingInfo;
#endif
CmLteTimingInfo nxtfrm = {0,0};
RgSchDlHqProcCb *tmpHqProc;
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
+ uint8_t noFdbks;
S16 i;
RgSchDlSf *nxtDlsf = NULLP;
CmLList *node;
CmLList *hqPNode;
- U8 idx;
+ uint8_t idx;
/*ccpu00130018 -MOD -Initiatizing with FALSE*/
- U8 maxRetx=FALSE;
+ uint8_t maxRetx=FALSE;
RgSchTddANInfo *anInfo = NULLP;
RgSchDlHqTbCb *tbCb;
RgSchUeCb *ue = NULLP;
- TRC2(rgSCHDhmRlsDlsfHqProc)
ascIdx =
rgSchTddDlAscSetIdxKTbl[cellCb->ulDlCfgIdx][uciTimingInfo.slot];
/* Update feedback time for this process so that
* next subframe its picked up */
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(
tmpHqProc->hqE->cell->instIdx,
tmpHqProc->hqE->cell->cellId,
ue);
/* Update feedback time for this process so that
* next subframe its picked up */
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(
tmpHqProc->hqE->cell->instIdx,
tmpHqProc->hqE->cell->cellId,
ue);
#endif
if(anInfo == NULLP)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
RGSCH_NULL_CHECK(cellCb->instIdx, nxtDlsf);
RGSCH_UPD_HQAN_FDBKTIME(tbCb, nxtDlsf, nxtfrm);
}
}
}
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHDhmRlsDlsfHqProc */
#else /* ifdef LTE_TDD */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc
+S16 rgSCHDhmRlsDlsfHqProc
(
RgSchCellCb *cell,
CmLteTimingInfo timingInfo
)
#else
-PUBLIC S16 rgSCHDhmRlsDlsfHqProc(cell, timingInfo)
+S16 rgSCHDhmRlsDlsfHqProc(cell, timingInfo)
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
#endif
Bool maxRetx;
CmLList *node;
CmLList *hqPNode;
- U8 idx;
+ uint8_t idx;
RgSchDlHqTbCb *tbCb;
RgSchUeCb *ue;
- TRC2(rgSCHDhmRlsDlsfHqProc)
-
/* Fetch the current timing info. Modify it to Last sf to be rlsd.*/
/* ccpu00133109: Removed RGSCHSUBFRMCRNTTIME as it is not giving proper
* output if diff is more than 10. Instead using RGSCHDECRFRMCRNTTIME()
}
/*CA Dev End*/
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmRlsDlsfHqProc */
#endif
#ifdef LTEMAC_SPS
* - Set isSpsHqProc = TRUE
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return S16
* -# ROK if successful
* -# RFAILED otherwise
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmMarkSpsHqProc
+S16 rgSCHDhmMarkSpsHqProc
(
RgSchUeCb *ue,
-U8 idx
+uint8_t idx
)
#else
-PUBLIC S16 rgSCHDhmMarkSpsHqProc(ue, idx)
+S16 rgSCHDhmMarkSpsHqProc(ue, idx)
RgSchUeCb *ue;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchDlHqProcCb *hqP;
- TRC2(rgSCHDhmMarkSpsHqProc)
/* Pick the proc based on the index provided */
rgSCHDhmGetHqProcFrmId(ue->cell, ue, idx, &hqP);
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmMarkSpsHqProc */
#endif /* RG_UNUSED */
#endif /* LTEMAC_SPS */
*
* @param[in] RgSchDlHqProcCb *hqP
* @param[in] RgSchDlSf *sf
- * @param[in] U8 tbCnt
- * @param[in] U8 *isAck
+ * @param[in] uint8_t tbCnt
+ * @param[in] uint8_t *isAck
* @return S16
* -# ROK
* -# RFAILED
(
RgSchDlHqProcCb *hqP,
RgSchDlSf *sf,
-U8 tbCnt,
-U8 *isAck
+uint8_t tbCnt,
+uint8_t *isAck
)
#else
PRIVATE S16 rgSCHDhmProcHqFdbkAckNackRep(hqP,sf,tbCnt,isAck)
RgSchDlHqProcCb *hqP;
RgSchDlSf *sf;
-U8 tbCnt;
-U8 *isAck;
+uint8_t tbCnt;
+uint8_t *isAck;
#endif
{
- TRC2(rgSCHDhmProcHqFdbkAckNackRep)
/* Check if this is repeating UE */
rgSCHUtlDlHqPTbRmvFrmTx(sf, hqP, tbCnt, TRUE);
/* Check if last repetition */
/* Update timingInfo for this hqP so that next subframe its picked up */
RG_SCH_ADD_TO_CRNT_TIME(hqP->tbInfo[tbCnt].timingInfo, \
hqP->tbInfo[tbCnt].timingInfo, 1);
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Take decision here based on the number
hqP->tbInfo[tbCnt].isAckNackDtx = *isAck;
- RETVALUE(ROK);
+ return ROK;
}
#endif /* ifndef LTE_TDD */
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmDlRetxAllocFail
+S16 rgSCHDhmDlRetxAllocFail
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC S16 rgSCHDhmDlRetxAllocFail(ue, hqP)
+S16 rgSCHDhmDlRetxAllocFail(ue, hqP)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
#endif
Bool maxRetx = FALSE;
RgSchCmnCell *cellSch;
- TRC2(rgSCHDhmDlRetxAllocFail);
-
cell = hqP->hqE->cell;
cellSch = RG_SCH_CMN_GET_CELL(cell);
rlsHqInfo = &(cell->rlsHqArr[cell->crntHqIdx]);
RgSchMacRlsHq(&pst, rlsHqInfo);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef DL_LA
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 hqfdbk,
-U8 tbCnt
+uint8_t hqfdbk,
+uint8_t tbCnt
)
#else
PRIVATE S16 rgSCHDhmUpdateAckNackHistory(cell, ueCb, hqfdbk, tbCnt)
(
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 hqfdbk;
-U8 tbCnt;
+uint8_t hqfdbk;
+uint8_t tbCnt;
)
#endif
{
*/
rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 rgSCHDhmUpdBlerBasediTbsEff
+S16 rgSCHDhmUpdBlerBasediTbsEff
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 tbCnt
+uint8_t tbCnt
)
#else
-PUBLIC S16 rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt)
+S16 rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt)
(
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 tbCnt;
+uint8_t tbCnt;
)
#endif
{
S32 iTbs;
RgSchCmnDlUe *ueDl;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
- U8 maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
maxiTbs = RG_SCH_DL_MAX_ITBS;
ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
(*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
[ueDl->mimoInfo.cwInfo[tbCnt].iTbs[1]];
- RETVALUE(ROK);
+ return ROK;
}
#endif
* 4 = DTX (UE did not transmit anything)
*
* @param[in] TfuHqInfo *fdbk
- * @param[in] U8 hqCnt
+ * @param[in] uint8_t hqCnt
* @return Void
*
**/
(
RgSchCellCb *cell,
TfuHqInfo *fdbk,
-U8 hqCnt
+uint8_t hqCnt
)
#else
PRIVATE Void rgSCHDhmPrcSplBundlFdbk(cell, fdbk, hqCnt)
(
RgSchCellCb *cell;
TfuHqInfo *fdbk;
-U8 hqCnt;
+uint8_t hqCnt;
)
#endif
{
- U8 numOfAcks;
+ uint8_t numOfAcks;
- TRC2(rgSCHDhmPrcSplBundlFdbk);
-
/* Num of ACKs reported by UE */
numOfAcks = fdbk->isAck[0];
the PDSCH trasnmission (spatial bundling). So we have
to assume same feedback for both codewords */
#ifdef LTE_ADV
- for(U8 idx = 1 ; idx < TFU_MAX_HARQ_FDBKS; idx++)
+ for(uint8_t idx = 1 ; idx < TFU_MAX_HARQ_FDBKS; idx++)
{
fdbk->isAck[idx] = fdbk->isAck[0];
}
fdbk->isAck[1] = fdbk->isAck[0];
#endif
- RETVOID;
+ return;
}
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPAdd2FreeLst
+Void rgSCHDhmHqPAdd2FreeLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPAdd2FreeLst(hqP)
+Void rgSCHDhmHqPAdd2FreeLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPAdd2FreeLst)
#ifdef LAA_DBG
if (hqP->hqPLst)
rgSCHLaaHndlHqProcFree(hqP);
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPAdd2FreeLst */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPAdd2InUseLst
+Void rgSCHDhmHqPAdd2InUseLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPAdd2InUseLst(hqP)
+Void rgSCHDhmHqPAdd2InUseLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPAdd2InUseLst)
#ifdef LAA_DBG
if (hqP->hqPLst)
}
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPAdd2InUseLst */
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPDelFrmFreeLst
+Void rgSCHDhmHqPDelFrmFreeLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPDelFrmFreeLst(hqP)
+Void rgSCHDhmHqPDelFrmFreeLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPDelFrmFreeLst)
#ifdef LAA_DBG
if (!hqP->hqPLst)
}
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPDelFrmFreeLst */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPDelFrmInUseLst
+Void rgSCHDhmHqPDelFrmInUseLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPDelFrmInUseLst(hqP)
+Void rgSCHDhmHqPDelFrmInUseLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
- TRC2(rgSCHDhmHqPDelFrmInUseLst)
#ifdef LAA_DBG
if (!hqP->hqPLst)
}
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPDelFrmInUseLst */
\f
Code Review / o-du / l2.git / blobdiff