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 extern 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 extern uint32_t isMemThreshReached(Region region);
  78 #endif
  79 #else
  80 #ifndef LTE_PAL_ENB
  81 extern 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 void rlcAmmUlAssembleCntrlInfo ARGS ((RlcCb *gCb, RlcUlRbCb *rbCb));
  94
  95 uint8_t rlcAmmExtractHdr ARGS ((RlcCb *gCb,
  96                                 RlcUlRbCb   *rbCb,
  97                                 Buffer *pdu,
  98                                 RlcAmHdr *amHdr,
  99                                 uint8_t *fByte));
 100
 101 bool rlcAmmUlPlacePduInRecBuf ARGS ((RlcCb *gCb,
 102                                      Buffer *pdu,
 103                                      RlcUlRbCb *rbCb,
 104                                      RlcAmHdr *amHdr));
 105
 106 void rlcAmmTriggerStatus ARGS ((RlcCb *gCb,
 107                                 RlcUlRbCb *rbCb,
 108                                 RlcSn sn,
 109                                 bool discFlg));
 110
 111 uint8_t  rlcAmmUlReassembleSdus ARGS ((RlcCb *gCb,
 112                                      RlcUlRbCb *rbCb,
 113                                      RlcAmRecBuf *recBuf));
 114
 115 PRIVATE Void rlcAmmProcPduOrSeg ARGS ((RlcCb *gCb,
 116                                       RlcUlRbCb *rbCb,
 117                                       RlcAmHdr *amHdr,
 118                                       Buffer *pdu));
 119
 120 PRIVATE Void rlcAmmUpdExpByteSeg ARGS ((RlcCb *gCb,RlcAmUl *amUl, RlcSeg* newSeg));
 121
 122 PRIVATE Void rlcAmmExtractElmnt ARGS ((RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo));
 123
 124 PRIVATE 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 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) & 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 += ((AMUL.snLen == RLC_AM_CFG_12BIT_SN_LEN)?6:7); /* NACK,E1,E2,Sostart,SoEnd */
 209       }
 210       else
 211       {
 212          sizeToBeEncd += ((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) & 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 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 = AMUL.rxNext;
 314    MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
 315    MODAMR(AMUL.rxHighestStatus, rxHighestStatus, AMUL.rxNext, AMUL.snModMask);
 316
 317    recBuf =  rlcUtlGetRecBuf(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) & (AMUL.snModMask); /* MOD 1024 */
 390       MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
 391
 392       /* Get the received Buffer the updated/next SN */
 393       recBuf =  rlcUtlGetRecBuf(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 = 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    AMUL.staTrg = FALSE;
 447    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 extern 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 = &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          RLC_FREE_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          RLC_FREE_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          RLC_FREE_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          extern uint32_t rlculdrop;
 573          rlculdrop++;
 574          RLC_FREE_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          extern uint32_t rlculdrop;
 584          rlculdrop++;
 585          RLC_FREE_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             RLC_FREE_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 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 #ifdef ANSI
 845 PRIVATE S16 rlcAmmExtractHdrOld
 846 (
 847 RlcCb       *gCb,
 848 Buffer     *pdu,
 849 RlcAmHdr    *amHdr,
 850 uint8_t         *fByte
 851 )
 852 #else
 853 PRIVATE S16 rlcAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
 854 RlcCb       *gCb;
 855 Buffer     *pdu;
 856 RlcAmHdr    *amHdr;
 857 uint8_t         *fByte;
 858 #endif
 859 {
 860    uint8_t         e;
 861    uint8_t         snByte;
 862    uint16_t        sn;
 863    MsgLen     pduSz;
 864    MsgLen     totalSz = 0;
 865    RlcExtHdr   hdrInfo;
 866
 867    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 868
 869    /* Extract fixed part of the header */
 870    SFndLenMsg(pdu,&pduSz);
 871    SRemPreMsg(fByte, pdu);
 872    amHdr->dc = (*fByte & RLC_DC_POS) >> RLC_DC_SHT;
 873    if (RLC_CNTRL_PDU == amHdr->dc)
 874    {
 875       return ROK;
 876    }
 877    /* kw002.201 : Changed the extraction of hdr elements to avoid */
 878    /*             function calls                                  */
 879    amHdr->rf = (*fByte & RLC_RF_POS)   >> RLC_RF_SHT;
 880    amHdr->p  = (*fByte & RLC_POLL_POS) >> RLC_POLL_SHT;
 881    amHdr->fi = (*fByte & RLC_FI_POS)   >> RLC_FI_SHT;
 882    e = amHdr->e  = (*fByte & RLC_E_POS)>> RLC_E_SHT;
 883
 884    SRemPreMsg(&snByte, pdu);
 885    sn = (uint16_t)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
 886    amHdr->sn = sn;
 887    if (amHdr->rf == 1)
 888    {
 889       /* Extract extn part of the header */
 890       hdrInfo.len = RLC_LSF_LEN;
 891       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 892       amHdr->lsf = (uint8_t)hdrInfo.val;
 893
 894       hdrInfo.len = RLC_SO_LEN;
 895       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 896       amHdr->so = hdrInfo.val;
 897       pduSz -= 2;
 898    }
 899
 900    amHdr->numLi = 0;
 901    /* Extract LIs */
 902    while (e && (amHdr->numLi < RLC_MAX_UL_LI))
 903    {
 904       hdrInfo.len = RLC_E_LEN;
 905       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 906       e = amHdr->e = (uint8_t)hdrInfo.val;
 907
 908       /* Extract LI value*/
 909       hdrInfo.len = RLC_LI_LEN;
 910       rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
 911       /* li = hdrInfo.val;*/
 912
 913       /* check if LI is zero */
 914       if (! hdrInfo.val)
 915       {
 916          RLOG0(L_ERROR, "Received LI as 0");
 917          return RFAILED;
 918       }
 919
 920       /* store the extracted  LI value */
 921       amHdr->li[amHdr->numLi++] = hdrInfo.val;
 922       totalSz += hdrInfo.val;  /* incrment the size by LI value */
 923    }
 924
 925    /*ccpu00122597:PDU is dropped if liCnt exceeds RLC_MAX_LI*/
 926    if(e && (amHdr->numLi >= RLC_MAX_UL_LI))
 927    {
 928       RLOG2(L_ERROR,"LI Count [%u] exceeds Max LI Count[%u]",
 929             amHdr->numLi, RLC_MAX_UL_LI);
 930       return RFAILED;
 931    }
 932
 933    /*                                first 2 bytes + Add one for  Odd LI*/
 934    pduSz -= ( amHdr->numLi + (amHdr->numLi >> 1) + 2 + (amHdr->numLi & 1) );
 935
 936    if ( totalSz >= pduSz )
 937    {
 938       RLOG3(L_ERROR,"SN [%d]:Corrupted PDU as TotSz[%lu] PduSz[%lu] ",
 939                amHdr->sn, totalSz, pduSz);
 940       return RFAILED;
 941    }
 942
 943    return ROK;
 944 }
 945 #endif
 946
 947 /**
 948  * @brief Private handler to process the status PDU
 949  *
 950  * @details
 951  *    Private handler invokded by rlcAmmProcessPdus to process the
 952  *    control PDU (status report) received from its peer RLC entity.
 953  *
 954  *        - Decode the values from the received control pdu
 955  *        - Create a RlcUdxStaPdu structure, copy the values onto it and
 956  *          send it to the DL instance for further processing
 957  *
 958  * @param[in]  gCb       RLC instance control block
 959  * @param[in]  rbCb      Uplink RB control block
 960  * @param[in]  cntrlPdu  Control PDU received from MAC
 961  * @param[in]  fByte     First byte already removed from the STATUS PDU
 962  *
 963  *  @return  Void
 964  *
 965  */
 966 void rlcAmmUlHndlStatusPdu(RlcCb *gCb, RlcUlRbCb *rbCb, Buffer *cntrlPdu, uint8_t *fByte)
 967 {
 968    uint8_t          e1;
 969    RlcExtHdr        hdrInfo;
 970    RlcUdxStaPdu     *pStaPdu;
 971    RlcUdxUlSapCb    *sapCb;
 972    uint8_t          e3; /* NACK RANGE : 5GNR */
 973    uint32_t         snLen;
 974    uint32_t         snRange;
 975    uint32_t         resrvdBitsAckSn=0;
 976    uint32_t         resrvdBitsNackSn=0;
 977
 978    RLC_MEM_ZERO(&hdrInfo, sizeof(RlcExtHdr));
 979
 980    /* Extract the Control PDU */
 981    hdrInfo.hdr  = (*fByte << 1);
 982    hdrInfo.pLen = 4;
 983
 984    /* D/C has been shifted in the calling function */
 985    if (hdrInfo.hdr & 0xE0)
 986    {
 987       DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: Reserved value for CPT received UEID:%d \
 988          CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
 989       return;
 990    }
 991
 992    sapCb = RLC_GET_UDX_SAP(gCb);
 993
 994    RLC_ALLOC_SHRABL_BUF(sapCb->pst.region,
 995                        sapCb->pst.pool,
 996                        pStaPdu,
 997                        sizeof(RlcUdxStaPdu));
 998
 999 #if (ERRCLASS & ERRCLS_ADD_RES)
1000    /* Memory allocation failure can not be expected  */
1001    if(!pStaPdu)
1002    {
1003      return;
1004    }
1005 #endif
1006
1007    if (rbCb->m.amUl.snLen == RLC_AM_CFG_12BIT_SN_LEN)
1008    {
1009       snLen = 12;
1010       resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_12BITS;
1011       resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_12BITS;
1012    }
1013    else if (rbCb->m.amUl.snLen == RLC_AM_CFG_18BIT_SN_LEN)
1014    {
1015       snLen = 18;
1016       resrvdBitsAckSn = RLC_STA_PDU_R_BITS_ACKSN_18BITS;
1017       resrvdBitsNackSn = RLC_STA_PDU_R_BITS_NACKSN_18BITS;
1018    }
1019    else
1020    {
1021       snLen = RLC_SN_LEN;
1022       resrvdBitsAckSn = 0;
1023       resrvdBitsAckSn = 0;
1024    }
1025
1026    pStaPdu->nackCnt = 0;
1027    /* For CPT */
1028    hdrInfo.hdr = hdrInfo.hdr << RLC_CPT_LEN;
1029
1030    /* ACK Sn */
1031    hdrInfo.len = snLen;
1032    rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1033    pStaPdu->ackSn = hdrInfo.val;
1034
1035    //printf ("++++++++++++ 5GNRLOG HNDL STATUS acksn %d : \n",  pStaPdu->ackSn);
1036    /* Check if NACK Exists */
1037    hdrInfo.len = RLC_E1_LEN;
1038    rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1039    e1 = (uint8_t)hdrInfo.val;
1040    DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
1041       pStaPdu->ackSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1042
1043    /* Extract the Reserved Bits after ACK SN field */
1044    hdrInfo.len = resrvdBitsAckSn;
1045    rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1046
1047    /* If NACK exists in control PDU */
1048    /* For ACKs and NACKs */
1049    while (e1 && (pStaPdu->nackCnt < RLC_MAX_NACK_CNT))
1050    {
1051       hdrInfo.len = snLen;
1052       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1053       pStaPdu->nackInfo[pStaPdu->nackCnt].sn = hdrInfo.val;
1054
1055       hdrInfo.len = RLC_E1_LEN;
1056       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1057       e1 = (uint8_t)hdrInfo.val;
1058
1059       /* Extract e2 */
1060       /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
1061          already present*/
1062       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1063       /*  e2 = (uint8_t) hdrInfo.val;*/
1064
1065       /* Store e2 value */
1066       pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (uint8_t) hdrInfo.val;
1067
1068       /* Extract e3 : 5GNR */
1069       /* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
1070          already present*/
1071       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1072       e3 = (uint8_t) hdrInfo.val;
1073
1074       /* Extract Reserved Bits after NACK SN */
1075       hdrInfo.len = resrvdBitsNackSn;
1076       rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1077
1078       /* Test for resegmentation */
1079       if (pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment)
1080       {
1081          hdrInfo.len = RLC_SO_LEN_5GNR; /* 5GNR : SO Len 16 Bits */
1082          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1083          pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = hdrInfo.val;
1084
1085          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1086          pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd   = hdrInfo.val;
1087
1088          DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: soStart and soEnd = %d %d"
1089             "UEID:%d CELLID:%d", pStaPdu->nackInfo[pStaPdu->nackCnt].soStart,
1090             pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd, rbCb->rlcId.ueId,
1091             rbCb->rlcId.cellId);
1092       }
1093       else
1094       {
1095          hdrInfo.len = 0;
1096          pStaPdu->nackInfo[pStaPdu->nackCnt].soStart = 0;
1097          pStaPdu->nackInfo[pStaPdu->nackCnt].soEnd   = 0;
1098
1099       }
1100       /* NACK RANGE Field is SET */
1101       if (e3)
1102       {
1103          /* Extract NACK range field */
1104          hdrInfo.len = RLC_NACK_RANGE_LEN;
1105          rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
1106          snRange = (uint8_t)hdrInfo.val;
1107
1108          pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
1109
1110       }
1111       pStaPdu->nackCnt++;
1112    }
1113
1114    gRlcStats.amRlcStats.numULStaPduRcvd++;
1115    gRlcStats.amRlcStats.numULNackInStaPduRcvd += pStaPdu->nackCnt;
1116
1117    /* In case we have reached the MAX NACK CNT, then we should modify the ACK_SN
1118       to the last NACK SN + 1 and discard the original ACK_SN*/
1119    if(pStaPdu->nackCnt == RLC_MAX_NACK_CNT)
1120    {
1121       pStaPdu->ackSn = (pStaPdu->nackInfo[RLC_MAX_NACK_CNT-1].sn + 1) & (rbCb->m.amUl.snModMask);
1122    }
1123
1124
1125    /* Parse & send Status PDU to RLC-DL */
1126    rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
1127
1128    return;
1129 }
1130
1131 /**
1132  * @brief Private handler to release all stored segments
1133  *
1134  * @details
1135  *    Private handler invokded by rlcAmmUlPlacePduInRecBuf to release the
1136  *    stored segements in case a complete PDU is received later.
1137  *
1138  * @param[in]  gCb      RLC instance control block
1139  * @param[in]  recBuf   Buffer that stores a received PDU or segments
1140  *
1141  * @return  Void
1142  *
1143  */
1144 void rlcAmmUlRlsAllSegs(RlcCb *gCb, RlcAmRecBuf *recBuf)
1145 {
1146    RlcSeg *seg;
1147
1148    RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1149    while (seg != NULLP)
1150    {
1151       RLC_FREE_BUF_WC(seg->seg);
1152       cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
1153       RLC_FREE_WC(gCb,seg, sizeof(RlcSeg));
1154       RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1155    }
1156
1157    return;
1158 }
1159
1160 /**
1161  * @brief Private handler to store the received segment
1162  *
1163  * @details
1164  *    Private handler invokded by rlcAmmUlPlacePduInRecBuf to add a received
1165  *    segment in reception buffer of a RBCB.
1166  *    - It is responsible for detecting duplicate segments
1167  *    - Adding it at appropriate position in the received buffer
1168  *    - Calling ExpByteSeg to set expSo field in the receiver buffer
1169  *
1170  * @param[in]  gCb      RLC instance control block
1171  * @param[in]  rbCb     Radio Bearer Contro Block
1172  * @param[in]  amHdr    AM Header received
1173  * @param[in]  pdu      Buffer received other than the headers
1174  * @param[in]  pduSz    size of the PDU buffer received
1175  *
1176  * @return  Bool
1177  *   -#TRUE  Successful insertion into the receiver buffer
1178  *   -#FALSE Possibly a duplicate segment
1179  */
1180 bool rlcAmmAddRcvdSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu, uint16_t pduSz)
1181 {
1182    RlcAmRecBuf   *recBuf = NULLP;
1183    RlcSeg        *seg;
1184    RlcSeg        *tseg;
1185    uint16_t      soEnd;       /* Holds the SoEnd of received segment */
1186    uint16_t      expSo = 0;   /* Expected SO */
1187
1188    soEnd = amHdr->so + pduSz - 1;
1189    recBuf =  rlcUtlGetRecBuf(AMUL.recBufLst, amHdr->sn);
1190
1191    if (NULLP == recBuf)
1192    {
1193       RLC_ALLOC(gCb,recBuf, sizeof(RlcAmRecBuf));
1194 #if (ERRCLASS & ERRCLS_ADD_RES)
1195       if (recBuf == NULLP)
1196       {
1197          DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
1198             rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1199
1200          RLC_FREE_BUF(pdu);
1201          return FALSE;
1202       }
1203 #endif /* ERRCLASS & ERRCLS_RES */
1204       rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, amHdr->sn);
1205    }
1206    else
1207    {
1208       if (recBuf->allRcvd == TRUE)
1209       {
1210          RLC_FREE_BUF(pdu);
1211          return FALSE;
1212       }
1213    }
1214
1215    recBuf->isDelvUpperLayer = FALSE;
1216    /* kw003.201 - Move past the segments that are different than the */
1217    /*             one received.                                      */
1218    RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1219    while ((seg != NULLP) && (seg->amHdr.so < amHdr->so))
1220    {
1221       expSo = seg->amHdr.so + seg->segSz;
1222       RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
1223    }
1224
1225    /* The received segment should start after the end of previous seg */
1226    if (expSo > amHdr->so)
1227    {
1228       /* This is a duplicate segment */
1229       gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
1230       RLC_FREE_BUF(pdu);
1231       return FALSE;
1232    }
1233
1234    if ((seg) && (seg->amHdr.so <= soEnd))
1235    {
1236       /* This is a duplicate segment */
1237       gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
1238       RLC_FREE_BUF(pdu);
1239       return FALSE;
1240    }
1241
1242    /* If we have come this far, we have to add this segment to the   */
1243    /* reception buffer as we either have eliminated duplicates or    */
1244    /* have found none.                                               */
1245    RLC_ALLOC_WC(gCb,tseg, sizeof(RlcSeg));
1246 #if (ERRCLASS & ERRCLS_ADD_RES)
1247    if (tseg == NULLP)
1248    {
1249       DU_LOG("\nRLC: rlcAmmAddRcvdSeg: Memory allocation failed UEID:%d CELLID:%d",
1250          rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1251       RLC_FREE_BUF(pdu);
1252       return FALSE;
1253    }
1254 #endif /* ERRCLASS & ERRCLS_RES */
1255
1256    tseg->seg = pdu;
1257    tseg->segSz = pduSz;
1258    RLC_MEM_CPY(&tseg->amHdr, amHdr, sizeof(RlcAmHdr));
1259    recBuf->amHdr.si = amHdr->si;
1260    recBuf->amHdr.sn = amHdr->sn;
1261    tseg->soEnd = soEnd;
1262    if (seg == NULLP)
1263    {
1264       cmLListAdd2Tail(&recBuf->segLst, &tseg->lstEnt);
1265    }
1266    else
1267    {
1268       recBuf->segLst.crnt = &seg->lstEnt;
1269       cmLListInsCrnt(&recBuf->segLst, &tseg->lstEnt);
1270    }
1271    tseg->lstEnt.node = (PTR)tseg;
1272    rlcAmmUpdExpByteSeg(gCb,&AMUL,tseg);
1273
1274    return TRUE;
1275 }
1276
1277 /**
1278  * @brief Private handler to place the PDU in the reception buffer
1279  *
1280  * @details
1281  *    This function checks if the received PDU's SN falls within the
1282  *    receiving window, after which it places the same in the reception
1283  *    buffer if its not a duplicate.
1284  *
1285  * @param[in]  gCb   RLC instance control block
1286  * @param[in]  pdu   Received PDU
1287  * @param[in]  rbCb  Uplink AM Radio Bearer
1288  * @param[out] amUl  AM UL Info
1289  *
1290  * @return Bool
1291  *     -# TRUE
1292  *     -# FALSE
1293  *
1294  */
1295 bool rlcAmmUlPlacePduInRecBuf(RlcCb *gCb, Buffer *pdu, RlcUlRbCb *rbCb, RlcAmHdr *amHdr)
1296 {
1297    RlcSn     sn;
1298    MsgLen   pduSz;
1299    RlcAmUl   *amUl = &(rbCb->m.amUl);
1300
1301    sn = amHdr->sn;
1302    SFndLenMsg(pdu, &pduSz);
1303
1304    gCb->genSts.bytesRecv += pduSz;
1305    gRlcStats.amRlcStats.numRlcAmCellSduBytesRx += pduSz;
1306    if (!RLC_AM_CHK_SN_WITHIN_RECV_WINDOW(sn, amUl))
1307    {
1308       gRlcStats.amRlcStats.numRlcAmCellDropOutWinRx++;
1309       DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: SN  %d outside the window"
1310          "UEID:%d CELLID:%d", sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1311
1312       gCb->genSts.unexpPdusRecv++;
1313       RLC_FREE_BUF(pdu);
1314       return FALSE;
1315    }
1316
1317    if (amHdr->si == 0)
1318    {
1319       RlcAmRecBuf *recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
1320
1321       /* We received a complete PDU. Either we already have it, in which */
1322       /* case we just ignore the new PDU and discard it. Otherwise,      */
1323       /* store the received PDU in the reception buffer                  */
1324       if (NULLP == recBuf)
1325       {
1326          RLC_ALLOC(gCb, recBuf, sizeof(RlcAmRecBuf));
1327 #if (ERRCLASS & ERRCLS_ADD_RES)
1328          if (recBuf == NULLP)
1329          {
1330             DU_LOG("\nRLC: rlcAmmUlPlacePduInRecBuf: Memory allocation failed \
1331                UEID:%d CELLID:%d", rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1332             RLC_FREE_BUF(pdu);
1333             return FALSE;
1334          }
1335 #endif /* ERRCLASS & ERRCLS_RES */
1336          rlcUtlStoreRecBuf(AMUL.recBufLst, recBuf, sn);
1337       }
1338       else if (recBuf->allRcvd != TRUE)
1339       {
1340          rlcAmmUlRlsAllSegs(gCb,recBuf);
1341       }
1342       else
1343       {
1344          gRlcStats.amRlcStats.numRlcAmCellDupPduRx++;
1345          gCb->genSts.unexpPdusRecv++;
1346          RLC_FREE_BUF(pdu);
1347          return FALSE;
1348       }
1349       recBuf->isDelvUpperLayer = FALSE;
1350       recBuf->pdu = pdu;
1351       recBuf->pduSz = pduSz;
1352       recBuf->allRcvd = TRUE;
1353       gRlcStats.amRlcStats.numRlcAmCellSduRx++;
1354       RLC_MEM_CPY(&recBuf->amHdr, amHdr, sizeof(RlcAmHdr));
1355       return TRUE;
1356    }
1357    else
1358    {
1359       /* We received a segment. We need to add that to the existing */
1360       /* segments, if any.                                          */
1361       return (rlcAmmAddRcvdSeg(gCb,rbCb, amHdr, pdu, pduSz));
1362    }
1363 }
1364
1365 /**
1366  * @brief Private handler to trigger status report
1367  *
1368  * @details
1369  *    Private handler invokded by rlcAmmProcessPdus to check if the
1370  *    status report need to be sent, and update the status trigger
1371  *    flag accordingly based on status prohibit timer.
1372  *
1373  *    - Check if the received pdu's sn is less than rxHighestStatus, set the
1374  *      staTrg flag.
1375  *    - If staProhTmr is not running, calculate cntrlBo, else it'll be
1376  *      updated at the expiry of staProhTmr.
1377  *    - Expiry of reOrdTmr also will set staTrg flag.
1378  *
1379  * @param[in]  gCb       RLC instance control block
1380  * @param[in]  rbCb      Uplink RB control block
1381  * @param[in]  sn        Sequence number of the pdu based on which to check if
1382  *                       status needs to be triggered
1383  * @param[in]  discFlg   Whether this pdu was discarded or not
1384  *
1385  * @return  Void
1386  *
1387  */
1388 void rlcAmmTriggerStatus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcSn sn, bool discFlg)
1389 {
1390    bool     tmrRunning;
1391    RlcSn     tSn;
1392    RlcSn     tVrMr;
1393    RlcSn     trxHighestStatus;
1394    RlcAmUl   *amUl = &(rbCb->m.amUl);
1395
1396    MODAMR(amUl->vrMr, tVrMr, amUl->rxNext, amUl->snModMask);
1397    MODAMR(amUl->rxHighestStatus, trxHighestStatus, amUl->rxNext, amUl->snModMask);
1398    MODAMR(sn , tSn, amUl->rxNext, amUl->snModMask);
1399
1400    /* kw005.201 Product CR ccpu00117114       *
1401     * The "=" in the 2nd condition is removed */
1402    if ((discFlg) || (tSn < trxHighestStatus) || (tSn >= tVrMr))
1403    {
1404       DU_LOG("\nRLC: rlcAmmTriggerStatus: Set Status Trigger UEID:%d CELLID:%d",
1405          rbCb->rlcId.ueId, rbCb->rlcId.cellId);
1406
1407       amUl->staTrg = TRUE;
1408       amUl->gatherStaPduInfo = FALSE;
1409
1410       /* Check if staProhTmr is running */
1411       tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1412
1413       if (!tmrRunning)
1414       {
1415          amUl->gatherStaPduInfo = TRUE;
1416       }
1417    }
1418
1419    return;
1420 }
1421
1422 /**
1423  * @brief Private handler to reassemble from a segment or a PDU
1424  *
1425  * @details
1426  *    Private handler invokded by kwAmmReassembleSdus with either a
1427  *    PDU or a segment of a PDU. This is also called in the case of
1428  *    reestablishment and hence out of sequence joining is also to
1429  *    be supported
1430  *
1431  *
1432  * @param[in]  gCb     RLC instance control block
1433  * @param[in]  rbCb    Uplink RB control block
1434  * @param[in]  amHdr   AM header received for this segment/PDU
1435  * @param[in]  pdu     PDU to be reassembled
1436  *
1437  * @return  Void
1438  *
1439  */
1440 void rlcAmmProcPduOrSeg(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmHdr *amHdr, Buffer *pdu)
1441 {
1442
1443    if ((AMUL.expSn != amHdr->sn) || (AMUL.expSo != amHdr->so))
1444    {
1445       /* Release the existing partial SDU as we have PDUs or */
1446       /* segments that are out of sequence                   */
1447       rbCb->m.amUl.isOutOfSeq = TRUE;
1448       RLC_FREE_BUF(AMUL.partialSdu);
1449    }
1450
1451    //if (amHdr->fi & RLC_FI_FIRST_SEG)
1452    if (amHdr->si == 0x01)
1453    {/* first Segment of the SDU */
1454       if (AMUL.partialSdu != NULLP)
1455       { /* Some old SDU may be present */
1456          RLC_FREE_BUF_WC(AMUL.partialSdu);
1457       }
1458       AMUL.partialSdu = pdu;
1459       pdu = NULLP;
1460    }
1461    else if(amHdr->si == 0x03)
1462    {/* Middle or last segment of the SUD */
1463       ODU_CAT_MSG(AMUL.partialSdu,pdu, M1M2);
1464       RLC_FREE_BUF_WC(pdu);
1465       pdu = NULLP;
1466    }
1467    else if (amHdr->si ==  0x02)
1468    {
1469       ODU_CAT_MSG(pdu,AMUL.partialSdu,M2M1);
1470       RLC_FREE_BUF_WC(AMUL.partialSdu);
1471    }
1472
1473    if (pdu != NULLP)
1474    {
1475       AMUL.partialSdu = NULLP;
1476       rlcUtlSendUlDataToDu(gCb,rbCb, pdu);
1477    }
1478
1479    return;
1480 }
1481
1482 /**
1483  *
1484  * @brief Private handler to reassemble SDUs
1485  *
1486  * @details
1487  *    Private handler invokded by rlcAmmProcessPdus with the PDU
1488  *    from the reception buffer in sequence to reassemble SDUs and
1489  *    send it to PDCP.
1490  *
1491  *        - With the stored header info, FI and LSF segment / concatenate
1492  *          PDUs or byte segments of PDUs to get the associated SDU.
1493  *
1494  * @param[in]  rbCb     RB control block
1495  * @param[in]  pdu      PDU to be reassembled
1496  *
1497  *  @return  S16
1498  *      -# ROK
1499  *      -# RFAILED
1500  *
1501  */
1502 uint8_t rlcAmmUlReassembleSdus(RlcCb *gCb, RlcUlRbCb *rbCb, RlcAmRecBuf *recBuf)
1503 {
1504    RlcSeg        *seg;
1505
1506    //if (recBuf->amHdr.rf == 0)
1507    if (recBuf->amHdr.si == 0)
1508    {
1509       /* This is a PDU */
1510       rlcAmmProcPduOrSeg(gCb,rbCb, &recBuf->amHdr, recBuf->pdu);
1511       /* Assign NULLP to recBuf->pdu as this PDU is sent to PDCP */
1512       recBuf->pdu = NULLP;
1513       AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
1514       AMUL.expSo = 0;
1515    }
1516    else
1517    {
1518       /* This is a set of segments */
1519       RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1520       AMUL.expSn = recBuf->amHdr.sn;
1521       AMUL.expSo = 0;
1522       while(seg)
1523       {
1524          rlcAmmProcPduOrSeg(gCb,rbCb, &seg->amHdr, seg->seg);
1525          AMUL.expSo = seg->soEnd + 1;
1526
1527          cmLListDelFrm(&(recBuf->segLst),&(seg->lstEnt));
1528          RLC_FREE_WC(gCb, seg, sizeof(RlcSeg));
1529
1530          RLC_LLIST_FIRST_SEG(recBuf->segLst, seg);
1531       }
1532       AMUL.expSn = (recBuf->amHdr.sn + 1) & (AMUL.snModMask); /* MOD 1024 */
1533       AMUL.expSo = 0;
1534    }
1535
1536    return ROK;
1537 }
1538
1539 /**
1540  * @brief   Handler to process the re-establishment request received from UIM
1541  *
1542  * @param[in] gCb         RLC instance control block
1543  * @param[in] rlcId       RLC identifier
1544  * @param[in] sendReEst   Whether to send back restablishment complete or not
1545  * @param[in] rbCb        Uplink RB control block
1546  *
1547  * @return  Void
1548  *
1549  */
1550 #ifdef ANSI
1551 Void rlcAmmUlReEstablish
1552 (
1553 RlcCb         *gCb,
1554 CmLteRlcId   rlcId,
1555 Bool         sendReEst,
1556 RlcUlRbCb     *rbCb
1557 )
1558 #else
1559 Void rlcAmmUlReEstablish(gCb, rlcId, sendReEst, rbCb)
1560 RlcCb         *gCb;
1561 CmLteRlcId   rlcId;
1562 Bool         sendReEst;
1563 RlcUlRbCb     *rbCb;
1564 #endif
1565 {
1566    RlcSn   sn;
1567    RlcSn   mSn;
1568    RlcSn   mVrMr;
1569
1570 #ifndef KW_PDCP
1571    RlcKwuSapCb *rlcKwuSap;
1572 #endif
1573    RlcAmRecBuf   *recBuf = NULLP;
1574
1575    sn = AMUL.rxNext;
1576
1577    MODAMR(AMUL.vrMr, mVrMr, AMUL.rxNext, AMUL.snModMask);
1578    MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
1579
1580    /* Reassemble SDUs from PDUs with SN less than upper edge of the window */
1581    while (mSn < mVrMr)
1582    {
1583       recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
1584       if (NULLP != recBuf)
1585       {
1586          if (recBuf->allRcvd == TRUE)
1587          {
1588             rlcAmmUlReassembleSdus(gCb,rbCb, recBuf);
1589          }
1590          else
1591          {
1592             /* Remove PDU and segments */
1593             if(recBuf->pdu)
1594             {
1595                RLC_FREE_BUF_WC(recBuf->pdu);
1596             }
1597             /* Release all the segments*/
1598             rlcAmmUlRlsAllSegs(gCb,recBuf);
1599          }
1600          rlcUtlDelRecBuf(AMUL.recBufLst, recBuf, gCb);
1601       }
1602       sn = (sn + 1) & (AMUL.snModMask); /* MOD 1024 */
1603       MODAMR(sn, mSn, AMUL.rxNext, AMUL.snModMask);
1604    }
1605    /* Discard remaining PDUs and bytesegments in recBuf */
1606
1607    /* Stop all timers and reset variables */
1608    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
1609    {
1610        rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
1611    }
1612    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
1613    {
1614        rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1615    }
1616
1617    AMUL.rxNext  = 0;
1618    AMUL.rxNextHighestRcvd  = 0;
1619    AMUL.rxNextStatusTrig  = 0;
1620    rbCb->m.amUl.vrMr = (rbCb->m.amUl.rxNext + RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) & (rbCb->m.amUl.snModMask);
1621    AMUL.rxHighestStatus = 0;
1622    AMUL.staTrg  = FALSE;
1623    AMUL.gatherStaPduInfo = FALSE;
1624    AMUL.expSn = 0;
1625    AMUL.expSo = 0;
1626    if (AMUL.partialSdu != NULLP)
1627    {
1628      RLC_FREE_BUF(AMUL.partialSdu);
1629    }
1630    rlcKwuSap = gCb->u.ulCb->rlcKwuUlSap + RLC_UI_PDCP;
1631
1632    if(sendReEst)
1633    {
1634       RlcUiKwuReEstCmpInd(&rlcKwuSap->pst, rlcKwuSap->suId, rlcId);
1635       rbCb->m.amUl.isOutOfSeq = FALSE;
1636    }
1637
1638    return;
1639 }
1640
1641 /**
1642  * @brief  Handler for reorder timer expiry
1643  *
1644  * @details
1645  *    This function is used to handle events upon expiry of reorder timer
1646  *
1647  *  @param[in] gCb   RLC instance control block
1648  *  @param[in] rbCb  RB control block
1649  *
1650  *  @return  Void
1651  *
1652  */
1653
1654 #ifdef ANSI
1655 Void rlcAmmReOrdTmrExp
1656 (
1657 RlcCb        *gCb,
1658 RlcUlRbCb    *rbCb
1659 )
1660 #else
1661 Void rlcAmmReOrdTmrExp(rbCb)
1662 RlcCb        *gCb;
1663 RlcUlRbCb    *rbCb;
1664 #endif
1665 {
1666    RlcAmUl *amUl = &(rbCb->m.amUl);
1667    RlcSn sn;
1668    RlcSn mSn;
1669    RlcSn mVrMr;
1670    RlcSn mrxHighestStatus;
1671    RlcSn mrxNextHighestRcvd;
1672    Bool tmrRunning = FALSE;
1673    RlcAmRecBuf   *recBuf = NULLP;
1674
1675    /* Update rxHighestStatus */
1676    sn = amUl->rxNextStatusTrig;
1677
1678    MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
1679    MODAMR(amUl->vrMr, mVrMr, amUl->rxNext, amUl->snModMask);
1680    recBuf = rlcUtlGetRecBuf(AMUL.recBufLst, sn);
1681
1682    while (mSn < mVrMr)
1683    {
1684       if ((recBuf == NULLP) ||
1685           ((recBuf != NULLP) && (!recBuf->allRcvd)) )
1686       {
1687          amUl->rxHighestStatus = sn;
1688          amUl->staTrg = TRUE;
1689          amUl->gatherStaPduInfo = FALSE;
1690
1691          /* Check if staProhTmr is running */
1692          tmrRunning = rlcChkTmr(gCb,(PTR) rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1693
1694          if (!tmrRunning)
1695          {
1696             gRlcStats.amRlcStats.numULReOrdTimerExpires++;
1697             amUl->gatherStaPduInfo = TRUE;
1698             rlcAmmUlAssembleCntrlInfo(gCb, rbCb);
1699          }
1700
1701          break;
1702       }
1703       sn = (sn + 1) & (amUl->snModMask);
1704       MODAMR(sn, mSn, amUl->rxNext, amUl->snModMask);
1705    }
1706
1707    /* Update rxNextStatusTrig */
1708    MODAMR(amUl->rxNextHighestRcvd, mrxNextHighestRcvd, amUl->rxNext, amUl->snModMask);
1709    MODAMR(amUl->rxHighestStatus, mrxHighestStatus, amUl->rxNext, amUl->snModMask);
1710    if (mrxNextHighestRcvd > mrxHighestStatus)
1711    {
1712       rlcStartTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
1713       amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
1714    }
1715
1716    return;
1717 } /* rlcAmmReOrdTmrExp */
1718
1719 /**
1720  * @brief  Handler for status prohibit timer expiry
1721  *
1722  * @details
1723  *    This function is used to handle events upon expiry of status prohibit
1724  *    timer
1725  *
1726  *  @param[in] gCb   RLC instance control block
1727  *  @param[in] rbCb   RB control block
1728  *
1729  *  @return  Void
1730  *
1731  */
1732
1733 #ifdef ANSI
1734 Void rlcAmmStaProTmrExp
1735 (
1736 RlcCb        *gCb,
1737 RlcUlRbCb    *rbCb
1738 )
1739 #else
1740 Void rlcAmmStaProTmrExp(gCb, rbCb)
1741 RlcCb        *gCb;
1742 RlcUlRbCb    *rbCb;
1743 #endif
1744 {
1745    RlcAmUl *amUl = &(rbCb->m.amUl);
1746
1747    amUl->gatherStaPduInfo = FALSE;
1748
1749    if (amUl->staTrg == TRUE)
1750    {
1751       amUl->gatherStaPduInfo = TRUE;
1752       /* kw002.201 : Sending StaRsp after StaProhibit tmr expiry */
1753       rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
1754    }
1755
1756    return;
1757 } /* rlcAmmStaProTmrExp */
1758
1759 /**
1760  * @brief  Handler to extract an element of AM Header
1761  *
1762  * @details
1763  *    This function is used to extract an element of AM header.
1764  *
1765  * @param[in]     pdu      The pdu to be decoded
1766  * @param[in,out] hdrInfo  Container to hold the decoded info
1767  *
1768  * @return Void
1769  *
1770  */
1771
1772 void rlcAmmExtractElmnt(RlcCb *gCb, Buffer *pdu, RlcExtHdr *hdrInfo)
1773 {
1774    uint8_t   hdr;
1775    uint8_t   pLen = hdrInfo->pLen;
1776    uint8_t   len  = (uint8_t)hdrInfo->len;
1777    uint32_t  val;
1778    uint8_t   tHdr;
1779    uint8_t   fLen;
1780    uint8_t   rLen;
1781    /* uint8_t   rLen1 = 0; */
1782    uint16_t  tVal;
1783
1784    hdr = hdrInfo->hdr;
1785
1786    if (pLen == 0)
1787    {
1788       ODU_REM_PRE_MSG(&hdr, pdu);
1789       pLen = 8;
1790    }
1791    tHdr = hdr;
1792    if (len <= 8)
1793    {
1794       val = tHdr >> (RLC_BYTE_LEN - (len));
1795       hdr =  hdr << len;
1796       pLen -= len;
1797    }
1798    else /*if (len > 8) */
1799    {
1800       fLen = pLen;
1801       val = tHdr;
1802       val = val >> (RLC_BYTE_LEN - fLen);
1803       val = val << (len - fLen);
1804       rLen = len - fLen;
1805       ODU_REM_PRE_MSG(&hdr, pdu);
1806       tHdr = hdr;
1807       if (rLen <= 8)
1808       {
1809          hdr = hdr >> (RLC_BYTE_LEN - rLen);
1810          val = val | hdr;
1811          hdr = tHdr << rLen;
1812          pLen = (RLC_BYTE_LEN - rLen);
1813       }
1814       else
1815       {
1816         rLen = rLen - RLC_BYTE_LEN;
1817         tVal = hdr;
1818         tVal = tVal << rLen;
1819         val = val | tVal;
1820
1821         ODU_REM_PRE_MSG(&hdr, pdu);
1822         tHdr = hdr;
1823         hdr = hdr >> (RLC_BYTE_LEN - rLen);
1824         val = val | hdr;
1825         hdr = tHdr << rLen;
1826         pLen = (RLC_BYTE_LEN - rLen);
1827       }
1828    }
1829
1830    hdrInfo->pLen = pLen;
1831    hdrInfo->hdr = hdr;
1832    hdrInfo->val = val;
1833
1834    return;
1835 }
1836
1837 /**
1838  * @brief  Handler to updated expected byte seg
1839  *
1840  * @details
1841  *    This function is used to update expected byte segment. The next segment
1842  *    expected is indicated by the SO of the segment which is expected. Intially
1843  *    the segment with SO 0 is expected and then in order. When all the segments
1844  *    are received (which would happen when an expected SO is encountered
1845  *    with LSF set) the allRcvd flag is set to TRUE
1846  *
1847  * @param[in]  gCb   RLC instance control block
1848  * @param[in]  amUl  AM Uplink Control Block
1849  * @param[in]  seg   Newly received segment
1850  *
1851  * @return Void
1852  *
1853  */
1854
1855 void rlcAmmUpdExpByteSeg(RlcCb *gCb, RlcAmUl *amUl, RlcSeg *seg)
1856 {
1857    uint16_t  newExpSo; /* The new expected SO */
1858    RlcSn     sn = seg->amHdr.sn;
1859    bool      lstRcvd=FALSE;
1860    RlcAmRecBuf *recBuf = NULLP;
1861
1862    recBuf = rlcUtlGetRecBuf(amUl->recBufLst, sn);
1863    if ((recBuf == NULLP) || (recBuf && (seg->amHdr.so != recBuf->expSo)))
1864    {
1865       return;
1866    }
1867
1868    newExpSo   = seg->soEnd + 1;
1869    recBuf->expSo = newExpSo;
1870    //lstRcvd = seg->amHdr.lsf;
1871    if(seg->amHdr.si == 0x2)
1872    {
1873       lstRcvd = TRUE;
1874    }
1875    /* kw003.201 - This should update seg with the one after newSeg */
1876    RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
1877    while(seg)
1878    {
1879       /* keep going ahead as long as the expectedSo match with the header so
1880          else store the expSo for later checking again */
1881       if(seg->amHdr.si == 0x2)
1882       {
1883          lstRcvd = TRUE;
1884       }
1885       if (seg->amHdr.so == newExpSo)
1886       {
1887          newExpSo = seg->soEnd + 1;
1888          recBuf->expSo = newExpSo;
1889          //lstRcvd = seg->amHdr.lsf;
1890          RLC_LLIST_NEXT_SEG(recBuf->segLst, seg);
1891       }
1892       else
1893       {
1894          recBuf->expSo = newExpSo;
1895          return;
1896       }
1897    }
1898    if (lstRcvd == TRUE)
1899    {
1900       recBuf->allRcvd = TRUE;
1901       gRlcStats.amRlcStats.numRlcAmCellSduRx++;
1902    }
1903
1904    return;
1905 }
1906
1907 /**
1908  * @brief
1909  *   Function to release/free the Acknowledged Mode Module  RbCb buffers
1910  *
1911  * @details
1912  *   This primitive Frees the AM RbCb transmission Buffer, retransmission
1913  *   Buffer and reciption Buffers
1914  *
1915  * @param [in]   gCb   - RLC instance Control Block
1916  * @param [in]   rbCb  - RB Control Block
1917  *
1918  * @return   void
1919  */
1920 #ifdef ANSI
1921 Void rlcAmmFreeUlRbCb
1922 (
1923 RlcCb       *gCb,
1924 RlcUlRbCb   *rbCb
1925 )
1926 #else
1927 Void rlcAmmFreeUlRbCb(gCb,rbCb)
1928 RlcCb       *gCb;
1929 RlcUlRbCb   *rbCb;
1930 #endif
1931 {
1932    RlcSn         curSn = 0;           /* Sequence number of PDU */
1933    RlcSn         windSz;              /* PDU window size */
1934    RlcAmRecBuf *recBuf = NULLP;
1935
1936    windSz  =  (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)) << 1;
1937
1938    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_REORD_TMR))
1939    {
1940       rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_REORD_TMR);
1941    }
1942    if(TRUE == rlcChkTmr(gCb,(PTR)rbCb,RLC_EVT_AMUL_STA_PROH_TMR))
1943    {
1944       rlcStopTmr(gCb,(PTR)rbCb, RLC_EVT_AMUL_STA_PROH_TMR);
1945    }
1946
1947
1948    /* on the first loop winSz is always greater than zero
1949     while( ( curSn < windSz ) hence changing to do while */
1950    do
1951    {
1952       recBuf = rlcUtlGetRecBuf(rbCb->m.amUl.recBufLst, curSn);
1953       if ( recBuf != NULLP )
1954       {
1955          if (recBuf->pdu != NULLP)
1956          {
1957             RLC_FREE_BUF_WC(recBuf->pdu);
1958          }
1959          /* Release all the segments */
1960          rlcAmmUlRlsAllSegs(gCb,recBuf);
1961          rlcUtlDelRecBuf(rbCb->m.amUl.recBufLst, recBuf, gCb);
1962       }
1963       curSn++;
1964    }while ( curSn < windSz );
1965
1966 #ifndef LTE_TDD
1967       RLC_FREE_WC(gCb,rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
1968       rbCb->m.amUl.recBufLst = NULLP;
1969 #endif
1970
1971    if(rbCb->m.amUl.partialSdu != NULLP)
1972    {
1973       RLC_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
1974    }
1975    return;
1976 } /* rlcAmmFreeUlRbCb */
1977
1978
1979 /*@}*/
1980
1981 \f
1982 /********************************************************************30**
1983
1984          End of file
1985 **********************************************************************/