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