X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_umm_dl.c;h=430adca402e214cc57e0bdaeeb13271e1d10ec3a;hb=7ebfb1f80967fe83bf169c2915cedf2c9fb5cbf7;hp=987d3edaf7c9da20a3e937ad57cb437cad5ecd6c;hpb=5625a52ad68f6ad93684e68bbbdbaef0d462cf9a;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_umm_dl.c b/src/5gnrrlc/kw_umm_dl.c index 987d3edaf..430adca40 100755 --- a/src/5gnrrlc/kw_umm_dl.c +++ b/src/5gnrrlc/kw_umm_dl.c @@ -18,41 +18,29 @@ /********************************************************************** - Name: LTE-RLC Layer + Name: NR RLC Layer Type: C file 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_dl.c **********************************************************************/ -static const char* RLOG_MODULE_NAME="RLC"; -static int RLOG_MODULE_ID=2048; -static int RLOG_FILE_ID=239; /** * @file kw_umm_dl.c * @brief RLC Unacknowledged Mode downlink module */ /* header (.h) include files */ -#include "envopt.h" /* environment options */ -#include "envdep.h" /* environment dependent */ -#include "envind.h" /* environment independent */ - -#include "gen.h" /* general */ -#include "ssi.h" /* system services interface */ -#include "cm5.h" /* Timer Functions */ -#include "cm_lte.h" /* common umts header file */ -#include "cm_hash.h" /* common hash module file */ -#include "cm_llist.h" /* common list header file */ +#include "common_def.h" #include "ckw.h" /* RRC layer */ #include "lkw.h" /* RRC layer */ #include "kwu.h" /* RLC service user */ @@ -68,13 +56,6 @@ static int RLOG_FILE_ID=239; /* header/extern include files (.x) */ -#include "gen.x" /* general */ -#include "ssi.x" /* system services interface */ -#include "cm_lib.x" /* common library */ -#include "cm5.x" /* Timer Functions */ -#include "cm_hash.x" /* common hash module */ -#include "cm_lte.x" /* common umts file */ -#include "cm_llist.x" /* common list header file */ #include "ckw.x" /* RRC layer */ #include "kwu.x" /* RLC service user */ #include "lkw.x" /* LM Interface */ @@ -84,22 +65,20 @@ static int RLOG_FILE_ID=239; #include "kw_udx.x" #include "kw_dl.x" -#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_DL) +#define RLC_MODULE (RLC_DBGMASK_UM | RLC_DBGMASK_DL) /* variables for logging :declared in BRDCM cl */ #ifndef TENB_ACC -extern U32 dldrops_kwu_um; -extern U32 dlpkt_um; -extern U32 buffer_occ; -extern U32 dlrate_kwu; +uint32_t dldrops_kwu_um; +uint32_t dlpkt_um; +uint32_t buffer_occ; +uint32_t dlrate_kwu; #endif -PRIVATE Void kwUmmEstHdrSz ARGS ((KwUmDl *umUl)); - -PRIVATE Void kwUmmCreatePdu ARGS ((KwCb *gCb, - KwDlRbCb *rbCb, +static Void rlcUmmCreatePdu ARGS ((RlcCb *gCb, + RlcDlRbCb *rbCb, Buffer *pdu, - U8 fi, + RlcUmHdr *umHdr, KwPduInfo *datReqPduInfo)); /** @addtogroup ummode */ @@ -122,46 +101,29 @@ PRIVATE Void kwUmmCreatePdu ARGS ((KwCb *gCb, * * @return Void */ -#ifdef ANSI -PUBLIC Void kwUmmQSdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwuDatReqInfo *datReq, -Buffer *mBuf -) -#else -PUBLIC Void kwUmmQSdu(gCb,rbCb,datReq,mBuf) -KwCb *gCb; -KwDlRbCb *rbCb; -KwuDatReqInfo *datReq; -Buffer *mBuf; -#endif +void rlcUmmQSdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReqInfo *datReq, Buffer *mBuf) { MsgLen len; /* SDU buffer length */ - KwSdu *sdu; /* SDU */ - - TRC2(kwUmmQSdu) + RlcSdu *sdu; /* SDU */ - KW_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb); + RLC_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb); - KW_ALLOC_WC(gCb, sdu, (Size)sizeof(KwSdu)); + RLC_ALLOC_WC(gCb, sdu, (Size)sizeof(RlcSdu)); #if (ERRCLASS & ERRCLS_ADD_RES) if ( sdu == 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 in rlcUmmQSdu for UEID:%d CELLID:%d",\ rbCb->rlcId.ueId, rbCb->rlcId.cellId); - SPutMsg(mBuf); - RETVOID; + ODU_PUT_MSG_BUF(mBuf); + return; } #endif /* ERRCLASS & ERRCLS_ADD_RES */ /* Discard new changes starts */ - kwUtlGetCurrTime(&sdu->arrTime); + rlcUtlGetCurrTime(&sdu->arrTime); /* Discard new changes ends */ - SFndLenMsg(mBuf,&len); + ODU_GET_MSG_LEN(mBuf,&len); sdu->mBuf = mBuf; sdu->sduSz = len; @@ -178,15 +140,13 @@ Buffer *mBuf; #endif #endif rbCb->m.umDl.bo += len; - + rbCb->m.umDl.bo += RLC_MAX_HDRSZ; cmLListAdd2Tail(&(rbCb->m.umDl.sduQ), &sdu->lstEnt); sdu->lstEnt.node = (PTR)sdu; - - kwUmmEstHdrSz(&rbCb->m.umDl); - if(!kwDlUtlIsReestInProgress(rbCb)) + if(!rlcDlUtlIsReestInProgress(rbCb)) { - kwUtlSndDStaRsp(gCb,rbCb,rbCb->m.umDl.bo,rbCb->m.umDl.estHdrSz,FALSE,0); + rlcUtlSendDedLcBoStatus(gCb, rbCb, rbCb->m.umDl.bo, 0, FALSE,0); } /* kw005.201 added support for L2 Measurement */ @@ -195,11 +155,11 @@ Buffer *mBuf; if((rbCb->rbL2Cb.measOn & LKW_L2MEAS_ACT_UE) && (rbCb->ueCb->numActRb[rbCb->qci]++ == 0)) { - kwCb.kwL2Cb.numActUe[rbCb->qci]++; + rlcCb.rlcL2Cb.numActUe[rbCb->qci]++; } #endif - RETVOID; + return; } @@ -221,48 +181,35 @@ Buffer *mBuf; * -# ROK In case of success * -# RFAILED If allocation of Sdu fails */ -#ifdef ANSI -PUBLIC Void kwUmmProcessSdus -( -KwCb *gCb, -KwDlRbCb *rbCb, -KwDatReq *datReq -) -#else -PUBLIC Void kwUmmProcessSdus(gCb, rbCb, datReq) -KwCb *gCb; -KwDlRbCb *rbCb; -KwDatReq *datReq; -#endif +void rlcUmmProcessSdus(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReq *datReq) { CmLList *firstNode; /* First Node in SDU queue */ - U8 fi=0; /* Framing Info */ Buffer *pdu; /* Buffer for holding the formed PDU */ KwPduInfo *pduInfo; /* PDU Info pointer */ - S16 pduSz; /* PDU Size to be constructed */ + int16_t pduSz; /* PDU Size to be constructed */ + RlcUmHdr umHdr; /* Header */ + uint32_t rlcHdrSz; + uint32_t rlcSduSz; + uint32_t rlcPduSz; + uint32_t macHdrSz; /* kw005.201 added support for L2 Measurement */ #ifdef LTE_L2_MEAS - KwContSduLst contSduLst; /*Contained sduLst */ - S32 dataVol = rbCb->m.umDl.bo; - U32* totMacGrant= &(datReq->totMacGrant); - KwL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh; - U8 *sduIdx = &dlIpThPut->lastSduIdx; - Bool newIdx = FALSE; - S32 oldBo; - KwlchInfo lchInfo = {0}; - U32 segSduCnt = 0; + RlcContSduLst contSduLst; /*Contained sduLst */ + int32_t dataVol = rbCb->m.umDl.bo; + uint32_t* totMacGrant= &(datReq->totMacGrant); + RlcL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh; + uint8_t *sduIdx = &dlIpThPut->lastSduIdx; + bool newIdx = FALSE; + int32_t oldBo; + RlclchInfo lchInfo = {0}; + uint32_t segSduCnt = 0; #endif Ticks curTime = 0; - S16 timeDiff = 0; - KwSdu *sdu; - - - TRC2(kwUmmProcessSdus) - + int16_t timeDiff = 0; + RlcSdu *sdu; pdu = NULLP; - pduInfo = &(datReq->pduInfo); pduSz = datReq->pduSz; @@ -275,90 +222,100 @@ KwDatReq *datReq; #endif /* Discard new changes starts */ - kwUtlGetCurrTime(&curTime); + rlcUtlGetCurrTime(&curTime); /* ccpu00143043 */ - while ((pduSz > 0) && (rbCb->m.umDl.sduQ.count > 0) && - (rbCb->m.umDl.numLi < KW_MAX_DL_LI) && (pduInfo->numPdu < KW_MAX_PDU)) + while ((pduSz > 0) && (rbCb->m.umDl.sduQ.count > 0) && (pduInfo->numPdu < RLC_MAX_PDU)) { CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,firstNode); - sdu = (KwSdu *)(firstNode->node); + sdu = (RlcSdu *)(firstNode->node); if ((sdu->mode.um.isSegmented == FALSE) && (rbCb->discTmrInt > 0) && (rbCb->rlcId.rbType == CM_LTE_DRB)) { - timeDiff = KW_TIME_DIFF(curTime,sdu->arrTime); + timeDiff = RLC_TIME_DIFF(curTime,sdu->arrTime); if (timeDiff >= rbCb->discTmrInt) { #ifdef LTE_L2_MEAS - KW_UPD_L2_DL_DISC_SDU_STS(gCb, rbCb); + RLC_UPD_L2_DL_DISC_SDU_STS(gCb, rbCb); #endif rbCb->m.umDl.bo -= sdu->sduSz; - KW_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu); + RLC_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu); continue; } } - /* When forming a new PDU, pdu == NULLP - -# Eliminate MAC header size for each pdu - -# Initialize the li array to 0 - -# Substract the fixed header length based on SN length - */ #ifdef LTE_L2_MEAS newIdx = FALSE; #endif - if (!pdu) + /* When forming a new PDU, pdu == NULLP + -# Eliminate MAC header size for each pdu + -# Substract the fixed header length based on SN length + */ + /* account for the RLC header size + minimum header size will be 1 , if Sdu is not segmented */ + rlcHdrSz = RLC_MIN_HDRSZ; + if(sdu->mode.um.isSegmented) { - KW_RMV_MAC_HDR_SZ(pduSz); + /* value of rbCb->m.umDl.snLen will be 1 for 6 bit SN and 2 for 12 bit SN and 2 bytes of SO */ + rlcHdrSz = (rbCb->m.umDl.snLen + 2); + } + macHdrSz = RLC_MAC_HDR_SZ2; /*Minimum MacHdr size */ + rlcSduSz = sdu->sduSz; + rlcPduSz = ((rlcSduSz + rlcHdrSz) < (pduSz - macHdrSz))? (rlcSduSz + rlcHdrSz) : (pduSz - macHdrSz); + rlcSduSz = rlcPduSz - rlcHdrSz; - /* account for the RLC header size */ - pduSz -= rbCb->m.umDl.snLen; + /*Estimate MAC Hdr based on calculated rlcPduSz */ + macHdrSz = (rlcPduSz > 255 ) ? RLC_MAC_HDR_SZ3 : RLC_MAC_HDR_SZ2; - /* kw005.201 fixing pduSz <= 0 problem, ccpu00119417 */ - if(pduSz <= 0) - { - break; - } - - rbCb->m.umDl.numLi = 0; - if (sdu->mode.um.isSegmented == TRUE) - { - fi = 2; - } - else - { - fi = 0; - } + if(macHdrSz != RLC_MAC_HDR_SZ2) + { + rlcSduSz = sdu->sduSz; + rlcPduSz = ((rlcSduSz + rlcHdrSz) < (pduSz - macHdrSz))? (rlcSduSz + rlcHdrSz) : (pduSz - macHdrSz); + rlcSduSz = rlcPduSz - rlcHdrSz; + macHdrSz = (rlcPduSz > 255 ) ? RLC_MAC_HDR_SZ3 : RLC_MAC_HDR_SZ2; } - kwUtlCalcLiForSdu(gCb,rbCb->m.umDl.numLi,sdu->sduSz,&pduSz); + if(sdu->mode.um.isSegmented == FALSE) + { + /* RLC SDU is estimated to be segmented first time */ + if(rlcSduSz < sdu->sduSz) + { + rlcHdrSz = rbCb->m.umDl.snLen; + rlcSduSz = sdu->sduSz; + rlcPduSz = ((rlcSduSz + rlcHdrSz) < (pduSz - macHdrSz))? (rlcSduSz + rlcHdrSz) : (pduSz - macHdrSz); + rlcSduSz = rlcPduSz - rlcHdrSz; + /*Estimate MAC Hdr based on calculated rlcPduSz */ + macHdrSz = (rlcPduSz > 255 ) ? RLC_MAC_HDR_SZ3 : RLC_MAC_HDR_SZ2; + } + } + + pduSz -= (rlcHdrSz + macHdrSz); + + if(pduSz <= 0) + { + break; + } - /* Exact fit scenario : - If the SDU size matches with the PDU size - -# Allocate memory equal to PDU size; - -# update BO - -# Remove SDu from queue - -# Append to already existing PDU portion if present . - -# Add Header and create complete PDU and place it in - pduInfo and return - */ - if (sdu->sduSz == pduSz) + /* No Segmentation scenario : + If SDU size is less than or equal to the requested PDU size + -# Allocate memory and copy SDU into it. + -# Update BO + -# Remove SDU from the Queue. + */ + if (sdu->sduSz <= pduSz) { if (!pdu) { pdu = sdu->mBuf; sdu->mBuf = NULLP; } - else - { - SCatMsg(pdu, sdu->mBuf, M1M2); - } - - rbCb->m.umDl.bo -= pduSz; - pduSz = 0; + rbCb->m.umDl.bo -= sdu->sduSz; + rbCb->m.umDl.bo -= RLC_MAX_HDRSZ; + pduSz -= sdu->sduSz; #ifdef LTE_L2_MEAS - if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb)) + if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb)) { if(sdu->mode.um.isSegmented) { @@ -366,14 +323,14 @@ KwDatReq *datReq; } else { - KW_GETSDUIDX(*sduIdx); + RLC_GETSDUIDX(*sduIdx); newIdx = TRUE; } - kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst); - kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, + rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst); + rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, sdu->mode.um.sduId, newIdx); /* ccpu00143043 */ - if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX) + if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX) { lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime; lchInfo.sduInfo[lchInfo.numSdus].isRetxPdu = FALSE; @@ -383,121 +340,51 @@ KwDatReq *datReq; #endif /* kw005.201 added support for L2 Measurement */ #ifdef LTE_L2_MEAS_RLC - kwUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE); + rlcUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE); if((rbCb->rbL2Cb.measOn & LKW_L2MEAS_DL_DELAY) || (rbCb->rbL2Cb.measOn & LKW_L2MEAS_UU_LOSS)) { /* ccpu00143043 */ - if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX) + if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX) { lchInfo.arvlTime[lchInfo.numSdus] = sdu->arrTime; lchInfo.numSdus++; } } #endif /* LTE_L2_MEAS */ - KW_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); /* kw003.201 */ - kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId); - kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo); - pdu = NULLP; - - } - /* Concatenation scenario : - If SDU size is less than the requested PDU size - -# Allocate memory and copy SDU into it. - -# Update BO - -# Remove SDU from the Queue. - -# Append to already existing PDU portion if present . - -# If the SDU size is greater than 2047 or the number of i - LIs reaches max, place it as a separate PDU in pduInfo and - set pdu to NULL - else - place the msglen in li array and continue with the next SDU. - -# If the number of PDUs is more than KW_MAX_PDU, return from - the function even if pduSize > 0. - */ - else if (sdu->sduSz < pduSz) - { - if (!pdu) + if(sdu->mode.um.isSegmented) { - pdu = sdu->mBuf; - sdu->mBuf = NULLP; + umHdr.si = RLC_SI_LAST_SEG; + umHdr.so = sdu->actSz - sdu->sduSz; + sdu->mode.um.isSegmented = FALSE; } else { - SCatMsg(pdu, sdu->mBuf ,M1M2); - } - rbCb->m.umDl.bo -= sdu->sduSz; - - pduSz -= sdu->sduSz; -/* kw005.201 added support for L2 Measurement */ -#ifdef LTE_L2_MEAS_RLC - kwUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE); -#endif /* LTE_L2_MEAS */ - if (sdu->sduSz < 2048 && rbCb->m.umDl.numLi < KW_MAX_DL_LI) - { - rbCb->m.umDl.li[(rbCb->m.umDl.numLi)++] = sdu->sduSz; - } - else - { - kwUmmCreatePdu(gCb, rbCb, pdu, fi, pduInfo); - pdu = NULLP; - - if ( pduInfo->numPdu == KW_MAX_PDU) - { - /* Could not transmit what MAC asked for because the number - * of PDUs to be transmitted has reached maximum. */ - RLOG_ARG2(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "Maximum Pdu limit has been reached UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - break; - } + umHdr.si = 0; + umHdr.so = 0; } -#ifdef LTE_L2_MEAS - if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) ) - { - if(sdu->mode.um.isSegmented) - { - *sduIdx = dlIpThPut->lastSduIdx; - } - else - { - KW_GETSDUIDX(*sduIdx); - newIdx = TRUE; - } - kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst); - kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, - sdu->mode.um.sduId, newIdx); - /* ccpu00143043 */ - if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX) - { - lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime; - lchInfo.sduInfo[lchInfo.numSdus].isRetxPdu = FALSE; - lchInfo.numSdus++; - } - } -#endif - KW_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); - /* kw005.201 ccpu00117318, updating the statistics */ - kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId); + rlcUmmCreatePdu(gCb, rbCb, pdu, &umHdr, pduInfo); + RLC_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); /* kw003.201 */ + rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId); + pdu = NULLP; } /* Segmentation scenario : If size of SDU is greater than PDU size -# Allocate memory and Segment the Sdu. -# Update BO - -# Append to already existing PDU if any. - -# Set the second bit of the framing info. + -# Add segment to the PDU + -# Set the second bit of the segmentation info. -# Create the complete PDU and place in pduInfo. */ else { Buffer *remSdu; - SSegMsg(sdu->mBuf,pduSz,&remSdu); + ODU_SEGMENT_MSG(sdu->mBuf,pduSz,&remSdu); #ifdef LTE_L2_MEAS - if(KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb)) + if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb)) { if(sdu->mode.um.isSegmented) { @@ -505,14 +392,14 @@ KwDatReq *datReq; } else { - KW_GETSDUIDX(*sduIdx); + RLC_GETSDUIDX(*sduIdx); newIdx = TRUE; } - kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst); - kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, + rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst); + rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, sdu->mode.um.sduId, newIdx); } - if(KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb)) + if(RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb)) { if(sdu->actSz == sdu->sduSz) { @@ -520,29 +407,29 @@ KwDatReq *datReq; } } #endif - if (!pdu) + if(sdu->mode.um.isSegmented) { - pdu = sdu->mBuf; + umHdr.si = RLC_SI_MID_SEG; + umHdr.so = sdu->actSz - sdu->sduSz; } - else + else { - SCatMsg(pdu, sdu->mBuf, M1M2); - KW_FREE_BUF_WC(sdu->mBuf); + umHdr.si = RLC_SI_FIRST_SEG; + umHdr.so = 0; + sdu->mode.um.isSegmented = TRUE; } + pdu = sdu->mBuf; + sdu->sduSz -= pduSz; + rbCb->m.umDl.bo -= pduSz; + sdu->mBuf = remSdu; + pduSz = 0; - sdu->sduSz -= pduSz; - rbCb->m.umDl.bo -= pduSz; - sdu->mode.um.isSegmented = TRUE; - sdu->mBuf = remSdu; - pduSz = 0; - - fi |= 1; /* kw005.201 added support for L2 Measurement */ #ifdef LTE_L2_MEAS_RLC - kwUtlUpdSduSnMap(rbCb, sdu, datReq, FALSE); + rlcUtlUpdSduSnMap(rbCb, sdu, datReq, FALSE); #endif /* LTE_L2_MEAS */ - kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo); + rlcUmmCreatePdu(gCb, rbCb, pdu, &umHdr, pduInfo); pdu = NULLP; } /* kw005.201 added support for L2 Measurement */ @@ -554,22 +441,22 @@ KwDatReq *datReq; { if(--(rbCb->ueCb->numActRb[rbCb->qci]) == 0) { - kwCb.kwL2Cb.numActUe[rbCb->qci]--; + rlcCb.rlcL2Cb.numActUe[rbCb->qci]--; } } #endif /* LTE_L2_MEAS */ #ifdef LTE_L2_MEAS - kwUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant); + rlcUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant); /* Need to check into optimizing this code : TODO */ - if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && (lchInfo.numSdus != 0)) + if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && (lchInfo.numSdus != 0)) { - KwL2MeasTb *l2MeasTb = kwUtlGetCurMeasTb(gCb, rbCb); + RlcL2MeasTb *l2MeasTb = rlcUtlGetCurMeasTb(gCb, rbCb); /* ccpu00143043 */ /* Fix Klock warning */ if ((lchInfo.numSdus != 0) && (l2MeasTb != NULLP) && - (l2MeasTb->numLchInfo < KW_MAX_ACTV_DRB)) + (l2MeasTb->numLchInfo < RLC_MAX_ACTV_DRB)) { - cmMemcpy((U8 *) &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], (U8 *) &lchInfo, sizeof(KwlchInfo)); + memcpy( &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], &lchInfo, sizeof(RlclchInfo)); l2MeasTb->numLchInfo++; } l2MeasTb->txSegSduCnt += segSduCnt; @@ -577,34 +464,15 @@ KwDatReq *datReq; *totMacGrant -= (oldBo - rbCb->m.umDl.bo); #endif - /* If we have a situation wherein the size requested is greater than the total size of SDUs - and a pdu buffer which is not null, this if loop helps to send - a non null PDU to the lower layer. - */ - if (pduSz > 0 && pdu) - { - if (pduInfo->numPdu != KW_MAX_PDU) - { - rbCb->m.umDl.numLi--; - kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo); - pdu = NULLP; - } - else - { - KW_FREE_BUF_WC(pdu); - } - } - - kwUmmEstHdrSz(&rbCb->m.umDl); datReq->boRep.bo = rbCb->m.umDl.bo; - datReq->boRep.estHdrSz = rbCb->m.umDl.estHdrSz; + datReq->boRep.estHdrSz = 0; datReq->boRep.staPduPrsnt = FALSE; if (rbCb->m.umDl.sduQ.count > 0) { datReq->boRep.oldestSduArrTime = - ((KwSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime; + ((RlcSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime; } - RETVOID; + return; } /** @@ -625,35 +493,19 @@ KwDatReq *datReq; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwDlUmmReEstablish -( -KwCb *gCb, -CmLteRlcId rlcId, -Bool sendReEst, -KwDlRbCb *rbCb -) -#else -PUBLIC Void kwDlUmmReEstablish(gCb, rlcId, rbCb) -KwCb *gCb; -CmLteRlcId rlcId; -Bool sendReEst; -KwDlRbCb *rbCb; -#endif +Void rlcDlUmmReEstablish(RlcCb *gCb,CmLteRlcId rlcId,Bool sendReEst,RlcDlRbCb *rbCb) { /* The re-establishment indication is sent from the UL only */ - TRC2(kwDlUmmReEstablish) - - kwUmmFreeDlRbCb(gCb, rbCb); + rlcUmmFreeDlRbCb(gCb, rbCb); - rbCb->m.umDl.vtUs = 0; + rbCb->m.umDl.txNext = 0; /* this would have been set when re-establishment was triggered for SRB 1 */ - kwDlUtlResetReestInProgress(rbCb); + rlcDlUtlResetReestInProgress(rbCb); - RETVOID; + return; } /** * @brief Handler to create the header and complete a PDU. @@ -667,165 +519,57 @@ KwDlRbCb *rbCb; * @param[in] gCb RLC instance control block * @param[in,out] rbCb RB control block * @param[in] pdu PDU - * @param[in] fi Framing Info field + * @param[in] umHdr UM mode header * @param[out] datReqPduInfo Holder in which to copy the created PDU pointer * * @return Void */ -#ifdef ANSI -PRIVATE Void kwUmmCreatePdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -Buffer *pdu, -U8 fi, -KwPduInfo *datReqPduInfo -) -#else -PRIVATE Void kwUmmCreatePdu(gCb, rbCb, pdu, fi, datReqPduInfo) -KwCb *gCb; -KwDlRbCb *rbCb; -Buffer *pdu; -U8 fi; -KwPduInfo *datReqPduInfo -#endif +static void rlcUmmCreatePdu(RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *pdu, RlcUmHdr *umHdr, KwPduInfo *datReqPduInfo) { - KwSn sn; /* Sequence Number */ - U32 liCount; /* LI count */ - U8 e = 0; /* Extension Bit */ - U32 count; /* Loop Counter */ - U32 hdrSz; - - /* create a big array to store the header, assuming 3 bytes per 2 L1s - * (2 bytes if only a single LI) and 2 bytes for the - * FI and SN - * size of header = ( NumLi /2 ) * 3 + (NumLi % 2) * 2 + 2; - * where NumLi = Number of Length Indicators to be sent - */ - U8 hdr[((KW_MAX_DL_LI >> 1) * 3) + ((KW_MAX_DL_LI & 0x01) << 1) + 2]; - U32 idx = 0; /* To index to the hdr array */ + RlcSn sn; /* Sequence Number */ + uint8_t hdr[RLC_MAX_HDRSZ]; /* Stores header */ + uint32_t idx = 0; /* To index to the hdr array */ - /* Note: idx is not checked against crossing the hdr array bound as - * liCount will be < KW_MAX_DL_LI and as per the size calculated above; - * idx cannot cross the array - */ - - TRC2(kwUmmCreatePdu) - - /* stats updated before for bytes sent before adding RLC headers */ - kwUtlIncrementGenStsBytesAndPdusSent(&gCb->genSts, pdu); + rlcUtlIncrementGenStsBytesAndPdusSent(&gCb->genSts, pdu); - sn = rbCb->m.umDl.vtUs; - liCount = rbCb->m.umDl.numLi; - - if(liCount > KW_MAX_DL_LI) - liCount = KW_MAX_DL_LI; - - /* if there are any LI's then set the first E bit */ - if(liCount) - { - e = 1; - } - - if (rbCb->m.umDl.snLen == 1) + /* If SI = 0, 1 byte header conatining SI/R */ + if(umHdr->si == 0) { - hdr[idx++] = (fi << 6) | (e << 5) | sn; + hdr[idx++] = 0; } - else /* SN length is 2 */ + else { - /* SN length is 10 bits */ - hdr[idx] = (fi << 3) | (e << 2) | (sn >> 8); - hdr[++idx] = sn & 0xff; - ++idx; - } - - hdrSz = sizeof(hdr); - for (count = 0;count < liCount;count++) - { - /* In each iteration we try and encode 2 LIs */ - /* if this is the last LI then e should be 0 */ - if(count == liCount - 1) + /* Add SN based on SN length */ + sn = rbCb->m.umDl.txNext; + if (rbCb->m.umDl.snLen == RLC_UM_CFG_6BIT_SN_LEN) { - e = 0; + hdr[idx++] = (umHdr->si << 6) | sn; } - - /* ccpu00135170 Fixing KLOCK warning */ - if((idx + 1)>= hdrSz) - { - break; - } - /* odd LI, 1st , 3rd etc */ - hdr[idx] = (e << 7) | (rbCb->m.umDl.li[count] >> 4); - hdr[++idx] = (rbCb->m.umDl.li[count] & 0xf) << 4; - - count++; - if(count == liCount - 1) - { - e = 0; - } - else if(count >= liCount) + else { - break; + hdr[idx++] = (umHdr->si << 6) | (sn >> 8); + hdr[idx++] = sn & 0xff ; } - /* ccpu00135170 Fixing KLOCK warning */ - if((idx + 1)>= hdrSz) + + /* Add SO for middle and last segments*/ + if((umHdr->si == RLC_SI_MID_SEG) | (umHdr->si == RLC_SI_LAST_SEG)) { - break; + hdr[idx++] = (umHdr->so >> 8); + hdr[idx++] = umHdr->so & 0xff; } - /* even one, 2nd , 4th etc LI's, count starts at 0 */ - hdr[idx] |= ((e << 3) | (rbCb->m.umDl.li[count] >> 8)); - hdr[++idx] = rbCb->m.umDl.li[count] & 0xff; - ++idx; - } - /* if odd number of L1s increment idx */ - if(liCount & 0x1) - { - ++idx; - } + /* Increment TX_Next if this is last segment of current SDU */ + if(umHdr->si == RLC_SI_LAST_SEG) + rbCb->m.umDl.txNext = (rbCb->m.umDl.txNext + 1) & rbCb->m.umDl.modBitMask; - /* increment VT(US) */ - rbCb->m.umDl.vtUs = (rbCb->m.umDl.vtUs + 1) & rbCb->m.umDl.modBitMask; + } /* add the header to the beginning of the pdu */ - SAddPreMsgMultInOrder(hdr, idx, pdu); + ODU_ADD_PRE_MSG_MULT_IN_ORDER(hdr, idx, pdu); datReqPduInfo->mBuf[datReqPduInfo->numPdu++] = pdu; - RETVOID; -} - -/** - * @brief Handler to estimate the header size of the RLC SDUs - * present in the SDU queue. - * - * @details - * This function is used to update the estimated header size variable in RB. - * This function is called when a SDU is queued and when a PDU is formed and - * sent to the lower layer. - * - * @param[in] umDl UM mode downlink control block - * - * @return Void -*/ -#ifdef ANSI -PRIVATE Void kwUmmEstHdrSz -( -KwUmDl *umDl -) -#else -PRIVATE Void kwUmmEstHdrSz(umDl) -KwUmDl *umDl; -#endif -{ - /* The header size is estimated as : - If sdu count = 0 then 0 - else sdu count * 2 + 1; the 1 is added for the FI and SN byte; - 2 for one LI and E - */ - umDl->estHdrSz = (umDl->sduQ.count)?((umDl->sduQ.count << 1) + 1) : 0; - - RETVOID; + return; } /** @@ -844,40 +588,24 @@ KwUmDl *umDl; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwUmmDiscSdu -( -KwCb *gCb, -KwDlRbCb *rbCb, -U32 sduId -) -#else -PUBLIC Void kwUmmDiscSdu(gCb,rbCb,sduId) -KwCb *gCb; -KwDlRbCb *rbCb; -U32 sduId; -#endif +Void rlcUmmDiscSdu(RlcCb *gCb,RlcDlRbCb *rbCb,uint32_t sduId) { CmLList *tmpNode; /* Temporary Node in SDU queue */ - - TRC2(kwUmmDiscSdu) - - CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,tmpNode); if (tmpNode) { - KwSdu *sdu = (KwSdu *)tmpNode->node; + RlcSdu *sdu = (RlcSdu *)tmpNode->node; if (sdu->mode.um.sduId == sduId && sdu->mode.um.isSegmented == FALSE) { /* kw005.201 added support for L2 Measurement */ - KW_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu); + RLC_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu); gCb->genSts.numSduDisc++; } } - RETVOID; + return; } /* @@ -893,27 +621,15 @@ U32 sduId; * * @return Void */ -#ifdef ANSI -PUBLIC Void kwUmmFreeDlRbCb -( -KwCb *gCb, -KwDlRbCb *rbCb -) -#else -PUBLIC Void kwUmmFreeDlRbCb(gCb,rbCb) -KwCb *gCb; -KwDlRbCb *rbCb; -#endif +Void rlcUmmFreeDlRbCb(RlcCb *gCb,RlcDlRbCb *rbCb) { - TRC2(kwUmmFreeDlRbCb) - /* cat the SDU queue to the to be freed list */ cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.umDl.sduQ)); - kwUtlRaiseDlCleanupEvent(gCb); + rlcUtlRaiseDlCleanupEvent(gCb); - RETVOID; -} /* kwUmmFreeDlRbCb */ + return; +} /* rlcUmmFreeDlRbCb */ /********************************************************************30** End of file