File: kw_dbm_ul.c
*********************************************************************21*/
-static const char* RLOG_MODULE_NAME="DBM";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=194;
\f
/* header (.h) include files */
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
- RLOG0(L_ERROR, "UeLstCp Initialization Failed");
+ DU_LOG("\nERROR --> RLC_UL : UeLstCp Initialization Failed");
return RFAILED;
}
RLC_GET_MEM_POOL(gCb)))
{
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
- RLOG0(L_ERROR, "CellLstCp Initialization Failed");
+ DU_LOG("\nERROR --> RLC_UL : CellLstCp Initialization Failed");
return RFAILED;
}
{
cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
cmHashListDeinit(&gCb->u.ulCb->cellLstCp);
- RLOG0(L_ERROR, "transIdLstCp Initialization Failed");
+ DU_LOG("\nERROR --> RLC_UL : transIdLstCp Initialization Failed");
return RFAILED;
}
if(rlcId->rbId >= RLC_MAX_RB_PER_CELL)
{
- RLOG_ARG3(L_ERROR,DBG_RBID,rlcId->rbId ,
- "Invalid RbId, cellId:%d UEID:%d Max is [%d]",
- rlcId->cellId,
- rlcId->ueId,
- RLC_MAX_RB_PER_CELL);
+ DU_LOG("\nERROR --> RLC_UL : Invalid RbId, cellId:%d UEID:%d Max is [%d]",
+ rlcId->cellId, rlcId->ueId, RLC_MAX_RB_PER_CELL);
return;
}
rlcDbmFetchUlCellCb(gCb,rlcId->cellId, &cellCb);
if(!cellCb)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID,rlcId->cellId,
- "CellCb not found RBID:%d UEID:%d",
+ DU_LOG("\nERROR --> RLC_UL : CellCb not found RBID:%d UEID:%d",
rlcId->rbId,
rlcId->ueId);
return;
if (!(RLC_VALIDATE_UE_RBID(rlcId->rbType, rlcId->rbId)))
{
- RLOG_ARG3(L_ERROR,DBG_RBID, rlcId->rbId,
- "Invalid RbId for RbType[%d] CELLID:%d UEID:%d",
+ DU_LOG("\nERROR --> RLC_UL : Invalid RbId for RbType[%d] CELLID:%d UEID:%d",
rlcId->rbType,
rlcId->cellId,
rlcId->ueId);
if (rlcDbmFetchUlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb) != ROK)
{
- RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId->cellId,
- "UeId [%d]: UeCb not found RBID:%d",
+ DU_LOG("\nERROR --> RLC_UL : UeId [%d]: UeCb not found RBID:%d",
rlcId->ueId,
rlcId->rbId);
return;
rlcDbmFetchUlCellCb(gCb,cellId, &cellCb);
if(!cellCb)
{
- DU_LOG("\nRLC : rlcDbmFetchUlRbCbFromLchId: CellCb[%d] not found UEID:%d",\
+ DU_LOG("\nERROR --> RLC_UL : rlcDbmFetchUlRbCbFromLchId: CellCb[%d] not found UEID:%d",\
cellId, ueId);
return;
}
if (rlcDbmFetchUlUeCb(gCb,ueId, cellId, &ueCb) != ROK)
{
- DU_LOG("\nRLC : rlcDbmFetchUlRbCbFromLchId: UeId [%d]: UeCb not found",ueId);
+ DU_LOG("\nERROR --> RLC_UL : rlcDbmFetchUlRbCbFromLchId: UeId [%d]: UeCb not found",ueId);
return;
}
(uint8_t *)&(ueCb->ueId),
(uint16_t) sizeof(CmLteRnti)))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,
- "UeId[%u] HashList Insertion Failed",
+ DU_LOG("\nERROR --> RLC_UL : UeId[%u] HashList Insertion Failed",
ueId);
return RFAILED;
}
)
{
#ifndef ALIGN_64BIT
- RLOG1(L_DEBUG, "(transId(%ld)", cfg->transId);
+ DU_LOG("\nDEBUG --> RLC_UL : (transId(%ld)", cfg->transId);
#else
- RLOG1(L_DEBUG, "(transId(%d))", cfg->transId);
+ DU_LOG("\nDEBUG --> RLC_UL : (transId(%d))", cfg->transId);
#endif
return (cmHashListInsert(&(gCb->u.ulCb->transIdLstCp),
sizeof (transId),
RLC_DEF_SEQ_NUM,(PTR *) cfg))
{
- RLOG1(L_ERROR,"TransId [%ld] not found",transId);
+ DU_LOG("\nERROR --> RLC_UL : TransId [%d] not found",transId);
return RFAILED;
}
return ROK;
if(cmHashListDelete(&(gCb->u.ulCb->transIdLstCp),(PTR) (cfg)) != ROK)
{
- RLOG0(L_ERROR,"HashList Deletion failed");
+ DU_LOG("\nERROR --> RLC_UL : HashList Deletion failed");
return RFAILED;
}
/* Delete ueCb entry from ueLstCp */
if(ROK != cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) ueCb))
{
- RLOG_ARG1(L_ERROR,DBG_UEID,ueCb->ueId,
- "HashList Deletion Failed cellId(%d)",
+ DU_LOG("\nERROR --> RLC_UL : HashList Deletion Failed cellId(%d)",
ueCb->cellId);
}
/* kw005.201 ccpu00117318, updating the statistics */
(uint8_t *)&(tCellCb->cellId),
(uint16_t) sizeof(CmLteCellId)))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,tCellCb->cellId,
- "HashList Insertion Failed");
+ DU_LOG("\nERROR --> RLC_UL : HashList Insertion Failed");
return RFAILED;
}
(uint8_t *)&(cellId),sizeof(CmLteCellId),
RLC_DEF_SEQ_NUM, (PTR*) cellCb))
{
- DU_LOG("\nRLC : rlcDbmFetchUlCellCb : CellCb[%d] not found", cellId);
+ DU_LOG("\nERROR --> RLC_UL : rlcDbmFetchUlCellCb : CellCb[%d] not found", cellId);
}
return;
/* Delete cellCb entry in hash list cellLstCp */
if(ROK != cmHashListDelete(&(gCb->u.ulCb->cellLstCp), (PTR) cellCb))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cellCb->cellId,
- "HashList Deletion Failed");
+ DU_LOG("\nERROR --> RLC_UL : HashList Deletion Failed");
}
/* Deallocate cellCb */
RLC_FREE(gCb, cellCb, sizeof(RlcUlCellCb));
cmLListInit(&freeL2UeStatsLst);
for (cnt=0; cnt < L2_STATS_MAX_CELLS; cnt++)
{
- if(NULL == l2CellStats[cnt])
- {
- if (SGetSBuf(region, pool, (Data **)&l2CellStats[cnt],
- (Size)sizeof (TSL2CellStatsCb)) != ROK)
- {
- printf("\n STATS Unexpected MEM Alloc Failure\n");
- }
- }
- memset(l2CellStats[cnt], 0x00, sizeof(TSL2CellStatsCb));
+ if(NULL == l2CellStats[cnt])
+ {
+ if (SGetSBuf(region, pool, (Data **)&l2CellStats[cnt],
+ (Size)sizeof (TSL2CellStatsCb)) != ROK)
+ {
+ DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure\n");
+ }
+ }
+ memset(l2CellStats[cnt], 0x00, sizeof(TSL2CellStatsCb));
}
for (cnt=0; cnt < L2_STATS_MAX_UES; cnt++)
{
- TSL2UeStatsCb *statsCb = l2UeStats[cnt];
- if(NULL == statsCb)
- {
- if (SGetSBuf(region, pool, (Data **)&statsCb,
- (Size)sizeof (TSL2UeStatsCb)) != ROK)
- {
- printf("\n STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
- }
- }
- memset(statsCb, 0x00, sizeof(TSL2UeStatsCb));
- statsCb->lnk.node = (PTR)statsCb;
- cmLListAdd2Tail(&freeL2UeStatsLst, &statsCb->lnk);
- l2UeStats[cnt] = statsCb;
+ TSL2UeStatsCb *statsCb = l2UeStats[cnt];
+ if(NULL == statsCb)
+ {
+ if (SGetSBuf(region, pool, (Data **)&statsCb,
+ (Size)sizeof (TSL2UeStatsCb)) != ROK)
+ {
+ DU_LOG("\nERROR --> RLC : STATS Unexpected MEM Alloc Failure at %d\n", (int)cnt);
+ }
+ }
+ memset(statsCb, 0x00, sizeof(TSL2UeStatsCb));
+ statsCb->lnk.node = (PTR)statsCb;
+ cmLListAdd2Tail(&freeL2UeStatsLst, &statsCb->lnk);
+ l2UeStats[cnt] = statsCb;
}
return;
}
/*
-*
-* Fun: TSL2AllocUeStatsBlk
-*
-* Desc: Assign Stats Block for this UE[RNTI]
-*
-* Ret:
-*
-* Notes: None
-*
-*
-*/
+ *
+ * Fun: TSL2AllocUeStatsBlk
+ *
+ * Desc: Assign Stats Block for this UE[RNTI]
+ *
+ * Ret:
+ *
+ * Notes: None
+ *
+ *
+ */
TSL2UeStatsCb* TSL2AllocUeStatsBlk (uint16_t rnti)
{
CmLList *tmp = NULLP;
tmp = freeL2UeStatsLst.first;
if (tmp == NULLP)
{
- printf("\n STATS Unexpected Mem BLK unavailable for UE %d\n", rnti);
+ DU_LOG("\nERROR --> RLC : STATS Unexpected Mem BLK unavailable for UE %d\n", rnti);
}
cmLListDelFrm(&freeL2UeStatsLst, tmp);
statsCb = (TSL2UeStatsCb *)(tmp->node);
}
/*
-*
-* Fun: TSL2DeallocUeStatsBlk
-*
-* Desc: Deassign Stats Block for this UE[RNTI]
-*
-* Ret:
-*
-* Notes: None
-*
-*
-*/
+ *
+ * Fun: TSL2DeallocUeStatsBlk
+ *
+ * Desc: Deassign Stats Block for this UE[RNTI]
+ *
+ * Ret:
+ *
+ * Notes: None
+ *
+ *
+ */
Void TSL2DeallocUeStatsBlk(uint16_t rnti,TSL2UeStatsCb *statsCb)
{
statsCb->inUse = FALSE;
}
/*
-*
-* Fun: TSL2AllocCellStatsBlk
-*
-* Desc: Assign Stats Block for this CELL[CELLID]
-*
-* Ret:
-*
-* Notes: None
-*
-*
-*/
+ *
+ * Fun: TSL2AllocCellStatsBlk
+ *
+ * Desc: Assign Stats Block for this CELL[CELLID]
+ *
+ * Ret:
+ *
+ * Notes: None
+ *
+ *
+ */
TSL2CellStatsCb* TSL2AllocCellStatsBlk(uint32_t cellId)
{
if (cellId != 1)
{
- printf("\n STATS Unexpected CellID = %d\n", (int)cellId);
+ DU_LOG("\nERROR --> RLC : STATS Unexpected CellID = %d\n", (int)cellId);
}
return (l2CellStats[cellId-1]);
}
/*
-*
-* Fun: TSL2DeallocCellStatsBlk
-*
-* Desc: Deassign Stats Block for this CELL[CELLID]
-*
-* Ret:
-*
-* Notes: None
-*
-*
-*/
+ *
+ * Fun: TSL2DeallocCellStatsBlk
+ *
+ * Desc: Deassign Stats Block for this CELL[CELLID]
+ *
+ * Ret:
+ *
+ * Notes: None
+ *
+ *
+ */
Void TSL2DeallocCellStatsBlk(uint32_t cellId)
{
}
/*
-*
-* Fun: TSL2SendStatsToApp
-*
-* Desc: Collates and Sends STATS to Application
-* Send UE STATS first. 10 UEs are grouped in one message.
-* Followed by CELL Stats. All CELLS are grouped in one msg.
-* At Reception of CELL stats APP assumes STATS reception cycle is complete.
-*
-* Ret:
-*
-* Notes: None
-*
-*
-*/
+ *
+ * Fun: TSL2SendStatsToApp
+ *
+ * Desc: Collates and Sends STATS to Application
+ * Send UE STATS first. 10 UEs are grouped in one message.
+ * Followed by CELL Stats. All CELLS are grouped in one msg.
+ * At Reception of CELL stats APP assumes STATS reception cycle is complete.
+ *
+ * Ret:
+ *
+ * Notes: None
+ *
+ *
+ */
Void TSL2SendStatsToApp(Pst *pst, SuId suId)
{
uint32_t idx;
uint32_t rnti;
if (statsCb->inUse != TRUE)
{
- continue;
+ continue;
}
if (pst->selector == 0)
{
- /* Loose Coupling */
- TSInfPkSndL2UeStats(pst, suId, &statsCb->stats);
+ /* Loose Coupling */
+ TSInfPkSndL2UeStats(pst, suId, &statsCb->stats);
}
else
{
#ifdef PX
- /* Tight Coupling */
- TSInfHdlL2UeStatsInd(pst, suId, &statsCb->stats);
+ /* Tight Coupling */
+ TSInfHdlL2UeStatsInd(pst, suId, &statsCb->stats);
#endif
}
rnti = statsCb->stats.rnti;
uint32_t cellId;
if (pst->selector == 0)
{
- /* Loose Coupling */
- TSInfPkSndL2CellStats(pst, suId, l2CellStats[idx]);
+ /* Loose Coupling */
+ TSInfPkSndL2CellStats(pst, suId, l2CellStats[idx]);
}
else
{
#ifdef PX
- /* Tight Coupling */
- TSInfHdlL2CellStatsInd(pst, suId, l2CellStats[idx]);
+ /* Tight Coupling */
+ TSInfHdlL2CellStatsInd(pst, suId, l2CellStats[idx]);
#endif
}
cellId = statsCellCb->cellId;
}
#endif /* TENB_STATS */
/**********************************************************************
- End of file
-**********************************************************************/
+ End of file
+ **********************************************************************/
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "Memory Allocation failed UEID:%d CELLID:%d",
- rbCb->rlcId.ueId,
- rbCb->rlcId.cellId);
+ DU_LOG("\nERROR --> RLC_DL : Memory Allocation failed UEID:%d CELLID:%d",
+ rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
(sdu->mode.tm.slot != ((slot+TFU_DELTA)%10)))
{
node = node->next;
- DU_LOG("\nRLC: rlcTmmSendToMac: Releasing SDU of RNTI = %d for RNTI = %d \
+ DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: Releasing SDU of RNTI = %d for RNTI = %d \
UEID:%d CELLID:%d", sdu->mode.tm.rnti, staInd->rnti, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- DU_LOG("\nRLC: rlcTmmSendToMac: sfn %d slot %d UEID:%d CELLID:%d",
+ DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: sfn %d slot %d UEID:%d CELLID:%d",
sfn, slot, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
ODU_PUT_MSG_BUF(sdu->mBuf);
{
timeDiff = curTime - sdu->arrTime;
}
- DU_LOG("\nRLC: rlcTmmSendToMac: TMM: TmSdu Sta Indication received \
+ DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu Sta Indication received \
for Rnti %d Sdu Rnti %d UEID:%d CELLID:%d", staInd->rnti,
sdu->mode.tm.rnti, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- DU_LOG("\nRLC: rlcTmmSendToMac: TMM: TmSdu Sta Indication received : \
+ DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu Sta Indication received : \
timeDiff %d SduQCnt %d UEID:%d CELLID:%d", timeDiff, rbCb->m.tm.sduQ.count,
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
if (timeDiff > 40)
{
/* Memory leak needs to be fixed */
node = node->next;
- DU_LOG("\nRLC: rlcTmmSendToMac: timeDiff greater than 40, so deleting\
+ DU_LOG("\nERROR --> RLC_DL : rlcTmmSendToMac: timeDiff greater than 40, so deleting\
the Sdu %u UEID:%d CELLID:%d", sdu->mode.tm.rnti, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
cmLListDelFrm(&(rbCb->m.tm.sduQ), &sdu->lstEnt);
{
/* Memory leak needs to be fixed */
node = node->next;
- DU_LOG("\nRLC: rlcTmmSendToMac: TMM: Searching for Rnti %d Skipping \
+ DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: Searching for Rnti %d Skipping \
Sdu for Rnti %d UEID:%d CELLID:%d", staInd->rnti, sdu->mode.tm.rnti,
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- DU_LOG("\nRLC: rlcTmmSendToMac: timeDiff %d sdu->arrTime %d UEID:%d CELLID:%d",
+ DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: timeDiff %d sdu->arrTime %d UEID:%d CELLID:%d",
timeDiff, sdu->arrTime, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- DU_LOG("\nRLC: rlcTmmSendToMac: curTime %d SduQCnt %d and continuing"
+ DU_LOG("\nINFO --> RLC_DL : rlcTmmSendToMac: curTime %d SduQCnt %d and continuing"
" UEID:%d CELLID:%d", curTime, rbCb->m.tm.sduQ.count, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
continue;
}
else
{
- DU_LOG("\nRLC: rlcTmmSendToMac: TMM: TmSdu found %u UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcTmmSendToMac: TMM: TmSdu found %u UEID:%d CELLID:%d",
sdu->mode.tm.rnti, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
break;
}
}
if ( node == NULLP )
{
- DU_LOG("\nRLC: rlcTmmSendToMac: SDU not found TM Queue is empty UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcTmmSendToMac: SDU not found TM Queue is empty UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( dlData == NULLP )
{
- DU_LOG("\nRLC: rlcTmmSendToMac: Memory Allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcTmmSendToMac: Memory Allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
dlData->pduInfo[0].pduBuf, pduLen);
if (dlData->pduInfo[0].pduBuf == NULLP )
{
- DU_LOG("Memory allocation failed");
+ DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
return;
}
ODU_COPY_MSG_TO_FIX_BUF(sdu->mBuf, 0, pduLen, \
boStatus, sizeof(RlcBoStatus));
if ( boStatus == NULLP )
{
- DU_LOG("Memory Allocation failed UEID:%d CELLID:%d",\
+ DU_LOG("\nERROR --> RLC_DL : Memory Allocation failed UEID:%d CELLID:%d",\
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
File: kw_tmm_ul.c
**********************************************************************/
-static const char* RLOG_MODULE_NAME="TMM";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=201;
/** @file kw_tmm_ul.c
@brief RLC Transparent Mode module
SAddPstMsgMult(rrcConReq,6,pdu);
- RLOG1(L_INFO,"Profiling Framework Sending RRC Connection Req to RRC for UE :%d\n",crnti);
- printf("Profiling Framework Sending RRC Connection Req to RRC for UE :%d\n",crnti);
+ DU_LOG("\nINFO --> RLC_UL : Profiling Framework Sending RRC Connection Req to RRC for UE :%d\n",crnti);
rlcSendUlDataToDu(&ulPst1, datIndInfo, pdu);
}
else if(2 == rrcMsgType)
SAddPstMsgMult(rrcConSetupComplete,34,pdu);
- RLOG1(L_INFO,"Profiling Framework: Sending RRC Connection Setup Complete to RRC for UE :%d\n",crnti);
- printf("Profiling Framework: Sending RRC Connection Setup Complete to RRC for UE :%d\n",crnti);
+ DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC Connection Setup Complete to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#endif
#else
SAddPstMsgMult(rrcUeCapabilityInfo,sizeof(rrcUeCapabilityInfo),pdu);
#endif
- RLOG1(L_INFO,"Profiling Framework: Sending RRC UE Capability Info to RRC for UE :%d\n",crnti);
- printf("Profiling Framework: Sending RRC UE Capability Info to RRC for UE :%d\n",crnti);
+ DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC UE Capability Info to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#endif
SAddPstMsgMult(rrcSecurityModeComplete,2,pdu);
- RLOG1(L_INFO,"Profiling Framework: Sending RRC Security Mode Complete to RRC for UE :%d\n",crnti);
- printf("Profiling Framework: Sending RRC Security Mode Complete to RRC for UE :%d\n",crnti);
+ DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC Security Mode Complete to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#endif
SAddPstMsgMult(rrcReconfigComplete,2,pdu);
- RLOG1(L_INFO,"Profiling Framework: Sending RRC Reconfig Complete to RRC for UE :%d\n",crnti);
- printf("Profiling Framework: Sending RRC Reconfig Complete to RRC for UE :%d\n",crnti);
+ DU_LOG("\nINFO --> RLC_UL : Profiling Framework: Sending RRC Reconfig Complete to RRC for UE :%d\n",crnti);
#ifdef PJ
PjUiPjuDatInd(&ulPst2, 1, &pdcpId, pdu);
#ifdef EG_GEN_LOAD_5GTF
}
else
{
- DU_LOG("\nRLC : rlcTmmRcvFrmMac: Memory allocation failed for UL RRC Msg");
+ DU_LOG("\nERROR --> RLC_UL : rlcTmmRcvFrmMac: Memory allocation failed for UL RRC Msg");
}
}
else
{
- DU_LOG("\nRLC : rlcTmmRcvFrmMac: Memory allocation failed for ulRrcMsgInfo");
+ DU_LOG("\nERROR --> RLC_UL : rlcTmmRcvFrmMac: Memory allocation failed for ulRrcMsgInfo");
}
return;
RlcUlRbCb *rbCb
)
{
- RLOG_ARG0(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,"do nothing for TMM for ReEstablish");
+ DU_LOG("\nINFO --> RLC_UL : do nothing for TMM for ReEstablish");
return;
}
#endif
default:
{
- DU_LOG("\nRLC : rlcStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("\nERROR --> RLC : rlcStartTmr: Invalid tmr Evnt [%d]", tmrEvnt);
}
}
#endif
default:
{
- DU_LOG("\nRLC : rlcStopTmr: Invalid tmr Evnt[%d]", tmrType);
+ DU_LOG("\nERROR --> RLC : rlcStopTmr: Invalid tmr Evnt[%d]", tmrType);
}
}
if (tmrType != TMR0)
}
default:
{
- DU_LOG("\nRLC : rlcChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
+ DU_LOG("\nERROR --> RLC : rlcChkTmr: Invalid tmr Evnt [%d]", tmrEvnt);
}
}
File: kw_uim.c
**********************************************************************/
-static const char* RLOG_MODULE_NAME="UIM";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=205;
-
/**
* @file kw_uim.c
* @brief RLC Upper Interface Module
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- RLOG2(L_DEBUG, "spId(%d), suId(%d)", spId, suId);
+ DU_LOG("\nDEBUG --> RLC_UL : spId(%d), suId(%d)", spId, suId);
ckwSap = &(tRlcCb->u.ulCb->ckwSap);
/* Take action based on the current state of the SAP */
switch(ckwSap->state)
/* Update the State */
ckwSap->state = RLC_SAP_BND;
- RLOG1(L_DEBUG, "RlcUiCkwBndReq: state (%d)", ckwSap->state);
+ DU_LOG("\nDEBUG --> RLC_UL : RlcUiCkwBndReq: state (%d)", ckwSap->state);
break;
}
case RLC_SAP_BND:
LKW_EVENT_CKW_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
- RLOG0(L_ERROR, "CKW SAP already Bound");
+ DU_LOG("\nERROR --> RLC_UL : CKW SAP already Bound");
RlcUiCkwBndCfm(&(ckwSap->pst), ckwSap->suId, CM_BND_NOK);
return (RFAILED);
}
default:
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- RLOG0(L_ERROR, "Invalid CKW SAP State in Bind Req");
+ DU_LOG("\nERROR --> RLC_UL : Invalid CKW SAP State in Bind Req");
RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
LKW_EVENT_CKW_BND_REQ,
#endif /* ERRCLASS & ERRCLS_INT_PAR */
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- RLOG2(L_DEBUG,"spId(%d), reason(%d)",
+ DU_LOG("\nDEBUG --> RLC_UL : spId(%d), reason(%d)",
spId,
reason);
tRlcCb->u.ulCb->rlcUlUdxEventType = pst->event;
if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData) != ROK)
{
- RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
+ DU_LOG("\nERROR --> RLC_UL : Addition to UL transId Lst Failed");
RLC_PST_FREE(pst->region, pst->pool, cfg, sizeof(RlcCfgInfo));
return RFAILED;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#ifndef ALIGN_64BIT
- RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId,
- "RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))",
+ DU_LOG("\nDEBUG --> RLC_UL : RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%ld))",
spId,
transId);
#else
- RLOG_ARG2(L_DEBUG,DBG_CELLID,newUeInfo->cellId,
- "RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n",
- spId,
- transId);
+ DU_LOG("\nDEBUG --> RLC_UL : RlcUiCkwUeIdChgReq(pst, spId(%d), transId(%d))\n",
+ spId, transId);
#endif
RLC_ALLOC(tRlcCb, cfgTmpData, sizeof (RlcUlCfgTmpData));
if (rlcDbmAddUlTransaction(tRlcCb, cfgTmpData))
{
- RLOG0(L_ERROR, "Addition to UL transId Lst Failed");
+ DU_LOG("\nERROR --> RLC_UL : Addition to UL transId Lst Failed");
ret = RFAILED;
break;
}
if(ROK != rlcCfgValidateUeIdChng(tRlcCb,ueInfo,newUeInfo,cfgTmpData))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cfgTmpData->ueInfo->cellId,
- "Validation Failure for UeId change");
+ DU_LOG("\nERROR --> RLC_UL : Validation Failure for UeId change");
}
rlcUlUdxUeIdChgReq(&(RLC_GET_UDX_SAP(tRlcCb)->pst),
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
{
- RLOG_ARG2(L_ERROR,DBG_UEID, cfgTmpData->ueId,
- "CELLID [%u]:Validation Failure for UL RB [%d]",
+ DU_LOG("\nERROR --> RLC_UL : CELLID [%u]:Validation Failure for UL RB [%d]",
cfg->cellId,cfg->entCfg[idx].rbId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/*Validation is getting failed so no need to do configuration at DL.
&cfg->entCfg[idx],
&cfgTmpData->cfgEntData[idx]))
{
- RLOG_ARG2(L_ERROR,DBG_UEID,cfg->ueId,
- "CellID [%u]:Validation Failure for Reest UL RB [%d]",
+ DU_LOG("\nERROR --> RLC_UL : CellID [%u]:Validation Failure for Reest UL RB [%d]",
cfg->cellId,cfg->entCfg[idx].rbId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
{
- RLOG_ARG1(L_ERROR,DBG_CELLID,cfg->cellId,
- "UL UEID [%d]:Validation Failure",
+ DU_LOG("\nERROR --> RLC_UL : UL UEID [%d]:Validation Failure",
cfgTmpData->ueId);
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
&cfgTmpData->cfgEntData[idx],
cfgTmpData))
{
- RLOG_ARG0(L_ERROR,DBG_CELLID,cfg->cellId,
- "Del UL Cell Validation Failure");
+ DU_LOG("\nERROR --> RLC_UL : Del UL Cell Validation Failure");
cfgTmpData->cfgEntData[idx].entUlCfgCfm.status.status = CKW_CFG_CFM_NOK;
/* Setting dir as UL, so that no configuration is done at DL */
cfg->entCfg[idx].dir = RLC_DIR_UL;
}
#endif
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- RLOG2(L_DEBUG, "RlcUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
+ DU_LOG("\nDEBUG --> RLC_UL : RlcUiKwuBndReq(pst, spId(%d), suId(%d))", spId, suId);
/* Validation of input parameters */
#if (ERRCLASS & ERRCLS_INT_PAR)
if(!((spId < (S16) tRlcCb->genCfg.maxKwuSaps) && (spId >=0)))
{
- RLOG0(L_ERROR,"Invalid spId");
+ DU_LOG("\nERROR --> RLC_UL : Invalid spId");
RLC_SEND_SAPID_ALARM(tRlcCb,spId, LKW_EVENT_KWU_BND_REQ, LCM_CAUSE_INV_SAP);
return RFAILED;
}
/* Update the State */
rlckwuSap->state = RLC_SAP_BND;
- RLOG1(L_DEBUG, "RlcUiKwuBndReq: state (%d)", rlckwuSap->state);
+ DU_LOG("\nDEBUG --> RLC_UL : RlcUiKwuBndReq: state (%d)", rlckwuSap->state);
break;
}
case RLC_SAP_BND:
spId,
LKW_EVENT_KWU_BND_REQ,
LCM_CAUSE_INV_PAR_VAL);
- RLOG1(L_ERROR,"RLC Mode [%d] : KWU SAP already Bound",
+ DU_LOG("\nERROR --> RLC_UL : RLC Mode [%d] : KWU SAP already Bound",
tRlcCb->genCfg.rlcMode);
RlcUiKwuBndCfm(&(rlckwuSap->pst), rlckwuSap->suId, CM_BND_NOK);
return (RFAILED);
default:
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- RLOG1(L_ERROR,"RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
+ DU_LOG("\nERROR --> RLC_UL : RLC Mode [%d]:Invalid KWU SAP State in Bind Req",
tRlcCb->genCfg.rlcMode);
RLC_SEND_SAPID_ALARM(tRlcCb,
spId,
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
- RLOG2(L_DEBUG, "spId(%d), reason(%d)",
+ DU_LOG("\nDEBUG --> RLC_UL : spId(%d), reason(%d)",
spId,
reason);
RlcDlRbCb *rbCb; /* RB Control Block */
RlcCb *tRlcCb;
- DU_LOG("\nRLC : Received DL Data");
+ DU_LOG("\nDEBUG --> RLC_UL : Received DL Data");
#if (ERRCLASS & ERRCLS_INT_PAR)
if(pst->dstInst >= MAX_RLC_INSTANCES)
rlcDbmFetchDlRbCbByRbId(tRlcCb, &datReq->rlcId, &rbCb);
if(!rbCb)
{
- DU_LOG("\nRLC : CellId[%u]:DL RbId [%d] not found",
+ DU_LOG("\nERROR --> RLC_UL : CellId[%u]:DL RbId [%d] not found",
datReq->rlcId.cellId,datReq->rlcId.rbId);
ODU_PUT_MSG_BUF(mBuf);
}
default:
{
- DU_LOG("\nRLC : Invalid RB Mode");
+ DU_LOG("\nERROR --> RLC_UL : Invalid RB Mode");
break;
}
}
Code Review / o-du / l2.git / commitdiff