@brief MAC Multiplexing API.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_FILE_ID=229;
-static int RLOG_MODULE_ID=4096;
/* header include files -- defines (.h) */
#include "common_def.h"
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static S16 rgMUXAddCes
(
Inst inst,
Buffer *ceBuf,
RgErrInfo *err
)
-#else
-static S16 rgMUXAddCes(inst,pdu, ceShdrBuf, ceBuf, err)
-Inst inst;
-RgBldPduInfo *pdu;
-Buffer *ceBuf;
-RgErrInfo *err;
-#endif
{
S16 ret;
RgMUXSubHdr subHdr;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
- RLOG0(L_ERROR, "Muxing of Contention Resolution CE sub-header is failed");
+ DU_LOG("\nERROR --> MAC : Muxing of Contention Resolution CE sub-header is failed");
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
- RLOG0(L_ERROR, "Muxing of Contention Resolution CE is failed")
+ DU_LOG("\nERROR --> MAC : Muxing of Contention Resolution CE is failed");
return RFAILED;
}
pdu->schdTbSz -= RG_CRES_ELM_LEN;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
- RLOG0(L_ERROR, "Muxing of TA CE sub-hdr is failed")
+ DU_LOG("\nERROR --> MAC : Muxing of TA CE sub-hdr is failed");
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
- RLOG0(L_ERROR, "Muxing of TA CE is failed")
+ DU_LOG("\nERROR --> MAC : Muxing of TA CE is failed");
return RFAILED;
}
pdu->schdTbSz -= RG_TA_ELM_LEN;
- RLOG1(L_DEBUG,"TA muxed by MAC: %u", pdu->ta.val);
+ DU_LOG("\nDEBUG --> MAC : TA muxed by MAC: %u", pdu->ta.val);
}
}
#ifdef LTE_ADV
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
- RLOG0(L_ERROR, "Muxing of SCELL Activation CE sub-hdr is failed")
+ DU_LOG("\nERROR --> MAC : Muxing of SCELL Activation CE sub-hdr is failed")
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
- RLOG0(L_ERROR, "Muxing of SCELL Activation CE is failed")
+ DU_LOG("\nERROR --> MAC : Muxing of SCELL Activation CE is failed")
return RFAILED;
}
pdu->schdTbSz -= RG_SCELL_CE_ELM_LEN;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static S16 rgMUXInsSdu
(
Inst inst,
Buffer *sduBuf,
RgErrInfo *err
)
-#else
-static S16 rgMUXInsSdu(inst,schdTbSz, lcId, sdu, sduBuf, err)
-Inst inst;
-MsgLen *schdTbSz;
-uint8_t lcId;
-Buffer *sdu;
-Buffer *sduBuf;
-RgErrInfo *err;
-#endif
{
S16 ret;
MsgLen msgLen = 0;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_SDUHDR_FAIL;
- RLOG1(L_ERROR, "RGERR_MUX_BLD_SDUHDR_FAIL for LCID:%d",lcId);
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_SDUHDR_FAIL for LCID:%d",lcId);
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_SDU_FAIL;
- RLOG1(L_ERROR, "RGERR_MUX_BLD_SDU_FAIL for LCID:%d",lcId);
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_SDU_FAIL for LCID:%d",lcId);
return RFAILED;
}
else
{
/* This Sub-PDU can not be accodmodated at all */
- RLOG4(L_ERROR, "Failed lcId %u, elmTotLen %d lenBytes %d LCID:%d",
+ DU_LOG("\nERROR --> MAC : Failed lcId %u, elmTotLen %d lenBytes %d LCID:%d",
lcId, ((S16)elmTotLen), lenBytes,lcId);
- RLOG3(L_ERROR, "msglen %d schdTbSz %d LCID:%d",
+ DU_LOG("\nERROR --> MAC : msglen %d schdTbSz %d LCID:%d",
((S16)msgLen), ((S16)*schdTbSz),lcId);
return RFAILED;
}
#ifdef L2_OPTMZ
uint32_t padSize = 0;
#endif
-#ifdef ANSI
S16 rgMUXAddPadd
(
Inst inst,
Bool isRar,
RgErrInfo *err
)
-#else
-S16 rgMUXAddPadd(inst,schdTbSz, sduBuf, isRar, err)
-Inst inst;
-MsgLen *schdTbSz;
-Buffer *sduBuf;
-Bool isRar;
-RgErrInfo *err;
-#endif
{
S16 ret = ROK;
Buffer *padBuf = NULLP;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PADHDR_FAIL;
- RLOG0(L_ERROR, "RGERR_MUX_BLD_PADHDR_FAIL");
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_PADHDR_FAIL");
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
- RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_PAD_FAIL");
return RFAILED;
}
*schdTbSz = 0;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
- RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_PAD_FAIL");
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
- RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_PAD_FAIL");
return RFAILED;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static S16 rgMUXAddSdus
(
Inst inst,
Buffer *sduBuf,
RgErrInfo *err
)
-#else
-static S16 rgMUXAddSdus(inst,pdu, sduBuf, err)
-Inst inst;
-RgBldPduInfo *pdu;
-Buffer *sduBuf;
-RgErrInfo *err;
-#endif
{
RgRguDDatReqPerUe *dDatReq;
RgRguCmnDatReq *cDatReq;
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sduBuf, err) != ROK)
{
- RLOG1(L_ERROR, "FAILED for LCID:%d",datReqTb->lchData[idx1].lcId);
+ DU_LOG("\nERROR --> MAC : FAILED for LCID:%d",datReqTb->lchData[idx1].lcId);
return RFAILED;
}
}
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sduBuf, err) != ROK)
{
- RLOG2(L_ERROR, "FAILED TB Size %d LCID:%d",
+ DU_LOG("\nERROR --> MAC : FAILED TB Size %d LCID:%d",
((S16)pdu->schdTbSz),datReqTb->lchData[idx1].lcId);
return RFAILED;
}
} /* End of switch(reqType) */
if(rgMUXAddPadd(inst,&pdu->schdTbSz, sduBuf, FALSE, err) != ROK)
{
- RLOG1(L_ERROR, "FAILED for TB Size:%d",(S16)pdu->schdTbSz);
+ DU_LOG("\nERROR --> MAC : FAILED for TB Size:%d",(S16)pdu->schdTbSz);
return RFAILED;
}
return ROK;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgMUXBldPdu
(
Inst inst,
Buffer **txPdu,
RgErrInfo *err
)
-#else
-S16 rgMUXBldPdu(inst, pdu, txPdu, err)
-Inst inst;
-RgBldPduInfo *pdu;
-Buffer **txPdu;
-RgErrInfo *err;
-#endif
{
Buffer *mBuf = NULLP;
/* Buffer couldnt get allocated. Return a failure */
err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
err->errType = RGERR_MUX_BLD_PDU;
- RLOG1(L_FATAL, "Memory allocation failed during MUXing of MAC TB: MacInst %d", inst);
+ DU_LOG("\nERROR --> MAC : Memory allocation failed during MUXing of MAC TB: MacInst %d", inst);
return RFAILED;
}
{
RG_FREE_MSG(mBuf);
err->errType = RGERR_MUX_BLD_PDU;
- RLOG1(L_ERROR, "Failed to Multiplex MAC CEs: MacInst %d", inst);
+ DU_LOG("\nERROR --> MAC : Failed to Multiplex MAC CEs: MacInst %d", inst);
return RFAILED;
}
{
RG_FREE_MSG(mBuf);
err->errType = RGERR_MUX_BLD_PDU;
- RLOG1(L_ERROR, "FAILED to Multiplex MAC SDU: MacInst %d", inst);
+ DU_LOG("\nERROR --> MAC : FAILED to Multiplex MAC SDU: MacInst %d", inst);
return RFAILED;
}
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
static S16 rgMUXAddSdus
(
Inst inst,
RgTfuDatReqTbInfo *tb,
RgErrInfo *err
)
-#else
-static S16 rgMUXAddSdus(pdu, sHdrBuf, tb, err)
-Inst inst;
-RgBldPduInfo *pdu;
-Buffer *sHdrBuf;
-RgTfuDatReqTbInfo *tb;
-RgErrInfo *err;
-#endif
{
RgRguDDatReqPerUe *dDatReq;
RgRguCmnDatReq *cDatReq;
= cDatReq->pdu;
tb->lchInfo[tb->numLch].numPdu++;
tb->numLch++;
- RLOG3(L_INFO,"MSG4 is muxed numLch=%ld numPdu=%ld tbaddr =%p", tb->numLch,tb->lchInfo[tb->numLch-1].numPdu, (uint32_t)tb);
+ DU_LOG("\nINFO --> MAC : MSG4 is muxed numLch=%ld numPdu=%ld tbaddr =%p",\
+ tb->numLch,tb->lchInfo[tb->numLch-1].numPdu, (uint32_t)tb);
}
break;
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sHdrBuf, NULLP, err) != ROK)
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED\n"));
+ DU_LOG("\nERROR --> MAC : Failed to insert SDU in rgMUXAddSdus\n");
return RFAILED;
}
tmp = datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont;
if(NULL == tmp->b_rptr)
{
- RLOG0(L_INFO,"11111Its Null here only ");
+ DU_LOG("\nERROR --> MAC : rgMUXAddSdus failed in EVTRGUDDATREQ");
}
}
else
{
- RLOG0(L_INFO,"222222Its Null here only \n");
+ DU_LOG("\nERROR --> MAC : rgMUXAddSdus failed in EVTRGUDDATREQ");
}
pduIdx++;
//tb->lchInfo[tb->numLch].numPdu++;
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sHdrBuf, NULLP, err) != ROK)
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED TB Size %d\n",
- ((S16)pdu->schdTbSz)));
+ DU_LOG("\nERROR --> MAC : FAILED TB Size %d\n",
+ ((S16)pdu->schdTbSz));
return RFAILED;
}
/* L2 Optimization for mUe/Tti:Increment numPdu by 1
tmp = datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont;
if(NULL == tmp->b_rptr)
{
- RLOG0(L_INFO,"2212121Its Null here only \n");
+ DU_LOG("\nERROR --> MAC : rgMUXAddSdus failed in EVTRGUDDATREQ");
}
}
else
{
- RLOG0(L_INFO,"343343433ts Null here only \n");
+ DU_LOG("\nERROR --> MAC : rgMUXAddSdus failed in EVTRGUDDATREQ");
}
pduIdx++;
// tb->lchInfo[tb->numLch].numPdu++;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgMUXBldPdu
(
Inst inst,
RgTfuDatReqTbInfo *tb,
RgErrInfo *err
)
-#else
-S16 rgMUXBldPdu(inst, pdu, tb, err)
-Inst inst;
-RgBldPduInfo *pdu;
-RgTfuDatReqTbInfo *tb;
-RgErrInfo *err;
-#endif
{
Buffer *mBuf1; /* MAC hearder */
Buffer *mBuf2; /* MAC CEs */
if(rgMUXAddCes(inst, pdu, mBuf1, mBuf2, err) != ROK)
{
/* Reset rPtr and wPtr to the base of data buffer(db_base)*/
- RLOG0(L_INFO,"rgMUXBldPdu: rgMUXAddCes is Failed \n");
+ DU_LOG("\nERROR --> MAC : rgMUXBldPdu: rgMUXAddCes is Failed \n");
RG_FREE_TB(tb);
err->errType = RGERR_MUX_BLD_PDU;
//RGDBGERRNEW((rgPBuf, "FAILED"));
{
/*TODO:MP Reset rPtr and wPtr to the base of data buffer(db_base)
* Reset numLch and numPdu to zero and set MAC SDU buf to NULLP */
- RLOG0(L_INFO, "rgMUXBldPdu: rgMUXAddSdus is Failed \n");
+ DU_LOG("\nERROR --> MAC : rgMUXBldPdu: rgMUXAddSdus is Failed \n");
RG_FREE_TB(tb);
err->errType = RGERR_MUX_BLD_PDU;
* -# ROK
* -# RFAILED
**/
-#ifdef ANSI
S16 rgMUXBldRarPdu
(
RgCellCb *cell,
Buffer **txPdu,
RgErrInfo *err
)
-#else
-S16 rgMUXBldRarPdu(cell, alloc, txPdu, err)
-RgCellCb *cell;
-RgInfRaRntiInfo *alloc;
-Buffer **txPdu;
-RgErrInfo *err;
-#endif
{
Buffer *datBuf = NULLP;
S16 ret;
{
/* Buffer couldnt get allocated. Return a failure */
err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "FAILED to getMsg");
+ DU_LOG("\nERROR --> MAC : FAILED to getMsg");
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_BI_FAIL;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_BI_FAIL");
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_BI_FAIL");
RG_FREE_MSG(datBuf);
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_RAPIDHDR_FAIL;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPIDHDR_FAIL");
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_RAPIDHDR_FAIL");
RG_FREE_MSG(datBuf);
return RFAILED;
}
data[4] = (alloc->crntiInfo[idx].tmpCrnti) >> 8;
data[5] = (uint8_t) (alloc->crntiInfo[idx].tmpCrnti);
- RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
- "Rar,Rapid=%d, Temp CRNTI:%d",
+ DU_LOG("\nDEBUG --> MAC : Rar,Rapid=%d, Temp CRNTI:%d",
alloc->crntiInfo[idx].rapId,
alloc->crntiInfo[idx].tmpCrnti);
MS_BUF_ADD_ALLOC_CALLER();
if(SAddPstMsgMult(&data[0], RG_RAR_ELEM_LEN, datBuf) != ROK)
{
err->errCause = RGERR_MUX_BLD_RAPID_FAIL;
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPID_FAIL");
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_RAPID_FAIL");
RG_FREE_MSG(datBuf);
return RFAILED;
}
if(rgMUXAddPadd(inst,&schdTbSz, datBuf, TRUE, err) != ROK)
{
RG_FREE_MSG(datBuf);
- RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"FAILED to mux add padding");
+ DU_LOG("\nERROR --> MAC : FAILED to mux add padding");
return RFAILED;
}
* File : rg_mux.c
*
**********************************************************/
-#ifdef ANSI
static Void rgMUXGet20bitRarGrnt
(
uint8_t ulBw,
RgInfRarUlGrnt *msg3Grnt,
uint8_t *grnt
)
-#else
-static Void rgMUXGet20bitRarGrnt(ulBw, msg3Grnt, grnt)
-uint8_t ulBw;
-RgInfRarUlGrnt *msg3Grnt;
-uint8_t *grnt;
-#endif
{
uint16_t riv = rgMUXCalcRiv(ulBw, msg3Grnt->rbStart, msg3Grnt->numRb);
* File : rg_mux.c
*
**********************************************************/
-#ifdef ANSI
uint16_t rgMUXCalcRiv
(
uint8_t bw,
uint8_t rbStart,
uint8_t numRb
)
-#else
-uint16_t rgMUXCalcRiv(bw, rbStart, numRb)
-uint8_t bw;
-uint8_t rbStart;
-uint8_t numRb;
-#endif
{
uint8_t numRbMinus1 = numRb - 1;
uint16_t riv;