src/5gnrmac/rg_uim.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
  21      Name:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for Entry point fucntions
  26
  27      File:     rg_uim.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_uim.c.
  32 @brief This module acts as an interface handler for upper interface and
  33 manages Pst and Sap related information for upper interface APIs.
  34 */
  35
  36
  37 /* header include files -- defines (.h) */
  38
  39 /* header/extern include files (.x) */
  40 /* header include files (.h) */
  41 #include "common_def.h"
  42 #include "crg.h"           /* CRG defines */
  43 #include "lrg.h"           /* layer management defines for LTE-MAC */
  44 #include "tfu.h"
  45 #include "rgu.h"
  46 #include "rg_sch_inf.h"
  47 #include "rg_env.h"        /* customizable defines and macros for MAC */
  48 #include "rg.h"            /* defines and macros for MAC */
  49 #include "rg_err.h"        /* RG error defines */
  50 #include "mac_utils.h"
  51
  52 /* header/extern include files (.x) */
  53
  54 #include "crg.x"           /* CRG types */
  55 #include "lrg.x"           /* layer management typedefs for MAC */
  56 #include "tfu.x"
  57 #include "rgu.x"
  58 #include "rg_sch_inf.x"
  59 #include "rg_prg.x"        /* PRG interface typedefs*/
  60 #include "du_app_mac_inf.h"
  61 #include "rg.x"            /* typedefs for MAC */
  62
  63 #include "ss_rbuf.h"
  64 #include "ss_rbuf.x"
  65
  66 /* local defines */
  67
  68 /* local typedefs */
  69
  70 /* local externs */
  71
  72 /* forward references */
  73
  74 #if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
  75 S16 rgBatchProc(Void);
  76 #endif
  77 uint8_t rgRguDlSap;
  78 uint8_t rgRguUlSap;
  79 /**
  80  * @brief Handler for Bind request.
  81  *
  82  * @details
  83  *
  84  *     Function : RgUiRguBndReq
  85  *
  86  *     This function handles the bind request from MAC Service User.
  87  *
  88  *
  89  *  @param[in]  Pst  *pst
  90  *  @param[in]  SuId suId
  91  *  @param[in]  SpId spId
  92  *  @return  S16
  93  *      -# ROK
  94  *      -# RFAILED
  95  **/
  96 S16 RgUiRguBndReq
  97 (
  98 Pst  *pst,
  99 SuId suId,
 100 SpId spId
 101 )
 102 {
 103    Inst      inst;
 104    S16       ret = ROK;
 105    Pst       tmpPst;   /* Temporary Post Structure */
 106    RgUstaDgn dgn;      /* Alarm diagnostics structure */
 107
 108    RG_IS_INST_VALID(pst->dstInst);
 109    inst = pst->dstInst - RG_INST_START;
 110
 111    tmpPst.prior       = pst->prior;
 112    tmpPst.route       = pst->route;
 113    tmpPst.selector    = pst->selector;
 114    tmpPst.region      = rgCb[inst].rgInit.region;
 115    tmpPst.pool        = rgCb[inst].rgInit.pool;
 116    tmpPst.srcProcId   = rgCb[inst].rgInit.procId;
 117    tmpPst.srcEnt      = rgCb[inst].rgInit.ent;
 118    tmpPst.srcInst     = rgCb[inst].rgInit.inst;
 119    tmpPst.event       = EVTNONE;
 120    tmpPst.dstProcId   = pst->srcProcId;
 121    tmpPst.dstEnt      = pst->srcEnt;
 122    tmpPst.dstInst     = pst->srcInst;
 123
 124    if(spId == rgCb[inst].rguSap[spId].sapCfg.spId)
 125    {
 126       /* Check the state of the SAP */
 127       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
 128       {
 129          case LRG_NOT_CFG: /* SAP Not configured */
 130             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
 131             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
 132                   LCM_CAUSE_INV_SAP, &dgn);
 133             DU_LOG("\nDEBUG  -->  MAC : SAP Not Configured");
 134             ret = RgUiRguBndCfm(&tmpPst, suId, CM_BND_NOK);
 135             break;
 136          case LRG_UNBND: /* SAP is not bound */
 137             DU_LOG("\nDEBUG  -->  MAC : SAP Not yet bound");
 138             rgCb[inst].rguSap[spId].sapSta.sapState = LRG_BND;
 139             rgCb[inst].rguSap[spId].sapCfg.suId = suId;
 140             /* Send Bind Confirm with status as SUCCESS */
 141             /*T2K - Passing spId as it is required to access the SAP CB*/
 142             ret = rgUIMRguBndCfm(inst,spId, CM_BND_OK);
 143             /* Indicate to Layer manager */
 144             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
 145             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_EVENT_RGUSAP_ENB,
 146                   LCM_CAUSE_UNKNOWN, &dgn);
 147             break;
 148          case LRG_BND: /* SAP is already bound*/
 149             DU_LOG("\nDEBUG  -->  MAC : SAP already bound");
 150             /*T2K - Passing spId as it is required to access the SAP CB*/
 151             ret = rgUIMRguBndCfm(inst,spId, CM_BND_OK);
 152             break;
 153          default: /* Should Never Enter here */
 154 #if (ERRCLASS & ERRCLS_ADD_RES)
 155             DU_LOG("\nERROR  -->  MAC : Invalid SAP State:RgUiRguBndReq failed\n");
 156 #endif
 157             /*T2K - Passing spId as it is required to access the SAP CB*/
 158             ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
 159             break;
 160       }
 161    }
 162    else
 163    {
 164 #if (ERRCLASS & ERRCLS_ADD_RES)
 165       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:RgUiRguBndReq failed\n");
 166 #endif
 167       /*T2K - Passing spId as it is required to access the SAP CB*/
 168       ret = rgUIMRguBndCfm(inst,spId, CM_BND_NOK);
 169    }
 170    return (ret);
 171 }  /* RgUiRguBndReq */
 172
 173
 174 /**
 175  * @brief Handler for Unbind request.
 176  *
 177  * @details
 178  *
 179  *     Function : RgUiRguUbndReq
 180  *
 181  *     This function handles the unbind request from MAC Service User.
 182  *
 183  *
 184  *  @param[in]  Pst    *pst
 185  *  @param[in]  SpId   spId
 186  *  @param[in]  Reason reason
 187  *  @return  S16
 188  *      -# ROK
 189  *      -# RFAILED
 190  **/
 191 S16 RgUiRguUbndReq
 192 (
 193 Pst    *pst,
 194 SpId   spId,
 195 Reason reason
 196 )
 197 {
 198    Inst      inst;
 199
 200    RG_IS_INST_VALID(pst->dstInst);
 201    inst = pst->dstInst - RG_INST_START;
 202    /* SAP Id validation */
 203    if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
 204    {
 205       switch(rgCb[inst].rguSap[spId].sapSta.sapState)
 206       {
 207          case LRG_BND: /* SAP is already bound*/
 208             DU_LOG("\nDEBUG  -->  MAC : SAP already bound");
 209             /* setting SAP state to UN BOUND */
 210             rgCb[inst].rguSap[spId].sapSta.sapState = LRG_UNBND;
 211             break;
 212          default:
 213 #if (ERRCLASS & ERRCLS_ADD_RES)
 214      DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiRguUbndReq failed",
 215                   rgCb[inst].rguSap[spId].sapSta.sapState);
 216
 217 #endif
 218             break;
 219       }
 220    }
 221    else
 222    {
 223 #if (ERRCLASS & ERRCLS_ADD_RES)
 224      DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:RgUiRguUbndReq failed\n");
 225 #endif
 226       return RFAILED;
 227    }
 228    return ROK;
 229 }  /* RgUiRguUbndReq */
 230 /**
 231  * @brief API for sending bind confirm from MAC to RLC
 232  *
 233  * @details
 234  *
 235  *     Function: rgUIMRguBndCfm
 236  *
 237  *     This API is invoked to send bind confirm from MAC to RLC.
 238  *     This API fills in Pst structure and SAP Ids and invokes
 239  *     bind confirm API towards RLC.
 240  *
 241  *  @param[in] Inst        inst
 242  *  @param[in]  SuId          suId
 243  *  @param[in]  uint8_t            status
 244  *  @return  S16
 245  *      -# ROK
 246  *      -# RFAILED
 247  **/
 248 S16 rgUIMRguBndCfm(Inst inst,SpId spId,uint8_t status)
 249 {
 250    S16  ret = ROK;
 251
 252    ret = RgUiRguBndCfm(&rgCb[inst].rguSap[spId].sapCfg.sapPst,
 253                       rgCb[inst].rguSap[spId].sapCfg.suId, status);
 254    if (ret != ROK)
 255    {
 256
 257       DU_LOG("\nERROR  -->  MAC : RgUiRguBndCfm Failed ");
 258       return (ret);
 259    }
 260    return (ret);
 261 }  /* rgUIMRguBndCfm*/
 262
 263
 264 /**
 265  * @brief Handler for dedicated DatReq from RGU
 266  *
 267  * @details
 268  *
 269  *     Function : RgUiRguDDatReq
 270  *
 271  *     This function validates SAP and invokes ROM for further processing
 272  *
 273  *  @param[in]  Pst             *pst
 274  *  @param[in]  SpId            spId
 275  *  @param[in]  RguDDatReqInfo  *datReq
 276  *  @return  S16
 277  *      -# ROK
 278  *      -# RFAILED
 279  **/
 280 S16 RgUiRguDDatReq(Pst *pst,SpId spId,RguDDatReqInfo  *datReq)
 281 {
 282    S16   ret = ROK;
 283    Inst  inst;
 284 #ifndef NO_ERRCLS
 285    uint32_t   id;
 286    uint32_t   id1;
 287    uint32_t   id2;
 288    uint32_t   id3;
 289 #endif
 290
 291    RG_IS_INST_VALID(pst->dstInst);
 292    inst = pst->dstInst - RG_INST_START;
 293 #ifndef NO_ERRCLS
 294    if (datReq == NULLP)
 295    {
 296       DU_LOG("\nERROR  -->  MAC : Input Message Buffer is NULL");
 297       return RFAILED;
 298    }
 299
 300    if(rgCb[inst].rguSap[spId].sapCfg.spId == spId)
 301    {
 302       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
 303       {
 304          case LRG_BND: /* SAP is bound */
 305             DU_LOG("\nDEBUG  -->  MAC : SAP is already bound");
 306             break;
 307          default: /* Should never reach here */
 308 #if (ERRCLASS & ERRCLS_ADD_RES)
 309             DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiRguDDatReq failed",
 310                   rgCb[inst].rguSap[spId].sapSta.sapState);
 311 #endif
 312 #ifndef L2_OPTMZ
 313             for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
 314             {
 315                RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[id3]);
 316             }
 317 #endif
 318             return RFAILED;
 319       }
 320    }
 321    else
 322    {
 323 #if (ERRCLASS & ERRCLS_ADD_RES)
 324       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:RgUiRguDDatReq failed\n");
 325 #endif
 326 #ifndef L2_OPTMZ
 327       for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
 328       {
 329          RG_DROP_RGUDDATREQ_MBUF(datReq->datReq[id3]);
 330       }
 331 #endif
 332       return RFAILED;
 333    }
 334
 335    /* Update RGU SAP statistics for received sdu count */
 336    /*ccpu00118201 - ADD - Send trace only when its enabled*/
 337    if(rgCb[inst].rgInit.trc)
 338    {
 339       for(id3 = 0; id3 < datReq->nmbOfUeGrantPerTti; id3++)
 340       {
 341          RguDDatReqPerUe *datReqPerUe = &datReq->datReq[id3];
 342          for (id = 0; id < datReqPerUe->nmbOfTbs; id++)
 343          {
 344             for (id1 = 0; id1 < datReqPerUe->datReqTb[id].nmbLch; id1++)
 345             {
 346                /* rgCb.rguSap.sapSts.numPduRcvd is updated by
 347                 * rgROMDedDatReq -> rgUpdtRguDedSts function
 348                 * So numPduRcvd updation is commented here */
 349                /* rgCb.rguSap.sapSts.numPduRcvd +=
 350                   datReq->datReqTb[id].lchData[id1].pdu.numPdu; */
 351                for (id2 = 0; id2 < datReqPerUe->datReqTb[id].lchData[id1].pdu.numPdu; id2++)
 352                {
 353                   RG_SEND_TRC_IND(inst,datReqPerUe->datReqTb[id].
 354                         lchData[id1].pdu.mBuf[id2], EVTRGUDDATREQ);
 355                }
 356             }
 357          }
 358       }
 359    }
 360 #endif
 361
 362    /* Call Ownership module for further processing */
 363    ret = rgROMDedDatReq(inst,datReq);
 364    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, datReq,sizeof(RguDDatReqInfo));
 365    return (ret);
 366 }  /* RgUiRguDDatReq */
 367
 368
 369 /**
 370  * @brief Handler for common DatReq from RGU
 371  *
 372  * @details
 373  *
 374  *     Function : RgUiRguCDatReq
 375  *
 376  *     This function validates SAP invokes ROM for further processing
 377  *
 378  *  @param[in]  Pst             *pst
 379  *  @param[in]  SpId            spId
 380  *  @param[in]  RguCDatReqInfo  *datReq
 381  *  @return  S16
 382  *      -# ROK
 383  *      -# RFAILED
 384  **/
 385 S16 RgUiRguCDatReq
 386 (
 387 Pst             *pst,
 388 SpId            spId,
 389 RguCDatReqInfo  *datReq
 390 )
 391 {
 392    Inst  inst;
 393    S16   ret = ROK;
 394
 395    RG_IS_INST_VALID(pst->dstInst);
 396    inst = pst->dstInst - RG_INST_START;
 397 #ifndef NO_ERRCLS
 398    if (datReq == NULLP)
 399    {
 400       DU_LOG("\nERROR  -->  MAC : Input Message Buffer is NULL");
 401       return RFAILED;
 402    }
 403
 404    if(rgCb[inst].rguSap[spId].sapCfg.spId == spId)
 405    {
 406       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
 407       {
 408          case LRG_BND: /* SAP is bound */
 409             DU_LOG("\nERROR  -->  MAC : SAP is already bound");
 410             break;
 411          default: /* Should never reach here */
 412 #if (ERRCLASS & ERRCLS_ADD_RES)
 413             DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiRguCDatReq failed",
 414                   rgCb[inst].rguSap[spId].sapSta.sapState);
 415 #endif
 416             return RFAILED;
 417       }
 418    }
 419    else
 420    {
 421 #if (ERRCLASS & ERRCLS_ADD_RES)
 422       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:%d RgUiRguCDatReq failed ",spId);
 423 #endif
 424       return RFAILED;
 425    }
 426 #endif
 427
 428    /* Update RGU SAP statistics for received sdu count */
 429    /* rgCb.rguSap.sapSts.numPduRcvd is updated by
 430     * rgROMCmnDatReq ->rgUpdtRguCmnSts function
 431     * So numPduRcvd updation is commented here */
 432    /* rgCb.rguSap.sapSts.numPduRcvd++; */
 433
 434    ret = rgROMCmnDatReq(inst,datReq);
 435    /*ccpu00118201 - ADD - Send trace only when its enabled*/
 436    if(rgCb[inst].rgInit.trc)
 437    {
 438       RG_SEND_TRC_IND(inst,datReq->pdu, EVTRGUCDATREQ);
 439    }
 440    if (ret == RFAILED)
 441    {
 442       RG_DROP_RGUCDATREQ_MBUF(datReq);
 443    }
 444    MAC_FREE_SHRABL_BUF(pst->region, pst->pool,datReq,sizeof(RguCDatReqInfo));
 445    return (ret);
 446 }  /* RgUiRguCDatReq */
 447
 448
 449 /**
 450  * @brief Handler for dedicated StaRsp from RGU
 451  *
 452  * @details
 453  *
 454  *     Function : RgUiRguDStaRsp
 455  *
 456  *     This function validates SAP and invokes ROM for further processing
 457  *
 458  *  @param[in]  Pst             *pst
 459  *  @param[in]  SpId            spId
 460  *  @param[in]  RguDStaRspInfo  *staRsp
 461  *  @return  S16
 462  *      -# ROK
 463  *      -# RFAILED
 464  **/
 465 S16 RgUiRguDStaRsp
 466 (
 467 Pst             *pst,
 468 SpId            spId,
 469 RguDStaRspInfo  *staRsp
 470 )
 471 {
 472    Inst  inst;
 473    S16   ret       = ROK;
 474    volatile uint32_t     startTime = 0;
 475
 476
 477    RG_IS_INST_VALID(pst->dstInst);
 478    inst = pst->dstInst - RG_INST_START;
 479    /*starting Task*/
 480    SStartTask(&startTime, PID_MAC_STA_RSP);
 481
 482    ret = rgROMDedStaRsp(inst,staRsp);
 483    if (ret != ROK)
 484    {
 485        DU_LOG("\nERROR  -->  MAC : Processing Of Status Response Failed");
 486    }
 487
 488
 489    /*stoping Task*/
 490    SStopTask(startTime, PID_MAC_STA_RSP);
 491    return (ret);
 492 }  /* RgUiRguDStaRsp */
 493
 494
 495 /**
 496  * @brief Handler for common StaRsp from RGU
 497  *
 498  * @details
 499  *
 500  *     Function : RgUiRguCStaRsp
 501  *
 502  *     This function validates SAP and invokes ROM
 503  *     for further processing
 504  *
 505  *
 506  *  @param[in]  Pst             *pst
 507  *  @param[in]  SpId            spId
 508  *  @param[in]  RguCStaRspInfo  *staRsp
 509  *  @return  S16
 510  *      -# ROK
 511  *      -# RFAILED
 512  **/
 513 S16 RgUiRguCStaRsp
 514 (
 515 Pst             *pst,
 516 SpId            spId,
 517 RguCStaRspInfo  *staRsp
 518 )
 519 {
 520    Inst  inst;
 521    S16   ret = ROK;
 522
 523    RG_IS_INST_VALID(pst->dstInst);
 524    inst = pst->dstInst - RG_INST_START;
 525 #ifndef NO_ERRCLS
 526    if (staRsp == NULLP)
 527    {
 528       DU_LOG("\nERROR  -->  MAC : Input Response Buffer is NULL");
 529       return RFAILED;
 530    }
 531
 532    if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
 533    {
 534       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
 535       {
 536          case LRG_BND: /* SAP is bound */
 537             DU_LOG("\nDEBUG  -->  MAC : SAP is already bound");
 538             break;
 539          default: /* Should never reach here */
 540 #if (ERRCLASS & ERRCLS_ADD_RES)
 541             DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiRguCStaRsp failed",
 542                   rgCb[inst].rguSap[spId].sapSta.sapState);
 543 #endif
 544             return RFAILED;
 545       }
 546    }
 547    else
 548    {
 549 #if (ERRCLASS & ERRCLS_ADD_RES)
 550       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:%d RgUiRguCStaRsp failed",spId);
 551 #endif
 552       return RFAILED;
 553    }
 554 #endif
 555
 556    ret = rgROMCmnStaRsp(inst,staRsp);
 557    if (ret != ROK)
 558    {
 559       DU_LOG("\nERROR  -->  MAC : Processing Of Status Response Failed");
 560       return (ret);
 561    }
 562
 563    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, staRsp,sizeof(RguCStaRspInfo));
 564    return (ret);
 565 }  /* RgUiRguCStaRsp */
 566
 567 #ifdef LTE_L2_MEAS
 568
 569 /**
 570  * @brief Handler for L2M MeasReq from RGU
 571  *
 572  * @details
 573  *
 574  *     Function :RgUiRguL2MUlThrpMeasReq
 575  *
 576  *     This function validates SAP and invokes ROM for further processing
 577  *
 578  *  @param[in]  Pst             *pst
 579  *  @param[in]  SpId            spId
 580  *  @param[in]  RguL2MUlThrpMeasReqInfo  *measReq
 581  *  @return  S16
 582  *      -# ROK
 583  *      -# RFAILED
 584  **/
 585 S16 RgUiRguL2MUlThrpMeasReq
 586 (
 587 Pst             *pst,
 588 SpId            spId,
 589 RguL2MUlThrpMeasReqInfo  *measReq
 590 )
 591 {
 592    Inst  inst;
 593
 594    S16   ret = ROK;
 595
 596    RG_IS_INST_VALID(pst->dstInst);
 597    inst = pst->dstInst - RG_INST_START;
 598 #ifndef NO_ERRCLS
 599    if (measReq == NULLP)
 600    {
 601       DU_LOG("\nERROR  -->  MAC : Input Response Buffer is NULL");
 602       return RFAILED;
 603    }
 604
 605    if (spId == rgCb[inst].rguSap[spId].sapCfg.spId)
 606    {
 607       switch (rgCb[inst].rguSap[spId].sapSta.sapState)
 608       {
 609          case LRG_BND: /* SAP is bound */
 610             DU_LOG("\nERROR  -->  MAC : SAP is already bound");
 611             break;
 612          default: /* Should never reach here */
 613 #if (ERRCLASS & ERRCLS_ADD_RES)
 614             DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiRguL2MUlThrpMeasReq failed",
 615                   rgCb[inst].rguSap[spId].sapSta.sapState);
 616 #endif
 617             return RFAILED;
 618       }
 619    }
 620    else
 621    {
 622 #if (ERRCLASS & ERRCLS_ADD_RES)
 623       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:%d RgUiRguL2MUlThrpMeasReq failed",spId);
 624 #endif
 625       return RFAILED;
 626    }
 627 #endif
 628
 629    ret = rgROML2MUlThrpMeasReq(inst,measReq);
 630    if (ret != ROK)
 631    {
 632       DU_LOG("\nERROR  -->  MAC : Processing Of Meas Request Failed");
 633    }
 634
 635    MAC_FREE_SHRABL_BUF(pst->region, pst->pool, (Data *)measReq,sizeof(RguL2MUlThrpMeasReqInfo));
 636    return (ret);
 637 }  /* RgUiRguL2MUlThrpMeasReq */
 638 #endif
 639
 640 /**
 641  * @brief Handler for sending staInd to dedicated logical channels of a UE
 642  *
 643  * @details
 644  *
 645  *     Function : rgUIMSndDedStaInd
 646  *
 647  *     This function fills SAP and Pst information to send the staInd to
 648  *     a UE.
 649  *
 650  *
 651  *  @param[in] Inst        inst
 652  *  @param[in] RgUpSapCb  *rguSap
 653  *  @param[in]  RgRguDedStaInd  *staInd
 654  *  @return  S16
 655  *      -# ROK
 656  *      -# RFAILED
 657  **/
 658 S16 rgUIMSndDedStaInd
 659 (
 660 Inst         inst,
 661 RgUpSapCb    *rguSap,
 662 RgRguDedStaInd  *staInd
 663 )
 664 {
 665    S16  ret = ROK;
 666
 667    DU_LOG("\nINFO  -->  MAC : rgUIMSndDedStaInd(): staInd = %p;\n", (void *)staInd);
 668
 669    ret = RgUiRguDStaInd(&(rguSap->sapCfg.sapPst), rguSap->sapCfg.suId,
 670          staInd);
 671    if (ret != ROK)
 672    {
 673       DU_LOG("\nERROR  -->  MAC : RgUiRguDStaInd Failed");
 674       return (ret);
 675    }
 676    return (ret);
 677 }  /* rgUIMSndDedStaInd */
 678
 679
 680 /**
 681  * @brief Handler for sending staInd to a common logical channel.
 682  *
 683  * @details
 684  *
 685  *     Function : rgUIMSndCmnStaInd
 686  *
 687  *     This function fills SAP and Pst information to send the staInd to
 688  *     a common logical channel.
 689  *
 690  *
 691  *  @param[in] Inst        inst
 692  *  @param[in] RgUpSapCb  *rguSap
 693  *  @param[in]  RgRguCmnStaInd  *staInd
 694  *  @return  S16
 695  *      -# ROK
 696  *      -# RFAILED
 697  **/
 698 S16 rgUIMSndCmnStaInd
 699 (
 700 Inst            inst,
 701 RgUpSapCb    *rguDlSap,
 702 RgRguCmnStaInd  *staInd
 703 )
 704 {
 705    S16  ret = ROK;
 706
 707    ret = RgUiRguCStaInd(&(rguDlSap->sapCfg.sapPst), rguDlSap->sapCfg.suId,
 708          staInd);
 709    if (ret != ROK)
 710    {
 711       DU_LOG("\nERROR  -->  MAC : RgUiRguCStaInd Failed");
 712       return (ret);
 713    }
 714    return (ret);
 715 }  /* rgUIMSndCmnStaInd */
 716
 717
 718 /**
 719  * @brief Handler for sending datInd to dedicated logical channels of a UE
 720  *
 721  * @details
 722  *
 723  *     Function : rgUIMSndDedDatInd
 724  *
 725  *     This function fills SAP and Pst information to send the datInd to
 726  *     a UE.
 727  *
 728  *
 729  *  @param[in] Inst        inst
 730  *  @param[in] RgUpSapCb  *rguUlSap
 731  *  @param[in]  RgRguDedDatInd  *datInd
 732  *  @return  S16
 733  *      -# ROK
 734  *      -# RFAILED
 735  **/
 736 S16 rgUIMSndDedDatInd
 737 (
 738 Inst         inst,
 739 RgUpSapCb    *rguUlSap,
 740 RgRguDedDatInd  *datInd
 741 )
 742 {
 743    S16  ret = ROK;
 744
 745    rguUlSap->sapSts.numPduTxmit += datInd->numLch;
 746 #ifndef SS_RBUF
 747    ret = RgUiRguDDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId,
 748          datInd);
 749    if (ret != ROK)
 750    {
 751       DU_LOG("\nERROR  -->  MAC : RgUiRguDdatInd Failed");
 752       return (ret);
 753    }
 754 #else
 755    SRngIncrWIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
 756    SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].pktRate++;
 757 #endif
 758    return (ret);
 759 }  /* rgUIMSndDedDatInd */
 760
 761
 762 /**
 763  * @brief Handler for sending datInd to a common logical channel.
 764  *
 765  * @details
 766  *
 767  *     Function : rgUIMSndCmnDatInd
 768  *
 769  *     This function fills SAP and Pst information to send the datInd to
 770  *     a common logical channel.
 771  *
 772  *
 773  *  @param[in] Inst        inst
 774  *  @param[in] RgUpSapCb  *rguSap
 775  *  @param[in]  RgRguCmnDatInd  *datInd
 776  *  @return  S16
 777  *      -# ROK
 778  *      -# RFAILED
 779  **/
 780 S16 rgUIMSndCmnDatInd(Inst inst,RgUpSapCb *rguUlSap,RgRguCmnDatInd  *datInd)
 781 {
 782    S16  ret = ROK;
 783
 784    DU_LOG("\nDEBUG  -->  MAC : rgUIMSndCmnDatInd(): staInd = %p;\n", (void *)datInd);
 785
 786    rguUlSap->sapSts.numPduTxmit++;
 787
 788    DU_LOG("\nDEBUG  -->  MAC : rgUIMSndCmnDatInd suId = %d\n", rguUlSap->sapCfg.suId);
 789    ret = RgUiRguCDatInd(&(rguUlSap->sapCfg.sapPst), rguUlSap->sapCfg.suId,
 790          datInd);
 791    if (ret != ROK)
 792    {
 793       DU_LOG("\nERROR  -->  MAC : RgUiRguCDatInd Failed");
 794       return (ret);
 795    }
 796    return (ret);
 797 }  /* rgUIMSndCmnDatInd */
 798
 799 /**
 800
 801  * @brief API for bind request from RRC towards MAC.
 802  *
 803  * @details
 804  *
 805  *     Function: RgUiCrgBndReq
 806  *
 807  *     This API is invoked by RRC towards MAC to bind CRG SAP.
 808  *     These API validates the Pst, spId, suId and sends the bind confirm to RRC.
 809  *
 810  *
 811  *  @param[in]  Pst   *pst
 812  *  @param[in]  SuId  suId
 813  *  @param[in]  SpId  spId
 814  *  @return  S16
 815  *      -# ROK
 816  *      -# RFAILED
 817  **/
 818 S16 RgUiCrgBndReq(Pst   *pst, SuId  suId,SpId  spId)
 819 {
 820    S16       ret = ROK;
 821    Pst       tmpPst;   /* Temporary Post Structure */
 822    RgUstaDgn dgn;      /* Alarm diagnostics structure */
 823    Inst      inst;
 824
 825    RG_IS_INST_VALID(pst->dstInst);
 826    inst = pst->dstInst - RG_INST_START;
 827
 828    tmpPst.prior       = pst->prior;
 829    tmpPst.route       = pst->route;
 830    tmpPst.selector    = pst->selector;
 831    tmpPst.region      = rgCb[inst].rgInit.region;
 832    tmpPst.pool        = rgCb[inst].rgInit.pool;
 833    tmpPst.srcProcId   = rgCb[inst].rgInit.procId;
 834    tmpPst.srcEnt      = rgCb[inst].rgInit.ent;
 835    tmpPst.srcInst     = rgCb[inst].rgInit.inst;
 836    tmpPst.event       = EVTNONE;
 837    tmpPst.dstProcId   = pst->srcProcId;
 838    tmpPst.dstEnt      = pst->srcEnt;
 839    tmpPst.dstInst     = pst->srcInst;
 840
 841
 842    if(spId == rgCb[inst].crgSap.sapCfg.spId)
 843    {
 844       /* Check the state of the SAP */
 845       switch (rgCb[inst].crgSap.sapSta.sapState)
 846       {
 847          case LRG_NOT_CFG: /* SAP Not configured */
 848
 849             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
 850             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_NOT_CFG,
 851                   LCM_CAUSE_INV_SAP, &dgn);
 852             DU_LOG("\nDEBUG  -->  MAC : SAP Not Configured");
 853             ret = RgUiCrgBndCfm(&tmpPst, suId, CM_BND_NOK);
 854             break;
 855          case LRG_UNBND: /* SAP is not bound */
 856             DU_LOG("\nERROR  -->  MAC : SAP Not yet bound");
 857
 858             rgCb[inst].crgSap.sapSta.sapState = LRG_BND;
 859             rgCb[inst].crgSap.sapCfg.suId = suId;
 860             /* Send Bind Confirm with status as SUCCESS */
 861             ret = rgUIMCrgBndCfm(inst,suId, CM_BND_OK);
 862             /* Indicate to Layer manager */
 863             rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
 864             ret = rgLMMStaInd(inst,LCM_CATEGORY_INTERFACE,LRG_EVENT_CRGSAP_ENB,
 865                   LCM_CAUSE_UNKNOWN, &dgn);
 866             break;
 867          case LRG_BND: /* SAP is already bound*/
 868             DU_LOG("\nDEBUG  -->  MAC : SAP is already bound");
 869
 870             ret = rgUIMCrgBndCfm(inst,suId, CM_BND_OK);
 871             break;
 872          default: /* Should Never Enter here */
 873 #if (ERRCLASS & ERRCLS_ADD_RES)
 874             DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiCrgBndReq failed",
 875                   rgCb[inst].crgSap.sapSta.sapState);
 876 #endif
 877             ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
 878             break;
 879       }
 880    }
 881    else
 882    {
 883 #if (ERRCLASS & ERRCLS_ADD_RES)
 884       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:%d RgUiCrgBndReq failed",
 885            rgCb[inst].crgSap.sapCfg.spId);
 886 #endif
 887       ret = rgUIMCrgBndCfm(inst,suId, CM_BND_NOK);
 888    }
 889    return (ret);
 890 }  /* RgUiCrgBndReq */
 891
 892
 893 /**
 894  * @brief API for unbind request from RRC towards MAC.
 895  *
 896  * @details
 897  *
 898  *     Function: RgUiCrgUbndReq
 899  *
 900  *     This API is invoked by RRC towards MAC to unbind CRG SAP.
 901  *     These API validates the Pst, spId, suId and sends the bind confirm to RRC.
 902  *
 903  *
 904  *  @param[in]  Pst    *pst
 905  *  @param[in]  SuId   suId
 906  *  @param[in]  Reason reason
 907  *  @return  S16
 908  *      -# ROK
 909  *      -# RFAILED
 910  **/
 911 S16 RgUiCrgUbndReq(Pst *pst,SpId spId,Reason reason)
 912 {
 913    Inst      inst;
 914
 915    RG_IS_INST_VALID(pst->dstInst);
 916    inst = pst->dstInst - RG_INST_START;
 917    /* SAP Id validation */
 918    if (spId == rgCb[inst].crgSap.sapCfg.spId)
 919    {
 920       switch(rgCb[inst].crgSap.sapSta.sapState)
 921       {
 922          case LRG_BND: /* SAP is already bound*/
 923             /* setting SAP state to UN BOUND */
 924             DU_LOG("\nDEBUG  -->  MAC : SAP is already bound");
 925
 926             rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
 927             break;
 928          default:
 929 #if (ERRCLASS & ERRCLS_ADD_RES)
 930             DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiCrgUbndReq failed",
 931                   rgCb[inst].crgSap.sapSta.sapState);
 932 #endif
 933             return RFAILED;
 934       }
 935    }
 936    else
 937    {
 938 #if (ERRCLASS & ERRCLS_ADD_RES)
 939       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:%d RgUiCrgUbndReq failed",
 940             rgCb[inst].crgSap.sapCfg.spId);
 941 #endif
 942       return RFAILED;
 943    }
 944    return ROK;
 945 }  /* RgUiCrgUbndReq */
 946
 947 /**
 948  * @brief API for sending bind confirm from MAC to RRC
 949  *
 950  * @details
 951  *
 952  *     Function: rgUIMRgrBndCfm
 953  *
 954  *     This API is invoked to send bind confirm from MAC to RRC.
 955  *     This API fills in Pst structure and SAP Ids and invokes
 956  *     bind confirm API towards RRC.
 957  *
 958  *  @param[in] Inst        inst
 959  *  @param[in]  SuId          suId
 960  *  @param[in]  uint8_t            status
 961  *  @return  S16
 962  *      -# ROK
 963  *      -# RFAILED
 964  **/
 965 S16 rgUIMCrgBndCfm(Inst  inst,SuId suId,uint8_t status)
 966 {
 967
 968    if(RgUiCrgBndCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, status) != ROK)
 969    {
 970       DU_LOG("\nERROR  -->  MAC : RgUiCrgBndCfm Failed ");
 971       return RFAILED;
 972    }
 973
 974    return ROK;
 975 }  /* rgUIMCrgBndCfm*/
 976
 977 /**
 978  * @brief API for configuration request from RRC towards MAC.
 979  *
 980  * @details
 981  *
 982  *     Function: RgUiCrgCfgReq
 983  *
 984  *     This API is invoked by RRC towards MAC to configure MAC.
 985  *     These API validates the Pst, spId, suId and transfers the config request
 986  *     specific information to corresponding ownership module (COM) API.
 987  *
 988  *
 989  *  @param[in]  Pst           *pst
 990  *  @param[in]  SpId          spId
 991  *  @param[in]  CrgCfgTransId transId
 992  *  @param[in]  CrgCfgReqInfo *cfgReqInfo
 993  *  @return  S16
 994  *      -# ROK
 995  *      -# RFAILED
 996  **/
 997 S16 RgUiCrgCfgReq
 998 (
 999 Pst           *pst,
1000 SpId          spId,
1001 CrgCfgTransId transId,
1002 CrgCfgReqInfo *cfgReqInfo
1003 )
1004 {
1005    Inst      inst;
1006    S16       ret       = ROK;
1007    uint8_t   cfmStatus = 0x00ff;
1008    uint8_t   prntTrans[CRG_CFG_TRANSID_SIZE+1];
1009
1010    RG_IS_INST_VALID(pst->dstInst);
1011    inst = pst->dstInst - RG_INST_START;
1012    /* Ensuring transId is always Null terminated. */
1013    memcpy(prntTrans, transId.trans, CRG_CFG_TRANSID_SIZE);
1014    prntTrans[CRG_CFG_TRANSID_SIZE] = '\0';
1015
1016
1017    /* CrgCfgReqInfo Validation for NULLP */
1018    if (cfgReqInfo == NULLP)
1019    {
1020       DU_LOG("\nERROR  -->  MAC : Input Param crgReqInfo is NULL ");
1021       rgUIMCrgCfgCfm(inst,transId, cfmStatus);
1022       return RFAILED;
1023    }
1024
1025    /* Upper SAP Id and State validation */
1026    if (spId == rgCb[inst].crgSap.sapCfg.spId)
1027    {
1028       switch(rgCb[inst].crgSap.sapSta.sapState)
1029       {
1030          case LRG_BND: /* SAP is already bound */
1031             DU_LOG("\nDEBUG  -->  MAC : SAP is already bound");
1032             break;
1033          default: /* Should never reach here */
1034 #if (ERRCLASS & ERRCLS_ADD_RES)
1035            DU_LOG("\nERROR  -->  MAC : Invalid SAP State:%d RgUiCrgCfgReq failed",
1036                   rgCb[inst].crgSap.sapSta.sapState);
1037 #endif
1038            MAC_FREE(cfgReqInfo, sizeof(CrgCfgReqInfo));
1039
1040            rgUIMCrgCfgCfm(inst,transId, cfmStatus);
1041            return RFAILED;
1042       }
1043    }
1044    else
1045    {
1046 #if (ERRCLASS & ERRCLS_ADD_RES)
1047       DU_LOG("\nERROR  -->  MAC : Invalid SAP Id:%d RgUiCrgCfgReq failed",
1048             rgCb[inst].crgSap.sapCfg.spId);
1049 #endif
1050       MAC_FREE(cfgReqInfo, sizeof(CrgCfgReqInfo));
1051       rgUIMCrgCfgCfm(inst,transId, cfmStatus);
1052       return RFAILED;
1053    }
1054    ret = rgCOMCfgReq(inst,transId, cfgReqInfo);
1055    MAC_FREE(cfgReqInfo, sizeof(CrgCfgReqInfo));
1056    if (ret != ROK)
1057    {
1058       DU_LOG("\nERROR  -->  MAC : Configuration Request Handling Failed ");
1059       return RFAILED;
1060    }
1061
1062    return ROK;
1063 }  /* RgUiCrgCfgReq */
1064
1065 /**
1066  * @brief API for sending configuration confirm from MAC to RRC
1067  *
1068  * @details
1069  *
1070  *     Function: rgUIMCrgCfgCfm
1071  *
1072  *     This API is invoked to send configuration confirm from MAC to RRC.
1073  *     This API fills in Pst structure and SAP Ids and invokes
1074  *     config confirm API towards RRC.
1075  *
1076  *  @param[in] Inst        inst
1077  *  @param[in]  CrgCfgTransId transId
1078  *  @param[in]  uint8_t            status
1079  *  @return  S16
1080  *      -# ROK
1081  *      -# RFAILED
1082  **/
1083 S16 rgUIMCrgCfgCfm
1084 (
1085 Inst      inst,
1086 CrgCfgTransId transId,
1087 uint8_t       status
1088 )
1089 {
1090    S16  ret = ROK;
1091    uint8_t   prntTrans[CRG_CFG_TRANSID_SIZE+1];
1092
1093    memcpy(prntTrans, transId.trans, CRG_CFG_TRANSID_SIZE);
1094    prntTrans[CRG_CFG_TRANSID_SIZE] = '\0';
1095
1096
1097    ret = RgUiCrgCfgCfm(&(rgCb[inst].crgSap.sapCfg.sapPst), rgCb[inst].crgSap.sapCfg.suId, transId, status);
1098    if (ret != ROK)
1099    {
1100       DU_LOG("\nERROR  -->  MAC : RgUiCrgCfgCfm Failed ");
1101       return (ret);
1102    }
1103
1104    return (ret);
1105 }  /* rgUIMCrgCfgCfm */
1106 #if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
1107
1108 S16 rgBatchProc(Void)
1109 {
1110 /* Read from Ring Buffer and process RLC BO Update */
1111    Pst pst = {0};
1112    SpId spId = 0;
1113    RguDStaRspInfo  *staRsp;
1114    uint32_t elmIndx = 0;
1115 #ifndef LTE_ADV
1116 /* Fill pst */
1117    pst.srcProcId = 1;
1118    pst.dstProcId = 1;
1119    pst.dstEnt = ENTMAC;
1120    pst.dstInst = 0;
1121    pst.srcEnt = ENTRLC;
1122    pst.srcInst = 1;
1123    pst.prior = PRIOR0;
1124    pst.route = RTESPEC;
1125    pst.event = EVTRGUDSTARSP;
1126    pst.region = 0;
1127    pst.pool = 0;
1128    pst.selector = 2; /*SM_SELECTOR_LC */
1129 #else
1130 #endif
1131
1132    elmIndx = (uint32_t)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
1133    while(NULLP != elmIndx)
1134    {
1135       staRsp = (RguDStaRspInfo *)elmIndx;
1136 #ifdef LTE_ADV
1137       pst = staRsp->post;
1138 #endif
1139       RgUiRguDStaRsp(&pst, spId, staRsp);
1140
1141       elmIndx = NULLP;
1142       staRsp = NULLP;
1143       SRngIncrRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
1144
1145       if((elmIndx = (uint32_t)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC)) == NULLP)
1146       break;
1147    }
1148    return ROK;
1149 }
1150 #endif
1151
1152 /**********************************************************************
1153
1154          End of file
1155 **********************************************************************/