X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_umm_dl.c;h=557b0baa0ddb86ceeb6ea87d55cb4250a2fc98b0;hb=de455b62ebaa9e36fe74dc36d342d7f6a22314e1;hp=739d39b31e2466dae97e41e9a4e3ab4658eafc45;hpb=0a26c487f1b6bbb5217e47b15fa8273b2e749283;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_umm_dl.c b/src/5gnrrlc/kw_umm_dl.c index 739d39b31..557b0baa0 100755 --- a/src/5gnrrlc/kw_umm_dl.c +++ b/src/5gnrrlc/kw_umm_dl.c @@ -34,9 +34,6 @@ 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 @@ -72,18 +69,16 @@ static int RLOG_FILE_ID=239; /* 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 rlcUmmEstHdrSz ARGS ((RlcUmDl *umUl)); - -PRIVATE Void rlcUmmCreatePdu ARGS ((RlcCb *gCb, +static Void rlcUmmCreatePdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *pdu, - U8 fi, + RlcUmHdr *umHdr, KwPduInfo *datReqPduInfo)); /** @addtogroup ummode */ @@ -106,46 +101,29 @@ PRIVATE Void rlcUmmCreatePdu ARGS ((RlcCb *gCb, * * @return Void */ -#ifdef ANSI -Void rlcUmmQSdu -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -KwuDatReqInfo *datReq, -Buffer *mBuf -) -#else -Void rlcUmmQSdu(gCb,rbCb,datReq,mBuf) -RlcCb *gCb; -RlcDlRbCb *rbCb; -KwuDatReqInfo *datReq; -Buffer *mBuf; -#endif +void rlcUmmQSdu(RlcCb *gCb, RlcDlRbCb *rbCb, RlcDatReqInfo *datReq, Buffer *mBuf) { MsgLen len; /* SDU buffer length */ RlcSdu *sdu; /* SDU */ - TRC2(rlcUmmQSdu) - RLC_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb); 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 */ rlcUtlGetCurrTime(&sdu->arrTime); /* Discard new changes ends */ - SFndLenMsg(mBuf,&len); + ODU_GET_MSG_LEN(mBuf,&len); sdu->mBuf = mBuf; sdu->sduSz = len; @@ -162,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; - - rlcUmmEstHdrSz(&rbCb->m.umDl); if(!rlcDlUtlIsReestInProgress(rbCb)) { - rlcUtlSndDStaRsp(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 */ @@ -183,7 +159,7 @@ Buffer *mBuf; } #endif - RETVOID; + return; } @@ -205,48 +181,35 @@ Buffer *mBuf; * -# ROK In case of success * -# RFAILED If allocation of Sdu fails */ -#ifdef ANSI -Void rlcUmmProcessSdus -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -RlcDatReq *datReq -) -#else -Void rlcUmmProcessSdus(gCb, rbCb, datReq) -RlcCb *gCb; -RlcDlRbCb *rbCb; -RlcDatReq *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 RlcContSduLst contSduLst; /*Contained sduLst */ - S32 dataVol = rbCb->m.umDl.bo; - U32* totMacGrant= &(datReq->totMacGrant); + int32_t dataVol = rbCb->m.umDl.bo; + uint32_t* totMacGrant= &(datReq->totMacGrant); RlcL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh; - U8 *sduIdx = &dlIpThPut->lastSduIdx; - Bool newIdx = FALSE; - S32 oldBo; + uint8_t *sduIdx = &dlIpThPut->lastSduIdx; + bool newIdx = FALSE; + int32_t oldBo; RlclchInfo lchInfo = {0}; - U32 segSduCnt = 0; + uint32_t segSduCnt = 0; #endif Ticks curTime = 0; - S16 timeDiff = 0; + int16_t timeDiff = 0; RlcSdu *sdu; - - TRC2(rlcUmmProcessSdus) - - pdu = NULLP; - pduInfo = &(datReq->pduInfo); pduSz = datReq->pduSz; @@ -262,8 +225,7 @@ RlcDatReq *datReq; rlcUtlGetCurrTime(&curTime); /* ccpu00143043 */ - while ((pduSz > 0) && (rbCb->m.umDl.sduQ.count > 0) && - (rbCb->m.umDl.numLi < RLC_MAX_DL_LI) && (pduInfo->numPdu < RLC_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 = (RlcSdu *)(firstNode->node); @@ -283,63 +245,74 @@ RlcDatReq *datReq; 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) { - RLC_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; + } + + 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; + } } - rlcUtlCalcLiForSdu(gCb,rbCb->m.umDl.numLi,sdu->sduSz,&pduSz); + 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(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb)) @@ -379,106 +352,36 @@ RlcDatReq *datReq; } } #endif /* LTE_L2_MEAS */ - RLC_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); /* kw003.201 */ - rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId); - rlcUmmCreatePdu(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 RLC_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 - rlcUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE); -#endif /* LTE_L2_MEAS */ - if (sdu->sduSz < 2048 && rbCb->m.umDl.numLi < RLC_MAX_DL_LI) - { - rbCb->m.umDl.li[(rbCb->m.umDl.numLi)++] = sdu->sduSz; + umHdr.si = 0; + umHdr.so = 0; } - else - { - rlcUmmCreatePdu(gCb, rbCb, pdu, fi, pduInfo); - pdu = NULLP; - - if ( pduInfo->numPdu == RLC_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; - } - } -#ifdef LTE_L2_MEAS - if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) ) - { - if(sdu->mode.um.isSegmented) - { - *sduIdx = dlIpThPut->lastSduIdx; - } - else - { - RLC_GETSDUIDX(*sduIdx); - newIdx = TRUE; - } - rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst); - rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz, - sdu->mode.um.sduId, newIdx); - /* ccpu00143043 */ - if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX) - { - lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime; - lchInfo.sduInfo[lchInfo.numSdus].isRetxPdu = FALSE; - lchInfo.numSdus++; - } - } -#endif - RLC_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); - /* kw005.201 ccpu00117318, updating the statistics */ - rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId); + 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(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb)) @@ -504,29 +407,29 @@ RlcDatReq *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); - RLC_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 rlcUtlUpdSduSnMap(rbCb, sdu, datReq, FALSE); #endif /* LTE_L2_MEAS */ - rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo); + rlcUmmCreatePdu(gCb, rbCb, pdu, &umHdr, pduInfo); pdu = NULLP; } /* kw005.201 added support for L2 Measurement */ @@ -553,7 +456,7 @@ RlcDatReq *datReq; if ((lchInfo.numSdus != 0) && (l2MeasTb != NULLP) && (l2MeasTb->numLchInfo < RLC_MAX_ACTV_DRB)) { - cmMemcpy((U8 *) &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], (U8 *) &lchInfo, sizeof(RlclchInfo)); + memcpy( &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], &lchInfo, sizeof(RlclchInfo)); l2MeasTb->numLchInfo++; } l2MeasTb->txSegSduCnt += segSduCnt; @@ -561,34 +464,15 @@ RlcDatReq *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 != RLC_MAX_PDU) - { - rbCb->m.umDl.numLi--; - rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo); - pdu = NULLP; - } - else - { - RLC_FREE_BUF_WC(pdu); - } - } - - rlcUmmEstHdrSz(&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 = ((RlcSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime; } - RETVOID; + return; } /** @@ -609,35 +493,19 @@ RlcDatReq *datReq; * * @return Void */ -#ifdef ANSI -Void rlcDlUmmReEstablish -( -RlcCb *gCb, -CmLteRlcId rlcId, -Bool sendReEst, -RlcDlRbCb *rbCb -) -#else -Void rlcDlUmmReEstablish(gCb, rlcId, rbCb) -RlcCb *gCb; -CmLteRlcId rlcId; -Bool sendReEst; -RlcDlRbCb *rbCb; -#endif +Void rlcDlUmmReEstablish(RlcCb *gCb,CmLteRlcId rlcId,Bool sendReEst,RlcDlRbCb *rbCb) { /* The re-establishment indication is sent from the UL only */ - TRC2(rlcDlUmmReEstablish) - 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 */ rlcDlUtlResetReestInProgress(rbCb); - RETVOID; + return; } /** * @brief Handler to create the header and complete a PDU. @@ -651,165 +519,57 @@ RlcDlRbCb *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 rlcUmmCreatePdu -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -Buffer *pdu, -U8 fi, -KwPduInfo *datReqPduInfo -) -#else -PRIVATE Void rlcUmmCreatePdu(gCb, rbCb, pdu, fi, datReqPduInfo) -RlcCb *gCb; -RlcDlRbCb *rbCb; -Buffer *pdu; -U8 fi; -KwPduInfo *datReqPduInfo -#endif +static void rlcUmmCreatePdu(RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *pdu, RlcUmHdr *umHdr, KwPduInfo *datReqPduInfo) { - RlcSn 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[((RLC_MAX_DL_LI >> 1) * 3) + ((RLC_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 < RLC_MAX_DL_LI and as per the size calculated above; - * idx cannot cross the array - */ - - TRC2(rlcUmmCreatePdu) - - /* stats updated before for bytes sent before adding RLC headers */ rlcUtlIncrementGenStsBytesAndPdusSent(&gCb->genSts, pdu); - sn = rbCb->m.umDl.vtUs; - liCount = rbCb->m.umDl.numLi; - - if(liCount > RLC_MAX_DL_LI) - liCount = RLC_MAX_DL_LI; - - /* if there are any LI's then set the first E bit */ - if(liCount) + /* If SI = 0, 1 byte header conatining SI/R */ + if(umHdr->si == 0) { - e = 1; + hdr[idx++] = 0; } - - if (rbCb->m.umDl.snLen == 1) - { - hdr[idx++] = (fi << 6) | (e << 5) | sn; - } - 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) - { - e = 0; - } - - /* ccpu00135170 Fixing KLOCK warning */ - if((idx + 1)>= hdrSz) + /* Add SN based on SN length */ + sn = rbCb->m.umDl.txNext; + if (rbCb->m.umDl.snLen == RLC_UM_CFG_6BIT_SN_LEN) { - break; + hdr[idx++] = (umHdr->si << 6) | sn; } - /* 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 rlcUmmEstHdrSz -( -RlcUmDl *umDl -) -#else -PRIVATE Void rlcUmmEstHdrSz(umDl) -RlcUmDl *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; } /** @@ -828,25 +588,9 @@ RlcUmDl *umDl; * * @return Void */ -#ifdef ANSI -Void rlcUmmDiscSdu -( -RlcCb *gCb, -RlcDlRbCb *rbCb, -U32 sduId -) -#else -Void rlcUmmDiscSdu(gCb,rbCb,sduId) -RlcCb *gCb; -RlcDlRbCb *rbCb; -U32 sduId; -#endif +Void rlcUmmDiscSdu(RlcCb *gCb,RlcDlRbCb *rbCb,uint32_t sduId) { CmLList *tmpNode; /* Temporary Node in SDU queue */ - - TRC2(rlcUmmDiscSdu) - - CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,tmpNode); if (tmpNode) @@ -861,7 +605,7 @@ U32 sduId; } } - RETVOID; + return; } /* @@ -877,26 +621,14 @@ U32 sduId; * * @return Void */ -#ifdef ANSI -Void rlcUmmFreeDlRbCb -( -RlcCb *gCb, -RlcDlRbCb *rbCb -) -#else -Void rlcUmmFreeDlRbCb(gCb,rbCb) -RlcCb *gCb; -RlcDlRbCb *rbCb; -#endif +Void rlcUmmFreeDlRbCb(RlcCb *gCb,RlcDlRbCb *rbCb) { - TRC2(rlcUmmFreeDlRbCb) - /* cat the SDU queue to the to be freed list */ cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.umDl.sduQ)); rlcUtlRaiseDlCleanupEvent(gCb); - RETVOID; + return; } /* rlcUmmFreeDlRbCb */ /********************************************************************30**