src/5gnrmac/rg_sch_pt.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 INF Interface Module
  26
  27      File:     rg_sch_pt.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_sch_pt.c
  32 @brief This file contains the definitions for Upper Interface(RGR/CRG/RGU)
  33        primitives that are invoked from MAC to its service users.
  34        Portable functions corresponding to these primitives are also defined.
  35 */
  36 /* header include files (.h) */
  37 #include "envopt.h"        /* environment options */
  38 #include "envdep.h"        /* environment dependent */
  39 #include "envind.h"        /* environment independent */
  40 #include "gen.h"           /* general */
  41 #include "ssi.h"           /* system services */
  42 #include "cm_tkns.h"       /* Common Token Defines */
  43 #include "cm_llist.h"      /* Common Link List Defines */
  44 #include "cm_hash.h"       /* Common Hash List Defines */
  45 #include "cm_lte.h"        /* Common LTE Defines */
  46 #include "rg_env.h"        /* MAC Environment Defines */
  47 #include "crg.h"           /* CRG Interface defines */
  48 #include "rgr.h"           /* RGR Interface defines */
  49 #include "rgu.h"           /* RGU Interface defines */
  50 #include "cm_mblk.h"       /* memory management */
  51 #include "cm_lte.h"        /* Common LTE Defines */
  52 #include "tfu.h"           /* RGU Interface defines */
  53 #ifdef LTE_L2_MEAS
  54 #include "lrg.h"
  55 #endif
  56 #include "rg_sch_inf.h"           /* RGU Interface defines */
  57
  58 /* header/extern include files (.x) */
  59 #include "gen.x"           /* general */
  60 #include "ssi.x"           /* system services */
  61 #include "cm_tkns.x"       /* Common Token Definitions */
  62 #include "cm_llist.x"      /* Common Link List Definitions */
  63 #include "cm_lib.x"        /* Common Library Definitions */
  64 #include "cm_hash.x"       /* Common Hash List Definitions */
  65 #include "cm_lte.x"        /* Common LTE Defines */
  66 #include "crg.x"           /* CRG Interface includes */
  67 #include "rgr.x"           /* RGR Interface includes */
  68 #include "rgu.x"           /* RGU Interface includes */
  69 #include "cm_mblk.x"       /* memory management */
  70 #include "cm_lte.x"        /* Common LTE Defines */
  71 #include "tfu.x"           /* RGU Interface includes */
  72 #ifdef LTE_L2_MEAS
  73 #include "lrg.x"
  74 #endif
  75 #include "rg_sch_inf.x"           /* RGU Interface includes */
  76
  77 #define RG_MAX_SCH 1
  78
  79 PRIVATE CONSTANT CellRegReq RgSchMacCellRegReqMt[RG_MAX_SCH] =
  80 {
  81 #ifdef LCSCH
  82    cmPkSchMacCellRegReq,
  83 #else
  84    RgSchMacCellRegReq
  85 #endif
  86 };
  87
  88 PRIVATE CONSTANT DedBoUpdtReq RgMacSchDedBoUpdtReqMt[RG_MAX_SCH] =
  89 {
  90 #ifdef LCSCH
  91    cmPkMacSchDedBoUpdtReq,
  92 #else
  93    RgMacSchDedBoUpdtReq
  94 #endif
  95 };
  96
  97 PRIVATE CONSTANT CmnBoUpdtReq RgMacSchCmnBoUpdtReqMt[RG_MAX_SCH] =
  98 {
  99 #ifdef LCSCH
 100    cmPkMacSchCmnBoUpdtReq,
 101 #else
 102    RgMacSchCmnBoUpdtReq
 103 #endif
 104 };
 105
 106 PRIVATE CONSTANT SfRecpInd RgMacSchSfRecpIndMt[RG_MAX_SCH] =
 107 {
 108 #ifdef LCSCH
 109    cmPkMacSchSfRecpInd
 110 #else
 111    RgMacSchSfRecpInd,
 112 #endif
 113 };
 114 /*Fix: start: Inform UE delete to scheduler*/
 115 PRIVATE CONSTANT UeDelInd RgMacSchUeDelIndMt[RG_MAX_SCH] =
 116 {
 117 #ifdef LCSCH
 118    cmPkMacSchUeDelInd
 119 #else
 120    RgMacSchUeDelInd,
 121 #endif
 122 };
 123 /*Fix: end: Inform UE delete to scheduler*/
 124 PRIVATE CONSTANT SfAllocReq RgSchMacSfAllocReqMt[RG_MAX_SCH] =
 125 {
 126 #ifdef LCSCH
 127    cmPkSchMacSfAllocReq,
 128 #else
 129    RgSchMacSfAllocReq
 130 #endif
 131 };
 132
 133 PRIVATE CONSTANT RstHqEntReq RgSchMacRstHqEntReqMt[RG_MAX_SCH] =
 134 {
 135 #ifdef LCSCH
 136    cmPkSchMacRstHqEntReq,
 137 #else
 138    RgSchMacRstHqEntReq
 139 #endif
 140 };
 141 PRIVATE CONSTANT RlsHqReq RgSchMacRlsHqReqMt[RG_MAX_SCH] =
 142 {
 143 #ifdef LCSCH
 144    cmPkSchMacRlsHqReq,
 145 #else
 146    RgSchMacRlsHqReq
 147 #endif
 148 };
 149
 150 PRIVATE CONSTANT RlsRntiReq RgSchMacRlsRntiReqMt[RG_MAX_SCH] =
 151 {
 152 #ifdef LCSCH
 153    cmPkSchMacRlsRntiReq,
 154 #else
 155    RgSchMacRlsRntiReq
 156 #endif
 157 };
 158
 159 PRIVATE CONSTANT LcgReg RgSchMacLcgRegReqMt[RG_MAX_SCH] =
 160 {
 161 #ifdef LCSCH
 162    cmPkSchMacLcgRegReq,
 163 #else
 164    RgSchMacLcgRegReq
 165 #endif
 166 };
 167
 168 #ifdef LTEMAC_SPS
 169 PRIVATE CONSTANT SpsLcReg RgSchMacSpsLcRegReqMt[RG_MAX_SCH] =
 170 {
 171 #ifdef LCSCH
 172    cmPkSchMacSpsLcRegReq,
 173 #else
 174    RgSchMacSpsLcRegReq
 175 #endif
 176 };
 177
 178 PRIVATE CONSTANT UlSpsReset RgSchMacUlSpsResetMt[RG_MAX_SCH] =
 179 {
 180 #ifdef LCSCH
 181    cmPkSchMacUlSpsReset,
 182 #else
 183    RgSchMacUlSpsResetReq
 184 #endif
 185 };
 186
 187
 188
 189 PRIVATE CONSTANT SpsLcDereg RgSchMacSpsLcDeregReqMt[RG_MAX_SCH] =
 190 {
 191 #ifdef LCSCH
 192    cmPkSchMacSpsLcDeregReq,
 193 #else
 194    RgSchMacSpsLcDeregReq
 195 #endif
 196 };
 197
 198 PRIVATE CONSTANT SpsRelInd RgMacSchSpsRelIndMt[RG_MAX_SCH] =
 199 {
 200 #ifdef LCSCH
 201    cmPkMacSchSpsRelInd,
 202 #else
 203    RgMacSchSpsRelInd
 204 #endif
 205 };
 206
 207 #endif /* LTEMAC_SPS */
 208
 209 #ifdef LTE_L2_MEAS
 210 PRIVATE CONSTANT L2MeasReq RgSchMacL2MeasReqMt[RG_MAX_SCH] =
 211 {
 212 #ifdef LCSCH
 213    cmPkSchMacL2MeasReq
 214 #else
 215    RgSchMacL2MeasReq
 216 #endif
 217 };
 218 /*Added for Rsys oam*/
 219 PRIVATE CONSTANT L2MeasStopReq RgSchMacL2MeasStopReqMt[RG_MAX_SCH] =
 220 {
 221 #ifdef LCSCH
 222    cmPkSchMacL2MeasStopReq
 223 #else
 224    RgSchMacL2MeasStopReq
 225 #endif
 226 };
 227
 228 PRIVATE CONSTANT L2MeasSendReq RgSchMacL2MeasSendReqMt[RG_MAX_SCH] =
 229 {
 230 #ifdef LCSCH
 231    cmPkSchMacL2MeasSendReq
 232 #else
 233    RgSchMacL2MeasSendReq
 234 #endif
 235 };
 236
 237 PRIVATE CONSTANT L2MeasCfm RgMacSchL2MeasCfmMt[RG_MAX_SCH] =
 238 {
 239 #ifdef LCSCH
 240    cmPkMacSchL2MeasCfm
 241 #else
 242    RgMacSchL2MeasCfm
 243 #endif
 244 };
 245 PRIVATE CONSTANT L2MeasStopCfm RgMacSchL2MeasStopCfmMt[RG_MAX_SCH] =
 246 {
 247 #ifdef LCSCH
 248    cmPkMacSchL2MeasStopCfm
 249 #else
 250    RgMacSchL2MeasStopCfm
 251 #endif
 252 };
 253 #endif/*LTE_L2_MEAS*/
 254 /**
 255 * @brief Data Indication from MAC to RLC to
 256  * forward the data received for dedicated channels
 257 *
 258 * @details
 259 *
 260 *     Function : RgSchMacCellReg
 261 *
 262 *  @param[in]   Pst*  pst
 263 *  @param[in]   SuId  suId
 264 *  @param[in]   RguDDatIndInfo  *  datInd
 265 *  @return   S16
 266 *      -# ROK
 267 **/
 268 #ifdef ANSI
 269 PUBLIC S16 RgSchMacCellReg
 270 (
 271 Pst* pst,
 272 RgInfCellReg*   regReq
 273 )
 274 #else
 275 PUBLIC S16 RgSchMacCellReg(pst, regReq)
 276 Pst* pst;
 277 RgInfCellReg*   regReq;
 278 #endif
 279 {
 280
 281    TRC3(RgSchMacCellReg);
 282
 283    RETVALUE((*RgSchMacCellRegReqMt[0])(pst, regReq));
 284 }
 285
 286 /**
 287 * @brief Data Indication from MAC to RLC to
 288  * forward the data received for dedicated channels
 289 *
 290 * @details
 291 *
 292 *     Function : RgMacSchDedBoUpdt
 293 *
 294 *  @param[in]   Pst*  pst
 295 *  @param[in]   SuId  suId
 296 *  @param[in]   RguDDatIndInfo  *  datInd
 297 *  @return   S16
 298 *      -# ROK
 299 **/
 300 #ifdef ANSI
 301 PUBLIC S16 RgMacSchDedBoUpdt
 302 (
 303 Pst* pst,
 304 RgInfDedBoRpt*  boRpt
 305 )
 306 #else
 307 PUBLIC S16 RgMacSchDedBoUpdt(pst, boRpt)
 308 Pst* pst;
 309 RgInfDedBoRpt*  boRpt;
 310 #endif
 311 {
 312
 313    TRC3(RgMacSchDedBoUpdt);
 314
 315    RETVALUE((*RgMacSchDedBoUpdtReqMt[0])(pst, boRpt));
 316 }
 317
 318 /**
 319 * @brief Data Indication from MAC to RLC to
 320  * forward the data received for dedicated channels
 321 *
 322 * @details
 323 *
 324 *     Function : RgMacSchCmnBoUpdt
 325 *
 326 *  @param[in]   Pst*  pst
 327 *  @param[in]   SuId  suId
 328 *  @param[in]   RguDDatIndInfo  *  datInd
 329 *  @return   S16
 330 *      -# ROK
 331 **/
 332 #ifdef ANSI
 333 PUBLIC S16 RgMacSchCmnBoUpdt
 334 (
 335 Pst* pst,
 336 RgInfCmnBoRpt*  boRpt
 337 )
 338 #else
 339 PUBLIC S16 RgMacSchCmnBoUpdt(pst, boRpt)
 340 Pst* pst;
 341 RgInfCmnBoRpt*  boRpt;
 342 #endif
 343 {
 344
 345    TRC3(RgMacSchCmnBoUpdt);
 346
 347    RETVALUE((*RgMacSchCmnBoUpdtReqMt[0])(pst, boRpt));
 348 }
 349
 350 /*Fix: start: Inform UE delete to scheduler*/
 351 /**
 352 * @brief This primitive is used to indicate deletion of UE
 353 *        at MAC to scheduler.
 354 *
 355 * @details
 356 *
 357 *     Function : RgMacSchUeDel
 358 *
 359 *  @param[in]   Pst*  pst
 360 *  @param[in]   RgInfSfDatInd*  ueDelInd
 361 *  @return   S16
 362 *      -# ROK
 363 **/
 364 #ifdef ANSI
 365 PUBLIC S16 RgMacSchUeDel
 366 (
 367 Pst* pst,
 368 RgInfUeDelInd*  ueDelInd
 369 )
 370 #else
 371 PUBLIC S16 RgMacSchUeDel(pst, datInd)
 372 Pst* pst;
 373 RgInfUeDelInd*  ueDelInd;
 374 #endif
 375 {
 376
 377    TRC3(RgMacSchUeDel);
 378
 379    RETVALUE((*RgMacSchUeDelIndMt[0])(pst, ueDelInd));
 380 }
 381 /*Fix: end: Inform UE delete to scheduler*/
 382 /**
 383 * @brief Data Indication from MAC to RLC to
 384  * forward the data received for dedicated channels
 385 *
 386 * @details
 387 *
 388 *     Function : RgMacSchSfRecp
 389 *
 390 *  @param[in]   Pst*  pst
 391 *  @param[in]   SuId  suId
 392 *  @param[in]   RguDDatIndInfo  *  datInd
 393 *  @return   S16
 394 *      -# ROK
 395 **/
 396 #ifdef ANSI
 397 PUBLIC S16 RgMacSchSfRecp
 398 (
 399 Pst* pst,
 400 RgInfSfDatInd*  datInd
 401 )
 402 #else
 403 PUBLIC S16 RgMacSchSfRecp(pst, datInd)
 404 Pst* pst;
 405 RgInfSfDatInd*  datInd;
 406 #endif
 407 {
 408
 409    TRC3(RgMacSchSfRecp);
 410
 411    RETVALUE((*RgMacSchSfRecpIndMt[0])(pst, datInd));
 412 }
 413
 414 /**
 415 * @brief Data Indication from MAC to RLC to
 416  * forward the data received for dedicated channels
 417 *
 418 * @details
 419 *
 420 *     Function : RgSchMacSfAlloc
 421 *
 422 *  @param[in]   Pst*  pst
 423 *  @param[in]   SuId  suId
 424 *  @param[in]   RguDDatIndInfo  *  datInd
 425 *  @return   S16
 426 *      -# ROK
 427 **/
 428 #ifdef ANSI
 429 PUBLIC S16 RgSchMacSfAlloc
 430 (
 431 Pst* pst,
 432 RgInfSfAlloc*   resAllocReq
 433 )
 434 #else
 435 PUBLIC S16 RgSchMacSfAlloc(pst, resAllocReq)
 436 Pst* pst;
 437 RgInfSfAlloc*   resAllocReq;
 438 #endif
 439 {
 440
 441    TRC3(RgSchMacSfAlloc);
 442
 443    RETVALUE((*RgSchMacSfAllocReqMt[0])(pst, resAllocReq));
 444 }
 445
 446 /**
 447 * @brief Trigger for resetting Harq Entity at MAC
 448 *
 449 * @details
 450 *
 451 *     Function : RgSchMacRstHqEnt
 452 *
 453 *  @param[in]   Pst*  pst
 454 *  @param[in]   RgInfResetHqEnt *hqEntRstReq
 455 *  @return   S16
 456 *      -# ROK
 457 **/
 458 #ifdef ANSI
 459 PUBLIC S16 RgSchMacRstHqEnt
 460 (
 461 Pst*                 pst,
 462 RgInfResetHqEnt*     hqEntInfo
 463 )
 464 #else
 465 PUBLIC S16 RgSchMacRstHqEnt(pst, hqEntInfo)
 466 Pst*                 pst;
 467 RgInfResetHqEnt*     hqEntInfo;
 468 #endif
 469 {
 470
 471    TRC3(RgSchMacRstHqEnt)
 472
 473    RETVALUE((*RgSchMacRstHqEntReqMt[0])(pst, hqEntInfo));
 474 }
 475
 476 /**
 477 * @brief Data Indication from MAC to RLC to
 478  * forward the data received for dedicated channels
 479 *
 480 * @details
 481 *
 482 *     Function : RgSchMacRlsHq
 483 *
 484 *  @param[in]   Pst*  pst
 485 *  @param[in]   SuId  suId
 486 *  @param[in]   RguDDatIndInfo  *  datInd
 487 *  @return   S16
 488 *      -# ROK
 489 **/
 490 #ifdef ANSI
 491 PUBLIC S16 RgSchMacRlsHq
 492 (
 493 Pst* pst,
 494 RgInfRlsHqInfo* sfHqInfo
 495 )
 496 #else
 497 PUBLIC S16 RgSchMacRlsHq(pst, sfHqInfo)
 498 Pst* pst;
 499 RgInfRlsHqInfo* sfHqInfo;
 500 #endif
 501 {
 502
 503    TRC3(RgSchMacRlsHq);
 504
 505    RETVALUE((*RgSchMacRlsHqReqMt[0])(pst, sfHqInfo));
 506 }
 507
 508 /**
 509 * @brief Data Indication from MAC to RLC to
 510  * forward the data received for dedicated channels
 511 *
 512 * @details
 513 *
 514 *     Function : RgSchMacRlsRnti
 515 *
 516 *  @param[in]   Pst*  pst
 517 *  @param[in]   SuId  suId
 518 *  @param[in]   RguDDatIndInfo  *  datInd
 519 *  @return   S16
 520 *      -# ROK
 521 **/
 522 #ifdef ANSI
 523 PUBLIC S16 RgSchMacRlsRnti
 524 (
 525 Pst* pst,
 526 RgInfRlsRnti*   rlsRnti
 527 )
 528 #else
 529 PUBLIC S16 RgSchMacRlsRnti(pst, rlsRnti)
 530 Pst* pst;
 531 RgInfRlsRnti*   rlsRnti;
 532 #endif
 533 {
 534
 535    TRC3(RgSchMacRlsRnti);
 536
 537    RETVALUE((*RgSchMacRlsRntiReqMt[0])(pst, rlsRnti));
 538 }
 539
 540 /**
 541 * @brief Request from SCH to MAC to register the GBR LCG of a UE
 542 *
 543 * @details
 544 *
 545 *     Function : RgSchMacLcgReg
 546 *
 547 *  @param[in]   Pst*           pst
 548 *  @param[in]   RgInfLcgRegReq *lcgRegReq
 549 *  @return   S16
 550 *      -# ROK
 551 **/
 552 #ifdef ANSI
 553 PUBLIC S16 RgSchMacLcgReg
 554 (
 555 Pst*                pst,
 556 RgInfLcgRegReq      *lcgRegReq
 557 )
 558 #else
 559 PUBLIC S16 RgSchMacLcgReg(pst, lcgRegReq)
 560 Pst*                pst;
 561 RgInfLcgRegReq       *lcgRegReq;
 562 #endif
 563 {
 564
 565    TRC3(RgSchMacLcgReg);
 566
 567    RETVALUE((*RgSchMacLcgRegReqMt[0])(pst, lcgRegReq));
 568 } /* end of RgSchMacLcgReg */
 569
 570 #ifdef LTEMAC_SPS
 571 /**
 572 * @brief Data Indication from MAC to SCH to
 573  * indicate the arrival of the data on SPS logical channels
 574 *
 575 * @details
 576 *
 577 *     Function : RgMacSchSpsRel
 578 *
 579 *  @param[in]   Pst*  pst
 580 *  @param[in]   RgInfSpsRelInfo* relInfo
 581 *  @return   S16
 582 *      -# ROK
 583 **/
 584 #ifdef ANSI
 585 PUBLIC S16 RgMacSchSpsRel
 586 (
 587 Pst*                pst,
 588 RgInfSpsRelInfo*    relInfo
 589 )
 590 #else
 591 PUBLIC S16 RgMacSchSpsRel(pst, relInfo)
 592 Pst*                pst;
 593 RgInfSpsRelInfo*    relInfo;
 594 #endif
 595 {
 596
 597    TRC3(RgMacSchS);
 598
 599    RETVALUE((*RgMacSchSpsRelIndMt[0])(pst, relInfo));
 600 } /* end of RgMacSchSpsRel */
 601
 602 /**
 603 * @brief Request from SCH to MAC to register the SPS logical channels of a UE
 604 *
 605 * @details
 606 *
 607 *     Function : RgSchMacSpsLcReg
 608 *
 609 *  @param[in]   Pst*           pst
 610 *  @param[in]   RgInfSpsLcInfo *lcInfo
 611 *  @return   S16
 612 *      -# ROK
 613 **/
 614 #ifdef ANSI
 615 PUBLIC S16 RgSchMacSpsLcReg
 616 (
 617 Pst*                pst,
 618 RgInfSpsLcInfo      *lcInfo
 619 )
 620 #else
 621 PUBLIC S16 RgSchMacSpsLcReg(pst, lcInfo)
 622 Pst*                pst;
 623 RgInfSpsLcInfo      *lcInfo;
 624 #endif
 625 {
 626
 627    TRC3(RgSchMacSpsLcReg);
 628
 629    RETVALUE((*RgSchMacSpsLcRegReqMt[0])(pst, lcInfo));
 630 } /* end of RgSchMacSpsLcReg */
 631
 632
 633
 634 /**
 635 * @brief Request from SCH to MAC to reset UL SPS params
 636 *
 637 * @details
 638 *
 639 *     Function : RgSchMacUlSpsReset
 640 *
 641 *  @param[in]   Pst*           pst
 642 *  @param[in]   RgInfUlSpsReset *lcInfo
 643 *  @return   S16
 644 *      -# ROK
 645 **/
 646 #ifdef ANSI
 647 PUBLIC S16 RgSchMacUlSpsReset
 648 (
 649 Pst*                pst,
 650 RgInfUlSpsReset      *ulSpsResetInfo
 651 )
 652 #else
 653 PUBLIC S16 RgSchMacUlSpsReset(pst, ulSpsResetInfo)
 654 Pst*                pst;
 655 RgInfUlSpsReset      *ulSpsResetInfo;
 656 #endif
 657 {
 658
 659    TRC3(RgSchMacUlSpsReset);
 660
 661    RETVALUE((*RgSchMacUlSpsResetMt[0])(pst, ulSpsResetInfo));
 662 } /* end of RgSchMacUlSpsReset */
 663
 664
 665
 666 /**
 667 * @brief Request from SCH to MAC to deregister the SPS logical channels of a UE
 668 *
 669 * @details
 670 *
 671 *     Function : RgSchMacSpsLcDereg
 672 *
 673 *  @param[in]   Pst*           pst
 674 *  @param[in]   RgInfSpsLcInfo *lcInfo
 675 *  @return   S16
 676 *      -# ROK
 677 **/
 678 #ifdef ANSI
 679 PUBLIC S16 RgSchMacSpsLcDereg
 680 (
 681 Pst*                pst,
 682 CmLteCellId         cellId,
 683 CmLteRnti           crnti
 684 )
 685 #else
 686 PUBLIC S16 RgSchMacSpsLcDereg(pst, cellId, crnti)
 687 Pst*                pst;
 688 CmLteCellId         cellId;
 689 CmLteRnti           crnti;
 690 #endif
 691 {
 692
 693    TRC3(RgSchMacSpsLcDereg);
 694
 695    RETVALUE((*RgSchMacSpsLcDeregReqMt[0])(pst, cellId, crnti));
 696 } /* end of RgSchMacSpsLcDereg */
 697
 698 #endif /* LTEMAC_SPS */
 699 #ifdef LTE_L2_MEAS
 700 /**
 701 * @brief Request from SCH to MAC for L2 Measurement
 702 *
 703 * @details
 704 *
 705 *     Function : RgSchMacL2Meas
 706 *
 707 *  @param[in]   Pst*           pst
 708 *  @param[in]   RgInfL2MeasReq *measInfo
 709 *  @return   S16
 710 *      -# ROK
 711 **/
 712 #ifdef ANSI
 713 PUBLIC S16 RgSchMacL2Meas
 714 (
 715 Pst*                pst,
 716 RgInfL2MeasReq      *measInfo
 717 )
 718 #else
 719 PUBLIC S16 RgSchMacL2Meas(pst, measInfo)
 720 Pst*                pst;
 721 RgInfL2MeasReq      *measInfo;
 722 #endif
 723 {
 724
 725    TRC3(RgSchMacL2Meas);
 726
 727    RETVALUE((*RgSchMacL2MeasReqMt[0])(pst, measInfo));
 728 } /* end of RgSchMacL2Meas */
 729
 730 /**
 731 * @brief Request from SCH to MAC for Stopping L2 Measurement
 732 *
 733 * @details
 734 *
 735 *     Function : RgSchMacL2MeasStop
 736 *
 737 *  @param[in]   Pst*           pst
 738 *  @param[in]   RgInfL2MeasReq *measInfo
 739 *  @return   S16
 740 *      -# ROK
 741 **/
 742 #ifdef ANSI
 743 PUBLIC S16 RgSchMacL2MeasStop
 744 (
 745 Pst*                pst,
 746 RgInfL2MeasStopReq *measInfo
 747 )
 748 #else
 749 PUBLIC S16 RgSchMacL2MeasStop(pst, measInfo)
 750 Pst*                pst;
 751 RgInfL2MeasStopReq *measInfo;
 752 #endif
 753 {
 754
 755    TRC3(RgSchMacL2MeasStop);
 756
 757    RETVALUE((*RgSchMacL2MeasStopReqMt[0])(pst, measInfo));
 758 } /* end of RgSchMacL2Meas */
 759
 760 /**
 761 * @brief Request from SCH to MAC for Sending L2 Measurement
 762 *
 763 * @details
 764 *
 765 *     Function : RgSchMacL2MeasSend
 766 *
 767 *  @param[in]   Pst*           pst
 768 *  @param[in]   RgInfL2MeasReq *measInfo
 769 *  @return   S16
 770 *      -# ROK
 771 **/
 772 #ifdef ANSI
 773 PUBLIC S16 RgSchMacL2MeasSend
 774 (
 775 Pst*                pst,
 776 RgInfL2MeasSndReq *measInfo
 777 )
 778 #else
 779 PUBLIC S16 RgSchMacL2MeasSend(pst, measInfo)
 780 Pst*                pst;
 781 RgInfL2MeasSndReq *measInfo;
 782 #endif
 783 {
 784
 785    TRC3(RgSchMacL2MeasSend);
 786
 787    RETVALUE((*RgSchMacL2MeasSendReqMt[0])(pst, measInfo));
 788 } /* end of RgSchMacL2MeasSend */
 789
 790 /**
 791 * @brief Request from MAC to SCH for L2 Measurement
 792 *
 793 * @details
 794 *
 795 *     Function : RgMacSchL2Meas
 796 *
 797 *  @param[in]   Pst*           pst
 798 *  @param[in]   RgInfL2MeasCfm *measInfo
 799 *  @return   S16
 800 *      -# ROK
 801 **/
 802 #ifdef ANSI
 803 PUBLIC S16 RgMacSchL2Meas
 804 (
 805 Pst*                pst,
 806 RgInfL2MeasCfm      *measInfo
 807 )
 808 #else
 809 PUBLIC S16 RgMacSchL2Meas(pst, measInfo)
 810 Pst*                pst;
 811 RgInfL2MeasCfm      *measInfo;
 812 #endif
 813 {
 814
 815    TRC3(RgMacSchL2Meas);
 816
 817    RETVALUE((*RgMacSchL2MeasCfmMt[0])(pst, measInfo));
 818 } /* end of RgSchMacL2Meas */
 819 /**
 820 * @brief Request from MAC to SCH for L2 Measurement
 821 *
 822 * @details
 823 *
 824 *     Function : RgMacSchL2MeasStop
 825 *
 826 *  @param[in]   Pst*           pst
 827 *  @param[in]   RgInfL2MeasCfm *measInfo
 828 *  @return   S16
 829 *      -# ROK
 830 **/
 831 #ifdef ANSI
 832 PUBLIC S16 RgMacSchL2MeasStop
 833 (
 834 Pst*                pst,
 835 RgInfL2MeasCfm      *measInfo
 836 )
 837 #else
 838 PUBLIC S16 RgMacSchL2MeasStop(pst, measInfo)
 839 Pst*                pst;
 840 RgInfL2MeasCfm      *measInfo;
 841 #endif
 842 {
 843
 844    TRC3(RgMacSchL2MeasStop);
 845
 846    RETVALUE((*RgMacSchL2MeasStopCfmMt[0])(pst, measInfo));
 847 } /* end of RgSchMacL2MeasStop*/
 848 #endif/*LTE_L2_MEAS*/
 849 /**********************************************************************
 850
 851          End of file
 852 **********************************************************************/