static int RLOG_FILE_ID=279;
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 "common_def.h"
#ifdef L2_OPTMZ
#include "ss_strm.h"
#endif
-#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 "lrg.h"
#include "crg.h"
-#include "rgu.h"
#include "tfu.h"
+#include "rgu.h"
#include "rg_sch_inf.h"
#include "rg_env.h"
#include "rg_err.h"
#include "rg.h"
+#include "du_app_mac_inf.h"
/* header/extern include files (.x) */
-#include "gen.x" /* general layer */
-#include "ssi.x" /* system service interface */
#ifdef L2_OPTMZ
#include "ss_strm.x"
#endif
-#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 "crg.x"
-#include "rgu.x"
#include "tfu.x"
+#include "rgu.x"
#include "rg_sch_inf.x"
#include "rg_prg.x" /* PRG interface typedefs */
-#include "du_app_mac_inf.h"
#include "rg.x"
#ifdef L2_OPTMZ
RgTfuDatReqPduInfo *datReq));
#ifdef L2_OPTMZ
-PUBLIC S16 rgDHMFreeHqProcTB
+S16 rgDHMFreeHqProcTB
(
RgDlHqProcCb *hqP,
U8 tbIndex
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMHqEntInit
+S16 rgDHMHqEntInit
(
Inst inst,
RgDlHqEnt *hqE,
U8 maxHqProcs
)
#else
-PUBLIC S16 rgDHMHqEntInit(inst,hqE, maxHqProcs)
+S16 rgDHMHqEntInit(inst,hqE, maxHqProcs)
Inst inst,
RgDlHqEnt *hqE;
U8 maxHqProcs;
rgFreeSBuf(inst,(Data **)&(hqE->procs[idx1]), sizeof(RgDlHqProcCb));
}
RLOG0(L_ERROR, "Memory Alloc Failure for RgDlHqProcCb");
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqE->procs[idx1]->procId = idx1;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMHqEntInit */
/**
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMUeReset
+Void rgDHMUeReset
(
RgCellCb *cell,
RgDlHqEnt *hqE
)
#else
-PUBLIC Void rgDHMUeReset(cell, hqE)
+Void rgDHMUeReset(cell, hqE)
RgCellCb *cell;
RgDlHqEnt *hqE;
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMHdlBufFree
+Void rgDHMHdlBufFree
(
Inst inst,
Buffer **mBuf
)
#else
-PUBLIC Void rgDHMHdlBufFree(Inst inst, Buffer **mBuf)
+Void rgDHMHdlBufFree(Inst inst, Buffer **mBuf)
Inst inst;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMFreeTbBufs
+Void rgDHMFreeTbBufs
(
Inst inst
)
#else
-PUBLIC Void rgDHMFreeTbBufs(inst)
+Void rgDHMFreeTbBufs(inst)
Inst inst;
#endif
{
} /* rgDHMFreeTbBufs */
#ifdef ANSI
-PUBLIC Void rgDHMFreeAllTbBufs
+Void rgDHMFreeAllTbBufs
(
Inst inst
)
#else
-PUBLIC Void rgDHMFreeAllTbBufs(inst)
+Void rgDHMFreeAllTbBufs(inst)
Inst inst;
#endif
{
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMRlsHqProcTB
+S16 rgDHMRlsHqProcTB
(
RgCellCb *cell,
RgDlHqProcCb *hqP,
U8 tbIndex
)
#else
-PUBLIC S16 rgDHMRlsHqProcTB(cell, hqP, tbIndex)
+S16 rgDHMRlsHqProcTB(cell, hqP, tbIndex)
RgCellCb *cell;
RgDlHqProcCb *hqP;
U8 tbIndex;
if((tbIndex > RG_MAX_TB_PER_UE) ||
(tbIndex == 0))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
hqP->tbInfo[tbIndex-1].numSchLch = 0;
hqP->tbInfo[tbIndex-1].contResCe = NOTPRSNT;
hqP->tbInfo[tbIndex-1].contResId = NULLP;
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMRlsHqProc */
/**
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMGetHqProcFrmId
+S16 rgDHMGetHqProcFrmId
(
RgUeCb *ue,
U8 idx,
RgDlHqProcCb **hqP
)
#else
-PUBLIC S16 rgDHMGetHqProcFrmId(ue, idx, hqP)
+S16 rgDHMGetHqProcFrmId(ue, idx, hqP)
RgUeCb *ue;
U8 idx;
RgDlHqProcCb **hqP;
/* Pick the proc based on the index provided */
*hqP = (ue->dl.hqEnt.procs[idx]);
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMGetHqProcFrmId */
/*PRIVATE U32 dataAvl; */
* -#RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDHMSndDatReq
+S16 rgDHMSndDatReq
(
RgCellCb *cellCb,
RgDlSf *dlSf,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMSndDatReq(cellCb, dlSf, datInfo, hqP, err)
+S16 rgDHMSndDatReq(cellCb, dlSf, datInfo, hqP, err)
RgCellCb *cellCb;
RgDlSf *dlSf;
RgTfuDatReqInfo *datInfo;
/* Data not received but ta needs to be sent. */
/* MUX TA and send it */
bldPdu.datReq = NULLP;
- bldPdu.reqType = EVENT_SLOT_IND_TO_MAC;
+ //bldPdu.reqType = EVENT_SLOT_IND_TO_MAC;
bldPdu.schdTbSz = hqP->tbInfo[i].tbSz;
bldPdu.ta = hqP->tbInfo[i].schdTa;
#ifdef LTE_ADV
hqP->tbInfo[i].timingInfo.slot, hqP->procId,
hqP->tbInfo[i].pdcch.rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
else
#ifdef LTEMAC_RGU_PAD
/* Data not received from RLC. Padding at MAC */
bldPdu.datReq = NULLP;
- bldPdu.reqType = EVENT_SLOT_IND_TO_MAC;
+ //bldPdu.reqType = EVENT_SLOT_IND_TO_MAC;
bldPdu.schdTbSz = hqP->tbInfo[i].tbSz;
bldPdu.ta = hqP->tbInfo[i].schdTa;
#ifdef LTE_ADV
hqP->tbInfo[i].timingInfo.slot, hqP->procId,
hqP->tbInfo[i].pdcch.rnti);
- RETVALUE(RFAILED);
+ return RFAILED;
}
#else
/*Padding is not done so data for this UE will not be
rgDHMRlsHqProcTB(cellCb, hqP, 2);
}
- RETVALUE(ROK);
+ return ROK;
}
if (rgGetEventMem(inst,(Ptr *)&datReq, sizeof(TfuDatReqPduInfo),
&(datInfo->memCp)) != ROK)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
/* Fill the TFU Dat Req with information from Harq Proc */
cmLListAdd2Tail(&datInfo->pdus, &(datReq->lnk));
datReq->lnk.node = (PTR)datReq;
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMSndDatReq */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDHMHndlDedDatReq
+S16 rgDHMHndlDedDatReq
(
Inst inst,
RgDlHqProcCb *hqProc,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMHndlDedDatReq(inst,hqProc, datReq, dlSf, err)
+S16 rgDHMHndlDedDatReq(inst,hqProc, datReq, dlSf, err)
Inst inst;
RgDlHqProcCb *hqProc;
RgRguDDatReqPerUe *datReq;
}
rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(i=0;i<datReq->nmbOfTbs;i++)
rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
printf("\nrgDHMHndlDedDatReq:: hqP %p \n", (Void *)hqProc);
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
#ifndef L2_OPTMZ
}
rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
}
- RETVALUE(RFAILED);
+ return RFAILED;
}
/*
SFndLenMsg(hqProc->tbInfo[i].tb, &len);
*/
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMHndlDedDatReq */
/**
* -# RFAILED
**/
#ifdef ANSI
-PUBLIC S16 rgDHMHndlCmnDatReq
+S16 rgDHMHndlCmnDatReq
(
Inst inst,
RgDlHqProcCb *hqProc,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMHndlCmnDatReq(inst,hqProc, datReq, err)
+S16 rgDHMHndlCmnDatReq(inst,hqProc, datReq, err)
Inst inst;
RgDlHqProcCb *hqProc;
RgRguCmnDatReq *datReq;
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_HARQ);
rgLMMStaInd(inst,LCM_CATEGORY_PROTOCOL, LCM_EVENT_UI_INV_EVT,
LRG_CAUSE_HQ_PROC_BUSY, &dgn);
- RETVALUE(RFAILED);
+ return RFAILED;
}
bldPdu.datReq = datReq;
hqProc->tbInfo[0].pdcch.rnti);
RG_FREE_MSG(datReq->pdu);
- RETVALUE(RFAILED);
+ return RFAILED;
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMHndlCmnDatReq */
/**
**/
RgUeCb *gUe =NULLP;
#ifdef ANSI
-PUBLIC S16 rgDHMSndConsolidatedStaInd
+S16 rgDHMSndConsolidatedStaInd
(
RgCellCb *cell,
RgInfUeInfo *ueInfo,
RgErrInfo *err
)
#else
-PUBLIC S16 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err)
+S16 rgDHMSndConsolidatedStaInd(cell, ueInfo, timingInfo, err)
RgCellCb *cell;
RgInfUeInfo *ueInfo;
CmLteTimingInfo timingInfo;
{
err->errType = RGERR_DHM_SND_STA_IND;
err->errCause = RG_DHM_MEM_ALLOC_FAIL;
- RETVALUE(RFAILED);
+ return RFAILED;
}
}
err->errType = RGERR_DHM_SND_STA_IND;
err->errCause = RG_DHM_MEM_ALLOC_FAIL;
/* Need to return as memory allocation will fail for other UEs also*/
- RETVALUE(RFAILED);
+ return RFAILED;
}
dStaInd[rguDlSpId]->nmbOfUeGrantPerTti = 0;
rguDlSap[rguDlSpId] = ue->rguDlSap;
}
}
- RETVALUE(ROK);
+ return ROK;
} /* rgDHMSndConsolidatedStaInd */
*
**/
#ifdef ANSI
-PUBLIC S16 rgDHMFreeHqProcTB
+S16 rgDHMFreeHqProcTB
(
RgDlHqProcCb *hqP,
U8 tbIndex
)
#else
-PUBLIC S16 rgDHMFreeHqProcTB(hqP, tbIndex)
+S16 rgDHMFreeHqProcTB(hqP, tbIndex)
RgDlHqProcCb *hqP;
U8 tbIndex;
#endif
if((tbIndex > RG_MAX_TB_PER_UE) ||
(tbIndex == 0))
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
tb = &(hqP->tbInfo[tbIndex-1].tb);
}
hqP->tbInfo[tbIndex-1].sfLnkInfo[idx].sf = NULLP;
}
- RETVALUE(ROK);
+ return ROK;
}
#endif
*
**/
#ifdef ANSI
-PUBLIC Void rgDHMFreeUe
+Void rgDHMFreeUe
(
Inst inst,
RgDlHqEnt *hqE
)
#else
-PUBLIC Void rgDHMFreeUe(inst,hqE)
+Void rgDHMFreeUe(inst,hqE)
Inst inst;
RgDlHqEnt *hqE;
#endif
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRstHqEntReq
+S16 RgSchMacRstHqEntReq
(
Pst* pst,
RgInfResetHqEnt* hqEntInfo
)
#else
-PUBLIC S16 RgSchMacRstHqEntReq(pst, hqEntInfo)
+S16 RgSchMacRstHqEntReq(pst, hqEntInfo)
Pst* pst;
RgInfResetHqEnt* hqEntInfo;
#endif
{
RGDBGERRNEW(inst,(rgPBuf(inst), "For user [%d]Cell does not exist %d\n",
hqEntInfo->crnti,hqEntInfo->cellId));
- RETVALUE(RFAILED);
+ return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, hqEntInfo->crnti)) == NULLP)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE does not exist for this hqEntInfo\n",
hqEntInfo->crnti));
- RETVALUE(RFAILED);
+ return RFAILED;
}
rgDHMUeReset(cell, &ue->dl.hqEnt);
- RETVALUE(ROK);
+ return ROK;
}
U32 gSaveVal;
\f
* -# ROK
**/
#ifdef ANSI
-PUBLIC S16 RgSchMacRlsHqReq
+S16 RgSchMacRlsHqReq
(
Pst *pst,
RgInfRlsHqInfo *rlshqUeInfo
)
#else
-PUBLIC S16 RgSchMacRlsHqReq(pst, rlshqUeInfo)
+S16 RgSchMacRlsHqReq(pst, rlshqUeInfo)
Pst *pst;
RgInfRlsHqInfo *rlshqUeInfo;
#endif
if(NULLP == rlshqUeInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
if((cell == NULLP)
RLOG_ARG0(L_ERROR,DBG_CELLID,rlshqUeInfo->cellId,
"No cellCb found with cellId");
- RETVALUE(RFAILED);
+ return RFAILED;
}
if(NULLP == rlshqUeInfo->ueHqInfo)
{
- RETVALUE(RFAILED);
+ return RFAILED;
}
for(idx1 = 0; idx1 < rlshqUeInfo->numUes; idx1++)
/*starting Task*/
SStopTask(startTime,PID_MAC_AM_HARQ_RLS);
- RETVALUE(ROK);
+ return ROK;
} /* end of RgSchMacRlsHqReq */
Code Review / o-du / l2.git / blobdiff