/**********************************************************************
- Name: LTE-RLC Layer
+ Name: NR RLC Layer
Type: C file
File: kw_utl_ul.c
**********************************************************************/
-static const char* RLOG_MODULE_NAME="UTL";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=210;
/** @file kw_utl_ul.c
@brief RLC Utility Module
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;
{
if(datIndInfo->lchData[i].pdu.mBuf[j])
{
- RLC_FREE_BUF_WC(datIndInfo->lchData[i].pdu.mBuf[j]);
+ ODU_PUT_MSG_BUF(datIndInfo->lchData[i].pdu.mBuf[j]);
}
}
}
{
if(pduInfo->mBuf[j])
{
- RLC_FREE_BUF_WC(pduInfo->mBuf[j]);
+ ODU_PUT_MSG_BUF(pduInfo->mBuf[j]);
}
}
continue;
#ifdef SS_RBUF
SMrkUlPkt(pduInfo->mBuf[0]);
#endif
- if ( rbCb->mode == CM_LTE_MODE_UM )
+ if ( rbCb->mode == RLC_MODE_UM )
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
rlcUmmProcessPdus(gCb,rbCb,pduInfo);
#endif
}
- else if (rbCb->mode == CM_LTE_MODE_AM )
+ else if (rbCb->mode == RLC_MODE_AM )
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
KwuDatIndInfo *datIndInfo; /* Data Indication Information */
KwuDatIndInfo datIndInfoTmp;
#endif
- RlcUlRrcMsgInfo *ulRrcMsgInfo;
+ RlcUlRrcMsgInfo *ulRrcMsgInfo;
+ RlcUlUserDatInfo *ulUserDatInfo;
uint16_t msgLen, copyLen;
Pst pst;
/* Creating static memory for KwuDatIndInfo. #else will be
* removed once the testing is done on all platforms */
datIndInfo = &datIndInfoTmp;
-
-#if (ERRCLASS & ERRCLS_ADD_RES )
- if ( datIndInfo == NULLP )
+ if (datIndInfo == NULLP)
{
- DU_LOG("\nRLC : rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- RLC_FREE_BUF(sdu);
+ ODU_PUT_MSG_BUF(sdu);
return RFAILED;
}
-#endif /* ERRCLASS & ERRCLS_ADD_RES */
RLC_MEM_CPY(&(datIndInfo->rlcId),&(rbCb->rlcId),sizeof(CmLteRlcId));
/* Set the "isOutofSeq" flag for each packet
datIndInfo->isOutOfSeq = rbCb->m.amUl.isOutOfSeq;
#endif /* KW_PDCP */
- /* Filling UL RRC Message Info */
- RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
- ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
- if (ulRrcMsgInfo)
+ if(rbCb->rlcId.rbType == RB_TYPE_SRB)
{
- ulRrcMsgInfo->cellId = rbCb->rlcId.cellId;
- ulRrcMsgInfo->ueIdx = rbCb->rlcId.ueId;
- ulRrcMsgInfo->lcId = rbCb->lch.lChId;
- RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
- ulRrcMsgInfo->rrcMsg, msgLen);
- if (ulRrcMsgInfo->rrcMsg)
- {
- ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
- ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulRrcMsgInfo->rrcMsg, (MsgLen *)©Len);
- ulRrcMsgInfo->msgLen = msgLen;
-
- /* Sending UL RRC Message transfeer to DU APP */
- memset(&pst, 0, sizeof(Pst));
- FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_RRC_MSG_TRANS_TO_DU);
- rlcSendUlRrcMsgToDu(&pst, ulRrcMsgInfo);
- }
- else
- {
- DU_LOG("\nRLC : rlcUtlSendUlDataToDu: Memory allocation failed for rrcMsg");
- RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
- return RFAILED;
- }
- }
- else
- {
- DU_LOG("\nRLC : rlcUtlSendUlDataToDu: Memory allocation failed for ulRrcMsgInfo");
- return RFAILED;
- }
-
+ /* Filling UL RRC Message Info if UL msg is not received on SRBs*/
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
+ ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
+ if (ulRrcMsgInfo)
+ {
+ ulRrcMsgInfo->cellId = rbCb->rlcId.cellId;
+ ulRrcMsgInfo->ueIdx = rbCb->rlcId.ueId;
+ ulRrcMsgInfo->lcId = rbCb->lch.lChId;
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
+ ulRrcMsgInfo->rrcMsg, msgLen);
+ if (ulRrcMsgInfo->rrcMsg)
+ {
+ ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
+ ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulRrcMsgInfo->rrcMsg, (MsgLen *)©Len);
+ ulRrcMsgInfo->msgLen = msgLen;
+
+ /* Sending UL RRC Message transfeer to DU APP */
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_RRC_MSG_TRANS_TO_DU);
+ rlcSendUlRrcMsgToDu(&pst, ulRrcMsgInfo);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for rrcMsg");
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulRrcMsgInfo");
+ return RFAILED;
+ }
+ }
+ else if(rbCb->rlcId.rbType == RB_TYPE_DRB)
+ {
+ /* Filling UL User Data Info if UL msg is received on a DRB */
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo, sizeof(RlcUlUserDatInfo));
+ if (ulUserDatInfo)
+ {
+ ulUserDatInfo->cellId = rbCb->rlcId.cellId;
+ ulUserDatInfo->ueIdx = rbCb->rlcId.ueId;
+ ulUserDatInfo->rbId = rbCb->rlcId.rbId;
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo->userData, msgLen);
+ if (ulUserDatInfo->userData)
+ {
+ ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
+ ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulUserDatInfo->userData, (MsgLen *)©Len);
+ ulUserDatInfo->msgLen = msgLen;
+
+ /* Sending UL RRC Message transfeer to DU APP */
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_USER_DATA_TRANS_TO_DU);
+ rlcSendUlUserDataToDu(&pst, ulUserDatInfo);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for user data");
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo, sizeof(RlcUlUserDatInfo));
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulUserDatInfo");
+ return RFAILED;
+ }
+ }
return ROK;
} /* rlcUtlSendUlDataToDu */
static Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
{
- if(ulRbCb->mode == CM_LTE_MODE_UM)
+ if(ulRbCb->mode == RLC_MODE_UM)
{
uint32_t i;
uint32_t pdusInReceptionBuffer = 0;
- uint32_t windSz = ulRbCb->m.umUl.umWinSz << 1;
+ uint32_t totalSegs = 0;
- for(i = 0; i< windSz; i++)
+ for(i = 0; i< RLC_RCV_BUF_BIN_SIZE; i++)
{
- if(ulRbCb->m.umUl.recBuf[i] != NULLP)
+ RlcUmRecBuf *recBuf = rlcUtlGetUmRecBuf(ulRbCb->m.umUl.recBufLst, i);
+ if(recBuf != NULLP)
{
- pdusInReceptionBuffer++;
+ pdusInReceptionBuffer++;
+ totalSegs += (recBuf->segLst.count);
}
}
- RLOG_ARG3(L_DEBUG,DBG_RBID,ulRbCb->rlcId.rbId,
- "UM UL UEID:%d CELLID:%d Reception Buffer size = %d",
- (int)ulRbCb->rlcId.ueId,
- (int)ulRbCb->rlcId.cellId,
- (int)pdusInReceptionBuffer);
+ DU_LOG("\nDEBUG --> RLC_UL: UM UL UEID:%d CELLID:%d Reception Buffer size = %d Total segs = %d",
+ ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
}
- else if(ulRbCb->mode == CM_LTE_MODE_AM)
+ else if(ulRbCb->mode == RLC_MODE_AM)
{
uint32_t i;
uint32_t pdusInReceptionBuffer = 0;
}
}
- RLOG_ARG4(L_DEBUG,DBG_RBID,ulRbCb->rlcId.rbId,
- "AM UL UEID:%d CELLID:%d Reception Buf size = %d"
- "total segs = %d",
- (int)ulRbCb->rlcId.ueId,
- (int)ulRbCb->rlcId.cellId,
- (int)pdusInReceptionBuffer,
- (int)totalSegs);
+ DU_LOG("\nDEBUG --> RLC_UL: AM UL UEID:%d CELLID:%d Reception Buf size = %d total segs = %d",
+ ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
}
}
/*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,
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.sampOc++;
}
measEvtCb->val.nonIpThMeas.measCb.numSamples--;
- rlcStartTmr(gCb, (PTR)measEvtCb, RLC_EVT_L2_TMR);
+ rlcStartTmr(gCb, (PTR)measEvtCb, EVENT_RLC_L2_TMR);
return (ROK);
}
#endif
/* 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 */
CM_LLIST_NEXT_NODE(recBufLstCp, node);
}
return NULLP;
-} /* rlcUtlStoreRecBuf */
+} /* rlcUtlGetRecBuf */
/**
*
* @brief Delete the UL buffer from the list
recBufLstCp = &recBufLst[hashKey];
cmLListDelFrm(recBufLstCp, &recBuf->lnk);
- RLC_FREE_WC(gCb, recBuf, sizeof(RlcAmRecBuf));
+ RLC_FREE(gCb, recBuf, sizeof(RlcAmRecBuf));
return;
} /* rlcUtlDelRecBuf */
+/**
+ *
+ * @brief Store the UL buffer in hashList
+ *
+ * @b Description
+ *
+ * Use the SN % binSize as key and store the received UL buffer
+ * @param[in] recBufLst List CP array
+ * @param[in] recBuf received buffer
+ * @param[in] sn sn of the received buffer
+ *
+ * @return Void
+ */
+void rlcUtlStoreUmRecBuf(CmLListCp *recBufLst, RlcUmRecBuf *recBuf, RlcSn sn)
+{
+ uint32_t hashKey;
+
+ hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
+ recBuf->lnk.node = (PTR)recBuf;
+ cmLListAdd2Tail(&(recBufLst[hashKey]), &recBuf->lnk);
+
+ return;
+} /* rlcUtlStoreUmRecBuf */
+
+/**
+ *
+ * @brief Retrieve the UL buffer from the list
+ *
+ * @Description
+ *
+ * Use the SN % binSize as key and retrieve the UL buffer
+ * @param[in] recBufLst List CP array
+ * @param[in] sn sn of the received buffer
+ *
+ * @return Void
+ */
+RlcUmRecBuf* rlcUtlGetUmRecBuf(CmLListCp *recBufLst, RlcSn sn)
+{
+ uint32_t hashKey;
+ CmLListCp *recBufLstCp;
+ RlcUmRecBuf *recBuf;
+ CmLList *node = NULLP;
+
+ hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
+
+ recBufLstCp = &recBufLst[hashKey];
+ CM_LLIST_FIRST_NODE(recBufLstCp, node);
+ while(node)
+ {
+ recBuf = (RlcUmRecBuf *) node->node;
+ if(recBuf->umHdr.sn == sn)
+ {
+ return recBuf;
+ }
+ CM_LLIST_NEXT_NODE(recBufLstCp, node);
+ }
+ return NULLP;
+} /* rlcUtlGetUmRecBuf */
+
+/**
+ *
+ * @brief Delete the UM Mode UL buffer from the list
+ *
+ *
+ * @details
+ * Use the SN % binSize as key and retrieve the UL buffer
+ *
+ * @param[in] *recBufLst List CP array
+ * @param[in] *recBuf Received buffer
+ *
+ * @return Void
+ */
+void rlcUtlDelUmRecBuf(RlcCb *gCb, CmLListCp *recBufLst, RlcUmRecBuf *recBuf)
+{
+ uint32_t hashKey;
+ CmLListCp *recBufLstCp;
+ hashKey = (recBuf->sn % RLC_RCV_BUF_BIN_SIZE );
+ recBufLstCp = &recBufLst[hashKey];
+ cmLListDelFrm(recBufLstCp, &recBuf->lnk);
+ RLC_FREE(gCb, recBuf, sizeof(RlcUmRecBuf));
+ return;
+} /* rlcUtlDelUmRecBuf */
/********************************************************************30**
End of file
Code Review / o-du / l2.git / blobdiff