/**********************************************************************
- Name: LTE-RLC Layer
+ Name: NR RLC Layer
Type: C file
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
/* 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 */
*
* @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;
#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 */
}
#endif
- RETVOID;
+ return;
}
* -# 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;
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);
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))
}
}
#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))
}
}
#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 */
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;
*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;
}
/**
*
* @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.
* @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;
}
/**
*
* @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)
}
}
- RETVOID;
+ return;
}
/*
*
* @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**
Code Review / o-du / l2.git / blobdiff