X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2F5gnrrlc%2Fkw_amm_ul.c;h=adf5385b262e89ca25680751939f3dd92693b5d8;hb=refs%2Fchanges%2F91%2F5391%2F11;hp=f7ef2bfce5df1ea04f03e793788b4c644326d0ec;hpb=5625a52ad68f6ad93684e68bbbdbaef0d462cf9a;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_amm_ul.c b/src/5gnrrlc/kw_amm_ul.c index f7ef2bfce..adf5385b2 100755 --- a/src/5gnrrlc/kw_amm_ul.c +++ b/src/5gnrrlc/kw_amm_ul.c @@ -40,18 +40,7 @@ static int RLOG_MODULE_ID=2048; static int RLOG_FILE_ID=190; /* header include files (.h) */ -#include "envopt.h" /* environment options */ -#include "envdep.h" /* environment dependent */ -#include "envind.h" /* environment independent */ - -#include "gen.h" /* general */ -#include "ssi.h" /* system services */ -#include "cm5.h" /* common timer defines */ -#include "cm_tkns.h" /* common tokens defines */ -#include "cm_mblk.h" /* common memory allocation library defines */ -#include "cm_llist.h" /* common link list defines */ -#include "cm_hash.h" /* common hash list defines */ -#include "cm_lte.h" /* common LTE defines */ +#include "common_def.h" #include "lkw.h" /* LKW defines */ #include "ckw.h" /* CKW defines */ #include "kwu.h" /* KWU defines */ @@ -64,16 +53,6 @@ static int RLOG_FILE_ID=190; #include "kw_ul.h" /* extern (.x) include files */ -#include "gen.x" /* general */ -#include "ssi.x" /* system services */ - -#include "cm5.x" /* common timer library */ -#include "cm_tkns.x" /* common tokens */ -#include "cm_mblk.x" /* common memory allocation */ -#include "cm_llist.x" /* common link list */ -#include "cm_hash.x" /* common hash list */ -#include "cm_lte.x" /* common LTE includes */ -#include "cm_lib.x" /* common memory allocation library */ #include "lkw.x" /* LKW */ #include "ckw.x" /* CKW */ #include "kwu.x" /* KWU */ @@ -87,7 +66,7 @@ static int RLOG_FILE_ID=190; #ifndef RGL_SPECIFIC_CHANGES #ifndef TENB_ACC #ifndef LTE_PAL_ENB -extern U32 ulrate_rgu; +uint32_t ulrate_rgu; #endif #endif #endif @@ -95,11 +74,11 @@ extern U32 ulrate_rgu; #ifndef TENB_ACC #ifndef TENB_T2K3K_SPECIFIC_CHANGES #ifndef LTE_PAL_ENB -extern U32 isMemThreshReached(Region region); +uint32_t isMemThreshReached(Region region); #endif #else #ifndef LTE_PAL_ENB -extern U32 isMemThreshReached(Region region); +uint32_t isMemThreshReached(Region region); #endif #endif #endif @@ -107,59 +86,59 @@ extern U32 isMemThreshReached(Region region); /** @file gp_amm_ul.c @brief RLC Acknowledged Mode Uplink Module **/ -#define KW_MODULE (KW_DBGMASK_AM | KW_DBGMASK_UL) /* for debugging purpose */ +#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_UL) /* for debugging purpose */ /* private function declarations */ -PRIVATE Void kwAmmUlAssembleCntrlInfo ARGS ((KwCb *gCb, KwUlRbCb *rbCb)); +static void rlcAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb)); -PRIVATE S16 kwAmmExtractHdr ARGS ((KwCb *gCb, - KwUlRbCb *rbCb, +static uint8_t rlcAmmExtractHdr ARGS ((RlcCb *gCb, + RlcUlRbCb *rbCb, Buffer *pdu, - KwAmHdr *amHdr, - U8 *fByte)); - -PRIVATE Bool kwAmmUlPlacePduInRecBuf ARGS ((KwCb *gCb, - Buffer *pdu, - KwUlRbCb *rbCb, - KwAmHdr *amHdr)); - -PRIVATE Void kwAmmTriggerStatus ARGS ((KwCb *gCb, - KwUlRbCb *rbCb, - KwSn sn, - Bool discFlg)); - -PRIVATE S16 kwAmmUlReassembleSdus ARGS ((KwCb *gCb, - KwUlRbCb *rbCb, - KwAmRecBuf *recBuf)); - -PRIVATE Void kwAmmProcPduOrSeg ARGS ((KwCb *gCb, - KwUlRbCb *rbCb, - KwAmHdr *amHdr, + RlcAmHdr *amHdr, + uint8_t *fByte)); + +static bool rlcAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb, + Buffer *pdu, + RlcUlRbCb *rbCb, + RlcAmHdr *amHdr)); + +static void rlcAmmTriggerStatus ARGS ((RlcCb *gCb, + RlcUlRbCb *rbCb, + RlcSn sn, + bool discFlg)); + +static uint8_t rlcAmmUlReassembleSdus ARGS ((RlcCb *gCb, + RlcUlRbCb *rbCb, + RlcAmRecBuf *recBuf)); + +static Void rlcAmmProcPduOrSeg ARGS ((RlcCb *gCb, + RlcUlRbCb *rbCb, + RlcAmHdr *amHdr, Buffer *pdu)); -PRIVATE Void kwAmmUpdExpByteSeg ARGS ((KwCb *gCb,KwAmUl *amUl, KwSeg* newSeg)); +static Void rlcAmmUpdExpByteSeg ARGS ((RlcCb *gCb,RlcAmUl *amUl, RlcSeg* newSeg)); -PRIVATE Void kwAmmExtractElmnt ARGS ((KwCb *gCb, Buffer *pdu, KwExtHdr *hdrInfo)); +static Void rlcAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo)); -PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((KwCb *gCb, - KwUlRbCb *rbCb, +static Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb, + RlcUlRbCb *rbCb, Buffer *cntrlPdu, - U8 *fByte)); + uint8_t *fByte)); /****************************************************************************** AM Module contains the following funcitons: - - kwAmmProcessSdus - - kwAmmUlAssembleCntrlInfo - - kwResegRetxPdus - - kwAssembleSdus + - rlcAmmProcessSdus + - rlcAmmUlAssembleCntrlInfo + - rlcResegRetxPdus + - rlcAssembleSdus - kwChkandSetPoll - - kwAmmProcessPdus - - kwAmmUlHndlStatusPdu - - kwAmmTriggerStatus - - kwAmmUlReassembleSdus + - rlcAmmProcessPdus + - rlcAmmUlHndlStatusPdu + - rlcAmmTriggerStatus + - rlcAmmUlReassembleSdus *******************************************************************************/ /** @addtogroup ammode */ @@ -180,128 +159,107 @@ PRIVATE Void kwAmmUlHndlStatusPdu ARGS ((KwCb *gCb, * The number of bytes required to encode this NACK information * */ -#ifdef ANSI -PRIVATE S16 kwAmmUlSetNackInfo -( -KwUlRbCb *rbCb, -KwSn sn, -Bool isSegment, -U16 soStart, -U16 soEnd, -KwUdxDlStaPdu *statusPdu, -KwSn *prevNackSn -) -#else -PRIVATE S16 kwAmmUlSetNackInfo(rbCb, sn, isSegment, soStart, statusPdu, prevNackSn) -KwUlRbCb *rbCb; -KwSn sn; -Bool isSegment; -U16 soStart; -U16 soEnd; -KwUdxDlStaPdu *statusPdu, -KwSn *prevNackSn; -#endif +static uint8_t rlcAmmUlSetNackInfo(RlcUlRbCb *rbCb, RlcSn sn, bool isSegment, \ + uint16_t soStart, uint16_t soEnd, RlcUdxDlStaPdu *statusPdu, RlcSn *prevNackSn) { - KwNackInfo *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount); - S16 sizeToBeEncd = 0; /* Status PDu size to be encoded */ - - TRC2(kwAmmUlSetNackInfo) - - /* In following cases we should increment the nackCnt & fill new NACK_SN info: - * 1) First NACK_SN of the statusdPdu - * 2) NACK_SN is not continuous with previous - * 3) NACK_SN is same as previuos but segments are not continuous - * 4) NACK_SN is continuous with previous but previous NACK_SN segments - * are not missing in sequence till end - */ - if((*prevNackSn == 0xffffffff) || ((((*prevNackSn) + 1) & AMUL.snModMask) != sn) || - (((*prevNackSn) == sn) && (((nackInfo->soEnd + 1) != soStart))) || - ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != KW_ALL_BYTES_MISSING))) + RlcNackInfo *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount); + uint16_t sizeToBeEncd = 0; /* Status PDu size to be encoded */ + + /* In following cases we should increment the nackCnt & fill new NACK_SN info: + * 1) First NACK_SN of the statusdPdu + * 2) NACK_SN is not continuous with previous + * 3) NACK_SN is same as previuos but segments are not continuous + * 4) NACK_SN is continuous with previous but previous NACK_SN segments + * are not missing in sequence till end + */ + if((*prevNackSn == 0xffffffff) || ((((*prevNackSn) + 1) & RLC_AMUL.snModMask) != sn) || + (((*prevNackSn) == sn) && (((nackInfo->soEnd + 1) != soStart))) || + ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != RLC_ALL_BYTES_MISSING))) + { + if(nackInfo->nackRange) { - if(nackInfo->nackRange) - { - if((nackInfo->soEnd) && (!nackInfo->soStart)) - { - /*First nack_sn of this nackRange not segmented but last is segmented */ - sizeToBeEncd = 5; /*32 for soStart and soEnd and 8 for nackRange */ - } - else - { - /*First nack_sn of this nackRange was segmented */ - sizeToBeEncd = 1; /*8 for nackRange */ - } - } + if((nackInfo->soEnd) && (!nackInfo->soStart)) + { + /*First nack_sn of this nackRange not segmented but last is segmented */ + sizeToBeEncd = 5; /*32 for soStart and soEnd and 8 for nackRange */ + } + else + { + /*First nack_sn of this nackRange was segmented */ + sizeToBeEncd = 1; /*8 for nackRange */ + } + } - if(*prevNackSn != 0xffffffff) - { - /* Increment nackCount as this sn is continous */ - statusPdu->nackCount++; - nackInfo = statusPdu->nackInfo + statusPdu->nackCount; - } + if(*prevNackSn != 0xffffffff) + { + /* Increment nackCount as this sn is continous */ + statusPdu->nackCount++; + nackInfo = statusPdu->nackInfo + statusPdu->nackCount; + } - nackInfo->sn = sn; - nackInfo->isSegment = isSegment; - nackInfo->soStart = soStart; - nackInfo->soEnd = soEnd; - nackInfo->nackRange = 0; + nackInfo->sn = sn; + nackInfo->isSegment = isSegment; + nackInfo->soStart = soStart; + nackInfo->soEnd = soEnd; + nackInfo->nackRange = 0; - if(isSegment) - { - sizeToBeEncd += ((AMUL.snLen == KW_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */ - } - else - { - sizeToBeEncd += ((AMUL.snLen == KW_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */ - } + if(isSegment) + { + sizeToBeEncd += ((RLC_AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */ } else { - if(!(nackInfo->nackRange)) - { - nackInfo->nackRange++; - } - /* This case means there are continuous SNs/Segments. If it is the next - * Sn then increment nackRnage. if same SN but different segment then - * dont increment nackRange */ - if((((*prevNackSn) + 1) & AMUL.snModMask) == sn) - { - nackInfo->nackRange++; - } - - /* If NackRange is reached to max value then increment statusPdu->nackCount*/ - if(nackInfo->nackRange == 255) - { - statusPdu->nackCount++; - if(nackInfo->isSegment) - { - sizeToBeEncd = 1; /* return only nackRangeSize*/ - } - else if (isSegment) - { - /* First SN was not segmented of this nackRange but last SN is segmented */ - sizeToBeEncd = 5; /* return size of soSatrt + soEnd + nackRnage */ - } - } + sizeToBeEncd += ((RLC_AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */ + } + } + else + { + if(!(nackInfo->nackRange)) + { + nackInfo->nackRange++; + } + /* This case means there are continuous SNs/Segments. If it is the next + * Sn then increment nackRnage. if same SN but different segment then + * dont increment nackRange */ + if((((*prevNackSn) + 1) & RLC_AMUL.snModMask) == sn) + { + nackInfo->nackRange++; + } - if(isSegment) - { - nackInfo->isSegment = isSegment; - nackInfo->soEnd = soEnd; - } - else if(nackInfo->isSegment) - { - nackInfo->soEnd = KW_ALL_BYTES_MISSING; - } - else - { - nackInfo->soStart = 0; - nackInfo->soEnd = 0; - } + /* If NackRange is reached to max value then increment statusPdu->nackCount*/ + if(nackInfo->nackRange == 255) + { + statusPdu->nackCount++; + if(nackInfo->isSegment) + { + sizeToBeEncd = 1; /* return only nackRangeSize*/ + } + else if (isSegment) + { + /* First SN was not segmented of this nackRange but last SN is segmented */ + sizeToBeEncd = 5; /* return size of soSatrt + soEnd + nackRnage */ + } + } + if(isSegment) + { + nackInfo->isSegment = isSegment; + nackInfo->soEnd = soEnd; + } + else if(nackInfo->isSegment) + { + nackInfo->soEnd = RLC_ALL_BYTES_MISSING; + } + else + { + nackInfo->soStart = 0; + nackInfo->soEnd = 0; } + + } *prevNackSn = sn; - RETVALUE(sizeToBeEncd); + return (sizeToBeEncd); } /** @@ -320,68 +278,52 @@ KwSn *prevNackSn; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmUlAssembleCntrlInfo -( -KwCb *gCb, -KwUlRbCb *rbCb -) -#else -PRIVATE Void kwAmmUlAssembleCntrlInfo(gCb, rbCb) -KwCb *gCb; -KwUlRbCb *rbCb; -#endif +static void rlcAmmUlAssembleCntrlInfo(RlcCb *gCb, RlcUlRbCb *rbCb) { - KwUdxDlStaPdu *pStatusPdu; - KwNackInfo *nackInfo; - KwSn sn; /* sequence number */ - KwSn mSn; /* Mod val of sequence number */ - KwSn rxHighestStatus; /* Mod val of rxHighestStatus */ - KwSeg *seg; /* pdu segment */ - U16 nackCnt = 0; /* Index for staPdu */ - U16 seqSo; /* segmment offset */ - KwUdxUlSapCb *sapCb; - U16 staPduEncSize = 3; /* size that would be of the encoded + RlcUdxDlStaPdu *pStatusPdu; + RlcNackInfo *nackInfo; + RlcSn sn; /* sequence number */ + RlcSn mSn; /* Mod val of sequence number */ + RlcSn rxHighestStatus; /* Mod val of rxHighestStatus */ + RlcSeg *seg; /* pdu segment */ + uint16_t nackCnt = 0; /* Index for staPdu */ + uint16_t seqSo; /* segmment offset */ + RlcUdxUlSapCb *sapCb; + uint16_t staPduEncSize = 3; /* size that would be of the encoded STATUS PDU, it is in bits; 15 for first fixed part of STATUS PDU */ - KwAmRecBuf *recBuf = NULLP; - KwSn prevNackSn = 0xffffffff; - - TRC2(kwAmmUlAssembleCntrlInfo) + RlcAmRecBuf *recBuf = NULLP; + RlcSn prevNackSn = 0xffffffff; + sapCb = RLC_GET_UDX_SAP(gCb); - sapCb = KW_GET_UDX_SAP(gCb); - - KW_ALLOC_SHRABL_BUF(sapCb->pst.region, + RLC_ALLOC_SHRABL_BUF(sapCb->pst.region, sapCb->pst.pool, pStatusPdu, - sizeof(KwUdxDlStaPdu)); + sizeof(RlcUdxDlStaPdu)); #if (ERRCLASS & ERRCLS_ADD_RES) /* Memory allocation failure can not be expected */ if(!pStatusPdu) { - RETVOID; + return; } #endif - sn = AMUL.rxNext; - MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask); - MODAMR(AMUL.rxHighestStatus, rxHighestStatus, AMUL.rxNext, AMUL.snModMask); + sn = RLC_AMUL.rxNext; + MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask); + MODAMR(RLC_AMUL.rxHighestStatus, rxHighestStatus, RLC_AMUL.rxNext, RLC_AMUL.snModMask); - recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn); + recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn); while (mSn < rxHighestStatus ) { /* For missing PDUs */ - if ((NULLP == recBuf) && nackCnt < KW_MAX_NACK_CNT ) + if ((NULLP == recBuf) && nackCnt < RLC_MAX_NACK_CNT ) { - RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "Missing PDU's SN = %d UEID:%d CELLID:%d", - sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - staPduEncSize += kwAmmUlSetNackInfo(rbCb, + DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing PDU's SN = %d UEID:%d \ + CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); + staPduEncSize += rlcAmmUlSetNackInfo(rbCb, sn, FALSE, /* isSegment */ 0, /* SOStart */ @@ -396,13 +338,13 @@ KwUlRbCb *rbCb; with soStart and soEnd info to staPdu */ seqSo = 0; - KW_LLIST_FIRST_SEG(recBuf->segLst, seg); - while (seg != NULLP && nackCnt < KW_MAX_NACK_CNT) + RLC_LLIST_FIRST_SEG(recBuf->segLst, seg); + while (seg != NULLP && nackCnt < RLC_MAX_NACK_CNT) { /* For missing byte segments */ if (seg->amHdr.so != seqSo) { - staPduEncSize += kwAmmUlSetNackInfo(rbCb, + staPduEncSize += rlcAmmUlSetNackInfo(rbCb, sn, TRUE, seqSo, @@ -410,64 +352,51 @@ KwUlRbCb *rbCb; pStatusPdu, &prevNackSn); - RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "Missing byte segment's" - " SN:%d UEID:%d CELLID:%d", - sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "soStart and soEnd = %d, %d UEID:%d CELLID:%d", - seqSo, - seg->amHdr.so - 1, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing byte segment's" + " SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d \ + UEID:%d CELLID:%d", seqSo, seg->amHdr.so - 1, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); } seqSo = seg->soEnd + 1; - KW_LLIST_NEXT_SEG(recBuf->segLst, seg); + RLC_LLIST_NEXT_SEG(recBuf->segLst, seg); } /* Check if the last segment is missing */ - KW_LLIST_LAST_SEG(recBuf->segLst, seg); + RLC_LLIST_LAST_SEG(recBuf->segLst, seg); if ((seg != NULLP) && - (seg->amHdr.si != KW_SI_LAST_SEG && nackCnt < KW_MAX_NACK_CNT)) + (seg->amHdr.si != RLC_SI_LAST_SEG && nackCnt < RLC_MAX_NACK_CNT)) { - staPduEncSize += kwAmmUlSetNackInfo(rbCb, + staPduEncSize += rlcAmmUlSetNackInfo(rbCb, sn, TRUE, seqSo, - KW_ALL_BYTES_MISSING, + RLC_ALL_BYTES_MISSING, pStatusPdu, &prevNackSn); - RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmUlAssembleCntrlInfo: Missing (last) byte " - "segment's SN:%d UEID:%d CELLID:%d", - sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "soStart and soEnd = %d, %d UEID:%d CELLID:%d", - seqSo, - KW_ALL_BYTES_MISSING, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing (last) byte " + "segment's SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d\ + UEID:%d CELLID:%d", seqSo, RLC_ALL_BYTES_MISSING, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); } } - sn = (sn + 1) & (AMUL.snModMask); /* MOD 1024 */ - MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask); + sn = (sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */ + MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask); /* Get the received Buffer the updated/next SN */ - recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn); + recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn); /* Find the next missing sequence number if nackCnt reaches maximum and still Reordering window has some missing AMDPDUs / AMDPDU segments. The next missing sequence number will be considered as the ack sequnece number in the status pdu.*/ - if((nackCnt == KW_MAX_NACK_CNT) && + if((nackCnt == RLC_MAX_NACK_CNT) && ((recBuf == NULLP) || ((recBuf->pdu == NULLP) && (recBuf->segLst.count > 0)))) @@ -501,50 +430,45 @@ KwUlRbCb *rbCb; /* Update ACK SN with the last sn for which feedback is not assembled */ if ( mSn == rxHighestStatus) { - pStatusPdu->ackSn = AMUL.rxHighestStatus; + pStatusPdu->ackSn = RLC_AMUL.rxHighestStatus; } else { pStatusPdu->ackSn = sn; } - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmUlAssembleCntrlInfo: ACK PDU's SN = %d" - "UEID:%d CELLID:%d", - pStatusPdu->ackSn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d" + "UEID:%d CELLID:%d", pStatusPdu->ackSn, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); pStatusPdu->controlBo = staPduEncSize; /*Its already in bytes */ - AMUL.staTrg = FALSE; - AMUL.gatherStaPduInfo = FALSE; + RLC_AMUL.staTrg = FALSE; + RLC_AMUL.gatherStaPduInfo = FALSE; - if (KwUlUdxStaPduReq(&sapCb->pst, + if (rlcUlUdxStaPduReq(&sapCb->pst, sapCb->spId, &rbCb->rlcId, pStatusPdu) != ROK) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Failed to Send Sta Pdu UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - KW_FREE_SHRABL_BUF_WC(sapCb->pst.region, + DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Failed to Send Sta Pdu UEID:%d \ + CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); + RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region, sapCb->pst.pool, pStatusPdu, - sizeof(KwUdxDlStaPdu)); + sizeof(RlcUdxDlStaPdu)); } - RETVOID; + return; } #ifdef XEON_SPECIFIC_CHANGES -extern U32 gRlcDatIndUL; +uint32_t gRlcDatIndUL; #endif #ifdef T2K_TRIGGER_RLC_REEST -PUBLIC U32 drpRlcDrbPack; +uint32_t drpRlcDrbPack; #endif /** * @brief Handler to process the PDUs received from MAC and send it to PDCP @@ -563,78 +487,41 @@ PUBLIC U32 drpRlcDrbPack; * */ #ifdef LTE_L2_MEAS -#ifdef ANSI -PUBLIC Void kwAmmProcessPdus -( -KwCb *gCb, -KwUlRbCb *rbCb, -KwPduInfo *pduInfo, -U32 ttiCnt -) -#else -PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo, ulTimeInfo) -KwCb *gCb; -KwUlRbCb *rbCb; -KwPduInfo *pduInfo; -U32 ttiCnt; -#endif -#else -#ifdef ANSI -PUBLIC Void kwAmmProcessPdus -( -KwCb *gCb, -KwUlRbCb *rbCb, -KwPduInfo *pduInfo -) +void rlcAmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo, uint32_t ttiCnt) #else -PUBLIC Void kwAmmProcessPdus(gCb, rbCb, pduInfo) -KwCb *gCb; -KwUlRbCb *rbCb; -KwPduInfo *pduInfo; -#endif +void rlcAmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo) #endif { Buffer *pdu; - KwAmUl *amUl; - KwAmHdr amHdr; - U8 numPdu = 0; - U8 numPduToProcess; - KwSn sn; - KwSn tSn; - KwSn mSn; - U8 fByte; - Bool discFlg; + RlcAmUl *amUl; + RlcAmHdr amHdr; + uint8_t numPdu = 0; + uint8_t numPduToProcess; + RlcSn sn; + RlcSn tSn; + RlcSn mSn; + uint8_t fByte; + bool discFlg; #ifdef LTE_L2_MEAS_RLC MsgLen rlcSduSz; /*Holds length of Rlc Sdu*/ #endif /* LTE_L2_MEAS */ - TRC2(kwAmmProcessPdus) - + amUl = &RLC_AMUL; - amUl = &AMUL; - - numPduToProcess = KW_MIN(pduInfo->numPdu, RGU_MAX_PDU); - RLOG_ARG4(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "numPdu[%ld],numPduToProcess[%ld] UEID:%ld CELLID:%ld", - numPdu, - numPduToProcess, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + numPduToProcess = RLC_MIN(pduInfo->numPdu, RGU_MAX_PDU); + DU_LOG("\nRLC : rlcAmmProcessPdus: numPdu[%d],numPduToProcess[%d] UEID:%d CELLID:%d", + numPdu, numPduToProcess, rbCb->rlcId.ueId, rbCb->rlcId.cellId); - //printf ("++++++++++++ 5GNRLOG numPduToProcess %d \n", numPduToProcess); while (numPdu < numPduToProcess) { - //printf ("++++++++++++ 5GNRLOG processing pdu %d \n", numPdu); discFlg = FALSE; pdu = pduInfo->mBuf[numPdu++]; if (! pdu) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Null Pdu UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC : rlcAmmProcessPdus: Null Pdu UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); gCb->genSts.errorPdusRecv++; break; } @@ -642,41 +529,36 @@ KwPduInfo *pduInfo; #ifndef TENB_ACC #ifndef LTE_PAL_ENB MsgLen len; - SFndLenMsg(pdu, &len); + ODU_GET_MSG_LEN(pdu, &len); ulrate_rgu += len; #endif #endif #endif /* Extract AM PDU/SEG header Info */ - KW_MEM_ZERO(&amHdr, sizeof(KwAmHdr)); + RLC_MEM_ZERO(&amHdr, sizeof(RlcAmHdr)); /* Avoided the allocation of amHdr and sending a single pointer */ - if (kwAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK) + if (rlcAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Header Extraction Failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - KW_FREE_BUF(pdu); + DU_LOG("\nRLC : rlcAmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + ODU_PUT_MSG_BUF(pdu); gCb->genSts.errorPdusRecv++; continue; } /* Check if its a control PDU */ if (amHdr.dc == 0) { - kwAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte); - KW_FREE_BUF(pdu); + rlcAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte); + ODU_PUT_MSG_BUF(pdu); continue; } - if((amHdr.si == KW_SI_LAST_SEG) && (!amHdr.so)) + if((amHdr.si == RLC_SI_LAST_SEG) && (!amHdr.so)) { - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmProcessPdus: Dropping PDU because SO can't be zero for last segment sn:%u " - "UEID:%d CELLID:%d", - amHdr.sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - KW_FREE_BUF(pdu); + DU_LOG("\nRLC: rlcAmmProcessPdus: Dropping PDU because SO can't be zero\ + for last segment sn:%u UEID:%d CELLID:%d", amHdr.sn, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); + ODU_PUT_MSG_BUF(pdu); continue; } #ifndef RGL_SPECIFIC_CHANGES @@ -685,22 +567,22 @@ KwPduInfo *pduInfo; #ifndef TENB_T2K3K_SPECIFIC_CHANGES #ifndef LTE_PAL_ENB /* Changed the condition to TRUE from ROK */ - if(isMemThreshReached(kwCb[0]->init.region) == TRUE) + if(isMemThreshReached(rlcCb[0]->init.region) == TRUE) { - extern U32 rlculdrop; + uint32_t rlculdrop; rlculdrop++; - KW_FREE_BUF(pdu); + ODU_PUT_MSG_BUF(pdu); continue; } #endif #else #ifndef LTE_PAL_ENB /*ccpu00142274 - UL memory based flow control*/ - if(isMemThreshReached(kwCb[0]->init.region) != ROK) + if(isMemThreshReached(rlcCb[0]->init.region) != ROK) { - extern U32 rlculdrop; + uint32_t rlculdrop; rlculdrop++; - KW_FREE_BUF(pdu); + ODU_PUT_MSG_BUF(pdu); continue; } #endif @@ -714,7 +596,7 @@ KwPduInfo *pduInfo; { if(rbCb->rlcId.rbType == CM_LTE_DRB) { - KW_FREE_BUF(pdu); + ODU_PUT_MSG_BUF(pdu); continue; } } @@ -722,15 +604,15 @@ KwPduInfo *pduInfo; #endif /* Reordering data PDU */ sn = amHdr.sn; - if (kwAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE) + if (rlcAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE) { - KwAmRecBuf *recBuf; - Bool tmrRunning; - KwSn tVrMr; - KwSn mrxNextHighestRcvd; + RlcAmRecBuf *recBuf; + bool tmrRunning; + RlcSn tVrMr; + RlcSn mrxNextHighestRcvd; #ifdef LTE_L2_MEAS - kwUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt); + rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt); #endif /* LTE_L2_MEAS */ /* Update rxNextHighestRcvd */ @@ -740,19 +622,16 @@ KwPduInfo *pduInfo; { amUl->rxNextHighestRcvd = ((sn + 1) & (amUl->snModMask)); - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d", - amUl->rxNextHighestRcvd, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d", + amUl->rxNextHighestRcvd, rbCb->rlcId.ueId, rbCb->rlcId.cellId); } - recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn); + recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn); if ((NULLP != recBuf) && ( recBuf->allRcvd)) { /* deliver the reassembled RLC SDU to upper layer, But not removed from the table */ - kwAmmUlReassembleSdus(gCb, rbCb, recBuf); + rlcAmmUlReassembleSdus(gCb, rbCb, recBuf); recBuf->isDelvUpperLayer = TRUE; MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask); @@ -762,7 +641,7 @@ KwPduInfo *pduInfo; { tSn = (sn + 1) & (amUl->snModMask) ; /* MOD (2 Pwr SN LEN- 1) */ - recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn); + recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn); /* Scan through till the upper edge of the window */ MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask); while (mSn <= tVrMr) @@ -770,7 +649,7 @@ KwPduInfo *pduInfo; if ((NULLP == recBuf) || (!recBuf->allRcvd)) { RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmProcessPdus: Updated rxHighestStatus:%d " + "rlcAmmProcessPdus: Updated rxHighestStatus:%d " "UEID:%d CELLID:%d", tSn, rbCb->rlcId.ueId, @@ -780,7 +659,7 @@ KwPduInfo *pduInfo; break; } tSn = (tSn + 1) & (amUl->snModMask); /* MOD (2 Pwr SN LEN- 1) */ - recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn); + recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn); mSn++; } } @@ -790,7 +669,7 @@ KwPduInfo *pduInfo; if (sn == amUl->rxNext) { tSn = sn; - recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn); + recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn); MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask); /* Scan through till the upper edge of the window */ while (mSn <= tVrMr) @@ -801,31 +680,31 @@ KwPduInfo *pduInfo; /* RecBuf should remove from table since PDU is already sent to upper layer */ recBuf->isDelvUpperLayer = FALSE; - kwUtlDelRecBuf(amUl->recBufLst, recBuf, gCb); + rlcUtlDelRecBuf(amUl->recBufLst, recBuf, gCb); } else { amUl->rxNext = tSn; - amUl->vrMr = (amUl->rxNext + (KW_AM_GET_WIN_SZ(amUl->snLen))) & (amUl->snModMask); + amUl->vrMr = (amUl->rxNext + (RLC_AM_GET_WIN_SZ(amUl->snLen))) & (amUl->snModMask); break; } tSn = (tSn + 1) & (amUl->snModMask); - recBuf = kwUtlGetRecBuf(amUl->recBufLst, tSn); + recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn); mSn++; } } } /* Check if reOrdTmr is running and update rxNextStatusTrig accordingly */ - tmrRunning = kwChkTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR); + tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR); if (tmrRunning) { - Bool snInWin = KW_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl); + Bool snInWin = RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl); if ( (amUl->rxNextStatusTrig == amUl->rxNext) || ( (!snInWin) && (amUl->rxNextStatusTrig != amUl->vrMr) ) ) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR); + rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR); tmrRunning = FALSE; } } @@ -834,14 +713,12 @@ KwPduInfo *pduInfo; { if (amUl->rxNextHighestRcvd > amUl->rxNext) { - kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR); + rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR); amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd; - RLOG_ARG3(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmProcessPdus: Updated rxNextStatusTrig = %d UEID:%d CELLID:%d", - amUl->rxNextStatusTrig, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmProcessPdus: Updated rxNextStatusTrig = %d \ + UEID:%d CELLID:%d", amUl->rxNextStatusTrig, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); } } } @@ -853,20 +730,20 @@ KwPduInfo *pduInfo; if (amHdr.p) { - kwAmmTriggerStatus(gCb,rbCb, sn, discFlg); + rlcAmmTriggerStatus(gCb,rbCb, sn, discFlg); } } #ifdef LTE_L2_MEAS - kwUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt); + rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt); #endif /* LTE_L2_MEAS */ gCb->genSts.pdusRecv += pduInfo->numPdu; if (amUl->gatherStaPduInfo) { - kwAmmUlAssembleCntrlInfo(gCb,rbCb); + rlcAmmUlAssembleCntrlInfo(gCb,rbCb); } - RETVOID; + return; } @@ -891,75 +768,55 @@ KwPduInfo *pduInfo; * -# RFAILED * */ -#ifdef ANSI -PRIVATE S16 kwAmmExtractHdr -( -KwCb *gCb, -KwUlRbCb *rbCb, -Buffer *pdu, -KwAmHdr *amHdr, -U8 *fByte -) -#else -PRIVATE S16 kwAmmExtractHdr(gCb, rbCb, pdu, amHdr, fByte) -KwCb *gCb; -KwUlRbCb *rbCb; -Buffer *pdu; -KwAmHdr *amHdr; -U8 *fByte; -#endif +static uint8_t rlcAmmExtractHdr(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *pdu, RlcAmHdr *amHdr, uint8_t *fByte) { - U8 snByte; - KwSn sn = 0; + uint8_t snByte; + RlcSn sn = 0; MsgLen pduSz; - KwExtHdr hdrInfo; - - TRC2(kwAmmExtractHdr) + RlcExtHdr hdrInfo; - - KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr)); + RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr)); /* Extract fixed part of the header */ - SFndLenMsg(pdu,&pduSz); - SRemPreMsg(fByte, pdu); - amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT; - if (KW_CNTRL_PDU == amHdr->dc) + ODU_GET_MSG_LEN(pdu,&pduSz); + ODU_REM_PRE_MSG(fByte, pdu); + amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT; + if (RLC_CNTRL_PDU == amHdr->dc) { //printf ("++++++++++++ 5GNRLOG HDR extracted CTRL : \n"); - RETVALUE(ROK); + return ROK; } - amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT; + amHdr->p = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT; - amHdr->si = (*fByte & KW_SI_POS) >> KW_SI_SHT; + amHdr->si = (*fByte & RLC_SI_POS) >> RLC_SI_SHT; /* 12 BIT SN */ - if (rbCb->m.amUl.snLen == KW_AM_CFG_12BIT_SN_LEN) + if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN) { - SRemPreMsg(&snByte, pdu); - sn = (KwSn)(((*fByte & KW_SN_POS_12BIT) << KW_BYTE_LEN ) | snByte); + ODU_REM_PRE_MSG(&snByte, pdu); + sn = (RlcSn)(((*fByte & RLC_SN_POS_12BIT) << RLC_BYTE_LEN ) | snByte); amHdr->sn = sn; } - else if (rbCb->m.amUl.snLen == KW_AM_CFG_18BIT_SN_LEN) + else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN) { - SRemPreMsg(&snByte, pdu); - sn = (KwSn)(((*fByte & KW_SN_POS_18BIT) << KW_BYTE_LEN ) | snByte); + ODU_REM_PRE_MSG(&snByte, pdu); + sn = (RlcSn)(((*fByte & RLC_SN_POS_18BIT) << RLC_BYTE_LEN ) | snByte); - SRemPreMsg(&snByte, pdu); - sn = ((sn << KW_BYTE_LEN) | snByte); + ODU_REM_PRE_MSG(&snByte, pdu); + sn = ((sn << RLC_BYTE_LEN) | snByte); amHdr->sn = sn; } if ((amHdr->si != 0) && (amHdr->si != 0x01)) { - hdrInfo.len = KW_SO_LEN_5GNR; - kwAmmExtractElmnt(gCb, pdu, &hdrInfo); + hdrInfo.len = RLC_SO_LEN_5GNR; + rlcAmmExtractElmnt(gCb, pdu, &hdrInfo); amHdr->so = hdrInfo.val; pduSz -= 2; } - //printf ("++++++++++++ 5GNRLOG HDR extracted DATA : sn %d \n", sn); - RETVALUE(ROK); + return ROK; } #ifdef OLD @@ -984,83 +841,66 @@ U8 *fByte; * -# RFAILED * */ -#ifdef ANSI -PRIVATE S16 kwAmmExtractHdrOld -( -KwCb *gCb, -Buffer *pdu, -KwAmHdr *amHdr, -U8 *fByte -) -#else -PRIVATE S16 kwAmmExtractHdrOld(gCb, pdu, amHdr, fByte) -KwCb *gCb; -Buffer *pdu; -KwAmHdr *amHdr; -U8 *fByte; -#endif +static S16 rlcAmmExtractHdrOld(RlcCb *gCb,Buffer *pdu,RlcAmHdr *amHdr,uint8_t *fByte) { - U8 e; - U8 snByte; - U16 sn; + uint8_t e; + uint8_t snByte; + uint16_t sn; MsgLen pduSz; MsgLen totalSz = 0; - KwExtHdr hdrInfo; + RlcExtHdr hdrInfo; - TRC2(kwAmmExtractHdrOld) - - - KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr)); + RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr)); /* Extract fixed part of the header */ SFndLenMsg(pdu,&pduSz); SRemPreMsg(fByte, pdu); - amHdr->dc = (*fByte & KW_DC_POS) >> KW_DC_SHT; - if (KW_CNTRL_PDU == amHdr->dc) + amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT; + if (RLC_CNTRL_PDU == amHdr->dc) { - RETVALUE(ROK); + return ROK; } /* kw002.201 : Changed the extraction of hdr elements to avoid */ /* function calls */ - amHdr->rf = (*fByte & KW_RF_POS) >> KW_RF_SHT; - amHdr->p = (*fByte & KW_POLL_POS) >> KW_POLL_SHT; - amHdr->fi = (*fByte & KW_FI_POS) >> KW_FI_SHT; - e = amHdr->e = (*fByte & KW_E_POS)>> KW_E_SHT; - + amHdr->rf = (*fByte & RLC_RF_POS) >> RLC_RF_SHT; + amHdr->p = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT; + amHdr->fi = (*fByte & RLC_FI_POS) >> RLC_FI_SHT; + e = amHdr->e = (*fByte & RLC_E_POS)>> RLC_E_SHT; + SRemPreMsg(&snByte, pdu); - sn = (U16)(((*fByte & KW_SN_POS) << KW_BYTE_LEN ) | snByte); + sn = (uint16_t)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte); amHdr->sn = sn; if (amHdr->rf == 1) { /* Extract extn part of the header */ - hdrInfo.len = KW_LSF_LEN; - kwAmmExtractElmnt(gCb, pdu, &hdrInfo); - amHdr->lsf = (U8)hdrInfo.val; + hdrInfo.len = RLC_LSF_LEN; + rlcAmmExtractElmnt(gCb, pdu, &hdrInfo); + amHdr->lsf = (uint8_t)hdrInfo.val; - hdrInfo.len = KW_SO_LEN; - kwAmmExtractElmnt(gCb, pdu, &hdrInfo); + hdrInfo.len = RLC_SO_LEN; + rlcAmmExtractElmnt(gCb, pdu, &hdrInfo); amHdr->so = hdrInfo.val; pduSz -= 2; } amHdr->numLi = 0; /* Extract LIs */ - while (e && (amHdr->numLi < KW_MAX_UL_LI)) + while (e && (amHdr->numLi < RLC_MAX_UL_LI)) { - hdrInfo.len = KW_E_LEN; - kwAmmExtractElmnt(gCb, pdu, &hdrInfo); - e = amHdr->e = (U8)hdrInfo.val; + hdrInfo.len = RLC_E_LEN; + rlcAmmExtractElmnt(gCb, pdu, &hdrInfo); + e = amHdr->e = (uint8_t)hdrInfo.val; /* Extract LI value*/ - hdrInfo.len = KW_LI_LEN; - kwAmmExtractElmnt(gCb, pdu, &hdrInfo); + hdrInfo.len = RLC_LI_LEN; + rlcAmmExtractElmnt(gCb, pdu, &hdrInfo); /* li = hdrInfo.val;*/ /* check if LI is zero */ if (! hdrInfo.val) { RLOG0(L_ERROR, "Received LI as 0"); - RETVALUE(RFAILED); + return RFAILED; } /* store the extracted LI value */ @@ -1068,12 +908,12 @@ U8 *fByte; totalSz += hdrInfo.val; /* incrment the size by LI value */ } - /*ccpu00122597:PDU is dropped if liCnt exceeds KW_MAX_LI*/ - if(e && (amHdr->numLi >= KW_MAX_UL_LI)) + /*ccpu00122597:PDU is dropped if liCnt exceeds RLC_MAX_LI*/ + if(e && (amHdr->numLi >= RLC_MAX_UL_LI)) { RLOG2(L_ERROR,"LI Count [%u] exceeds Max LI Count[%u]", - amHdr->numLi, KW_MAX_UL_LI); - RETVALUE(RFAILED); + amHdr->numLi, RLC_MAX_UL_LI); + return RFAILED; } /* first 2 bytes + Add one for Odd LI*/ @@ -1083,10 +923,10 @@ U8 *fByte; { RLOG3(L_ERROR,"SN [%d]:Corrupted PDU as TotSz[%lu] PduSz[%lu] ", amHdr->sn, totalSz, pduSz); - RETVALUE(RFAILED); + return RFAILED; } - RETVALUE(ROK); + return ROK; } #endif @@ -1094,11 +934,11 @@ U8 *fByte; * @brief Private handler to process the status PDU * * @details - * Private handler invokded by kwAmmProcessPdus to process the + * Private handler invokded by rlcAmmProcessPdus to process the * control PDU (status report) received from its peer RLC entity. * * - Decode the values from the received control pdu - * - Create a KwUdxStaPdu structure, copy the values onto it and + * - Create a RlcUdxStaPdu structure, copy the values onto it and * send it to the DL instance for further processing * * @param[in] gCb RLC instance control block @@ -1109,36 +949,19 @@ U8 *fByte; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmUlHndlStatusPdu -( -KwCb *gCb, -KwUlRbCb *rbCb, -Buffer *cntrlPdu, -U8 *fByte -) -#else -PRIVATE Void kwAmmUlHndlStatusPdu(gCb, rbCb, cntrlPdu, fByte) -KwCb *gCb; -KwUlRbCb *rbCb; -Buffer *cntrlPdu; -U8 *fByte; -#endif +static void rlcAmmUlHndlStatusPdu(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *cntrlPdu, uint8_t *fByte) { - U8 e1; - KwExtHdr hdrInfo; - KwUdxStaPdu *pStaPdu; - KwUdxUlSapCb *sapCb; - U8 e3; /* NACK RANGE : 5GNR */ - U32 snLen; - U32 snRange; - U32 resrvdBitsAckSn=0; - U32 resrvdBitsNackSn=0; - - TRC2(kwAmmUlHndlStatusPdu) - - - KW_MEM_ZERO(&hdrInfo, sizeof(KwExtHdr)); + uint8_t e1; + RlcExtHdr hdrInfo; + RlcUdxStaPdu *pStaPdu; + RlcUdxUlSapCb *sapCb; + uint8_t e3; /* NACK RANGE : 5GNR */ + uint32_t snLen; + uint32_t snRange; + uint32_t resrvdBitsAckSn=0; + uint32_t resrvdBitsNackSn=0; + + RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr)); /* Extract the Control PDU */ hdrInfo.hdr = (*fByte << 1); @@ -1147,120 +970,111 @@ U8 *fByte; /* D/C has been shifted in the calling function */ if (hdrInfo.hdr & 0xE0) { - RLOG_ARG2(L_ERROR,DBG_RBID,rbCb->rlcId.rbId, - "Reserved value for CPT received UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - - RETVOID; + DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: Reserved value for CPT received UEID:%d \ + CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); + return; } - sapCb = KW_GET_UDX_SAP(gCb); + sapCb = RLC_GET_UDX_SAP(gCb); - KW_ALLOC_SHRABL_BUF(sapCb->pst.region, + RLC_ALLOC_SHRABL_BUF(sapCb->pst.region, sapCb->pst.pool, pStaPdu, - sizeof(KwUdxStaPdu)); + sizeof(RlcUdxStaPdu)); #if (ERRCLASS & ERRCLS_ADD_RES) /* Memory allocation failure can not be expected */ if(!pStaPdu) { - RETVOID; + return; } #endif - if (rbCb->m.amUl.snLen == KW_AM_CFG_12BIT_SN_LEN) + if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN) { snLen = 12; - resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_12BITS; - resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_12BITS; + resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_12BITS; + resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_12BITS; } - else if (rbCb->m.amUl.snLen == KW_AM_CFG_18BIT_SN_LEN) + else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN) { snLen = 18; - resrvdBitsAckSn = KW_STA_PDU_R_BITS_ACKSN_18BITS; - resrvdBitsNackSn = KW_STA_PDU_R_BITS_NACKSN_18BITS; + resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_18BITS; + resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_18BITS; } else { - snLen = KW_SN_LEN; + snLen = RLC_SN_LEN; resrvdBitsAckSn = 0; resrvdBitsAckSn = 0; } pStaPdu->nackCnt = 0; /* For CPT */ - hdrInfo.hdr = hdrInfo.hdr << KW_CPT_LEN; + hdrInfo.hdr = hdrInfo.hdr << RLC_CPT_LEN; /* ACK Sn */ hdrInfo.len = snLen; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->ackSn = hdrInfo.val; //printf ("++++++++++++ 5GNRLOG HNDL STATUS acksn %d : \n", pStaPdu->ackSn); /* Check if NACK Exists */ - hdrInfo.len = KW_E1_LEN; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); - e1 = (U8)hdrInfo.val; - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d", - pStaPdu->ackSn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + hdrInfo.len = RLC_E1_LEN; + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + e1 = (uint8_t)hdrInfo.val; + DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d", + pStaPdu->ackSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); /* Extract the Reserved Bits after ACK SN field */ hdrInfo.len = resrvdBitsAckSn; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); /* If NACK exists in control PDU */ /* For ACKs and NACKs */ - while (e1 && (pStaPdu->nackCnt < KW_MAX_NACK_CNT)) + while (e1 && (pStaPdu->nackCnt < RLC_MAX_NACK_CNT)) { hdrInfo.len = snLen; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->nackInfo[pStaPdu->nackCnt].sn = hdrInfo.val; - hdrInfo.len = KW_E1_LEN; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); - e1 = (U8)hdrInfo.val; + hdrInfo.len = RLC_E1_LEN; + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + e1 = (uint8_t)hdrInfo.val; /* Extract e2 */ - /* hdrInfo.len = KW_E1_LEN; --> previusly stored value (for e1) is + /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is already present*/ - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); - /* e2 = (U8) hdrInfo.val;*/ + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + /* 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 = KW_E1_LEN; --> previusly stored value (for e1) is + /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is already present*/ - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); - e3 = (U8) hdrInfo.val; + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + e3 = (uint8_t) hdrInfo.val; /* Extract Reserved Bits after NACK SN */ hdrInfo.len = resrvdBitsNackSn; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); /* Test for resegmentation */ if (pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment) { - hdrInfo.len = KW_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */ - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + hdrInfo.len = RLC_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */ + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = hdrInfo.val; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd = hdrInfo.val; - RLOG_ARG4(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmUlHndlStatusPdu: soStart and soEnd = %d %d" - "UEID:%d CELLID:%d", - pStaPdu->nackInfo[pStaPdu->nackCnt].soStart, - pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d" + "UEID:%d CELLID:%d", pStaPdu->nackInfo[pStaPdu->nackCnt].soStart, + pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd, rbCb->rlcId.ueId, + rbCb->rlcId.cellId); } else { @@ -1273,9 +1087,9 @@ U8 *fByte; if (e3) { /* Extract NACK range field */ - hdrInfo.len = KW_NACK_RANGE_LEN; - kwAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); - snRange = (U8)hdrInfo.val; + hdrInfo.len = RLC_NACK_RANGE_LEN; + rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo); + snRange = (uint8_t)hdrInfo.val; pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange; @@ -1288,23 +1102,23 @@ U8 *fByte; /* In case we have reached the MAX NACK CNT, then we should modify the ACK_SN to the last NACK SN + 1 and discard the original ACK_SN*/ - if(pStaPdu->nackCnt == KW_MAX_NACK_CNT) + if(pStaPdu->nackCnt == RLC_MAX_NACK_CNT) { - pStaPdu->ackSn = (pStaPdu->nackInfo[KW_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask); + pStaPdu->ackSn = (pStaPdu->nackInfo[RLC_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask); } /* Parse & send Status PDU to RLC-DL */ - KwUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu); + rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu); - RETVOID; + return; } /** * @brief Private handler to release all stored segments * * @details - * Private handler invokded by kwAmmUlPlacePduInRecBuf to release the + * Private handler invokded by rlcAmmUlPlacePduInRecBuf to release the * stored segements in case a complete PDU is received later. * * @param[in] gCb RLC instance control block @@ -1313,39 +1127,27 @@ U8 *fByte; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmUlRlsAllSegs -( -KwCb *gCb, -KwAmRecBuf *recBuf -) -#else -PRIVATE Void kwAmmUlRlsAllSegs(gCb,recBuf) -KwCb *gCb; -KwAmRecBuf *recBuf; -#endif +static void rlcAmmUlRlsAllSegs(RlcCb *gCb, RlcAmRecBuf *recBuf) { - KwSeg *seg; - - TRC2(kwAmmUlRlsAllSegs) + RlcSeg *seg; - KW_LLIST_FIRST_SEG(recBuf->segLst, seg); + RLC_LLIST_FIRST_SEG(recBuf->segLst, seg); while (seg != NULLP) { - KW_FREE_BUF_WC(seg->seg); + ODU_PUT_MSG_BUF(seg->seg); cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt)); - KW_FREE_WC(gCb,seg, sizeof(KwSeg)); - KW_LLIST_FIRST_SEG(recBuf->segLst, seg); + RLC_FREE(gCb,seg, sizeof(RlcSeg)); + RLC_LLIST_FIRST_SEG(recBuf->segLst, seg); } - RETVOID; + return; } /** * @brief Private handler to store the received segment * * @details - * Private handler invokded by kwAmmUlPlacePduInRecBuf to add a received + * Private handler invokded by rlcAmmUlPlacePduInRecBuf to add a received * segment in reception buffer of a RBCB. * - It is responsible for detecting duplicate segments * - Adding it at appropriate position in the received buffer @@ -1361,69 +1163,49 @@ KwAmRecBuf *recBuf; * -#TRUE Successful insertion into the receiver buffer * -#FALSE Possibly a duplicate segment */ -#ifdef ANSI -PRIVATE Bool kwAmmAddRcvdSeg -( -KwCb *gCb, -KwUlRbCb *rbCb, -KwAmHdr *amHdr, -Buffer *pdu, -U16 pduSz -) -#else -PRIVATE Bool kwAmmAddRcvdSeg(gCb, rbCb, amHdr, pdu, pduSz) -KwCb *gCb; -KwUlRbCb *rbCb; -KwAmHdr *amHdr; -Buffer *pdu; -U16 pduSz; -#endif +static bool rlcAmmAddRcvdSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu, uint16_t pduSz) { - KwAmRecBuf *recBuf = NULLP; - KwSeg *seg; - KwSeg *tseg; - U16 soEnd; /* Holds the SoEnd of received segment */ - U16 expSo = 0; /* Expected SO */ - - TRC2(kwAmmAddRcvdSeg) + RlcAmRecBuf *recBuf = NULLP; + RlcSeg *seg; + RlcSeg *tseg; + uint16_t soEnd; /* Holds the SoEnd of received segment */ + uint16_t expSo = 0; /* Expected SO */ soEnd = amHdr->so + pduSz - 1; - recBuf = kwUtlGetRecBuf(AMUL.recBufLst, amHdr->sn); + recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, amHdr->sn); if (NULLP == recBuf) { - KW_ALLOC(gCb,recBuf, sizeof(KwAmRecBuf)); + RLC_ALLOC(gCb,recBuf, sizeof(RlcAmRecBuf)); #if (ERRCLASS & ERRCLS_ADD_RES) if (recBuf == NULLP) { - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } #endif /* ERRCLASS & ERRCLS_RES */ - kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn); + rlcUtlStoreRecBuf(RLC_AMUL.recBufLst, recBuf, amHdr->sn); } else { if (recBuf->allRcvd == TRUE) { - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } } recBuf->isDelvUpperLayer = FALSE; /* kw003.201 - Move past the segments that are different than the */ /* one received. */ - KW_LLIST_FIRST_SEG(recBuf->segLst, seg); + RLC_LLIST_FIRST_SEG(recBuf->segLst, seg); while ((seg != NULLP) && (seg->amHdr.so < amHdr->so)) { expSo = seg->amHdr.so + seg->segSz; - KW_LLIST_NEXT_SEG(recBuf->segLst, seg); + RLC_LLIST_NEXT_SEG(recBuf->segLst, seg); } /* The received segment should start after the end of previous seg */ @@ -1431,37 +1213,35 @@ U16 pduSz; { /* This is a duplicate segment */ gRlcStats.amRlcStats.numRlcAmCellDupPduRx++; - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } if ((seg) && (seg->amHdr.so <= soEnd)) { /* This is a duplicate segment */ gRlcStats.amRlcStats.numRlcAmCellDupPduRx++; - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } /* If we have come this far, we have to add this segment to the */ /* reception buffer as we either have eliminated duplicates or */ /* have found none. */ - KW_ALLOC_WC(gCb,tseg, sizeof(KwSeg)); + RLC_ALLOC_WC(gCb,tseg, sizeof(RlcSeg)); #if (ERRCLASS & ERRCLS_ADD_RES) if (tseg == NULLP) { - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } #endif /* ERRCLASS & ERRCLS_RES */ tseg->seg = pdu; tseg->segSz = pduSz; - KW_MEM_CPY(&tseg->amHdr, amHdr, sizeof(KwAmHdr)); + RLC_MEM_CPY(&tseg->amHdr, amHdr, sizeof(RlcAmHdr)); recBuf->amHdr.si = amHdr->si; recBuf->amHdr.sn = amHdr->sn; tseg->soEnd = soEnd; @@ -1475,9 +1255,9 @@ U16 pduSz; cmLListInsCrnt(&recBuf->segLst, &tseg->lstEnt); } tseg->lstEnt.node = (PTR)tseg; - kwAmmUpdExpByteSeg(gCb,&AMUL,tseg); + rlcAmmUpdExpByteSeg(gCb,&RLC_AMUL,tseg); - RETVALUE(TRUE); + return TRUE; } /** @@ -1498,96 +1278,73 @@ U16 pduSz; * -# FALSE * */ -#ifdef ANSI -PRIVATE Bool kwAmmUlPlacePduInRecBuf -( -KwCb *gCb, -Buffer *pdu, -KwUlRbCb *rbCb, -KwAmHdr *amHdr -) -#else -PRIVATE Bool kwAmmUlPlacePduInRecBuf(gCb, pdu, rbCb, amHdr) -KwCb *gCb; -Buffer *pdu; -KwUlRbCb *rbCb; -KwAmHdr *amHdr; -#endif +static bool rlcAmmUlPlacePduInRecBuf(RlcCb *gCb, Buffer *pdu, RlcUlRbCb *rbCb, RlcAmHdr *amHdr) { - KwSn sn; + RlcSn sn; MsgLen pduSz; - KwAmUl *amUl = &(rbCb->m.amUl); - - TRC2(kwAmmUlPlacePduInRecBuf) - + RlcAmUl *amUl = &(rbCb->m.amUl); sn = amHdr->sn; SFndLenMsg(pdu, &pduSz); gCb->genSts.bytesRecv += pduSz; gRlcStats.amRlcStats.numRlcAmCellSduBytesRx += pduSz; - if (!KW_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl)) + if (!RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl)) { gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx++; - RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmUlPlacePduInRecBuf: SN %d outside the window" - "UEID:%d CELLID:%d", - sn, - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: SN %d outside the window" + "UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId); gCb->genSts.unexpPdusRecv++; - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } if (amHdr->si == 0) { - KwAmRecBuf *recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn); + RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn); /* We received a complete PDU. Either we already have it, in which */ /* case we just ignore the new PDU and discard it. Otherwise, */ /* store the received PDU in the reception buffer */ if (NULLP == recBuf) { - KW_ALLOC(gCb, recBuf, sizeof(KwAmRecBuf)); + RLC_ALLOC(gCb, recBuf, sizeof(RlcAmRecBuf)); #if (ERRCLASS & ERRCLS_ADD_RES) if (recBuf == NULLP) { - RLOG_ARG2(L_FATAL,DBG_RBID,rbCb->rlcId.rbId, - "Memory allocation failed UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: Memory allocation failed \ + UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } #endif /* ERRCLASS & ERRCLS_RES */ - kwUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn); + rlcUtlStoreRecBuf(RLC_AMUL.recBufLst, recBuf, sn); } else if (recBuf->allRcvd != TRUE) { - kwAmmUlRlsAllSegs(gCb,recBuf); + rlcAmmUlRlsAllSegs(gCb,recBuf); } else { gRlcStats.amRlcStats.numRlcAmCellDupPduRx++; gCb->genSts.unexpPdusRecv++; - KW_FREE_BUF(pdu); - RETVALUE(FALSE); + ODU_PUT_MSG_BUF(pdu); + return FALSE; } recBuf->isDelvUpperLayer = FALSE; recBuf->pdu = pdu; recBuf->pduSz = pduSz; recBuf->allRcvd = TRUE; gRlcStats.amRlcStats.numRlcAmCellSduRx++; - KW_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(KwAmHdr)); - RETVALUE(TRUE); + RLC_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(RlcAmHdr)); + return TRUE; } else { /* We received a segment. We need to add that to the existing */ /* segments, if any. */ - RETVALUE(kwAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz)); + return (rlcAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz)); } } @@ -1595,7 +1352,7 @@ KwAmHdr *amHdr; * @brief Private handler to trigger status report * * @details - * Private handler invokded by kwAmmProcessPdus to check if the + * Private handler invokded by rlcAmmProcessPdus to check if the * status report need to be sent, and update the status trigger * flag accordingly based on status prohibit timer. * @@ -1614,30 +1371,13 @@ KwAmHdr *amHdr; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmTriggerStatus -( -KwCb *gCb, -KwUlRbCb *rbCb, -KwSn sn, -Bool discFlg -) -#else -PRIVATE Void kwAmmTriggerStatus(gCb,rbCb, sn, discFlg) -KwCb *gCb; -KwUlRbCb *rbCb; -KwSn sn; -Bool discFlg; -#endif +static void rlcAmmTriggerStatus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcSn sn, bool discFlg) { - Bool tmrRunning; - KwSn tSn; - KwSn tVrMr; - KwSn trxHighestStatus; - KwAmUl *amUl = &(rbCb->m.amUl); - - TRC2(kwAmmTriggerStatus) - + bool tmrRunning; + RlcSn tSn; + RlcSn tVrMr; + RlcSn trxHighestStatus; + RlcAmUl *amUl = &(rbCb->m.amUl); MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask); MODAMR(amUl->rxHighestStatus, trxHighestStatus, amUl->rxNext, amUl->snModMask); @@ -1647,16 +1387,14 @@ Bool discFlg; * The "=" in the 2nd condition is removed */ if ((discFlg) || (tSn < trxHighestStatus) || (tSn >= tVrMr)) { - RLOG_ARG2(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId, - "kwAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d", - rbCb->rlcId.ueId, - rbCb->rlcId.cellId); + DU_LOG("\nRLC: rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d", + rbCb->rlcId.ueId, rbCb->rlcId.cellId); amUl->staTrg = TRUE; amUl->gatherStaPduInfo = FALSE; /* Check if staProhTmr is running */ - tmrRunning = kwChkTmr(gCb,(PTR) rbCb, KW_EVT_AMUL_STA_PROH_TMR); + tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, EVENT_RLC_AMUL_STA_PROH_TMR); if (!tmrRunning) { @@ -1664,7 +1402,7 @@ Bool discFlg; } } - RETVOID; + return; } /** @@ -1685,62 +1423,46 @@ Bool discFlg; * @return Void * */ -#ifdef ANSI -PRIVATE Void kwAmmProcPduOrSeg -( -KwCb *gCb, -KwUlRbCb *rbCb, -KwAmHdr *amHdr, -Buffer *pdu -) -#else -PRIVATE Void kwAmmProcPduOrSeg(gCb, rbCb, amHdr, pdu) -KwCb *gCb; -KwUlRbCb *rbCb; -KwAmHdr *amHdr; -Buffer *pdu; -#endif +static void rlcAmmProcPduOrSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu) { - TRC2(kwAmmProcPduOrSeg) - - if ((AMUL.expSn != amHdr->sn) || (AMUL.expSo != amHdr->so)) + if ((RLC_AMUL.expSn != amHdr->sn) || (RLC_AMUL.expSo != amHdr->so)) { /* Release the existing partial SDU as we have PDUs or */ /* segments that are out of sequence */ rbCb->m.amUl.isOutOfSeq = TRUE; - KW_FREE_BUF(AMUL.partialSdu); + ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu); } - //if (amHdr->fi & KW_FI_FIRST_SEG) + //if (amHdr->fi & RLC_FI_FIRST_SEG) if (amHdr->si == 0x01) {/* first Segment of the SDU */ - if (AMUL.partialSdu != NULLP) + if (RLC_AMUL.partialSdu != NULLP) { /* Some old SDU may be present */ - KW_FREE_BUF_WC(AMUL.partialSdu); + ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu); } - AMUL.partialSdu = pdu; + RLC_AMUL.partialSdu = pdu; pdu = NULLP; } else if(amHdr->si == 0x03) {/* Middle or last segment of the SUD */ - SCatMsg(AMUL.partialSdu,pdu, M1M2); - KW_FREE_BUF_WC(pdu); + ODU_CAT_MSG(RLC_AMUL.partialSdu,pdu, M1M2); + ODU_PUT_MSG_BUF(pdu); pdu = NULLP; } else if (amHdr->si == 0x02) { - SCatMsg(pdu,AMUL.partialSdu,M2M1); - KW_FREE_BUF_WC(AMUL.partialSdu); + ODU_CAT_MSG(pdu,RLC_AMUL.partialSdu,M2M1); + ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu); } if (pdu != NULLP) { - AMUL.partialSdu = NULLP; - kwUtlSndDatInd(gCb,rbCb, pdu); + RLC_AMUL.partialSdu = NULLP; + rlcUtlSendUlDataToDu(gCb,rbCb, pdu); } - RETVOID; + return; } /** @@ -1748,7 +1470,7 @@ Buffer *pdu; * @brief Private handler to reassemble SDUs * * @details - * Private handler invokded by kwAmmProcessPdus with the PDU + * Private handler invokded by rlcAmmProcessPdus with the PDU * from the reception buffer in sequence to reassemble SDUs and * send it to PDCP. * @@ -1763,54 +1485,41 @@ Buffer *pdu; * -# RFAILED * */ -#ifdef ANSI -PRIVATE S16 kwAmmUlReassembleSdus -( -KwCb *gCb, -KwUlRbCb *rbCb, -KwAmRecBuf *recBuf -) -#else -PRIVATE S16 kwAmmUlReassembleSdus(gCb, rbCb, recBuf) -KwCb *gCb; -KwUlRbCb *rbCb; -KwAmRecBuf *recBuf; -#endif +static uint8_t rlcAmmUlReassembleSdus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmRecBuf *recBuf) { - KwSeg *seg; + RlcSeg *seg; - TRC2(kwAmmUlReassembleSdus) //if (recBuf->amHdr.rf == 0) if (recBuf->amHdr.si == 0) { /* This is a PDU */ - kwAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu); + rlcAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu); /* Assign NULLP to recBuf->pdu as this PDU is sent to PDCP */ recBuf->pdu = NULLP; - AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */ - AMUL.expSo = 0; + RLC_AMUL.expSn = (recBuf->amHdr.sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */ + RLC_AMUL.expSo = 0; } else { /* This is a set of segments */ - KW_LLIST_FIRST_SEG(recBuf->segLst, seg); - AMUL.expSn = recBuf->amHdr.sn; - AMUL.expSo = 0; + RLC_LLIST_FIRST_SEG(recBuf->segLst, seg); + RLC_AMUL.expSn = recBuf->amHdr.sn; + RLC_AMUL.expSo = 0; while(seg) { - kwAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg); - AMUL.expSo = seg->soEnd + 1; + rlcAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg); + RLC_AMUL.expSo = seg->soEnd + 1; cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt)); - KW_FREE_WC(gCb, seg, sizeof(KwSeg)); + RLC_FREE(gCb, seg, sizeof(RlcSeg)); - KW_LLIST_FIRST_SEG(recBuf->segLst, seg); + RLC_LLIST_FIRST_SEG(recBuf->segLst, seg); } - AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */ - AMUL.expSo = 0; + RLC_AMUL.expSn = (recBuf->amHdr.sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */ + RLC_AMUL.expSo = 0; } - RETVALUE(ROK); + return ROK; } /** @@ -1824,98 +1533,81 @@ KwAmRecBuf *recBuf; * @return Void * */ -#ifdef ANSI -PUBLIC Void kwAmmUlReEstablish -( -KwCb *gCb, -CmLteRlcId rlcId, -Bool sendReEst, -KwUlRbCb *rbCb -) -#else -PUBLIC Void kwAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb) -KwCb *gCb; -CmLteRlcId rlcId; -Bool sendReEst; -KwUlRbCb *rbCb; -#endif +Void rlcAmmUlReEstablish(RlcCb *gCb,CmLteRlcId rlcId,Bool sendReEst,RlcUlRbCb *rbCb) { - KwSn sn; - KwSn mSn; - KwSn mVrMr; + RlcSn sn; + RlcSn mSn; + RlcSn mVrMr; #ifndef KW_PDCP - KwKwuSapCb *kwKwSap; + RlcKwuSapCb *rlcKwuSap; #endif - KwAmRecBuf *recBuf = NULLP; - - TRC2(kwAmmUlReEstablish); + RlcAmRecBuf *recBuf = NULLP; + sn = RLC_AMUL.rxNext; - sn = AMUL.rxNext; - - MODAMR(AMUL.vrMr, mVrMr, AMUL.rxNext, AMUL.snModMask); - MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask); + MODAMR(RLC_AMUL.vrMr, mVrMr, RLC_AMUL.rxNext, RLC_AMUL.snModMask); + MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask); /* Reassemble SDUs from PDUs with SN less than upper edge of the window */ while (mSn < mVrMr) { - recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn); + recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn); if (NULLP != recBuf) { if (recBuf->allRcvd == TRUE) { - kwAmmUlReassembleSdus(gCb,rbCb, recBuf); + rlcAmmUlReassembleSdus(gCb,rbCb, recBuf); } else { /* Remove PDU and segments */ if(recBuf->pdu) { - KW_FREE_BUF_WC(recBuf->pdu); + ODU_PUT_MSG_BUF(recBuf->pdu); } /* Release all the segments*/ - kwAmmUlRlsAllSegs(gCb,recBuf); + rlcAmmUlRlsAllSegs(gCb,recBuf); } - kwUtlDelRecBuf(AMUL.recBufLst, recBuf, gCb); + rlcUtlDelRecBuf(RLC_AMUL.recBufLst, recBuf, gCb); } - sn = (sn + 1) & (AMUL.snModMask); /* MOD 1024 */ - MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask); + sn = (sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */ + MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask); } /* Discard remaining PDUs and bytesegments in recBuf */ /* Stop all timers and reset variables */ - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_REORD_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_REORD_TMR)) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR); + rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR); } - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_STA_PROH_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_STA_PROH_TMR)) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR); - } - - AMUL.rxNext = 0; - AMUL.rxNextHighestRcvd = 0; - AMUL.rxNextStatusTrig = 0; - rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask); - AMUL.rxHighestStatus = 0; - AMUL.staTrg = FALSE; - AMUL.gatherStaPduInfo = FALSE; - AMUL.expSn = 0; - AMUL.expSo = 0; - if (AMUL.partialSdu != NULLP) + rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_STA_PROH_TMR); + } + + RLC_AMUL.rxNext = 0; + RLC_AMUL.rxNextHighestRcvd = 0; + RLC_AMUL.rxNextStatusTrig = 0; + rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask); + RLC_AMUL.rxHighestStatus = 0; + RLC_AMUL.staTrg = FALSE; + RLC_AMUL.gatherStaPduInfo = FALSE; + RLC_AMUL.expSn = 0; + RLC_AMUL.expSo = 0; + if (RLC_AMUL.partialSdu != NULLP) { - KW_FREE_BUF(AMUL.partialSdu); + ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu); } - kwKwSap = gCb->u.ulCb->kwuUlSap + KW_UI_PDCP; + rlcKwuSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP; if(sendReEst) { - KwUiKwuReEstCmpInd(&kwKwSap->pst, kwKwSap->suId, rlcId); + RlcUiKwuReEstCmpInd(&rlcKwuSap->pst, rlcKwuSap->suId, rlcId); rbCb->m.amUl.isOutOfSeq = FALSE; } - RETVOID; + return; } /** @@ -1931,36 +1623,23 @@ KwUlRbCb *rbCb; * */ -#ifdef ANSI -PUBLIC Void kwAmmReOrdTmrExp -( -KwCb *gCb, -KwUlRbCb *rbCb -) -#else -PUBLIC Void kwAmmReOrdTmrExp(rbCb) -KwCb *gCb; -KwUlRbCb *rbCb; -#endif +Void rlcAmmReOrdTmrExp(RlcCb *gCb,RlcUlRbCb *rbCb) { - KwAmUl *amUl = &(rbCb->m.amUl); - KwSn sn; - KwSn mSn; - KwSn mVrMr; - KwSn mrxHighestStatus; - KwSn mrxNextHighestRcvd; + RlcAmUl *amUl = &(rbCb->m.amUl); + RlcSn sn; + RlcSn mSn; + RlcSn mVrMr; + RlcSn mrxHighestStatus; + RlcSn mrxNextHighestRcvd; Bool tmrRunning = FALSE; - KwAmRecBuf *recBuf = NULLP; - - TRC2(kwAmmReOrdTmrExp); - + RlcAmRecBuf *recBuf = NULLP; /* Update rxHighestStatus */ sn = amUl->rxNextStatusTrig; MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask); MODAMR(amUl->vrMr, mVrMr, amUl->rxNext, amUl->snModMask); - recBuf = kwUtlGetRecBuf(AMUL.recBufLst, sn); + recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn); while (mSn < mVrMr) { @@ -1972,13 +1651,13 @@ KwUlRbCb *rbCb; amUl->gatherStaPduInfo = FALSE; /* Check if staProhTmr is running */ - tmrRunning = kwChkTmr(gCb,(PTR) rbCb, KW_EVT_AMUL_STA_PROH_TMR); + tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, EVENT_RLC_AMUL_STA_PROH_TMR); if (!tmrRunning) { gRlcStats.amRlcStats.numULReOrdTimerExpires++; amUl->gatherStaPduInfo = TRUE; - kwAmmUlAssembleCntrlInfo(gCb, rbCb); + rlcAmmUlAssembleCntrlInfo(gCb, rbCb); } break; @@ -1992,12 +1671,12 @@ KwUlRbCb *rbCb; MODAMR(amUl->rxHighestStatus, mrxHighestStatus, amUl->rxNext, amUl->snModMask); if (mrxNextHighestRcvd > mrxHighestStatus) { - kwStartTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR); + rlcStartTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR); amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd; } - RETVOID; -} /* kwAmmReOrdTmrExp */ + return; +} /* rlcAmmReOrdTmrExp */ /** * @brief Handler for status prohibit timer expiry @@ -2013,22 +1692,9 @@ KwUlRbCb *rbCb; * */ -#ifdef ANSI -PUBLIC Void kwAmmStaProTmrExp -( -KwCb *gCb, -KwUlRbCb *rbCb -) -#else -PUBLIC Void kwAmmStaProTmrExp(gCb, rbCb) -KwCb *gCb; -KwUlRbCb *rbCb; -#endif +Void rlcAmmStaProTmrExp(RlcCb *gCb,RlcUlRbCb *rbCb) { - KwAmUl *amUl = &(rbCb->m.amUl); - - TRC2(kwAmmStaProTmrExp); - + RlcAmUl *amUl = &(rbCb->m.amUl); amUl->gatherStaPduInfo = FALSE; @@ -2036,11 +1702,11 @@ KwUlRbCb *rbCb; { amUl->gatherStaPduInfo = TRUE; /* kw002.201 : Sending StaRsp after StaProhibit tmr expiry */ - kwAmmUlAssembleCntrlInfo(gCb,rbCb); + rlcAmmUlAssembleCntrlInfo(gCb,rbCb); } - RETVOID; -} /* kwAmmStaProTmrExp */ + return; +} /* rlcAmmStaProTmrExp */ /** * @brief Handler to extract an element of AM Header @@ -2055,43 +1721,29 @@ KwUlRbCb *rbCb; * */ -#ifdef ANSI -PRIVATE Void kwAmmExtractElmnt -( -KwCb *gCb, -Buffer *pdu, -KwExtHdr *hdrInfo -) -#else -PRIVATE Void kwAmmExtractElmnt(gCb, pdu, hdrInfo) -KwCb *gCb; -Buffer *pdu; -KwExtHdr *hdrInfo; -#endif +static void rlcAmmExtractElmnt(RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo) { - U8 hdr; - U8 pLen = hdrInfo->pLen; - U8 len = (U8)hdrInfo->len; - U32 val; - U8 tHdr; - U8 fLen; - U8 rLen; - /* U8 rLen1 = 0; */ - U16 tVal; - - TRC2(kwAmmExtractElmnt); + uint8_t hdr; + uint8_t pLen = hdrInfo->pLen; + uint8_t len = (uint8_t)hdrInfo->len; + uint32_t val; + uint8_t tHdr; + uint8_t fLen; + uint8_t rLen; + /* uint8_t rLen1 = 0; */ + uint16_t tVal; hdr = hdrInfo->hdr; if (pLen == 0) { - SRemPreMsg(&hdr, pdu); + ODU_REM_PRE_MSG(&hdr, pdu); pLen = 8; } tHdr = hdr; if (len <= 8) { - val = tHdr >> (KW_BYTE_LEN - (len)); + val = tHdr >> (RLC_BYTE_LEN - (len)); hdr = hdr << len; pLen -= len; } @@ -2099,31 +1751,31 @@ KwExtHdr *hdrInfo; { fLen = pLen; val = tHdr; - val = val >> (KW_BYTE_LEN - fLen); + val = val >> (RLC_BYTE_LEN - fLen); val = val << (len - fLen); rLen = len - fLen; - SRemPreMsg(&hdr, pdu); + ODU_REM_PRE_MSG(&hdr, pdu); tHdr = hdr; if (rLen <= 8) { - hdr = hdr >> (KW_BYTE_LEN - rLen); + hdr = hdr >> (RLC_BYTE_LEN - rLen); val = val | hdr; hdr = tHdr << rLen; - pLen = (KW_BYTE_LEN - rLen); + pLen = (RLC_BYTE_LEN - rLen); } else { - rLen = rLen - KW_BYTE_LEN; + rLen = rLen - RLC_BYTE_LEN; tVal = hdr; tVal = tVal << rLen; val = val | tVal; - SRemPreMsg(&hdr, pdu); + ODU_REM_PRE_MSG(&hdr, pdu); tHdr = hdr; - hdr = hdr >> (KW_BYTE_LEN - rLen); + hdr = hdr >> (RLC_BYTE_LEN - rLen); val = val | hdr; hdr = tHdr << rLen; - pLen = (KW_BYTE_LEN - rLen); + pLen = (RLC_BYTE_LEN - rLen); } } @@ -2131,7 +1783,7 @@ KwExtHdr *hdrInfo; hdrInfo->hdr = hdr; hdrInfo->val = val; - RETVOID; + return; } /** @@ -2152,32 +1804,17 @@ KwExtHdr *hdrInfo; * */ -#ifdef ANSI -PRIVATE Void kwAmmUpdExpByteSeg -( -KwCb *gCb, -KwAmUl *amUl, -KwSeg *seg -) -#else -PRIVATE Void kwAmmUpdExpByteSeg(gCb, amUl, seg) -KwCb *gCb; -KwAmUl *amUl; -KwSeg *seg; -#endif +static void rlcAmmUpdExpByteSeg(RlcCb *gCb, RlcAmUl *amUl, RlcSeg *seg) { - U16 newExpSo; /* The new expected SO */ - KwSn sn = seg->amHdr.sn; - Bool lstRcvd=FALSE; - KwAmRecBuf *recBuf = NULLP; + uint16_t newExpSo; /* The new expected SO */ + RlcSn sn = seg->amHdr.sn; + bool lstRcvd=FALSE; + RlcAmRecBuf *recBuf = NULLP; - TRC2(kwAmmUpdExpByteSeg); - - - recBuf = kwUtlGetRecBuf(amUl->recBufLst, sn); + recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn); if ((recBuf == NULLP) || (recBuf && (seg->amHdr.so != recBuf->expSo))) { - RETVOID; + return; } newExpSo = seg->soEnd + 1; @@ -2188,7 +1825,7 @@ KwSeg *seg; lstRcvd = TRUE; } /* kw003.201 - This should update seg with the one after newSeg */ - KW_LLIST_NEXT_SEG(recBuf->segLst, seg); + RLC_LLIST_NEXT_SEG(recBuf->segLst, seg); while(seg) { /* keep going ahead as long as the expectedSo match with the header so @@ -2202,12 +1839,12 @@ KwSeg *seg; newExpSo = seg->soEnd + 1; recBuf->expSo = newExpSo; //lstRcvd = seg->amHdr.lsf; - KW_LLIST_NEXT_SEG(recBuf->segLst, seg); + RLC_LLIST_NEXT_SEG(recBuf->segLst, seg); } else { recBuf->expSo = newExpSo; - RETVOID; + return; } } if (lstRcvd == TRUE) @@ -2216,7 +1853,7 @@ KwSeg *seg; gRlcStats.amRlcStats.numRlcAmCellSduRx++; } - RETVOID; + return; } /** @@ -2232,34 +1869,21 @@ KwSeg *seg; * * @return void */ -#ifdef ANSI -PUBLIC Void kwAmmFreeUlRbCb -( -KwCb *gCb, -KwUlRbCb *rbCb -) -#else -PUBLIC Void kwAmmFreeUlRbCb(gCb,rbCb) -KwCb *gCb; -KwUlRbCb *rbCb; -#endif +Void rlcAmmFreeUlRbCb(RlcCb *gCb,RlcUlRbCb *rbCb) { - KwSn curSn = 0; /* Sequence number of PDU */ - KwSn windSz; /* PDU window size */ - KwAmRecBuf *recBuf = NULLP; - - TRC2(kwAmmFreeUlRbCb) - + RlcSn curSn = 0; /* Sequence number of PDU */ + RlcSn windSz; /* PDU window size */ + RlcAmRecBuf *recBuf = NULLP; - windSz = (KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1; + windSz = (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1; - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_REORD_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_REORD_TMR)) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_REORD_TMR); + rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_REORD_TMR); } - if(TRUE == kwChkTmr(gCb,(PTR)rbCb,KW_EVT_AMUL_STA_PROH_TMR)) + if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,EVENT_RLC_AMUL_STA_PROH_TMR)) { - kwStopTmr(gCb,(PTR)rbCb, KW_EVT_AMUL_STA_PROH_TMR); + rlcStopTmr(gCb,(PTR)rbCb, EVENT_RLC_AMUL_STA_PROH_TMR); } @@ -2267,31 +1891,31 @@ KwUlRbCb *rbCb; while( ( curSn < windSz ) hence changing to do while */ do { - recBuf = kwUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn); + recBuf = rlcUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn); if ( recBuf != NULLP ) { if (recBuf->pdu != NULLP) { - KW_FREE_BUF_WC(recBuf->pdu); + ODU_PUT_MSG_BUF(recBuf->pdu); } /* Release all the segments */ - kwAmmUlRlsAllSegs(gCb,recBuf); - kwUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb); + rlcAmmUlRlsAllSegs(gCb,recBuf); + rlcUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb); } curSn++; }while ( curSn < windSz ); #ifndef LTE_TDD - KW_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp))); + RLC_FREE(gCb,rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp))); rbCb->m.amUl.recBufLst = NULLP; #endif if(rbCb->m.amUl.partialSdu != NULLP) { - KW_FREE_BUF_WC(rbCb->m.amUl.partialSdu); + ODU_PUT_MSG_BUF(rbCb->m.amUl.partialSdu); } - RETVOID; -} /* kwAmmFreeUlRbCb */ + return; +} /* rlcAmmFreeUlRbCb */ /*@}*/