//UDAY
#ifdef L2_OPTMZ
-extern U32 rlcAmmStaPduList[512];
- U32 rlcAmmStaPduListCnt = 0;
+extern uint32_t rlcAmmStaPduList[512];
+ uint32_t rlcAmmStaPduListCnt = 0;
#endif
**/
#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_DL)
-U32 rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt;
+uint32_t rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt;
/* local defines */
PRIVATE Void rlcGetNxtRetx ARGS ((RlcCb *gCb, RlcRetx **retx));
PRIVATE Void rlcConstructAmHdr ARGS ((RlcAmHdr *amHdr,
- U8 *hdr,
- U8 snLen,
- U16 *idx));
+ uint8_t *hdr,
+ uint8_t snLen,
+ uint16_t *idx));
PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcNackInfo *nackInfo,
CmLList *retxNode,
RlcNackInfo *nackSnInfo,
-U8 idx
+uint8_t idx
));
PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS(
}
}
- RETVOID;
+ return;
}
/**
{
amDl->txNextAck = sn;
- RETVOID;
+ return;
}
/**
rlcRemRetxPdu(gCb, rbCb, retx);
- RETVOID;
+ return;
}
/**
if (*retx == NULLP)
{
RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
gRlcStats.amRlcStats.numDLRetransPdus++;
- RETVOID;
+ return;
} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
/**
txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
lnk = txBuf->pduLst.first;
while(lnk)
rlcUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb);
}
- RETVOID;
+ return;
}
/**
(*retxNode) = retx->lstEnt.next;
}
- RETVOID;
+ return;
}
/* process the pdus/segments in the re-transmit buffer with
break;
}
} /* end of retxNode while loop*/
- RETVOID;
+ return;
}
/**
* @param[in]RlcNackInfo *nackSnInfo,
* @param[in]RlcRetx *retx;
* @param[in]RlcSn sn,
-* @param[in]U8 idx
+* @param[in]uint8_t idx
*
* @return Void
*
RlcNackInfo *nackInfo,
CmLList *retxNode,
RlcNackInfo *nackSnInfo,
-U8 idx
+uint8_t idx
)
#else
PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
(
RlcAmDl *amDl;
RlcNackInfo *nackInfo;
-CmLList *retxNode;
+CmLList *retxNode;
RlcNackInfo *nackSnInfo;
-U8 idx;
+uint8_t idx;
)
#endif
{
{
nackSnInfo->soStart = 0;
nackSnInfo->soEnd = 0;
- RETVOID;
+ return;
}
txBuf = rlcUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn);
if(txBuf != NULLP)
while(node)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(node->node);
- U16 pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1;
+ uint16_t pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1;
if((!idx) && (pduInfo->amHdr.so == nackInfo->soStart))
{
nackSnInfo->isSegment = TRUE;
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
rbCb->rlcId.cellId);
/* RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
/* Venki - stopping the poll retx timer */
RlcSn transWinStartSn = AMDL.txNextAck; /*used to track the SN from which
to start processing the transmission
buffer */
- U32 idx = 0;
+ uint32_t idx = 0;
/* if any NACKs then txNextAck should be equal to the first NACK_SN*/
txNextAck = pStaPdu->nackInfo[0].sn;
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
/* clear all the SNs < NACK_SN from re-transmission list */
}
else
{
- U8 idx1 = 0;
+ uint8_t idx1 = 0;
/* Update issegment, soStart, soEnd ,sn in nackSnInfo and handle
* nack sn*/
do
rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
}
- RETVOID;
+ return;
}
/**
return bo;
}
-U32 kwRxSdu;
+uint32_t kwRxSdu;
/**
* @brief Handler to queue the SDUs received from PDCP
* @param[in] datReq Ptr to the datReq sent from PDCP
*
* @return Void
- * -# RETVOID
+ * -# void
*/
void rlcAmmQSdu(RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *mBuf, KwuDatReqInfo *datReq)
{
rlcUtlAddReTxPduToBeFreedQueue(gCb, retx);
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
{
if (AMDL.maxReTxReached == TRUE)
{
- RETVOID;
+ return;
}
if(retx->pendingReTrans == FALSE)
rlcRemRetxPdu(gCb,rbCb, retx);
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
}
/**
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
rlcUtlRaiseDlCleanupEvent(gCb);
}
- RETVOID;
+ return;
}
/**
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
pduNode = txBuf->pduLst.first;
while(pduNode)
/* so that it is not processed again */
rlcUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb);
- RETVOID;
+ return;
}
/**
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
RlcUiKwuStaInd(&rlckwuSap->pst, rlckwuSap->suId, staInd);
#endif /* KW_PDCP */
- RETVOID;
+ return;
}
/**
else
{
*retx = NULLP;
- RETVOID;
+ return;
}
}while((*retx)->pendingReTrans == FALSE);
/* ccpu00135170 Removing KLOCK warning */
if(resetRb == NULLP)
{
- RETVOID;
+ return;
}
RLC_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb));
newAmDl->snLen = oldAmDl->snLen;
newAmDl->snModMask = oldAmDl->snModMask;
newAmDl->pollRetxTmrInt = oldAmDl->pollRetxTmrInt;
- rbCb->boUnRprtdCnt = (U32)0;
- rbCb->lastRprtdBoToMac = (U32)0;
+ rbCb->boUnRprtdCnt = (uint32_t)0;
+ rbCb->lastRprtdBoToMac = (uint32_t)0;
cmInitTimers(&(resetRb->m.amDl.pollRetxTmr), 1);
/* AGHOSH changes end */
"UeId [%d]: UeCb not found RBID;%d",
rlcId.ueId,
rlcId.rbId);
- RETVOID;
+ return;
}
if(rlcId.rbType == CM_LTE_SRB)
/* allocate the TX array again */
#ifndef LTE_TDD
- U32 hashIndex;
+ uint32_t hashIndex;
RLC_ALLOC(gCb,
resetRb->m.amDl.txBufLst,
(RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
rlcDlUtlResetReestInProgress(ueCb->drbCb[rlcId.rbId]);
}
- RETVOID;
+ return;
}
/**
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 sduId
+uint32_t sduId
)
#else
S16 rlcAmmDiscSdu(gCb, rbCb, sduId)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 sduId;
+uint32_t sduId;
#endif
{
return (RFAILED);
}
rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
- RETVOID;
+ return;
}
/* Get the last node in retxLst */
RLC_LLIST_LAST_RETX(amDl->retxLst, retx);
}
}
- RETVOID;
+ return;
}
/**
MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask);
}
- RETVOID;
+ return;
}
/**
MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask);
}
- RETVOID;
+ return;
}
hdr[0] = hdr[0] | ((amHdr->si & 0x3) << 4);
if(snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
- hdr[0] = hdr[0] | (U8)((amHdr->sn & 0xF00) >> 8);
- hdr[1] = (U8)(amHdr->sn & 0x0FF);
+ hdr[0] = hdr[0] | (uint8_t)((amHdr->sn & 0xF00) >> 8);
+ hdr[1] = (uint8_t)(amHdr->sn & 0x0FF);
(*idx)++;
}
else
{
- hdr[0] = hdr[0] | (U8)((amHdr->sn & 0x30000) >> 16);
- hdr[1] = (U8)((amHdr->sn & 0xFF00) >> 8);
+ hdr[0] = hdr[0] | (uint8_t)((amHdr->sn & 0x30000) >> 16);
+ hdr[1] = (uint8_t)((amHdr->sn & 0xFF00) >> 8);
(*idx)++;
- hdr[2] = (U8)(amHdr->sn & 0xFF);
+ hdr[2] = (uint8_t)(amHdr->sn & 0xFF);
(*idx)++;
}
if ((amHdr->si == RLC_SI_MID_SEG) || (amHdr->si == RLC_SI_LAST_SEG))
{
(*idx)++;
- hdr[(*idx)] = (U8)((amHdr->so & 0xFF00)>> 8);
+ hdr[(*idx)] = (uint8_t)((amHdr->so & 0xFF00)>> 8);
(*idx)++;
- hdr[(*idx)] = (U8)(amHdr->so & 0xFF);
+ hdr[(*idx)] = (uint8_t)(amHdr->so & 0xFF);
}
return;
amDl->nxtRetx = retx;
}
- RETVOID;
+ return;
}
/**
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
while(txBuf->pduLst.first)
{
if (*retx == NULLP)
{
RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
/* Remove PDU from txBuf */
rlcUtlDelTxBuf(amDl->txBufLst, txBuf,gCb);
- RETVOID;
+ return;
}
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
"UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
cntrlPdu[0] |= (ack_sn & 0xF00)>> 8;
- cntrlPdu[1] = (U8)ack_sn;
+ cntrlPdu[1] = (uint8_t)ack_sn;
}
}
}
/* 18 BIT Nack SN encode */
- cntrlPdu[encIdx] = (U8)((sn & 0x3FC00) >> 10);
+ cntrlPdu[encIdx] = (uint8_t)((sn & 0x3FC00) >> 10);
/* Next Octet */
- cntrlPdu[encIdx + 1] = (U8)((sn & 0x3FC) >> 2);
+ cntrlPdu[encIdx + 1] = (uint8_t)((sn & 0x3FC) >> 2);
/* Next Octet */
- cntrlPdu[encIdx + 2] = (U8)((sn & 0x3)<< 6);
+ cntrlPdu[encIdx + 2] = (uint8_t)((sn & 0x3)<< 6);
if (rlcNackInfo->isSegment)
{
/* Add soStart and soEnd */
/* SOstart */
cntrlPdu[encIdx + 3] = (rlcNackInfo->soStart) >> 8;
- cntrlPdu[encIdx + 4] = (U8)rlcNackInfo->soStart;
+ cntrlPdu[encIdx + 4] = (uint8_t)rlcNackInfo->soStart;
/* SOend */
cntrlPdu[encIdx + 5] = (rlcNackInfo->soEnd) >> 8;
- cntrlPdu[encIdx + 6] = (U8)(rlcNackInfo->soEnd);
+ cntrlPdu[encIdx + 6] = (uint8_t)(rlcNackInfo->soEnd);
}
if (rlcNackInfo->nackRange)
RlcExtHdr *hdrInfo;
#endif
{
- U8 hdr;
- U8 pLen = hdrInfo->pLen;
- U8 len = (U8)hdrInfo->len;
- U16 val;
- U8 tHdr;
- U8 fLen;
- U8 rLen;
- /* U8 rLen1 = 0; */
- U16 tVal;
+ uint8_t hdr;
+ uint8_t pLen = hdrInfo->pLen;
+ uint8_t len = (uint8_t)hdrInfo->len;
+ uint16_t val;
+ uint8_t tHdr;
+ uint8_t fLen;
+ uint8_t rLen;
+ /* uint8_t rLen1 = 0; */
+ uint16_t tVal;
hdr = hdrInfo->hdr;
hdrInfo->hdr = hdr;
hdrInfo->val = val;
- RETVOID;
+ return;
}
RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *cntrlPdu,
-U8 *fByte
+uint8_t *fByte
)
#else
PRIVATE Void rgAmmUlHndlStatusPdu(udxPst,suId,gCb, rbCb, cntrlPdu, fByte)
RlcCb *gCb;
RlcDlRbCb *rbCb;
Buffer *cntrlPdu;
-U8 *fByte;
+uint8_t *fByte;
#endif
{
- U8 e1;
+ uint8_t e1;
RlcExtHdr hdrInfo;
RlcUdxStaPdu *pStaPdu;
- U8 e3; /* NACK RANGE : 5GNR */
- U32 snLen;
- U32 snRange;
- U32 resrvdBitsAckSn;
- U32 resrvdBitsNackSn;
+ uint8_t e3; /* NACK RANGE : 5GNR */
+ uint32_t snLen;
+ uint32_t snRange;
+ uint32_t resrvdBitsAckSn;
+ uint32_t resrvdBitsNackSn;
RLCDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n");
if (hdrInfo.hdr & 0xE0)
{
RLCDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n");
- RETVOID;
+ return;
}
RLC_ALLOC_SHRABL_BUF(udxPst->region,
/* Memory allocation failure can not be expected */
if(!pStaPdu)
{
- RETVOID;
+ return;
}
#endif
/* Check if NACK Exists */
hdrInfo.len = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ e1 = (uint8_t)hdrInfo.val;
RLCDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: ACK SN = %d \n", pStaPdu->ackSn);
/* Extract the Reserved Bits after ACK SN field */
hdrInfo.len = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ e1 = (uint8_t)hdrInfo.val;
/* Extract e2 */
/* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- /* e2 = (U8) hdrInfo.val;*/
+ /* e2 = (uint8_t) hdrInfo.val;*/
/* Store e2 value */
- pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val;
+ pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (uint8_t) hdrInfo.val;
/* Extract e3 : 5GNR */
/* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e3 = (U8) hdrInfo.val;
+ e3 = (uint8_t) hdrInfo.val;
/* Extract Reserved Bits after NACK SN */
hdrInfo.len = resrvdBitsNackSn;
/* Extract NACK range field */
hdrInfo.len = RLC_NACK_RANGE_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- snRange = (U8)hdrInfo.val;
+ snRange = (uint8_t)hdrInfo.val;
pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
//rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
rlcUlUdxStaUpdReq(udxPst, suId, &rbCb->rlcId, pStaPdu);
- RETVOID;
+ return;
}
S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
{
RlcDlRbCb *rbCb = NULLP;
RlcDlUeCb *ueCb = NULLP;
- U8 fByte;
- U8 temp;
+ uint8_t fByte;
+ uint8_t temp;
S16 retVal = RFAILED;
RlcCb *gCb;
Pst dlRlcPst = *udxPst;
Code Review / o-du / l2.git / blobdiff