src/5gnrrlc/kw_lim.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:    LTE-RLC Layer - Lower Interface Functions
  22
  23      Type:    C file
  24
  25      Desc:     Source code for RLC Lower Interface Module.
  26                This file contains following functions
  27
  28         --KwLiRguBndCfm
  29         --KwLiRguCDatInd
  30         --KwLiRguDDatInd
  31         --KwLiRguCStaInd
  32         --KwLiRguDStaInd
  33         --KwLiRguHqStaInd
  34
  35      File:     kw_lim.c
  36
  37 **********************************************************************/
  38 static const char* RLOG_MODULE_NAME="LIM";
  39 static int RLOG_MODULE_ID=2048;
  40 static int RLOG_FILE_ID=196;
  41
  42 /**
  43  * @file kw_lim.c
  44  * @brief RLC Lower Interface module
  45 */
  46
  47 #define KW_MODULE KW_DBGMASK_INF
  48
  49 \f
  50 /* header (.h) include files */
  51 #include "envopt.h"        /* environment options */
  52 #include "envdep.h"        /* environment dependent */
  53 #include "envind.h"        /* environment independent */
  54
  55 #include "gen.h"           /* general */
  56 #include "ssi.h"           /* system services */
  57 #include "cm5.h"           /* common timer defines */
  58 #include "cm_tkns.h"       /* common tokens defines */
  59 #include "cm_mblk.h"       /* common memory allocation library defines */
  60 #include "cm_llist.h"      /* common link list  defines  */
  61 #include "cm_hash.h"       /* common hash list  defines */
  62 #include "cm_lte.h"        /* common LTE defines */
  63 #include "lkw.h"           /* LKW defines */
  64 #include "ckw.h"           /* CKW defines */
  65 #include "kwu.h"           /* KWU defines */
  66 #include "rgu.h"           /* RGU defines */
  67 #include "kw_err.h"
  68 #include "kw_env.h"        /* RLC environment options */
  69
  70 #include "kw.h"            /* RLC defines */
  71 #include "kw_udx.h"
  72 #include "kw_dl.h"
  73 #include "kw_ul.h"
  74
  75 /* extern (.x) include files */
  76 #include "gen.x"           /* general */
  77 #include "ssi.x"           /* system services */
  78
  79 #include "cm5.x"           /* common timer library */
  80 #include "cm_tkns.x"       /* common tokens */
  81 #include "cm_mblk.x"       /* common memory allocation */
  82 #include "cm_llist.x"      /* common link list */
  83 #include "cm_hash.x"       /* common hash list */
  84 #include "cm_lte.x"        /* common LTE includes */
  85 #include "cm_lib.x"        /* common memory allocation library */
  86 #include "lkw.x"           /* LKW */
  87 #include "ckw.x"           /* CKW */
  88 #include "kwu.x"           /* KWU */
  89 #include "rgu.x"           /* RGU */
  90
  91 #include "kw.x"
  92 #include "kw_udx.x"
  93 #include "kw_dl.x"
  94 #include "kw_ul.x"
  95
  96 #ifdef __cplusplus
  97 EXTERN "C" {
  98 #endif /* __cplusplus */
  99
 100 \f
 101 /*****************************************************************************
 102  *                          RGU INTERFACE
 103  ****************************************************************************/
 104 /**
 105  * @brief Handler for bind confirmation from MAC.
 106  *
 107  * @details
 108  *    This function handles the bind confirmation received from MAC. If the
 109  *    bind was successful changes the state of the SAP to KW_SAP_BND
 110  *    else KW_SAP_CFG. Sends an alarm to LM in any case
 111  *
 112  * @param[in] pst     Post structure
 113  * @param[in] suId    Service User ID
 114  * @param[in] status  Status whether the bind was successful or not
 115  *
 116  * @return  S16
 117  *    -# ROK
 118  *    -# RFAILED
 119  *
 120 */
 121 #ifdef ANSI
 122 PUBLIC S16 KwLiRguBndCfm
 123 (
 124 Pst    *pst,
 125 SuId   suId,
 126 U8     status
 127 )
 128 #else
 129 PUBLIC S16 KwLiRguBndCfm (pst, suId, status)
 130 Pst    *pst;
 131 SuId   suId;
 132 U8     status;
 133 #endif
 134 {
 135    U16          event;     /* Event */
 136    U16          cause;     /* Cause */
 137    KwRguSapCb   *rguSap;   /* RGU SAP Control Block */
 138    KwCb         *tKwCb;
 139
 140    TRC3(KwLiRguBndCfm)
 141
 142 #if (ERRCLASS & ERRCLS_INT_PAR)
 143    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 144    {
 145       RETVALUE (RFAILED);
 146    }
 147 #endif
 148    tKwCb = KW_GET_KWCB(pst->dstInst);
 149
 150    RLOG2(L_DEBUG,"KwLiRguBndCfm(suId(%d), status(%d)", suId, status);
 151
 152 #if (ERRCLASS & ERRCLS_INT_PAR)
 153    if (tKwCb->init.cfgDone != TRUE)
 154    {
 155       RLOG0(L_FATAL,"General configuration not done");
 156
 157       KW_SEND_SAPID_ALARM(tKwCb,suId,LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_STATE);
 158
 159       RETVALUE(RFAILED);
 160    }
 161
 162    if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0))
 163    {
 164       RLOG0(L_ERROR, "Invalid suId");
 165
 166       KW_SEND_SAPID_ALARM(tKwCb,suId, LKW_EVENT_LI_BND_CFM, LCM_CAUSE_INV_SUID);
 167
 168       RETVALUE(RFAILED);
 169    }
 170 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 171
 172    rguSap = (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
 173             &(tKwCb->u.dlCb->rguDlSap[suId]) : &(tKwCb->u.ulCb->rguUlSap[suId]);
 174
 175    RLOG1(L_DEBUG, "KwLiRguBndCfm: For RGU SAP state=%d", rguSap->state)
 176
 177    switch (rguSap->state)
 178    {
 179       case KW_SAP_BINDING:
 180       {
 181          kwStopTmr (tKwCb,(PTR)rguSap, KW_EVT_WAIT_BNDCFM);
 182
 183          rguSap->retryCnt = 0;
 184
 185          if (status == CM_BND_OK)
 186          {
 187             rguSap->state = KW_SAP_BND;
 188             event = LCM_EVENT_BND_OK;
 189             cause = LKW_CAUSE_SAP_BNDENB;
 190          }
 191          else
 192          {
 193             rguSap->state = KW_SAP_CFG;
 194             event = LCM_EVENT_BND_FAIL;
 195             cause = LKW_CAUSE_UNKNOWN;
 196          }
 197
 198          break;
 199       }
 200       default:
 201          event = LKW_EVENT_RGU_BND_CFM;
 202          cause = LCM_CAUSE_INV_STATE;
 203          break;
 204    }
 205
 206    /* Send an alarm with proper event and cause */
 207    KW_SEND_SAPID_ALARM(tKwCb, suId, event, cause);
 208
 209    RETVALUE(ROK);
 210 } /* KwLiRguBndCfm */
 211
 212 /**
 213  * @brief Handler to process PDU received from MAC
 214  *
 215  * @details
 216  *    This function receives the PDU from MAC.
 217  *    seggregates common and dedicated logical channel
 218  *    PDU and call respective handler.
 219  *
 220  * @param[in] pst     Post structure
 221  * @param[in] suId    Service User ID
 222  * @param[in] datInd  Data Indication Information
 223  *
 224  * @return  S16
 225  *    -# ROK
 226  *    -# RFAILED
 227  *
 228 */
 229
 230 PUBLIC S16 RlcMacProcUlData(Pst *pst, SuId suId, RlcMacData *ulData)
 231 {
 232    U8              idx;
 233    U8              lcId;                    /* Logical Channel */
 234    U8              numDLch = 0;             /* Number of dedicated logical channel */
 235    Bool            dLchPduPres;             /* PDU received on dedicated logical channel */
 236    RguLchDatInd    dLchData[RGU_MAX_LC];  /* PDU info on dedicated logical channel */
 237    RguDDatIndInfo  *dLchUlDat;               /* UL data on dedicated logical channel */
 238    RguCDatIndInfo  *cLchUlDat;               /* UL data on common logical channel */
 239
 240    /* Initializing dedicated logical channel Database */
 241    for(idx = 0; idx < RGU_MAX_LC; idx++)
 242    {
 243       dLchData[idx].lcId = idx;
 244       dLchData[idx].pdu.numPdu = 0;
 245    }
 246
 247    dLchPduPres = FALSE;
 248
 249    /* Seggregate PDUs received on common and dedicated channels
 250     * and call common channel's handler */
 251    for(idx = 0; idx< ulData->nmbPdu; idx++)
 252    {
 253       if(ulData->pduInfo[idx].commCh)
 254       {
 255          KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchUlDat, sizeof(RguCDatIndInfo));
 256          cmMemset((U8*)cLchUlDat, (U8)0, sizeof(RguCDatIndInfo));
 257
 258          cLchUlDat->cellId = ulData->cellId;
 259          cLchUlDat->rnti   = ulData->rnti;
 260          cLchUlDat->lcId   = ulData->pduInfo[idx].lcId;
 261          cLchUlDat->pdu    = ulData->pduInfo[idx].pduBuf;
 262
 263          KwLiRguCDatInd(pst, suId, cLchUlDat);
 264       }
 265       else
 266       {
 267          if(!dLchPduPres)
 268          {
 269             KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchUlDat, sizeof(RguDDatIndInfo));
 270             dLchPduPres = TRUE;
 271          }
 272
 273          lcId = ulData->pduInfo[idx].lcId;
 274          dLchData[lcId].pdu.mBuf[dLchData[lcId].pdu.numPdu] = ulData->pduInfo[idx].pduBuf;
 275          dLchData[lcId].pdu.numPdu++;
 276       }
 277    }
 278
 279    /* If any PDU received on dedicated logical channel, copy into RguDDatIndInfo
 280     * and call its handler */
 281    if(dLchPduPres)
 282    {
 283       dLchUlDat->cellId = ulData->cellId;
 284       dLchUlDat->rnti   = ulData->rnti;
 285
 286       for(idx = 0; idx < RGU_MAX_LC; idx++)
 287       {
 288          if(dLchData[idx].pdu.numPdu)
 289          {
 290             cmMemcpy((U8 *)&dLchUlDat->lchData[numDLch], (U8 *)&dLchData[idx], sizeof(RguLchDatInd));
 291             numDLch++;
 292          }
 293       }
 294       dLchUlDat->numLch = numDLch;
 295       KwLiRguDDatInd(pst, suId, dLchUlDat);
 296    }
 297
 298
 299    KW_FREE_SHRABL_BUF(pst->region, pst->pool, ulData, sizeof(RlcMacData));
 300    RETVALUE(ROK);
 301
 302 }/* End of RlcMacProcUlData */
 303
 304 PUBLIC int   rlcDDatIndRcvd;
 305 PUBLIC int   rlcCDatIndRcvd;
 306 /**
 307  * @brief Handler to process PDU received from MAC for common logical channels.
 308  *
 309  * @details
 310  *    This function receives the PDU from MAC for common logical channels
 311  *    does checks before handing over the PDU to the TM module
 312  *
 313  * @param[in] pst     Post structure
 314  * @param[in] suId    Service User ID
 315  * @param[in] datInd  Data Indication Information
 316  *
 317  * @return  S16
 318  *    -# ROK
 319  *    -# RFAILED
 320  *
 321 */
 322 #ifdef ANSI
 323 PUBLIC S16 KwLiRguCDatInd
 324 (
 325 Pst              *pst,
 326 SuId             suId,
 327 RguCDatIndInfo   *datInd
 328 )
 329 #else
 330 PUBLIC S16 KwLiRguCDatInd(pst,suId,datInd)
 331 Pst              *pst;
 332 SuId             suId;
 333 RguCDatIndInfo   *datInd;
 334 #endif
 335 {
 336    KwUlRbCb   *rbCb;
 337    KwCb       *tKwCb;
 338
 339    rlcCDatIndRcvd++;
 340    TRC3(KwLiRguCDatInd)
 341
 342 #if (ERRCLASS & ERRCLS_INT_PAR)
 343    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 344    {
 345       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
 346       RETVALUE (RFAILED);
 347    }
 348 #endif
 349
 350    tKwCb = KW_GET_KWCB(pst->dstInst);
 351
 352
 353 #if (ERRCLASS & ERRCLS_DEBUG)
 354    if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
 355    {
 356       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
 357       RETVALUE(RFAILED);
 358    }
 359 #endif
 360
 361    /* kw006.201 ccpu00120058, Added array boundary condition check */
 362 #if (ERRCLASS & ERRCLS_DEBUG)
 363    if(KW_MAX_LCH_PER_CELL <= datInd->lcId)
 364    {
 365       RLOG_ARG1(L_ERROR,DBG_LCID,datInd->lcId, "Invalid LcId, Max is [%d]",
 366          KW_MAX_LCH_PER_CELL);
 367       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
 368       RETVALUE(RFAILED);
 369    }
 370 #endif /* (ERRCLASS & ERRCLS_DEBUG) */
 371
 372    /* Fetch RbCb from lcId */
 373    kwDbmFetchUlRbCbFromLchId(tKwCb, 0, datInd->cellId, datInd->lcId, &rbCb);
 374    if (!rbCb)
 375    {
 376       RLOG_ARG1(L_ERROR, DBG_CELLID,datInd->cellId, "LcId [%d] not found",
 377          datInd->lcId);
 378       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
 379       RETVALUE(RFAILED);
 380    }
 381
 382    /* Dispatch to TM Module */
 383 #ifdef CCPU_OPT
 384    kwTmmRcvFrmLi(tKwCb, rbCb, datInd->rnti, datInd->pdu);
 385 #else /* CCPU_OPT */
 386    kwTmmRcvFrmLi(tKwCb, rbCb, datInd->pdu);
 387 #endif /* CCPU_OPT */
 388
 389    KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguCDatIndInfo));
 390
 391    RETVALUE(ROK);
 392 } /* KwLiRguCDatInd */
 393
 394 /**
 395  * @brief Handler to process PDU received from MAC for
 396  *        dedicated logical channels.
 397  *
 398  * @details
 399  *    This function receives the PDU from MAC for one or more dedicated
 400  *    logical channels and passes it to the UTL module for further processing
 401  *
 402  * @param[in] pst     Post structure
 403  * @param[in] suId    Service User ID
 404  * @param[in] datInd  Data Indication Information
 405  *
 406  * @return  S16
 407  *    -# ROK
 408  *    -# RFAILED
 409  *
 410 */
 411
 412 #ifdef ANSI
 413 PUBLIC S16 KwLiRguDDatInd
 414 (
 415 Pst              *pst,
 416 SuId             suId,
 417 RguDDatIndInfo   *datInd
 418 )
 419 #else
 420 PUBLIC S16 KwLiRguDDatInd(pst, suId, datInd)
 421 Pst              *pst;
 422 SuId             suId;
 423 RguDDatIndInfo   *datInd;
 424 #endif
 425 {
 426    TRC3(KwLiRguDDatInd)
 427
 428    rlcDDatIndRcvd++;
 429 #if (ERRCLASS & ERRCLS_INT_PAR)
 430    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 431    {
 432        KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
 433        RETVALUE (RFAILED);
 434    }
 435 #endif
 436
 437 #if (ERRCLASS & ERRCLS_DEBUG)
 438    if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_DL)
 439    {
 440        RLOG1(L_DEBUG,"KwLiRguDDatInd(pst, suId(%d))recieved in DL Inst",suId);
 441        KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
 442        RETVALUE(RFAILED);
 443    }
 444 #endif
 445    kwUtlRcvFrmLi(KW_GET_KWCB(pst->dstInst),datInd);
 446 #ifndef SS_RBUF
 447 #ifdef SS_LOCKLESS_MEMORY
 448    KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
 449 #else
 450    KW_PST_FREE(pst->region, pst->pool, datInd, sizeof(RguDDatIndInfo));
 451 #endif
 452 #endif
 453
 454    RETVALUE(ROK);
 455 } /* KwLiRguDDatInd */
 456
 457
 458 /*******************************************************************
 459  *
 460  * @brief Handler for extracting common and dedicated channel
 461  *      Scheduling result report.
 462  *
 463  * @details
 464  *
 465  *    Function : RlcMacProcSchedRep
 466  *
 467  *    Functionality:
 468  *     Handler for extracting common and dedicated channel
 469  *      Scheduling result report
 470  *
 471  * @params[in]
 472  * @return ROK     - success
 473  *         RFAILED - failure
 474  *
 475  * ****************************************************************/
 476 PUBLIC S16 RlcMacProcSchedRep(Pst *pst, SuId suId, RlcMacSchedRep *schRep)
 477 {
 478    U8 idx;                     /* Iterator */
 479    U8 nmbDLch = 0;                 /* Number of dedicated logical channles */
 480    RguCStaIndInfo   *cLchSchInfo;    /* Common logical channel scheduling result */
 481    RguDStaIndInfo   *dLchSchInfo;  /* Dedicated logical channel scheduling result */
 482
 483    DU_LOG("\nRLC : Received scheduling report from MAC");
 484
 485    for(idx=0; idx < schRep->nmbLch; idx++)
 486    {
 487        /* If it is common channel, fill status indication information
 488         * and trigger the handler for each common lch separately */
 489        if(schRep->lchSta[idx].commCh)
 490        {
 491           KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, cLchSchInfo, sizeof(RguCStaIndInfo));
 492           cmMemset((U8*)cLchSchInfo, (U8)0, sizeof(RguCStaIndInfo));
 493
 494           cLchSchInfo->cellId  = schRep->cellId;
 495           cLchSchInfo->lcId    = schRep->lchSta[idx].lchStaInd.lcId;
 496           //cLchSchInfo->transId = schRep->timeToTx;  /* TODO : fill transId suing timeToTx */
 497           cLchSchInfo->rnti    = schRep->rnti;
 498
 499           KwLiRguCStaInd(pst, suId, cLchSchInfo);
 500
 501        }
 502        else
 503        {
 504           /* Fill status info structure if at least one dedicated channel
 505            * scheduling report is received */
 506           if(nmbDLch == 0)
 507           {
 508              KW_SHRABL_STATIC_BUF_ALLOC(pst->region, pst->pool, dLchSchInfo, sizeof(RguDStaIndInfo));
 509
 510              dLchSchInfo->cellId = schRep->cellId;
 511              dLchSchInfo->nmbOfUeGrantPerTti = 1;
 512              dLchSchInfo->staInd[0].rnti = schRep->rnti;
 513              //dLchSchInfo->staInd[0].transId = schRep->timeToTx;  /* TODO : fill transId suing timeToTx */
 514              dLchSchInfo->staInd[0].nmbOfTbs = 1;
 515              //dLchSchInfo->staInd[0].fillCrlPdu = /* TODO : Check the value needed to be filled */
 516           }
 517
 518           /* Fill logical channel scheduling info */
 519           cmMemcpy((U8 *)&dLchSchInfo->staInd[0].staIndTb[0].lchStaInd[nmbDLch], (U8 *)&schRep->lchSta[idx].lchStaInd, sizeof(RguLchStaInd));
 520           nmbDLch++;
 521
 522        }
 523
 524    }
 525
 526    /* Calling handler for all dedicated channels scheduling*/
 527    if(nmbDLch)
 528    {
 529       dLchSchInfo->staInd[0].staIndTb[0].nmbLch = nmbDLch;
 530       KwLiRguDStaInd(pst, suId, dLchSchInfo);
 531    }
 532
 533    KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, schRep, sizeof(RlcMacSchedRep));
 534
 535    RETVALUE(ROK);
 536 }
 537
 538 /**
 539  * @brief Handler for trigerring the data transfer from RLC to MAC
 540  *        for common logical channels.
 541  *
 542  * @details
 543  *    This function receives the size of the PDU to be transmitted
 544  *    and acts as a trigger for forming PDU and sending it to MAC.
 545  *
 546  * @param[in] pst       Post structure
 547  * @param[in] suId      Service User ID
 548  * @param[in] staInd    Status Indication Information for Common Logical
 549  *                      Channels
 550  *
 551  * @return  S16
 552  *    -# ROK
 553  *    -# RFAILED
 554  *
 555 */
 556 #ifdef ANSI
 557 PUBLIC S16 KwLiRguCStaInd
 558 (
 559 Pst              *pst,
 560 SuId             suId,
 561 RguCStaIndInfo   *staInd
 562 )
 563 #else
 564 PUBLIC S16 KwLiRguCStaInd(pst,suId,staInd)
 565 Pst              *pst;
 566 SuId             suId;
 567 RguCStaIndInfo   *staInd;
 568 #endif
 569 {
 570    KwDlRbCb   *rbCb;
 571    KwCb       *tKwCb;
 572
 573    TRC3(KwLiRguCStaInd)
 574
 575 #if (ERRCLASS & ERRCLS_INT_PAR)
 576    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 577    {
 578       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
 579       RETVALUE (RFAILED);
 580    }
 581 #endif
 582
 583    tKwCb = KW_GET_KWCB(pst->dstInst);
 584
 585
 586 #if (ERRCLASS & ERRCLS_INT_PAR)
 587    if ((suId >= tKwCb->genCfg.maxRguSaps) || (suId < 0))
 588    {
 589       KWLOGERROR(tKwCb,
 590             ERRCLS_INT_PAR,
 591             EKW040,
 592             (ErrVal) suId,
 593             "KwLiRguCStaInd: Invalid RGU suId\n");
 594       RETVALUE(RFAILED);
 595    }
 596    if (tKwCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
 597    {
 598        RLOG_ARG1(L_ERROR,DBG_LCID,staInd->lcId,
 599              "Received in RLC UL CELLID:%d",
 600              staInd->cellId);
 601        KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
 602        RETVALUE(RFAILED);
 603    }
 604 #endif
 605
 606    rbCb = NULLP;
 607
 608    /* kw006.201 ccpu00120058, added boundary condition check */
 609 #if (ERRCLASS & ERRCLS_DEBUG)
 610    if(KW_MAX_LCH_PER_CELL < staInd->lcId)
 611    {
 612       RLOG_ARG2(L_ERROR,DBG_LCID,staInd->lcId,
 613             "Invalid LcId, Max is [%d] CELLID:%d",
 614             KW_MAX_LCH_PER_CELL,
 615             staInd->cellId);
 616       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
 617       RETVALUE(RFAILED);
 618    }
 619 #endif /* (ERRCLASS & ERRCLS_DEBUG) */
 620    /* Fertch RbCb from lcId */
 621    kwDbmFetchDlRbCbFromLchId(tKwCb,0, staInd->cellId, staInd->lcId, &rbCb);
 622    if(!rbCb)
 623    {
 624       RLOG_ARG1(L_ERROR, DBG_CELLID,staInd->cellId,
 625             "LcId [%d] not found CELLID:%d",
 626             staInd->lcId);
 627       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
 628       RETVALUE(RFAILED);
 629    }
 630
 631    /* Dispatch to TM Module */
 632    rbCb->transId = staInd->transId;
 633    /* ccpu00136940 */
 634   /* If trace flag is enabled send the trace indication */
 635    if(tKwCb->init.trc == TRUE)
 636    {
 637      /* Populate the trace params */
 638       kwLmmSendTrc(tKwCb,EVTRGUCSTAIND, NULLP);
 639    }
 640    kwTmmSndToLi(tKwCb, suId, rbCb, staInd);
 641 #ifndef SS_RBUF
 642 #ifdef SS_LOCKLESS_MEMORY
 643    KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
 644 #else
 645    KW_PST_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
 646 #endif
 647 #else
 648    KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguCStaIndInfo));
 649 #endif
 650    RETVALUE(ROK);
 651 } /* KwLiRguCStaInd */
 652
 653 /**
 654  * @brief Handler for trigerring the data transfer from RLC to MAC
 655  *        for dedicated logical channels.
 656  *
 657  * @details
 658  *    This function receives the size of the PDUs to be transmitted to
 659  *    MAC via one or more dedicated logical channels and acts as a trigger
 660  *    for forming PDUs and sending them to MAC.
 661  *
 662  * @param[in] pst       Post structure
 663  * @param[in] suId      Service User ID
 664  * @param[in] staInd    Status Indication Information for Dedicated Logical
 665  *                      Channels
 666  *
 667  * @return  S16
 668  *    -# ROK
 669  *    -# RFAILED
 670  *
 671 */
 672 #ifdef ANSI
 673 PUBLIC S16 KwLiRguDStaInd
 674 (
 675 Pst              *pst,
 676 SuId             suId,
 677 RguDStaIndInfo   *staInd
 678 )
 679 #else
 680 PUBLIC S16 KwLiRguDStaInd(pst, suId, staInd)
 681 Pst              *pst;
 682 SuId             suId;
 683 RguDStaIndInfo   *staInd;
 684 #endif
 685 {
 686    KwCb        *gCb;
 687    TRC3(KwLiRguDStaInd)
 688
 689 #if (ERRCLASS & ERRCLS_INT_PAR)
 690    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 691    {
 692       KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
 693       RETVALUE (RFAILED);
 694    }
 695 #endif
 696
 697    gCb = KW_GET_KWCB(pst->dstInst);
 698
 699 #if (ERRCLASS & ERRCLS_INT_PAR)
 700    if (((KwCb*)KW_GET_KWCB(pst->dstInst))->genCfg.rlcMode == LKW_RLC_MODE_UL)
 701    {
 702        RLOG_ARG0(L_ERROR,DBG_CELLID,staInd->cellId,"Received in RLC UL ");
 703        KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
 704        RETVALUE(RFAILED);
 705    }
 706    if ((suId >= gCb->genCfg.maxRguSaps) || (suId < 0))
 707    {
 708       KWLOGERROR(gCb,
 709             ERRCLS_INT_PAR,
 710             EKW040,
 711             (ErrVal) suId,
 712             "KwLiRguDStaInd: Invalid RGU suId\n");
 713       RETVALUE(RFAILED);
 714    }
 715 #endif
 716    kwUtlSndToLi(gCb, suId, staInd);
 717
 718    /* kw002.201 :Freeing from proper region */
 719    KW_SHRABL_STATIC_BUF_FREE(pst->region, pst->pool, staInd, sizeof(RguDStaIndInfo));
 720    RETVALUE(ROK);
 721 } /* KwLiRguDStaInd */
 722
 723 /**
 724  * @brief Handler for handling the flow cntrl Ind from MAC
 725  *  to RLC
 726  *
 727  * @details
 728  *   This function receives the flow control indication from
 729  *   MAC and calls kwUtlTrigPdbFlowCntrl
 730  *
 731  * @param[in] pst       Post structure
 732  * @param[in] suId      Service User ID
 733  * @param[in] flowCntrlInd flow control Indication Information
 734  *           from MAC
 735  *
 736  * @return  S16
 737  *    -# ROK
 738  *    -# RFAILED
 739  *
 740 */
 741 #ifdef ANSI
 742 PUBLIC S16 KwLiRguFlowCntrlInd
 743 (
 744 Pst              *pst,
 745 SuId             suId,
 746 RguFlowCntrlInd *flowCntrlInd
 747 )
 748 #else
 749 PUBLIC S16 KwLiRguFlowCntrlInd(pst, suId, flowCntrlInd)
 750 Pst              *pst;
 751 SuId             suId;
 752 RguFlowCntrlInd  *flowCntrlInd;
 753 #endif
 754 {
 755    KwCb       *tKwCb;
 756    KwDlRbCb   *rbCb = NULLP;
 757    U32        idx;
 758    U32        lcIdx;
 759
 760    tKwCb = KW_GET_KWCB(pst->dstInst);
 761    for (idx = 0; idx < flowCntrlInd->numUes; idx++)
 762    {
 763       for (lcIdx = 0; lcIdx < flowCntrlInd->ueFlowCntrlInfo[idx].numLcs; lcIdx++)
 764       {
 765          RguLcFlowCntrlInfo *lcInfo = &(flowCntrlInd->ueFlowCntrlInfo[idx].lcInfo[lcIdx]);
 766          kwDbmFetchDlRbCbFromLchId(tKwCb, flowCntrlInd->ueFlowCntrlInfo[idx].ueId, flowCntrlInd->cellId, lcInfo->lcId, &rbCb);
 767          if (rbCb)
 768          {
 769
 770             if (lcInfo->pktAdmitCnt == 0) /* Special case */
 771             {
 772                kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt);
 773                continue;
 774             }
 775             if (rbCb->mode == CM_LTE_MODE_AM)
 776             {
 777                if ((rbCb->m.amDl.retxLst.count != 0) ||
 778                    ((rbCb->m.amDl.bo == 0) ||
 779                     (rbCb->m.amDl.bo < lcInfo->maxBo4FlowCtrl)))
 780                {
 781                   continue;
 782                }
 783             }
 784             else /* UM */
 785             {
 786                if ((rbCb->m.umDl.bo == 0) ||
 787                    (rbCb->m.umDl.bo < lcInfo->maxBo4FlowCtrl))
 788                {
 789                   continue;
 790                }
 791             }
 792             kwUtlTrigPdbFlowCntrl(tKwCb, rbCb, lcInfo->pktAdmitCnt);
 793          }
 794       }
 795    }
 796    RETVALUE(ROK);
 797 }
 798 /* kw005.201 added support for L2 Measurement */
 799 #ifdef LTE_L2_MEAS
 800 \f
 801 /**
 802  *
 803  * @brief
 804  *
 805  *        Handler for indicating the Harq Status of the data sent.
 806  *
 807  * @b Description:
 808  *
 809  *        This function receives the harq status of the data sent to MAC.
 810  *        This information is used for two things.
 811  *        1. Computing the UuLoss of UM
 812  *        2. Computing the DL Delay for UM and AM.
 813  *
 814  *  @param[in] pst     -   Post structure
 815  *  @param[in] suId    -   Service User ID
 816  *  @param[in] staInd  -   Harq Status Indication Information.
 817  *
 818  *  @return  S16
 819  *      -# ROK
 820  *      -# RFAILED
 821  *
 822  */
 823 #ifdef ANSI
 824 PUBLIC S16 KwLiRguHqStaInd
 825 (
 826 Pst                *pst,
 827 SuId               suId,
 828 RguHarqStatusInd   *staInd
 829 )
 830 #else
 831 PUBLIC S16 KwLiRguHqStaInd(pst,suId,staInd)
 832 Pst                *pst;
 833 SuId               suId;
 834 RguHarqStatusInd   *staInd;
 835 #endif
 836 {
 837
 838    KwUeKey   ueKey;
 839    S16       ret;
 840    KwDlUeCb    *ueCb;
 841    U8        tbIdx;
 842    KwCb       *tKwCb;
 843
 844    TRC3(KwLiRguHqStaInd)
 845
 846    tKwCb = KW_GET_KWCB(pst->dstInst);
 847    ueKey.cellId = staInd->cellId;
 848    ueKey.ueId   = staInd->ueId;
 849
 850    ret = kwDbmFetchDlUeCb(tKwCb, ueKey.ueId, ueKey.cellId, &ueCb);
 851    if (ret != ROK )
 852    {
 853       RETVALUE(RFAILED);
 854    }
 855
 856    /*Call kwUtlProcHarqInd as many times as number of Tbs present*/
 857    for ( tbIdx = 0; tbIdx < staInd->numTbs; tbIdx++)
 858    {
 859       kwUtlProcHarqInd(tKwCb, staInd, ueCb, tbIdx);
 860    }
 861
 862    RETVALUE(ROK);
 863 } /* KwLiRguHqStaInd */
 864 #endif /* LTE_L2_MEAS */
 865
 866 #ifdef __cplusplus
 867 }
 868 #endif /* __cplusplus */
 869
 870 /********************************************************************30**
 871          End of file
 872 **********************************************************************/