src/5gnrmac/rg_ptmi.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 portable definitions for Layer Manager
  26                Interface primitives.
  27
  28      File:     rg_ptmi.c
  29
  30 **********************************************************************/
  31
  32 /** @file rg_ptmi.c
  33 @brief This file contains the definitions for Layer Manager
  34        Interface primitives that are invoked from MAC to Layer Manager
  35        (Confirmations and Indications) Portable functions corresponding
  36        to these primitives are also defined.
  37 */
  38
  39 /* header include files (.h) */
  40 #include "common_def.h"
  41 #include "lrg.h"           /* LRG Interface defines */
  42 /* header/extern include files (.x) */
  43 #include "lrg.x"           /* LRG Interface includes */
  44
  45 #ifdef __cplusplus
  46 extern "C" {
  47 #endif /* __cplusplus */
  48
  49 #if !(defined(LCRGMILRG) && defined(SM))
  50 #define PTRGMILRG
  51 #endif
  52
  53 #define RG_MAX_LRG_USR 2
  54
  55 /* portable functions at LRG interface */
  56 #ifdef PTRGMILRG
  57 S16 PtMiLrgCfgCfm ARGS((Pst *pst, RgMngmt *cfm));
  58 S16 PtMiLrgSchCfgCfm ARGS((Pst *pst, RgMngmt *cfm));
  59 S16 PtMiLrgStsCfm ARGS((Pst *pst, RgMngmt *cfm));
  60 S16 PtMiLrgStaCfm ARGS((Pst *pst, RgMngmt *cfm));
  61 S16 PtMiLrgStaInd ARGS((Pst *pst, RgMngmt *usta));
  62 S16 PtMiLrgSchStaInd ARGS((Pst *pst, RgMngmt *usta));
  63 S16 PtMiLrgCntrlCfm ARGS((Pst *pst, RgMngmt *cfm));
  64 S16 PtMiLrgSchCntrlCfm ARGS((Pst *pst, RgMngmt *cfm));
  65 S16 PtMiLrgTrcInd ARGS((Pst *pst, RgMngmt *trc,Buffer *mBuf));
  66 #ifdef LTE_L2_MEAS
  67 S16 PtMiLrgSchL2MeasCfm ARGS((Pst *pst, LrgSchMeasCfmInfo *cfm));
  68 S16 PtMiLrgSchL2MeasStopCfm ARGS((Pst *pst,LrgSchMeasCfmInfo *cfm ));
  69 #endif
  70 #endif
  71
  72 /* ***********LRG interface Mapping matrices ********************/
  73
  74 /** @brief Configuration Confirm primitive Matrix
  75  *  This matrix defines the mapping between the configuration confirm
  76  *  primitive called by the upper interface of MAC layer and the
  77  *  corresponding primitives of the MAC layer service user(s).
  78  *
  79  *  The parameter RG_MAX_LRG_USR defines the maximum number of Layer
  80  *  managers of MAC at the LRG interface. This is an array of functions
  81  *  per primitive invoked by MAC whose size is RG_MAX_LRG_USR.
  82  *
  83  *  The dispatching is performed by the configurable variable: selector.
  84  *  The selector is configured on a per SAP basis. The selectors are:
  85  *
  86  *  LCRGMILRG - loosely coupled LMK interface
  87  *  TCRGMILRG - Tightly coupled LMK interface
  88  *
  89  *  In a similar fashion, the matrices for Status, Statistics and
  90  *  Control confirms and, Status and trace indications are defined.
  91  **/
  92 static const LrgCfgCfm RgMiLrgCfgCfmMt[RG_MAX_LRG_USR] =
  93 {
  94 #ifdef LCRGMILRG
  95    cmPkLrgCfgCfm,                  /* 0 - loosely coupled */
  96 #else
  97    PtMiLrgCfgCfm,                  /* 0 - loosely coupled */
  98 #endif
  99 #ifdef SM
 100    SmMiLrgCfgCfm,                  /* 1 - Tightly coupled SM */
 101 #else
 102    //PtMiLrgCfgCfm,                  /* 1 - Tightly coupled SM  */
 103 #endif
 104 };
 105
 106 /** @brief Scheduler Config Confirm primitive Matrix */
 107 static const LrgSchCfgCfm RgMiLrgSchCfgCfmMt[RG_MAX_LRG_USR] =
 108 {
 109 #ifdef LCRGMILRG
 110    cmPkLrgSchCfgCfm,                  /* 0 - loosely coupled */
 111 #else
 112    PtMiLrgSchCfgCfm,                  /* 0 - loosely coupled */
 113 #endif
 114 #ifdef SM
 115    SmMiLrgSchCfgCfm,                  /* 1 - Tightly coupled SM */
 116 #else
 117    //PtMiLrgSchCfgCfm,                  /* 1 - Tightly coupled SM  */
 118 #endif
 119 };
 120
 121 /** @brief Statistics Confirm primitive Matrix */
 122 static const LrgStsCfm RgMiLrgStsCfmMt[RG_MAX_LRG_USR] =
 123 {
 124 #ifdef LCRGMILRG
 125    cmPkLrgStsCfm,                  /* 0 - loosely coupled */
 126 #else
 127    PtMiLrgStsCfm,                  /* 0 - loosely coupled */
 128 #endif
 129 #ifdef SM
 130    SmMiLrgStsCfm,                  /* 1 - Tightly coupled SM */
 131 #else
 132    PtMiLrgStsCfm,                  /* 1 - Tightly coupled SM  */
 133 #endif
 134 };
 135
 136 /** @brief Status Confirm primitive Matrix */
 137 static const LrgStaCfm RgMiLrgStaCfmMt[RG_MAX_LRG_USR] =
 138 {
 139 #ifdef LCRGMILRG
 140    cmPkLrgStaCfm,                  /* 0 - loosely coupled */
 141 #else
 142    PtMiLrgStaCfm,                  /* 0 - loosely coupled */
 143 #endif
 144 #ifdef SM
 145    SmMiLrgStaCfm,                  /* 1 - Tightly coupled SM */
 146 #else
 147    PtMiLrgStaCfm,                  /* 1 - Tightly coupled SM  */
 148 #endif
 149 };
 150
 151
 152 /** @brief Status Indication primitive Matrix */
 153 static const LrgStaInd RgMiLrgStaIndMt[RG_MAX_LRG_USR] =
 154 {
 155 #ifdef LCRGMILRG
 156    cmPkLrgStaInd,                  /* 0 - loosely coupled */
 157 #else
 158    PtMiLrgStaInd,                  /* 0 - loosely coupled */
 159 #endif
 160 #ifdef SM
 161    SmMiLrgStaInd,                  /* 1 - Tightly coupled SM */
 162 #else
 163    PtMiLrgStaInd,                  /* 1 - Tightly coupled SM  */
 164 #endif
 165 };
 166
 167 /** @brief Scheduler  Status Indication primitive Matrix */
 168 static const LrgSchStaInd RgMiLrgSchStaIndMt[RG_MAX_LRG_USR] =
 169 {
 170 #ifdef LCRGMILRG
 171    cmPkLrgSchStaInd,                  /* 0 - loosely coupled */
 172 #else
 173    PtMiLrgSchStaInd,                  /* 0 - loosely coupled */
 174 #endif
 175 #ifdef SM
 176    SmMiLrgSchStaInd,                  /* 1 - Tightly coupled SM */
 177 #else
 178    PtMiLrgSchStaInd,                  /* 1 - Tightly coupled SM  */
 179 #endif
 180 };
 181
 182
 183 /** @brief Control Confirm primitive Matrix */
 184 static const LrgCntrlCfm RgMiLrgCntrlCfmMt[RG_MAX_LRG_USR] =
 185 {
 186 #ifdef LCRGMILRG
 187    cmPkLrgCntrlCfm,                  /* 0 - loosely coupled */
 188 #else
 189    PtMiLrgCntrlCfm,                  /* 0 - loosely coupled */
 190 #endif
 191 #ifdef SM
 192    SmMiLrgCntrlCfm,                  /* 1 - Tightly coupled SM */
 193 #else
 194    PtMiLrgCntrlCfm,                  /* 1 - Tightly coupled SM  */
 195 #endif
 196 };
 197
 198 /** @brief Scheduler Control Confirm primitive Matrix */
 199 static const LrgSchCntrlCfm RgMiLrgSchCntrlCfmMt[RG_MAX_LRG_USR] =
 200 {
 201 #ifdef LCRGMILRG
 202    cmPkLrgSchCntrlCfm,                  /* 0 - loosely coupled */
 203 #else
 204    PtMiLrgSchCntrlCfm,                  /* 0 - loosely coupled */
 205 #endif
 206 #ifdef SM
 207    SmMiLrgSchCntrlCfm,                  /* 1 - Tightly coupled SM */
 208 #else
 209    PtMiLrgSchCntrlCfm,                  /* 1 - Tightly coupled SM  */
 210 #endif
 211 };
 212
 213 /** @brief Trace Indication primitive Matrix */
 214 static const LrgTrcInd RgMiLrgTrcIndMt[RG_MAX_LRG_USR] =
 215 {
 216 #ifdef LCRGMILRG
 217    cmPkLrgTrcInd,                  /* 0 - loosely coupled */
 218 #else
 219    PtMiLrgTrcInd,                  /* 0 - loosely coupled */
 220 #endif
 221 #ifdef SM
 222    SmMiLrgTrcInd,                  /* 1 - Tightly coupled SM */
 223 #else
 224    PtMiLrgTrcInd,                  /* 1 - Tightly coupled SM  */
 225 #endif
 226 };
 227 #ifdef LTE_L2_MEAS
 228 /** @brief L2 Meas Cfm primitive Matrix */
 229 static const LrgSchL2MeasCfm RgMiLrgSchL2mMeasCfmMt[RG_MAX_LRG_USR] =
 230 {
 231 #ifdef LCRGMILRG
 232    cmPkLrgSchL2MeasCfm,                /* 0 - loosely coupled */
 233 #else
 234    PtMiLrgSchL2MeasCfm,                  /* 0 - loosely coupled */
 235 #endif
 236 #ifdef SM
 237    SmMiLrgSchL2MeasCfm,                  /* 1 - Tightly coupled SM */
 238 #else
 239    PtMiLrgSchL2MeasCfm,                  /* 1 - loosely coupled */
 240 #endif
 241 };
 242 /** @brief L2 Meas Stop Cfm primitive Matrix */
 243 static const LrgSchL2MeasStopCfm RgMiLrgSchL2mMeasStopCfmMt[RG_MAX_LRG_USR] =
 244 {
 245 #ifdef LCRGMILRG
 246    cmPkLrgSchL2MeasStopCfm,                /* 0 - loosely coupled */
 247 #else
 248    PtMiLrgSchL2MeasStopCfm,                  /* 0 - loosely coupled */
 249 #endif
 250 #ifdef SM
 251    SmMiLrgSchL2MeasStopCfm,                  /* 1 - Tightly coupled SM */
 252 #else
 253    PtMiLrgSchL2MeasStopCfm,                  /* 1 - loosely coupled */
 254 #endif
 255 };
 256 #endif /* LTE_L2_MEAS */
 257
 258 #ifdef __cplusplus
 259 }
 260 #endif /* __cplusplus */
 261
 262 #ifdef RG
 263
 264 \f
 265 /**
 266  * @brief Layer Manager Configuration confirm handler.
 267  *
 268  * @details
 269  *
 270  *     Function : RgMiLrgCfgCfm
 271  *
 272  *     This function handles the configuration
 273  *     confirm invoked by MAC to Layer Manager.
 274  *     -# Based on the pst->selector value it invokes one of the
 275  *        functions cmPkLrgCfgCfm() or SmMiLrgCfgCfm().
 276  *
 277  *  @param[in]  Pst *pst, the post structure
 278  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 279  *  @return  S16
 280  *      -# ROK
 281  **/
 282 S16 RgMiLrgCfgCfm
 283 (
 284 Pst      *pst,    /* post structure  */
 285 RgMngmt  *cfm     /* config confirm structure  */
 286 )
 287 {
 288
 289    (*RgMiLrgCfgCfmMt[pst->selector])(pst, cfm);
 290
 291    return ROK;
 292
 293 }/*-- RgMiLrgCfgCfm --*/
 294
 295 /**
 296  * @brief Layer Manager scheduler Configuration confirm handler.
 297  *
 298  * @details
 299  *
 300  *     Function : RgMiLrgSchCfgCfm
 301  *
 302  *     This function handles the configuration
 303  *     confirm invoked by Scheduler to Layer Manager.
 304  *     -# Based on the pst->selector value it invokes one of the
 305  *        functions cmPkLrgSchCfgCfm() or SmMiLrgSchCfgCfm().
 306  *
 307  *  @param[in]  Pst *pst, the post structure
 308  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 309  *  @return  S16
 310  *      -# ROK
 311  **/
 312 S16 RgMiLrgSchCfgCfm
 313 (
 314 Pst      *pst,    /* post structure  */
 315 RgMngmt  *cfm     /* config confirm structure  */
 316 )
 317 {
 318
 319    (*RgMiLrgSchCfgCfmMt[pst->selector])(pst, cfm);
 320
 321    return ROK;
 322
 323 }/*-- RgMiLrgSchCfgCfm --*/
 324
 325
 326 \f
 327 /**
 328  * @brief Layer Manager Statistics confirm handler.
 329  *
 330  * @details
 331  *
 332  *     Function : RgMiLrgStsCfm
 333  *
 334  *     This function handles the statistics
 335  *     confirm invoked by MAC to Layer Manager.
 336  *     -# Based on the pst->selector value it invokes one of the
 337  *        functions cmPkLrgStsCfm() or SmMiLrgStsCfm().
 338  *
 339  *  @param[in]  Pst *pst, the post structure
 340  *  @param[in]  RgMngmt *cfm, the statistics confirm structure
 341  *  @return  S16
 342  *      -# ROK
 343  **/
 344 S16 RgMiLrgStsCfm
 345 (
 346 Pst      *pst,    /* post structure  */
 347 RgMngmt  *cfm     /* statistics confirm structure  */
 348 )
 349 {
 350
 351    (*RgMiLrgStsCfmMt[pst->selector])(pst, cfm);
 352
 353    return ROK;
 354
 355 }/*-- RgMiLrgStsCfm --*/
 356
 357 \f
 358 /**
 359  * @brief Layer Manager Status confirm handler.
 360  *
 361  * @details
 362  *
 363  *     Function : RgMiLrgStaCfm
 364  *
 365  *     This function handles the status
 366  *     confirm invoked by MAC to Layer Manager.
 367  *     -# Based on the pst->selector value it invokes one of the
 368  *        functions cmPkLrgStaCfm() or SmMiLrgStaCfm().
 369  *
 370  *  @param[in]  Pst *pst, the post structure
 371  *  @param[in]  RgMngmt *cfm, the status confirm structure
 372  *  @return  S16
 373  *      -# ROK
 374  **/
 375 S16 RgMiLrgStaCfm
 376 (
 377 Pst      *pst,    /* post structure  */
 378 RgMngmt  *cfm     /* status confirm structure  */
 379 )
 380 {
 381
 382    (*RgMiLrgStaCfmMt[pst->selector])(pst,cfm);
 383
 384    return ROK;
 385
 386 }/*-- RgMiLrgStaCfm --*/
 387
 388 \f
 389 /**
 390  * @brief Layer Manager Control confirm handler.
 391  *
 392  * @details
 393  *
 394  *     Function : RgMiLrgCntrlCfm
 395  *
 396  *     This function handles the control
 397  *     confirm invoked by MAC to Layer Manager.
 398  *     -# Based on the pst->selector value it invokes one of the
 399  *        functions cmPkLrgCntrlCfm() or SmMiLrgCntrlCfm().
 400  *
 401  *  @param[in]  Pst *pst, the post structure
 402  *  @param[in]  RgMngmt *cfm, the control confirm structure
 403  *  @return  S16
 404  *      -# ROK
 405  **/
 406 S16 RgMiLrgCntrlCfm
 407 (
 408 Pst      *pst,    /* post structure  */
 409 RgMngmt  *cfm     /* control confirm structure  */
 410 )
 411 {
 412
 413    (*RgMiLrgCntrlCfmMt[pst->selector])(pst,cfm);
 414
 415    return ROK;
 416
 417 }/*-- RgMiLrgCntrlCfm --*/
 418
 419 /**
 420  * @brief Layer Manager scheduler Control confirm handler.
 421  *
 422  * @details
 423  *
 424  *     Function : RgMiLrgSchCntrlCfm
 425  *
 426  *     This function handles the control
 427  *     confirm invoked by scheduler to Layer Manager.
 428  *     -# Based on the pst->selector value it invokes one of the
 429  *        functions cmPkLrgSchCntrlCfm() or SmMiLrgSchCntrlCfm().
 430  *
 431  *  @param[in]  Pst *pst, the post structure
 432  *  @param[in]  RgMngmt *cfm, the control confirm structure
 433  *  @return  S16
 434  *      -# ROK
 435  **/
 436 S16 RgMiLrgSchCntrlCfm
 437 (
 438 Pst      *pst,    /* post structure  */
 439 RgMngmt  *cfm     /* control confirm structure  */
 440 )
 441 {
 442
 443    (*RgMiLrgSchCntrlCfmMt[pst->selector])(pst,cfm);
 444
 445    return ROK;
 446
 447 }/*-- RgMiLrgSchCntrlCfm --*/
 448
 449 \f
 450 /**
 451  * @brief Layer Manager Unsolicited Status Indication handler.
 452  *
 453  * @details
 454  *
 455  *     Function : RgMiLrgStaInd
 456  *
 457  *     This function handles the unsolicited status
 458  *     Indication invoked by MAC to Layer Manager.
 459  *     -# Based on the pst->selector value it invokes one of the
 460  *        functions cmPkLrgStaInd() or SmMiLrgStaInd().
 461  *
 462  *  @param[in]  Pst *pst, the post structure
 463  *  @param[in]  RgMngmt *usta, the status indication structure
 464  *  @return  S16
 465  *      -# ROK
 466  **/
 467 S16 RgMiLrgStaInd
 468 (
 469 Pst      *pst,    /* post structure  */
 470 RgMngmt  *usta    /* status indication structure  */
 471 )
 472 {
 473
 474    (*RgMiLrgStaIndMt[pst->selector])(pst,usta);
 475
 476    return ROK;
 477
 478 }/*-- RgMiLrgStaInd --*/
 479
 480 /**
 481  * @brief Layer Manager Unsolicited Status Indication handler from scheduler
 482  *
 483  * @details
 484  *
 485  *     Function : RgMiLrgSchStaInd
 486  *
 487  *     This function handles the unsolicited status
 488  *     Indication invoked by Scheduler to Layer Manager.
 489  *     -# Based on the pst->selector value it invokes one of the
 490  *        functions cmPkLrgSchStaInd() or SmMiLrgSchStaInd().
 491  *
 492  *  @param[in]  Pst *pst, the post structure
 493  *  @param[in]  RgMngmt *usta, the status indication structure
 494  *  @return  S16
 495  *      -# ROK
 496  **/
 497 S16 RgMiLrgSchStaInd
 498 (
 499 Pst      *pst,    /* post structure  */
 500 RgMngmt  *usta    /* status indication structure  */
 501 )
 502 {
 503
 504    (*RgMiLrgSchStaIndMt[pst->selector])(pst,usta);
 505
 506    return ROK;
 507
 508 }/*-- RgMiLrgSchStaInd --*/
 509
 510 \f
 511 /**
 512  * @brief Layer Manager Trace Indication handler.
 513  *
 514  * @details
 515  *
 516  *     Function : RgMiLrgTrcInd
 517  *
 518  *     This function handles the trace
 519  *     Indication invoked by MAC to Layer Manager.
 520  *     -# Based on the pst->selector value it invokes one of the
 521  *        functions cmPkLrgTrcInd() or SmMiLrgTrcInd().
 522  *
 523  *  @param[in]  Pst *pst, the post structure
 524  *  @param[in]  RgMngmt *trc, the trace event
 525  *  @param[in]  Buffer *mBuf, the trace message
 526  *  @return  S16
 527  *      -# ROK
 528  **/
 529 S16 RgMiLrgTrcInd
 530 (
 531 Pst      *pst,    /* post structure  */
 532 RgMngmt  *trc,    /* Trace event  */
 533 Buffer   *mBuf    /* Trace message  */
 534 )
 535 {
 536
 537    (*RgMiLrgTrcIndMt[pst->selector])(pst,trc,mBuf);
 538
 539    return ROK;
 540
 541 }/*-- RgMiLrgTrcInd --*/
 542
 543 #ifdef LTE_L2_MEAS
 544
 545 /* TODO: Function header */
 546 S16 RgMiLrgSchL2MeasCfm
 547 (
 548 Pst               *pst,          /* post structure  */
 549 LrgSchMeasCfmInfo *cfm       /* Meas Cfm Info */
 550 )
 551 {
 552
 553    (*RgMiLrgSchL2mMeasCfmMt[pst->selector])(pst,cfm);
 554
 555    return ROK;
 556
 557 } /* RgMiLrgSchL2MeasCfm */
 558
 559 /**
 560  * @brief This function used to send L2 measurement stop confirmation
 561  *        to Layer manager.
 562  *
 563  *
 564  * @details
 565  *
 566  *     Function : RgMiLrgSchL2MeasStopCfm
 567  *     This function sends reposnes to L2 Measurement stop request
 568  *
 569  *
 570  *  @param[in]  Pst *pst, the post structure
 571  *  @param[in]  LrgSchMeasCfmInfo *cfm, theconfirm structure
 572  *  @return  S16
 573  *      -# ROK
 574  **/
 575
 576 S16 RgMiLrgSchL2MeasStopCfm
 577 (
 578 Pst               *pst,          /* post structure  */
 579 LrgSchMeasCfmInfo *cfm       /* Meas Cfm Info */
 580 )
 581 {
 582    (*RgMiLrgSchL2mMeasStopCfmMt[pst->selector])(pst,cfm);
 583
 584    return ROK;
 585
 586 } /* RgMiLrgSchL2MeasStopCfm */
 587
 588 #endif /* LTE_L2_MEAS */
 589
 590 #endif /*-- MK --*/
 591
 592 #ifdef PTRGMILRG
 593 \f
 594 /**
 595  * @brief Portable Function definition for Layer Manager Configuration
 596  *         confirm handler.
 597  *
 598  * @details
 599  *
 600  *     Function : PtMiLrgCfgCfm
 601  *
 602  *     This function handles the configuration
 603  *     confirm invoked by MAC to Layer Manager.
 604  *     Users of MAC who intend to provide a glue logic
 605  *     for portability of Configuration Confirm are expected
 606  *     to fill in the code in this function definition.
 607  *
 608  *  @param[in]  Pst *pst, the post structure
 609  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 610  *  @return  S16
 611  *      -# ROK
 612  **/
 613 S16 PtMiLrgCfgCfm
 614 (
 615 Pst *pst,               /* post structure */
 616 RgMngmt *cfm            /* Config Confirm */
 617 )
 618 {
 619    return ROK;
 620 }/* end of PtMiLrgCfgCfm */
 621
 622 /**
 623  * @brief Portable Function definition for Layer Manager Configuration
 624  *         confirm handler.
 625  *
 626  * @details
 627  *
 628  *     Function : PtMiLrgSchCfgCfm
 629  *
 630  *     This function handles the configuration
 631  *     confirm invoked by scheduler to Layer Manager.
 632  *     Users of MAC who intend to provide a glue logic
 633  *     for portability of Configuration Confirm are expected
 634  *     to fill in the code in this function definition.
 635  *
 636  *  @param[in]  Pst *pst, the post structure
 637  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 638  *  @return  S16
 639  *      -# ROK
 640  **/
 641 S16 PtMiLrgSchCfgCfm
 642 (
 643 Pst *pst,               /* post structure */
 644 RgMngmt *cfm            /* Config Confirm */
 645 )
 646 {
 647
 648    return ROK;
 649 }/* end of PtMiLrgSchCfgCfm */
 650
 651
 652 \f
 653 /**
 654  * @brief Portable Function definition for Layer Manager Statistics
 655  *         confirm handler.
 656  *
 657  * @details
 658  *
 659  *     Function : PtMiLrgStsCfm
 660  *
 661  *     This function handles the statistics
 662  *     confirm invoked by MAC to Layer Manager.
 663  *     Users of MAC who intend to provide a glue logic
 664  *     for portability of statistics Confirm are expected
 665  *     to fill in the code in this function definition.
 666  *
 667  *  @param[in]  Pst *pst, the post structure
 668  *  @param[in]  RgMngmt *cfm, the statistics confirm structure
 669  *  @return  S16
 670  *      -# ROK
 671  **/
 672 S16 PtMiLrgStsCfm
 673 (
 674 Pst *pst,               /* post structure */
 675 RgMngmt *cfm            /* Statistics Confirm */
 676 )
 677 {
 678
 679    return ROK;
 680 }/* end of PtMiLrgStsCfm */
 681
 682
 683 \f
 684 /**
 685  * @brief Portable Function definition for Layer Manager Status
 686  *         confirm handler.
 687  *
 688  * @details
 689  *
 690  *     Function : PtMiLrgStaCfm
 691  *
 692  *     This function handles the status
 693  *     confirm invoked by MAC to Layer Manager.
 694  *     Users of MAC who intend to provide a glue logic
 695  *     for portability of status Confirm are expected
 696  *     to fill in the code in this function definition.
 697  *
 698  *  @param[in]  Pst *pst, the post structure
 699  *  @param[in]  RgMngmt *cfm, the status confirm structure
 700  *  @return  S16
 701  *      -# ROK
 702  **/
 703 S16 PtMiLrgStaCfm
 704 (
 705 Pst *pst,               /* post structure */
 706 RgMngmt *cfm            /* Status Confirm */
 707 )
 708 {
 709    return ROK;
 710 }/* end of PtMiLrgStaCfm */
 711
 712
 713 \f
 714 /**
 715  * @brief Portable Function definition for Layer Manager Status
 716  *        Indication handler.
 717  *
 718  * @details
 719  *
 720  *     Function : PtMiLrgStaInd
 721  *
 722  *     This function handles the status
 723  *     indication invoked by MAC to Layer Manager.
 724  *     Users of MAC who intend to provide a glue logic
 725  *     for portability of status indication are expected
 726  *     to fill in the code in this function definition.
 727  *
 728  *  @param[in]  Pst *pst, the post structure
 729  *  @param[in]  RgMngmt *cfm, the status indication structure
 730  *  @return  S16
 731  *      -# ROK
 732  **/
 733 S16 PtMiLrgStaInd
 734 (
 735 Pst *pst,               /* post structure */
 736 RgMngmt *usta           /* Status Indication */
 737 )
 738 {
 739    return ROK;
 740 }/* end of PtMiLrgStaInd */
 741
 742 /**
 743  * @brief Portable Function definition for Layer Manager Status
 744  *        Indication handler.
 745  *
 746  * @details
 747  *
 748  *     Function : PtMiLrgSchStaInd
 749  *
 750  *     This function handles the status
 751  *     indication invoked by Scheduler to Layer Manager.
 752  *     Users of MAC who intend to provide a glue logic
 753  *     for portability of status indication are expected
 754  *     to fill in the code in this function definition.
 755  *
 756  *  @param[in]  Pst *pst, the post structure
 757  *  @param[in]  RgMngmt *cfm, the status indication structure
 758  *  @return  S16
 759  *      -# ROK
 760  **/
 761 S16 PtMiLrgSchStaInd
 762 (
 763 Pst *pst,               /* post structure */
 764 RgMngmt *usta           /* Status Indication */
 765 )
 766 {
 767    return ROK;
 768 }/* end of PtMiLrgSchStaInd */
 769
 770 \f
 771 /**
 772  * @brief Portable Function definition for Layer Manager Control
 773  *         confirm handler.
 774  *
 775  * @details
 776  *
 777  *     Function : PtMiLrgCntrlCfm
 778  *
 779  *     This function handles the control
 780  *     confirm invoked by MAC to Layer Manager.
 781  *     Users of MAC who intend to provide a glue logic
 782  *     for portability of control Confirm are expected
 783  *     to fill in the code in this function definition.
 784  *
 785  *  @param[in]  Pst *pst, the post structure
 786  *  @param[in]  RgMngmt *cfm, the control confirm structure
 787  *  @return  S16
 788  *      -# ROK
 789  **/
 790 S16 PtMiLrgCntrlCfm
 791 (
 792 Pst *pst,               /* post structure */
 793 RgMngmt *cfm            /* Control Confirm */
 794 )
 795 {
 796    return ROK;
 797 }/* end of PtMiLrgCntrlCfm */
 798
 799 /**
 800  * @brief Portable Function definition for Layer Manager Control
 801  *         confirm handler.
 802  *
 803  * @details
 804  *
 805  *     Function : PtMiLrgSchCntrlCfm
 806  *
 807  *     This function handles the control
 808  *     confirm invoked by scheduler to Layer Manager.
 809  *     Users of MAC who intend to provide a glue logic
 810  *     for portability of control Confirm are expected
 811  *     to fill in the code in this function definition.
 812  *
 813  *  @param[in]  Pst *pst, the post structure
 814  *  @param[in]  RgMngmt *cfm, the control confirm structure
 815  *  @return  S16
 816  *      -# ROK
 817  **/
 818 S16 PtMiLrgSchCntrlCfm
 819 (
 820 Pst *pst,               /* post structure */
 821 RgMngmt *cfm            /* Control Confirm */
 822 )
 823 {
 824    return ROK;
 825 }/* end of PtMiLrgSchCntrlCfm */
 826
 827 \f
 828 /**
 829  * @brief Portable Function definition for Layer Manager Trace
 830  *        Indication handler.
 831  *
 832  * @details
 833  *
 834  *     Function : PtMiLrgTrcInd
 835  *
 836  *     This function handles the trace
 837  *     indication invoked by MAC to Layer Manager.
 838  *     Users of MAC who intend to provide a glue logic
 839  *     for portability of trace indication are expected
 840  *     to fill in the code in this function definition.
 841  *
 842  *  @param[in]  Pst *pst, the post structure
 843  *  @param[in]  RgMngmt *cfm, the trace indication structure
 844  *  @return  S16
 845  *      -# ROK
 846  **/
 847 S16 PtMiLrgTrcInd
 848 (
 849 Pst *pst,               /* post structure */
 850 RgMngmt *trc,           /* Trace Event */
 851 Buffer *mBuf            /* Trace message */
 852 )
 853 {
 854    return ROK;
 855 }/* end of PtMiLrgTrcInd */
 856 #ifdef LTE_L2_MEAS
 857 /**
 858  * @brief Portable Function definition for L2 Measurement Configuration
 859  *         confirm handler.
 860  *
 861  * @details
 862  *
 863  *     Function : PtMiLrgSchL2MeasCfm
 864  *
 865  *
 866  *  @param[in]  Pst *pst, the post structure
 867  *  @param[in]  *cfm, the measurement confirm structure
 868  *  @return  S16
 869  *      -# ROK
 870  **/
 871 S16 PtMiLrgSchL2MeasCfm
 872 (
 873 Pst *pst,               /* post structure */
 874 LrgSchMeasCfmInfo *cfm  /* Measurement Confirm */
 875 )
 876 {
 877
 878    return ROK;
 879 }/* end of PtMiLrgSchL2MeasCfm */
 880
 881 /**
 882  * @brief Portable Function definition for L2 Measurement stop
 883  *         confirm handler.
 884  *
 885  * @details
 886  *
 887  *     Function : PtMiLrgSchL2MeasStopCfm
 888  *
 889  *
 890  *  @param[in]  Pst *pst, the post structure
 891  *  @param[in]  *cfm, the measurement confirm structure
 892  *  @return  S16
 893  *      -# ROK
 894  **/
 895 S16 PtMiLrgSchL2MeasStopCfm
 896 (
 897 Pst *pst,               /* post structure */
 898 LrgSchMeasCfmInfo *cfm  /* Measurement Confirm */
 899 )
 900 {
 901
 902    return ROK;
 903 }/* end of PtMiLrgSchL2MeasStopCfm */
 904 #endif
 905 #endif /*--PTRGMILRG--*/
 906
 907 \f
 908 /**********************************************************************
 909
 910          End of file
 911 **********************************************************************/