X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_umm_ul.c;h=14ecb0d0b110e084243387860038c234538730c1;hb=403f2638b77471fec732ad1d24d6a0746ac1237a;hp=ab849f4d819b26de431322b2eae8e69641a107e7;hpb=4d45b914f9e94203603d3b9fdbcb1aad361301dd;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_umm_ul.c b/src/5gnrrlc/kw_umm_ul.c index ab849f4d8..14ecb0d0b 100755 --- a/src/5gnrrlc/kw_umm_ul.c +++ b/src/5gnrrlc/kw_umm_ul.c @@ -25,19 +25,15 @@ Desc: Source code for RLC Unacknowledged mode assembly and reassembly.This file contains following functions - --kwUmmQSdu - --kwUmmProcessSdus - --kwUmmProcessPdus - --kwUmmReAssembleSdus + --rlcUmmQSdu + --rlcUmmProcessSdus + --rlcUmmProcessPdus + --rlcUmmReAssembleSdus --kwUmmReEstablish File: kw_umm_ul.c **********************************************************************/ -static const char* RLOG_MODULE_NAME="RLC"; -static int RLOG_MODULE_ID=2048; -static int RLOG_FILE_ID=240; - /** * @file kw_umm_ul.c * @brief RLC Unacknowledged Mode uplink module @@ -67,20 +63,31 @@ static int RLOG_FILE_ID=240; #include "kw.x" /* RLC layer */ #include "kw_ul.x" -#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_UL) +#define RLC_MODULE (RLC_DBGMASK_UM | RLC_DBGMASK_UL) -PRIVATE S16 kwUmmExtractHdr ARGS ((RlcCb *gCb, +static uint8_t rlcUmmExtractHdr ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *pdu, - KwUmHdr *umHdr)); + RlcUmHdr *umHdr)); + +uint8_t rlcUmmReAssembleSdus ARGS ((RlcCb *gCb, + RlcUlRbCb *rbCb, + RlcUmRecBuf *umRecBuf)); + +#ifdef NR_RLC_UL +bool rlcUmmAddRcvdSeg ARGS ((RlcCb *gCb, + RlcUlRbCb *rbCb, + RlcUmHdr *umHdr, + Buffer *pdu, + uint16_t pduSz)); + +void rlcUmmRelAllSegs(RlcCb *gCb, RlcUmRecBuf *recBuf); -PRIVATE Void kwUmmReAssembleSdus ARGS ((RlcCb *gCb, - RlcUlRbCb *rbCb, - KwUmRecBuf *umRecBuf)); +#endif #ifndef TENB_ACC #ifndef LTE_PAL_ENB -extern U32 isMemThreshReached(Region region); +uint32_t isMemThreshReached(Region region); #endif #endif /** @@ -96,11 +103,11 @@ extern U32 isMemThreshReached(Region region); * * @return Void */ -PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn) +static void rlcUmmFindNextVRUR (RlcUmUl* umUl, RlcSn nextSn) { - KwSn ur = KW_UM_GET_VALUE(umUl->vrUr, *umUl); + RlcSn ur = RLC_UM_GET_VALUE(umUl->vrUr, *umUl); - KwSn nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl); + RlcSn nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl); while (ur < nextSnToCompare) { @@ -110,7 +117,7 @@ PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn) break; } nextSn = (nextSn + 1) & umUl->modBitMask; - nextSnToCompare = KW_UM_GET_VALUE(nextSn,*umUl); + nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl); } } @@ -127,12 +134,324 @@ PRIVATE Void kwUmmFindNextVRUR (KwUmUl* umUl, KwSn nextSn) * * @return Void */ -PRIVATE S16 kwUmmCheckSnInReordWindow (KwSn sn, - CONSTANT KwUmUl* CONSTANT umUl) +static int16_t rlcUmmCheckSnInReordWindow (RlcSn sn, const RlcUmUl* const umUl) { - return (KW_UM_GET_VALUE(sn, *umUl) < KW_UM_GET_VALUE(umUl->vrUh, *umUl)); + return (RLC_UM_GET_VALUE(sn, *umUl) < RLC_UM_GET_VALUE(umUl->vrUh, *umUl)); } +#ifdef NR_RLC_UL + +/** + * @brief Handler to updated expected byte seg + * + * @details + * This function is used to update expected byte segment. The next segment + * expected is indicated by the SO of the segment which is expected. Intially + * the segment with SO 0 is expected and then in order. When all the segments + * are received (which would happen when an expected SO is encountered + * with LSF set) the allRcvd flag is set to TRUE + * + * @param[in] gCb RLC instance control block + * @param[in] umUl AM Uplink Control Block + * @param[in] seg Newly received segment + * + * @return void + * + */ + +void rlcUmmUpdExpByteSeg(RlcCb *gCb, RlcUmUl *umUl, RlcUmSeg *seg) +{ + uint16_t newExpSo; /* The new expected SO */ + RlcSn sn = seg->umHdr.sn; + bool lstRcvd=FALSE; + RlcUmRecBuf *recBuf = NULLP; + + recBuf = rlcUtlGetUmRecBuf(umUl->recBufLst, sn); + if ((recBuf == NULLP) || (recBuf && (seg->umHdr.so != recBuf->expSo))) + { + return; + } + recBuf->noMissingSeg = FALSE; + newExpSo = seg->soEnd + 1; + recBuf->expSo = newExpSo; + if(seg->umHdr.si == RLC_SI_LAST_SEG) + { + lstRcvd = TRUE; + } + RLC_UMM_LLIST_NEXT_SEG(recBuf->segLst, seg); + while(seg) + { + /* keep going ahead as long as the expectedSo match with the header so + else store the expSo for later checking again */ + if(seg->umHdr.si == RLC_SI_LAST_SEG) + { + lstRcvd = TRUE; + } + if (seg->umHdr.so == newExpSo) + { + newExpSo = seg->soEnd + 1; + recBuf->expSo = newExpSo; + RLC_UMM_LLIST_NEXT_SEG(recBuf->segLst, seg); + } + else + { + recBuf->expSo = newExpSo; + return; + } + } + if (lstRcvd == TRUE) + { + recBuf->allSegRcvd = TRUE; + } + recBuf->noMissingSeg = TRUE; + + return; +} +/** + * @brief Private handler to store the received segment + * + * @details + * Private handler invokded by rlcUmmUlPlacePduInRecBuf to add a received + * segment in reception buffer of a RBCB. + * - It is responsible for detecting duplicate segments + * - Adding it at appropriate position in the received buffer + * - Calling ExpByteSeg to set expSo field in the receiver buffer + * + * @param[in] gCb RLC instance control block + * @param[in] rbCb Radio Bearer Contro Block + * @param[in] umHdr UM Header received + * @param[in] pdu Buffer received other than the headers + * @param[in] pduSz size of the PDU buffer received + * + * @return bool + * -#TRUE Successful insertion into the receiver buffer + * -#FALSE Possibly a duplicate segment + */ + +bool rlcUmmAddRcvdSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcUmHdr *umHdr, Buffer *pdu, uint16_t pduSz) +{ + RlcUmRecBuf *recBuf = NULLP; + RlcUmSeg *seg; + RlcUmSeg *tseg; + uint16_t soEnd; /* Holds the SoEnd of received segment */ + uint16_t expSo = 0; /* Expected SO */ + + soEnd = umHdr->so + pduSz - 1; + recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst, umHdr->sn); + + if (NULLP == recBuf) + { + RLC_ALLOC(gCb,recBuf, sizeof(RlcUmRecBuf)); + if (recBuf == NULLP) + { + DU_LOG("\nERROR --> RLC_UL : Failed to allocate memory to recv buf for UEID:%d CELLID:%d in rlcUmmAddRcvdSeg()", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + + ODU_PUT_MSG_BUF(pdu); + return FALSE; + } + rlcUtlStoreUmRecBuf(RLC_UMUL.recBufLst, recBuf, umHdr->sn); + } + else + { + if (recBuf->allSegRcvd == TRUE) + { + ODU_PUT_MSG_BUF(pdu); + return FALSE; + } + } + + RLC_UMM_LLIST_FIRST_SEG(recBuf->segLst, seg); + while ((seg != NULLP) && (seg->umHdr.so < umHdr->so)) + { + expSo = seg->umHdr.so + seg->segSz; + RLC_UMM_LLIST_NEXT_SEG(recBuf->segLst, seg); + } + + if (expSo > umHdr->so) + { + DU_LOG("\nDEBUG --> RLC_UL : Received duplicate segment in rlcUmmAddRcvdSeg()"); + /* This is a duplicate segment */ + ODU_PUT_MSG_BUF(pdu); + return FALSE; + } + + if ((seg) && (seg->umHdr.so <= soEnd)) + { + DU_LOG("\nDEBUG --> RLC_UL : Received duplicate segment in rlcUmmAddRcvdSeg()"); + /* This is a duplicate segment */ + ODU_PUT_MSG_BUF(pdu); + return FALSE; + } + + /* If we have come this far, we have to add this segment to the */ + /* reception buffer as we either have eliminated duplicates or */ + /* have found none. */ + RLC_ALLOC_WC(gCb, tseg, sizeof(RlcUmSeg)); + if (tseg == NULLP) + { + DU_LOG("\nERROR --> RLC_UL : Failed to allocate memory to segment for UEID:%d CELLID:%d in rlcUmmAddRcvdSeg()", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + ODU_PUT_MSG_BUF(pdu); + return FALSE; + } + + tseg->seg = pdu; + tseg->segSz = pduSz; + RLC_MEM_CPY(&tseg->umHdr, umHdr, sizeof(RlcUmHdr)); + RLC_MEM_CPY(&recBuf->umHdr, umHdr, sizeof(RlcUmHdr)); + recBuf->sn = umHdr->sn; + tseg->soEnd = soEnd; + if (seg == NULLP) + { + cmLListAdd2Tail(&recBuf->segLst, &tseg->lstEnt); + } + else + { + recBuf->segLst.crnt = &seg->lstEnt; + cmLListInsCrnt(&recBuf->segLst, &tseg->lstEnt); + } + tseg->lstEnt.node = (PTR)tseg; + rlcUmmUpdExpByteSeg(gCb, &RLC_UMUL, tseg); + return TRUE; +} + +/** + * @brief Private handler to release all stored segments + * + * @details + * Private handler invokded by rlcUmmRelAllSegs to release the + * stored segements in case a complete PDU is received later. + * + * @param[in] gCb RLC instance control block + * @param[in] recBuf Buffer that stores a received PDU or segments + * + * @return void + * + */ +void rlcUmmRelAllSegs(RlcCb *gCb, RlcUmRecBuf *recBuf) +{ + RlcUmSeg *seg; + + RLC_UMM_LLIST_FIRST_SEG(recBuf->segLst, seg); + while (seg != NULLP) + { + ODU_PUT_MSG_BUF(seg->seg); + cmLListDelFrm(&(recBuf->segLst), &(seg->lstEnt)); + RLC_FREE(gCb, seg, sizeof(RlcUmSeg)); + RLC_UMM_LLIST_FIRST_SEG(recBuf->segLst, seg); + } + + return; +} + +/** + * @brief Private handler to reassemble from a segment or a PDU + * + * @details + * Private handler invokded by rlcUmmReAssembleSdus with either a + * PDU or a segment of a PDU. This is also called in the case of + * reestablishment and hence out of sequence joining is also to + * be supported + * + * + * @param[in] gCb RLC instance control block + * @param[in] rbCb Uplink RB control block + * @param[in] umHdr UM header received for this segment/PDU + * @param[in] pdu PDU to be reassembled + * + * @return ROK/RFILED + * + */ + +uint8_t rlcUmmProcSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcUmHdr *umHdr, Buffer *pdu) +{ + + if ((RLC_UMUL.expSn != umHdr->sn) || (RLC_UMUL.expSo != umHdr->so)) + { + /* Release the existing SDU as we have PDUs or */ + /* segments that are out of sequence */ + DU_LOG("\nDEBUG --> RLC_UL : Received Segments are out of sequence in rlcUmmProcSeg()"); + ODU_PUT_MSG_BUF(RLC_UMUL.assembleSdu); + return RFAILED; + } + + if (umHdr->si == RLC_SI_FIRST_SEG) + {/* first Segment of the SDU */ + if (RLC_UMUL.assembleSdu != NULLP) + { /* Some old SDU may be present */ + ODU_PUT_MSG_BUF(RLC_UMUL.assembleSdu); + } + RLC_UMUL.assembleSdu = pdu; + pdu = NULLP; + } + else if(umHdr->si == RLC_SI_MID_SEG) + {/* Middle Segment of the SDU */ + ODU_CAT_MSG(RLC_UMUL.assembleSdu,pdu, M1M2); + ODU_PUT_MSG_BUF(pdu); + pdu = NULLP; + } + else if(umHdr->si == RLC_SI_LAST_SEG) + { + ODU_CAT_MSG(pdu, RLC_UMUL.assembleSdu, M2M1); + ODU_PUT_MSG_BUF(RLC_UMUL.assembleSdu); + } + + if (pdu != NULLP) + { + RLC_UMUL.assembleSdu = NULLP; + rlcUtlSendUlDataToDu(gCb,rbCb, pdu); + } + + return ROK; +} +/** + * + * @brief Private handler to reassemble SDUs + * + * @details + * Private handler invokded by rlcUmmProcessPdus with the PDU + * from the reception buffer in sequence to reassemble SDUs and + * send it to PDCP. + * + * - With the stored header info, FI and LSF segment / concatenate + * PDUs or byte segments of PDUs to get the associated SDU. + * + * @param[in] rbCb RB control block + * @param[in] pdu PDU to be reassembled + * + * @return uint8_t + * -# ROK + * -# RFAILED + * + */ +uint8_t rlcUmmReAssembleSdus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcUmRecBuf *recBuf) +{ + RlcUmSeg *seg; + + /* This is a set of segments */ + RLC_UMM_LLIST_FIRST_SEG(recBuf->segLst, seg); + RLC_UMUL.expSn = recBuf->sn; + RLC_UMUL.expSo = 0; + while(seg) + { + if(rlcUmmProcSeg(gCb, rbCb, &seg->umHdr, seg->seg) == RFAILED) + { + rlcUmmRelAllSegs(gCb, recBuf); + break; + } + RLC_UMUL.expSo = seg->soEnd + 1; + cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt)); + RLC_FREE(gCb, seg, sizeof(RlcSeg)); + RLC_UMM_LLIST_FIRST_SEG(recBuf->segLst, seg); + } + RLC_UMUL.expSn = (recBuf->umHdr.sn + 1) & (RLC_UMUL.modBitMask); + RLC_UMUL.expSo = 0; + return ROK; +} + +#endif + /** * @brief Handler to process the Data Indication from the lower layer * and send the PDUs to re-assembly unit. @@ -150,51 +469,20 @@ PRIVATE S16 kwUmmCheckSnInReordWindow (KwSn sn, */ /* kw005.201 added support for L2 Measurement */ #ifdef LTE_L2_MEAS - -#ifdef ANSI -PUBLIC Void kwUmmProcessPdus -( -RlcCb *gCb, -RlcUlRbCb *rbCb, /* Rb Control Block */ -KwPduInfo *pduInfo, /* Pdu data and related information */ -U32 ttiCnt /* ttiCnt received from MAC */ -) -#else -PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo,ttiCnt) -RlcCb *gCb; -RlcUlRbCb *rbCb; /* Rb Control Block */ -KwPduInfo *pduInfo; /* Pdu data and related information */ -U32 ttiCnt; /* ttiCnt received from MAC */ -#endif -#else -#ifdef ANSI -PUBLIC Void kwUmmProcessPdus -( -RlcCb *gCb, -RlcUlRbCb *rbCb, /* Rb Control Block */ -KwPduInfo *pduInfo /* Pdu data and related information */ -) +void rlcUmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo, uint32_t ttiCnt) #else -PUBLIC Void kwUmmProcessPdus(rbCb,pduInfo) -RlcCb *gCb; -RlcUlRbCb *rbCb; /* Rb Control Block */ -KwPduInfo *pduInfo; /* Pdu data and related information */ -#endif +void rlcUmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo) #endif { - KwSn *vrUh; /* vr(uh) */ - KwSn *vrUr; /* vr(ur) */ - KwSn *vrUx; /* vr(ux) */ - U16 curSn; /* Current Sequence Number */ - U32 pduCount; /* PDU count */ - U32 count; /* Loop counter */ - KwUmRecBuf **recBuf; /* UM Reception Buffer */ - - Bool tmrRunning; /* Boolean for checking Tmr */ -/* kw005.201 added support for L2 Measurement */ - - TRC2(kwUmmProcessPdus) + RlcSn *vrUh; /* vr(uh) */ + RlcSn *vrUr; /* vr(ur) */ + RlcSn *vrUx; /* vr(ux) */ + uint16_t curSn; /* Current Sequence Number */ + uint32_t pduCount; /* PDU count */ + uint32_t count; /* Loop counter */ + RlcUmRecBuf **recBuf; /* UM Reception Buffer */ + bool tmrRunning; /* Boolean for checking Tmr */ count = 0; @@ -208,34 +496,31 @@ KwPduInfo *pduInfo; /* Pdu data and related information */ while (count < pduCount) { - KwSn ur; - KwSn uh; - KwSn seqNum; + RlcSn ur; + RlcSn uh; + RlcSn seqNum; Buffer *pdu = pduInfo->mBuf[count]; - KwUmRecBuf *tmpRecBuf; + RlcUmRecBuf *tmpRecBuf; gCb->genSts.pdusRecv++; #ifndef RGL_SPECIFIC_CHANGES #ifndef TENB_ACC #ifndef LTE_PAL_ENB - extern U32 ulrate_rgu; + uint32_t ulrate_rgu; MsgLen len; - SFndLenMsg(pdu, &len); + ODU_GET_MSG_LEN(pdu, &len); ulrate_rgu += len; #endif #endif #endif /* create a buffer to be later inserted into the reception buffer */ - RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf)); + RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf)); #if (ERRCLASS & ERRCLS_ADD_RES) if (tmpRecBuf == NULLP) { - RLOG_ARG2(L_FATAL, DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - SPutMsg(pdu); - - RETVOID; + DU_LOG("\nRLC : rlcUmmProcessPdus: Memory allocation failed UEID:%d CELLID:%d",\ + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + ODU_PUT_MSG_BUF(pdu); + return; } #endif /* ERRCLASS & ERRCLS_ADD_RES */ /* ccpu00142274 - UL memory based flow control*/ @@ -246,10 +531,10 @@ KwPduInfo *pduInfo; /* Pdu data and related information */ #ifndef XEON_SPECIFIC_CHANGES if(isMemThreshReached(rlcCb[0]->init.region) == TRUE) { - extern U32 rlculdrop; + uint32_t rlculdrop; rlculdrop++; - RLC_FREE_BUF(pdu); - RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf)); + ODU_PUT_MSG_BUF(pdu); + RLC_FREE(gCb, tmpRecBuf, sizeof(RlcUmRecBuf)); /*Fix for CR ccpu00144030: If threshhold is hit then also count *should be incrmented */ count++; @@ -260,42 +545,44 @@ KwPduInfo *pduInfo; /* Pdu data and related information */ #endif #endif /* get the pdu header */ - if (kwUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr))) + if (rlcUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr))) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Header Extraction Failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",\ + rbCb->rlcId.ueId, rbCb->rlcId.cellId); /* Header extraction is a problem. * log an error and free the allocated memory */ /* ccpu00136940 */ - RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf)); - SPutMsg(pdu); + RLC_FREE(gCb, tmpRecBuf, sizeof(RlcUmRecBuf)); + ODU_PUT_MSG_BUF(pdu); count++; /* kw005.201 ccpu00117318, updating the statistics */ gCb->genSts.errorPdusRecv++; continue; } +#ifdef NR_RLC_UL + + /*TODO 1.Extract Hdr */ + /* 2.Add Seg into Reception Buffer */ + /* 3.If All Seg Recvd in Reception buffer list */ + /* 4.Step 3 is true call Assemble Sdus */ +#endif curSn = tmpRecBuf->umHdr.sn; /* Check if the PDU should be discarded or not */ - ur = KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL); - uh = KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL); - seqNum = KW_UM_GET_VALUE(curSn, KW_UMUL); + ur = RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL); + uh = RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL); + seqNum = RLC_UM_GET_VALUE(curSn, RLC_UMUL); - if (((ur < seqNum) && (seqNum < uh) && (KW_UMUL.recBuf[curSn])) || + if (((ur < seqNum) && (seqNum < uh) && (RLC_UMUL.recBuf[curSn])) || (seqNum < ur)) { /* PDU needs to be discarded */ - RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "Received a duplicate pdu with sn %d UEID:%d CELLID:%d", - curSn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - - RLC_FREE_BUF(pdu); - RLC_FREE_WC(gCb, tmpRecBuf, sizeof(KwUmRecBuf)); + DU_LOG("\nRLC : rlcUmmProcessPdus: Received a duplicate pdu with sn %d \ + UEID:%d CELLID:%d", curSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); + + ODU_PUT_MSG_BUF(pdu); + RLC_FREE(gCb, tmpRecBuf, sizeof(RlcUmRecBuf)); count++; /* kw005.201 ccpu00117318, updating the statistics */ gCb->genSts.unexpPdusRecv++; @@ -306,259 +593,106 @@ KwPduInfo *pduInfo; /* Pdu data and related information */ #ifdef LTE_L2_MEAS /* kw006.201 ccpu00120058, reduced code complexity by adding new function */ - kwUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt); + rlcUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt); #endif recBuf[curSn] = tmpRecBuf; recBuf[curSn]->pdu = pdu; - SFndLenMsg(pdu,&(recBuf[curSn]->pduSz)); + ODU_GET_MSG_LEN(pdu,&(recBuf[curSn]->pduSz)); /* kw005.201 ccpu00117318, updating the statistics */ gCb->genSts.bytesRecv += recBuf[curSn]->pduSz; - if (!kwUmmCheckSnInReordWindow(curSn,&KW_UMUL)) + if (!rlcUmmCheckSnInReordWindow(curSn,&RLC_UMUL)) { /* currSn is outside re-ordering window */ - *vrUh = (curSn + 1) & KW_UMUL.modBitMask; + *vrUh = (curSn + 1) & RLC_UMUL.modBitMask; /* re-assemble all pdus outside the modified re-ordering window */ /* the first SN is VR(UR) */ - if (!kwUmmCheckSnInReordWindow(*vrUr,&KW_UMUL)) + if (!rlcUmmCheckSnInReordWindow(*vrUr,&RLC_UMUL)) { /* TODO : should it be VR(UR) + 1 ?... check, earlier it was so */ - KwSn sn = *vrUr; /* SN's which need to be re-assembled */ - KwSn lowerEdge; /* to hold the lower-edge of the + RlcSn sn = *vrUr; /* SN's which need to be re-assembled */ + RlcSn lowerEdge; /* to hold the lower-edge of the re-ordering window */ /* The new value ov VR(UR) is the lower end of the window i * and SN's still this value need to be re-assembled */ - *vrUr = (*vrUh - KW_UMUL.umWinSz) & KW_UMUL.modBitMask; - lowerEdge = KW_UM_GET_VALUE(*vrUr ,KW_UMUL); + *vrUr = (*vrUh - RLC_UMUL.umWinSz) & RLC_UMUL.modBitMask; + lowerEdge = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL); - while (KW_UM_GET_VALUE(sn, KW_UMUL) < lowerEdge) + while (RLC_UM_GET_VALUE(sn, RLC_UMUL) < lowerEdge) { if (recBuf[sn]) { - kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]); - RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf)); +#ifdef NR_RLC_UL + rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]); +#endif + RLC_FREE(gCb,recBuf[sn],sizeof(RlcUmRecBuf)); recBuf[sn] = NULLP; } - sn = (sn + 1) & KW_UMUL.modBitMask; + sn = (sn + 1) & RLC_UMUL.modBitMask; } } } if (recBuf[*vrUr]) { - KwSn sn = *vrUr; - KwSn tSn = KW_UM_GET_VALUE(sn,KW_UMUL); - KwSn tVrUr; + RlcSn sn = *vrUr; + RlcSn tSn = RLC_UM_GET_VALUE(sn,RLC_UMUL); + RlcSn tVrUr; /* set VR(UR) to next SN > current VR(UR) which is not received */ - KwSn nextVrUr = (*vrUr + 1) & KW_UMUL.modBitMask; - kwUmmFindNextVRUR(&KW_UMUL, nextVrUr); + RlcSn nextVrUr = (*vrUr + 1) & RLC_UMUL.modBitMask; + rlcUmmFindNextVRUR(&RLC_UMUL, nextVrUr); /* re-assemble SDUs with SN < Vr(UR) */ - tVrUr = KW_UM_GET_VALUE(*vrUr,KW_UMUL); + tVrUr = RLC_UM_GET_VALUE(*vrUr,RLC_UMUL); while (recBuf[sn] && tSn < tVrUr) { - kwUmmReAssembleSdus(gCb,rbCb,recBuf[sn]); - RLC_FREE_WC(gCb,recBuf[sn],sizeof(KwUmRecBuf)); +#ifdef NR_RLC_UL + rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]); +#endif + RLC_FREE(gCb,recBuf[sn],sizeof(RlcUmRecBuf)); recBuf[sn] = NULLP; - sn = (sn + 1) & KW_UMUL.modBitMask; - tSn = KW_UM_GET_VALUE(sn, KW_UMUL); + sn = (sn + 1) & RLC_UMUL.modBitMask; + tSn = RLC_UM_GET_VALUE(sn, RLC_UMUL); } } - tmrRunning = kwChkTmr(gCb,(PTR)rbCb, KW_EVT_UMUL_REORD_TMR); + tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_UMUL_REORD_TMR); if (tmrRunning) { - KwSn tVrUx = KW_UM_GET_VALUE(*vrUx, KW_UMUL); - KwSn tVrUr = KW_UM_GET_VALUE(*vrUr ,KW_UMUL); + RlcSn tVrUx = RLC_UM_GET_VALUE(*vrUx, RLC_UMUL); + RlcSn tVrUr = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL); - KwSn tVrUh = KW_UM_GET_VALUE(*vrUh, KW_UMUL); + RlcSn tVrUh = RLC_UM_GET_VALUE(*vrUh, RLC_UMUL); - S16 ret = kwUmmCheckSnInReordWindow(*vrUx, &KW_UMUL); + S16 ret = rlcUmmCheckSnInReordWindow(*vrUx, &RLC_UMUL); if ( (tVrUx <= tVrUr) || ((!ret) && (tVrUx != tVrUh))) { - kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR); + rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR); tmrRunning = FALSE; } } if (!tmrRunning) { - if (KW_UM_GET_VALUE(*vrUh, KW_UMUL) > KW_UM_GET_VALUE(*vrUr, KW_UMUL)) + if (RLC_UM_GET_VALUE(*vrUh, RLC_UMUL) > RLC_UM_GET_VALUE(*vrUr, RLC_UMUL)) { - kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR); + rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR); *vrUx = *vrUh; } } count++; }/* end while count < pduCount */ #ifdef LTE_L2_MEAS - kwUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt); + rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt); #endif /* LTE_L2_MEAS */ - RETVOID; -} - -/** - * @brief Handler to reassemble the SDUs and send them to the upper layer. - * - * @details - * This function processes the received in-sequence PDU and - * re-assembles the SDUs and sends them to the upper layer. - * - * @param[in] gCb RLC Instance control block - * @param[in] rbCb RB control block - * @param[in] umRecBuf Reception Buffer to be Re-Assembled - * - * @return Void -*/ -#ifdef ANSI -PRIVATE Void kwUmmReAssembleSdus -( -RlcCb *gCb, -RlcUlRbCb *rbCb, -KwUmRecBuf *umRecBuf -) -#else -PRIVATE Void kwUmmReAssembleSdus(gCb,rbCb,umRecBuf) -RlcCb *gCb; -RlcUlRbCb *rbCb; -KwUmRecBuf *umRecBuf; -#endif -{ - U32 liCount; /* LI count */ - U32 count; /* Loop counter */ - U8 fi; /* Framing Info */ - U16 sn; /* Sequence Number of current PDU */ - MsgLen len; /* PDU Length */ - Buffer *sdu; /* SDU to be sent to upper layer */ - Buffer *remPdu; /* Remaining PDU */ - Buffer **partialSdu; /* Partial SDU */ - - TRC2(kwUmmReAssembleSdus) - - - liCount = umRecBuf->umHdr.numLi; - fi = umRecBuf->umHdr.fi; - sn = umRecBuf->umHdr.sn; - - for (count = 0; (count <= liCount);count++) - { - if (count < liCount ) - len = umRecBuf->umHdr.li[count]; - else - { - if (!(umRecBuf->pdu)) - { - RETVOID; - } - SFndLenMsg(umRecBuf->pdu,&len); - } - - /* get the sdu out of the pdu */ - SSegMsg(umRecBuf->pdu,len,&remPdu); - sdu = umRecBuf->pdu; - umRecBuf->pdu = remPdu; - - partialSdu = &(rbCb->m.umUl.partialSdu); - /* While re-assembling the SDUs, consider the first LI and perform - * the following steps. - -# If the first bit of FI(Framing Info of 2 bits) is set => - -# The current Data field in the PDU is a segment. - So form a SDU only if the - rbCb->m.um.umUl.partialSdu exists and the SNs are - in-sequence. - -# If there are no LIs and the second bit of LI is 1 - then a partial SDU is formed which would not be sent - to the upper layer. - -# else - -# If rbCb->partialSdu is not NULL then flush it off. - -# If LI count > 0 or LI count is 0 and second bit - of FI is not 1 - The SDU is complete.So send it to upper layer. - -# else - The SDU is partial and is placed - in rbCb->m.um.umUl.partialSdu; - */ - - if (0 == count ) - { - if (fi & 2) - { - if ((*partialSdu) && - (sn == ((rbCb->m.umUl.sn + 1) & rbCb->m.umUl.modBitMask))) - { - SCatMsg(*partialSdu,sdu,M1M2); - RLC_FREE_BUF(sdu); - if (liCount > 0 || !(fi & 1)) - { - kwUtlSndDatInd(gCb,rbCb,*partialSdu); - *partialSdu = NULLP; - } - } - else - { - /* Partial Sdu stored is not valid now.So free it */ - if (*partialSdu) - { - RLC_FREE_BUF(*partialSdu); - *partialSdu = NULLP; - } - - RLC_FREE_BUF(sdu); - sdu = NULLP; - } - } - else - { - if (*partialSdu) - { - RLC_FREE_BUF(*partialSdu); /* RLC mem leak fix */ - *partialSdu = NULLP; - } - - if (liCount > 0 || !( fi & 1)) - { - kwUtlSndDatInd(gCb,rbCb,sdu); - } - else - { - *partialSdu = sdu; - } - } - } - /* - If the SDU pointer has the last Data field of the PDU - -# If FI is 1,place the SDU in rbCb->m.um.umDl.partialSdu - -# else send the SDU to upper layer. - */ - else if (count == liCount) - { - if (fi & 1) - { - *partialSdu = sdu; - } - else - { - kwUtlSndDatInd(gCb, rbCb, sdu); - } - } - /* - If the LI is something other than the first one, - just send the SDU to the upper layer */ - else - { - kwUtlSndDatInd(gCb, rbCb, sdu); - } - } - rbCb->m.umUl.sn = sn; - - RETVOID; + return; } /** @@ -570,7 +704,7 @@ KwUmRecBuf *umRecBuf; * - If direction of the RB is downlink : * Remove all the SDUs in the SDU queue. * - If direction of the RB is uplink : - * Call kwUmmReAssembleSdus() for each PDU with SN < VR(UH) + * Call rlcUmmReAssembleSdus() for each PDU with SN < VR(UH) * * @param[in] gCb RLC Instance control block * @param[in] rlcID Identity of the RLC entity for which @@ -580,43 +714,35 @@ KwUmRecBuf *umRecBuf; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwUmmUlReEstablish +Void rlcUmmUlReEstablish ( RlcCb *gCb, CmLteRlcId *rlcId, RlcUlRbCb *rbCb ) -#else -PUBLIC Void kwUmmUlReEstablish(gCb, rlcId, rbCb) -RlcCb *gCb; -CmLteRlcId *rlcId; -RlcUlRbCb *rbCb; -#endif { - KwSn curSn; - KwSn vrUh; - KwUmRecBuf **recBuf; /* UM Reception Buffer */ - KwKwuSapCb *kwKwSap; /* KWU SAP Information */ - - TRC2(kwUmmUlReEstablish) - + RlcSn curSn; + RlcSn vrUh; + RlcUmRecBuf **recBuf; /* UM Reception Buffer */ + RlcKwuSapCb *rlcKwSap; /* KWU SAP Information */ curSn = rbCb->m.umUl.vrUr; - vrUh = KW_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl); + vrUh = RLC_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl); recBuf = rbCb->m.umUl.recBuf; - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR)) { - kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR); + rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR); } - while (KW_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh) + while (RLC_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh) { if ( recBuf[curSn] != NULLP ) { - kwUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]); - RLC_FREE_WC(gCb,recBuf[curSn],sizeof(KwUmRecBuf)); +#ifdef NR_RLC_UL + rlcUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]); +#endif + RLC_FREE(gCb,recBuf[curSn],sizeof(RlcUmRecBuf)); recBuf[curSn] = NULLP; } curSn = (curSn + 1) & rbCb->m.umUl.modBitMask; @@ -625,12 +751,12 @@ RlcUlRbCb *rbCb; rbCb->m.umUl.vrUh = 0; rbCb->m.umUl.vrUx = 0; - kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP; + rlcKwSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP; /* In the UM Mode always send reestablish-indication to Upper Latyer*/ - KwUiKwuReEstCmpInd(&kwKwSap->pst, kwKwSap->suId, *rlcId); + RlcUiKwuReEstCmpInd(&rlcKwSap->pst, rlcKwSap->suId, *rlcId); - RETVOID; + return; } /** @@ -650,50 +776,30 @@ RlcUlRbCb *rbCb; * -# TRUE * -# FALSE */ -#ifdef ANSI -PRIVATE S16 kwUmmExtractHdr -( -RlcCb *gCb, -RlcUlRbCb *rbCb, -Buffer *pdu, -KwUmHdr *umHdr -) -#else -PRIVATE S16 kwUmmExtractHdr(gCb, rbCb, pdu, umHdr) -RlcCb *gCb; -RlcUlRbCb *rbCb; -Buffer *pdu; -KwUmHdr *umHdr; -#endif +static uint8_t rlcUmmExtractHdr(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *pdu, RlcUmHdr *umHdr) { - U8 e; /* Extension Bit */ + uint8_t e; /* Extension Bit */ Data dst[2]; /* Destination Buffer */ - S32 totalSz; /* Sum of LIs */ + int32_t totalSz; /* Sum of LIs */ MsgLen pduSz; /* PDU size */ #if (ERRCLASS & ERRCLS_DEBUG) - S16 ret; /* Return Value */ + uint8_t ret; /* Return Value */ #endif - TRC3(kwUmmExtractHdr) - - - SFndLenMsg(pdu,&pduSz); + ODU_GET_MSG_LEN(pdu,&pduSz); if ( rbCb->m.umUl.snLen == 1) { #if (ERRCLASS & ERRCLS_DEBUG) - ret = SRemPreMsg(dst,pdu); + ret = ODU_REM_PRE_MSG(dst,pdu); if (ret != ROK) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "SRemPreMsg Failed for 5 bit SN UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - + DU_LOG("\nRLC : rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed for 5 bit SN \ + UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); return RFAILED; } #else - SRemPreMsg(dst,pdu); + ODU_REM_PRE_MSG(dst,pdu); #endif pduSz--; umHdr->sn = (dst[0]) & 0x1F; @@ -704,17 +810,15 @@ KwUmHdr *umHdr; { /* snLen - sequnce length will be 10 bits requiring 2 bytes */ #if (ERRCLASS & ERRCLS_DEBUG) - ret = SRemPreMsgMult(dst,2,pdu); + ret = ODU_REM_PRE_MSG_MULT(dst,2,pdu); if (ret != ROK) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "SRemPreMsgMult Failed for 10 bits SN UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmExtractHdr : ODU_REM_PRE_MSG_MULT Failed for 10 bits SN \ + UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); return RFAILED; } #else - SRemPreMsgMult(dst,2,pdu); + ODU_REM_PRE_MSG_MULT(dst,2,pdu); #endif pduSz -= 2; @@ -731,45 +835,34 @@ KwUmHdr *umHdr; umHdr->numLi = 0; totalSz = 0; - while(e && umHdr->numLi < KW_MAX_UL_LI ) + while(e && umHdr->numLi < RLC_MAX_UL_LI ) { #if (ERRCLASS & ERRCLS_DEBUG) - ret = SRemPreMsgMult(dst,2,pdu); + ret = ODU_REM_PRE_MSG_MULT(dst,2,pdu); if (ret != ROK) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "SRemPreMsgMult Failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmExtractHdr : ODU_REM_PRE_MSG_MULT Failed UEID:%d CELLID:%d",\ + rbCb->rlcId.ueId, rbCb->rlcId.cellId); return RFAILED; } #else - SRemPreMsgMult(dst,2,pdu); + ODU_REM_PRE_MSG_MULT(dst,2,pdu); #endif umHdr->li[umHdr->numLi] = ((dst[0]) & 0x7F) << 4; umHdr->li[umHdr->numLi] |= dst[1] >> 4; if ( 0 == umHdr->li[umHdr->numLi] ) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Received LI as 0 UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmExtractHdr : Received LI as 0 UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); return RFAILED; } totalSz += umHdr->li[umHdr->numLi]; if ( pduSz <= totalSz ) { - RLOG_ARG3(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "SN [%d]: UEID:%d CELLID:%d", - umHdr->sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RLOG_ARG4(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Corrupted PDU as TotSz[%lu] PduSz[%lu] UEID:%d CELLID:%d ", - totalSz, - pduSz, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmExtractHdr : SN [%d]: UEID:%d CELLID:%d",\ + umHdr->sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmExtractHdr : Corrupted PDU as TotSz[%d] PduSz[%d] \ + UEID:%d CELLID:%d ", totalSz, pduSz, rbCb->rlcId.ueId, rbCb->rlcId.cellId); return RFAILED; /* the situation where in the PDU size is something that does not match with the size in LIs*/ @@ -779,34 +872,30 @@ KwUmHdr *umHdr; e = ((dst[0]) & 0x80) >> 7; - if ( e && umHdr->numLi < KW_MAX_UL_LI) + if ( e && umHdr->numLi < RLC_MAX_UL_LI) { - U8 tmp = ((dst[1]) & 0x08) >> 3; + uint8_t tmp = ((dst[1]) & 0x08) >> 3; umHdr->li[umHdr->numLi] = ( dst[1] & 0x07) << 8; #if (ERRCLASS & ERRCLS_DEBUG) - ret = SRemPreMsg(dst,pdu); + ret = ODU_REM_PRE_MSG(dst,pdu); if (ret != ROK) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "SRemPreMsg Failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); return RFAILED; } #else - SRemPreMsg(dst,pdu); + ODU_REM_PRE_MSG(dst,pdu); #endif umHdr->li[umHdr->numLi] |= ( dst[0] ); /* The first byte lies in the first 8 bits.We want them in the last 8 bits */ if ( 0 == umHdr->li[umHdr->numLi] ) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Received LI as 0 UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcUmmExtractHdr :Received LI as 0 UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); return RFAILED; } totalSz += umHdr->li[umHdr->numLi]; @@ -822,10 +911,10 @@ KwUmHdr *umHdr; e = tmp; } - } /* while(e && umHdr->numLi < KW_MAX_LI ) */ + } /* while(e && umHdr->numLi < RLC_MAX_LI ) */ if (e) { - /* PDU was constructed with LIs that exceeded KW_MAX_LI */ + /* PDU was constructed with LIs that exceeded RLC_MAX_LI */ return RFAILED; } return ROK; @@ -839,50 +928,42 @@ KwUmHdr *umHdr; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwUmmReOrdTmrExp +Void rlcUmmReOrdTmrExp ( RlcCb *gCb, RlcUlRbCb *rbCb ) -#else -PUBLIC Void kwUmmReOrdTmrExp(gCb, rbCb) -RlcCb *gCb; -RlcUlRbCb *rbCb; -#endif { - KwSn prevVrUr; /* prevVrUr */ - - TRC3(kwUmmReOrdTmrExp) - - - prevVrUr = KW_UMUL.vrUr; + RlcSn prevVrUr; /* prevVrUr */ + prevVrUr = RLC_UMUL.vrUr; /* set VR(UR) to SN >= VR(UX) that has not been received */ - kwUmmFindNextVRUR(&KW_UMUL, KW_UMUL.vrUx); + rlcUmmFindNextVRUR(&RLC_UMUL, RLC_UMUL.vrUx); - while (KW_UM_GET_VALUE(prevVrUr,KW_UMUL) < - KW_UM_GET_VALUE(KW_UMUL.vrUr,KW_UMUL)) + while (RLC_UM_GET_VALUE(prevVrUr,RLC_UMUL) < + RLC_UM_GET_VALUE(RLC_UMUL.vrUr,RLC_UMUL)) { - if (KW_UMUL.recBuf[prevVrUr]) + if (RLC_UMUL.recBuf[prevVrUr]) { - kwUmmReAssembleSdus(gCb, rbCb, KW_UMUL.recBuf[prevVrUr]); - if(KW_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */ +#ifdef NR_RLC_UL + rlcUmmReAssembleSdus(gCb, rbCb, RLC_UMUL.recBuf[prevVrUr]); +#endif + if(RLC_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */ { - RLC_FREE_BUF(KW_UMUL.recBuf[prevVrUr]->pdu); + ODU_PUT_MSG_BUF(RLC_UMUL.recBuf[prevVrUr]->pdu); } - RLC_FREE_WC(gCb, KW_UMUL.recBuf[prevVrUr], sizeof(KwUmRecBuf)); - KW_UMUL.recBuf[prevVrUr] = NULLP; + RLC_FREE(gCb, RLC_UMUL.recBuf[prevVrUr], sizeof(RlcUmRecBuf)); + RLC_UMUL.recBuf[prevVrUr] = NULLP; } prevVrUr = (prevVrUr + 1) & rbCb->m.umUl.modBitMask; } - if (KW_UM_GET_VALUE(KW_UMUL.vrUh, KW_UMUL) > - KW_UM_GET_VALUE(KW_UMUL.vrUr, KW_UMUL)) + if (RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL) > + RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL)) { - kwStartTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR); - KW_UMUL.vrUx = KW_UMUL.vrUh; + rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR); + RLC_UMUL.vrUx = RLC_UMUL.vrUh; } } @@ -900,48 +981,39 @@ RlcUlRbCb *rbCb; * @return void */ -#ifdef ANSI -PUBLIC Void kwUmmFreeUlRbCb +Void rlcUmmFreeUlRbCb ( RlcCb *gCb, RlcUlRbCb *rbCb ) -#else -PUBLIC Void kwUmmFreeUlRbCb(gCb,rbCb) -RlcCb *gCb; -RlcUlRbCb *rbCb; -#endif { - KwSn curSn = 0; /* sequence number of PDU */ - KwSn windSz; /* PDU window size */ - KwUmRecBuf **umRecBuf; /* UM module receive buffer */ - - TRC2(kwUmmFreeUlRbCb) - + RlcSn curSn = 0; /* sequence number of PDU */ + RlcSn windSz; /* PDU window size */ + RlcUmRecBuf **umRecBuf; /* UM module receive buffer */ windSz = rbCb->m.umUl.umWinSz << 1; umRecBuf = rbCb->m.umUl.recBuf; - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR)) { - kwStopTmr(gCb,(PTR)rbCb,KW_EVT_UMUL_REORD_TMR); + rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR); } while (curSn < windSz) { if (umRecBuf[curSn] != NULLP) { - RLC_FREE_BUF_WC(umRecBuf[curSn]->pdu); + ODU_PUT_MSG_BUF(umRecBuf[curSn]->pdu); umRecBuf[curSn]->pdu = NULLP; - RLC_FREE_WC(gCb, umRecBuf[curSn], sizeof(KwUmRecBuf)); + RLC_FREE(gCb, umRecBuf[curSn], sizeof(RlcUmRecBuf)); umRecBuf[curSn] = NULLP; } curSn++; } - RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(KwUmRecBuf*)); + RLC_FREE(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(RlcUmRecBuf*)); rbCb->m.umUl.recBuf = NULLP; - RETVOID; + return; }