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 #ifdef RG_UNUSED
  88 PRIVATE Void rgLIMUtlFreeDatReqEvnt ARGS((TfuDatReqInfo *datReq,
  89                                           Bool error));
  90 #endif
  91 /* forward references */
  92
  93 /**
  94  * @brief This API is invoked to send TFU SAP bind request to PHY.
  95  *
  96  * @details
  97  *
  98  *     Function : rgLIMTfuBndReq
  99  *
 100  *      This API is invoked to send TFU SAP bind request to PHY. It fills in
 101  *      the Pst structure, spId and suId values and invokes bind request
 102  *      primitive at TFU.
 103  *
 104  *  @param[in]  Inst        inst
 105  *  @param[in]  SuId            suId
 106  *  @param[in]  SpId            spId
 107  *  @return  S16
 108  *      -# ROK
 109  *      -# RFAILED
 110  **/
 111 #ifdef ANSI
 112 PUBLIC S16 rgLIMTfuBndReq
 113 (
 114 Inst    inst,
 115 SuId    suId,
 116 SpId    spId
 117 )
 118 #else
 119 PUBLIC S16 rgLIMTfuBndReq(inst,suId, spId)
 120 Inst    inst;
 121 SuId    suId;
 122 SpId    spId;
 123 #endif
 124 {
 125    S16         ret;
 126    RgLowSapCb  *tfuSap;
 127    Pst         pst;
 128
 129    TRC2(rgLIMTfuBndReq);
 130
 131    /* Get the lower SAP control block from the layer control block. */
 132    tfuSap = &(rgCb[inst].tfuSap);
 133    (Void)cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
 134    if((ret = RgLiTfuBndReq (&pst, suId, spId)) != ROK)
 135    {
 136       RLOG0(L_ERROR,"Call to RgLiTfuBndReq() failed");
 137    }
 138    RETVALUE(ret);
 139 }  /* rgLIMTfuBndReq */
 140
 141
 142 /**
 143  * @brief This API is invoked to send TFU SAP unbind request to PHY.
 144  *
 145  * @details
 146  *
 147  *     Function : rgLIMTfuBndReq
 148  *
 149  *      This API is invoked to send TFU SAP unbind request to PHY. It fills in
 150  *      the Pst structure and spId value and invokes unbind request
 151  *      primitive at TFU.
 152  *
 153  *  @param[in]  Inst        inst
 154  *  @param[in]  SpId            spId
 155  *  @param[in]  Reason          reason
 156  *  @return  S16
 157  *      -# ROK
 158  *      -# RFAILED
 159  **/
 160 #ifdef ANSI
 161 PUBLIC S16 rgLIMTfuUbndReq
 162 (
 163 Inst    inst,
 164 SpId    spId,
 165 Reason  reason
 166 )
 167 #else
 168 PUBLIC S16 rgLIMTfuUbndReq(inst,spId, reason)
 169 Inst    inst;
 170 SpId    spId;
 171 Reason  reason;
 172 #endif
 173 {
 174    S16         ret;
 175    RgLowSapCb  *tfuSap;
 176    Pst         pst;
 177
 178    TRC2(rgLIMTfuUbndReq);
 179
 180    /* Get the lower SAP control block from the layer control block. */
 181    tfuSap = &(rgCb[inst].tfuSap);
 182    cmMemcpy ((U8*)&pst, (U8*)&(tfuSap->sapCfg.sapPst), sizeof(Pst));
 183    if((ret = RgLiTfuUbndReq (&pst, tfuSap->sapCfg.spId, reason)) != ROK)
 184    {
 185       RLOG0(L_ERROR,"Call to RgLiTfuUbndReq() failed");
 186    }
 187    RETVALUE(ret);
 188
 189 }  /* rgLIMTfuUbndReq */
 190
 191
 192 /**
 193  * @brief Bind confirm API for TFU SAP
 194  *
 195  * @details
 196  *
 197  *     Function : RgLiTfuBndCfm
 198  *
 199  *      This API is invoked by PHY to confirm TFU SAP bind.
 200  *
 201  *
 202  *  @param[in]  Pst   *pst
 203  *  @param[in]  SuId  suId
 204  *  @param[in]  U8    status
 205  *  @return  S16
 206  *      -# ROK
 207  *      -# RFAILED
 208  **/
 209 #ifdef ANSI
 210 PUBLIC S16 RgLiTfuBndCfm
 211 (
 212 Pst     *pst,
 213 SuId    suId,
 214 U8      status
 215 )
 216 #else
 217 PUBLIC S16 RgLiTfuBndCfm(pst, suId, status)
 218 Pst     *pst;
 219 SuId    suId;
 220 U8      status;
 221 #endif
 222 {
 223    Inst inst;
 224    S16 ret;
 225    RgLowSapCb  *tfuSap;
 226
 227    TRC3(RgLiTfuBndCfm);
 228
 229
 230    RG_IS_INST_VALID(pst->dstInst);
 231    inst = pst->dstInst - RG_INST_START;
 232    /* Lets validate suId first */
 233    /* CA_Change */
 234    tfuSap = &(rgCb[inst].tfuSap);
 235
 236    if (suId != tfuSap->sapCfg.suId)
 237    {
 238       RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
 239             tfuSap->sapCfg.suId, suId);
 240       RETVALUE(RFAILED);
 241    }
 242    ret = rgLMMBndCfm (pst, suId, status);
 243    RETVALUE(ret);
 244 }  /* RgLiTfuBndCfm */
 245
 246  /** @brief This function Validates the SAP information received along with the
 247   * primitive from the lower layer.
 248   * Function:
 249   *   Validates SAP information.
 250  *  @param[in]  Inst        inst
 251   * @param  suId The SAP Id
 252   * @return
 253   *   -# ROK
 254   *   -# RFAILED
 255   */
 256 #ifdef UNUSED_FUNC
 257 #ifdef ANSI
 258 PRIVATE S16 rgLIMValidateSap
 259 (
 260  Inst    inst,
 261  SuId    suId
 262 )
 263 #else
 264 PRIVATE S16 rgLIMValidateSap(inst,suId)
 265  Inst    inst;
 266  SuId    suId;
 267 #endif
 268 {
 269    RgLowSapCb  *tfuSap;
 270
 271    TRC2(rgLIMValidateSap)
 272
 273    tfuSap = &(rgCb[inst].tfuSap);
 274
 275    /* First lets check the suId */
 276    if( suId != tfuSap->sapCfg.suId)
 277    {
 278       RLOG2(L_ERROR,"Incorrect SuId. Configured (%d) Recieved (%d)",
 279             tfuSap->sapCfg.suId, suId);
 280       RETVALUE(RFAILED);
 281    }
 282    if (tfuSap->sapSta.sapState != LRG_BND)
 283    {
 284       RLOG1(L_ERROR,"Lower SAP not enabled SuId (%d)",
 285             tfuSap->sapCfg.suId);
 286       RETVALUE(RFAILED);
 287    }
 288    RETVALUE(ROK);
 289 } /* end of rgLIMValidateSap */
 290 #endif
 291 /** @brief This function frees up the TfuDatIndInfo structure
 292  *
 293  * @details
 294  *
 295  *     Function: rgLIMUtlFreeDatIndEvnt
 296  *       - Function frees up the TfuDatIndInfo structure, in case of error it shall
 297  *       free up the buffer's present in the datIndLst.
 298  *
 299  *         Processing steps:
 300  * @param  [in] TfuDatIndInfo *datInd
 301  * @param  [in] Bool          *error
 302  * @return
 303  */
 304 #ifdef ANSI
 305 PRIVATE Void rgLIMUtlFreeDatIndEvnt
 306 (
 307  TfuDatIndInfo *datInd,
 308  Bool          error
 309  )
 310 #else
 311 PRIVATE Void rgLIMUtlFreeDatIndEvnt(datInd, error)
 312  TfuDatIndInfo *datInd;
 313  Bool          error;
 314 #endif
 315 {
 316
 317    TfuDatInfo     *datInfo;
 318    CmLList        *node;
 319
 320    TRC2(rgLIMUtlFreeDatIndEvnt);
 321    /* Steps of freeing up the TfuDatInd.
 322     * 1. loop through the datIndLst and free up all the buffers.
 323     * 2. free up the whole event
 324     */
 325    if ((error == TRUE) && (datInd->datIndLst.count > 0))
 326    {
 327       node =  datInd->datIndLst.first;
 328       while (node)
 329       {
 330          datInfo = (TfuDatInfo*)node->node;
 331          RG_FREE_MSG(datInfo->mBuf);
 332          node = node->next;
 333       }
 334    }
 335    RG_FREE_MEM(datInd);
 336    RETVOID;
 337 } /* end of rgLIMUtlFreeDatIndEvnt*/
 338
 339 /**
 340  * @brief Downlink data indication from PHY.
 341  *
 342  * @details
 343  *
 344  *     Function : RgLiTfuDatInd
 345  *
 346  *      This API is invoked by PHY to send data indication to MAC on
 347  *      recieving data from UEs.
 348  *
 349  *  @param[in]  Pst              *pst
 350  *  @param[in]  SuId             suId
 351  *  @param[in]  TfuDatIndInfo    *datInd
 352  *  @return  S16
 353  *      -# ROK
 354  *      -# RFAILED
 355  **/
 356 #ifdef ANSI
 357 PUBLIC S16 RgLiTfuDatInd
 358 (
 359 Pst                *pst,
 360 SuId               suId,
 361 TfuDatIndInfo    *datInd
 362 )
 363 #else
 364 PUBLIC S16 RgLiTfuDatInd(pst, suId, datInd)
 365 Pst                *pst;
 366 SuId               suId;
 367 TfuDatIndInfo    *datInd;
 368 #endif
 369 {
 370    Inst             inst;
 371    S16              ret;
 372    VOLATILE U32     startTime=0;
 373
 374    TRC3(RgLiTfuDatInd);
 375
 376   // printf("5GTF:: DatindRcvd\n");
 377
 378    RG_IS_INST_VALID(pst->dstInst);
 379    inst = pst->dstInst - RG_INST_START;
 380    /*starting Task*/
 381    SStartTask(&startTime, PID_MAC_TFU_DATIND);
 382
 383 #ifndef NO_ERRCLS
 384    if ((ret = rgLIMValidateSap (inst,suId)) != ROK)
 385    {
 386       RLOG_ARG0(L_ERROR,DBG_CELLID,datInd->cellId,"SAP Validation failed");
 387       rgLIMUtlFreeDatIndEvnt(datInd, TRUE);
 388       RETVALUE(ret);
 389    }
 390 #endif
 391    /* Now call the TOM (Tfu ownership module) primitive to process further */
 392    rgCb[inst].tfuSap.sapSts.numPduRcvd +=
 393                     datInd->datIndLst.count;
 394    ret = rgTOMDatInd(inst,datInd);
 395    /* Fix: sriky memory corruption precautions */
 396    /* Free up the memory for the request structure */
 397    if (ret == ROK)
 398    {
 399       rgLIMUtlFreeDatIndEvnt(datInd, FALSE);
 400    }
 401    else
 402    {
 403       rgLIMUtlFreeDatIndEvnt(datInd, TRUE);
 404    }
 405
 406    /*stoping Task*/
 407    SStopTask(startTime, PID_MAC_TFU_DATIND);
 408
 409    RETVALUE(ret);
 410 }  /* RgLiTfuDatInd*/
 411
 412 #ifdef RG_UNUSED
 413 /** @brief This function frees up the TfuDatReqInfo structure.
 414  *
 415  * @details
 416  *
 417  *     Function: rgLIMUtlFreeDatReqEvnt
 418  *       - Function frees up the TfuDatReqInfo structure, in case of error it shall
 419  *       free up the buffer's present in the PDUs list.
 420  *
 421  *         Processing steps:
 422  * @param  [in] TfuDatReqInfo *datReq
 423  * @param  [in] Bool          *error
 424  * @return
 425  */
 426 #ifdef ANSI
 427 PRIVATE Void rgLIMUtlFreeDatReqEvnt
 428 (
 429  TfuDatReqInfo *datReq,
 430  Bool          error
 431  )
 432 #else
 433 PRIVATE Void rgLIMUtlFreeDatReqEvnt(datReq, error)
 434  TfuDatReqInfo *datReq;
 435  Bool          error;
 436 #endif
 437 {
 438
 439    TfuDatReqPduInfo *datInfo;
 440    CmLList          *node;
 441    U8               i;
 442
 443    TRC2(rgLIMUtlFreeDatReqEvnt);
 444    /* Steps of freeing up the TfuDatReq.
 445     * 1. Free the bch buffer.
 446     * 2. loop through the pdus list and free up all the buffers.
 447     * 3. free up the whole event
 448     */
 449    if (error)
 450    {
 451       if (datReq->bchDat.pres == PRSNT_NODEF)
 452       {
 453          RG_FREE_MSG(datReq->bchDat.val);
 454       }
 455       if (datReq->pdus.count > 0)
 456       {
 457          node =  datReq->pdus.first;
 458          while (node)
 459          {
 460             datInfo = (TfuDatReqPduInfo*)node->node;
 461             for (i=0; i<datInfo->nmbOfTBs; i++)
 462             {
 463                if (datInfo->mBuf[i] != NULLP)
 464                {
 465                   RG_FREE_MSG(datInfo->mBuf[i]);
 466                }
 467             }
 468             node = node->next;
 469          }
 470       }
 471    }
 472    RG_FREE_MEM(datReq);
 473    RETVOID;
 474 } /* end of rgLIMUtlFreeDatReqEvnt*/
 475 #endif
 476 /**
 477  * @brief This API is invoked to send Data to PHY.
 478  *
 479  * @details
 480  *
 481  *     Function : rgLIMTfuDatReq
 482  *
 483  *      This API is invoked to send Data to PHY. It
 484  *      fills in the Pst structure, spId value and invokes Data
 485  *      request primitive at TFU.
 486  *
 487  *  @param[in]  Inst        inst
 488  *  @param[in]  TfuDatReqInfo *datReq
 489  *  @return  S16
 490  *      -# ROK
 491  *      -# RFAILED
 492  **/
 493 #ifdef ANSI
 494 PUBLIC S16 rgLIMTfuDatReq
 495 (
 496 Inst          inst,
 497 TfuDatReqInfo *datReq
 498 )
 499 #else
 500 PUBLIC S16 rgLIMTfuDatReq(inst,datReq)
 501 Inst          inst;
 502 TfuDatReqInfo *datReq;
 503 #endif
 504 {
 505    S16         ret;
 506    RgLowSapCb  *tfuSap;
 507
 508    TRC2(rgLIMTfuDatReq)
 509
 510    /* Get the lower SAP control block from the layer control block. */
 511    tfuSap = &(rgCb[inst].tfuSap);
 512
 513 #ifndef NO_ERRCLS
 514    if (tfuSap->sapSta.sapState != LRG_BND)
 515    {
 516       RLOG_ARG1(L_ERROR,DBG_CELLID,datReq->cellId,"Lower SAP not bound (%d)",
 517             tfuSap->sapSta.sapState);
 518 #ifdef RG_UNUSED
 519       /* This case will never be hit if sap is not bound then we dont get TTI */
 520       rgLIMUtlFreeDatReqEvnt(datReq, TRUE);
 521 #endif
 522       RETVALUE(RFAILED);
 523    }
 524 #endif
 525
 526    tfuSap->sapSts.numPduTxmit += datReq->pdus.count;
 527
 528    /* Using existing pst - for optimization */
 529    if((ret = RgLiTfuDatReq (&tfuSap->sapCfg.sapPst, tfuSap->sapCfg.spId,
 530                             datReq)) != ROK)
 531    {
 532       RLOG_ARG0(L_ERROR,DBG_CELLID,datReq->cellId,"Call to RgLiTfuDatReq() failed");
 533    }
 534    RETVALUE(ret);
 535 }  /* rgLIMTfuDatReq*/
 536
 537 #ifdef L2_OPTMZ
 538 /**
 539  * @brief This API is invoked to send Data to PHY.
 540  *
 541  * @details
 542  *
 543  *     Function : rgLIMTfuDelDatReq
 544  *
 545  *      This API is invoked to send Data to PHY. It
 546  *      fills in the Pst structure, spId value and invokes Data
 547  *      request primitive at TFU.
 548  *
 549  *  @param[in]  Inst        inst
 550  *  @param[in]  TfuDelDatReqInfo *datReq
 551  *  @return  S16
 552  *      -# ROK
 553  *      -# RFAILED
 554  **/
 555 #ifdef ANSI
 556 PUBLIC S16 rgLIMTfuDelDatReq
 557 (
 558 Inst          inst,
 559 TfuDelDatReqInfo *delDatReq
 560 )
 561 #else
 562 PUBLIC S16 rgLIMTfuDatReq(inst,delDatReq)
 563 Inst          inst;
 564 TfuDelDatReqInfo *delDatReq;
 565 #endif
 566 {
 567    S16         ret;
 568    RgLowSapCb  *tfuSap;
 569
 570    TRC2(rgLIMTfuDelDatReq)
 571
 572    /* Get the lower SAP control block from the layer control block. */
 573    tfuSap = &(rgCb[inst].tfuSap);
 574
 575 #ifndef NO_ERRCLS
 576    if (tfuSap->sapSta.sapState != LRG_BND)
 577    {
 578       RLOG_ARG1(L_ERROR,DBG_CELLID,delDatReq->cellId,"Lower SAP not bound (%d)",
 579             tfuSap->sapSta.sapState);
 580       RETVALUE(RFAILED);
 581    }
 582 #endif
 583
 584    if((ret = RgLiTfuDelDatReq (&tfuSap->sapCfg.sapPst, tfuSap->sapCfg.spId,
 585                             delDatReq)) != ROK)
 586    {
 587       RLOG_ARG0(L_ERROR,DBG_CELLID,delDatReq->cellId,"Call to RgLiTfuDelDatReq() failed");
 588    }
 589    RETVALUE(ret);
 590 }  /* rgLIMTfuDatReq*/
 591 #endif /*L2_OPTMZ */
 592
 593 /*******************************************************************
 594  *
 595  * @brief Fills post structure
 596  *
 597  * @details
 598  *
 599  *    Function : fillMacToSchPst
 600  *
 601  *    Functionality:
 602  *      Fills post structure to be used when sending msg from
 603  *      MAC to SCH
 604  *
 605  * @params[in] Post structure pointer
 606  * @return ROK     - success
 607  *         RFAILED - failure
 608  *
 609  * ****************************************************************/
 610 void fillMacToSchPst(Pst *pst)
 611 {
 612    pst->srcProcId = 0;
 613    pst->dstProcId = 0;
 614    pst->srcEnt = ENTRG;
 615    pst->dstEnt = ENTRG;
 616    pst->srcInst = 0;
 617    pst->dstInst = 1;
 618    pst->region = 0;
 619    pst->pool =  0;
 620    pst->selector = MAC_SELECTOR_TC;
 621 }
 622
 623 /*******************************************************************
 624  *
 625  * @brief MAC handler for config response from PHY
 626  *
 627  * @details
 628  *
 629  *    Function : fapiMacConfigRsp
 630  *
 631  *    Functionality:
 632  *     Processes config response from PHY and sends cell config
 633  *     confirm to DU APP
 634  *
 635  * @params[in]
 636  * @return void
 637  *
 638  * ****************************************************************/
 639 void fapiMacConfigRsp()
 640 {
 641    /* TODO : Processing of config response from PHY */
 642
 643    /* Send cell config cfm to DU APP */
 644    MacSendCellCfgCfm(RSP_OK);
 645 }
 646
 647 /*******************************************************************
 648  *
 649  * @brief Send stop indication to DU APP
 650  *
 651  * @details
 652  *
 653  *    Function : sendStopIndMacToDuApp
 654  *
 655  *    Functionality:
 656  *       Send stop indication to DU APP
 657  *
 658  * @params[in] Pst info
 659  * @return ROK     - success
 660  *         RFAILED - failure
 661  *
 662  * ****************************************************************/
 663 uint8_t sendStopIndMacToDuApp()
 664 {
 665    Pst pst;
 666    uint8_t ret = ROK;
 667
 668    MacCellStopInfo *cellStopId;
 669
 670    /*  Allocate sharable memory */
 671    MAC_ALLOC_SHRABL_BUF(cellStopId, sizeof(MacCellStopInfo));
 672    if(!cellStopId)
 673    {
 674       DU_LOG("\nMAC : Stop Indication memory allocation failed");
 675       return RFAILED;
 676    }
 677    cellStopId->cellId = macCb.macCell->cellId;
 678
 679    /* Fill Pst */
 680    pst.selector  = DU_MAC_LWLC;
 681    pst.srcEnt    = ENTRG;
 682    pst.dstEnt    = ENTDUAPP;
 683    pst.dstInst   = 0;
 684    pst.srcInst   = macCb.macInst;
 685    pst.dstProcId = rgCb[pst.srcInst].rgInit.procId;
 686    pst.srcProcId = rgCb[pst.srcInst].rgInit.procId;
 687    pst.region = MAC_MEM_REGION;
 688    pst.pool = MAC_POOL;
 689    pst.event = EVENT_MAC_STOP_IND;
 690    pst.route = 0;
 691    pst.prior = 0;
 692    pst.intfVer = 0;
 693
 694    ret = MacDuAppStopInd(&pst, cellStopId);
 695    if(ret != ROK)
 696    {
 697       DU_LOG("\nMAC: Failed to send stop indication to DU APP");
 698       MAC_FREE_SHRABL_BUF(MAC_MEM_REGION, MAC_POOL, cellStopId, sizeof(MacCellStopInfo));
 699    }
 700    return ROK;
 701 }
 702 #if defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
 703  /**
 704  * @brief Transmission of non-rt indication from CL.
 705  *
 706  * @details
 707  *
 708  *     Function : RgLiTfuNonRtInd
 709  *
 710  *      This API is invoked by CL to indicate non-rt processing indication to MAC for a cell.
 711  *
 712  *  @param[in]  Pst            *pst
 713  *  @param[in]  SuId           suId
 714  *  @return  S16
 715  *      -# ROK
 716  *      -# RFAILED
 717  **/
 718 #ifdef ANSI
 719 PUBLIC S16 RgLiTfuNonRtInd
 720 (
 721 Pst                 *pst,
 722 SuId                suId
 723 )
 724 #else
 725 PUBLIC S16 RgLiTfuNonRtInd(pst, suId)
 726 Pst                 *pst;
 727 SuId                suId;
 728 #endif
 729 {
 730    TRC3(RgLiTfuNonRtInd);
 731
 732 #ifdef NO_ERRCLS
 733    if (rgLIMValidateSap (pst->dstInst - RG_INST_START, suId) != ROK)
 734    {
 735       RGDBGERRNEW(pst->dstInst - RG_INST_START, (rgPBuf(pst->dstInst - RG_INST_START),"RgLiTfuNonRtInd() SAP Validation failed.\n"));
 736       RETVALUE(RFAILED);
 737    }
 738 #endif
 739    rgDHMFreeTbBufs(pst->dstInst - RG_INST_START);
 740    RETVALUE(ROK);
 741 }  /* RgLiTfuNonRtInd */
 742
 743 #endif
 744 /**********************************************************************
 745
 746          End of file
 747 **********************************************************************/