Desc: Source code for RLC Utility Module
This file contains following functions
- --rlcUtlSndToLi
- --rlcUtlRcvFrmLi
+ --rlcUtlSendToMac
+ --rlcUtlRcvFrmMac
--rlcUtlEmptySduQ
- --rlcUtlSndDatInd
+ --rlcUtlSendUlDataToDu
--kwUtlShutDown
File: kw_utl_ul.c
#include "kw.x" /* RLC inlcudes */
#include "kw_ul.x" /* RLC uplink includes */
-#include "ss_rbuf.h"
-#include "ss_rbuf.x"
+#include "rlc_utils.h"
+#include "du_app_rlc_inf.h"
+#include "rlc_upr_inf_api.h"
+
#ifdef SS_RBUF
S16 SMrkUlPkt(Buffer *mbuf);
#endif
* -# RFAILED
*
*/
-#ifdef ANSI
-S16 rlcUtlRcvFrmLi
-(
-RlcCb *gCb,
-KwDatIndInfo *datIndInfo
-)
-#else
-S16 rlcUtlRcvFrmLi(gCb,datIndInfo)
-RlcCb *gCb;
-KwDatIndInfo *datIndInfo;
-#endif
+uint8_t rlcUtlRcvFrmMac(RlcCb *gCb, KwDatIndInfo *datIndInfo)
{
- U32 count; /* Loop Counter */
+ uint32_t count; /* Loop Counter */
KwPduInfo *pduInfo; /* PDU Information */
RlcUlRbCb *rbCb; /* RB Control Block */
RlcUlUeCb *ueCb; /* UE Control Block */
-/* kw005.201 added support for L2 Measurement */
-
- TRC2(rlcUtlRcvFrmLi)
-
ueCb = NULLP;
if( ROK != rlcDbmFetchUlUeCb(gCb,datIndInfo->rnti,datIndInfo->cellId,&(ueCb)))
{
/* Fetch UeCb failed */
- RLOG_ARG1(L_ERROR,DBG_CELLID,datIndInfo->cellId,
- "UEID:%d UeCb not found",
+ DU_LOG("\nRLC : rlcUtlRcvFrmMac : UEID:%d UeCb not found",
datIndInfo->rnti);
/* free the buffers inside the datIndInfo */
- U32 i,j;
+ uint32_t i,j;
for(i = 0; i< datIndInfo->numLch; i++)
{
for(j = 0; j < datIndInfo->lchData[i].pdu.numPdu; 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(rbCb == NULLP)
{
- U32 j;
+ uint32_t j;
for(j = 0; j < pduInfo->numPdu; j++)
{
if(pduInfo->mBuf[j])
{
- RLC_FREE_BUF_WC(pduInfo->mBuf[j]);
+ ODU_PUT_MSG_BUF(pduInfo->mBuf[j]);
}
}
continue;
* @return S16
* -# ROK
*/
-#ifdef ANSI
-S16 rlcUtlSndDatInd
-(
-RlcCb *gCb,
-RlcUlRbCb *rbCb,
-Buffer *sdu
-)
-#else
-S16 rlcUtlSndDatInd(gCb,rbCb,sdu)
-RlcCb *gCb;
-RlcUlRbCb *rbCb;
-Buffer *sdu;
-#endif
+uint8_t rlcUtlSendUlDataToDu(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *sdu)
{
#ifndef KW_PDCP
KwuDatIndInfo *datIndInfo; /* Data Indication Information */
KwuDatIndInfo datIndInfoTmp;
#endif
-
- TRC3(rlcUtlSndDatInd)
-
+ RlcUlRrcMsgInfo *ulRrcMsgInfo;
+ uint16_t msgLen, copyLen;
+ Pst pst;
#ifndef KW_PDCP
/* Creating static memory for KwuDatIndInfo. #else will be
#if (ERRCLASS & ERRCLS_ADD_RES )
if ( datIndInfo == NULLP )
{
- RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId,
- "Memory allocation failed UEID:%d CELLID:%d",
- rbCb->rlcId.ueId,
- rbCb->rlcId.cellId);
- RLC_FREE_BUF(sdu);
+ DU_LOG("\nRLC : rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
+ CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+ ODU_PUT_MSG_BUF(sdu);
return RFAILED;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
datIndInfo->isOutOfSeq = rbCb->m.amUl.isOutOfSeq;
#endif /* KW_PDCP */
- /* If trace flag is enabled send the trace indication */
- if(gCb->init.trc == TRUE)
+ /* Filling UL RRC Message Info */
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
+ ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
+ if (ulRrcMsgInfo)
{
- /* Populate the trace params */
- rlcLmmSendTrc(gCb,KWU_EVT_DAT_IND, sdu);
- }
-#ifndef KW_PDCP
+ 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;
+ }
- RlcUiKwuDatInd(&gCb->genCfg.lmPst, datIndInfo, sdu);
-#endif
- return (ROK);
-} /* rlcUtlSndDatInd */
+ return ROK;
+} /* rlcUtlSendUlDataToDu */
-PRIVATE Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
+static Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
{
if(ulRbCb->mode == CM_LTE_MODE_UM)
{
- U32 i;
- U32 pdusInReceptionBuffer = 0;
- U32 windSz = ulRbCb->m.umUl.umWinSz << 1;
+ uint32_t i;
+ uint32_t pdusInReceptionBuffer = 0;
+ uint32_t windSz = ulRbCb->m.umUl.umWinSz << 1;
for(i = 0; i< windSz; i++)
{
}
else if(ulRbCb->mode == CM_LTE_MODE_AM)
{
- U32 i;
- U32 pdusInReceptionBuffer = 0;
- U32 totalSegs = 0;
- U32 windSz = RLC_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
+ uint32_t i;
+ uint32_t pdusInReceptionBuffer = 0;
+ uint32_t totalSegs = 0;
+ uint32_t windSz = RLC_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
for(i = 0; i< windSz; i++)
{
(PTR) ueCb,
(PTR *)&ueCb))
{
- U32 i;
+ uint32_t i;
for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
{
RlcUlRbCb* ulRbCb = ueCb->srbCb[i];
*/
S16 rlcUtlL2MeasUlInit(RlcCb *gCb)
{
- U16 cntr;
+ uint16_t cntr;
gCb->u.ulCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- cmMemset((U8 *)&(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
+ memset(&(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr]), 0, sizeof(RlcL2MeasEvtCb));
}
gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[RLC_L2MEAS_UL_IP].measCb.measType = LKW_L2MEAS_UL_IP;
return ROK;
* @return Void
*
*/
-#ifdef ANSI
- Void rlcUtlCalUlIpThrPutIncTTI
-(
-RlcCb *gCb,
-RlcUlRbCb *rbCb,
-U32 ttiCnt
-)
-#else
-Void rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb, ttiCnt)
-RlcCb *gCb;
-RlcUlRbCb *rbCb;
-U32 ttiCnt;
-#endif
+Void rlcUtlCalUlIpThrPutIncTTI(RlcCb *gCb,RlcUlRbCb *rbCb,uint32_t ttiCnt)
{
- VOLATILE U32 startTime = 0;
- TRC2(rlcUtlCalUlIpThrPutIncTTI)
+ volatile uint32_t startTime = 0;
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
* @return Void
*
*/
-#ifdef ANSI
- Void rlcUtlCalUlIpThrPut
+Void rlcUtlCalUlIpThrPut
(
-RlcCb *gCb,
-RlcUlRbCb *rbCb,
-Buffer *pdu,
-U32 ttiCnt
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
+Buffer *pdu,
+uint32_t ttiCnt
)
-#else
-Void rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt)
- RlcCb *gCb;
- RlcUlRbCb *rbCb;
- Buffer *pdu;
- U32 ttiCnt;
-#endif
{
MsgLen rlcSduSz = 0; /*Holds length of Rlc Sdu*/
- VOLATILE U32 startTime = 0;
- TRC2(rlcUtlCalUlIpThrPut)
-
+ volatile uint32_t startTime = 0;
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCVOL);
* -# ROK
*/
-#ifdef ANSI
-S16 rlcUtlHdlL2TmrExp
-(
-RlcCb *gCb,
-RlcL2MeasEvtCb *measEvtCb
-)
-#else
-S16 rlcUtlHdlL2TmrExp(measEvtCb)
-RlcCb *gCb;
-RlcL2MeasEvtCb *measEvtCb;
-#endif
+S16 rlcUtlHdlL2TmrExp(RlcCb *gCb,RlcL2MeasEvtCb *measEvtCb)
{
- TRC3(rlcUtlHdlL2TmrExp)
#ifdef LTE_L2_MEAS_RLC
- U16 qciIdx;
+ uint16_t qciIdx;
RlcL2MeasCb *measCb;
/* Clean up the RB data structures */
* -# ROK
*/
-#ifdef ANSI
-S16 rlcUtlSndUlL2MeasCfm
-(
-RlcCb *gCb,
-RlcL2MeasEvtCb *measEvtCb
-)
-#else
-S16 rlcUtlSndUlL2MeasCfm(gCb, measEvtCb)
-RlcCb *gCb;
-RlcL2MeasEvtCb *measEvtCb;
-#endif
+S16 rlcUtlSndUlL2MeasCfm(RlcCb *gCb,RlcL2MeasEvtCb *measEvtCb)
{
- U32 qciIdx;
- RlcL2MeasCb *measCb;
- RlcL2MeasCfmEvt measCfmEvt;
-
- U64 ulDataVol;
- U64 ulTime;
- U16 cntr;
+ uint32_t qciIdx;
+ RlcL2MeasCb *measCb;
+ RlcL2MeasCfmEvt measCfmEvt;
+ uint64_t ulDataVol;
+ uint64_t ulTime;
+ uint16_t cntr;
/* Discard new changes starts */
- U8 qci = 0;
- U32 cfmIdx =0;
+ uint8_t qci = 0;
+ uint32_t cfmIdx =0;
/* Discard new changes ends */
- TRC3(rlcUtlSndUlL2MeasCfm)
-
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
#ifndef ALIGN_64BIT
RLOG1(L_DEBUG,"rlcUtlSndUlL2MeasCfm(transId(%ld))", measEvtCb->transId);
/* Clean up the RB data structures */
measCb = &measEvtCb->measCb;
- cmMemset((U8*)&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
+ memset(&measCfmEvt, 0, sizeof(RlcL2MeasCfmEvt));
measCfmEvt.transId = measEvtCb->transId;
measCfmEvt.measType = measCb->measType;
* -# ROK
*/
-#ifdef ANSI
-S16 rlcUtlSndUlL2MeasNCfm
-(
-RlcCb *gCb,
-RlcL2MeasReqEvt *measReqEvt,
-RlcL2MeasCfmEvt *measCfmEvt
-)
-#else
-S16 rlcUtlSndUlL2MeasNCfm(gCb, measReqEvt, measCfmEvt)
-RlcCb *gCb;
-RlcL2MeasReqEvt *measReqEvt;
-RlcL2MeasCfmEvt *measCfmEvt;
-#endif
+S16 rlcUtlSndUlL2MeasNCfm(RlcCb *gCb,RlcL2MeasReqEvt *measReqEvt,RlcL2MeasCfmEvt *measCfmEvt)
{
- TRC3(rlcUtlSndUlL2MeasNCfm)
RlcMiLkwL2MeasCfm(&gCb->genCfg.lmPst, measCfmEvt);
return ROK;
* @param[out] numLCh Number of LCh in array lChId.
**/
-#ifdef ANSI
S16 rlcUtlValidateL2Meas
(
RlcL2MeasReqEvt *measReqEvt,
RlcL2MeasCfmEvt *measCfmEvt,
-CmLteLcId *lChId,
-U8 *numLCh
+CmLteLcId *lChId,
+uint8_t *numLCh
)
-#else
-S16 rlcUtlValidateL2Meas(measReqEvt, measCfmEvt, lChId, numLCh)
-RlcL2MeasReqEvt *measReqEvt;
-RlcL2MeasCfmEvt *measCfmEvt;
-CmLteLcId *lChId;
-U8 *numLCh;
-#endif
{
- U8 measType;
- S16 ret;
- U8 qciIdx;
- U8 qci;
- U8 idx;
- U8 *qciVal;
- U8 numQci;
+ uint8_t measType;
+ S16 ret;
+ uint8_t qciIdx;
+ uint8_t qci;
+ uint8_t idx;
+ uint8_t *qciVal;
+ uint8_t numQci;
RlcUlRbCb *rbCb;
-
- RlcUlUeCb *ueCb;
+ RlcUlUeCb *ueCb;
RbCb **rbCbLst;
- U8 rbIdx;
- U8 lsbNibble = 0;
- U8 msbNibble = 0;
- U8 numFaild = 0;
+ uint8_t rbIdx;
+ uint8_t lsbNibble = 0;
+ uint8_t msbNibble = 0;
+ uint8_t numFaild = 0;
-
- TRC3(rlcUtlValidateL2Meas)
-
idx = 0;
rbCb = NULLP;
ret = ROK;
{
qci = qciVal[qciIdx];
ret = cmHashListFind(&(rlcCb.rlcL2Cb.qciHlCp),
- (U8 *)&qci, (U16)sizeof(qci), 0, (PTR *)&rbCb);
+ (uint8_t *)&qci, (uint16_t)sizeof(qci), 0, (PTR *)&rbCb);
if(ret != ROK)
{
measCfmEvt->val.nonIpThMeas.measCfm[measCfmEvt->val.nonIpThMeas.numCfm].qci = qci;
}/* rlcUtlValidateL2Meas */
#endif
-#ifdef ANSI
-S16 rlcUtlValidateIpThL2Meas
-(
-RlcL2MeasReqEvt *measReqEvt,
-RlcL2MeasCfmEvt *measCfmEvt
-)
-#else
-S16 rlcUtlValidateIpThL2Meas(measReqEvt, measCfmEvt)
-RlcL2MeasReqEvt *measReqEvt;
-RlcL2MeasCfmEvt *measCfmEvt;
-#endif
+S16 rlcUtlValidateIpThL2Meas(RlcL2MeasReqEvt *measReqEvt,RlcL2MeasCfmEvt *measCfmEvt)
{
- U8 measType;
- U8 lsbNibble = 0;
- U8 msbNibble = 0;
+ uint8_t measType;
+ uint8_t lsbNibble = 0;
+ uint8_t msbNibble = 0;
- TRC3(rlcUtlValidateIpThL2Meas)
-
measType = measReqEvt->measReq.measType;
/* Check for the range of measType */
/* LKW_L2MEAS_DL_IP+ LKW_L2MEAS_UL_IP = 0x0030*/
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlResetUlL2MeasInRlcRb
-(
-RlcCb *gCb,
-RlcL2MeasCb *measCb,
-U8 measType
-)
-#else
-Void rlcUtlResetUlL2MeasInRlcRb(measCb, measType)
-RlcCb *gCb;
-RlcL2MeasCb *measCb;
-U8 measType;
-#endif
+Void rlcUtlResetUlL2MeasInRlcRb(RlcCb *gCb,RlcL2MeasCb *measCb,uint8_t measType)
{
- U32 rbIdx;
- U32 ueIdx;
- U32 qciIdx;
+ uint32_t rbIdx;
+ uint32_t ueIdx;
+ uint32_t qciIdx;
RlcUlUeCb *ueCb = NULL;
* @return S16
* -# ROK
*/
-#ifdef ANSI
-Void rlcUtlPlcMeasDatInL2Sts
-(
-RlcL2Cntr *measData,
-RlcL2MeasRbCb *rbL2Cb,
-U8 measType
-)
-#else
-Void rlcUtlPlcMeasDatInL2Sts(measData, rbL2Cb, measType)
-RlcL2Cntr *measData;
-RlcL2MeasRbCb *rbL2Cb;
-U8 measType;
-#endif
+Void rlcUtlPlcMeasDatInL2Sts(RlcL2Cntr *measData,RlcL2MeasRbCb *rbL2Cb,uint8_t measType)
{
- TRC3(rlcUtlPlcMeasDatInL2Sts)
-
/* We should check the number of measType in the request. This can be done
* by looking at each bit in the measType. Also store the measData in the
* correct index of l2Sts in RbCb.
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlStoreRecBuf
-(
-CmLListCp *recBufLst,
-RlcAmRecBuf *recBuf,
-RlcSn sn
-)
-#else
-Void rlcUtlStoreRecBuf(recBufLst, recBuf, sn)
-CmLListCp *recBufLst;
-RlcAmRecBuf *recBuf;
-RlcSn sn;
-#endif
+void rlcUtlStoreRecBuf(CmLListCp *recBufLst, RlcAmRecBuf *recBuf, RlcSn sn)
{
- U32 hashKey;
-
- TRC3(rlcUtlStoreRecBuf)
+ uint32_t hashKey;
hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
recBuf->lnk.node = (PTR)recBuf;
cmLListAdd2Tail(&(recBufLst[hashKey]), &recBuf->lnk);
- RETVOID;
+ return;
} /* rlcUtlStoreRecBuf */
/**
*
* @return Void
*/
-#ifdef ANSI
-RlcAmRecBuf* rlcUtlGetRecBuf
-(
-CmLListCp *recBufLst,
-RlcSn sn
-)
-#else
-RlcAmRecBuf* rlcUtlGetRecBuf(recBufLst, sn)
-CmLListCp *recBufLst;
-RlcSn sn;
-#endif
+RlcAmRecBuf* rlcUtlGetRecBuf(CmLListCp *recBufLst, RlcSn sn)
{
- U32 hashKey;
+ uint32_t hashKey;
CmLListCp *recBufLstCp;
- RlcAmRecBuf *recBuf;
+ RlcAmRecBuf *recBuf;
CmLList *node = NULLP;
- TRC3(rlcUtlGetRecBuf)
-
hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
recBufLstCp = &recBufLst[hashKey];
recBuf = (RlcAmRecBuf *) node->node;
if(recBuf->amHdr.sn == sn)
{
- return (recBuf);
+ return recBuf;
}
CM_LLIST_NEXT_NODE(recBufLstCp, node);
}
- return (NULLP);
-} /* rlcUtlStoreRecBuf */
+ return NULLP;
+} /* rlcUtlGetRecBuf */
/**
*
* @brief Delete the UL buffer from the list
*
* @return Void
*/
-#ifdef ANSI
-Void rlcUtlDelRecBuf
-(
-CmLListCp *recBufLst,
-RlcAmRecBuf *recBuf,
-RlcCb *gCb
-)
-#else
-Void rlcUtlDelRecBuf(recBufLst, recBufi, gCb)
-CmLListCp *recBufLst;
-RlcAmRecBuf *recBuf;
-RlcCb *gCb;
-#endif
+void rlcUtlDelRecBuf(CmLListCp *recBufLst, RlcAmRecBuf *recBuf, RlcCb *gCb)
{
- U32 hashKey;
+ uint32_t hashKey;
CmLListCp *recBufLstCp;
- TRC3(rlcUtlDelRecBuf)
-
hashKey = (recBuf->amHdr.sn % RLC_RCV_BUF_BIN_SIZE );
recBufLstCp = &recBufLst[hashKey];
cmLListDelFrm(recBufLstCp, &recBuf->lnk);
- RLC_FREE_WC(gCb, recBuf, sizeof(RlcAmRecBuf));
+ RLC_FREE(gCb, recBuf, sizeof(RlcAmRecBuf));
- RETVOID;
+ return;
} /* rlcUtlDelRecBuf */
+#ifdef NR_RLC_UL
+/**
+ *
+ * @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 */
+#endif
/********************************************************************30**
Code Review / o-du / l2.git / blobdiff