src/5gnrrlc/kw_amm_ul.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /********************************************************************20**
  20
  21         Name:    RLC - AM module file
  22
  23         Type:    C source file
  24
  25         Desc:    Source code for Acknowledged Mode Module functions such as,
  26
  27                  Transmission of data/control PDUs
  28                  Retransmission (Feedback in terms of status)
  29                  Polling
  30                  Assemble SDUs
  31                  Reception - reordering
  32                  Duplicate detection for byte segments
  33                  Reassemble SDUs
  34
  35         File:    kw_amm_ul.c
  36
  37 *********************************************************************21*/
  38 static const char* RLOG_MODULE_NAME="AMM";
  39 static int RLOG_MODULE_ID=2048;
  40 static int RLOG_FILE_ID=190;
  41
  42 /* header include files (.h) */
  43 #include "common_def.h"
  44 #include "lkw.h"           /* LKW defines */
  45 #include "ckw.h"           /* CKW defines */
  46 #include "kwu.h"           /* KWU defines */
  47 #include "rgu.h"           /* RGU defines */
  48 #include "kw_udx.h"
  49 #include "kw_err.h"        /* Err defines */
  50 #include "kw_env.h"        /* RLC environment options */
  51
  52 #include "kw.h"            /* RLC defines */
  53 #include "kw_ul.h"
  54
  55 /* extern (.x) include files */
  56 #include "lkw.x"           /* LKW */
  57 #include "ckw.x"           /* CKW */
  58 #include "kwu.x"           /* KWU */
  59 #include "rgu.x"           /* RGU */
  60
  61 #include "kw.x"
  62 #include "kw_ul.x"
  63 #include "kw_udx.x"
  64
  65 /* Variable for logging, declared in cl */
  66 #ifndef RGL_SPECIFIC_CHANGES
  67 #ifndef TENB_ACC
  68 #ifndef LTE_PAL_ENB
  69 uint32_t ulrate_rgu;
  70 #endif
  71 #endif
  72 #endif
  73 #ifndef RGL_SPECIFIC_CHANGES
  74 #ifndef TENB_ACC
  75 #ifndef TENB_T2K3K_SPECIFIC_CHANGES
  76 #ifndef LTE_PAL_ENB
  77 uint32_t isMemThreshReached(Region region);
  78 #endif
  79 #else
  80 #ifndef LTE_PAL_ENB
  81 uint32_t  isMemThreshReached(Region region);
  82 #endif
  83 #endif
  84 #endif
  85 #endif
  86 /** @file gp_amm_ul.c
  87 @brief RLC Acknowledged Mode Uplink Module
  88 **/
  89 #define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_UL) /* for debugging purpose */
  90
  91 /* private function declarations */
  92
  93 static void rlcAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
  94
  95 static uint8_t rlcAmmExtractHdr ARGS ((RlcCb *gCb,
  96                                 RlcUlRbCb   *rbCb,
  97                                 Buffer *pdu,
  98                                 RlcAmHdr *amHdr,
  99                                 uint8_t *fByte));
 100
 101 static bool rlcAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
 102                                      Buffer *pdu,
 103                                      RlcUlRbCb *rbCb,
 104                                      RlcAmHdr *amHdr));
 105
 106 static void rlcAmmTriggerStatus ARGS ((RlcCb *gCb,
 107                                 RlcUlRbCb *rbCb,
 108                                 RlcSn sn,
 109                                 bool discFlg));
 110
 111 static uint8_t  rlcAmmUlReassembleSdus ARGS ((RlcCb *gCb,
 112                                      RlcUlRbCb *rbCb,
 113                                      RlcAmRecBuf *recBuf));
 114
 115 static Void rlcAmmProcPduOrSeg ARGS ((RlcCb *gCb,
 116                                       RlcUlRbCb *rbCb,
 117                                       RlcAmHdr *amHdr,
 118                                       Buffer *pdu));
 119
 120 static Void rlcAmmUpdExpByteSeg ARGS ((RlcCb *gCb,RlcAmUl *amUl, RlcSeg* newSeg));
 121
 122 static Void rlcAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo));
 123
 124 static Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
 125                                          RlcUlRbCb *rbCb,
 126                                          Buffer *cntrlPdu,
 127                                          uint8_t *fByte));
 128
 129 /******************************************************************************
 130
 131   AM Module contains the following funcitons:
 132
 133   -  rlcAmmProcessSdus
 134      -  rlcAmmUlAssembleCntrlInfo
 135      -  rlcResegRetxPdus
 136      -  rlcAssembleSdus
 137      -  kwChkandSetPoll
 138   -  rlcAmmProcessPdus
 139      -  rlcAmmUlHndlStatusPdu
 140      -  rlcAmmTriggerStatus
 141      -  rlcAmmUlReassembleSdus
 142
 143 *******************************************************************************/
 144 /** @addtogroup ammode */
 145 /*@{*/
 146
 147 /**
 148  * @brief   Private function to fill NACK information in status Pdu as per 5GNR
 149  *
 150  * @param[in]   rbCb       Ul RbCb
 151  * @param[in]   sn         Sequence number of the PDU for which the NACK
 152  * @param[in]   isSegment  TRUE means NACK for segment; FALSE for PDU
 153  * @param[in]   soStart    SOStart
 154  * @param[in]   soEnd      SOEnd
 155  * @param[out]  statusPdu  status Pdu holder to be filled
 156  * @param[in]   prevNackSn It holds previous nack Sn
 157  *
 158  * @return  S16
 159  *    The number of bytes required to encode this NACK information
 160  *
 161  */
 162 static uint8_t rlcAmmUlSetNackInfo(RlcUlRbCb *rbCb, RlcSn sn, bool isSegment, \
 163    uint16_t soStart, uint16_t soEnd, RlcUdxDlStaPdu *statusPdu, RlcSn *prevNackSn)
 164 {
 165    RlcNackInfo   *nackInfo = (statusPdu->nackInfo + statusPdu->nackCount);
 166    uint16_t       sizeToBeEncd = 0; /* Status PDu size to be encoded */
 167
 168    /* In following cases we should increment the nackCnt & fill new NACK_SN info:
 169     *    1) First NACK_SN of the statusdPdu
 170     *    2) NACK_SN is not continuous with previous
 171     *    3) NACK_SN is same as previuos but segments are not continuous
 172     *    4) NACK_SN is continuous with previous but previous NACK_SN segments
 173     *       are not missing in sequence till end
 174     */
 175    if((*prevNackSn == 0xffffffff) || ((((*prevNackSn) + 1) & RLC_AMUL.snModMask) != sn) ||
 176          (((*prevNackSn) == sn) && (((nackInfo->soEnd + 1) != soStart))) ||
 177          ((nackInfo->isSegment) && (((*prevNackSn) + 1) == sn) && (nackInfo->soEnd != RLC_ALL_BYTES_MISSING)))
 178    {
 179       if(nackInfo->nackRange)
 180       {
 181          if((nackInfo->soEnd) && (!nackInfo->soStart))
 182          {
 183             /*First nack_sn of this nackRange not segmented but last is segmented */
 184             sizeToBeEncd = 5; /*32 for soStart and soEnd and 8 for nackRange */
 185          }
 186          else
 187          {
 188             /*First nack_sn of this nackRange was segmented */
 189             sizeToBeEncd = 1; /*8 for nackRange */
 190          }
 191       }
 192
 193       if(*prevNackSn != 0xffffffff)
 194       {
 195          /* Increment nackCount as this sn is continous */
 196          statusPdu->nackCount++;
 197          nackInfo = statusPdu->nackInfo + statusPdu->nackCount;
 198       }
 199
 200       nackInfo->sn = sn;
 201       nackInfo->isSegment = isSegment;
 202       nackInfo->soStart = soStart;
 203       nackInfo->soEnd   = soEnd;
 204       nackInfo->nackRange = 0;
 205
 206       if(isSegment)
 207       {
 208          sizeToBeEncd += ((RLC_AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
 209       }
 210       else
 211       {
 212          sizeToBeEncd += ((RLC_AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?2:3); /* NACK,E1,E2 */
 213       }
 214    }
 215    else
 216    {
 217       if(!(nackInfo->nackRange))
 218       {
 219          nackInfo->nackRange++;
 220       }
 221       /* This case means there are continuous SNs/Segments. If it is the next
 222        * Sn then increment nackRnage. if same SN but different segment then
 223        * dont increment nackRange */
 224       if((((*prevNackSn) + 1) & RLC_AMUL.snModMask) == sn)
 225       {
 226          nackInfo->nackRange++;
 227       }
 228
 229       /* If NackRange is reached to max value then increment statusPdu->nackCount*/
 230       if(nackInfo->nackRange == 255)
 231       {
 232          statusPdu->nackCount++;
 233          if(nackInfo->isSegment)
 234          {
 235             sizeToBeEncd = 1; /* return only nackRangeSize*/
 236          }
 237          else if (isSegment)
 238          {
 239             /* First SN was not segmented of this nackRange but last SN is segmented */
 240             sizeToBeEncd = 5; /* return size of soSatrt + soEnd + nackRnage */
 241          }
 242       }
 243
 244       if(isSegment)
 245       {
 246          nackInfo->isSegment = isSegment;
 247          nackInfo->soEnd = soEnd;
 248       }
 249       else if(nackInfo->isSegment)
 250       {
 251          nackInfo->soEnd = RLC_ALL_BYTES_MISSING;
 252       }
 253       else
 254       {
 255          nackInfo->soStart = 0;
 256          nackInfo->soEnd =   0;
 257       }
 258
 259    }
 260    *prevNackSn = sn;
 261
 262    return (sizeToBeEncd);
 263 }
 264
 265 /**
 266  * @brief   Private handler to gather information required to create the STATUS
 267  *          PDU
 268  *
 269  * @details
 270  *    Scans the reception buffer and copies information to the UdxDlStaPdu
 271  *    structure about SN's  and segments not yet received. This data is
 272  *    sent to the DL instance so that it can create an appropriate (depending
 273  *    on the grants from MAC) STATUS PDU and send it to MAC.
 274  *
 275  * @param[in]  gCb      RLC instance control block
 276  * @param[in]  rbCb     Uplink RB control block
 277  *
 278  * @return  Void
 279  *
 280  */
 281 static void rlcAmmUlAssembleCntrlInfo(RlcCb *gCb, RlcUlRbCb *rbCb)
 282 {
 283    RlcUdxDlStaPdu   *pStatusPdu;
 284    RlcNackInfo      *nackInfo;
 285    RlcSn            sn;                /* sequence number */
 286    RlcSn            mSn;               /* Mod val of sequence number */
 287    RlcSn            rxHighestStatus;              /* Mod val of rxHighestStatus */
 288    RlcSeg           *seg;              /* pdu segment */
 289    uint16_t         nackCnt = 0;       /* Index for staPdu */
 290    uint16_t         seqSo;             /* segmment offset */
 291    RlcUdxUlSapCb    *sapCb;
 292    uint16_t         staPduEncSize = 3; /* size that would be of the encoded
 293                                           STATUS PDU, it is in bits; 15 for
 294                                           first fixed part of STATUS PDU */
 295    RlcAmRecBuf      *recBuf = NULLP;
 296    RlcSn            prevNackSn = 0xffffffff;
 297
 298    sapCb = RLC_GET_UDX_SAP(gCb);
 299
 300    RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
 301                        sapCb->pst.pool,
 302                        pStatusPdu,
 303                        sizeof(RlcUdxDlStaPdu));
 304
 305 #if (ERRCLASS & ERRCLS_ADD_RES)
 306    /* Memory allocation failure can not be expected  */
 307    if(!pStatusPdu)
 308    {
 309      return;
 310    }
 311 #endif
 312
 313    sn = RLC_AMUL.rxNext;
 314    MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
 315    MODAMR(RLC_AMUL.rxHighestStatus, rxHighestStatus, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
 316
 317    recBuf =  rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
 318
 319    while (mSn < rxHighestStatus )
 320    {
 321       /* For missing PDUs */
 322       if ((NULLP  == recBuf) && nackCnt < RLC_MAX_NACK_CNT )
 323       {
 324          DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing PDU's SN = %d UEID:%d \
 325             CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 326          staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
 327                                              sn,
 328                                              FALSE, /* isSegment */
 329                                              0,     /* SOStart */
 330                                              0,     /* SOEnd */
 331                                              pStatusPdu,
 332                                              &prevNackSn);
 333       }
 334       else if (recBuf && (recBuf->pdu == NULLP) &&
 335                (recBuf->segLst.count > 0))
 336       {
 337          /* Scan through the byte segments of PDU and add this sn
 338             with soStart and soEnd info to staPdu */
 339
 340          seqSo  = 0;
 341          RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
 342          while (seg != NULLP && nackCnt < RLC_MAX_NACK_CNT)
 343          {
 344             /* For missing byte segments */
 345             if (seg->amHdr.so != seqSo)
 346             {
 347                staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
 348                                                    sn,
 349                                                    TRUE,
 350                                                    seqSo,
 351                                                    seg->amHdr.so - 1,
 352                                                    pStatusPdu,
 353                                                    &prevNackSn);
 354
 355                DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing byte segment's"
 356                   " SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 357                DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d \
 358                    UEID:%d CELLID:%d", seqSo, seg->amHdr.so - 1, rbCb->rlcId.ueId,
 359                    rbCb->rlcId.cellId);
 360             }
 361
 362             seqSo = seg->soEnd + 1;
 363             RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
 364          }
 365
 366          /* Check if the last segment is missing */
 367          RLC_LLIST_LAST_SEG(recBuf->segLst, seg);
 368          if ((seg != NULLP) &&
 369              (seg->amHdr.si != RLC_SI_LAST_SEG && nackCnt < RLC_MAX_NACK_CNT))
 370          {
 371             staPduEncSize += rlcAmmUlSetNackInfo(rbCb,
 372                                                 sn,
 373                                                 TRUE,
 374                                                 seqSo,
 375                                                 RLC_ALL_BYTES_MISSING,
 376                                                 pStatusPdu,
 377                                                 &prevNackSn);
 378
 379             DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Missing (last) byte "
 380                "segment's SN:%d UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId,
 381                rbCb->rlcId.cellId);
 382             DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: soStart and soEnd = %d, %d\
 383                UEID:%d CELLID:%d", seqSo, RLC_ALL_BYTES_MISSING, rbCb->rlcId.ueId,
 384                rbCb->rlcId.cellId);
 385          }
 386       }
 387
 388
 389       sn = (sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
 390       MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
 391
 392       /* Get the received Buffer the updated/next SN */
 393       recBuf =  rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
 394
 395       /* Find the next missing sequence number if nackCnt reaches maximum and
 396          still Reordering window has some missing AMDPDUs / AMDPDU segments. The
 397          next missing sequence number will be considered as the ack sequnece
 398          number in the status pdu.*/
 399       if((nackCnt == RLC_MAX_NACK_CNT) &&
 400           ((recBuf == NULLP) ||
 401             ((recBuf->pdu == NULLP) &&
 402              (recBuf->segLst.count > 0))))
 403       {
 404          break;
 405       }
 406    }
 407
 408    /*Unfortunately i have write below peice of code here because kwAmmsetNackInfo()
 409     * don't know that this is the last nackSn with nackRange*/
 410    nackInfo = &(pStatusPdu->nackInfo[pStatusPdu->nackCount]);
 411    if(nackInfo->nackRange)
 412    {
 413       if((nackInfo->soEnd) && (!nackInfo->soStart))
 414       {
 415          /*First nack_sn of this nackRange not segmented but last is segmented */
 416          staPduEncSize += 5; /*32 for soStart and soEnd and 8 for nackRange */
 417       }
 418       else
 419       {
 420          /*First nack_sn of this nackRange was segmented */
 421          staPduEncSize += 1; /*8 for nackRange */
 422       }
 423    }
 424    /* nackCount is used as an index to nackInfo array but in status Pdu it
 425     * should be equal to number nackInfo that are filled. hence incrementing by 1*/
 426    if(prevNackSn != 0xffffffff)
 427    {
 428       pStatusPdu->nackCount++;
 429    }
 430    /* Update ACK SN with the last sn for which feedback is not assembled */
 431    if ( mSn == rxHighestStatus)
 432    {
 433       pStatusPdu->ackSn = RLC_AMUL.rxHighestStatus;
 434    }
 435    else
 436    {
 437       pStatusPdu->ackSn = sn;
 438    }
 439
 440     DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: ACK PDU's SN = %d"
 441        "UEID:%d CELLID:%d", pStatusPdu->ackSn, rbCb->rlcId.ueId,
 442        rbCb->rlcId.cellId);
 443
 444    pStatusPdu->controlBo = staPduEncSize; /*Its already in bytes */
 445
 446    RLC_AMUL.staTrg = FALSE;
 447    RLC_AMUL.gatherStaPduInfo = FALSE;
 448
 449
 450    if (rlcUlUdxStaPduReq(&sapCb->pst,
 451                         sapCb->spId,
 452                         &rbCb->rlcId,
 453                         pStatusPdu) != ROK)
 454    {
 455       DU_LOG("\nRLC: rlcAmmUlAssembleCntrlInfo: Failed to Send Sta Pdu UEID:%d \
 456          CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 457       RLC_FREE_SHRABL_BUF_WC(sapCb->pst.region,
 458                             sapCb->pst.pool,
 459                             pStatusPdu,
 460                             sizeof(RlcUdxDlStaPdu));
 461    }
 462
 463    return;
 464 }
 465
 466 #ifdef XEON_SPECIFIC_CHANGES
 467 uint32_t  gRlcDatIndUL;
 468 #endif
 469
 470 #ifdef T2K_TRIGGER_RLC_REEST
 471 uint32_t drpRlcDrbPack;
 472 #endif
 473 /**
 474  * @brief Handler to process the PDUs received from MAC and send it to PDCP
 475  *
 476  * @details
 477  *    This function is invoked by UTL with the PDU(s) received from MAC.
 478  *    It reorders the received data PDUs and trigger status report as
 479  *    needed. Reassembles the SDUs in sequence and send it to PDCP.
 480  *    It also processes the control PDU
 481  *
 482  * @param[in]  gCb      RLC instance control block
 483  * @param[in]  rbCb     RB control block
 484  * @param[out] pduInfo  PDU Info received from MAC
 485  *
 486  *  @return Void
 487  *
 488  */
 489 #ifdef LTE_L2_MEAS
 490 void rlcAmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo, uint32_t ttiCnt)
 491 #else
 492 void rlcAmmProcessPdus(RlcCb *gCb, RlcUlRbCb *rbCb, KwPduInfo *pduInfo)
 493 #endif
 494 {
 495    Buffer    *pdu;
 496    RlcAmUl    *amUl;
 497    RlcAmHdr   amHdr;
 498    uint8_t    numPdu = 0;
 499    uint8_t    numPduToProcess;
 500    RlcSn      sn;
 501    RlcSn      tSn;
 502    RlcSn      mSn;
 503    uint8_t    fByte;
 504    bool      discFlg;
 505 #ifdef LTE_L2_MEAS_RLC
 506    MsgLen              rlcSduSz;  /*Holds length of Rlc Sdu*/
 507 #endif /* LTE_L2_MEAS */
 508
 509    amUl = &RLC_AMUL;
 510
 511    numPduToProcess = RLC_MIN(pduInfo->numPdu, RGU_MAX_PDU);
 512    DU_LOG("\nRLC : rlcAmmProcessPdus: numPdu[%d],numPduToProcess[%d] UEID:%d CELLID:%d",
 513             numPdu, numPduToProcess, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 514
 515    while (numPdu < numPduToProcess)
 516    {
 517       discFlg = FALSE;
 518       pdu = pduInfo->mBuf[numPdu++];
 519
 520       if (! pdu)
 521       {
 522
 523          DU_LOG("\nRLC : rlcAmmProcessPdus: Null Pdu UEID:%d CELLID:%d",
 524             rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 525          gCb->genSts.errorPdusRecv++;
 526          break;
 527       }
 528 #ifndef RGL_SPECIFIC_CHANGES
 529 #ifndef TENB_ACC
 530 #ifndef LTE_PAL_ENB
 531       MsgLen len;
 532       ODU_GET_MSG_LEN(pdu, &len);
 533       ulrate_rgu += len;
 534 #endif
 535 #endif
 536 #endif
 537       /* Extract AM PDU/SEG header Info */
 538       RLC_MEM_ZERO(&amHdr, sizeof(RlcAmHdr));
 539       /* Avoided the allocation of amHdr and sending
 540          a single pointer */
 541       if (rlcAmmExtractHdr(gCb, rbCb, pdu, &amHdr, &fByte) != ROK)
 542       {
 543          DU_LOG("\nRLC : rlcAmmProcessPdus: Header Extraction Failed UEID:%d CELLID:%d",
 544             rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 545          ODU_PUT_MSG_BUF(pdu);
 546          gCb->genSts.errorPdusRecv++;
 547          continue;
 548       }
 549       /* Check if its a control PDU */
 550       if (amHdr.dc == 0)
 551       {
 552          rlcAmmUlHndlStatusPdu(gCb, rbCb, pdu, &fByte);
 553          ODU_PUT_MSG_BUF(pdu);
 554          continue;
 555       }
 556       if((amHdr.si == RLC_SI_LAST_SEG) && (!amHdr.so))
 557       {
 558          DU_LOG("\nRLC: rlcAmmProcessPdus: Dropping PDU because SO can't be zero\
 559             for last segment sn:%u UEID:%d CELLID:%d", amHdr.sn, rbCb->rlcId.ueId,
 560             rbCb->rlcId.cellId);
 561          ODU_PUT_MSG_BUF(pdu);
 562          continue;
 563       }
 564 #ifndef RGL_SPECIFIC_CHANGES
 565 #ifdef LTE_TDD
 566 #ifndef TENB_ACC
 567 #ifndef TENB_T2K3K_SPECIFIC_CHANGES
 568 #ifndef LTE_PAL_ENB
 569     /* Changed the condition to TRUE from ROK  */
 570       if(isMemThreshReached(rlcCb[0]->init.region) == TRUE)
 571       {
 572          uint32_t rlculdrop;
 573          rlculdrop++;
 574          ODU_PUT_MSG_BUF(pdu);
 575          continue;
 576       }
 577 #endif
 578 #else
 579 #ifndef LTE_PAL_ENB
 580       /*ccpu00142274 - UL memory based flow control*/
 581       if(isMemThreshReached(rlcCb[0]->init.region) != ROK)
 582       {
 583          uint32_t rlculdrop;
 584          rlculdrop++;
 585          ODU_PUT_MSG_BUF(pdu);
 586          continue;
 587       }
 588 #endif
 589 #endif
 590 #endif
 591 #endif
 592 #endif
 593
 594 #ifdef T2K_TRIGGER_RLC_REEST
 595       if(drpRlcDrbPack > 1000)
 596       {
 597          if(rbCb->rlcId.rbType == CM_LTE_DRB)
 598          {
 599             ODU_PUT_MSG_BUF(pdu);
 600             continue;
 601          }
 602       }
 603       drpRlcDrbPack++;
 604 #endif
 605       /* Reordering data PDU */
 606       sn = amHdr.sn;
 607       if (rlcAmmUlPlacePduInRecBuf(gCb,pdu, rbCb, &amHdr) == TRUE)
 608       {
 609          RlcAmRecBuf      *recBuf;
 610          bool   tmrRunning;
 611          RlcSn   tVrMr;
 612          RlcSn   mrxNextHighestRcvd;
 613
 614 #ifdef LTE_L2_MEAS
 615          rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt);
 616 #endif /* LTE_L2_MEAS */
 617
 618          /* Update rxNextHighestRcvd */
 619          MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
 620          MODAMR(amUl->rxNextHighestRcvd, mrxNextHighestRcvd, amUl->rxNext, amUl->snModMask);
 621          if (mSn >= mrxNextHighestRcvd)
 622          {
 623             amUl->rxNextHighestRcvd = ((sn + 1) & (amUl->snModMask));
 624
 625             DU_LOG("\nRLC: rlcAmmProcessPdus: Updated rxNextHighestRcvd = %d UEID:%d CELLID:%d",
 626                amUl->rxNextHighestRcvd, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 627          }
 628
 629          recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
 630          if ((NULLP != recBuf) && ( recBuf->allRcvd))
 631          {
 632             /* deliver the reassembled RLC SDU to upper layer,
 633                But not removed from the table */
 634             rlcAmmUlReassembleSdus(gCb, rbCb, recBuf);
 635             recBuf->isDelvUpperLayer = TRUE;
 636
 637             MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
 638
 639             /* Update rxHighestStatus */
 640             if (sn == amUl->rxHighestStatus)
 641             {
 642                tSn = (sn + 1) & (amUl->snModMask) ; /* MOD (2 Pwr SN LEN- 1) */
 643
 644                recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
 645                /* Scan through till the upper edge of the window */
 646                MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask);
 647                while (mSn <= tVrMr)
 648                {
 649                   if ((NULLP == recBuf) || (!recBuf->allRcvd))
 650                   {
 651                      RLOG_ARG3(L_UNUSED,DBG_RBID,rbCb->rlcId.rbId,
 652                            "rlcAmmProcessPdus: Updated rxHighestStatus:%d "
 653                            "UEID:%d CELLID:%d",
 654                            tSn,
 655                            rbCb->rlcId.ueId,
 656                            rbCb->rlcId.cellId);
 657
 658                      amUl->rxHighestStatus = tSn;
 659                      break;
 660                   }
 661                   tSn = (tSn + 1) & (amUl->snModMask); /* MOD (2 Pwr SN LEN- 1) */
 662                   recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
 663                   mSn++;
 664                }
 665             }
 666
 667
 668             /* Update rxNext */
 669             if (sn == amUl->rxNext)
 670             {
 671                tSn = sn;
 672                recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
 673                MODAMR(tSn, mSn, amUl->rxNext, amUl->snModMask);
 674                /* Scan through till the upper edge of the window */
 675                while (mSn <= tVrMr)
 676                {
 677                   if ((NULLP != recBuf) && (recBuf->allRcvd) &&
 678                       (TRUE == recBuf->isDelvUpperLayer))
 679                   {
 680                      /* RecBuf should remove from table
 681                         since PDU is already sent to upper layer */
 682                       recBuf->isDelvUpperLayer = FALSE;
 683                       rlcUtlDelRecBuf(amUl->recBufLst, recBuf, gCb);
 684                   }
 685                   else
 686                   {
 687                      amUl->rxNext = tSn;
 688                      amUl->vrMr = (amUl->rxNext + (RLC_AM_GET_WIN_SZ(amUl->snLen))) & (amUl->snModMask);
 689                      break;
 690                   }
 691                   tSn = (tSn + 1) & (amUl->snModMask);
 692                   recBuf = rlcUtlGetRecBuf(amUl->recBufLst, tSn);
 693                   mSn++;
 694                }
 695             }
 696          }
 697
 698          /* Check if reOrdTmr is running and update rxNextStatusTrig accordingly */
 699          tmrRunning = rlcChkTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
 700          if (tmrRunning)
 701          {
 702             Bool snInWin = RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(amUl->rxNextStatusTrig, amUl);
 703
 704             if ( (amUl->rxNextStatusTrig == amUl->rxNext) || ( (!snInWin) &&
 705                                              (amUl->rxNextStatusTrig != amUl->vrMr) ) )
 706             {
 707                rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
 708                tmrRunning = FALSE;
 709             }
 710          }
 711
 712          if (!tmrRunning)
 713          {
 714             if (amUl->rxNextHighestRcvd > amUl->rxNext)
 715             {
 716                rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
 717                amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
 718
 719                DU_LOG("\nRLC: rlcAmmProcessPdus: Updated rxNextStatusTrig = %d \
 720                   UEID:%d CELLID:%d", amUl->rxNextStatusTrig, rbCb->rlcId.ueId,
 721                   rbCb->rlcId.cellId);
 722             }
 723          }
 724       }
 725       else
 726       {
 727          discFlg = TRUE;
 728          gRlcStats.amRlcStats.numULPdusDiscarded++;
 729       }
 730
 731       if (amHdr.p)
 732       {
 733          rlcAmmTriggerStatus(gCb,rbCb, sn, discFlg);
 734       }
 735    }
 736
 737 #ifdef LTE_L2_MEAS
 738    rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb,ttiCnt);
 739 #endif /* LTE_L2_MEAS */
 740    gCb->genSts.pdusRecv += pduInfo->numPdu;
 741    if (amUl->gatherStaPduInfo)
 742    {
 743       rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
 744    }
 745
 746    return;
 747 }
 748
 749
 750 /**
 751  * @brief Private handler to extract header Information of the PDU
 752  *
 753  * @details
 754  *    This function extracts the header elements of the PDU and store them
 755  *    in db for future reference.
 756  *
 757  *    fByte - is the first byte removed from the PDU as part of calling
 758  *            functions
 759  *
 760  * @param[in]  gCb     RLC instance control block
 761  * @param[in]  rbCb    Uplink RB control block
 762  * @param[in]  pdu     Received PDU
 763  * @param[out] amHdr   Pointer to the extracted AM header
 764  * @param[out] fByte   First byte removed from the PDU
 765  *
 766  * @return S16
 767  *     -# ROK
 768  *     -# RFAILED
 769  *
 770  */
 771 static uint8_t rlcAmmExtractHdr(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *pdu, RlcAmHdr *amHdr, uint8_t *fByte)
 772 {
 773    uint8_t    snByte;
 774    RlcSn      sn = 0;
 775    MsgLen     pduSz;
 776    RlcExtHdr  hdrInfo;
 777
 778    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 779
 780    /* Extract fixed part of the header */
 781    ODU_GET_MSG_LEN(pdu,&pduSz);
 782    ODU_REM_PRE_MSG(fByte, pdu);
 783    amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
 784    if (RLC_CNTRL_PDU == amHdr->dc)
 785    {
 786    //printf ("++++++++++++ 5GNRLOG HDR extracted CTRL : \n");
 787       return ROK;
 788    }
 789
 790    amHdr->p  = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT;
 791
 792    amHdr->si = (*fByte & RLC_SI_POS)   >> RLC_SI_SHT;
 793
 794    /* 12 BIT SN */
 795    if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
 796    {
 797       ODU_REM_PRE_MSG(&snByte, pdu);
 798       sn = (RlcSn)(((*fByte & RLC_SN_POS_12BIT) << RLC_BYTE_LEN ) | snByte);
 799       amHdr->sn = sn;
 800    }
 801    else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
 802    {
 803       ODU_REM_PRE_MSG(&snByte, pdu);
 804       sn = (RlcSn)(((*fByte & RLC_SN_POS_18BIT) << RLC_BYTE_LEN ) | snByte);
 805
 806       ODU_REM_PRE_MSG(&snByte, pdu);
 807       sn = ((sn << RLC_BYTE_LEN) | snByte);
 808
 809       amHdr->sn = sn;
 810    }
 811    if ((amHdr->si != 0) && (amHdr->si != 0x01))
 812    {
 813       hdrInfo.len = RLC_SO_LEN_5GNR;
 814       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 815       amHdr->so = hdrInfo.val;
 816       pduSz -= 2;
 817    }
 818
 819    return ROK;
 820 }
 821
 822 #ifdef OLD
 823 /**
 824  * @brief Private handler to extract header Information of the PDU
 825  *
 826  * @details
 827  *    This function extracts the header elements of the PDU and store them
 828  *    in db for future reference.
 829  *
 830  *    fByte - is the first byte removed from the PDU as part of calling
 831  *            functions
 832  *
 833  * @param[in]  gCb     RLC instance control block
 834  * @param[in]  rbCb    Uplink RB control block
 835  * @param[in]  pdu     Received PDU
 836  * @param[out] amHdr   Pointer to the extracted AM header
 837  * @param[out] fByte   First byte removed from the PDU
 838  *
 839  * @return S16
 840  *     -# ROK
 841  *     -# RFAILED
 842  *
 843  */
 844 static S16 rlcAmmExtractHdrOld(RlcCb *gCb,Buffer *pdu,RlcAmHdr *amHdr,uint8_t *fByte)
 845 {
 846    uint8_t         e;
 847    uint8_t         snByte;
 848    uint16_t        sn;
 849    MsgLen     pduSz;
 850    MsgLen     totalSz = 0;
 851    RlcExtHdr   hdrInfo;
 852
 853    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 854
 855    /* Extract fixed part of the header */
 856    SFndLenMsg(pdu,&pduSz);
 857    SRemPreMsg(fByte, pdu);
 858    amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
 859    if (RLC_CNTRL_PDU == amHdr->dc)
 860    {
 861       return ROK;
 862    }
 863    /* kw002.201 : Changed the extraction of hdr elements to avoid */
 864    /*             function calls                                  */
 865    amHdr->rf = (*fByte & RLC_RF_POS)   >> RLC_RF_SHT;
 866    amHdr->p  = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT;
 867    amHdr->fi = (*fByte & RLC_FI_POS)   >> RLC_FI_SHT;
 868    e = amHdr->e  = (*fByte & RLC_E_POS)>> RLC_E_SHT;
 869
 870    SRemPreMsg(&snByte, pdu);
 871    sn = (uint16_t)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
 872    amHdr->sn = sn;
 873    if (amHdr->rf == 1)
 874    {
 875       /* Extract extn part of the header */
 876       hdrInfo.len = RLC_LSF_LEN;
 877       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 878       amHdr->lsf = (uint8_t)hdrInfo.val;
 879
 880       hdrInfo.len = RLC_SO_LEN;
 881       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 882       amHdr->so = hdrInfo.val;
 883       pduSz -= 2;
 884    }
 885
 886    amHdr->numLi = 0;
 887    /* Extract LIs */
 888    while (e && (amHdr->numLi < RLC_MAX_UL_LI))
 889    {
 890       hdrInfo.len = RLC_E_LEN;
 891       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 892       e = amHdr->e = (uint8_t)hdrInfo.val;
 893
 894       /* Extract LI value*/
 895       hdrInfo.len = RLC_LI_LEN;
 896       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 897       /* li = hdrInfo.val;*/
 898
 899       /* check if LI is zero */
 900       if (! hdrInfo.val)
 901       {
 902          RLOG0(L_ERROR, "Received LI as 0");
 903          return RFAILED;
 904       }
 905
 906       /* store the extracted  LI value */
 907       amHdr->li[amHdr->numLi++] = hdrInfo.val;
 908       totalSz += hdrInfo.val;  /* incrment the size by LI value */
 909    }
 910
 911    /*ccpu00122597:PDU is dropped if liCnt exceeds RLC_MAX_LI*/
 912    if(e && (amHdr->numLi >= RLC_MAX_UL_LI))
 913    {
 914       RLOG2(L_ERROR,"LI Count [%u] exceeds Max LI Count[%u]",
 915             amHdr->numLi, RLC_MAX_UL_LI);
 916       return RFAILED;
 917    }
 918
 919    /*                                first 2 bytes + Add one for  Odd LI*/
 920    pduSz -= ( amHdr->numLi + (amHdr->numLi >> 1) + 2 + (amHdr->numLi & 1) );
 921
 922    if ( totalSz >= pduSz )
 923    {
 924       RLOG3(L_ERROR,"SN [%d]:Corrupted PDU as TotSz[%lu] PduSz[%lu] ",
 925                amHdr->sn, totalSz, pduSz);
 926       return RFAILED;
 927    }
 928
 929    return ROK;
 930 }
 931 #endif
 932
 933 /**
 934  * @brief Private handler to process the status PDU
 935  *
 936  * @details
 937  *    Private handler invokded by rlcAmmProcessPdus to process the
 938  *    control PDU (status report) received from its peer RLC entity.
 939  *
 940  *        - Decode the values from the received control pdu
 941  *        - Create a RlcUdxStaPdu structure, copy the values onto it and
 942  *          send it to the DL instance for further processing
 943  *
 944  * @param[in]  gCb       RLC instance control block
 945  * @param[in]  rbCb      Uplink RB control block
 946  * @param[in]  cntrlPdu  Control PDU received from MAC
 947  * @param[in]  fByte     First byte already removed from the STATUS PDU
 948  *
 949  *  @return  Void
 950  *
 951  */
 952 static void rlcAmmUlHndlStatusPdu(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *cntrlPdu, uint8_t *fByte)
 953 {
 954    uint8_t          e1;
 955    RlcExtHdr        hdrInfo;
 956    RlcUdxStaPdu     *pStaPdu;
 957    RlcUdxUlSapCb    *sapCb;
 958    uint8_t          e3; /* NACK RANGE : 5GNR */
 959    uint32_t         snLen;
 960    uint32_t         snRange;
 961    uint32_t         resrvdBitsAckSn=0;
 962    uint32_t         resrvdBitsNackSn=0;
 963
 964    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 965
 966    /* Extract the Control PDU */
 967    hdrInfo.hdr  = (*fByte << 1);
 968    hdrInfo.pLen = 4;
 969
 970    /* D/C has been shifted in the calling function */
 971    if (hdrInfo.hdr & 0xE0)
 972    {
 973       DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: Reserved value for CPT received UEID:%d \
 974          CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 975       return;
 976    }
 977
 978    sapCb = RLC_GET_UDX_SAP(gCb);
 979
 980    RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
 981                        sapCb->pst.pool,
 982                        pStaPdu,
 983                        sizeof(RlcUdxStaPdu));
 984
 985 #if (ERRCLASS & ERRCLS_ADD_RES)
 986    /* Memory allocation failure can not be expected  */
 987    if(!pStaPdu)
 988    {
 989      return;
 990    }
 991 #endif
 992
 993    if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
 994    {
 995       snLen = 12;
 996       resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_12BITS;
 997       resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_12BITS;
 998    }
 999    else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
1000    {
1001       snLen = 18;
1002       resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_18BITS;
1003       resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_18BITS;
1004    }
1005    else
1006    {
1007       snLen = RLC_SN_LEN;
1008       resrvdBitsAckSn = 0;
1009       resrvdBitsAckSn = 0;
1010    }
1011
1012    pStaPdu->nackCnt = 0;
1013    /* For CPT */
1014    hdrInfo.hdr = hdrInfo.hdr << RLC_CPT_LEN;
1015
1016    /* ACK Sn */
1017    hdrInfo.len = snLen;
1018    rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1019    pStaPdu->ackSn = hdrInfo.val;
1020
1021    //printf ("++++++++++++ 5GNRLOG HNDL STATUS acksn %d : \n",  pStaPdu->ackSn);
1022    /* Check if NACK Exists */
1023    hdrInfo.len = RLC_E1_LEN;
1024    rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1025    e1 = (uint8_t)hdrInfo.val;
1026    DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
1027       pStaPdu->ackSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1028
1029    /* Extract the Reserved Bits after ACK SN field */
1030    hdrInfo.len = resrvdBitsAckSn;
1031    rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1032
1033    /* If NACK exists in control PDU */
1034    /* For ACKs and NACKs */
1035    while (e1 && (pStaPdu->nackCnt < RLC_MAX_NACK_CNT))
1036    {
1037       hdrInfo.len = snLen;
1038       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1039       pStaPdu->nackInfo[pStaPdu->nackCnt].sn = hdrInfo.val;
1040
1041       hdrInfo.len = RLC_E1_LEN;
1042       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1043       e1 = (uint8_t)hdrInfo.val;
1044
1045       /* Extract e2 */
1046       /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
1047          already present*/
1048       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1049       /*  e2 = (uint8_t) hdrInfo.val;*/
1050
1051       /* Store e2 value */
1052       pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (uint8_t) hdrInfo.val;
1053
1054       /* Extract e3 : 5GNR */
1055       /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
1056          already present*/
1057       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1058       e3 = (uint8_t) hdrInfo.val;
1059
1060       /* Extract Reserved Bits after NACK SN */
1061       hdrInfo.len = resrvdBitsNackSn;
1062       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1063
1064       /* Test for resegmentation */
1065       if (pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment)
1066       {
1067          hdrInfo.len = RLC_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
1068          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1069          pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = hdrInfo.val;
1070
1071          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1072          pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd   = hdrInfo.val;
1073
1074          DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
1075             "UEID:%d CELLID:%d", pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
1076             pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd, rbCb->rlcId.ueId,
1077             rbCb->rlcId.cellId);
1078       }
1079       else
1080       {
1081          hdrInfo.len = 0;
1082          pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = 0;
1083          pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd   = 0;
1084
1085       }
1086       /* NACK RANGE Field is SET */
1087       if (e3)
1088       {
1089          /* Extract NACK range field */
1090          hdrInfo.len = RLC_NACK_RANGE_LEN;
1091          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1092          snRange = (uint8_t)hdrInfo.val;
1093
1094          pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
1095
1096       }
1097       pStaPdu->nackCnt++;
1098    }
1099
1100    gRlcStats.amRlcStats.numULStaPduRcvd++;
1101    gRlcStats.amRlcStats.numULNackInStaPduRcvd += pStaPdu->nackCnt;
1102
1103    /* In case we have reached the MAX NACK CNT, then we should modify the ACK_SN
1104       to the last NACK SN + 1 and discard the original ACK_SN*/
1105    if(pStaPdu->nackCnt == RLC_MAX_NACK_CNT)
1106    {
1107       pStaPdu->ackSn = (pStaPdu->nackInfo[RLC_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask);
1108    }
1109
1110
1111    /* Parse & send Status PDU to RLC-DL */
1112    rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
1113
1114    return;
1115 }
1116
1117 /**
1118  * @brief Private handler to release all stored segments
1119  *
1120  * @details
1121  *    Private handler invokded by rlcAmmUlPlacePduInRecBuf to release the
1122  *    stored segements in case a complete PDU is received later.
1123  *
1124  * @param[in]  gCb      RLC instance control block
1125  * @param[in]  recBuf   Buffer that stores a received PDU or segments
1126  *
1127  * @return  Void
1128  *
1129  */
1130 static void rlcAmmUlRlsAllSegs(RlcCb *gCb, RlcAmRecBuf *recBuf)
1131 {
1132    RlcSeg *seg;
1133
1134    RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1135    while (seg != NULLP)
1136    {
1137       ODU_PUT_MSG_BUF(seg->seg);
1138       cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
1139       RLC_FREE(gCb,seg, sizeof(RlcSeg));
1140       RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1141    }
1142
1143    return;
1144 }
1145
1146 /**
1147  * @brief Private handler to store the received segment
1148  *
1149  * @details
1150  *    Private handler invokded by rlcAmmUlPlacePduInRecBuf to add a received
1151  *    segment in reception buffer of a RBCB.
1152  *    - It is responsible for detecting duplicate segments
1153  *    - Adding it at appropriate position in the received buffer
1154  *    - Calling ExpByteSeg to set expSo field in the receiver buffer
1155  *
1156  * @param[in]  gCb      RLC instance control block
1157  * @param[in]  rbCb     Radio Bearer Contro Block
1158  * @param[in]  amHdr    AM Header received
1159  * @param[in]  pdu      Buffer received other than the headers
1160  * @param[in]  pduSz    size of the PDU buffer received
1161  *
1162  * @return  Bool
1163  *   -#TRUE  Successful insertion into the receiver buffer
1164  *   -#FALSE Possibly a duplicate segment
1165  */
1166 static bool rlcAmmAddRcvdSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu, uint16_t pduSz)
1167 {
1168    RlcAmRecBuf   *recBuf = NULLP;
1169    RlcSeg        *seg;
1170    RlcSeg        *tseg;
1171    uint16_t      soEnd;       /* Holds the SoEnd of received segment */
1172    uint16_t      expSo = 0;   /* Expected SO */
1173
1174    soEnd = amHdr->so + pduSz - 1;
1175    recBuf =  rlcUtlGetRecBuf(RLC_AMUL.recBufLst, amHdr->sn);
1176
1177    if (NULLP == recBuf)
1178    {
1179       RLC_ALLOC(gCb,recBuf, sizeof(RlcAmRecBuf));
1180 #if (ERRCLASS & ERRCLS_ADD_RES)
1181       if (recBuf == NULLP)
1182       {
1183          DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
1184             rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1185
1186          ODU_PUT_MSG_BUF(pdu);
1187          return FALSE;
1188       }
1189 #endif /* ERRCLASS & ERRCLS_RES */
1190       rlcUtlStoreRecBuf(RLC_AMUL.recBufLst, recBuf, amHdr->sn);
1191    }
1192    else
1193    {
1194       if (recBuf->allRcvd == TRUE)
1195       {
1196          ODU_PUT_MSG_BUF(pdu);
1197          return FALSE;
1198       }
1199    }
1200
1201    recBuf->isDelvUpperLayer = FALSE;
1202    /* kw003.201 - Move past the segments that are different than the */
1203    /*             one received.                                      */
1204    RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1205    while ((seg != NULLP) && (seg->amHdr.so < amHdr->so))
1206    {
1207       expSo = seg->amHdr.so + seg->segSz;
1208       RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
1209    }
1210
1211    /* The received segment should start after the end of previous seg */
1212    if (expSo > amHdr->so)
1213    {
1214       /* This is a duplicate segment */
1215       gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
1216       ODU_PUT_MSG_BUF(pdu);
1217       return FALSE;
1218    }
1219
1220    if ((seg) && (seg->amHdr.so <= soEnd))
1221    {
1222       /* This is a duplicate segment */
1223       gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
1224       ODU_PUT_MSG_BUF(pdu);
1225       return FALSE;
1226    }
1227
1228    /* If we have come this far, we have to add this segment to the   */
1229    /* reception buffer as we either have eliminated duplicates or    */
1230    /* have found none.                                               */
1231    RLC_ALLOC_WC(gCb,tseg, sizeof(RlcSeg));
1232 #if (ERRCLASS & ERRCLS_ADD_RES)
1233    if (tseg == NULLP)
1234    {
1235       DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
1236          rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1237       ODU_PUT_MSG_BUF(pdu);
1238       return FALSE;
1239    }
1240 #endif /* ERRCLASS & ERRCLS_RES */
1241
1242    tseg->seg = pdu;
1243    tseg->segSz = pduSz;
1244    RLC_MEM_CPY(&tseg->amHdr, amHdr, sizeof(RlcAmHdr));
1245    recBuf->amHdr.si = amHdr->si;
1246    recBuf->amHdr.sn = amHdr->sn;
1247    tseg->soEnd = soEnd;
1248    if (seg == NULLP)
1249    {
1250       cmLListAdd2Tail(&recBuf->segLst, &tseg->lstEnt);
1251    }
1252    else
1253    {
1254       recBuf->segLst.crnt = &seg->lstEnt;
1255       cmLListInsCrnt(&recBuf->segLst, &tseg->lstEnt);
1256    }
1257    tseg->lstEnt.node = (PTR)tseg;
1258    rlcAmmUpdExpByteSeg(gCb,&RLC_AMUL,tseg);
1259
1260    return TRUE;
1261 }
1262
1263 /**
1264  * @brief Private handler to place the PDU in the reception buffer
1265  *
1266  * @details
1267  *    This function checks if the received PDU's SN falls within the
1268  *    receiving window, after which it places the same in the reception
1269  *    buffer if its not a duplicate.
1270  *
1271  * @param[in]  gCb   RLC instance control block
1272  * @param[in]  pdu   Received PDU
1273  * @param[in]  rbCb  Uplink AM Radio Bearer
1274  * @param[out] amUl  AM UL Info
1275  *
1276  * @return Bool
1277  *     -# TRUE
1278  *     -# FALSE
1279  *
1280  */
1281 static bool rlcAmmUlPlacePduInRecBuf(RlcCb *gCb, Buffer *pdu, RlcUlRbCb *rbCb, RlcAmHdr *amHdr)
1282 {
1283    RlcSn     sn;
1284    MsgLen   pduSz;
1285    RlcAmUl   *amUl = &(rbCb->m.amUl);
1286
1287    sn = amHdr->sn;
1288    SFndLenMsg(pdu, &pduSz);
1289
1290    gCb->genSts.bytesRecv += pduSz;
1291    gRlcStats.amRlcStats.numRlcAmCellSduBytesRx += pduSz;
1292    if (!RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
1293    {
1294       gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx++;
1295       DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: SN  %d outside the window"
1296          "UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1297
1298       gCb->genSts.unexpPdusRecv++;
1299       ODU_PUT_MSG_BUF(pdu);
1300       return FALSE;
1301    }
1302
1303    if (amHdr->si == 0)
1304    {
1305       RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
1306
1307       /* We received a complete PDU. Either we already have it, in which */
1308       /* case we just ignore the new PDU and discard it. Otherwise,      */
1309       /* store the received PDU in the reception buffer                  */
1310       if (NULLP == recBuf)
1311       {
1312          RLC_ALLOC(gCb, recBuf, sizeof(RlcAmRecBuf));
1313 #if (ERRCLASS & ERRCLS_ADD_RES)
1314          if (recBuf == NULLP)
1315          {
1316             DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: Memory allocation failed \
1317                UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1318             ODU_PUT_MSG_BUF(pdu);
1319             return FALSE;
1320          }
1321 #endif /* ERRCLASS & ERRCLS_RES */
1322          rlcUtlStoreRecBuf(RLC_AMUL.recBufLst, recBuf, sn);
1323       }
1324       else if (recBuf->allRcvd != TRUE)
1325       {
1326          rlcAmmUlRlsAllSegs(gCb,recBuf);
1327       }
1328       else
1329       {
1330          gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
1331          gCb->genSts.unexpPdusRecv++;
1332          ODU_PUT_MSG_BUF(pdu);
1333          return FALSE;
1334       }
1335       recBuf->isDelvUpperLayer = FALSE;
1336       recBuf->pdu = pdu;
1337       recBuf->pduSz = pduSz;
1338       recBuf->allRcvd = TRUE;
1339       gRlcStats.amRlcStats.numRlcAmCellSduRx++;
1340       RLC_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(RlcAmHdr));
1341       return TRUE;
1342    }
1343    else
1344    {
1345       /* We received a segment. We need to add that to the existing */
1346       /* segments, if any.                                          */
1347       return (rlcAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
1348    }
1349 }
1350
1351 /**
1352  * @brief Private handler to trigger status report
1353  *
1354  * @details
1355  *    Private handler invokded by rlcAmmProcessPdus to check if the
1356  *    status report need to be sent, and update the status trigger
1357  *    flag accordingly based on status prohibit timer.
1358  *
1359  *    - Check if the received pdu's sn is less than rxHighestStatus, set the
1360  *      staTrg flag.
1361  *    - If staProhTmr is not running, calculate cntrlBo, else it'll be
1362  *      updated at the expiry of staProhTmr.
1363  *    - Expiry of reOrdTmr also will set staTrg flag.
1364  *
1365  * @param[in]  gCb       RLC instance control block
1366  * @param[in]  rbCb      Uplink RB control block
1367  * @param[in]  sn        Sequence number of the pdu based on which to check if
1368  *                       status needs to be triggered
1369  * @param[in]  discFlg   Whether this pdu was discarded or not
1370  *
1371  * @return  Void
1372  *
1373  */
1374 static void rlcAmmTriggerStatus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcSn sn, bool discFlg)
1375 {
1376    bool     tmrRunning;
1377    RlcSn     tSn;
1378    RlcSn     tVrMr;
1379    RlcSn     trxHighestStatus;
1380    RlcAmUl   *amUl = &(rbCb->m.amUl);
1381
1382    MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
1383    MODAMR(amUl->rxHighestStatus, trxHighestStatus, amUl->rxNext, amUl->snModMask);
1384    MODAMR(sn , tSn, amUl->rxNext, amUl->snModMask);
1385
1386    /* kw005.201 Product CR ccpu00117114       *
1387     * The "=" in the 2nd condition is removed */
1388    if ((discFlg) || (tSn < trxHighestStatus) || (tSn >= tVrMr))
1389    {
1390       DU_LOG("\nRLC: rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
1391          rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1392
1393       amUl->staTrg = TRUE;
1394       amUl->gatherStaPduInfo = FALSE;
1395
1396       /* Check if staProhTmr is running */
1397       tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1398
1399       if (!tmrRunning)
1400       {
1401          amUl->gatherStaPduInfo = TRUE;
1402       }
1403    }
1404
1405    return;
1406 }
1407
1408 /**
1409  * @brief Private handler to reassemble from a segment or a PDU
1410  *
1411  * @details
1412  *    Private handler invokded by kwAmmReassembleSdus with either a
1413  *    PDU or a segment of a PDU. This is also called in the case of
1414  *    reestablishment and hence out of sequence joining is also to
1415  *    be supported
1416  *
1417  *
1418  * @param[in]  gCb     RLC instance control block
1419  * @param[in]  rbCb    Uplink RB control block
1420  * @param[in]  amHdr   AM header received for this segment/PDU
1421  * @param[in]  pdu     PDU to be reassembled
1422  *
1423  * @return  Void
1424  *
1425  */
1426 static void rlcAmmProcPduOrSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu)
1427 {
1428
1429    if ((RLC_AMUL.expSn != amHdr->sn) || (RLC_AMUL.expSo != amHdr->so))
1430    {
1431       /* Release the existing partial SDU as we have PDUs or */
1432       /* segments that are out of sequence                   */
1433       rbCb->m.amUl.isOutOfSeq = TRUE;
1434       ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
1435    }
1436
1437    //if (amHdr->fi & RLC_FI_FIRST_SEG)
1438    if (amHdr->si == 0x01)
1439    {/* first Segment of the SDU */
1440       if (RLC_AMUL.partialSdu != NULLP)
1441       { /* Some old SDU may be present */
1442          ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
1443       }
1444       RLC_AMUL.partialSdu = pdu;
1445       pdu = NULLP;
1446    }
1447    else if(amHdr->si == 0x03)
1448    {/* Middle or last segment of the SUD */
1449       ODU_CAT_MSG(RLC_AMUL.partialSdu,pdu, M1M2);
1450       ODU_PUT_MSG_BUF(pdu);
1451       pdu = NULLP;
1452    }
1453    else if (amHdr->si ==  0x02)
1454    {
1455       ODU_CAT_MSG(pdu,RLC_AMUL.partialSdu,M2M1);
1456       ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
1457    }
1458
1459    if (pdu != NULLP)
1460    {
1461       RLC_AMUL.partialSdu = NULLP;
1462       rlcUtlSendUlDataToDu(gCb,rbCb, pdu);
1463    }
1464
1465    return;
1466 }
1467
1468 /**
1469  *
1470  * @brief Private handler to reassemble SDUs
1471  *
1472  * @details
1473  *    Private handler invokded by rlcAmmProcessPdus with the PDU
1474  *    from the reception buffer in sequence to reassemble SDUs and
1475  *    send it to PDCP.
1476  *
1477  *        - With the stored header info, FI and LSF segment / concatenate
1478  *          PDUs or byte segments of PDUs to get the associated SDU.
1479  *
1480  * @param[in]  rbCb     RB control block
1481  * @param[in]  pdu      PDU to be reassembled
1482  *
1483  *  @return  S16
1484  *      -# ROK
1485  *      -# RFAILED
1486  *
1487  */
1488 static uint8_t rlcAmmUlReassembleSdus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmRecBuf *recBuf)
1489 {
1490    RlcSeg        *seg;
1491
1492    //if (recBuf->amHdr.rf == 0)
1493    if (recBuf->amHdr.si == 0)
1494    {
1495       /* This is a PDU */
1496       rlcAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu);
1497       /* Assign NULLP to recBuf->pdu as this PDU is sent to PDCP */
1498       recBuf->pdu = NULLP;
1499       RLC_AMUL.expSn = (recBuf->amHdr.sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
1500       RLC_AMUL.expSo = 0;
1501    }
1502    else
1503    {
1504       /* This is a set of segments */
1505       RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1506       RLC_AMUL.expSn = recBuf->amHdr.sn;
1507       RLC_AMUL.expSo = 0;
1508       while(seg)
1509       {
1510          rlcAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg);
1511          RLC_AMUL.expSo = seg->soEnd + 1;
1512
1513          cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
1514          RLC_FREE(gCb, seg, sizeof(RlcSeg));
1515
1516          RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1517       }
1518       RLC_AMUL.expSn = (recBuf->amHdr.sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
1519       RLC_AMUL.expSo = 0;
1520    }
1521
1522    return ROK;
1523 }
1524
1525 /**
1526  * @brief   Handler to process the re-establishment request received from UIM
1527  *
1528  * @param[in] gCb         RLC instance control block
1529  * @param[in] rlcId       RLC identifier
1530  * @param[in] sendReEst   Whether to send back restablishment complete or not
1531  * @param[in] rbCb        Uplink RB control block
1532  *
1533  * @return  Void
1534  *
1535  */
1536 Void rlcAmmUlReEstablish(RlcCb *gCb,CmLteRlcId rlcId,Bool sendReEst,RlcUlRbCb  *rbCb)
1537 {
1538    RlcSn   sn;
1539    RlcSn   mSn;
1540    RlcSn   mVrMr;
1541
1542 #ifndef KW_PDCP
1543    RlcKwuSapCb *rlcKwuSap;
1544 #endif
1545    RlcAmRecBuf   *recBuf = NULLP;
1546
1547    sn = RLC_AMUL.rxNext;
1548
1549    MODAMR(RLC_AMUL.vrMr, mVrMr, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
1550    MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
1551
1552    /* Reassemble SDUs from PDUs with SN less than upper edge of the window */
1553    while (mSn < mVrMr)
1554    {
1555       recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
1556       if (NULLP != recBuf)
1557       {
1558          if (recBuf->allRcvd == TRUE)
1559          {
1560             rlcAmmUlReassembleSdus(gCb,rbCb, recBuf);
1561          }
1562          else
1563          {
1564             /* Remove PDU and segments */
1565             if(recBuf->pdu)
1566             {
1567                ODU_PUT_MSG_BUF(recBuf->pdu);
1568             }
1569             /* Release all the segments*/
1570             rlcAmmUlRlsAllSegs(gCb,recBuf);
1571          }
1572          rlcUtlDelRecBuf(RLC_AMUL.recBufLst, recBuf, gCb);
1573       }
1574       sn = (sn + 1) & (RLC_AMUL.snModMask); /* MOD 1024 */
1575       MODAMR(sn, mSn, RLC_AMUL.rxNext, RLC_AMUL.snModMask);
1576    }
1577    /* Discard remaining PDUs and bytesegments in recBuf */
1578
1579    /* Stop all timers and reset variables */
1580    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
1581    {
1582        rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
1583    }
1584    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
1585    {
1586        rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1587    }
1588
1589    RLC_AMUL.rxNext  = 0;
1590    RLC_AMUL.rxNextHighestRcvd  = 0;
1591    RLC_AMUL.rxNextStatusTrig  = 0;
1592    rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask);
1593    RLC_AMUL.rxHighestStatus = 0;
1594    RLC_AMUL.staTrg  = FALSE;
1595    RLC_AMUL.gatherStaPduInfo = FALSE;
1596    RLC_AMUL.expSn = 0;
1597    RLC_AMUL.expSo = 0;
1598    if (RLC_AMUL.partialSdu != NULLP)
1599    {
1600      ODU_PUT_MSG_BUF(RLC_AMUL.partialSdu);
1601    }
1602    rlcKwuSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
1603
1604    if(sendReEst)
1605    {
1606       RlcUiKwuReEstCmpInd(&rlcKwuSap->pst, rlcKwuSap->suId, rlcId);
1607       rbCb->m.amUl.isOutOfSeq = FALSE;
1608    }
1609
1610    return;
1611 }
1612
1613 /**
1614  * @brief  Handler for reorder timer expiry
1615  *
1616  * @details
1617  *    This function is used to handle events upon expiry of reorder timer
1618  *
1619  *  @param[in] gCb   RLC instance control block
1620  *  @param[in] rbCb  RB control block
1621  *
1622  *  @return  Void
1623  *
1624  */
1625
1626 Void rlcAmmReOrdTmrExp(RlcCb *gCb,RlcUlRbCb *rbCb)
1627 {
1628    RlcAmUl *amUl = &(rbCb->m.amUl);
1629    RlcSn sn;
1630    RlcSn mSn;
1631    RlcSn mVrMr;
1632    RlcSn mrxHighestStatus;
1633    RlcSn mrxNextHighestRcvd;
1634    Bool tmrRunning = FALSE;
1635    RlcAmRecBuf   *recBuf = NULLP;
1636
1637    /* Update rxHighestStatus */
1638    sn = amUl->rxNextStatusTrig;
1639
1640    MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
1641    MODAMR(amUl->vrMr, mVrMr, amUl->rxNext, amUl->snModMask);
1642    recBuf = rlcUtlGetRecBuf(RLC_AMUL.recBufLst, sn);
1643
1644    while (mSn < mVrMr)
1645    {
1646       if ((recBuf == NULLP) ||
1647           ((recBuf != NULLP) && (!recBuf->allRcvd)) )
1648       {
1649          amUl->rxHighestStatus = sn;
1650          amUl->staTrg = TRUE;
1651          amUl->gatherStaPduInfo = FALSE;
1652
1653          /* Check if staProhTmr is running */
1654          tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1655
1656          if (!tmrRunning)
1657          {
1658             gRlcStats.amRlcStats.numULReOrdTimerExpires++;
1659             amUl->gatherStaPduInfo = TRUE;
1660             rlcAmmUlAssembleCntrlInfo(gCb, rbCb);
1661          }
1662
1663          break;
1664       }
1665       sn = (sn + 1) & (amUl->snModMask);
1666       MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
1667    }
1668
1669    /* Update rxNextStatusTrig */
1670    MODAMR(amUl->rxNextHighestRcvd, mrxNextHighestRcvd, amUl->rxNext, amUl->snModMask);
1671    MODAMR(amUl->rxHighestStatus, mrxHighestStatus, amUl->rxNext, amUl->snModMask);
1672    if (mrxNextHighestRcvd > mrxHighestStatus)
1673    {
1674       rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
1675       amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
1676    }
1677
1678    return;
1679 } /* rlcAmmReOrdTmrExp */
1680
1681 /**
1682  * @brief  Handler for status prohibit timer expiry
1683  *
1684  * @details
1685  *    This function is used to handle events upon expiry of status prohibit
1686  *    timer
1687  *
1688  *  @param[in] gCb   RLC instance control block
1689  *  @param[in] rbCb   RB control block
1690  *
1691  *  @return  Void
1692  *
1693  */
1694
1695 Void rlcAmmStaProTmrExp(RlcCb *gCb,RlcUlRbCb *rbCb)
1696 {
1697    RlcAmUl *amUl = &(rbCb->m.amUl);
1698
1699    amUl->gatherStaPduInfo = FALSE;
1700
1701    if (amUl->staTrg == TRUE)
1702    {
1703       amUl->gatherStaPduInfo = TRUE;
1704       /* kw002.201 : Sending StaRsp after StaProhibit tmr expiry */
1705       rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
1706    }
1707
1708    return;
1709 } /* rlcAmmStaProTmrExp */
1710
1711 /**
1712  * @brief  Handler to extract an element of AM Header
1713  *
1714  * @details
1715  *    This function is used to extract an element of AM header.
1716  *
1717  * @param[in]     pdu      The pdu to be decoded
1718  * @param[in,out] hdrInfo  Container to hold the decoded info
1719  *
1720  * @return Void
1721  *
1722  */
1723
1724 static void rlcAmmExtractElmnt(RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo)
1725 {
1726    uint8_t   hdr;
1727    uint8_t   pLen = hdrInfo->pLen;
1728    uint8_t   len  = (uint8_t)hdrInfo->len;
1729    uint32_t  val;
1730    uint8_t   tHdr;
1731    uint8_t   fLen;
1732    uint8_t   rLen;
1733    /* uint8_t   rLen1 = 0; */
1734    uint16_t  tVal;
1735
1736    hdr = hdrInfo->hdr;
1737
1738    if (pLen == 0)
1739    {
1740       ODU_REM_PRE_MSG(&hdr, pdu);
1741       pLen = 8;
1742    }
1743    tHdr = hdr;
1744    if (len <= 8)
1745    {
1746       val = tHdr >> (RLC_BYTE_LEN - (len));
1747       hdr =  hdr << len;
1748       pLen -= len;
1749    }
1750    else /*if (len > 8) */
1751    {
1752       fLen = pLen;
1753       val = tHdr;
1754       val = val >> (RLC_BYTE_LEN - fLen);
1755       val = val << (len - fLen);
1756       rLen = len - fLen;
1757       ODU_REM_PRE_MSG(&hdr, pdu);
1758       tHdr = hdr;
1759       if (rLen <= 8)
1760       {
1761          hdr = hdr >> (RLC_BYTE_LEN - rLen);
1762          val = val | hdr;
1763          hdr = tHdr << rLen;
1764          pLen = (RLC_BYTE_LEN - rLen);
1765       }
1766       else
1767       {
1768         rLen = rLen - RLC_BYTE_LEN;
1769         tVal = hdr;
1770         tVal = tVal << rLen;
1771         val = val | tVal;
1772
1773         ODU_REM_PRE_MSG(&hdr, pdu);
1774         tHdr = hdr;
1775         hdr = hdr >> (RLC_BYTE_LEN - rLen);
1776         val = val | hdr;
1777         hdr = tHdr << rLen;
1778         pLen = (RLC_BYTE_LEN - rLen);
1779       }
1780    }
1781
1782    hdrInfo->pLen = pLen;
1783    hdrInfo->hdr = hdr;
1784    hdrInfo->val = val;
1785
1786    return;
1787 }
1788
1789 /**
1790  * @brief  Handler to updated expected byte seg
1791  *
1792  * @details
1793  *    This function is used to update expected byte segment. The next segment
1794  *    expected is indicated by the SO of the segment which is expected. Intially
1795  *    the segment with SO 0 is expected and then in order. When all the segments
1796  *    are received (which would happen when an expected SO is encountered
1797  *    with LSF set) the allRcvd flag is set to TRUE
1798  *
1799  * @param[in]  gCb   RLC instance control block
1800  * @param[in]  amUl  AM Uplink Control Block
1801  * @param[in]  seg   Newly received segment
1802  *
1803  * @return Void
1804  *
1805  */
1806
1807 static void rlcAmmUpdExpByteSeg(RlcCb *gCb, RlcAmUl *amUl, RlcSeg *seg)
1808 {
1809    uint16_t  newExpSo; /* The new expected SO */
1810    RlcSn     sn = seg->amHdr.sn;
1811    bool      lstRcvd=FALSE;
1812    RlcAmRecBuf *recBuf = NULLP;
1813
1814    recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
1815    if ((recBuf == NULLP) || (recBuf && (seg->amHdr.so != recBuf->expSo)))
1816    {
1817       return;
1818    }
1819
1820    newExpSo   = seg->soEnd + 1;
1821    recBuf->expSo = newExpSo;
1822    //lstRcvd = seg->amHdr.lsf;
1823    if(seg->amHdr.si == 0x2)
1824    {
1825       lstRcvd = TRUE;
1826    }
1827    /* kw003.201 - This should update seg with the one after newSeg */
1828    RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
1829    while(seg)
1830    {
1831       /* keep going ahead as long as the expectedSo match with the header so
1832          else store the expSo for later checking again */
1833       if(seg->amHdr.si == 0x2)
1834       {
1835          lstRcvd = TRUE;
1836       }
1837       if (seg->amHdr.so == newExpSo)
1838       {
1839          newExpSo = seg->soEnd + 1;
1840          recBuf->expSo = newExpSo;
1841          //lstRcvd = seg->amHdr.lsf;
1842          RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
1843       }
1844       else
1845       {
1846          recBuf->expSo = newExpSo;
1847          return;
1848       }
1849    }
1850    if (lstRcvd == TRUE)
1851    {
1852       recBuf->allRcvd = TRUE;
1853       gRlcStats.amRlcStats.numRlcAmCellSduRx++;
1854    }
1855
1856    return;
1857 }
1858
1859 /**
1860  * @brief
1861  *   Function to release/free the Acknowledged Mode Module  RbCb buffers
1862  *
1863  * @details
1864  *   This primitive Frees the AM RbCb transmission Buffer, retransmission
1865  *   Buffer and reciption Buffers
1866  *
1867  * @param [in]   gCb   - RLC instance Control Block
1868  * @param [in]   rbCb  - RB Control Block
1869  *
1870  * @return   void
1871  */
1872 Void rlcAmmFreeUlRbCb(RlcCb       *gCb,RlcUlRbCb   *rbCb)
1873 {
1874    RlcSn         curSn = 0;           /* Sequence number of PDU */
1875    RlcSn         windSz;              /* PDU window size */
1876    RlcAmRecBuf *recBuf = NULLP;
1877
1878    windSz  =  (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
1879
1880    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
1881    {
1882       rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
1883    }
1884    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
1885    {
1886       rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1887    }
1888
1889
1890    /* on the first loop winSz is always greater than zero
1891     while( ( curSn < windSz ) hence changing to do while */
1892    do
1893    {
1894       recBuf = rlcUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn);
1895       if ( recBuf != NULLP )
1896       {
1897          if (recBuf->pdu != NULLP)
1898          {
1899             ODU_PUT_MSG_BUF(recBuf->pdu);
1900          }
1901          /* Release all the segments */
1902          rlcAmmUlRlsAllSegs(gCb,recBuf);
1903          rlcUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb);
1904       }
1905       curSn++;
1906    }while ( curSn < windSz );
1907
1908 #ifndef LTE_TDD
1909       RLC_FREE(gCb,rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
1910       rbCb->m.amUl.recBufLst = NULLP;
1911 #endif
1912
1913    if(rbCb->m.amUl.partialSdu != NULLP)
1914    {
1915       ODU_PUT_MSG_BUF(rbCb->m.amUl.partialSdu);
1916    }
1917    return;
1918 } /* rlcAmmFreeUlRbCb */
1919
1920
1921 /*@}*/
1922
1923 \f
1924 /********************************************************************30**
1925
1926          End of file
1927 **********************************************************************/