Change-Id: I5077ab04e265f8bde386449031e9da689249b278
Signed-off-by: sphoorthi <sphoorthi.dayanand@radisys.com>
ssGetDBufOfSize(mInfo->region,_size, &_padBuf); \
if (_padBuf == NULLP) \
{ \
ssGetDBufOfSize(mInfo->region,_size, &_padBuf); \
if (_padBuf == NULLP) \
{ \
- RLOG0(L_ERROR, "RGERR_MUX_BLD_CEHDR_FAIL");\
+ DU_LOG("\nERROR --> MAC : RGERR_MUX_BLD_CEHDR_FAIL");\
return RFAILED;\
} \
if (mInfo->endptr == NULLP) { \
return RFAILED;\
} \
if (mInfo->endptr == NULLP) { \
#define RG_NULL_CHECK(_inst, _ptr ) \
if((_ptr) == NULLP) \
{ \
#define RG_NULL_CHECK(_inst, _ptr ) \
if((_ptr) == NULLP) \
{ \
- RGDBGERRNEW(_inst, (rgPBuf(_inst),"Null Pointer detected"));\
+ DU_LOG("\nERROR --> MAC : Null Pointer detected");\
SExit();\
}
#define RG_ARRAY_BOUND_CHECK(_inst, _array, _idxVal) \
if((_idxVal) >= (sizeof(_array)/sizeof(_array[0]))) \
{ \
SExit();\
}
#define RG_ARRAY_BOUND_CHECK(_inst, _array, _idxVal) \
if((_idxVal) >= (sizeof(_array)/sizeof(_array[0]))) \
{ \
- RGDBGERRNEW(_inst, (rgPBuf(_inst),"Array Bound Check Failed"));\
+ DU_LOG("\nERROR --> MAC : Array Bound Check Failed");\
@brief MAC Multiplexing API.
*/
@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"
/* header include files -- defines (.h) */
#include "common_def.h"
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
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");
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
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;
return RFAILED;
}
pdu->schdTbSz -= RG_CRES_ELM_LEN;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
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");
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
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;
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);
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
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")
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_CE_FAIL;
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;
return RFAILED;
}
pdu->schdTbSz -= RG_SCELL_CE_ELM_LEN;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_SDUHDR_FAIL;
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);
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_SDU_FAIL;
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);
else
{
/* This Sub-PDU can not be accodmodated at all */
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);
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;
}
((S16)msgLen), ((S16)*schdTbSz),lcId);
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PADHDR_FAIL;
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");
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
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;
return RFAILED;
}
*schdTbSz = 0;
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
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");
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_PAD_FAIL;
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");
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sduBuf, err) != ROK)
{
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);
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sduBuf, err) != ROK)
{
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;
}
((S16)pdu->schdTbSz),datReqTb->lchData[idx1].lcId);
return RFAILED;
}
} /* End of switch(reqType) */
if(rgMUXAddPadd(inst,&pdu->schdTbSz, sduBuf, FALSE, err) != ROK)
{
} /* 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;
return RFAILED;
}
return ROK;
/* Buffer couldnt get allocated. Return a failure */
err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
err->errType = RGERR_MUX_BLD_PDU;
/* 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);
{
RG_FREE_MSG(mBuf);
err->errType = RGERR_MUX_BLD_PDU;
{
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);
{
RG_FREE_MSG(mBuf);
err->errType = RGERR_MUX_BLD_PDU;
{
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);
= cDatReq->pdu;
tb->lchInfo[tb->numLch].numPdu++;
tb->numLch++;
= 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);
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sHdrBuf, NULLP, err) != ROK)
{
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");
tmp = datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont;
if(NULL == tmp->b_rptr)
{
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");
- RLOG0(L_INFO,"222222Its Null here only \n");
+ DU_LOG("\nERROR --> MAC : rgMUXAddSdus failed in EVTRGUDDATREQ");
}
pduIdx++;
//tb->lchInfo[tb->numLch].numPdu++;
}
pduIdx++;
//tb->lchInfo[tb->numLch].numPdu++;
datReqTb->lchData[idx1].pdu.mBuf[idx2],
sHdrBuf, NULLP, err) != ROK)
{
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
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)
{
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");
- RLOG0(L_INFO,"343343433ts Null here only \n");
+ DU_LOG("\nERROR --> MAC : rgMUXAddSdus failed in EVTRGUDDATREQ");
}
pduIdx++;
// tb->lchInfo[tb->numLch].numPdu++;
}
pduIdx++;
// tb->lchInfo[tb->numLch].numPdu++;
if(rgMUXAddCes(inst, pdu, mBuf1, mBuf2, err) != ROK)
{
/* Reset rPtr and wPtr to the base of data buffer(db_base)*/
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"));
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 */
{
/*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;
RG_FREE_TB(tb);
err->errType = RGERR_MUX_BLD_PDU;
{
/* Buffer couldnt get allocated. Return a failure */
err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
{
/* 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");
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_BI_FAIL;
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;
}
RG_FREE_MSG(datBuf);
return RFAILED;
}
if(ret != ROK)
{
err->errCause = RGERR_MUX_BLD_RAPIDHDR_FAIL;
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;
}
RG_FREE_MSG(datBuf);
return RFAILED;
}
data[4] = (alloc->crntiInfo[idx].tmpCrnti) >> 8;
data[5] = (uint8_t) (alloc->crntiInfo[idx].tmpCrnti);
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;
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;
}
RG_FREE_MSG(datBuf);
return RFAILED;
}
if(rgMUXAddPadd(inst,&schdTbSz, datBuf, TRUE, err) != ROK)
{
RG_FREE_MSG(datBuf);
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");
manages Pst and Sap related information for upper interface APIs.
*/
manages Pst and Sap related information for upper interface APIs.
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_MODULE_ID=4096;
-static int RLOG_FILE_ID=178;
/* header include files -- defines (.h) */
/* header include files -- defines (.h) */
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_NOT_CFG: /* SAP Not configured */
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_NOT_CFG: /* SAP Not configured */
- RGDBGINFO(inst,(rgPBuf(inst), "SAP Not Configured\n"));
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
LCM_CAUSE_INV_SAP, &dgn);
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
LCM_CAUSE_INV_SAP, &dgn);
- RLOG0(L_DEBUG,"SAP Not Configured");
+ DU_LOG("\nDEBUG --> MAC : SAP Not Configured");
ret = RgUiRguBndCfm(&tmpPst, suId, CM_BND_NOK);
break;
case LRG_UNBND: /* SAP is not bound */
ret = RgUiRguBndCfm(&tmpPst, suId, CM_BND_NOK);
break;
case LRG_UNBND: /* SAP is not bound */
- RLOG0(L_DEBUG,"SAP Not yet bound");
+ DU_LOG("\nDEBUG --> MAC : SAP Not yet bound");
rgCb[inst].rguSap[spId].sapSta.sapState = LRG_BND;
rgCb[inst].rguSap[spId].sapCfg.suId = suId;
/* Send Bind Confirm with status as SUCCESS */
rgCb[inst].rguSap[spId].sapSta.sapState = LRG_BND;
rgCb[inst].rguSap[spId].sapCfg.suId = suId;
/* Send Bind Confirm with status as SUCCESS */
LCM_CAUSE_UNKNOWN, &dgn);
break;
case LRG_BND: /* SAP is already bound*/
LCM_CAUSE_UNKNOWN, &dgn);
break;
case LRG_BND: /* SAP is already bound*/
- RLOG0(L_DEBUG,"SAP already bound");
+ DU_LOG("\nDEBUG --> MAC : SAP already bound");
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_OK);
break;
default: /* Should Never Enter here */
#if (ERRCLASS & ERRCLS_ADD_RES)
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_OK);
break;
default: /* Should Never Enter here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- RGLOGERROR(inst,ERRCLS_INT_PAR, ERG008, (ErrVal)rgCb[inst].rguSap[spId].sapSta.sapState,
- "Invalid SAP State:RgUiRguBndReq failed\n");
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:RgUiRguBndReq failed\n");
#endif
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
#endif
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RGLOGERROR(inst,ERRCLS_INT_PAR, ERG009, (ErrVal)rgCb[inst].rguSap[spId].sapCfg.spId,
- "Invalid SAP Id:RgUiRguBndReq failed\n");
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:RgUiRguBndReq failed\n");
#endif
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
#endif
/*T2K - Passing spId as it is required to access the SAP CB*/
ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
switch(rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is already bound*/
switch(rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is already bound*/
- RLOG0(L_DEBUG,"SAP already bound");
+ DU_LOG("\nDEBUG --> MAC : SAP already bound");
/* setting SAP state to UN BOUND */
rgCb[inst].rguSap[spId].sapSta.sapState = LRG_UNBND;
break;
default:
#if (ERRCLASS & ERRCLS_ADD_RES)
/* setting SAP state to UN BOUND */
rgCb[inst].rguSap[spId].sapSta.sapState = LRG_UNBND;
break;
default:
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguUbndReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiRguUbndReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RGLOGERROR(inst,ERRCLS_INT_PAR, ERG011, (ErrVal)rgCb[inst].rguSap[spId].sapCfg.spId,
- "Invalid SAP Id:RgUiRguUbndReq failed\n");
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:RgUiRguUbndReq failed\n");
- RLOG0(L_ERROR,"RgUiRguBndCfm Failed ");
+ DU_LOG("\nERROR --> MAC : RgUiRguBndCfm Failed ");
return (ret);
}
return (ret);
return (ret);
}
return (ret);
#ifndef NO_ERRCLS
if (datReq == NULLP)
{
#ifndef NO_ERRCLS
if (datReq == NULLP)
{
- RLOG0(L_ERROR,"Input Message Buffer is NULL");
+ DU_LOG("\nERROR --> MAC : Input Message Buffer is NULL");
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nDEBUG --> MAC : SAP is already bound");
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguDDatReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiRguDDatReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
#ifndef L2_OPTMZ
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
#ifndef L2_OPTMZ
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RGLOGERROR(inst,ERRCLS_INT_PAR, ERG013, (ErrVal)spId,
- "Invalid SAP Id:RgUiRguDDatReq failed\n");
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:RgUiRguDDatReq failed\n");
#endif
#ifndef L2_OPTMZ
for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
#endif
#ifndef L2_OPTMZ
for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
#ifndef NO_ERRCLS
if (datReq == NULLP)
{
#ifndef NO_ERRCLS
if (datReq == NULLP)
{
- RLOG0(L_ERROR,"Input Message Buffer is NULL");
+ DU_LOG("\nERROR --> MAC : Input Message Buffer is NULL");
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nERROR --> MAC : SAP is already bound");
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguCDatReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiRguCDatReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
return RFAILED;
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
return RFAILED;
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguCDatReq failed ",spId);
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiRguCDatReq failed ",spId);
ret = rgROMDedStaRsp(inst,staRsp);
if (ret != ROK)
{
ret = rgROMDedStaRsp(inst,staRsp);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,staRsp->cellId,
- "Processing Of Status Response Failed");
+ DU_LOG("\nERROR --> MAC : Processing Of Status Response Failed");
#ifndef NO_ERRCLS
if (staRsp == NULLP)
{
#ifndef NO_ERRCLS
if (staRsp == NULLP)
{
- RLOG0(L_ERROR,"Input Response Buffer is NULL");
+ DU_LOG("\nERROR --> MAC : Input Response Buffer is NULL");
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nDEBUG --> MAC : SAP is already bound");
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguCStaRsp failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiRguCStaRsp failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
return RFAILED;
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
return RFAILED;
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguCStaRsp failed",spId);
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiRguCStaRsp failed",spId);
ret = rgROMCmnStaRsp(inst,staRsp);
if (ret != ROK)
{
ret = rgROMCmnStaRsp(inst,staRsp);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,staRsp->cellId,"Processing Of Status Response Failed");
+ DU_LOG("\nERROR --> MAC : Processing Of Status Response Failed");
#ifndef NO_ERRCLS
if (measReq == NULLP)
{
#ifndef NO_ERRCLS
if (measReq == NULLP)
{
- RLOG0(L_ERROR,"Input Response Buffer is NULL");
+ DU_LOG("\nERROR --> MAC : Input Response Buffer is NULL");
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
switch (rgCb[inst].rguSap[spId].sapSta.sapState)
{
case LRG_BND: /* SAP is bound */
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nERROR --> MAC : SAP is already bound");
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiRguL2MUlThrpMeasReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiRguL2MUlThrpMeasReq failed",
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
return RFAILED;
rgCb[inst].rguSap[spId].sapSta.sapState);
#endif
return RFAILED;
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiRguL2MUlThrpMeasReq failed",spId);
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiRguL2MUlThrpMeasReq failed",spId);
ret = rgROML2MUlThrpMeasReq(inst,measReq);
if (ret != ROK)
{
ret = rgROML2MUlThrpMeasReq(inst,measReq);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,measReq->cellId,"Processing Of Meas Request Failed");
+ DU_LOG("\nERROR --> MAC : Processing Of Meas Request Failed");
}
SPutStaticBuffer(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo) , SS_SHARABLE_MEMORY);
}
SPutStaticBuffer(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo) , SS_SHARABLE_MEMORY);
- RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndDedStaInd(): staInd = %p;\n", (void *)staInd));
+ DU_LOG("\nINFO --> MAC : rgUIMSndDedStaInd(): staInd = %p;\n", (void *)staInd);
ret = RgUiRguDStaInd(&(rguSap->sapCfg.sapPst), rguSap->sapCfg.suId,
staInd);
if (ret != ROK)
{
ret = RgUiRguDStaInd(&(rguSap->sapCfg.sapPst), rguSap->sapCfg.suId,
staInd);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"RgUiRguDStaInd Failed");
+ DU_LOG("\nERROR --> MAC : RgUiRguDStaInd Failed");
return (ret);
}
return (ret);
return (ret);
}
return (ret);
staInd);
if (ret != ROK)
{
staInd);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"RgUiRguCStaInd Failed");
+ DU_LOG("\nERROR --> MAC : RgUiRguCStaInd Failed");
return (ret);
}
return (ret);
return (ret);
}
return (ret);
datInd);
if (ret != ROK)
{
datInd);
if (ret != ROK)
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"RgUiRguDdatInd Failed");
+ DU_LOG("\nERROR --> MAC : RgUiRguDdatInd Failed");
- RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndCmnDatInd(): staInd = %p;\n", (void *)datInd));
+ DU_LOG("\nDEBUG --> MAC : rgUIMSndCmnDatInd(): staInd = %p;\n", (void *)datInd);
rguUlSap->sapSts.numPduTxmit++;
rguUlSap->sapSts.numPduTxmit++;
- RGDBGPRM(inst,(rgPBuf(inst),"rgUIMSndCmnDatInd suId = %d\n", rguUlSap->sapCfg.suId));
+ DU_LOG("\nDEBUG --> MAC : rgUIMSndCmnDatInd suId = %d\n", rguUlSap->sapCfg.suId);
ret = RgUiRguCDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId,
datInd);
if (ret != ROK)
{
ret = RgUiRguCDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId,
datInd);
if (ret != ROK)
{
- RGDBGERRNEW(inst,(rgPBuf(inst),"RgUiRguCDatInd Failed\n"));
- RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"RgUiRguCDatInd Failed");
+ DU_LOG("\nERROR --> MAC : RgUiRguCDatInd Failed");
return (ret);
}
return (ret);
return (ret);
}
return (ret);
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
LCM_CAUSE_INV_SAP, &dgn);
rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
LCM_CAUSE_INV_SAP, &dgn);
- RLOG0(L_DEBUG,"SAP Not Configured");
+ DU_LOG("\nDEBUG --> MAC : SAP Not Configured");
ret = RgUiCrgBndCfm(&tmpPst, suId, CM_BND_NOK);
break;
case LRG_UNBND: /* SAP is not bound */
ret = RgUiCrgBndCfm(&tmpPst, suId, CM_BND_NOK);
break;
case LRG_UNBND: /* SAP is not bound */
- RLOG0(L_DEBUG,"SAP Not yet bound");
+ DU_LOG("\nERROR --> MAC : SAP Not yet bound");
rgCb[inst].crgSap.sapSta.sapState = LRG_BND;
rgCb[inst].crgSap.sapCfg.suId = suId;
rgCb[inst].crgSap.sapSta.sapState = LRG_BND;
rgCb[inst].crgSap.sapCfg.suId = suId;
LCM_CAUSE_UNKNOWN, &dgn);
break;
case LRG_BND: /* SAP is already bound*/
LCM_CAUSE_UNKNOWN, &dgn);
break;
case LRG_BND: /* SAP is already bound*/
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nDEBUG --> MAC : SAP is already bound");
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_OK);
break;
default: /* Should Never Enter here */
#if (ERRCLASS & ERRCLS_ADD_RES)
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_OK);
break;
default: /* Should Never Enter here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiCrgBndReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiCrgBndReq failed",
rgCb[inst].crgSap.sapSta.sapState);
#endif
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
rgCb[inst].crgSap.sapSta.sapState);
#endif
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiCrgBndReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiCrgBndReq failed",
rgCb[inst].crgSap.sapCfg.spId);
#endif
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
rgCb[inst].crgSap.sapCfg.spId);
#endif
ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
{
case LRG_BND: /* SAP is already bound*/
/* setting SAP state to UN BOUND */
{
case LRG_BND: /* SAP is already bound*/
/* setting SAP state to UN BOUND */
- RLOG0(L_DEBUG, "SAP is already bound");
+ DU_LOG("\nDEBUG --> MAC : SAP is already bound");
rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
break;
default:
#if (ERRCLASS & ERRCLS_ADD_RES)
rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
break;
default:
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiCrgUbndReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiCrgUbndReq failed",
rgCb[inst].crgSap.sapSta.sapState);
#endif
return RFAILED;
rgCb[inst].crgSap.sapSta.sapState);
#endif
return RFAILED;
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiCrgUbndReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiCrgUbndReq failed",
rgCb[inst].crgSap.sapCfg.spId);
#endif
return RFAILED;
rgCb[inst].crgSap.sapCfg.spId);
#endif
return RFAILED;
if(RgUiCrgBndCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, status) != ROK)
{
if(RgUiCrgBndCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, status) != ROK)
{
- RLOG0(L_ERROR,"RgUiCrgBndCfm Failed ");
+ DU_LOG("\nERROR --> MAC : RgUiCrgBndCfm Failed ");
/* CrgCfgReqInfo Validation for NULLP */
if (cfgReqInfo == NULLP)
{
/* CrgCfgReqInfo Validation for NULLP */
if (cfgReqInfo == NULLP)
{
- RLOG0(L_ERROR,"Input Param crgReqInfo is NULL ");
+ DU_LOG("\nERROR --> MAC : Input Param crgReqInfo is NULL ");
rgUIMCrgCfgCfm(inst,transId, cfmStatus);
return RFAILED;
}
rgUIMCrgCfgCfm(inst,transId, cfmStatus);
return RFAILED;
}
switch(rgCb[inst].crgSap.sapSta.sapState)
{
case LRG_BND: /* SAP is already bound */
switch(rgCb[inst].crgSap.sapSta.sapState)
{
case LRG_BND: /* SAP is already bound */
- RLOG0(L_DEBUG,"SAP is already bound");
+ DU_LOG("\nDEBUG --> MAC : SAP is already bound");
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
break;
default: /* Should never reach here */
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP State:%d RgUiCrgCfgReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP State:%d RgUiCrgCfgReq failed",
rgCb[inst].crgSap.sapSta.sapState);
#endif
SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
rgCb[inst].crgSap.sapSta.sapState);
#endif
SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
else
{
#if (ERRCLASS & ERRCLS_ADD_RES)
- RLOG1(L_ERROR,"Invalid SAP Id:%d RgUiCrgCfgReq failed",
+ DU_LOG("\nERROR --> MAC : Invalid SAP Id:%d RgUiCrgCfgReq failed",
rgCb[inst].crgSap.sapCfg.spId);
#endif
SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
rgCb[inst].crgSap.sapCfg.spId);
#endif
SPutSBuf (pst->region, pst->pool, (Data *)cfgReqInfo,
cfgReqInfo = NULLP;
if (ret != ROK)
{
cfgReqInfo = NULLP;
if (ret != ROK)
{
- RLOG0(L_ERROR,"Configuration Request Handling Failed ");
+ DU_LOG("\nERROR --> MAC : Configuration Request Handling Failed ");
ret = RgUiCrgCfgCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, transId, status);
if (ret != ROK)
{
ret = RgUiCrgCfgCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, transId, status);
if (ret != ROK)
{
- RLOG0(L_ERROR,"RgUiCrgCfgCfm Failed ");
+ DU_LOG("\nERROR --> MAC : RgUiCrgCfgCfm Failed ");
@brief This file implements utility functions for LTE MAC
*/
@brief This file implements utility functions for LTE MAC
*/
-static const char* RLOG_MODULE_NAME="MAC";
-static int RLOG_MODULE_ID=4096;
-static int RLOG_FILE_ID=179;
/* header include files (.h) */
#include "common_def.h"
/* header include files (.h) */
#include "common_def.h"
/* Send an alarm to Layer Manager */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
/* Send an alarm to Layer Manager */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
- RGLOGERROR(inst,ERRCLS_DEBUG, ERG028, 0, "Unable to Allocate Buffer");
+ DU_LOG("\nERROR --> MAC : Unable to Allocate Buffer");
return RFAILED;
}
#ifndef ALIGN_64BIT
return RFAILED;
}
#ifndef ALIGN_64BIT
- RGDBGINFO(inst,(rgPBuf(inst), "SGetSBuf(Region (%d), Pool (%d), Size (%ld)), Data (0x%p))\n",
- rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData));
+ DU_LOG("\nDEBUG --> MAC : SGetSBuf(Region (%d), Pool (%d), Size (%ld)), Data (0x%p))\n",
+ rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData);
- RGDBGINFO(inst,(rgPBuf(inst), "SGetSBuf(Region (%d), Pool (%d), Size (%d)), Data (0x%p))\n",
- rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData));
+ DU_LOG("\nDEBUG --> MAC : SGetSBuf(Region (%d), Pool (%d), Size (%d)), Data (0x%p))\n",
+ rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData);
#endif
/* zero out the allocated memory */
#endif
/* zero out the allocated memory */
/* Send an alarm to Layer Manager */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
/* Send an alarm to Layer Manager */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
- RGLOGERROR(inst,ERRCLS_DEBUG, ERG028, 0, "Unable to Allocate Buffer");
+ DU_LOG("\nERROR --> MAC : Unable to Allocate Buffer");
- RGLOGERROR(inst,ERRCLS_DEBUG, ERG029, (ErrVal) 0, "rgFreeSBuf failed.\n");
+ DU_LOG("\nERROR --> MAC : rgFreeSBuf failed.\n");
/* Send an alarm to Layer Manager */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
/* Send an alarm to Layer Manager */
rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
- RGLOGERROR(inst,ERRCLS_DEBUG, ERG030, 0, "Unable to Allocate Buffer");
+ DU_LOG("\nERROR --> MAC : Unable to Allocate Buffer");
#if (ERRCLASS & ERRCLS_DEBUG)
if (memSize<= 0)
{
#if (ERRCLASS & ERRCLS_DEBUG)
if (memSize<= 0)
{
- RGLOGERROR(inst,ERRCLS_INT_PAR, ERG031, memSize,
- "rgAllocEventMem(): memSize invalid\n");
+ DU_LOG("\nERROR --> MAC : rgAllocEventMem(): memSize invalid\n");
return (RFAILED);
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
return (RFAILED);
}
#endif /* ERRCLASS & ERRCLS_DEBUG */
if(ROK != cmAllocEvnt(memSize, TFU_MAX_MEMBLK_SIZE, &sMem, memPtr))
#endif /* */
{
if(ROK != cmAllocEvnt(memSize, TFU_MAX_MEMBLK_SIZE, &sMem, memPtr))
#endif /* */
{
- RLOG0(L_ERROR,"cmAllocEvnt Failed");
+ DU_LOG("\nERROR --> MAC : cmAllocEvnt Failed");
(cell->cellId != lcgRegReq->cellId))
{
(cell->cellId != lcgRegReq->cellId))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcgRegReq->cellId,"Cell does not exist ");
+ DU_LOG("\nERROR --> MAC : Cell does not exist ");
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, lcgRegReq->crnti)) == NULLP)
{
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, lcgRegReq->crnti)) == NULLP)
{
- RLOG_ARG1(L_ERROR, DBG_CELLID,cell->cellId,"CRNTI:%d does not exist",
+ DU_LOG("\nERROR --> MAC : CRNTI:%d does not exist",
lcgRegReq->crnti);
return RFAILED;
}
lcgRegReq->crnti);
return RFAILED;
}
(cell->cellId != ulSpsResetInfo->cellId))
{
(cell->cellId != ulSpsResetInfo->cellId))
{
- RLOG_ARG0(L_ERROR, DBG_CELLID,ulSpsResetInfo->cellId,"Cell does not exist ");
+ DU_LOG("\nERROR --> MAC : Cell does not exist ");
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, ulSpsResetInfo->crnti)) == NULLP)
{
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, ulSpsResetInfo->crnti)) == NULLP)
{
- RLOG_ARG1(L_ERROR, DBG_CELLID,cell->cellId,"CRNTI:%d does not exist",
+ DU_LOG("\nERROR --> MAC : CRNTI:%d does not exist",
ulSpsResetInfo->crnti);
return RFAILED;
}
ulSpsResetInfo->crnti);
return RFAILED;
}
(cell->cellId != lcInfo->cellId))
{
(cell->cellId != lcInfo->cellId))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,lcInfo->cellId, "Cell does not exist ");
+ DU_LOG("\nERROR --> MAC : Cell does not exist ");
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, lcInfo->crnti)) == NULLP)
{
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, lcInfo->crnti)) == NULLP)
{
- RLOG_ARG1(L_ERROR, DBG_CELLID,cell->cellId,"CRNTI:%d does not exist",
+ DU_LOG("\nERROR --> MAC : CRNTI:%d does not exist",
lcInfo->crnti);
return RFAILED;
}
lcInfo->crnti);
return RFAILED;
}
/* Insert the UE into SPS UE List */
if (rgDBMInsSpsUeCb(cell, ue) == RFAILED)
{
/* Insert the UE into SPS UE List */
if (rgDBMInsSpsUeCb(cell, ue) == RFAILED)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "Ue insertion into SPS list failed SPS CRNTI:%d", ue->spsRnti);
+ DU_LOG("\nERROR --> MAC : Ue insertion into SPS list failed SPS CRNTI:%d", ue->spsRnti);
(cell->cellId != cellId))
{
(cell->cellId != cellId))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellId, "Cell does not exist ");
+ DU_LOG("\nERROR --> MAC : Cell does not exist ");
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, crnti)) == NULLP)
{
return RFAILED;
}
if ((ue = rgDBMGetUeCb(cell, crnti)) == NULLP)
{
- RLOG_ARG1(L_ERROR, DBG_CELLID,cellId,"CRNTI:%d Ue does not exist", crnti);
+ DU_LOG("\nERROR --> MAC : CRNTI:%d Ue does not exist", crnti);
newUe = rgDBMGetUeCbFromRachLst(cell, newRnti);
if ((ue == NULLP) || (newUe == NULLP))
{
newUe = rgDBMGetUeCbFromRachLst(cell, newRnti);
if ((ue == NULLP) || (newUe == NULLP))
{
- RLOG_ARG4(L_ERROR,DBG_CELLID,cell->cellId,
- "RNTI:%d Failed to get UECB[%lu:%lu] or NEW RNTI:%d",
+ DU_LOG("\nERROR --> MAC : RNTI:%d Failed to get UECB[%lu:%lu] or NEW RNTI:%d",
rnti, ((PTR)ue), ((PTR)newUe), newRnti);
return RFAILED;
}
#ifdef XEON_SPECIFIC_CHANGES
rnti, ((PTR)ue), ((PTR)newUe), newRnti);
return RFAILED;
}
#ifdef XEON_SPECIFIC_CHANGES
- CM_LOG_DEBUG(CM_LOG_ID_MAC, "MAC:UE[%d] id changed to %d\n", rnti, newRnti);
+ DU_LOG("\nDEBUG --> MAC : MAC:UE[%d] id changed to %d\n", rnti, newRnti);
#endif
rgDBMDelUeCb(cell, ue);
#endif
rgDBMDelUeCb(cell, ue);
if((cell == NULLP) ||
(cell->cellId != ueSCellCb->cellId))
{
if((cell == NULLP) ||
(cell->cellId != ueSCellCb->cellId))
{
- RGDBGERRNEW(inst, (rgPBuf(inst),
- "[%d]Sec Cell does not exit %d\n",
- ueSCellCb->ueId, ueSCellCb->cellId));
+ DU_LOG("\nERROR --> MAC : [%d]Sec Cell does not exit %d\n",
+ ueSCellCb->ueId, ueSCellCb->cellId);
ret = RFAILED;
}
#ifdef TENB_MULT_CELL_SUPPRT
if((ueSCellCb->rguDlSapId > rgCb[inst].numRguSaps) ||
(ueSCellCb->rguUlSapId > rgCb[inst].numRguSaps))
{
ret = RFAILED;
}
#ifdef TENB_MULT_CELL_SUPPRT
if((ueSCellCb->rguDlSapId > rgCb[inst].numRguSaps) ||
(ueSCellCb->rguUlSapId > rgCb[inst].numRguSaps))
{
- RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for ueId %d failed\n",
+ DU_LOG("\nERROR --> MAC : Invald Sap Id: DL %d UL %d for ueId %d failed\n",
ueSCellCb->rguDlSapId,
ueSCellCb->rguUlSapId,
ueSCellCb->rguDlSapId,
ueSCellCb->rguUlSapId,
ue = rgDBMGetUeCb(cell, newRnti);
if (ue == NULLP)
{
ue = rgDBMGetUeCb(cell, newRnti);
if (ue == NULLP)
{
- RGDBGERRNEW(inst,(rgPBuf(inst),"[%d]RNTI:Failed to get ueCb \
- newRnti=%d\n", rnti, newRnti));
+ DU_LOG("\nERROR --> MAC : [%d]RNTI:Failed to get ueCb \
+ newRnti=%d\n", rnti, newRnti);
return RFAILED;
}
/* For all added SCells, prepare and send ueIdChngReq */
return RFAILED;
}
/* For all added SCells, prepare and send ueIdChngReq */
- RLOG_ARG1(L_WARNING,DBG_CELLID,cell->cellId,
- "RNTI:%d No ueCb found in RachLst",rlsRnti->rnti);
+ DU_LOG("\nERROR --> MAC : RNTI:%d No ueCb found in RachLst",rlsRnti->rnti);
{
if((ue=rgDBMGetUeCbFromRachLst (cell, rlsRnti->rnti)) != NULLP)
{
{
if((ue=rgDBMGetUeCbFromRachLst (cell, rlsRnti->rnti)) != NULLP)
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
- "RNTI:%d STALE UE is still present", rlsRnti->rnti);
+ DU_LOG("\nERROR --> MAC : RNTI:%d STALE UE is still present", rlsRnti->rnti);
(cell->cellId != rlsRnti->cellId))
{
(cell->cellId != rlsRnti->cellId))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,rlsRnti->cellId,
- "No cellCb found with cellId for RNTI:%d",
+ DU_LOG("\nERROR --> MAC : No cellCb found with cellId for RNTI:%d",
rlsRnti->rnti);
return RFAILED;
}
rlsRnti->rnti);
return RFAILED;
}
* is dummy */
if (rgUtlHndlCrntiChng(macInst,cell, rlsRnti->rnti, rlsRnti->newRnti) != ROK)
{
* is dummy */
if (rgUtlHndlCrntiChng(macInst,cell, rlsRnti->rnti, rlsRnti->newRnti) != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,rlsRnti->cellId,
- "CRNTI change failed for RNTI:%d new RNTI:%d",
+ DU_LOG("\nERROR --> MAC : CRNTI change failed for RNTI:%d new RNTI:%d",
rlsRnti->rnti,rlsRnti->newRnti);
return RFAILED;
}
rlsRnti->rnti,rlsRnti->newRnti);
return RFAILED;
}