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"
extern U32 rgNumSPSSchedDropMaxRetx;
extern U32 rgNumActDtx;
#endif
-PUBLIC U32 nackSf[10];
+U32 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
PRIVATE Void rgSCHDhmFdbkIndHndlTa ARGS((RgSchDlHqProcCb *hqP, U8 tbIdx, U8 fdbk,
Bool maxHqRetxReached));
-PUBLIC void rgEmtcsetNullSubFrm ARGS((RgSchDlHqProcCb *hqP));
+void rgEmtcsetNullSubFrm ARGS((RgSchDlHqProcCb *hqP));
#ifndef LTE_TDD
PRIVATE S16 rgSCHDhmProcHqFdbkAckNackRep ARGS((
RgSchDlHqProcCb *hqP,
/* Freeing up the HARQ proc blocked for
* indefinite time in case of Retx */
-PUBLIC S16 rgSCHDhmDlRetxAllocFail ARGS((
+S16 rgSCHDhmDlRetxAllocFail ARGS((
RgSchUeCb *ue,
RgSchDlHqProcCb *proc
));
**/
/*MS_WORKAROUND for ccpu00122893*/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqEntReset
+Void rgSCHDhmHqEntReset
(
RgSchDlHqEnt *hqE
)
#else
-PUBLIC Void rgSCHDhmHqEntReset(hqE)
+Void rgSCHDhmHqEntReset(hqE)
RgSchDlHqEnt *hqE;
#endif
{
*
**/
#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
*
**/
#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
}
#ifdef ANSI
-PUBLIC RgSchDlHqEnt *rgSCHDhmHqEntInit
+RgSchDlHqEnt *rgSCHDhmHqEntInit
(
RgSchCellCb *cell
)
#else
-PUBLIC RgSchDlHqEnt *rgSCHDhmHqEntInit(cell)
+RgSchDlHqEnt *rgSCHDhmHqEntInit(cell)
RgSchCellCb *cell;
#endif
{
{
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;
{
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 */
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqTbRetx
+Void rgSCHDhmHqTbRetx
(
RgSchDlHqEnt *hqE,
CmLteTimingInfo timingInfo,
U8 tbIdx
)
#else
-PUBLIC Void rgSCHDhmHqTbRetx(hqE, timingInfo, hqP, tbIdx)
+Void rgSCHDhmHqTbRetx(hqE, timingInfo, hqP, tbIdx)
RgSchDlHqEnt *hqE;
CmLteTimingInfo timingInfo;
RgSchDlHqProcCb *hqP;
*
**/
#ifdef ANSI
-PUBLIC RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc
+RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc
(
RgSchDlHqEnt *hqE
)
#else
-PUBLIC RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc(hqE)
+RgSchDlHqProcCb * rgSCHDhmLastSchedHqProc(hqE)
RgSchDlHqEnt *hqE;
#endif
{
* 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;
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
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 */
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRlsHqpTb
+Void rgSCHDhmRlsHqpTb
(
RgSchDlHqProcCb *hqP,
U8 tbIdx,
Bool togNdi
)
#else
-PUBLIC Void rgSCHDhmRlsHqpTb(hqP, tbIdx, togNdi)
+Void rgSCHDhmRlsHqpTb(hqP, tbIdx, togNdi)
RgSchDlHqProcCb *hqP;
U8 tbIdx;
Bool togNdi;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmRlsHqProc
+Void rgSCHDhmRlsHqProc
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmRlsHqProc(hqP)
+Void rgSCHDhmRlsHqProc(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmGetHqProcFrmId
+S16 rgSCHDhmGetHqProcFrmId
(
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgSCHDhmGetHqProcFrmId(cell, ue, idx, hqP)
+S16 rgSCHDhmGetHqProcFrmId(cell, ue, idx, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
U8 idx;
/* 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;
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 */
* -# 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
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.
* -# 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
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqTbTrnsFail
+Void rgSCHDhmHqTbTrnsFail
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
Bool *isMaxRetx
)
#else
-PUBLIC Void rgSCHDhmHqTbTrnsFail(cell, hqP, tbCnt, isMaxRetx)
+Void rgSCHDhmHqTbTrnsFail(cell, hqP, tbCnt, isMaxRetx)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
U8 tbCnt;
RETVOID;
} /* rgSCHDhmHqTbTrnsFail */
-PUBLIC U32 rgHqRvStats[2][4][2] = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
+U32 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
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmHqFdbkInd
+S16 rgSCHDhmHqFdbkInd
(
Void *cb,
U8 cbType,
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;
RgSchCellCb *cellCb;
{
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
{
RGSCHDBGINFO(cellCb->instIdx,(rgSchPBuf(cellCb->instIdx),
"Ack Rcvd. No Ack/Nack feedback available \n"));
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
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,
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;
{
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.
*
* @return RETVOID
**/
#ifdef ANSI
-PUBLIC Void rgSchGetHqFdbkPos
+Void rgSchGetHqFdbkPos
(
RgSchCellCb *cell,
RgSchUeCb *ue,
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;
}/* End of rgSchGetHqFdbkPos */
#ifdef LTE_ADV
#ifdef ANSI
-PUBLIC Void rgSchGetHqFdbkPosFormat3
+Void rgSchGetHqFdbkPosFormat3
(
RgSchDlHqProcCb *hqP,
U8 *isAck,
TfuHqFdbk *fdbk
)
#else
-PUBLIC Void rgSchGetHqFdbkPosFormat3(hqP,isAck,fdbk)
+Void rgSchGetHqFdbkPosFormat3(hqP,isAck,fdbk)
RgSchDlHqProcCb *hqP;
U8 *isAck;
TfuHqFdbk *fdbk;
* -# 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;
hqPCount--;
}
- RETVALUE(ret);
+ return (ret);
} /* rgSCHDhm5gtfHqFdbkInd */
/** * @brief Handler for HARQ feedback received for DL transmission.
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmHqFdbkInd
+S16 rgSCHDhmHqFdbkInd
(
Void *cb,
U8 cbType,
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;
RgSchCellCb *cell;
"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;
}
}
}
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;
* -# 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;
* -# 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;
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmFreeUe
+Void rgSCHDhmFreeUe
(
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDhmFreeUe(ueCb)
+Void rgSCHDhmFreeUe(ueCb)
RgSchUeCb *ueCb;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmUpdTa
+Void rgSCHDhmUpdTa
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
U8 ta
)
#else
-PUBLIC Void rgSCHDhmUpdTa(cell, ueCb, ta)
+Void rgSCHDhmUpdTa(cell, ueCb, ta)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
U8 ta;
* -#None.
*/
#ifdef ANSI
-PUBLIC Void rgSCHDhmProcTAExp
+Void rgSCHDhmProcTAExp
(
RgSchUeCb *ueCb
)
#else
-PUBLIC Void rgSCHDhmProcTAExp (ueCb)
+Void rgSCHDhmProcTAExp (ueCb)
RgSchUeCb *ueCb;
#endif
{
* -# 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;
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
RGSCHDECRFRMCRNTTIME(uciTimingInfo, dlSfTime, ascIdx.subfrmNum[i]);
rgSCHUtlDlRlsSubFrm(cellCb, dlSfTime);
}
- RETVALUE(ROK);
+ return ROK;
}/* rgSCHDhmTddRlsSubFrm */
#ifdef TFU_TDD
* -# 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
#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
}
/*CA Dev End*/
- RETVALUE(ROK);
+ return ROK;
} /* rgSCHDhmRlsDlsfHqProc */
#endif
#ifdef LTEMAC_SPS
*
**/
#ifdef ANSI
-PUBLIC S16 rgSCHDhmMarkSpsHqProc
+S16 rgSCHDhmMarkSpsHqProc
(
RgSchUeCb *ue,
U8 idx
)
#else
-PUBLIC S16 rgSCHDhmMarkSpsHqProc(ue, idx)
+S16 rgSCHDhmMarkSpsHqProc(ue, idx)
RgSchUeCb *ue;
U8 idx;
#endif
/* 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 */
/* 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
RgSchMacRlsHq(&pst, rlsHqInfo);
}
- RETVALUE(ROK);
+ return ROK;
}
#ifdef DL_LA
*/
rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt);
- RETVALUE(ROK);
+ return ROK;
}
#ifdef ANSI
-PUBLIC S16 rgSCHDhmUpdBlerBasediTbsEff
+S16 rgSCHDhmUpdBlerBasediTbsEff
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
U8 tbCnt
)
#else
-PUBLIC S16 rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt)
+S16 rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt)
(
RgSchCellCb *cell;
RgSchUeCb *ueCb;
(*(RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[1][cfi]))\
[ueDl->mimoInfo.cwInfo[tbCnt].iTbs[1]];
- RETVALUE(ROK);
+ return ROK;
}
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPAdd2FreeLst
+Void rgSCHDhmHqPAdd2FreeLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPAdd2FreeLst(hqP)
+Void rgSCHDhmHqPAdd2FreeLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPAdd2InUseLst
+Void rgSCHDhmHqPAdd2InUseLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPAdd2InUseLst(hqP)
+Void rgSCHDhmHqPAdd2InUseLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPDelFrmFreeLst
+Void rgSCHDhmHqPDelFrmFreeLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPDelFrmFreeLst(hqP)
+Void rgSCHDhmHqPDelFrmFreeLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgSCHDhmHqPDelFrmInUseLst
+Void rgSCHDhmHqPDelFrmInUseLst
(
RgSchDlHqProcCb *hqP
)
#else
-PUBLIC Void rgSCHDhmHqPDelFrmInUseLst(hqP)
+Void rgSCHDhmHqPDelFrmInUseLst(hqP)
RgSchDlHqProcCb *hqP;
#endif
{