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