src/5gnrmac/rg_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
  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_lim.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_lim.c.
  32 @brief It has APIs exposed by Lower Interface Modulue of MAC. It acts as an
  33 Interface handler for lower interface APIs.
  34 */
  35 static const char* RLOG_MODULE_NAME="MAC";
  36 static int RLOG_FILE_ID=182;
  37 static int RLOG_MODULE_ID=4096;
  38 /* header include files -- defines (.h) */
  39 #include "envopt.h"        /* environment options */
  40 #include "envdep.h"        /* environment dependent */
  41 #include "envind.h"        /* environment independent */
  42 #include "gen.h"           /* general layer */
  43 #include "ssi.h"           /* system services */
  44 #include "cm5.h"           /* common timers defines */
  45 #include "cm_hash.h"       /* common hash list defines */
  46 #include "cm_llist.h"      /* common linked list defines */
  47 #include "cm_mblk.h"       /* memory management */
  48 #include "cm_tkns.h"       /* common tokens */
  49 #include "cm_lte.h"       /* common tokens */
  50 #include "rgu.h"           /* RGU defines */
  51 #include "tfu.h"           /* RGU defines */
  52 #include "lrg.h"           /* layer management defines for LTE-MAC */
  53 #include "crg.h"           /* layer management defines for LTE-MAC */
  54 #include "rg_sch_inf.h"           /* layer management defines for LTE-MAC */
  55 #include "rg_env.h"        /* customisable defines and macros for MAC */
  56 #include "rg.h"            /* defines and macros for MAC */
  57 #include "du_log.h"
  58
  59 /* header/extern include files (.x) */
  60 #include "gen.x"           /* general layer typedefs */
  61 #include "ssi.x"           /* system services typedefs */
  62 #include "cm5.x"           /* common timers */
  63 #include "cm_hash.x"       /* common hash list */
  64 #include "cm_lib.x"        /* common library */
  65 #include "cm_llist.x"      /* common linked list */
  66 #include "cm_mblk.x"       /* memory management */
  67 #include "cm_tkns.x"       /* common tokens */
  68 #include "cm_lte.x"       /* common tokens */
  69 #include "rgu.x"           /* RGU types */
  70 #include "tfu.x"           /* RGU types */
  71 #include "lrg.x"           /* layer management typedefs for MAC */
  72 #include "crg.x"           /* layer management typedefs for MAC */
  73 #include "rg_sch_inf.x"    /* SCH interface typedefs */
  74 #include "rg_prg.x"    /* PRG interface typedefs */
  75 #include "du_app_mac_inf.h"
  76 #include "rg.x"            /* typedefs for MAC */
  77
  78 #include "mac_upr_inf_api.h"
  79 #include "mac.h"
  80
  81 /* local externs */
  82 #ifdef UNUSED_FUNC
  83 PRIVATE S16  rgLIMValidateSap ARGS((Inst inst,SuId suId));
  84 #endif
  85 PRIVATE Void rgLIMUtlFreeDatIndEvnt ARGS((TfuDatIndInfo *datInd,
  86                                           Bool error));
  87
  88 /* function pointers for packing slot ind from mac to sch */
  89 //S16 packMacSchSlotInd(Pst *pst, SlotIndInfo *slotInd);
  90
  91 MacSchSlotIndFunc macSchSlotIndOpts[] =
  92 {
  93    packMacSchSlotInd,
  94    macSchSlotInd,
  95    packMacSchSlotInd
  96 };
  97
  98 #ifdef RG_UNUSED
  99 PRIVATE Void rgLIMUtlFreeDatReqEvnt ARGS((TfuDatReqInfo *datReq,
 100                                           Bool error));
 101 #endif
 102 /* forward references */
 103
 104 /**
 105  * @brief This API is invoked to send TFU SAP bind request to PHY.
 106  *
 107  * @details
 108  *
 109  *     Function : rgLIMTfuBndReq
 110  *
 111  *      This API is invoked to send TFU SAP bind request to PHY. It fills in
 112  *      the Pst structure, spId and suId values and invokes bind request
 113  *      primitive at TFU.
 114  *
 115  *  @param[in]  Inst        inst
 116  *  @param[in]  SuId            suId
 117  *  @param[in]  SpId            spId
 118  *  @return  S16
 119  *      -# ROK
 120  *      -# RFAILED
 121  **/
 122 #ifdef ANSI
 123 PUBLIC S16 rgLIMTfuBndReq
 124 (
 125 Inst    inst,
 126 SuId    suId,
 127 SpId    spId
 128 )
 129 #else
 130 PUBLIC S16 rgLIMTfuBndReq(inst,suId, spId)
 131 Inst    inst;
 132 SuId    suId;
 133 SpId    spId;
 134 #endif
 135 {
 136    S16         ret;
 137    RgLowSapCb  *tfuSap;
 138    Pst         pst;
 139
 140    TRC2(rgLIMTfuBndReq);
 141
 142    /* Get the lower SAP control block from the layer control block. */
 143    tfuSap = &(rgCb[inst].tfuSap);
 144    (Void)cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
 145    if((ret = RgLiTfuBndReq (&pst, suId, spId)) != ROK)
 146    {
 147       RLOG0(L_ERROR,"Call to RgLiTfuBndReq() failed");
 148    }
 149    RETVALUE(ret);
 150 }  /* rgLIMTfuBndReq */
 151
 152
 153 /**
 154  * @brief This API is invoked to send TFU SAP unbind request to PHY.
 155  *
 156  * @details
 157  *
 158  *     Function : rgLIMTfuBndReq
 159  *
 160  *      This API is invoked to send TFU SAP unbind request to PHY. It fills in
 161  *      the Pst structure and spId value and invokes unbind request
 162  *      primitive at TFU.
 163  *
 164  *  @param[in]  Inst        inst
 165  *  @param[in]  SpId            spId
 166  *  @param[in]  Reason          reason
 167  *  @return  S16
 168  *      -# ROK
 169  *      -# RFAILED
 170  **/
 171 #ifdef ANSI
 172 PUBLIC S16 rgLIMTfuUbndReq
 173 (
 174 Inst    inst,
 175 SpId    spId,
 176 Reason  reason
 177 )
 178 #else
 179 PUBLIC S16 rgLIMTfuUbndReq(inst,spId, reason)
 180 Inst    inst;
 181 SpId    spId;
 182 Reason  reason;
 183 #endif
 184 {
 185    S16         ret;
 186    RgLowSapCb  *tfuSap;
 187    Pst         pst;
 188
 189    TRC2(rgLIMTfuUbndReq);
 190
 191    /* Get the lower SAP control block from the layer control block. */
 192    tfuSap = &(rgCb[inst].tfuSap);
 193    cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
 194    if((ret = RgLiTfuUbndReq (&pst, tfuSap->sapCfg.spId, reason)) != ROK)
 195    {
 196       RLOG0(L_ERROR,"Call to RgLiTfuUbndReq() failed");
 197    }
 198    RETVALUE(ret);
 199
 200 }  /* rgLIMTfuUbndReq */
 201
 202
 203 /**
 204  * @brief Bind confirm API for TFU SAP
 205  *
 206  * @details
 207  *
 208  *     Function : RgLiTfuBndCfm
 209  *
 210  *      This API is invoked by PHY to confirm TFU SAP bind.
 211  *
 212  *
 213  *  @param[in]  Pst   *pst
 214  *  @param[in]  SuId  suId
 215  *  @param[in]  U8    status
 216  *  @return  S16
 217  *      -# ROK
 218  *      -# RFAILED
 219  **/
 220 #ifdef ANSI
 221 PUBLIC S16 RgLiTfuBndCfm
 222 (
 223 Pst     *pst,
 224 SuId    suId,
 225 U8      status
 226 )
 227 #else
 228 PUBLIC S16 RgLiTfuBndCfm(pst, suId, status)
 229 Pst     *pst;
 230 SuId    suId;
 231 U8      status;
 232 #endif
 233 {
 234    Inst inst;
 235    S16 ret;
 236    RgLowSapCb  *tfuSap;
 237
 238    TRC3(RgLiTfuBndCfm);
 239
 240
 241    RG_IS_INST_VALID(pst->dstInst);
 242    inst = pst->dstInst - RG_INST_START;
 243    /* Lets validate suId first */
 244    /* CA_Change */
 245    tfuSap = &(rgCb[inst].tfuSap);
 246
 247    if (suId != tfuSap->sapCfg.suId)
 248    {
 249       RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
 250             tfuSap->sapCfg.suId, suId);
 251       RETVALUE(RFAILED);
 252    }
 253    ret = rgLMMBndCfm (pst, suId, status);
 254    RETVALUE(ret);
 255 }  /* RgLiTfuBndCfm */
 256
 257  /** @brief This function Validates the SAP information received along with the
 258   * primitive from the lower layer.
 259   * Function:
 260   *   Validates SAP information.
 261  *  @param[in]  Inst        inst
 262   * @param  suId The SAP Id
 263   * @return
 264   *   -# ROK
 265   *   -# RFAILED
 266   */
 267 #ifdef UNUSED_FUNC
 268 #ifdef ANSI
 269 PRIVATE S16 rgLIMValidateSap
 270 (
 271  Inst    inst,
 272  SuId    suId
 273 )
 274 #else
 275 PRIVATE S16 rgLIMValidateSap(inst,suId)
 276  Inst    inst;
 277  SuId    suId;
 278 #endif
 279 {
 280    RgLowSapCb  *tfuSap;
 281
 282    TRC2(rgLIMValidateSap)
 283
 284    tfuSap = &(rgCb[inst].tfuSap);
 285
 286    /* First lets check the suId */
 287    if( suId != tfuSap->sapCfg.suId)
 288    {
 289       RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
 290             tfuSap->sapCfg.suId, suId);
 291       RETVALUE(RFAILED);
 292    }
 293    if (tfuSap->sapSta.sapState != LRG_BND)
 294    {
 295       RLOG1(L_ERROR,"Lower SAP not enabled SuId (%d)",
 296             tfuSap->sapCfg.suId);
 297       RETVALUE(RFAILED);
 298    }
 299    RETVALUE(ROK);
 300 } /* end of rgLIMValidateSap */
 301 #endif
 302 /** @brief This function frees up the TfuDatIndInfo structure
 303  *
 304  * @details
 305  *
 306  *     Function: rgLIMUtlFreeDatIndEvnt
 307  *       - Function frees up the TfuDatIndInfo structure, in case of error it shall
 308  *       free up the buffer's present in the datIndLst.
 309  *
 310  *         Processing steps:
 311  * @param  [in] TfuDatIndInfo *datInd
 312  * @param  [in] Bool          *error
 313  * @return
 314  */
 315 #ifdef ANSI
 316 PRIVATE Void rgLIMUtlFreeDatIndEvnt
 317 (
 318  TfuDatIndInfo *datInd,
 319  Bool          error
 320  )
 321 #else
 322 PRIVATE Void rgLIMUtlFreeDatIndEvnt(datInd, error)
 323  TfuDatIndInfo *datInd;
 324  Bool          error;
 325 #endif
 326 {
 327
 328    TfuDatInfo     *datInfo;
 329    CmLList        *node;
 330
 331    TRC2(rgLIMUtlFreeDatIndEvnt);
 332    /* Steps of freeing up the TfuDatInd.
 333     * 1. loop through the datIndLst and free up all the buffers.
 334     * 2. free up the whole event
 335     */
 336    if ((error == TRUE) && (datInd->datIndLst.count > 0))
 337    {
 338       node =  datInd->datIndLst.first;
 339       while (node)
 340       {
 341          datInfo = (TfuDatInfo*)node->node;
 342          RG_FREE_MSG(datInfo->mBuf);
 343          node = node->next;
 344       }
 345    }
 346    RG_FREE_MEM(datInd);
 347    RETVOID;
 348 } /* end of rgLIMUtlFreeDatIndEvnt*/
 349
 350 /**
 351  * @brief Downlink data indication from PHY.
 352  *
 353  * @details
 354  *
 355  *     Function : RgLiTfuDatInd
 356  *
 357  *      This API is invoked by PHY to send data indication to MAC on
 358  *      recieving data from UEs.
 359  *
 360  *  @param[in]  Pst              *pst
 361  *  @param[in]  SuId             suId
 362  *  @param[in]  TfuDatIndInfo    *datInd
 363  *  @return  S16
 364  *      -# ROK
 365  *      -# RFAILED
 366  **/
 367 #ifdef ANSI
 368 PUBLIC S16 RgLiTfuDatInd
 369 (
 370 Pst                *pst,
 371 SuId               suId,
 372 TfuDatIndInfo    *datInd
 373 )
 374 #else
 375 PUBLIC S16 RgLiTfuDatInd(pst, suId, datInd)
 376 Pst                *pst;
 377 SuId               suId;
 378 TfuDatIndInfo    *datInd;
 379 #endif
 380 {
 381    Inst             inst;
 382    S16              ret;
 383    VOLATILE U32     startTime=0;
 384
 385    TRC3(RgLiTfuDatInd);
 386
 387   // printf("5GTF:: DatindRcvd\n");
 388
 389    RG_IS_INST_VALID(pst->dstInst);
 390    inst = pst->dstInst - RG_INST_START;
 391    /*starting Task*/
 392    SStartTask(&startTime, PID_MAC_TFU_DATIND);
 393
 394 #ifndef NO_ERRCLS
 395    if ((ret = rgLIMValidateSap (inst,suId)) != ROK)
 396    {
 397       RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"SAP Validation failed");
 398       rgLIMUtlFreeDatIndEvnt(datInd, TRUE);
 399       RETVALUE(ret);
 400    }
 401 #endif
 402    /* Now call the TOM (Tfu ownership module) primitive to process further */
 403    rgCb[inst].tfuSap.sapSts.numPduRcvd +=
 404                     datInd->datIndLst.count;
 405    ret = rgTOMDatInd(inst,datInd);
 406    /* Fix: sriky memory corruption precautions */
 407    /* Free up the memory for the request structure */
 408    if (ret == ROK)
 409    {
 410       rgLIMUtlFreeDatIndEvnt(datInd, FALSE);
 411    }
 412    else
 413    {
 414       rgLIMUtlFreeDatIndEvnt(datInd, TRUE);
 415    }
 416
 417    /*stoping Task*/
 418    SStopTask(startTime, PID_MAC_TFU_DATIND);
 419
 420    RETVALUE(ret);
 421 }  /* RgLiTfuDatInd*/
 422
 423 #ifdef RG_UNUSED
 424 /** @brief This function frees up the TfuDatReqInfo structure.
 425  *
 426  * @details
 427  *
 428  *     Function: rgLIMUtlFreeDatReqEvnt
 429  *       - Function frees up the TfuDatReqInfo structure, in case of error it shall
 430  *       free up the buffer's present in the PDUs list.
 431  *
 432  *         Processing steps:
 433  * @param  [in] TfuDatReqInfo *datReq
 434  * @param  [in] Bool          *error
 435  * @return
 436  */
 437 #ifdef ANSI
 438 PRIVATE Void rgLIMUtlFreeDatReqEvnt
 439 (
 440  TfuDatReqInfo *datReq,
 441  Bool          error
 442  )
 443 #else
 444 PRIVATE Void rgLIMUtlFreeDatReqEvnt(datReq, error)
 445  TfuDatReqInfo *datReq;
 446  Bool          error;
 447 #endif
 448 {
 449
 450    TfuDatReqPduInfo *datInfo;
 451    CmLList          *node;
 452    U8               i;
 453
 454    TRC2(rgLIMUtlFreeDatReqEvnt);
 455    /* Steps of freeing up the TfuDatReq.
 456     * 1. Free the bch buffer.
 457     * 2. loop through the pdus list and free up all the buffers.
 458     * 3. free up the whole event
 459     */
 460    if (error)
 461    {
 462       if (datReq->bchDat.pres == PRSNT_NODEF)
 463       {
 464          RG_FREE_MSG(datReq->bchDat.val);
 465       }
 466       if (datReq->pdus.count > 0)
 467       {
 468          node =  datReq->pdus.first;
 469          while (node)
 470          {
 471             datInfo = (TfuDatReqPduInfo*)node->node;
 472             for (i=0; i<datInfo->nmbOfTBs; i++)
 473             {
 474                if (datInfo->mBuf[i] != NULLP)
 475                {
 476                   RG_FREE_MSG(datInfo->mBuf[i]);
 477                }
 478             }
 479             node = node->next;
 480          }
 481       }
 482    }
 483    RG_FREE_MEM(datReq);
 484    RETVOID;
 485 } /* end of rgLIMUtlFreeDatReqEvnt*/
 486 #endif
 487 /**
 488  * @brief This API is invoked to send Data to PHY.
 489  *
 490  * @details
 491  *
 492  *     Function : rgLIMTfuDatReq
 493  *
 494  *      This API is invoked to send Data to PHY. It
 495  *      fills in the Pst structure, spId value and invokes Data
 496  *      request primitive at TFU.
 497  *
 498  *  @param[in]  Inst        inst
 499  *  @param[in]  TfuDatReqInfo *datReq
 500  *  @return  S16
 501  *      -# ROK
 502  *      -# RFAILED
 503  **/
 504 #ifdef ANSI
 505 PUBLIC S16 rgLIMTfuDatReq
 506 (
 507 Inst          inst,
 508 TfuDatReqInfo *datReq
 509 )
 510 #else
 511 PUBLIC S16 rgLIMTfuDatReq(inst,datReq)
 512 Inst          inst;
 513 TfuDatReqInfo *datReq;
 514 #endif
 515 {
 516    S16         ret;
 517    RgLowSapCb  *tfuSap;
 518
 519    TRC2(rgLIMTfuDatReq)
 520
 521    /* Get the lower SAP control block from the layer control block. */
 522    tfuSap = &(rgCb[inst].tfuSap);
 523
 524 #ifndef NO_ERRCLS
 525    if (tfuSap->sapSta.sapState != LRG_BND)
 526    {
 527       RLOG_ARG1(L_ERROR,DBG_CELLID,datReq->cellId,"Lower SAP not bound (%d)",
 528             tfuSap->sapSta.sapState);
 529 #ifdef RG_UNUSED
 530       /* This case will never be hit if sap is not bound then we dont get TTI */
 531       rgLIMUtlFreeDatReqEvnt(datReq, TRUE);
 532 #endif
 533       RETVALUE(RFAILED);
 534    }
 535 #endif
 536
 537    tfuSap->sapSts.numPduTxmit += datReq->pdus.count;
 538
 539    /* Using existing pst - for optimization */
 540    if((ret = RgLiTfuDatReq (&tfuSap->sapCfg.sapPst, tfuSap->sapCfg.spId,
 541                             datReq)) != ROK)
 542    {
 543       RLOG_ARG0(L_ERROR,DBG_CELLID,datReq->cellId,"Call to RgLiTfuDatReq() failed");
 544    }
 545    RETVALUE(ret);
 546 }  /* rgLIMTfuDatReq*/
 547
 548 #ifdef L2_OPTMZ
 549 /**
 550  * @brief This API is invoked to send Data to PHY.
 551  *
 552  * @details
 553  *
 554  *     Function : rgLIMTfuDelDatReq
 555  *
 556  *      This API is invoked to send Data to PHY. It
 557  *      fills in the Pst structure, spId value and invokes Data
 558  *      request primitive at TFU.
 559  *
 560  *  @param[in]  Inst        inst
 561  *  @param[in]  TfuDelDatReqInfo *datReq
 562  *  @return  S16
 563  *      -# ROK
 564  *      -# RFAILED
 565  **/
 566 #ifdef ANSI
 567 PUBLIC S16 rgLIMTfuDelDatReq
 568 (
 569 Inst          inst,
 570 TfuDelDatReqInfo *delDatReq
 571 )
 572 #else
 573 PUBLIC S16 rgLIMTfuDatReq(inst,delDatReq)
 574 Inst          inst;
 575 TfuDelDatReqInfo *delDatReq;
 576 #endif
 577 {
 578    S16         ret;
 579    RgLowSapCb  *tfuSap;
 580
 581    TRC2(rgLIMTfuDelDatReq)
 582
 583    /* Get the lower SAP control block from the layer control block. */
 584    tfuSap = &(rgCb[inst].tfuSap);
 585
 586 #ifndef NO_ERRCLS
 587    if (tfuSap->sapSta.sapState != LRG_BND)
 588    {
 589       RLOG_ARG1(L_ERROR,DBG_CELLID,delDatReq->cellId,"Lower SAP not bound (%d)",
 590             tfuSap->sapSta.sapState);
 591       RETVALUE(RFAILED);
 592    }
 593 #endif
 594
 595    if((ret = RgLiTfuDelDatReq (&tfuSap->sapCfg.sapPst, tfuSap->sapCfg.spId,
 596                             delDatReq)) != ROK)
 597    {
 598       RLOG_ARG0(L_ERROR,DBG_CELLID,delDatReq->cellId,"Call to RgLiTfuDelDatReq() failed");
 599    }
 600    RETVALUE(ret);
 601 }  /* rgLIMTfuDatReq*/
 602 #endif /*L2_OPTMZ */
 603
 604 /*******************************************************************
 605  *
 606  * @brief Fills post structure
 607  *
 608  * @details
 609  *
 610  *    Function : fillMacToSchPst
 611  *
 612  *    Functionality:
 613  *      Fills post structure to be used when sending msg from
 614  *      MAC to SCH
 615  *
 616  * @params[in] Post structure pointer
 617  * @return ROK     - success
 618  *         RFAILED - failure
 619  *
 620  * ****************************************************************/
 621 void fillMacToSchPst(Pst *pst)
 622 {
 623    pst->srcProcId = 0;
 624    pst->dstProcId = 0;
 625    pst->srcEnt = ENTRG;
 626    pst->dstEnt = ENTRG;
 627    pst->srcInst = 0;
 628    pst->dstInst = 1;
 629    pst->region = 0;
 630    pst->pool =  0;
 631    pst->selector = MAC_SELECTOR_TC;
 632 }
 633
 634 /*******************************************************************
 635  *
 636  * @brief MAC handler for config response from PHY
 637  *
 638  * @details
 639  *
 640  *    Function : fapiMacConfigRsp
 641  *
 642  *    Functionality:
 643  *     Processes config response from PHY and sends cell config
 644  *     confirm to DU APP
 645  *
 646  * @params[in]
 647  * @return void
 648  *
 649  * ****************************************************************/
 650 void fapiMacConfigRsp()
 651 {
 652    /* TODO : Processing of config response from PHY */
 653
 654    /* Send cell config cfm to DU APP */
 655    MacSendCellCfgCfm(RSP_OK);
 656 }
 657
 658 /**
 659  * @brief Transmission time interval indication from PHY.
 660  *
 661  * @details
 662  *
 663  *     Function : sendSlotIndMacToSch
 664  *
 665  *      This API is invoked by MAC to send slot ind to scheduler.
 666  *
 667  *  @param[in]  SlotIndInfo    *slotInd
 668  *  @return  S16
 669  *      -# ROK
 670  *      -# RFAILED
 671  **/
 672 int sendSlotIndMacToSch(SlotIndInfo *slotInd)
 673 {
 674    /* fill Pst structure to send to lwr_mac to MAC */
 675    Pst pst;
 676
 677    fillMacToSchPst(&pst);
 678    pst.event = EVENT_SLOT_IND_TO_SCH;
 679
 680    return(*macSchSlotIndOpts[pst.selector])(&pst,slotInd);
 681 }
 682
 683
 684 /*******************************************************************
 685  *
 686  * @brief Send slot indication to DU APP
 687  *
 688  * @details
 689  *
 690  *    Function : sendSlotIndMacToDuApp
 691  *
 692  *    Functionality:
 693  *       Send slot indication to DU APP
 694  *
 695  * @params[in] Slot indication info
 696  * @return ROK     - success
 697  *         RFAILED - failure
 698  *
 699  * ****************************************************************/
 700 int sendSlotIndMacToDuApp(SlotIndInfo *slotInd)
 701 {
 702    Pst pst;
 703    uint16_t ret;
 704    SlotInfo  *slotInfo;
 705
 706    /*  Allocate sharable memory */
 707    MAC_ALLOC_SHRABL_BUF(slotInfo, sizeof(SlotInfo));
 708    if(!slotInfo)
 709    {
 710       DU_LOG("\nMAC : Slot Indication memory allocation failed");
 711       return RFAILED;
 712    }
 713
 714    slotInfo->cellId = macCb.macCell->cellId;
 715    slotInfo->sfn = slotInd->sfn;
 716    slotInfo->slot = slotInd->slot;
 717
 718    /* Fill Pst */
 719    pst.selector  = DU_MAC_LWLC;
 720    pst.srcEnt    = ENTRG;
 721    pst.dstEnt    = ENTDUAPP;
 722    pst.dstInst   = 0;
 723    pst.srcInst   = macCb.macInst;
 724    pst.dstProcId = rgCb[pst.srcInst].rgInit.procId;
 725    pst.srcProcId = rgCb[pst.srcInst].rgInit.procId;
 726    pst.region = MAC_MEM_REGION;
 727    pst.pool = MAC_POOL;
 728    pst.event = EVENT_MAC_SLOT_IND;
 729    pst.route = 0;
 730    pst.prior = 0;
 731    pst.intfVer = 0;
 732
 733    ret = MacDuAppSlotInd(&pst, slotInfo);
 734    if(ret != ROK)
 735    {
 736            DU_LOG("\nMAC: Failed to send slot indication to DU APP");
 737       MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, slotInfo, sizeof(SlotInfo));
 738    }
 739
 740    return ret;
 741 }
 742
 743 /*******************************************************************
 744  *
 745  * @brief Send stop indication to DU APP
 746  *
 747  * @details
 748  *
 749  *    Function : sendStopIndMacToDuApp
 750  *
 751  *    Functionality:
 752  *       Send stop indication to DU APP
 753  *
 754  * @params[in] Pst info
 755  * @return ROK     - success
 756  *         RFAILED - failure
 757  *
 758  * ****************************************************************/
 759 uint8_t sendStopIndMacToDuApp()
 760 {
 761    Pst pst;
 762    uint8_t ret = ROK;
 763
 764    MacCellStopInfo *cellStopId;
 765
 766    /*  Allocate sharable memory */
 767    MAC_ALLOC_SHRABL_BUF(cellStopId, sizeof(MacCellStopInfo));
 768    if(!cellStopId)
 769    {
 770       DU_LOG("\nMAC : Stop Indication memory allocation failed");
 771       return RFAILED;
 772    }
 773    cellStopId->cellId = macCb.macCell->cellId;
 774
 775    /* Fill Pst */
 776    pst.selector  = DU_MAC_LWLC;
 777    pst.srcEnt    = ENTRG;
 778    pst.dstEnt    = ENTDUAPP;
 779    pst.dstInst   = 0;
 780    pst.srcInst   = macCb.macInst;
 781    pst.dstProcId = rgCb[pst.srcInst].rgInit.procId;
 782    pst.srcProcId = rgCb[pst.srcInst].rgInit.procId;
 783    pst.region = MAC_MEM_REGION;
 784    pst.pool = MAC_POOL;
 785    pst.event = EVENT_MAC_STOP_IND;
 786    pst.route = 0;
 787    pst.prior = 0;
 788    pst.intfVer = 0;
 789
 790    ret = MacDuAppStopInd(&pst, cellStopId);
 791    if(ret != ROK)
 792    {
 793       DU_LOG("\nMAC: Failed to send stop indication to DU APP");
 794       MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, cellStopId, sizeof(MacCellStopInfo));
 795    }
 796    return ROK;
 797 }
 798 #if defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
 799  /**
 800  * @brief Transmission of non-rt indication from CL.
 801  *
 802  * @details
 803  *
 804  *     Function : RgLiTfuNonRtInd
 805  *
 806  *      This API is invoked by CL to indicate non-rt processing indication to MAC for a cell.
 807  *
 808  *  @param[in]  Pst            *pst
 809  *  @param[in]  SuId           suId
 810  *  @return  S16
 811  *      -# ROK
 812  *      -# RFAILED
 813  **/
 814 #ifdef ANSI
 815 PUBLIC S16 RgLiTfuNonRtInd
 816 (
 817 Pst                 *pst,
 818 SuId                suId
 819 )
 820 #else
 821 PUBLIC S16 RgLiTfuNonRtInd(pst, suId)
 822 Pst                 *pst;
 823 SuId                suId;
 824 #endif
 825 {
 826    TRC3(RgLiTfuNonRtInd);
 827
 828 #ifdef NO_ERRCLS
 829    if (rgLIMValidateSap (pst->dstInst - RG_INST_START, suId) != ROK)
 830    {
 831       RGDBGERRNEW(pst->dstInst - RG_INST_START, (rgPBuf(pst->dstInst - RG_INST_START),"RgLiTfuNonRtInd() SAP Validation failed.\n"));
 832       RETVALUE(RFAILED);
 833    }
 834 #endif
 835    rgDHMFreeTbBufs(pst->dstInst - RG_INST_START);
 836    RETVALUE(ROK);
 837 }  /* RgLiTfuNonRtInd */
 838
 839 #endif
 840 /**********************************************************************
 841
 842          End of file
 843 **********************************************************************/