# macro for output file name and makefile name
#
-PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DNR_RLC_UL -DODU_SLOT_IND_DEBUG_LOG -DEGTP_TEST
+PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DODU_SLOT_IND_DEBUG_LOG -DEGTP_TEST
ifeq ($(MODE),TDD)
PLTFRM_FLAGS += -DMODE=TDD
macCb.macCell[cellIdx]->macRaCb[ueIdx].msg4TbSize);
memset(&macCb.macCell[cellIdx]->macRaCb[ueIdx], 0, sizeof(MacRaCbInfo));
}
-
+
/* Send UL Data to RLC */
ret = macProcUlData(cellId, rxDataIndPdu->rnti, slotInfo, lcId, length, pdu);
#define RLC_TRANS_ID_LST_BKT_SIZE 10
#define RLC_MAX_RB 32
+/* RLC Mode defines */
+#define RLC_MODE_TM 1
+#define RLC_MODE_UM 2
+#define RLC_MODE_AM 3
+
/* Direction defines */
#define RLC_DIR_UL 1 /*!< Unlink direction */
#define RLC_DIR_DL 2 /*!< Downlink direction */
#define RLC_TMR_LEN 10
#define RLC_MAX_UM_TMR 1
#define RLC_MAX_AM_TMR 3
-#define RLC_EVT_UMUL_REORD_TMR 1
-#define RLC_EVT_AMUL_REORD_TMR 2
-#define RLC_EVT_AMUL_STA_PROH_TMR 3
-#define RLC_EVT_AMDL_POLL_RETX_TMR 4
-#define RLC_EVT_WAIT_BNDCFM 5
+
+/* Timer events */
+#define EVENT_RLC_UMUL_REASSEMBLE_TMR 1
+#define EVENT_RLC_AMUL_REORD_TMR 2
+#define EVENT_RLC_AMUL_STA_PROH_TMR 3
+#define EVENT_RLC_AMDL_POLL_RETX_TMR 4
+#define EVENT_RLC_WAIT_BNDCFM 5
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-#define RLC_EVT_L2_TMR 6
+#define EVENT_RLC_L2_TMR 6
#endif /* LTE_L2_MEAS */
/*******************************************************************************
#define RLC_UMUL rbCb->m.umUl
/* Sequence Number length defines */
-#define RLC_UM_CFG_5BIT_SN_LEN 1 /**< UM 5-bit Sequence number length
+#define RLC_UM_CFG_6BIT_SN_LEN 1 /**< UM 6-bit Sequence number length
in bytes*/
-#define RLC_UM_CFG_10BIT_SN_LEN 2 /**< UM 10-bit Sequence number length
+#define RLC_UM_CFG_12BIT_SN_LEN 2 /**< UM 12-bit Sequence number length
in bytes*/
/* 5GNR */
/* Sequence Number length defines */
cmLListInsCrnt(&lstCp, nodeToIns); \
}
-#define RLC_LLIST_DEL_RECBUF(_recBuf) \
+#define RLC_LLIST_DEL_RECBUF(_recBuf) \
{ \
- RlcSeg *_seg = NULLP; \
- RLC_LLIST_FIRST_SEG(_recBuf->segLst, _seg); \
+ RlcSeg *_seg = NULLP; \
+ RLC_LLIST_FIRST_SEG(_recBuf->segLst, _seg); \
while (_seg) \
{ \
cmLListDelFrm(&_recBuf->segLst, &_seg->lstEnt); \
- RLC_FREE(_seg, sizeof(RlcSeg)); \
- RLC_LLIST_NEXT_SEG(_recBuf->segLst, _seg); \
+ RLC_FREE(_seg, sizeof(RlcSeg)); \
+ RLC_LLIST_NEXT_SEG(_recBuf->segLst, _seg); \
} \
}
-#ifdef NR_RLC_UL
#define RLC_UMM_LLIST_FIRST_SEG(lstCp, nod) \
{ \
CmLList *tmpNode; \
nod = NULLP; \
}/*!< next segment in um mode linked list*/
-#endif
-
#define MODAMT(x, y, z,_snModMask) \
{ \
y = (x - z) & _snModMask; \
* @brief Structure to hold an Unacknowledged Mode header
*
* @details
- * - fi : Framing Info
+ * - si : Segmentation Info
* - sn : Sequence number
- * - numLi : Number of length indicators in the following array (li)
- * - li : Length indicators
+ * - so : Segmentation offset
*/
typedef struct rlcUmHdr
{
-#ifdef NR_RLC_UL
- uint8_t si; /*!< Segmentation Info */
- uint16_t so; /*!< Segment offset 5G NR */
-#endif
- uint8_t fi; /*!< Framing Info */
+ uint8_t si; /*!< Segmentation Info */
RlcSn sn; /*!< Sequence number */
- uint16_t numLi; /*!< Number of LIs */
- uint16_t li[RLC_MAX_UL_LI]; /*!< Array of LIs */
+ uint16_t so; /*!< Segmentation offset */
}RlcUmHdr;
if (mPollSn <= mAckSn)
{
- if (rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
+ if (rlcChkTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
}
* then starting the timer. Fixes crs
* ccpu00117216 and ccpu00118284 .
* */
- if( TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR) )
+ if( TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMDL_POLL_RETX_TMR) )
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
- rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
return (pollBit);
Void rlcAmmFreeDlRbCb(RlcCb *gCb,RlcDlRbCb *rbCb)
{
/* stop the re-transmission timer */
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMDL_POLL_RETX_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
/* store the entire Rb pointer */
rbCb = ueCb->lCh[lcId - 1].dlRbCb;
/* Skip if mode is not AM */
- if((rbCb == NULLP) || (rbCb->mode != CM_LTE_MODE_AM))
+ if((rbCb == NULLP) || (rbCb->mode != RLC_MODE_AM))
{
return RFAILED;
}
}
/* Check if reOrdTmr is running and update rxNextStatusTrig accordingly */
- tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR);
if (tmrRunning)
{
Bool snInWin = RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl);
if ( (amUl->rxNextStatusTrig == amUl->rxNext) || ( (!snInWin) &&
(amUl->rxNextStatusTrig != amUl->vrMr) ) )
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR);
tmrRunning = FALSE;
}
}
{
if (amUl->rxNextHighestRcvd > amUl->rxNext)
{
- rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR);
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
DU_LOG("\nRLC: rlcAmmProcessPdus: Updated rxNextStatusTrig = %d \
amUl->gatherStaPduInfo = FALSE;
/* Check if staProhTmr is running */
- tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, EVENT_RLC_AMUL_STA_PROH_TMR);
if (!tmrRunning)
{
/* Discard remaining PDUs and bytesegments in recBuf */
/* Stop all timers and reset variables */
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_REORD_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR);
}
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_STA_PROH_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_STA_PROH_TMR);
}
RLC_AMUL.rxNext = 0;
amUl->gatherStaPduInfo = FALSE;
/* Check if staProhTmr is running */
- tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
+ tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, EVENT_RLC_AMUL_STA_PROH_TMR);
if (!tmrRunning)
{
MODAMR(amUl->rxHighestStatus, mrxHighestStatus, amUl->rxNext, amUl->snModMask);
if (mrxNextHighestRcvd > mrxHighestStatus)
{
- rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
+ rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR);
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
}
windSz = (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_REORD_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR);
}
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_STA_PROH_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_STA_PROH_TMR);
}
{
if (measCb->measType & LKW_L2MEAS_ACT_UE)
{
- if((rlcRbCb->mode == CM_LTE_MODE_UM) &&
+ if((rlcRbCb->mode == RLC_MODE_UM) &&
(rlcRbCb->dir & RLC_DIR_DL ))
{
if (rlcRbCb->m.umDl.sduQ.count)
}
}
}
- else if (rlcRbCb->mode == CM_LTE_MODE_AM)
+ else if (rlcRbCb->mode == RLC_MODE_AM)
{
if ((rlcRbCb->m.amDl.cntrlBo) ||
(rlcRbCb->m.amDl.retxBo) ||
/* Initialize according to entMode */
switch (entCfg->entMode)
{
- case CM_LTE_MODE_TM:
+ case RLC_MODE_TM:
{
rbCb->lch.lChId = entCfg->lCh[0].lChId;
rbCb->lch.lChType = entCfg->lCh[0].type;
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
rbCb->lch.lChId = entCfg->lCh[0].lChId;
rbCb->lch.lChType = entCfg->lCh[0].type;
rbCb->dir = entCfg->dir;
+
+ /* Spec 38.322 Section 7.1
+ * All UM state variables can take values from 0 to 63 for 6 bit SN or
+ * from 0 to 4095 for 12 bit SN. All arithmetic operations on UM state
+ * variables are affected by the UM modulus
+ * (i.e. final value = [value from arithmetic operation] modulo 64
+ * for 6 bit SN and 4096 for 12 bit SN)
+ */
rbCb->m.umDl.snLen = entCfg->m.umInfo.dl.snLen;
- if (entCfg->m.umInfo.dl.snLen == RLC_UM_CFG_5BIT_SN_LEN)
- rbCb->m.umDl.modBitMask = 0x1f;
+ if (entCfg->m.umInfo.dl.snLen == RLC_UM_CFG_6BIT_SN_LEN)
+ rbCb->m.umDl.modBitMask = 0x3f;
else
- rbCb->m.umDl.modBitMask = 0x3ff;
+ rbCb->m.umDl.modBitMask = 0xfff;
ueCb->lCh[rbCb->lch.lChId - 1].dlRbCb = rbCb;
break;
}
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
/* Down Link Information
* indx = 0 as Down Link */
switch (rbCb->mode)
{
- case CM_LTE_MODE_TM:
+ case RLC_MODE_TM:
{
RlcDlCellCb *cellCb = (RlcDlCellCb *)ptr;
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
RlcDlUeCb *ueCb = (RlcDlUeCb *)ptr;
break;
}
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
RlcDlUeCb *ueCb = (RlcDlUeCb *)ptr;
if (((entCfg->lCh[0].type == CM_LTE_LCH_BCCH) ||
(entCfg->lCh[0].type == CM_LTE_LCH_PCCH) ||
(entCfg->lCh[0].type == CM_LTE_LCH_CCCH)) &&
- (entCfg->entMode == CM_LTE_MODE_TM))
+ (entCfg->entMode == RLC_MODE_TM))
{
/* Cell CB present */
rlcDbmFetchDlCellCb(gCb, cellId, &cellCb);
}
else
{
- reason= (entCfg->entMode != CM_LTE_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
+ reason= (entCfg->entMode != RLC_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
CKW_CFG_REAS_LCHTYPE_MIS;
/* Fill entCfm structure */
RLC_CFG_FILL_CFG_CFM(entCfm, entCfg->rbId, entCfg->rbType,
return RFAILED;
}
if ((((entCfg->lCh[0].type == CM_LTE_LCH_DCCH) &&
- (entCfg->entMode != CM_LTE_MODE_UM) &&
+ (entCfg->entMode != RLC_MODE_UM) &&
(CM_LTE_SRB == entCfg->rbType)) ||
((entCfg->lCh[0].type == CM_LTE_LCH_DTCH) &&
(CM_LTE_DRB == entCfg->rbType))) &&
- (entCfg->entMode != CM_LTE_MODE_TM))
+ (entCfg->entMode != RLC_MODE_TM))
{
/* UE CB present */
if ( rlcDbmFetchDlUeCb(gCb,ueId, cellId, &ueCb) == ROK)
/* Validate LChId for UM and AM modes */
if ((entCfg->lCh[0].lChId <= 0) ||
- ((entCfg->entMode == CM_LTE_MODE_AM)&&
+ ((entCfg->entMode == RLC_MODE_AM)&&
(entCfg->lCh[1].lChId <= 0)))
{
/* Fill entCfm structure */
}
else
{
- if (entCfg->entMode == CM_LTE_MODE_TM)
+ if (entCfg->entMode == RLC_MODE_TM)
{
reason = CKW_CFG_REAS_RB_MODE_MIS;
}
RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, rlcRbCb);
#endif
/* Free the Buffers of RbCb */
- if( CM_LTE_MODE_UM == rlcRbCb->mode)
+ if( RLC_MODE_UM == rlcRbCb->mode)
{
rlcUmmFreeDlRbCb(gCb,rlcRbCb);
/* Delete RbCb */
RLC_FREE(gCb,rlcRbCb, sizeof(RlcDlRbCb));
}
- else if( CM_LTE_MODE_AM == rlcRbCb->mode)
+ else if( RLC_MODE_AM == rlcRbCb->mode)
{
rlcAmmFreeDlRbCb(gCb,rlcRbCb);
}
switch (rbCb->mode)
{
- case CM_LTE_MODE_TM:
+ case RLC_MODE_TM:
{
rlcDlTmmReEstablish(gCb,rbCb);
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
rlcDlUmmReEstablish(gCb,rlcId,sndReEstInd,rbCb);
break;
}
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
rlcAmmDlReEstablish(gCb, rlcId, rbCb);
break;
#ifdef LTE_L2_MEAS_RLC
if (measCb->measType & LKW_L2MEAS_ACT_UE)
{
- if((rlcRbCb->mode == CM_LTE_MODE_UM) &&
+ if((rlcRbCb->mode == RLC_MODE_UM) &&
(rlcRbCb->dir & RLC_DIR_DL ))
{
if (rlcRbCb->m.um.umDl.sduQ.count)
}
}
}
- else if (rlcRbCb->mode == CM_LTE_MODE_AM)
+ else if (rlcRbCb->mode == RLC_MODE_AM)
{
if ((rlcRbCb->m.am.amDl.cntrlBo) ||
(rlcRbCb->m.am.amDl.retxBo) ||
/* Initialize according to entMode */
switch (entCfg->entMode)
{
- case CM_LTE_MODE_TM:
+ case RLC_MODE_TM:
{
rbCb->lch.lChId = entCfg->lCh[0].lChId;
rbCb->lch.lChType = entCfg->lCh[0].type;
rbCb->dir = entCfg->dir;
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
rbCb->lch.lChId = entCfg->lCh[0].lChId;
rbCb->lch.lChType = entCfg->lCh[0].type;
/* the bitmask for SN = 10 is 0x3ff and for SN = 5 is 0x1f */
rbCb->m.umUl.modBitMask = (rbCb->m.umUl.umWinSz << 1) - 1;
- rbCb->m.umUl.reOrdTmrInt =
- entCfg->m.umInfo.ul.reOrdTmr;
- cmInitTimers(&(rbCb->m.umUl.reOrdTmr), 1);
+ rbCb->m.umUl.reAsmblTmrInt =
+ entCfg->m.umInfo.ul.reAsmblTmr;
+ cmInitTimers(&(rbCb->m.umUl.reAsmblTmr), 1);
ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
break;
}
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
/* Down Link Information
* indx = 1 as Up Link */
switch (rbCb->mode)
{
- case CM_LTE_MODE_TM:
+ case RLC_MODE_TM:
{
RlcUlCellCb *cellCb = (RlcUlCellCb *)ptr;
rbCb->dir = entCfg->dir;
cellCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
rlcCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg);
break;
}
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
{
/* Validate LChId for UM and AM modes */
if ((cfgToValidate->lCh[0].lChId <= 0) ||
- ((cfgToValidate->entMode == CM_LTE_MODE_AM) &&
+ ((cfgToValidate->entMode == RLC_MODE_AM) &&
(cfgToValidate->lCh[1].lChId <= 0)))
{
status->reason = CKW_CFG_REAS_INVALID_LCHID;
return RFAILED;
}
- if((cfgToValidate->entMode == CM_LTE_MODE_UM) &&
- (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_5BIT_SN_LEN) &&
- (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_10BIT_SN_LEN))
+ if((cfgToValidate->entMode == RLC_MODE_UM) &&
+ (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_6BIT_SN_LEN) &&
+ (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_12BIT_SN_LEN))
{
RLOG_ARG2(L_ERROR,DBG_UEID,ueId,
"CellId[%u]:UM Mode RB[%d],Invalid SN Len[%d]",
}
if ((cfgToValidate->lCh[0].type != CM_LTE_LCH_CCCH) &&
- (cfgToValidate->entMode != CM_LTE_MODE_TM))
+ (cfgToValidate->entMode != RLC_MODE_TM))
{
- status->reason= (cfgToValidate->entMode != CM_LTE_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
+ status->reason= (cfgToValidate->entMode != RLC_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
CKW_CFG_REAS_LCHTYPE_MIS;
return RFAILED;
}
return RFAILED;
}
- if(cfgToValidate->entMode == CM_LTE_MODE_TM)
+ if(cfgToValidate->entMode == RLC_MODE_TM)
{
status->reason = CKW_CFG_REAS_LCHTYPE_MIS;
return RFAILED;
}
if (!(((cfgToValidate->lCh[0].type == CM_LTE_LCH_DCCH) &&
- (cfgToValidate->entMode != CM_LTE_MODE_UM))||
+ (cfgToValidate->entMode != RLC_MODE_UM))||
(cfgToValidate->lCh[0].type == CM_LTE_LCH_DTCH)) )
{
status->reason = CKW_CFG_REAS_RB_MODE_MIS;
}
}
/*Allocating the memory for receive buffer */
- if(CM_LTE_MODE_UM == cfgToValidate->entMode)
+ if(RLC_MODE_UM == cfgToValidate->entMode)
{
- uint32_t hashIndex;
+ uint16_t hashIndex;
+
+ /* Spec 38.322 Section 7.2
+ * UM_Window_Size = 32 when a 6 bit SN is configured,
+ * UM_Window_Size = 2048 when a 12 bit SN is configured.
+ */
cfgEntData->rbCb->m.umUl.umWinSz = RLC_POWER(2,
- ((cfgToValidate->m.umInfo.ul.snLen *5)-1));
-#ifdef NR_RLC_UL
- RLC_ALLOC(gCb,
- cfgEntData->rbCb->m.umUl.recBufLst,
- (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
- for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++)
+ ((cfgToValidate->m.umInfo.ul.snLen *6)-1));
+ RLC_ALLOC(gCb, cfgEntData->rbCb->m.umUl.recBufLst,
+ (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++ )
{
- cmLListInit(&(cfgEntData->rbCb->m.umUl.recBufLst[hashIndex]));
+ cmLListInit(&(cfgEntData->rbCb->m.umUl.recBufLst[hashIndex]));
}
-#endif
}
- else if(CM_LTE_MODE_AM == cfgToValidate->entMode)
+ else if(RLC_MODE_AM == cfgToValidate->entMode)
{
#ifndef LTE_TDD
uint32_t hashIndex;
if(CKW_CFG_ADD == cfg->cfgType)
{
- if(CM_LTE_MODE_UM == cfg->entMode)
+ if(RLC_MODE_UM == cfg->entMode)
{
- RLC_FREE(gCb,
- cfgEntData->rbCb->m.umUl.recBuf,
- (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(RlcUmRecBuf*));
+ RLC_FREE(gCb, cfgEntData->rbCb->m.umUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
}
- else if(CM_LTE_MODE_AM == cfg->entMode)
+ else if(RLC_MODE_AM == cfg->entMode)
{
#ifndef LTE_TDD
RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
NULLP;
/* Free the Buffers of RbCb */
- if( CM_LTE_MODE_UM == cfgEntData->rbCb->mode )
+ if( RLC_MODE_UM == cfgEntData->rbCb->mode )
{
rlcUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
}
- else if(CM_LTE_MODE_AM == cfgEntData->rbCb->mode)
+ else if(RLC_MODE_AM == cfgEntData->rbCb->mode)
{
rlcAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
}
cfgEntData->rbCb->rlcId.ueId = ueId;
switch (cfgEntData->rbCb->mode)
{
- case CM_LTE_MODE_TM:
+ case RLC_MODE_TM:
{
rlcTmmUlReEstablish(gCb,cfgEntData->rbCb);
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
rlcUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
break;
}
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
rlcAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
break;
#ifdef LTE_L2_MEAS
RLC_UPD_L2_DECR_NONIP_PER_QCI_RB_COUNT(gCb, (rbCbLst[idx]));
#endif
- if( CM_LTE_MODE_UM == rbCbLst[idx]->mode)
+ if( RLC_MODE_UM == rbCbLst[idx]->mode)
{
rlcUmmFreeDlRbCb(gCb,rbCbLst[idx]);
RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcDlRbCb));
}
- else if( CM_LTE_MODE_AM == rbCbLst[idx]->mode)
+ else if( RLC_MODE_AM == rbCbLst[idx]->mode)
{
rlcAmmFreeDlRbCb(gCb,rbCbLst[idx]);
}
/* ccpu00136940 */
- else if(CM_LTE_MODE_TM == rbCbLst[idx]->mode)
+ else if(RLC_MODE_TM == rbCbLst[idx]->mode)
{
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCbLst[idx]->m.tm.sduQ));
RLC_FREE (gCb,rbCbLst[idx], sizeof (RlcDlRbCb));
if (rbCbLst[idx] != NULLP)
{
/* Free the Buffers of RbCb */
- if( CM_LTE_MODE_UM == rbCbLst[idx]->mode )
+ if( RLC_MODE_UM == rbCbLst[idx]->mode )
{
rlcUmmFreeUlRbCb(gCb,rbCbLst[idx]);
}
- else if(CM_LTE_MODE_AM == rbCbLst[idx]->mode)
+ else if(RLC_MODE_AM == rbCbLst[idx]->mode)
{
rlcAmmFreeUlRbCb(gCb,rbCbLst[idx]);
}
{
case RLC_SAP_BINDING:
{
- rlcStopTmr (tRlcCb,(PTR)rguSap, RLC_EVT_WAIT_BNDCFM);
+ rlcStopTmr (tRlcCb,(PTR)rguSap, EVENT_RLC_WAIT_BNDCFM);
rguSap->retryCnt = 0;
rlcUtlTrigPdbFlowCntrl(tRlcCb, rbCb, lcInfo->pktAdmitCnt);
continue;
}
- if (rbCb->mode == CM_LTE_MODE_AM)
+ if (rbCb->mode == RLC_MODE_AM)
{
if ((rbCb->m.amDl.retxLst.count != 0) ||
((rbCb->m.amDl.bo == 0) ||
}
/* Register the timer */
-#if 0
- if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
+ if(ODU_REG_TMR_MT(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
rlcActvTmr) != ROK)
{
RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
return (LCM_REASON_REGTMR_FAIL);
}
-#endif
+
#ifdef LTE_L2_MEAS
rlcUtlL2MeasUlInit(gCb);
#endif
if(UDX_SAP.state != RLC_SAP_BND)
{
/* start timer to wait for bind confirm */
- rlcStartTmr(gCb,(PTR)(&UDX_SAP), RLC_EVT_WAIT_BNDCFM);
+ rlcStartTmr(gCb,(PTR)(&UDX_SAP), EVENT_RLC_WAIT_BNDCFM);
UDX_SAP.state = RLC_SAP_BINDING;
rlcUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
}
if(rguSap->state != RLC_SAP_BND)
{
/* start timer to wait for bind confirm */
- rlcStartTmr(gCb,(PTR)(rguSap), RLC_EVT_WAIT_BNDCFM);
+ rlcStartTmr(gCb,(PTR)(rguSap), EVENT_RLC_WAIT_BNDCFM);
rguSap->state = RLC_SAP_BINDING;
rguSap->spId = cntrl->t.cntrl.s.sapCntrl.spId;
rguSap->suId = cntrl->t.cntrl.s.sapCntrl.suId;
/* kw002.201 Adjusting the wait time as per timeRes configured by layer manager */
switch (tmrEvnt)
{
- case RLC_EVT_UMUL_REORD_TMR:
+ case EVENT_RLC_UMUL_REASSEMBLE_TMR:
{
RlcUmUl* umUl = &(((RlcUlRbCb *)cb)->m.umUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
- RLC_TMR_CALCUATE_WAIT(arg.wait, umUl->reOrdTmrInt, gCb->genCfg.timeRes);
+ RLC_TMR_CALCUATE_WAIT(arg.wait, umUl->reAsmblTmrInt, gCb->genCfg.timeRes);
- arg.timers = &umUl->reOrdTmr;
+ arg.timers = &umUl->reAsmblTmr;
arg.max = RLC_MAX_UM_TMR;
break;
}
- case RLC_EVT_AMUL_REORD_TMR:
+ case EVENT_RLC_AMUL_REORD_TMR:
{
RlcAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
arg.max = RLC_MAX_AM_TMR;
break;
}
- case RLC_EVT_AMUL_STA_PROH_TMR:
+ case EVENT_RLC_AMUL_STA_PROH_TMR:
{
RlcAmUl* amUl = &(((RlcUlRbCb *)cb)->m.amUl);
/* kw005.201 Changed wait calculation ccpu00117634*/
arg.max = RLC_MAX_AM_TMR;
break;
}
- case RLC_EVT_AMDL_POLL_RETX_TMR:
+ case EVENT_RLC_AMDL_POLL_RETX_TMR:
{
RlcAmDl* amDl = &(((RlcDlRbCb *)cb)->m.amDl);
/* kw005.201 Changed wait calculation ccpu00117634*/
arg.max = RLC_MAX_AM_TMR;
break;
}
- case RLC_EVT_WAIT_BNDCFM:
+ case EVENT_RLC_WAIT_BNDCFM:
{
RlcRguSapCb* rguSap = (RlcRguSapCb *)cb;
/* kw005.201 Changed wait calculation ccpu00117634*/
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- case RLC_EVT_L2_TMR:
+ case EVENT_RLC_L2_TMR:
{
measEvtCb = (RlcL2MeasEvtCb *)cb;
/* kw005.201 Changed wait calculation ccpu00117634*/
switch (tmrType)
{
- case RLC_EVT_UMUL_REORD_TMR:
+ case EVENT_RLC_UMUL_REASSEMBLE_TMR:
{
- arg.timers = &((RlcUlRbCb *)cb)->m.umUl.reOrdTmr;
+ arg.timers = &((RlcUlRbCb *)cb)->m.umUl.reAsmblTmr;
arg.max = RLC_MAX_UM_TMR;
break;
}
- case RLC_EVT_AMUL_REORD_TMR:
+ case EVENT_RLC_AMUL_REORD_TMR:
{
arg.timers = &((RlcUlRbCb *)cb)->m.amUl.reOrdTmr;
arg.max = RLC_MAX_AM_TMR;
break;
}
- case RLC_EVT_AMUL_STA_PROH_TMR:
+ case EVENT_RLC_AMUL_STA_PROH_TMR:
{
arg.timers = &((RlcUlRbCb *)cb)->m.amUl.staProhTmr;
arg.max = RLC_MAX_AM_TMR;
break;
}
- case RLC_EVT_AMDL_POLL_RETX_TMR:
+ case EVENT_RLC_AMDL_POLL_RETX_TMR:
{
arg.timers = &((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr;
arg.max = RLC_MAX_AM_TMR;
break;
}
- case RLC_EVT_WAIT_BNDCFM:
+ case EVENT_RLC_WAIT_BNDCFM:
{
arg.timers = &((RlcRguSapCb *)cb)->bndTmr;
arg.max = RLC_MAX_RGUSAP_TMR;
}
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- case RLC_EVT_L2_TMR:
+ case EVENT_RLC_L2_TMR:
{
measEvtCb = (RlcL2MeasEvtCb *)cb;
arg.timers = &measEvtCb->l2Tmr;
switch (tmrEvnt)
{
- case RLC_EVT_UMUL_REORD_TMR:
+ case EVENT_RLC_UMUL_REASSEMBLE_TMR:
{
RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
- rlcUmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
+ rlcUmmReAsmblTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
- case RLC_EVT_AMUL_REORD_TMR:
+ case EVENT_RLC_AMUL_REORD_TMR:
{
RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
rlcAmmReOrdTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
- case RLC_EVT_AMUL_STA_PROH_TMR:
+ case EVENT_RLC_AMUL_STA_PROH_TMR:
{
RlcUlRbCb *ulRbCb = (RlcUlRbCb *)cb;
rlcAmmStaProTmrExp(RLC_GET_RLCCB(ulRbCb->inst), ulRbCb);
break;
}
- case RLC_EVT_AMDL_POLL_RETX_TMR:
+ case EVENT_RLC_AMDL_POLL_RETX_TMR:
{
RlcDlRbCb *dlRbCb = (RlcDlRbCb *)cb;
RlcCb *gCb = RLC_GET_RLCCB(dlRbCb->inst);
gCb->genSts.protTimeOut++;
break;
}
- case RLC_EVT_WAIT_BNDCFM:
+ case EVENT_RLC_WAIT_BNDCFM:
{
rlcBndTmrExpiry(cb);
break;
{
switch (tmrEvnt)
{
- case RLC_EVT_UMUL_REORD_TMR:
+ case EVENT_RLC_UMUL_REASSEMBLE_TMR:
{
- return (((RlcUlRbCb *)cb)->m.umUl.reOrdTmr.tmrEvnt ==
- RLC_EVT_UMUL_REORD_TMR);
+ return (((RlcUlRbCb *)cb)->m.umUl.reAsmblTmr.tmrEvnt ==
+ EVENT_RLC_UMUL_REASSEMBLE_TMR);
}
- case RLC_EVT_AMUL_REORD_TMR:
+ case EVENT_RLC_AMUL_REORD_TMR:
{
return (((RlcUlRbCb *)cb)->m.amUl.reOrdTmr.tmrEvnt ==
- RLC_EVT_AMUL_REORD_TMR);
+ EVENT_RLC_AMUL_REORD_TMR);
}
- case RLC_EVT_AMUL_STA_PROH_TMR:
+ case EVENT_RLC_AMUL_STA_PROH_TMR:
{
return (((RlcUlRbCb *)cb)->m.amUl.staProhTmr.tmrEvnt ==
- RLC_EVT_AMUL_STA_PROH_TMR);
+ EVENT_RLC_AMUL_STA_PROH_TMR);
}
- case RLC_EVT_AMDL_POLL_RETX_TMR:
+ case EVENT_RLC_AMDL_POLL_RETX_TMR:
{
return (((RlcDlRbCb *)cb)->m.amDl.pollRetxTmr.tmrEvnt ==
- RLC_EVT_AMDL_POLL_RETX_TMR);
+ EVENT_RLC_AMDL_POLL_RETX_TMR);
}
- case RLC_EVT_WAIT_BNDCFM:
+ case EVENT_RLC_WAIT_BNDCFM:
{
- return (((RlcRguSapCb *)cb)->bndTmr.tmrEvnt == RLC_EVT_WAIT_BNDCFM);
+ return (((RlcRguSapCb *)cb)->bndTmr.tmrEvnt == EVENT_RLC_WAIT_BNDCFM);
}
default:
{
/* start timer to wait for bind confirm */
rlcStartTmr(RLC_GET_RLCCB(rguSapCb->pst.srcInst),
(PTR)rguSapCb,
- RLC_EVT_WAIT_BNDCFM);
+ EVENT_RLC_WAIT_BNDCFM);
/* Send bind request */
rguSapCb->retryCnt++;
{
case RLC_SAP_BINDING:
{
- if(TRUE == rlcChkTmr(tRlcCb,(PTR)udxSap,RLC_EVT_WAIT_BNDCFM))
+ if(TRUE == rlcChkTmr(tRlcCb,(PTR)udxSap,EVENT_RLC_WAIT_BNDCFM))
{
- rlcStopTmr (tRlcCb,(PTR)udxSap, RLC_EVT_WAIT_BNDCFM);
+ rlcStopTmr (tRlcCb,(PTR)udxSap, EVENT_RLC_WAIT_BNDCFM);
}
udxSap->retryCnt = 0;
}
/* Start staProhTmr */
- rlcStartTmr(tRlcCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
+ rlcStartTmr(tRlcCb,(PTR)rbCb, EVENT_RLC_AMUL_STA_PROH_TMR);
return (ROK);
}
/* Dispatch according to mode of the rbCb */
switch (rbCb->mode)
{
- case CM_LTE_MODE_TM:
+ case RLC_MODE_TM:
{
/* Verify the user */
if (pst->srcEnt != ENTNH)
rlcTmmQSdu(tRlcCb,rbCb, datReq, mBuf);
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
rlcUmmQSdu(tRlcCb,rbCb, datReq, mBuf);
break;
}
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
rlcAmmQSdu(tRlcCb,rbCb, mBuf, datReq);
break;
typedef struct rlcUlUeCb RlcUlUeCb;
-#ifdef NR_RLC_UL
/**
* @brief Structure to hold a RLC UM PDU segment
*
uint16_t soEnd; /*!< Segment Offset End */
RlcUmHdr umHdr; /*!<Um Header */
}RlcUmSeg;
-#endif
-
-/** @defgroup um_uplink UM Uplink Module
-*/
/**
* @brief Structure to hold a UM PDU
*/
typedef struct rlcUmRecBuf
{
-#ifdef NR_RLC_UL
RlcSn sn; /*!< Sequence Number */
CmLList lnk; /*!< Link to the receive buffer list */
Bool allSegRcvd; /*!< Flag to check whether all seg are received */
uint16_t expSo; /*!< Next expected seg offset */
Bool allRcvd; /*!< All bytes received or not */
RlcUmSeg *expByteSeg; /*!< Next expected byte segment */
-#endif
- Buffer *pdu; /**< Buffer holding the UM PDU */
- RlcUmHdr umHdr; /**< UM PDU Header Information */
- MsgLen pduSz; /**< PDU Size */
+ Buffer *pdu; /**< Buffer holding the UM PDU */
+ RlcUmHdr umHdr; /**< UM PDU Header Information */
+ MsgLen pduSz; /**< PDU Size */
}RlcUmRecBuf;
/**
*/
typedef struct rlcUmUl
{
- uint8_t snLen; /**< Sequence number length */
- uint8_t reOrdTmrInt; /**< Timer Interval */
-#ifdef NR_RLC_UL
- CmLListCp *recBufLst; /*!<Reception Buffer List */
-#endif
- RlcUmRecBuf **recBuf; /**< Reception buffer */
+ uint8_t snLen; /**< Sequence number length */
+ uint8_t reAsmblTmrInt; /**< Timer Interval */
+ CmLListCp *recBufLst; /**!<Reception Buffer List */
RlcSn umWinSz; /**< UM window size */
uint16_t modBitMask; /**< Bitmask for modulus to wrap around variables */
RlcSn sn; /**< Sequence number */
RlcSn vrUr; /**< VR(UR) - Receive state variable */
RlcSn vrUh; /**< VR(UH) - Highest received state variable */
RlcSn vrUx; /**< VR(UX) - Reordering state variable */
- CmTimer reOrdTmr; /**< Reordering Timer */
- Buffer *assembleSdu; /**< Assemble Sdu - Remains till the complete SDU is received */
- uint16_t expSo; /*!< Expected SO for reassembly */
- RlcSn expSn; /*!< Expected Sn */
+ CmTimer reAsmblTmr; /**< Reordering Timer */
+ Buffer *assembleSdu; /**< Assemble Sdu - Remains till the complete SDU is received */
+ uint16_t expSo; /*!< Expected SO for reassembly */
+ RlcSn expSn; /*!< Expected Sn */
}RlcUmUl;
/*@}*/
CmLteRlcId *rlcId,
RlcUlRbCb *rbCb));
-Void rlcUmmReOrdTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
+Void rlcUmmReAsmblTmrExp ARGS((RlcCb *gCb, RlcUlRbCb *rbCb));
Void rlcUmmFreeUlRbCb ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
* Utility Functions
***************************************************************************/
-#ifdef NR_RLC_UL
void rlcUtlStoreUmRecBuf ARGS ((CmLListCp *recBufLst,
RlcUmRecBuf *recBuf,
RlcSn sn
RlcUmRecBuf* rlcUtlGetUmRecBuf ARGS ((CmLListCp *recBufLst,
RlcSn sn
));
-#endif
-void rlcUtlStoreRecBuf ARGS ((CmLListCp *recBufLst,
+void rlcUtlDelUmRecBuf(RlcCb *gCb, CmLListCp *recBufLst, RlcUmRecBuf *recBuf);
+
+Void rlcUtlStoreRecBuf ARGS ((CmLListCp *recBufLst,
RlcAmRecBuf *recBuf,
RlcSn sn
));
--rlcUmmQSdu
--rlcUmmProcessSdus
--rlcUmmProcessPdus
- --rlcUmmReAssembleSdus
+ --rlcUmUlReAssembleSdus
--kwUmmReEstablish
File: kw_umm_ul.c
RlcUlRbCb *rbCb,
RlcUmRecBuf *umRecBuf));
-#ifdef NR_RLC_UL
bool rlcUmmAddRcvdSeg ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
RlcUmHdr *umHdr,
void rlcUmmRelAllSegs(RlcCb *gCb, RlcUmRecBuf *recBuf);
-#endif
-
#ifndef TENB_ACC
#ifndef LTE_PAL_ENB
uint32_t isMemThreshReached(Region region);
*
* @details
* Finds the next VR(UR) depending on the passed SN. Updates VR(UR) to
- * the SN of the first UMD PDU with SN >= _nextSn that has not been received
+ * the SN of the first UMD PDU with SN >= _nextSn that has not been reassembled
*
* @param[in] umUl pointer to Um mode uplink control block
* @param[in] nextSn Sequence number after which the VR(UR) is to set to
*
* @return Void
*/
-static void rlcUmmFindNextVRUR (RlcUmUl* umUl, RlcSn nextSn)
+static void rlcUmmFindRxNextReassembly (RlcCb *gCb, RlcUmUl* umUl, RlcSn nextSn)
{
RlcSn ur = RLC_UM_GET_VALUE(umUl->vrUr, *umUl);
-
+ RlcSn prevRxNextReassembly = umUl->vrUr;
+
RlcSn nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
-
+ RlcUmRecBuf *recBuf = rlcUtlGetUmRecBuf(umUl->recBufLst,nextSn);
+ RlcUmRecBuf *prevRecBuf = rlcUtlGetUmRecBuf(umUl->recBufLst,prevRxNextReassembly);
while (ur < nextSnToCompare)
{
- if (!(umUl->recBuf[nextSn])) /* if the buffer is empty, SN not received */
+ if((ur + 1) == nextSnToCompare)
+ {
+ if ((recBuf == NULLP) || (!(recBuf->allSegRcvd))) /* if the buffer is empty, SN not received */
+ {
+ umUl->vrUr = nextSn;
+ if(prevRecBuf)
+ {
+ rlcUmmRelAllSegs(gCb, prevRecBuf);
+ rlcUtlDelUmRecBuf(gCb, umUl->recBufLst, prevRecBuf);
+ }
+ break;
+ }
+ else
+ {
+ if(prevRecBuf)
+ {
+ rlcUmmRelAllSegs(gCb, prevRecBuf);
+ rlcUtlDelUmRecBuf(gCb, umUl->recBufLst, prevRecBuf);
+ }
+ }
+ prevRecBuf = rlcUtlGetUmRecBuf(umUl->recBufLst,nextSn);
+ nextSn = (nextSn + 1) & umUl->modBitMask;
+ nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
+ recBuf = rlcUtlGetUmRecBuf(umUl->recBufLst,nextSn);
+ }
+ else
{
- umUl->vrUr = nextSn;
- break;
+ umUl->vrUr++;
+ ur = RLC_UM_GET_VALUE(umUl->vrUr, *umUl);
+ if(prevRecBuf)
+ {
+ rlcUmmRelAllSegs(gCb, prevRecBuf);
+ rlcUtlDelUmRecBuf(gCb, umUl->recBufLst, prevRecBuf);
+ }
+ prevRecBuf = rlcUtlGetUmRecBuf(umUl->recBufLst,umUl->vrUr);
}
- nextSn = (nextSn + 1) & umUl->modBitMask;
- nextSnToCompare = RLC_UM_GET_VALUE(nextSn,*umUl);
}
}
/**
* @brief Checks whether a sequence number is within the
- * re-ordering window or not
+ * re-assembly window or not
*
* @param[in] sn Sequence Number to be checked
* @param[in] umUl pointer to Um mode uplink control block
*
* @return Void
*/
-static int16_t rlcUmmCheckSnInReordWindow (RlcSn sn, const RlcUmUl* const umUl)
+static int16_t rlcUmmCheckSnInReassemblyWindow (RlcSn sn, const RlcUmUl* const 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
*
return ROK;
}
-#endif
-
/**
* @brief Handler to process the Data Indication from the lower layer
* and send the PDUs to re-assembly unit.
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 */
+ RlcUmRecBuf *recBuf; /* UM Reception Buffer */
+ RlcUmHdr umHdr; /* Um header*/
+ bool tmrRunning; /* Boolean for checking Tmr */
+ MsgLen pduSz; /* Pdu Size */
+ RlcSn tRxNextReassembly;
+ RlcSn tRxNextReassemblyNxt;
+ RlcSn tRxNextHighest;
count = 0;
vrUh = &(rbCb->m.umUl.vrUh);
vrUr = &(rbCb->m.umUl.vrUr);
vrUx = &(rbCb->m.umUl.vrUx);
- recBuf = (rbCb->m.umUl.recBuf);
while (count < pduCount)
{
RlcSn ur;
- RlcSn uh;
RlcSn seqNum;
- Buffer *pdu = pduInfo->mBuf[count];
- RlcUmRecBuf *tmpRecBuf;
+ Buffer *pdu = pduInfo->mBuf[count];
+
gCb->genSts.pdusRecv++;
#ifndef RGL_SPECIFIC_CHANGES
#ifndef TENB_ACC
#endif
#endif
#endif
- /* create a buffer to be later inserted into the reception buffer */
- RLC_ALLOC_WC(gCb, tmpRecBuf, sizeof(RlcUmRecBuf));
-#if (ERRCLASS & ERRCLS_ADD_RES)
- if (tmpRecBuf == NULLP)
- {
- 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*/
#ifndef RGL_SPECIFIC_CHANGES
#ifndef TENB_ACC
uint32_t rlculdrop;
rlculdrop++;
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++;
continue;
}
#endif
#endif
/* get the pdu header */
- if (rlcUmmExtractHdr(gCb, rbCb, pdu, &(tmpRecBuf->umHdr)))
+ if (rlcUmmExtractHdr(gCb, rbCb, pdu, &umHdr))
{
- DU_LOG("\nRLC : rlcUmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",\
+ DU_LOG("\nERROR --> RLC_UL: 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(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 delivered to upper layer */
+ if(umHdr.si == 0)
+ {
+ rlcUtlSendUlDataToDu(gCb, rbCb, pdu);
+ ODU_PUT_MSG_BUF(pdu);
+ count++;
+ continue;
+ }
+
+ curSn = umHdr.sn;
/* Check if the PDU should be discarded or not */
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) && (RLC_UMUL.recBuf[curSn])) ||
- (seqNum < ur))
+ if (seqNum < ur)
{
/* PDU needs to be discarded */
- DU_LOG("\nRLC : rlcUmmProcessPdus: Received a duplicate pdu with sn %d \
+ DU_LOG("\nINFO --> RLC_UL: rlcUmmProcessPdus: Received an unexpected 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++;
continue;
}
- /* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
-
- /* kw006.201 ccpu00120058, reduced code complexity by adding new function */
rlcUtlCalUlIpThrPut(gCb,rbCb, pdu, ttiCnt);
-
#endif
- recBuf[curSn] = tmpRecBuf;
-
- recBuf[curSn]->pdu = pdu;
- ODU_GET_MSG_LEN(pdu,&(recBuf[curSn]->pduSz));
- /* kw005.201 ccpu00117318, updating the statistics */
- gCb->genSts.bytesRecv += recBuf[curSn]->pduSz;
-
- if (!rlcUmmCheckSnInReordWindow(curSn,&RLC_UMUL))
- { /* currSn is outside re-ordering window */
- *vrUh = (curSn + 1) & RLC_UMUL.modBitMask;
+ ODU_GET_MSG_LEN(pdu, &pduSz);
+ /* Place sdu segment into recption buffer */
+ if(rlcUmmAddRcvdSeg(gCb, rbCb, &umHdr, pdu, pduSz) == TRUE)
+ {
+ recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst, umHdr.sn);
+ if (recBuf == NULLP)
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUmmProcessPdus: recBuf is NULLP UEID:%d CELLID:%d", \
+ rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+ ODU_PUT_MSG_BUF(pdu);
+ count++;
+ continue;
+ }
- /* re-assemble all pdus outside the modified re-ordering window */
- /* the first SN is VR(UR) */
- if (!rlcUmmCheckSnInReordWindow(*vrUr,&RLC_UMUL))
+ /* If all bytes segments of curSn are received, deliver assembled SDU to upper layer */
+ if(recBuf != NULLP && recBuf->allSegRcvd)
{
- /* TODO : should it be VR(UR) + 1 ?... check, earlier it was so */
- RlcSn sn = *vrUr; /* SN's which need to be re-assembled */
- RlcSn lowerEdge; /* to hold the lower-edge of the
- re-ordering window */
+ rlcUmmReAssembleSdus(gCb, rbCb, recBuf);
+ DU_LOG("\nDEBUG --> RLC_UL: rlcUmmProcessPdus: Assembled the Sdus for sn = %d UEID:%d CELLID:%d",\
+ umHdr.sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- /* 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 - RLC_UMUL.umWinSz) & RLC_UMUL.modBitMask;
- lowerEdge = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
-
- while (RLC_UM_GET_VALUE(sn, RLC_UMUL) < lowerEdge)
+ /* if curSn is same as the RX_NEXT_Reassembly */
+ if (seqNum == ur)
{
- if (recBuf[sn])
- {
-#ifdef NR_RLC_UL
- rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
-#endif
- RLC_FREE(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
- recBuf[sn] = NULLP;
- }
- sn = (sn + 1) & RLC_UMUL.modBitMask;
+ /* set RX_NEXT_Reassembly to next SN > current RX_NEXT_Reassembly which is not reassembled yet */
+ RlcSn nextVrUr = (*vrUr + 1) & RLC_UMUL.modBitMask;
+ rlcUmmFindRxNextReassembly(gCb, &RLC_UMUL, nextVrUr);
}
}
- }
- if (recBuf[*vrUr])
- {
- RlcSn sn = *vrUr;
- RlcSn tSn = RLC_UM_GET_VALUE(sn,RLC_UMUL);
- RlcSn tVrUr;
+ /* If curSn is outside re-assembly window */
+ else if (!rlcUmmCheckSnInReassemblyWindow(curSn,&RLC_UMUL))
+ {
+ DU_LOG("\nDEBUG --> RLC_UL: rlcUmmProcessPdus: curent sn is outSide the re-Assembly window. \
+ sn = %d UEID:%d CELLID:%d", umHdr.sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- /* set VR(UR) to next SN > current VR(UR) which is not received */
- RlcSn nextVrUr = (*vrUr + 1) & RLC_UMUL.modBitMask;
- rlcUmmFindNextVRUR(&RLC_UMUL, nextVrUr);
+ /* update RX_NEXT_Highest */
+ *vrUh = (curSn + 1) & RLC_UMUL.modBitMask;
- /* re-assemble SDUs with SN < Vr(UR) */
- tVrUr = RLC_UM_GET_VALUE(*vrUr,RLC_UMUL);
- while (recBuf[sn] && tSn < tVrUr)
- {
-#ifdef NR_RLC_UL
- rlcUmmReAssembleSdus(gCb,rbCb,recBuf[sn]);
-#endif
- RLC_FREE(gCb,recBuf[sn],sizeof(RlcUmRecBuf));
- recBuf[sn] = NULLP;
- sn = (sn + 1) & RLC_UMUL.modBitMask;
- tSn = RLC_UM_GET_VALUE(sn, RLC_UMUL);
+ /* Discard all pdus outside the modified re-assembly window */
+ if (!rlcUmmCheckSnInReassemblyWindow(*vrUr,&RLC_UMUL))
+ {
+ RlcSn sn = *vrUr; /* Stores SNs which need to be discarded. First SN is VR(UR) */
+ RlcSn lowerEdge; /* to hold the lower-edge of the re-assembly window */
+ RlcSn packetCount;
+
+ /* Set RX_NEXT_Reassembly to next SN >= (RX_NEXT_Highest - windowSize) that has not been reassembled yet */
+ *vrUr = (*vrUh - RLC_UMUL.umWinSz) & RLC_UMUL.modBitMask;
+ lowerEdge = *vrUr;
+ packetCount = (lowerEdge - sn) & RLC_UMUL.modBitMask;
+
+ while (packetCount)
+ {
+ recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst, sn);
+ if (recBuf)
+ {
+ rlcUmmRelAllSegs(gCb, recBuf);
+ rlcUtlDelUmRecBuf(gCb, RLC_UMUL.recBufLst, recBuf);
+ }
+ sn = (sn + 1) & RLC_UMUL.modBitMask;
+ packetCount--;
+ }
+ recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst, *vrUr);
+ if (recBuf != NULLP && recBuf->allSegRcvd)
+ {
+ /* set rxNextReassembly to next SN > current rxNextReassembly which is not received */
+ RlcSn nextRxNextReassembly = (*vrUr + 1) & RLC_UMUL.modBitMask;
+ rlcUmmFindRxNextReassembly(gCb ,&RLC_UMUL, nextRxNextReassembly);
+ }
+ }
}
- }
- tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_UMUL_REORD_TMR);
-
- if (tmrRunning)
- {
- RlcSn tVrUx = RLC_UM_GET_VALUE(*vrUx, RLC_UMUL);
- RlcSn tVrUr = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
-
- RlcSn tVrUh = RLC_UM_GET_VALUE(*vrUh, RLC_UMUL);
-
- S16 ret = rlcUmmCheckSnInReordWindow(*vrUx, &RLC_UMUL);
-
- if ( (tVrUx <= tVrUr) || ((!ret) && (tVrUx != tVrUh)))
- {
- rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
- tmrRunning = FALSE;
- }
+ tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, EVENT_RLC_UMUL_REASSEMBLE_TMR);
+ tRxNextReassembly = RLC_UM_GET_VALUE(*vrUr ,RLC_UMUL);
+ tRxNextReassemblyNxt = (*vrUr + 1) & rbCb->m.umUl.modBitMask;
+ tRxNextHighest = RLC_UM_GET_VALUE(*vrUh, RLC_UMUL);
+ tRxNextReassemblyNxt = RLC_UM_GET_VALUE(tRxNextReassemblyNxt ,RLC_UMUL);
+
+ /* If reassemby timer is running */
+ if (tmrRunning)
+ {
+ RlcSn tRxTimerTigger = RLC_UM_GET_VALUE(*vrUx, RLC_UMUL);
+ uint8_t ret = rlcUmmCheckSnInReassemblyWindow(*vrUx, &RLC_UMUL);
+ recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst,*vrUr);
+
+ if ((tRxTimerTigger <= tRxNextReassembly) || ((!ret) && (tRxTimerTigger != tRxNextHighest)) ||
+ (tRxNextHighest == tRxNextReassemblyNxt && recBuf && recBuf->noMissingSeg))
+ {
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_UMUL_REASSEMBLE_TMR);
+ tmrRunning = FALSE;
+ DU_LOG("\nINFO --> RLC_UL: rlcUmmProcessPdus: Stopped ReAssembly Timer rxTimerTigger = %d \
+ rxNextReassembly = %d rxNextHighest = %d ", tRxTimerTigger, tRxNextReassembly, tRxNextHighest);
+ }
+ }
+
+ /* If Reassembly timer is not running */
+ if (!tmrRunning)
+ {
+ recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst, curSn);
+ if ((tRxNextHighest > tRxNextReassemblyNxt) || ((tRxNextHighest == tRxNextReassemblyNxt)
+ && (recBuf && (!recBuf->noMissingSeg))))
+ {
+ DU_LOG("\nDEBUG --> RLC_UL: rlcUmmProcessPdus: Start ReAssembly Timer tRxNextReassemblyNxt = %d \
+ tRxNextHighest %d", tRxNextReassemblyNxt, tRxNextHighest);
+ rlcStartTmr(gCb, (PTR)rbCb, EVENT_RLC_UMUL_REASSEMBLE_TMR);
+ *vrUx = *vrUh;
+ }
+ }
}
-
- if (!tmrRunning)
+ else
{
- if (RLC_UM_GET_VALUE(*vrUh, RLC_UMUL) > RLC_UM_GET_VALUE(*vrUr, RLC_UMUL))
- {
- rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
- *vrUx = *vrUh;
- }
+ DU_LOG("\nERROR --> RLC_UL: rlcUmmProcessPdus:Failed to assemble the PDU for SN = %d UEID:%d CELLID:%d",\
+ umHdr.sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+
}
count++;
}/* end while count < pduCount */
* - If direction of the RB is downlink :
* Remove all the SDUs in the SDU queue.
* - If direction of the RB is uplink :
- * Call rlcUmmReAssembleSdus() for each PDU with SN < VR(UH)
+ * Call rlcUmUlReAssembleSdus() for each PDU with SN < VR(UH)
*
* @param[in] gCb RLC Instance control block
* @param[in] rlcID Identity of the RLC entity for which
{
RlcSn curSn;
RlcSn vrUh;
- RlcUmRecBuf **recBuf; /* UM Reception Buffer */
+ RlcUmRecBuf *recBuf; /* UM Reception Buffer */
RlcKwuSapCb *rlcKwSap; /* KWU SAP Information */
curSn = rbCb->m.umUl.vrUr;
vrUh = RLC_UM_GET_VALUE(rbCb->m.umUl.vrUh,rbCb->m.umUl);
- recBuf = rbCb->m.umUl.recBuf;
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_UMUL_REASSEMBLE_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb,EVENT_RLC_UMUL_REASSEMBLE_TMR);
}
- while (RLC_UM_GET_VALUE(curSn,rbCb->m.umUl) < vrUh)
+ while (RLC_UM_GET_VALUE(curSn, rbCb->m.umUl) < vrUh)
{
- if ( recBuf[curSn] != NULLP )
+ recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst, curSn);
+ if ( recBuf != NULLP )
{
-#ifdef NR_RLC_UL
- rlcUmmReAssembleSdus(gCb,rbCb,recBuf[curSn]);
-#endif
- RLC_FREE(gCb,recBuf[curSn],sizeof(RlcUmRecBuf));
- recBuf[curSn] = NULLP;
+ if(recBuf->allRcvd == TRUE)
+ {
+ rlcUmmReAssembleSdus(gCb,rbCb,recBuf);
+ }
+ else
+ {
+ /* Remove PDU and segments */
+ if(recBuf->pdu)
+ {
+ ODU_PUT_MSG_BUF(recBuf->pdu);
+ }
+ /* Release all the segments*/
+ rlcUmmRelAllSegs(gCb,recBuf);
+ }
+ rlcUtlDelUmRecBuf(gCb, RLC_UMUL.recBufLst, recBuf);
}
curSn = (curSn + 1) & rbCb->m.umUl.modBitMask;
}
*
* @details
* This function is used to extract the header of a PDU and store it
- * along with the PDU buffer.The sequence number,framing info
- * and LIs are extracted by this function.
+ * along with the PDU buffer.The sequence number, segmentation info
+ * and segmentation offset are extracted by this function.
*
* @param[in] gCb RLC Instance control block
* @param[in] rbCb Rb Control block for which the pdu is received
*/
static uint8_t rlcUmmExtractHdr(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *pdu, RlcUmHdr *umHdr)
{
- uint8_t e; /* Extension Bit */
Data dst[2]; /* Destination Buffer */
- int32_t totalSz; /* Sum of LIs */
- MsgLen pduSz; /* PDU size */
-#if (ERRCLASS & ERRCLS_DEBUG)
uint8_t ret; /* Return Value */
-#endif
- ODU_GET_MSG_LEN(pdu,&pduSz);
-
- if ( rbCb->m.umUl.snLen == 1)
+ memset(umHdr, 0, sizeof(RlcUmHdr));
+
+ ret = ODU_REM_PRE_MSG(dst,pdu);
+ if (ret != ROK)
{
-#if (ERRCLASS & ERRCLS_DEBUG)
- ret = ODU_REM_PRE_MSG(dst,pdu);
- if (ret != ROK)
- {
- 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
- ODU_REM_PRE_MSG(dst,pdu);
-#endif
- pduSz--;
- umHdr->sn = (dst[0]) & 0x1F;
- umHdr->fi = (dst[0]) >> 6;
- e = (dst[0]>>5) & 0x01;
+ DU_LOG("\nERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed for SI\
+ UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+ return RFAILED;
+ }
+ umHdr->si = (dst[0]) >> 6;
+
+ /* If SI = 0, the RLC PDU contains complete RLC SDU. Header extraction complete.
+ * No other fields present in header */
+ if(umHdr->si == 0)
+ return ROK;
+
+ /* If SI != 0, one SDU segment is present in RLC PDU. Hence extracting SN */
+ if (rbCb->m.umUl.snLen == RLC_UM_CFG_6BIT_SN_LEN)
+ {
+ /* Extractin 6-bit SN */
+ umHdr->sn = (dst[0]) & 0x3F;
}
else
{
- /* snLen - sequnce length will be 10 bits requiring 2 bytes */
-#if (ERRCLASS & ERRCLS_DEBUG)
- ret = ODU_REM_PRE_MSG_MULT(dst,2,pdu);
+ /* Extracting 12 bits SN */
+ umHdr->sn = (dst[0]) & 0x0F;
+ ret = ODU_REM_PRE_MSG(dst,pdu);
if (ret != ROK)
{
- 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;
+ DU_LOG("\nERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed for SN\
+ UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+ return RFAILED;
}
-#else
- ODU_REM_PRE_MSG_MULT(dst,2,pdu);
-#endif
- pduSz -= 2;
-
- /* kw005.201 R9 Upgrade 3gpp spec 36.322 ver9.3.0 CR0082 *
- * Removed the "if" condition for checking the reserved field *
- * Added mask 0x03 for extracting the FI field. */
-
- umHdr->fi = ( (dst[0] ) >> 3) & 0x03;
- e = ( (dst[0] ) >> 2) & 0x01;
- umHdr->sn = ( dst[0] & 0x03) << 8;
- umHdr->sn |= dst[1];
+ umHdr->sn = (umHdr->sn << 8) | dst[0];
}
- umHdr->numLi = 0;
-
- totalSz = 0;
- while(e && umHdr->numLi < RLC_MAX_UL_LI )
+ /* SO field is present for middle and last segments of SDU, not present for first segment */
+ if((umHdr->si == RLC_SI_LAST_SEG) || (umHdr->si == RLC_SI_MID_SEG))
{
-#if (ERRCLASS & ERRCLS_DEBUG)
ret = ODU_REM_PRE_MSG_MULT(dst,2,pdu);
if (ret != ROK)
{
- DU_LOG("\nRLC : rlcUmmExtractHdr : ODU_REM_PRE_MSG_MULT Failed UEID:%d CELLID:%d",\
- rbCb->rlcId.ueId, rbCb->rlcId.cellId);
+ DU_LOG("\nERROR --> RLC_UL: rlcUmmExtractHdr : ODU_REM_PRE_MSG_MULT Failed for 16 bits SO \
+ UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
return RFAILED;
}
-#else
- 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] )
- {
- 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 )
- {
- 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*/
- }
- umHdr->numLi++;
- pduSz -= 2;
-
- e = ((dst[0]) & 0x80) >> 7;
-
- if ( e && umHdr->numLi < RLC_MAX_UL_LI)
- {
- uint8_t tmp = ((dst[1]) & 0x08) >> 3;
- umHdr->li[umHdr->numLi] = ( dst[1] & 0x07) << 8;
-
-
-#if (ERRCLASS & ERRCLS_DEBUG)
- ret = ODU_REM_PRE_MSG(dst,pdu);
- if (ret != ROK)
- {
- DU_LOG("\nRLC : rlcUmmExtractHdr : ODU_REM_PRE_MSG Failed UEID:%d CELLID:%d",
- rbCb->rlcId.ueId, rbCb->rlcId.cellId);
- return RFAILED;
- }
-#else
- 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] )
- {
- 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];
- pduSz--;
- umHdr->numLi++;
-
- if (pduSz < totalSz)
- {
- return RFAILED; /* the situation where in the PDU size is
- something that does not match with the
- size in LIs*/
- }
-
- e = tmp;
- }
- } /* while(e && umHdr->numLi < RLC_MAX_LI ) */
- if (e)
- {
- /* PDU was constructed with LIs that exceeded RLC_MAX_LI */
- return RFAILED;
+ umHdr->so = dst[0];
+ umHdr->so = (umHdr->so << 8) | dst[1];
}
return ROK;
}
/**
- * @brief Handles expiry of re-ordering timer
+ * @brief Handles expiry of re-assembly timer
*
* @param[in] gCb RLC Instance control block
- * @param[in] rbCb Rb Control block for which re-order timer expired
+ * @param[in] rbCb Rb Control block for which re-assembly timer expired
*
* @return Void
*/
-Void rlcUmmReOrdTmrExp
+void rlcUmmReAsmblTmrExp
(
RlcCb *gCb,
RlcUlRbCb *rbCb
)
{
- RlcSn prevVrUr; /* prevVrUr */
- prevVrUr = RLC_UMUL.vrUr;
+ RlcSn tRxNextHighest;
+ RlcSn tRxNextReassembly;
+ RlcUmRecBuf *recBuf;
- /* set VR(UR) to SN >= VR(UX) that has not been received */
- rlcUmmFindNextVRUR(&RLC_UMUL, RLC_UMUL.vrUx);
-
- while (RLC_UM_GET_VALUE(prevVrUr,RLC_UMUL) <
- RLC_UM_GET_VALUE(RLC_UMUL.vrUr,RLC_UMUL))
- {
- if (RLC_UMUL.recBuf[prevVrUr])
- {
-#ifdef NR_RLC_UL
- rlcUmmReAssembleSdus(gCb, rbCb, RLC_UMUL.recBuf[prevVrUr]);
-#endif
- if(RLC_UMUL.recBuf[prevVrUr]->pdu != NULLP) /* RLC mem leak fix */
- {
- ODU_PUT_MSG_BUF(RLC_UMUL.recBuf[prevVrUr]->pdu);
- }
- RLC_FREE(gCb, RLC_UMUL.recBuf[prevVrUr], sizeof(RlcUmRecBuf));
- RLC_UMUL.recBuf[prevVrUr] = NULLP;
- }
+ DU_LOG("\nINFO --> RLC_UL: rlcUmmReAsmblTmrExp: UM Re-assembly timer expired");
- prevVrUr = (prevVrUr + 1) & rbCb->m.umUl.modBitMask;
- }
+ /* set VR(UR) to SN >= VR(UX) that has not been reassembled */
+ rlcUmmFindRxNextReassembly(gCb, &RLC_UMUL, RLC_UMUL.vrUx);
- if (RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL) >
- RLC_UM_GET_VALUE(RLC_UMUL.vrUr, RLC_UMUL))
+ tRxNextHighest = RLC_UM_GET_VALUE(RLC_UMUL.vrUh, RLC_UMUL);
+ tRxNextReassembly = (RLC_UMUL.vrUr + 1) & rbCb->m.umUl.modBitMask;
+ tRxNextReassembly = RLC_UM_GET_VALUE(tRxNextReassembly, RLC_UMUL);
+ recBuf = rlcUtlGetUmRecBuf(RLC_UMUL.recBufLst,RLC_UMUL.vrUr);
+ if ((tRxNextHighest > tRxNextReassembly) || ((tRxNextHighest == tRxNextReassembly) &&
+ ((recBuf) && !(recBuf->noMissingSeg))))
{
- rlcStartTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
+ rlcStartTmr(gCb, (PTR)rbCb, EVENT_RLC_UMUL_REASSEMBLE_TMR);
RLC_UMUL.vrUx = RLC_UMUL.vrUh;
}
}
RlcUlRbCb *rbCb
)
{
- 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;
+ RlcSn curSn = 0; /* Sequence number of PDU */
+ RlcUmRecBuf *recBuf = NULLP;
- if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR))
+ if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_UMUL_REASSEMBLE_TMR))
{
- rlcStopTmr(gCb,(PTR)rbCb,RLC_EVT_UMUL_REORD_TMR);
+ rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_UMUL_REASSEMBLE_TMR);
}
- while (curSn < windSz)
+
+ do
{
- if (umRecBuf[curSn] != NULLP)
+ recBuf = rlcUtlGetUmRecBuf(rbCb->m.umUl.recBufLst, curSn);
+ if ( recBuf != NULLP )
{
- ODU_PUT_MSG_BUF(umRecBuf[curSn]->pdu);
- umRecBuf[curSn]->pdu = NULLP;
-
- RLC_FREE(gCb, umRecBuf[curSn], sizeof(RlcUmRecBuf));
- umRecBuf[curSn] = NULLP;
+ if (recBuf->pdu != NULLP)
+ {
+ ODU_PUT_MSG_BUF(recBuf->pdu);
+ }
+ /* Release all the segments */
+ rlcUmmRelAllSegs(gCb,recBuf);
+ rlcUtlDelUmRecBuf(gCb, rbCb->m.umUl.recBufLst, recBuf);
}
curSn++;
+ }while ( curSn < RLC_RCV_BUF_BIN_SIZE);
+
+ RLC_FREE(gCb,rbCb->m.umUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ rbCb->m.umUl.recBufLst = NULLP;
+
+ if(rbCb->m.umUl.assembleSdu != NULLP)
+ {
+ ODU_PUT_MSG_BUF(rbCb->m.umUl.assembleSdu);
}
- RLC_FREE(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(RlcUmRecBuf*));
- rbCb->m.umUl.recBuf = NULLP;
return;
-}
-
+} /* rlcAmmFreeUlRbCb */
/********************************************************************30**
End of file
datReq.totMacGrant = grantPerLch[staIndTb->lchStaInd[count].lcId];
#endif
rlcUtlGetCurrTime(&datReq.boRep.oldestSduArrTime);
- if ( CM_LTE_MODE_UM == rbCb->mode )
+ if ( RLC_MODE_UM == rbCb->mode )
{
rlcUmmProcessSdus(gCb,rbCb,&datReq);
}
- else if ( CM_LTE_MODE_AM == rbCb->mode )
+ else if ( RLC_MODE_AM == rbCb->mode )
{
rlcAmmProcessSdus(gCb,rbCb,&datReq,staInd->fillCtrlPdu);
}
#ifdef L2_OPTMZ
/* Set if Bearer is UM */
- if ( CM_LTE_MODE_UM == rbCb->mode )
+ if ( RLC_MODE_UM == rbCb->mode )
{
datReqTb->lchData[count].freeBuff = TRUE;
}
#ifndef TENB_ACC
if ((rbCb->lastRprtdBoToMac > (uint32_t)8000) && (rbCb->boUnRprtdCnt < (uint32_t)5)
- && (!staPduPrsnt) && ((CM_LTE_MODE_AM == rbCb->mode ) && (RLC_AMDL.nxtRetx == NULLP)))
+ && (!staPduPrsnt) && ((RLC_MODE_AM == rbCb->mode ) && (RLC_AMDL.nxtRetx == NULLP)))
{
rbCb->boUnRprtdCnt++;
return ROK;
rbCb->reestInProgress = TRUE;
- if(rbCb->mode == CM_LTE_MODE_AM )
+ if(rbCb->mode == RLC_MODE_AM )
{
rbCb->m.amDl.estHdrSz = 0;
- if(rlcChkTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR))
+ if(rlcChkTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb, (PTR)rbCb, RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)rbCb, EVENT_RLC_AMDL_POLL_RETX_TMR);
}
}
else
else
{
/* For SRB we just need to stop the poll re-transmit timer */
- if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR))
+ if(rlcChkTmr(gCb, (PTR)ueCb->srbCb[rbIdx], EVENT_RLC_AMDL_POLL_RETX_TMR))
{
- rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], RLC_EVT_AMDL_POLL_RETX_TMR);
+ rlcStopTmr(gCb, (PTR)ueCb->srbCb[rbIdx], EVENT_RLC_AMDL_POLL_RETX_TMR);
}
}
}
static Void dumpRLCDlRbInformation(RlcDlRbCb* dlRbCb)
{
- if(dlRbCb->mode == CM_LTE_MODE_UM)
+ if(dlRbCb->mode == RLC_MODE_UM)
{
RLOG_ARG3(L_DEBUG,DBG_RBID,dlRbCb->rlcId.rbId,
"UM Downlink UEID:%d CELLID:%d Q size = %d",
dlRbCb->rlcId.cellId,
(int)dlRbCb->m.umDl.sduQ.count);
}
- else if(dlRbCb->mode == CM_LTE_MODE_AM)
+ else if(dlRbCb->mode == RLC_MODE_AM)
{
uint32_t j, numTxPdus=0;
for(j = 0; j <= (RLC_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
File: kw_utl_ul.c
**********************************************************************/
-static const char* RLOG_MODULE_NAME="UTL";
-static int RLOG_MODULE_ID=2048;
-static int RLOG_FILE_ID=210;
/** @file kw_utl_ul.c
@brief RLC Utility Module
#ifdef SS_RBUF
SMrkUlPkt(pduInfo->mBuf[0]);
#endif
- if ( rbCb->mode == CM_LTE_MODE_UM )
+ if ( rbCb->mode == RLC_MODE_UM )
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
rlcUmmProcessPdus(gCb,rbCb,pduInfo);
#endif
}
- else if (rbCb->mode == CM_LTE_MODE_AM )
+ else if (rbCb->mode == RLC_MODE_AM )
{
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
KwuDatIndInfo *datIndInfo; /* Data Indication Information */
KwuDatIndInfo datIndInfoTmp;
#endif
- RlcUlRrcMsgInfo *ulRrcMsgInfo;
+ RlcUlRrcMsgInfo *ulRrcMsgInfo;
+ RlcUlUserDatInfo *ulUserDatInfo;
uint16_t msgLen, copyLen;
Pst pst;
/* Creating static memory for KwuDatIndInfo. #else will be
* removed once the testing is done on all platforms */
datIndInfo = &datIndInfoTmp;
-
-#if (ERRCLASS & ERRCLS_ADD_RES )
- if ( datIndInfo == NULLP )
+ if (datIndInfo == NULLP)
{
- DU_LOG("\nRLC : rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed UEID:%d \
CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
ODU_PUT_MSG_BUF(sdu);
return RFAILED;
}
-#endif /* ERRCLASS & ERRCLS_ADD_RES */
RLC_MEM_CPY(&(datIndInfo->rlcId),&(rbCb->rlcId),sizeof(CmLteRlcId));
/* Set the "isOutofSeq" flag for each packet
datIndInfo->isOutOfSeq = rbCb->m.amUl.isOutOfSeq;
#endif /* KW_PDCP */
- /* Filling UL RRC Message Info */
- RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
- ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
- if (ulRrcMsgInfo)
+ if(rbCb->rlcId.rbType == RB_TYPE_SRB)
{
- ulRrcMsgInfo->cellId = rbCb->rlcId.cellId;
- ulRrcMsgInfo->ueIdx = rbCb->rlcId.ueId;
- ulRrcMsgInfo->lcId = rbCb->lch.lChId;
- RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
- ulRrcMsgInfo->rrcMsg, msgLen);
- if (ulRrcMsgInfo->rrcMsg)
- {
- ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
- ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulRrcMsgInfo->rrcMsg, (MsgLen *)©Len);
- ulRrcMsgInfo->msgLen = msgLen;
-
- /* Sending UL RRC Message transfeer to DU APP */
- memset(&pst, 0, sizeof(Pst));
- FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_RRC_MSG_TRANS_TO_DU);
- rlcSendUlRrcMsgToDu(&pst, ulRrcMsgInfo);
- }
- else
- {
- DU_LOG("\nRLC : rlcUtlSendUlDataToDu: Memory allocation failed for rrcMsg");
- RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
- return RFAILED;
- }
- }
- else
- {
- DU_LOG("\nRLC : rlcUtlSendUlDataToDu: Memory allocation failed for ulRrcMsgInfo");
- return RFAILED;
- }
-
+ /* Filling UL RRC Message Info if UL msg is not received on SRBs*/
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
+ ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
+ if (ulRrcMsgInfo)
+ {
+ ulRrcMsgInfo->cellId = rbCb->rlcId.cellId;
+ ulRrcMsgInfo->ueIdx = rbCb->rlcId.ueId;
+ ulRrcMsgInfo->lcId = rbCb->lch.lChId;
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL,
+ ulRrcMsgInfo->rrcMsg, msgLen);
+ if (ulRrcMsgInfo->rrcMsg)
+ {
+ ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
+ ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulRrcMsgInfo->rrcMsg, (MsgLen *)©Len);
+ ulRrcMsgInfo->msgLen = msgLen;
+
+ /* Sending UL RRC Message transfeer to DU APP */
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_RRC_MSG_TRANS_TO_DU);
+ rlcSendUlRrcMsgToDu(&pst, ulRrcMsgInfo);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for rrcMsg");
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulRrcMsgInfo, sizeof(RlcUlRrcMsgInfo));
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulRrcMsgInfo");
+ return RFAILED;
+ }
+ }
+ else if(rbCb->rlcId.rbType == RB_TYPE_DRB)
+ {
+ /* Filling UL User Data Info if UL msg is received on a DRB */
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo, sizeof(RlcUlUserDatInfo));
+ if (ulUserDatInfo)
+ {
+ ulUserDatInfo->cellId = rbCb->rlcId.cellId;
+ ulUserDatInfo->ueIdx = rbCb->rlcId.ueId;
+ ulUserDatInfo->rbId = rbCb->rlcId.rbId;
+ RLC_ALLOC_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo->userData, msgLen);
+ if (ulUserDatInfo->userData)
+ {
+ ODU_GET_MSG_LEN(sdu, (MsgLen *)&msgLen);
+ ODU_COPY_MSG_TO_FIX_BUF(sdu, 0, msgLen, ulUserDatInfo->userData, (MsgLen *)©Len);
+ ulUserDatInfo->msgLen = msgLen;
+
+ /* Sending UL RRC Message transfeer to DU APP */
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_RLC_TO_DUAPP(pst, RLC_UL_INST, EVENT_UL_USER_DATA_TRANS_TO_DU);
+ rlcSendUlUserDataToDu(&pst, ulUserDatInfo);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for user data");
+ RLC_FREE_SHRABL_BUF(RLC_MEM_REGION_UL, RLC_POOL, ulUserDatInfo, sizeof(RlcUlUserDatInfo));
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC_UL: rlcUtlSendUlDataToDu: Memory allocation failed for ulUserDatInfo");
+ return RFAILED;
+ }
+ }
return ROK;
} /* rlcUtlSendUlDataToDu */
static Void dumpRLCUlRbInformation(RlcUlRbCb* ulRbCb)
{
- if(ulRbCb->mode == CM_LTE_MODE_UM)
+ if(ulRbCb->mode == RLC_MODE_UM)
{
uint32_t i;
uint32_t pdusInReceptionBuffer = 0;
- uint32_t windSz = ulRbCb->m.umUl.umWinSz << 1;
+ uint32_t totalSegs = 0;
- for(i = 0; i< windSz; i++)
+ for(i = 0; i< RLC_RCV_BUF_BIN_SIZE; i++)
{
- if(ulRbCb->m.umUl.recBuf[i] != NULLP)
+ RlcUmRecBuf *recBuf = rlcUtlGetUmRecBuf(ulRbCb->m.umUl.recBufLst, i);
+ if(recBuf != NULLP)
{
- pdusInReceptionBuffer++;
+ pdusInReceptionBuffer++;
+ totalSegs += (recBuf->segLst.count);
}
}
- RLOG_ARG3(L_DEBUG,DBG_RBID,ulRbCb->rlcId.rbId,
- "UM UL UEID:%d CELLID:%d Reception Buffer size = %d",
- (int)ulRbCb->rlcId.ueId,
- (int)ulRbCb->rlcId.cellId,
- (int)pdusInReceptionBuffer);
+ DU_LOG("\nDEBUG --> RLC_UL: UM UL UEID:%d CELLID:%d Reception Buffer size = %d Total segs = %d",
+ ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
}
- else if(ulRbCb->mode == CM_LTE_MODE_AM)
+ else if(ulRbCb->mode == RLC_MODE_AM)
{
uint32_t i;
uint32_t pdusInReceptionBuffer = 0;
}
}
- RLOG_ARG4(L_DEBUG,DBG_RBID,ulRbCb->rlcId.rbId,
- "AM UL UEID:%d CELLID:%d Reception Buf size = %d"
- "total segs = %d",
- (int)ulRbCb->rlcId.ueId,
- (int)ulRbCb->rlcId.cellId,
- (int)pdusInReceptionBuffer,
- (int)totalSegs);
+ DU_LOG("\nDEBUG --> RLC_UL: AM UL UEID:%d CELLID:%d Reception Buf size = %d total segs = %d",
+ ulRbCb->rlcId.ueId, ulRbCb->rlcId.cellId, pdusInReceptionBuffer, totalSegs);
}
}
measCb->val.nonIpThMeas.measData[measCb->val.nonIpThMeas.qci[qciIdx]].actUe.sampOc++;
}
measEvtCb->val.nonIpThMeas.measCb.numSamples--;
- rlcStartTmr(gCb, (PTR)measEvtCb, RLC_EVT_L2_TMR);
+ rlcStartTmr(gCb, (PTR)measEvtCb, EVENT_RLC_L2_TMR);
return (ROK);
}
#endif
return;
} /* rlcUtlDelRecBuf */
-#ifdef NR_RLC_UL
/**
*
* @brief Store the UL buffer in hashList
*
- *
* @b Description
*
- * Use the SN % binSize as key and store the received UL buffer
+ * Use the SN % binSize as key and store the received UL buffer
* @param[in] recBufLst List CP array
* @param[in] recBuf received buffer
* @param[in] sn sn of the received buffer
*
- *
* @return Void
*/
void rlcUtlStoreUmRecBuf(CmLListCp *recBufLst, RlcUmRecBuf *recBuf, RlcSn sn)
return;
} /* rlcUtlStoreUmRecBuf */
+
/**
*
* @brief Retrieve the UL buffer from the list
*
- *
* @Description
*
* Use the SN % binSize as key and retrieve the UL buffer
* @param[in] recBufLst List CP array
* @param[in] sn sn of the received buffer
*
- *
* @return Void
*/
RlcUmRecBuf* rlcUtlGetUmRecBuf(CmLListCp *recBufLst, RlcSn sn)
}
return NULLP;
} /* rlcUtlGetUmRecBuf */
-#endif
+/**
+ *
+ * @brief Delete the UM Mode UL buffer from the list
+ *
+ *
+ * @details
+ * Use the SN % binSize as key and retrieve the UL buffer
+ *
+ * @param[in] *recBufLst List CP array
+ * @param[in] *recBuf Received buffer
+ *
+ * @return Void
+ */
+void rlcUtlDelUmRecBuf(RlcCb *gCb, CmLListCp *recBufLst, RlcUmRecBuf *recBuf)
+{
+ uint32_t hashKey;
+ CmLListCp *recBufLstCp;
+
+ hashKey = (recBuf->sn % RLC_RCV_BUF_BIN_SIZE );
+ recBufLstCp = &recBufLst[hashKey];
+ cmLListDelFrm(recBufLstCp, &recBuf->lnk);
+ RLC_FREE(gCb, recBuf, sizeof(RlcUmRecBuf));
+
+ return;
+} /* rlcUtlDelUmRecBuf */
/********************************************************************30**
End of file
+++ /dev/null
-/*******************************************************************************
-################################################################################
-# Copyright (c) [2017-2019] [Radisys] #
-# #
-# Licensed under the Apache License, Version 2.0 (the "License"); #
-# you may not use this file except in compliance with the License. #
-# You may obtain a copy of the License at #
-# #
-# http://www.apache.org/licenses/LICENSE-2.0 #
-# #
-# Unless required by applicable law or agreed to in writing, software #
-# distributed under the License is distributed on an "AS IS" BASIS, #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
-# See the License for the specific language governing permissions and #
-# limitations under the License. #
-################################################################################
-*******************************************************************************/
-
-#ifdef EGTP_TEST
-#include "common_def.h"
-
-#define DU_IP_V4_ADDR "192.168.130.81"
-#define CU_IP_V4_ADDR "192.168.130.82"
-
-uint8_t rlcDatSn = 0;
-
-void macStubBuildUlData(Buffer *mBuf)
-{
- char data[30] = "This is EGTP data from DU";
- int datSize = 30;
-
- ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf);
-
- /* filling IPv4 header */
- CmIpv4Hdr ipv4Hdr;
- MsgLen mLen;
- uint32_t ipv4_du, ipv4_cu;
-
- cmInetAddr((S8*)DU_IP_V4_ADDR, &ipv4_du);
- cmInetAddr((S8*)CU_IP_V4_ADDR, &ipv4_cu);
-
- mLen = 0;
- SFndLenMsg(mBuf, &mLen);
-
- memset(&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
- ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
- ipv4Hdr.hdrVer = 0x45;
- ipv4Hdr.proto = 1;
- ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(ipv4_du);
- ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(ipv4_cu);
-
- /* Packing IPv4 header into buffer */
- S16 ret, cnt, idx;
- Data revPkArray[CM_IPV4_HDRLEN];
- Data pkArray[CM_IPV4_HDRLEN];
-
- /* initialize locals */
- cnt = 0;
- memset(revPkArray, 0, CM_IPV4_HDRLEN);
- memset(pkArray, 0, CM_IPV4_HDRLEN);
-
- /* Pack Header Version */
- pkArray[cnt++] = ipv4Hdr.hdrVer;
-
- /* Pack TOS */
- pkArray[cnt++] = ipv4Hdr.tos;
-
- pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length);
- pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length);
-
- /* Pack Id */
- pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id);
- pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id);
-
- /* Pack Offset */
- pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off);
- pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off);
-
- /* Pack TTL */
- pkArray[cnt++] = ipv4Hdr.ttl;
-
- /* Pack Protocol */
- pkArray[cnt++] = ipv4Hdr.proto;
-
- /* Pack Checksum */
- pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum);
- pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum);
-
- /* Pack Source Address */
- pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr));
- pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr));
-
- /* Pack Destination Address */
- pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr));
- pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr));
-
- for (idx = 0; idx < CM_IPV4_HDRLEN; idx++)
- revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
-
- /* this function automatically reverses revPkArray */
- ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
-
- ODU_ADD_PRE_MSG_MULT((Data *)&rlcDatSn, sizeof(uint8_t), mBuf);
-
- if(rlcDatSn++ >15 )
- rlcDatSn = 0;
-
-} /* macStubBuildUlData */
-
-#endif /* EGTP_TEST */
-
-/**********************************************************************
- End of file
-**********************************************************************/
+++ /dev/null
-/*******************************************************************************
-################################################################################
-# Copyright (c) [2017-2019] [Radisys] #
-# #
-# Licensed under the Apache License, Version 2.0 (the "License"); #
-# you may not use this file except in compliance with the License. #
-# You may obtain a copy of the License at #
-# #
-# http://www.apache.org/licenses/LICENSE-2.0 #
-# #
-# Unless required by applicable law or agreed to in writing, software #
-# distributed under the License is distributed on an "AS IS" BASIS, #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
-# See the License for the specific language governing permissions and #
-# limitations under the License. #
-################################################################################
-*******************************************************************************/
-
-#ifdef EGTP_TEST
-
-#ifndef __MAC_STUB_H__
-#define __MAC_STUB_H__
-
-#include "du_log.h"
-#include "rgu.h"
-#include "kw.h"
-
-#include "rgu.x"
-
-
-#define DU_IP_V4_ADDR "192.168.130.81"
-#define CU_IP_V4_ADDR "192.168.130.82"
-
-uint8_t macStubBOStatus(Pst *pst, SpId spId, RlcMacBOStatus *boSta);
-uint8_t macStubSendDlData(Pst *post, SpId spId, RlcMacData *dlData);
-void macStubBuildUlData(Buffer *mBuf);
-
-#endif /* __MAC_STUB_H__ */
-#endif /* EGTP_TEST */
-
-/**********************************************************************
- End of file
-**********************************************************************/
switch(rlcMode)
{
case RLC_AM:
- *entMode = CM_LTE_MODE_AM;
+ *entMode = RLC_MODE_AM;
*direction = RLC_CFG_DIR_BOTH;
break;
case RLC_UM_BI_DIRECTIONAL:
- *entMode = CM_LTE_MODE_UM;
+ *entMode = RLC_MODE_UM;
*direction = RLC_CFG_DIR_BOTH;
break;
case RLC_UM_UNI_DIRECTIONAL_UL:
- *entMode = CM_LTE_MODE_UM;
+ *entMode = RLC_MODE_UM;
*direction = RLC_CFG_DIR_UL;
break;
case RLC_UM_UNI_DIRECTIONAL_DL:
- *entMode = CM_LTE_MODE_UM;
+ *entMode = RLC_MODE_UM;
*direction = RLC_CFG_DIR_DL;
break;
default :
switch(rlcUeCfg->entMode)
{
- case CM_LTE_MODE_AM:
+ case RLC_MODE_AM:
{
/* DL AM INFO */
rlcUeCfg->m.amInfo.dl.snLen = duRlcUeCfg->u.amCfg->dlAmCfg.snLenDl;
rlcUeCfg->lCh[lChRbIdx].type = duRlcUeCfg->lcType;
rlcUeCfg->m.amInfo.ul.snLen = duRlcUeCfg->u.amCfg->ulAmCfg.snLenUl;
rlcUeCfg->m.amInfo.ul.staProhTmr = duRlcUeCfg->u.amCfg->ulAmCfg.statProhTmr;
- rlcUeCfg->m.amInfo.ul.reOrdTmr = duRlcUeCfg->u.amCfg->ulAmCfg.reAssemTmr;
+ rlcUeCfg->m.amInfo.ul.reOrdTmr = duRlcUeCfg->u.amCfg->ulAmCfg.reAssemTmr * RLC_REASSEMBLY_TMR_BASE;
break;
}
- case CM_LTE_MODE_UM:
+ case RLC_MODE_UM:
{
/* UL UM CONFIG */
- rlcUeCfg->m.umInfo.ul.snLen = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm;
- rlcUeCfg->m.umInfo.ul.reOrdTmr = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr;
+ rlcUeCfg->m.umInfo.ul.snLen = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.snLenUlUm;
+ rlcUeCfg->m.umInfo.ul.reAsmblTmr = duRlcUeCfg->u.umBiDirCfg->ulUmCfg.reAssemTmr * RLC_REASSEMBLY_TMR_BASE;
/* DL UM CONFIG */
rlcUeCfg->m.umInfo.dl.snLen = duRlcUeCfg->u.umBiDirCfg->dlUmCfg.snLenDlUm;
uint8_t RlcProcUlData(Pst *pst, RlcData *ulData)
{
uint8_t ret = ROK;
- uint8_t idx, pduIdx;
- uint8_t lcId; /* Logical Channel */
- uint8_t numDLch = 0; /* Number of dedicated logical channel */
+ uint8_t idx, pduIdx;
+ uint8_t lcId; /* Logical Channel */
+ uint8_t numDLch = 0; /* Number of dedicated logical channel */
bool dLchPduPres; /* PDU received on dedicated logical channel */
- RguLchDatInd dLchData[MAX_NUM_LC]; /* PDU info on dedicated logical channel */
- RguDDatIndInfo *dLchUlDat; /* UL data on dedicated logical channel */
- RguCDatIndInfo *cLchUlDat; /* UL data on common logical channel */
+ RguLchDatInd dLchData[MAX_NUM_LC]; /* PDU info on dedicated logical channel */
+ RguDDatIndInfo *dLchUlDat; /* UL data on dedicated logical channel */
+ RguCDatIndInfo *cLchUlDat; /* UL data on common logical channel */
/* Initializing dedicated logical channel Database */
DU_LOG("\nRLC: Received UL Data request from MAC");
if(dLchPduPres)
{
dLchUlDat->cellId = ulData->cellId;
- dLchUlDat->rnti = ulData->rnti;
+ GET_UE_IDX(ulData->rnti, dLchUlDat->rnti);
for(idx = 0; idx < MAX_NUM_LC; idx++)
{
packRlcDlRrcMsgRspToDu /* 2 - Light weight loosely coupled */
};
+/* Function pointer array for UL RRC Msg Transfer */
+RlcUlUserDataToDuFunc rlcSendUlUserDataToDuOpts[] =
+{
+ packRlcUlUserDataToDu, /* 0 - Loosely coupled */
+ DuProcRlcUlUserDataTrans, /* 1 - Tightly coupled */
+ packRlcUlUserDataToDu /* 2 - Light weight loosely coupled */
+};
+
/*******************************************************************
*
* @brief Sends UL RRC Message Info to DU APP
return (*rlcSendDlRrcMsgRspToDuOpts[pst->selector])(pst, dlRrcMsg);
}
+/*******************************************************************
+ *
+ * @brief Sends UL User data Info to DU APP
+ *
+ * @details
+ *
+ * Function : rlcSendUlUserDataToDu
+ *
+ * Functionality: Sends UL User Data Info to DU APP
+ *
+ * @params[in] Pst structure
+ * UL user data Info
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t rlcSendUlUserDataToDu(Pst *pst, RlcUlUserDatInfo *ulUserData)
+{
+ return (*rlcSendUlUserDataToDuOpts[pst->selector])(pst, ulUserData);
+}
+
/**********************************************************************
End of file
**********************************************************************/
uint8_t rlcSendUlRrcMsgToDu(Pst *pst, RlcUlRrcMsgInfo *ulRrcMsgInfo);
uint8_t rlcSendRrcDeliveryReportToDu(Pst *pst, RrcDeliveryReport *rrcDelivery);
uint8_t rlcSendDlRrcMsgRspToDu(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsgRsp);
+uint8_t rlcSendUlUserDataToDu(Pst *pst, RlcUlUserDatInfo *ulUserData);
+
/**********************************************************************
End of file
**********************************************************************/
#define RLC_DL_INST 1
#define PDCP_SN 1
+#define RLC_REASSEMBLY_TMR_BASE 5 /* Used to calculate timer value from enum values */
/* Fill Pst structure for sending msg from RLC to DUAPP */
#define FILL_PST_RLC_TO_DUAPP(_pst, _srcInst, _event) \
}
case CKW_CFG_DIR_UL:
{
- CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reOrdTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reAsmblTmr, mBuf);
CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.snLen, mBuf);
break;
}
case CKW_CFG_DIR_BOTH:
{
CMCHKPK(oduUnpackUInt8, param->m.umInfo.dl.snLen, mBuf);
- CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reOrdTmr, mBuf);
+ CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.reAsmblTmr, mBuf);
CMCHKPK(oduUnpackUInt8, param->m.umInfo.ul.snLen, mBuf);
break;
}
case CKW_CFG_DIR_UL:
{
CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.snLen), mBuf);
- CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reAsmblTmr), mBuf);
break;
}
/* Patch ckw_c_001.main_3 */
case CKW_CFG_DIR_BOTH:
{
CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.snLen), mBuf);
- CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
+ CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.ul.reAsmblTmr), mBuf);
CMCHKUNPK(oduPackUInt8, &(param->m.umInfo.dl.snLen), mBuf);
break;
}
{
struct _umDl
{
- uint8_t snLen; /*!< Sequence Number length in bits. Allowed values are 6 and 12*/
+ uint8_t snLen; /*!< Sequence Number length in bits. Allowed values are 6 and 12*/
}dl; /*!< Downlink */
struct _umUl
{
- uint8_t snLen; /*!< Sequence Number length in bits.*/
+ uint8_t snLen; /*!< Sequence Number length in bits.*/
/*!< Allowed values are 6 and 12*/
- uint8_t reOrdTmr; /*!< T_reordering Timer in msec */
+ uint8_t reAsmblTmr; /*!< T_reassembly Timer in msec */
}ul; /*!< Uplink */
}RlcUmInfo;
++tqCp->nxtEnt;
expire = tqCp->nxtEnt;
- tqCp->tmrLen = 1;
entry = (uint32_t) (expire % (uint32_t)(tqCp->tmrLen));
tqCp->tmp = (tqEnt = &tq[entry])->first;
}
return RFAILED;
}
+
+/*******************************************************************
+ *
+ * @brief Pack and send UL user data from RLC to DU APP
+ *
+ * @details
+ *
+ * Function : packRlcUlUserDataToDu
+ *
+ * Functionality:
+ * Pack and send UL User Data from RLC to DU APP
+ *
+ * @params[in] Post structure
+ * UL user data
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t packRlcUlUserDataToDu(Pst *pst, RlcUlUserDatInfo *ulUserData)
+{
+ Buffer *mBuf = NULLP;
+
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ DU_LOG("\nERROR --> RLC UL: Memory allocation failed at packRlcUlUserDataToDu");
+ return RFAILED;
+ }
+ /* pack the address of the structure */
+ CMCHKPK(oduPackPointer,(PTR)ulUserData, mBuf);
+ return ODU_POST_TASK(pst,mBuf);
+ }
+ else
+ {
+ DU_LOG("\nERROR --> RLC UL: Only LWLC supported for packRlcUlUserDataToDu");
+ }
+ return RFAILED;
+}
+
+/*******************************************************************
+ *
+ * @brief Unpack UL user data received at DU APP from RLC
+ *
+ * @details
+ *
+ * Function : unpackRlcUlUserDataToDu
+ *
+ * Functionality:
+ * Unpack UL user data received at DU APP from RLC
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t unpackRlcUlUserDataToDu(RlcUlUserDataToDuFunc func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ RlcUlUserDatInfo *ulUserData;
+ /* unpack the address of the structure */
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&ulUserData, mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
+ return (*func)(pst, ulUserData);
+ }
+ else
+ {
+ /* Nothing to do for other selectors */
+ DU_LOG("\nERROR --> DU APP: Only LWLC supported for UL User data transfer ");
+ ODU_PUT_MSG_BUF(mBuf);
+ }
+
+ return RFAILED;
+}
+
/**********************************************************************
End of file
***********************************************************************/
#define EVENT_RLC_UE_RECONFIG_REQ 215
#define EVENT_RLC_UE_RECONFIG_RSP 216
#define EVENT_DL_RRC_MSG_RSP_TO_DU 217
+#define EVENT_DL_USER_DATA_TRANS_TO_DU 218
+#define EVENT_UL_USER_DATA_TRANS_TO_DU 219
#define RB_ID_SRB 0
#define RB_ID_DRB 1
uint8_t *rrcMsg; /* RRC Message (UL-DCCH Message) */
}RlcUlRrcMsgInfo;
+/* UL User Data from RLC to DU APP */
+typedef struct ulUserDatInfo
+{
+ uint16_t cellId; /* Cell Id */
+ uint16_t ueIdx; /* UE Index */
+ uint8_t rbId;
+ uint16_t msgLen; /* User data length (in bytes) */
+ uint8_t *userData; /* User data (UL-DTCH Message) */
+}RlcUlUserDatInfo;
+
/* DL RRC Message from DU APP to RLC */
typedef struct dlRrcMsgInfo
{
Pst *pst,
RlcDlRrcMsgRsp *dlRrcMsgRsp));
+/* UL User data from RLC to DU APP */
+typedef uint8_t (*RlcUlUserDataToDuFunc) ARGS((
+ Pst *pst,
+ RlcUlUserDatInfo *ulUserData));
+
/* Pack/Unpack function declarations */
uint8_t packDuRlcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg);
uint8_t unpackRlcUeCreateReq(DuRlcUeCreateReq func, Pst *pst, Buffer *mBuf);
uint8_t unpackRlcUeReconfigReq(DuRlcUeReconfigReq func, Pst *pst, Buffer *mBuf);
uint8_t packRlcDlRrcMsgRspToDu(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsgRsp);
uint8_t unpackRlcDlRrcMsgRspToDu(RlcDlRrcMsgRspToDuFunc func, Pst *pst, Buffer *mBuf);
-
+uint8_t packRlcUlUserDataToDu(Pst *pst, RlcUlUserDatInfo *ulUserData);
+uint8_t unpackRlcUlUserDataToDu(RlcUlUserDataToDuFunc func, Pst *pst, Buffer *mBuf);
/* Event Handler function declarations */
uint8_t RlcProcUeCreateReq(Pst *pst, RlcUeCfg *ueCfg);
uint8_t DuProcRlcRrcDeliveryReport(Pst *pst, RrcDeliveryReport *rrcDeliveryReport);
uint8_t RlcProcUeReconfigReq(Pst *pst, RlcUeCfg *ueCfg);
uint8_t DuProcRlcDlRrcMsgRsp(Pst *pst, RlcDlRrcMsgRsp *dlRrcMsg);
+uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData);
#endif /* RLC_INF_H */
uint8_t duSendEgtpSrvOpenReq();
uint8_t duHdlEgtpSrvOpenComplete(CmStatus cfm);
uint8_t duSendEgtpTnlMgmtReq(uint8_t action, uint32_t lclTeid, uint32_t remTeid);
-uint8_t duSendEgtpTestData();
uint8_t duSendEgtpDatInd(Buffer *mBuf);
uint8_t duHdlSchCfgComplete(Pst *pst, RgMngmt *cfm);
uint8_t duBuildAndSendMacCellStart();
ret = unpackRlcDlRrcMsgRspToDu(DuProcRlcDlRrcMsgRsp, pst, mBuf);
break;
}
+ case EVENT_UL_USER_DATA_TRANS_TO_DU:
+ {
+ ret = unpackRlcUlUserDataToDu(DuProcRlcUlUserDataTrans, pst, mBuf);
+ break;
+ }
default:
{
DU_LOG("\nERROR --> DU_APP : Invalid event %d received at duActvTsk from ENTRLC", \
if(tnlEvtCfm.cfmStatus.status == LCM_PRIM_OK)
{
- DU_LOG("\nDEBUG --> DU_APP : Tunnel management confirm OK");
-#ifdef EGTP_TEST
- duSendEgtpTestData();
-#endif
+ DU_LOG("\nDEBUG --> DU_APP: Tunnel management confirm OK");
}
else
{
- DU_LOG("\nERROR --> DU_APP : Tunnel management failed");
+ DU_LOG("\nERROR --> DU_APP: Tunnel management failed");
ret = RFAILED;
}
}
-#ifdef EGTP_TEST
-/*******************************************************************
- *
- * @brief Simulate UL Data for intial test
- *
- * @details
- *
- * Function : duSendEgtpTestData
- *
- * Functionality:
- * Simulate UL data for initial test
- *
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-uint8_t duSendEgtpTestData()
-{
- char data[30] = "This is EGTP data from DU";
- int datSize = 30;
-
- Buffer *mBuf;
-
- if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
- {
- if(ODU_ADD_POST_MSG_MULT((Data *)data, datSize, mBuf) != ROK)
- {
- DU_LOG("\nERROR --> DU_APP : ODU_ADD_POST_MSG_MULT failed");
- ODU_PUT_MSG_BUF(mBuf);
- return RFAILED;
- }
- }
- else
- {
- DU_LOG("\nERROR --> DU_APP : Failed to allocate memory");
- return RFAILED;
- }
-
- /* filling IPv4 header */
- CmIpv4Hdr ipv4Hdr;
- MsgLen mLen;
-
- mLen = 0;
- ODU_GET_MSG_LEN(mBuf, &mLen);
-
- memset(&ipv4Hdr, 0, sizeof(CmIpv4Hdr));
- ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
- ipv4Hdr.hdrVer = 0x45;
- ipv4Hdr.proto = 1;
- ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(duCfgParam.egtpParams.localIp.ipV4Addr);
- ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(duCfgParam.egtpParams.destIp.ipV4Addr);
-
- /* Packing IPv4 header into buffer */
- uint8_t ret, cnt, idx;
- Data revPkArray[CM_IPV4_HDRLEN];
- Data pkArray[CM_IPV4_HDRLEN];
-
- /* initialize locals */
- cnt = 0;
- memset(revPkArray, 0, CM_IPV4_HDRLEN);
- memset(pkArray, 0, CM_IPV4_HDRLEN);
-
- /* Pack Header Version */
- pkArray[cnt++] = ipv4Hdr.hdrVer;
-
- /* Pack TOS */
- pkArray[cnt++] = ipv4Hdr.tos;
-
- pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.length);
- pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.length);
-
- /* Pack Id */
- pkArray[cnt++] = (Data) GetHiByte(ipv4Hdr.id);
- pkArray[cnt++] = (Data) GetLoByte(ipv4Hdr.id);
-
- /* Pack Offset */
- pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.off);
- pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.off);
-
- /* Pack TTL */
- pkArray[cnt++] = ipv4Hdr.ttl;
-
- /* Pack Protocol */
- pkArray[cnt++] = ipv4Hdr.proto;
-
- /* Pack Checksum */
- pkArray[cnt++] = (Data)GetHiByte(ipv4Hdr.chkSum);
- pkArray[cnt++] = (Data)GetLoByte(ipv4Hdr.chkSum);
-
- /* Pack Source Address */
- pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.srcAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.srcAddr));
- pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.srcAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.srcAddr));
-
- /* Pack Destination Address */
- pkArray[cnt++] = (Data)GetHiByte(GetHiWord(ipv4Hdr.destAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetHiWord(ipv4Hdr.destAddr));
- pkArray[cnt++] = (Data)GetHiByte(GetLoWord(ipv4Hdr.destAddr));
- pkArray[cnt++] = (Data)GetLoByte(GetLoWord(ipv4Hdr.destAddr));
-
- for (idx = 0; idx < CM_IPV4_HDRLEN; idx++)
- revPkArray[idx] = pkArray[CM_IPV4_HDRLEN - idx -1];
-
- /* this function automatically reverses revPkArray */
- ret = ODU_ADD_PRE_MSG_MULT(revPkArray, (MsgLen)cnt, mBuf);
-
- duSendEgtpDatInd(mBuf);
-
- return ROK;
-}
-#endif /* EGTP_TEST */
-
-
/**************************************************************************
* @brief Function to send configs to SCH
*
return ret;
}
+/*******************************************************************
+ *
+ * @brief Process UL user data from RLC
+ *
+ * @details
+ *
+ * Function : DuProcRlcUlUserDataTrans
+ *
+ * Functionality: Process UL user data from RLC
+ *
+ * @params[in] Post structure
+ * UL user data
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t DuProcRlcUlUserDataTrans(Pst *pst, RlcUlUserDatInfo *ulUserData)
+{
+ uint8_t rbIdx;
+ DuCellCb *cellCb;
+ DuUeCb ueCb;
+ EgtpMsg egtpMsg;
+ Buffer *mBuf;
+
+ if(duGetCellCb(ulUserData->cellId, &cellCb) != ROK)
+ return RFAILED;
+
+ ueCb = cellCb->ueCb[ulUserData->ueIdx -1];
+
+ DU_LOG("\nDEBUG --> DU APP : Received UL user data");
+
+ /* Fill EGTP header */
+ egtpMsg.msgHdr.msgType = EGTPU_MSG_GPDU;
+ egtpMsg.msgHdr.nPdu.pres = FALSE;
+ egtpMsg.msgHdr.seqNum.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.udpPort.pres = FALSE;
+ egtpMsg.msgHdr.extHdr.pdcpNmb.pres = FALSE;
+
+ /* Fetch EGTP tunnel info */
+ /* TODO : keep the "#if 0" code block and test once DL User data changes are submitted */
+#if 0
+ for(rbIdx = 0; rbIdx < MAX_NUM_DRB; rbIdx++)
+ {
+ if(ueCb.ulTnlCfg[rbIx]->drbId == ulUserData->rbId)
+ {
+ egtpMsg.msgHdr.teId = ueCb.ulTnlCfg[rbIx]->tnlCfg.teId;
+ }
+ }
+#else
+ egtpMsg.msgHdr.teId = 1;
+#endif
+
+ if (ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) != ROK)
+ {
+ DU_LOG("\nERROR --> DU APP : Failed to allocated buffer memory in DuProcRlcUlUserDataTrans");
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo));
+ return RFAILED;
+ }
+ oduCpyFixBufToMsg(ulUserData->userData, mBuf, ulUserData->msgLen);
+ ODU_PRINT_MSG(mBuf, 0, 0);
+ egtpMsg.msg = mBuf;
+ egtpHdlDatInd(egtpMsg);
+
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData->userData, ulUserData->msgLen);
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, ulUserData, sizeof(RlcUlUserDatInfo));
+ return ROK;
+}
/**********************************************************************
End of file
+++ /dev/null
-/*******************************************************************************
-################################################################################
-# Copyright (c) [2017-2019] [Radisys] #
-# #
-# Licensed under the Apache License, Version 2.0 (the "License"); #
-# you may not use this file except in compliance with the License. #
-# You may obtain a copy of the License at #
-# #
-# http://www.apache.org/licenses/LICENSE-2.0 #
-# #
-# Unless required by applicable law or agreed to in writing, software #
-# distributed under the License is distributed on an "AS IS" BASIS, #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
-# See the License for the specific language governing permissions and #
-# limitations under the License. #
-################################################################################
-*******************************************************************************/
-
-/* This file handles slot indication */
-
-#include "common_def.h"
-#include "lphy_stub.h"
-#include "du_log.h"
-
-uint16_t l1BuildAndSendSlotIndication();
-pthread_t thread = 0;
-
-void *GenerateTicks(void *arg)
-{
- int milisec = 1; /* 1ms */
- struct timespec req = {0};
-
- req.tv_sec = 0;
- req.tv_nsec = milisec * 1000000L;
-
- while(1)
- {
- nanosleep(&req, (struct timespec *)NULL);
-
- /* Send Slot indication indication to lower mac */
- l1BuildAndSendSlotIndication();
- }
- return((void *)NULLP);
-}
-
-void l1HdlSlotIndicaion(bool stopSlotInd)
-{
- int ret;
-
- if(!stopSlotInd)
- {
- ret = pthread_create(&thread, NULL, GenerateTicks, NULL);
- if(ret)
- {
- DU_LOG("\nPHY_STUB: Unable to create thread");
- }
- }
- else
- {
- ret = pthread_cancel(thread);
- if(ret)
- {
- DU_LOG("\nPHY_STUB: Unable to stop thread");
- }
- }
-}
-
-/**********************************************************************
- End of file
-**********************************************************************/
void fillMsgHeader ARGS((fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen));
#endif
void procPhyMessages(uint16_t msgType, uint32_t msgSize, void *msg);
+void l1StartConsoleHandler();
/**********************************************************************
End of file
#include "lphy_stub.h"
#include "lwr_mac_upr_inf.h"
#include "mac_utils.h"
-#include "l1.h"
+#include "phy_stub.h"
/*******************************************************************
*
if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
{
l1HdlSlotIndicaion(FALSE);
+ l1StartConsoleHandler();
MAC_FREE(msg, msgLen);
}
else
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Send UL user data to DU
+ *
+ * @details
+ *
+ * Function : l1SendUlUserData
+ *
+ * Functionality: Send UL user data to DU
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t l1SendUlUserData()
+{
+ uint8_t cnt = 0;
+ fapi_rx_data_indication_t *rxDataInd;
+ fapi_pdu_ind_info_t *pduInfo;
+ uint8_t *pdu = NULLP;
+ uint16_t byteIdx = 0;
+ uint32_t msgLen = 0;
+ uint8_t idx = 0;
+
+ MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ if(!rxDataInd)
+ {
+ printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
+ return RFAILED;
+ }
+ memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
+
+ msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
+ rxDataInd->sfn = 0;
+ rxDataInd->slot = 0;
+ rxDataInd->numPdus = 1;
+
+ /* TODO : Fill pduInfo using PUSCH PDU. Currently hardcoding */
+ pduInfo = &rxDataInd->pdus[idx];
+ pduInfo->handle = 100;
+ pduInfo->rnti = 100;
+ pduInfo->harqId = 1;
+ /* Since user data size = 50bytes and 2 bytes of MAC header and 3 byte of RLC header,
+ * setting tbsize = 56 from Table 5.1.3.2-1 spec 38.214 */
+ pduInfo->pdu_length = 56;
+ pduInfo->ul_cqi = 0;
+ pduInfo->timingAdvance = 0;
+ pduInfo->rssi = 0;
+
+ /* Filling pdu with random values for testing */
+ pduInfo->pduData = NULL;
+ MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
+ if(!pduInfo->pduData)
+ {
+ printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ return RFAILED;
+ }
+
+ /* Filling PDU */
+ pdu = (uint8_t *)pduInfo->pduData;
+ msgLen = 51;
+
+ /* For UL User data
+ MAC subheader format is R/F/LCId/L (2/3 bytes)
+ LCId is 4 for DRB1
+ L is length of PDU i.e 50 bytes
+ From 38.321 section 6.1.1
+ */
+ uint8_t ulMsg[] = {4, msgLen, 0, 69, 0, 0, 50, 0, 0, 0, 0, 0, 1, 0, 0, 192, 168, 130, 81, 192, 168, 130, 82, 84, 104,
+ 105, 115, 32, 105, 115, 32, 69, 71, 84, 80, 32, 100, 97, 116, 97, 32, 102, 114, 111, 109, 32, 68, 85, 0, 0, 0, 0, 0};
+ msgLen += 2; /* 2bytes of header */
+ memcpy(pdu, &ulMsg, msgLen);
+ byteIdx += msgLen; /* 2 bytes of header */
+
+
+ /* Filling MAC SDU for Padding bytes*/
+ if(byteIdx < pduInfo->pdu_length)
+ {
+ /* For Padding
+ MAC subheader format is R/R/LCId (1byte)
+ LCId is 63 for padding
+ From 38.321 section 6.1.1
+ */
+ pdu[byteIdx++] = 63;
+
+ for(; byteIdx < pduInfo->pdu_length; byteIdx++)
+ pdu[byteIdx] = 0;
+ }
+ msgLen += pduInfo->pdu_length;
+
+ fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
+
+ /* Send Message to peer */
+ while(cnt < 200)
+ {
+ DU_LOG("\nDEBUG --> PHY STUB : Sending UL User Data[%d] at sfn %d slot %d", cnt+1, sfnValue, slotValue);
+ /* Sending Rx data indication to MAC */
+ rxDataInd->sfn = sfnValue;
+ rxDataInd->slot = slotValue;
+ procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
+ cnt++;
+ }
+
+ if(pduInfo->pdu_length)
+ MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
+ MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Receives message from MAC
--- /dev/null
+/*******************************************************************************
+################################################################################
+# Copyright (c) [2017-2019] [Radisys] #
+# #
+# Licensed under the Apache License, Version 2.0 (the "License"); #
+# you may not use this file except in compliance with the License. #
+# You may obtain a copy of the License at #
+# #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+# #
+# Unless required by applicable law or agreed to in writing, software #
+# distributed under the License is distributed on an "AS IS" BASIS, #
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
+# See the License for the specific language governing permissions and #
+# limitations under the License. #
+################################################################################
+*******************************************************************************/
+
+/* This file handles slot indication */
+
+#include "common_def.h"
+#include "lphy_stub.h"
+#include "du_log.h"
+
+uint8_t l1SendUlUserData();
+uint16_t l1BuildAndSendSlotIndication();
+pthread_t thread = 0;
+
+/*******************************************************************
+ *
+ * @brief Generates slot indications
+ *
+ * @details
+ *
+ * Function : GenerateTicks
+ *
+ * Functionality: Generates slot indications
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void *GenerateTicks(void *arg)
+{
+ int milisec = 1; /* 1ms */
+ struct timespec req = {0};
+
+ req.tv_sec = 0;
+ req.tv_nsec = milisec * 1000000L;
+
+ while(1)
+ {
+ nanosleep(&req, (struct timespec *)NULL);
+
+ /* Send Slot indication indication to lower mac */
+ l1BuildAndSendSlotIndication();
+ }
+ return((void *)NULLP);
+}
+
+/*******************************************************************
+ *
+ * @brief Create/cancel thread for generating slot indication
+ *
+ * @details
+ *
+ * Function : l1HdlSlotIndicaion
+ *
+ * Functionality: Create/cancel thread for generating slot indication
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void l1HdlSlotIndicaion(bool stopSlotInd)
+{
+ int ret;
+
+ if(!stopSlotInd)
+ {
+ ret = pthread_create(&thread, NULL, GenerateTicks, NULL);
+ if(ret)
+ {
+ DU_LOG("\nERROR --> PHY_STUB: Unable to create thread");
+ }
+ }
+ else
+ {
+ ret = pthread_cancel(thread);
+ if(ret)
+ {
+ DU_LOG("\nERROR --> PHY_STUB: Unable to stop thread");
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Handles Console input
+ *
+ * @details
+ *
+ * Function : l1ConsoleHandler
+ *
+ * Functionality: Handles Console input
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void *l1ConsoleHandler(void *args)
+{
+ char ch;
+ while(true)
+ {
+ /* Send UL user data to DU when user enters 'd' on console */
+ if((ch = getchar()) == 'd')
+ {
+ /* Start Pumping data from PHY stub to DU */
+ DU_LOG("\nDEBUG --> PHY STUB: Sending UL User Data");
+ l1SendUlUserData();
+ }
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Creates thread for handling console input
+ *
+ * @details
+ *
+ * Function : l1StartConsoleHandler
+ *
+ * Functionality: Creates thread for handling console input
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void l1StartConsoleHandler()
+{
+ uint8_t retVal;
+ pthread_t conThrdId;
+ pthread_attr_t attr;
+
+ /* Start thread to receive console input */
+ pthread_attr_init(&attr);
+ pthread_attr_setstacksize(&attr, (size_t)NULLD);
+ pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ retVal = pthread_create(&conThrdId, &attr, l1ConsoleHandler, NULLP);
+ if(retVal != 0)
+ {
+ DU_LOG("\nERROR --> PHY STUB : Thread creation failed. Cause %d", retVal);
+ }
+ pthread_attr_destroy(&attr);
+
+}
+
+/**********************************************************************
+ End of file
+**********************************************************************/