File: kw_amm_dl.c
*********************************************************************21*/
-static const char* RLOG_MODULE_NAME="AMM";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=189;
/* header include files (.h) */
#include "common_def.h"
#include "lkw.h" /* LKW defines */
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
{
- RLOG0(L_FATAL, "Memory allocation failed");
+ DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
return;
}
#endif /* ERRCLASS & ERRCLS_RES */
if ((nackSnInfo->isSegment) &&
((retx->soEnd < nackSnInfo->soStart) /*|| (retx->amHdr.so > soEnd)*/))
{
- RLOG_ARG3(L_DEBUG, DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: Handle ACK for byte segment, Its "
+ DU_LOG( "\nDEBUG --> RLC_DL : rlcHndlStaRsp: Handle ACK for byte segment, Its "
"sn = %d UEID:%d CELLID:%d",
nackSnInfo->sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RLOG_ARG4(L_DEBUG, DBG_RBID, rbCb->rlcId.rbId,
- "soStart and soEnd = %d, %d, UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : soStart and soEnd = %d, %d, UEID:%d CELLID:%d",
retx->amHdr.so, retx->soEnd,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (datCfm == NULLP)
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "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);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
if(mAckSn > mTxNext)
{
- RLOG_ARG4(L_WARNING,DBG_RBID, rbCb->rlcId.rbId,
- "Invalid ACK SN = %d received. Current Vta =%d"
+ DU_LOG("\nERROR --> RLC_DL : Invalid ACK SN = %d received. Current Vta =%d"
"UEID:%d CELLID:%d",
pStaPdu->ackSn,
RLC_AMDL.txNextAck,
nackSnInfo.nackRange = pStaPdu->nackInfo[idx].nackRange;
nackSnInfo.sn = pStaPdu->nackInfo[idx].sn;
- RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: NACK SN = %d UEID:%d CELLID:%d",
nackSnInfo.sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
if ((mNackSn > mAckSn) || (mNackSn >= mTxNext))
{
/* Erroneous NACK_SN, we should raise an error towards L3 */
- RLOG_ARG2(L_ERROR,DBG_RBID, rbCb->rlcId.rbId,
- "Status Pdu is not correct UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : Status Pdu is not correct UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
{
rlcStatusAckCnt++;
/* For All ACKs */
- RLOG_ARG2(L_UNUSED,DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: Received All ACKS UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
{
if(datCfm->numSduIds > 1024)
{
- RLOG_ARG4(L_DEBUG,DBG_RBID,datCfm->rlcId.rbId,
- "Sending [%lu] SDU Cfms to PDCP & [%lu] lost for"
+ DU_LOG("\nDEBUG --> RLC_DL : Sending [%u] SDU Cfms to PDCP & [%u] lost for"
"UEID:%d CELLID:%d",
datCfm->numSduIds,
datCfm->numSduIds-1024,
#if (ERRCLASS & ERRCLS_ADD_RES)
if (sdu == NULLP)
{
- DU_LOG("\n RLC : rlcAmmQSdu : Memory allocation failed UEID:%d CELLID:%d",\
+ DU_LOG("\nERROR --> RLC_DL : rlcAmmQSdu : Memory allocation failed UEID:%d CELLID:%d",\
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
* queue */
if (RLC_AMDL.nxtTx == NULLP)
{
- DU_LOG("\nRLC : rlcAmmQSdu: Received SDU will be transmitted next \
+ DU_LOG("\nDEBUG --> RLC_DL : rlcAmmQSdu: Received SDU will be transmitted next \
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
RLC_AMDL.nxtTx = sdu;
}
}
else
{
- DU_LOG("\nRLC: rlcAmmProcessSdus: Miscomputation of control Bo. \
+ DU_LOG("\nERROR --> RLC_DL : rlcAmmProcessSdus: Miscomputation of control Bo. \
UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
}
RLC_AMDL.cntrlBo = 0;
/* kw003.201 - Eliminate MAC Header Size based on bites needed */
tmpSz = RLC_MIN((retx->segSz + retx->hdrSz), rlcDatReq->pduSz);
pduSz = (retx->segSz + retx->hdrSz);
- /* 5GNR_RLC: length field in 5GNR MAC Hdr is 8/16 btis*/
+ /* 5GNR_RLC_DL : length field in 5GNR MAC Hdr is 8/16 btis*/
rlcDatReq->pduSz -= (tmpSz < 255) ? RLC_MAC_HDR_SZ2 : RLC_MAC_HDR_SZ3;
/* kw003.201 - We should have at least one more than basic header */
{
uint8_t pollBit;
- DU_LOG("\nRLC: rlcResegRetxPdus: Send retx buf without segmentation "
+ DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: Send retx buf without segmentation "
"UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
if (retx->yetToConst)
/* Segment this pdu / portion of pdu. Insert this segment into */
/* retxLst and update offset */
- DU_LOG("\nRLC: rlcResegRetxPdus: Segment retx buf UEID:%d CELLID:%d",
+ DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: Segment retx buf UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* Eliminate fixed header size if the pdu is segmented for the */
#if (ERRCLASS & ERRCLS_ADD_RES)
if (tNode == NULLP)
{
- DU_LOG("\nRLC: rlcResegRetxPdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcResegRetxPdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
amDl->retxBo -= retx->segSz;
}
#ifndef ALIGN_64BIT
- DU_LOG("\nRLC: rlcResegRetxPdus: retxBo after resegmentation = %ld"
+ DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %ld"
"UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
#else
- DU_LOG("\nRLC: rlcResegRetxPdus: retxBo after resegmentation = %d "
+ DU_LOG("\nINFO --> RLC_DL : rlcResegRetxPdus: retxBo after resegmentation = %d "
"UEID:%d CELLID:%d", amDl->retxBo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
#endif
#if (ERRCLASS & ERRCLS_ADD_RES)
if (discSduInfo == NULLP)
{
- DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
/* store the info for sending it to PDCP */
if(discSduInfo->numSduIds > 500)
{
- DU_LOG("\nRLC: rlcAssembleSdus: This is a big error, we shouldn't be here"
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: This is a big error, we shouldn't be here"
"UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
break;
}
if (RLC_AM_IS_TRANS_WIN_STALLED(amDl))
{
//int *a = NULLP;
- printf("\n Window stalled \n");
+ DU_LOG("\nINFO --> RLC_DL : Window stalled \n");
gRlcStats.amRlcStats.numRlcAmCellWinStall++;
//*a = 10;
break;
{
uint32_t avblMem = 0;
SRegInfoShow(gCb->init.region, &avblMem);
- DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
{
uint32_t avblMem = 0;
SRegInfoShow(gCb->init.region, &avblMem);
- DU_LOG("\nRLC: rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleSdus: Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
/* Update Framing Info */
if (sdu->mode.am.isSegmented)
{
- /*5GNR RLC: SN should be same for all segment of a SDU*/
+ /*5GNR RLC_DL : SN should be same for all segment of a SDU*/
pduInfo->amHdr.sn = sdu->mode.am.sn;
pduInfo->amHdr.si = RLC_SI_LAST_SEG; /* binary 10 */
pduInfo->amHdr.so = sdu->actSz - sdu->sduSz;
gRlcStats.amRlcStats.numRlcAmCellSduTx++;
- //printf("\n 5GNRLOG: last segment of lcId %d SduId %u So %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
+ //DU_LOG("\nINFO --> RLC_DL : 5GNRLOG: last segment of lcId %d SduId %u So %u macGrntSz\
+ %u sduActSz %u sdu->sduSz %u\n",
// rbCb->lch.lChId, sdu->mode.am.sduId, pduInfo->amHdr.so, macGrntSz, sdu->actSz, sdu->sduSz);
}
else
/* Create PDU with hdr and data */
rlcAmmCreatePdu(gCb,rbCb, amHdr, pduInfo, pdu);
- //printf("\n Segmentation not required case: numPdu %d pdu %p \n",rlcDatReq->pduInfo.numPdu, pdu);
+ //DU_LOG("\nINFO --> Segmentation not required case: numPdu %d pdu %p \n",rlcDatReq->pduInfo.numPdu, pdu);
#ifdef LTE_L2_MEAS_RLC
rlcUtlUpdSduSnMap(rbCb, sdu, rlcDatReq, TRUE);
Buffer *remSeg = NULLP;
- //printf("\n SDU segmentation case: numPdu %d pdu %p \n", rlcDatReq->pduInfo.numPdu, pdu);
+ //DU_LOG("\nINFO --> SDU segmentation case: numPdu %d pdu %p \n", rlcDatReq->pduInfo.numPdu, pdu);
#ifdef LTE_L2_MEAS
if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb,rbCb) ||
RLC_MEAS_IS_DL_DELAY_MEAS_ON_FOR_RB(gCb,rbCb) ||
/* Update SI and SN */
if (sdu->mode.am.isSegmented)
{
- /*5GNR RLC: SN should be same for all segment of a SDU.
+ /*5GNR RLC_DL : SN should be same for all segment of a SDU.
* Sdu was already segmented and segmenting again*/
pduInfo->amHdr.sn = sdu->mode.am.sn;
pduInfo->amHdr.si = RLC_SI_MID_SEG; /* binary 11 */
pduInfo->amHdr.so = sdu->actSz - sdu->sduSz;
- //printf("\n 5GNRLOG: mid segment of lcId %d SduId %u So %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
+ //DU_LOG("\nINFO --> RLC_DL : 5GNRLOG: mid segment of lcId %d SduId %u So %u macGrntSz %u sduActSz\
+ %u sdu->sduSz %u\n",
// rbCb->lch.lChId, sdu->mode.am.sduId, txBuf->amHdr.so, macGrntSz, sdu->actSz, sdu->sduSz);
}
else
{
- /*5GNR RLC: This means it is the first*/
+ /*5GNR RLC_DL : This means it is the first*/
pduInfo->amHdr.si = RLC_SI_FIRST_SEG; /* binary 01 */
- /*5GNR_RLC: Store SN so that in sub-seqent SDU segments will use this SN*/
+ /*5GNR_RLC_DL : Store SN so that in sub-seqent SDU segments will use this SN*/
sdu->mode.am.sn = pduInfo->amHdr.sn;
pduInfo->amHdr.so = 0;
- //printf("\n 5GNRLOG: First segment of lcId %d SduId %u So %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
+ //DU_LOG("\nINFO --> RLC_DL : 5GNRLOG: First segment of lcId %d SduId %u So\
+ %u macGrntSz %u sduActSz %u sdu->sduSz %u\n",
// rbCb->lch.lChId, sdu->mode.am.sduId, txBuf->amHdr.so, macGrntSz, sdu->actSz, sdu->sduSz);
}
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, discSduInfo, sizeof(KwuDiscSduInfo));
}
- DU_LOG("\nRLC: rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcAssembleSdus: BO after assembly = %d UEID:%d CELLID:%d",
amDl->bo, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return;
}
amDl->pollSn = (amDl->txNext - 1) & amDl->snModMask;
- DU_LOG("\nRLC: rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
+ DU_LOG("\nINFO --> RLC_DL : rlcAmmDlCheckAndSetPoll: Poll SN = %d UEID:%d CELLID:%d",
amDl->pollSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
/* kw005.201: Fix for poll retransmission timer.
/* Update sn */
amHdr->sn = amDl->txNext;
- /*5GNR RLC: Increment txNext only if no segmentation of it is a last segment */
+ /*5GNR RLC_DL : Increment txNext only if no segmentation of it is a last segment */
if((!amHdr->si) || (amHdr->si == RLC_SI_LAST_SEG))
{
- //printf("\n 5GNRLOG: no segment/last seg SDU with lcId %d Sn %u txNext %u So %u\n",
+ //DU_LOG("\nINFO --> RLC_DL : 5GNRLOG: no segment/last seg SDU with lcId %d Sn %u txNext %u So %u\n",
// rbCb->lch.lChId, amHdr->sn, amDl->txNext, amHdr->so);
amDl->txNext = (amDl->txNext + 1) & amDl->snModMask;
}
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*datCfm == NULLP)
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "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;
#if (ERRCLASS & ERRCLS_ADD_RES)
if (staInd == NULLP)
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "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;
if (ROK != rlcDbmFetchDlUeCb(gCb,rlcId.ueId, rlcId.cellId, &ueCb))
{
- RLOG_ARG2(L_ERROR,DBG_CELLID, rlcId.cellId,
- "UeId [%d]: UeCb not found RBID;%d",
+ DU_LOG("\nERROR --> RLC_DL : UeId [%d]: UeCb not found RBID;%d",
rlcId.ueId,
rlcId.rbId);
return;
txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, sn);
if (txBuf != NULLP)
{
- RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
- "rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
- "with sn = %ld UEID:%ld CELLID:%ld",
+
+ DU_LOG("\nDEBUG --> RLC_DL : rlcAmmDlUpdateTxAndReTxBufForAckSn: ACK for PDU "
+ "with sn = %d UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
txBuf = rlcUtlGetTxBuf(RLC_AMDL.txBufLst, sn);
if ((txBuf != NULLP))
{
- RLOG_ARG3(L_DEBUG,DBG_RBID, rbCb->rlcId.rbId,
- "rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
+ DU_LOG("\nDEBUG --> RLC_DL : rlcHndlStaRsp: Handle ACK (sn = %d) UEID:%d CELLID:%d",
sn,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#if (ERRCLASS & ERRCLS_ADD_RES)
if (*retx == NULLP)
{
- RLOG0(L_FATAL, "Memory allocation failed");
+ DU_LOG("\nERROR --> RLC_DL : Memory allocation failed");
return;
}
#endif /* ERRCLASS & ERRCLS_RES */
/* set ACK SN */
{
- DU_LOG("\nRLC: rlcAssembleCntrlInfo: ACK PDU's SN = %d"\
+ DU_LOG("\nINFO --> RLC_DL : rlcAssembleCntrlInfo: ACK PDU's SN = %d"\
"UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
cntrlPdu[0] |= (ack_sn & 0xF00)>> 8;
/* set ACK SN */
{
- DU_LOG("\nRLC: rlcAssembleCntrlInfo: ACK PDU's SN = %d"
+ DU_LOG("\nINFO --> RLC_DL : rlcAssembleCntrlInfo: ACK PDU's SN = %d"
"UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId,rbCb->rlcId.cellId);
cntrlPdu[0] |= (ack_sn & 0x3C000) >> 14;
else
{
/* ERROR Log */
- DU_LOG("\nRLC: rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! \
+ DU_LOG("\nERROR --> RLC_DL : rlcAssembleCntrlInfo:Conf SN LEN %d is INVALID !!!! \
UEID:%d CELLID:%d", rbCb->m.amDl.snLen, rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
}
if( ROK != rlcDbmFetchDlUeCb(gCb,rnti,cellId,&(ueCb)))
{
- printf("\n RLC UECb Not found...\n");
+ DU_LOG("\nERROR --> RLC_DL : RLC UECb Not found...\n");
return RFAILED;
}
if(ROK != SExamMsg((Data *)(&fByte),
rlcSdu, 0))
{
- printf("\n Failure in Rlc Hdr SExamMsg\n");
+ DU_LOG("\nERROR --> RLC_DL : Failure in Rlc Hdr SExamMsg\n");
return RFAILED;
}
File: kw_ul_ex_ms.c
*********************************************************************21*/
-static const char* RLOG_MODULE_NAME="RLC_UL";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=206;
/** @file kw_ul_ex_ms.c
@brief RLC System Services Interface
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- RLOG1(L_FATAL,"Received Invalid Event[%d] from SM",
+ DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from SM",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- RLOG1(L_ERROR,"Received Invalid Event[%d] from RLC UL",
+ DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from RLC UL",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- RLOG1(L_ERROR,"Received Invalid Event[%d] from RRC",
+ DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from RRC",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- RLOG1(L_ERROR,"Received Invalid Event[%d] from PDCP",
+ DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from PDCP",
pst->event);
}
ret = RFAILED;
ODU_PUT_MSG_BUF(mBuf);
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- RLOG1(L_ERROR,"Received Invalid Event[%d] from MAC",
+ DU_LOG("\nERROR --> RLC_UL : Received Invalid Event[%d] from MAC",
pst->event);
}
ret = RFAILED;
}
default:
{
- printf("\n ERROR Invalid Event[%d] from CL to PDCPUL\n",
+ DU_LOG("\nERROR --> RLC_UL : Invalid Event[%d] from CL to PDCPUL\n",
pst->event);
ODU_PUT_MSG_BUF(mBuf);
break;
{
if (pst->dstInst < MAX_RLC_INSTANCES)
{
- RLOG1(L_ERROR, "Received Invalid Source Entity[%d]",pst->event);
+ DU_LOG("\nERROR --> RLC_UL : Received Invalid Source Entity[%d]",pst->event);
}
ODU_PUT_MSG_BUF(mBuf);
ret = RFAILED;
File: kw_utl_dl.c
**********************************************************************/
-static const char* RLOG_MODULE_NAME="UTL";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=209;
/** @file kw_utl_dl.c
@brief RLC Utility Module
RlcCb* dlInst = rlcCb[1];
RlcCb* ulInst = rlcCb[0];
- RLOG4(L_ALWAYS,"RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
dlInst->genSts.pdusSent,
dlInst->genSts.pdusRetx,
dlInst->genSts.protTimeOut,
dlInst->genSts.numSduDisc);
- RLOG3(L_ALWAYS,"RLC Stats: PDUs Rcvd = (%ld), unexpPdus = (%ld), errorPdus = (%ld)",
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%ld), unexpPdus = (%ld), errorPdus = (%ld)",
ulInst->genSts.pdusRecv,
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
- RLOG4(L_ALWAYS,"RLC Stats: RLC_AMDL: "
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
"StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu,
gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
- RLOG3(L_ALWAYS,"RLC Stats: RLC_AMDL: "
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
"DRB:%lu MaxRetx:%lu RetransPdus:%lu",
gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx,
gRlcStats.amRlcStats.numDLRetransPdus);
- RLOG4(L_ALWAYS,"RLC Stats: RLC_AMUL: "
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: "
" PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ",
gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires,
gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
RlcCb* dlInst = rlcCb[1];
RlcCb* ulInst = rlcCb[0];
- printf ("\n================================ RLC STATS ===========================\n");
- RLOG4(L_ALWAYS,"RLC Stats: PDUs Sent = (%ld), PdusRext = (%ld), TimeOut = (%ld), SduDiscarded = (%ld)",
+ DU_LOG ("\n ================================ RLC STATS ===========================\n");
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Sent = (%d), PdusRext = (%d), TimeOut = (%d), SduDiscarded = (%d)",
dlInst->genSts.pdusSent,
dlInst->genSts.pdusRetx,
dlInst->genSts.protTimeOut,
dlInst->genSts.numSduDisc);
- RLOG3(L_ALWAYS,"RLC Stats: PDUs Rcvd = (%ld), unexpPdus = (%ld), errorPdus = (%ld)",
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: PDUs Rcvd = (%d), unexpPdus = (%d), errorPdus = (%d)",
ulInst->genSts.pdusRecv,
ulInst->genSts.unexpPdusRecv,
ulInst->genSts.errorPdusRecv);
- RLOG4(L_ALWAYS,"RLC Stats: RLC_AMDL: "
- "StaPduSent:%lu NacksInStaPdu:%lu BytesUnused:%lu PollTimerExpires SRB:%lu ",
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
+ "StaPduSent:%u NacksInStaPdu:%u BytesUnused:%u PollTimerExpires SRB:%u ",
gRlcStats.amRlcStats.numDLStaPduSent, gRlcStats.amRlcStats.numDLNacksInStaPdu,
gRlcStats.amRlcStats.numDLBytesUnused, gRlcStats.amRlcStats.numDLPollTimerExpiresSrb);
- RLOG3(L_ALWAYS,"RLC Stats: RLC_AMDL: "
- "DRB:%lu MaxRetx:%lu RetransPdus:%lu",
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMDL: "
+ "DRB:%u MaxRetx:%u RetransPdus:%u",
gRlcStats.amRlcStats.numDLPollTimerExpiresDrb, gRlcStats.amRlcStats.numDLMaxRetx,
gRlcStats.amRlcStats.numDLRetransPdus);
- RLOG4(L_ALWAYS,"RLC Stats: RLC_AMUL: "
- " PdusDiscarded:%lu ReOrdTimerExpires:%lu StaPduRcvd:%lu NackInStaPduRcvd:%lu ",
+ DU_LOG("\nINFO --> RLC_DL : RLC Stats: AMUL: "
+ " PdusDiscarded:%u ReOrdTimerExpires:%u StaPduRcvd:%u NackInStaPduRcvd:%u ",
gRlcStats.amRlcStats.numULPdusDiscarded, gRlcStats.amRlcStats.numULReOrdTimerExpires,
gRlcStats.amRlcStats.numULStaPduRcvd, gRlcStats.amRlcStats.numULNackInStaPduRcvd);
/* RTLIN_DUMP_DEBUG("AM RLC Stats:"
dlData, sizeof(RlcData));
if ( dlData == NULLP )
{
- DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed for dl data");
+ DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for dl data");
RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_DL, RLC_POOL,
datReqInfo, sizeof(RguDDatReqInfo));
return RFAILED;
if (dlData->pduInfo[dlData->numPdu].pduBuf == NULLP )
{
- DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed");
+ DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed");
for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
{
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData->pduInfo[pduIdx].pduBuf,\
dlRrcMsgRsp, sizeof(RlcDlRrcMsgRsp));
if( dlRrcMsgRsp == NULLP )
{
- DU_LOG("\nRLC: rlcSendDedLcDlData: Memory allocation failed for dlRrcMsgRsp");
+ DU_LOG("\nERROR --> RLC_DL : rlcSendDedLcDlData: Memory allocation failed for dlRrcMsgRsp");
for(pduIdx = 0; pduIdx < dlData->numPdu; pduIdx++)
{
RLC_FREE_SHRABL_BUF(pst.region, pst.pool, dlData->pduInfo[pduIdx].pduBuf,\
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( datReqInfo == NULLP )
{
- DU_LOG("\nRLC: rlcUtlSendToMac: Memory allocation failed");
+ DU_LOG("\nERROR --> RLC_DL : rlcUtlSendToMac: Memory allocation failed");
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
if(ROK != rlcDbmFetchDlUeCb(gCb, ueIdx, staIndInfo->cellId,&ueCb))
{
/* Fetch UeCb failed */
- DU_LOG("\nRLC: rlcUtlSendToMac: UeId[%u]:ueCb not found",
+ DU_LOG("\nERROR --> RLC_DL : rlcUtlSendToMac: UeId[%u]:ueCb not found",
staInd->rnti);
/* If ueCb is not found for current rnti then continue to look for next rnti*/
continue;
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
- RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
+ DU_LOG("\nDEBUG --> RLC_DL : rlcUtlSndL2MeasCfm(transId(%ld))", measEvtCb->transId);
#else
- RLOG1(L_DEBUG,"rlcUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
+ DU_LOG("\nDEBUG --> RLC_DL : rlcUtlSndL2MeasCfm(transId(%d))", measEvtCb->transId);
#endif
/* Clean up the RB data structures */
{
if(dlRbCb->mode == RLC_MODE_UM)
{
- RLOG_ARG3(L_DEBUG,DBG_RBID,dlRbCb->rlcId.rbId,
- "UM Downlink UEID:%d CELLID:%d Q size = %d",
+ DU_LOG("\nDEBUG --> RLC_DL : UM Downlink UEID:%d CELLID:%d Q size = %d",
dlRbCb->rlcId.ueId,
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.umDl.sduQ.count);
numTxPdus++;
}
}
- RLOG_ARG4(L_DEBUG,DBG_RBID,dlRbCb->rlcId.rbId,
- "AM Downlink UEID:%d CELLID:%d Sizes SDU Q = %d TX Q = %d ",
+ DU_LOG("\nDEBUG --> RLC_DL : AM Downlink UEID:%d CELLID:%d Sizes SDU Q = %d TX Q = %d ",
dlRbCb->rlcId.ueId,
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.amDl.sduQ.count,
(int)numTxPdus);
- RLOG_ARG3(L_DEBUG,DBG_RBID,dlRbCb->rlcId.rbId,
- "AM Downlink UEID:%d CELLID:%d RETX Q= %d",
+ DU_LOG("\nDEBUG --> RLC_DL : AM Downlink UEID:%d CELLID:%d RETX Q= %d",
dlRbCb->rlcId.ueId,
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.amDl.retxLst.count);
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
- //printf("D-sn(%d)\n", txBuf->hdr.sn);
+ //DU_LOG("\nINFO --> RLC_DL : D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
RLC_FREE(gCb, txBuf, sizeof(RlcTx));
return;
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
- //printf("D-sn(%d)\n", txBuf->hdr.sn);
+ //DU_LOG("\nINFO --> RLC_DL : D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
return;
} /* rlcUtlRemovTxBuf */
if( ROK != rlcDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
{
/* Fetch UeCb failed */
- DU_LOG("\nRLC : rlcUtlRcvFrmMac : UEID:%d UeCb not found",
+ DU_LOG("\nERROR --> RLC_UL : rlcUtlRcvFrmMac : UEID:%d UeCb not found",
datIndInfo->rnti);
/* free the buffers inside the datIndInfo */
uint32_t i,j;
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
#ifndef ALIGN_64BIT
- RLOG_ARG4(L_UNUSED, DBG_RBID,rbCb->rlcId.rbId,"Log for ul ip throughput:"
+ DU_LOG("\nDEBUG --> RLC_UL : Log for ul ip throughput:"
"RB_MeasOn:%d ttiCnt :%ld UEID:%d CELLID:%d",
rbCb->rbL2Cb.measOn,ttiCnt,
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
#else
- RLOG_ARG4(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, "Log for ul ip throughput:"
+ DU_LOG("\nDEBUG --> RLC_UL : Log for ul ip throughput:"
"RB_MeasOn:%d ttiCnt :%d UEID:%d CELLID:%d",
rbCb->rbL2Cb.measOn,ttiCnt,
rbCb->rlcId.ueId,
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
- RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
+ DU_LOG("\nDEBUG --> RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
#else
- RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
+ DU_LOG("\nDEBUG --> RLC_UL : rlcUtlSndUlL2MeasCfm(transId(%d))", measEvtCb->transId);
#endif
/* Clean up the RB data structures */
RLC_ALLOC_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCfgRsp));
if(!ueRsp)
{
- DU_LOG("RLC: Memory allocation failed for ueRsp at SendRlcUeCreateRspToDu()");
+ DU_LOG("\nERROR --> RLC: Memory allocation failed for ueRsp at SendRlcUeCreateRspToDu()");
ret = RFAILED;
}
else
ret = (*rlcUeCfgRspOpts[pst->selector])(pst, ueRsp);
if(ret)
{
- DU_LOG("RLC: Failed at SendRlcUeRspToDu()");
+ DU_LOG("\nERROR --> RLC: Failed at SendRlcUeRspToDu()");
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCfgRsp));
}
}
else
{
- DU_LOG("RLC: Failed at fillRlcUeCfgRsp() for event %d", pst->event);
+ DU_LOG("\nERROR --> RLC: Failed at fillRlcUeCfgRsp() for event %d", pst->event);
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueRsp, sizeof(RlcUeCfgRsp));
}
}
*direction = RLC_CFG_DIR_DL;
break;
default :
- DU_LOG("\nRLC: Rlc Mode invalid %d", rlcMode);
+ DU_LOG("\nERROR --> RLC: Rlc Mode invalid %d", rlcMode);
break;
}
}
RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo));
if(rlcUeCfg == NULLP)
{
- DU_LOG("\nRLC: Failed to allocate memory at RlcProcUeCreateReq()");
+ DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeCreateReq()");
ret = RFAILED;
}
else
fillRlcCfg(rlcUeCfg, ueCfg);
ret = RlcProcCfgReq(pst, rlcUeCfg);
if(ret != ROK)
- DU_LOG("\nRLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()");
+ DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeCreateReq()");
}
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg));
Pst pst;
RrcDeliveryReport *rrcDelivery;
- DU_LOG("\nRLC : Filling the RRC Delivery Report");
+ DU_LOG("\nINFO --> RLC : Filling RRC Delivery Report");
RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, rrcDelivery, sizeof(RrcDeliveryReport));
if(rrcDelivery)
}
else
{
- DU_LOG("\nRLC : Memory allocation failed");
+ DU_LOG("\nERROR --> RLC : Memory allocation failed");
}
return ROK;
RLC_SHRABL_STATIC_BUF_ALLOC(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(KwuDatReqInfo));
if(!datReqInfo)
{
- DU_LOG("\nRLC : Memory allocation failed in RlcProcDlRrcMsgTransfer");
+ DU_LOG("\nERROR --> RLC : Memory allocation failed in RlcProcDlRrcMsgTransfer");
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
return RFAILED;
/* Copy fixed buffer to message */
if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &mBuf) != ROK)
{
- DU_LOG("\nRLC : Memory allocation failed at RlcMacProcUlData");
+ DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_DL, RLC_POOL, datReqInfo, sizeof(KwuDatReqInfo));
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo->rrcMsg, dlRrcMsgInfo->msgLen);
RLC_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, dlRrcMsgInfo, sizeof(RlcDlRrcMsgInfo));
RguCDatIndInfo *cLchUlDat; /* UL data on common logical channel */
/* Initializing dedicated logical channel Database */
- DU_LOG("\nRLC: Received UL Data request from MAC");
+ DU_LOG("\nDEBUG --> RLC: Received UL Data request from MAC");
for(idx = 0; idx < MAX_NUM_LC; idx++)
{
dLchData[idx].lcId = idx;
sizeof(RguCDatIndInfo));
if(!cLchUlDat)
{
- DU_LOG("\nRLC : Memory allocation failed at RlcProcUlData");
+ DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData");
ret = RFAILED;
break;
}
/* Copy fixed buffer to message */
if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, &cLchUlDat->pdu) != ROK)
{
- DU_LOG("\nRLC : Memory allocation failed at RlcProcUlData");
+ DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcProcUlData");
RLC_SHRABL_STATIC_BUF_FREE(RLC_MEM_REGION_UL, RLC_POOL, cLchUlDat, \
sizeof(RguCDatIndInfo));
ret = RFAILED;
sizeof(RguDDatIndInfo));
if(!dLchUlDat)
{
- DU_LOG("\nRLC : Memory allocation failed at RlcMacProcUlData");
+ DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
ret = RFAILED;
break;
}
if(ODU_GET_MSG_BUF(RLC_MEM_REGION_UL, RLC_POOL, \
&dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]) != ROK)
{
- DU_LOG("\nRLC : Memory allocation failed at RlcMacProcUlData");
+ DU_LOG("\nERROR --> RLC : Memory allocation failed at RlcMacProcUlData");
for(pduIdx=0; pduIdx < dLchData[lcId].pdu.numPdu; pduIdx++)
{
ODU_PUT_MSG_BUF(dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu]);
RguCStaIndInfo *cLchSchInfo; /* Common logical channel scheduling result */
RguDStaIndInfo *dLchSchInfo; /* Dedicated logical channel scheduling result */
- DU_LOG("\nRLC : Received scheduling report from MAC");
+ DU_LOG("\nDEBUG --> RLC : Received scheduling report from MAC");
for(idx=0; idx < schRep->numLc; idx++)
{
/* If it is common channel, fill status indication information
sizeof(RguCStaIndInfo));
if(!cLchSchInfo)
{
- DU_LOG("\nRLC: RlcProcSchedResultRpt: Memory allocation failed for cLchSchInfo");
+ DU_LOG("\nERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for cLchSchInfo");
ret = RFAILED;
break;
}
sizeof(RguDStaIndInfo));
if(!dLchSchInfo)
{
- DU_LOG("\nRLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo");
+ DU_LOG("\nERROR --> RLC: RlcProcSchedResultRpt: Memory allocation failed for dLchSchInfo");
ret = RFAILED;
break;
}
RlcCfgInfo *rlcUeCfg = NULLP; //Seed code Rlc cfg struct
RlcCb *rlcUeCb = NULLP;
- DU_LOG("\nRLC: UE reconfig request received. CellID[%d] UEIDX[%d]",ueCfg->cellId, ueCfg->ueIdx);
+ DU_LOG("\nDEBUG --> RLC: UE reconfig request received. CellID[%d] UEIDX[%d]",ueCfg->cellId, ueCfg->ueIdx);
rlcUeCb = RLC_GET_RLCCB(pst->dstInst);
RLC_ALLOC(rlcUeCb, rlcUeCfg, sizeof(RlcCfgInfo));
if(rlcUeCfg == NULLP)
{
- DU_LOG("\nRLC: Failed to allocate memory at RlcProcUeReconfigReq()");
+ DU_LOG("\nERROR --> RLC: Failed to allocate memory at RlcProcUeReconfigReq()");
ret = RFAILED;
}
else
fillRlcCfg(rlcUeCfg, ueCfg);
ret = RlcProcCfgReq(pst, rlcUeCfg);
if(ret != ROK)
- DU_LOG("\nRLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()");
+ DU_LOG("\nERROR --> RLC: Failed to configure Add/Mod/Del entities at RlcProcUeReconfigReq()");
}
RLC_FREE_SHRABL_BUF(pst->region, pst->pool, ueCfg, sizeof(RlcUeCfg));
Code Review / o-du / l2.git / commitdiff