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 EXTERN S16 PtMiLrgCfgCfm ARGS((Pst *pst, RgMngmt *cfm));
  58 EXTERN S16 PtMiLrgSchCfgCfm ARGS((Pst *pst, RgMngmt *cfm));
  59 EXTERN S16 PtMiLrgStsCfm ARGS((Pst *pst, RgMngmt *cfm));
  60 EXTERN S16 PtMiLrgStaCfm ARGS((Pst *pst, RgMngmt *cfm));
  61 EXTERN S16 PtMiLrgStaInd ARGS((Pst *pst, RgMngmt *usta));
  62 EXTERN S16 PtMiLrgSchStaInd ARGS((Pst *pst, RgMngmt *usta));
  63 EXTERN S16 PtMiLrgCntrlCfm ARGS((Pst *pst, RgMngmt *cfm));
  64 EXTERN S16 PtMiLrgSchCntrlCfm ARGS((Pst *pst, RgMngmt *cfm));
  65 EXTERN S16 PtMiLrgTrcInd ARGS((Pst *pst, RgMngmt *trc,Buffer *mBuf));
  66 #ifdef LTE_L2_MEAS
  67 EXTERN S16 PtMiLrgSchL2MeasCfm ARGS((Pst *pst, LrgSchMeasCfmInfo *cfm));
  68 EXTERN 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 PRIVATE CONSTANT 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 #ifdef ANSI
 283 S16 RgMiLrgCfgCfm
 284 (
 285 Pst      *pst,    /* post structure  */
 286 RgMngmt  *cfm     /* config confirm structure  */
 287 )
 288 #else
 289 S16 RgMiLrgCfgCfm(pst, cfm)
 290 Pst      *pst;    /* post structure  */
 291 RgMngmt  *cfm;    /* config confirm structure  */
 292 #endif
 293 {
 294
 295    (*RgMiLrgCfgCfmMt[pst->selector])(pst, cfm);
 296
 297    return ROK;
 298
 299 }/*-- RgMiLrgCfgCfm --*/
 300
 301 /**
 302  * @brief Layer Manager scheduler Configuration confirm handler.
 303  *
 304  * @details
 305  *
 306  *     Function : RgMiLrgSchCfgCfm
 307  *
 308  *     This function handles the configuration
 309  *     confirm invoked by Scheduler to Layer Manager.
 310  *     -# Based on the pst->selector value it invokes one of the
 311  *        functions cmPkLrgSchCfgCfm() or SmMiLrgSchCfgCfm().
 312  *
 313  *  @param[in]  Pst *pst, the post structure
 314  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 315  *  @return  S16
 316  *      -# ROK
 317  **/
 318 #ifdef ANSI
 319 S16 RgMiLrgSchCfgCfm
 320 (
 321 Pst      *pst,    /* post structure  */
 322 RgMngmt  *cfm     /* config confirm structure  */
 323 )
 324 #else
 325 S16 RgMiLrgSchCfgCfm(pst, cfm)
 326 Pst      *pst;    /* post structure  */
 327 RgMngmt  *cfm;    /* config confirm structure  */
 328 #endif
 329 {
 330
 331    (*RgMiLrgSchCfgCfmMt[pst->selector])(pst, cfm);
 332
 333    return ROK;
 334
 335 }/*-- RgMiLrgSchCfgCfm --*/
 336
 337
 338 \f
 339 /**
 340  * @brief Layer Manager Statistics confirm handler.
 341  *
 342  * @details
 343  *
 344  *     Function : RgMiLrgStsCfm
 345  *
 346  *     This function handles the statistics
 347  *     confirm invoked by MAC to Layer Manager.
 348  *     -# Based on the pst->selector value it invokes one of the
 349  *        functions cmPkLrgStsCfm() or SmMiLrgStsCfm().
 350  *
 351  *  @param[in]  Pst *pst, the post structure
 352  *  @param[in]  RgMngmt *cfm, the statistics confirm structure
 353  *  @return  S16
 354  *      -# ROK
 355  **/
 356 #ifdef ANSI
 357 S16 RgMiLrgStsCfm
 358 (
 359 Pst      *pst,    /* post structure  */
 360 RgMngmt  *cfm     /* statistics confirm structure  */
 361 )
 362 #else
 363 S16 RgMiLrgStsCfm(pst, cfm)
 364 Pst      *pst;    /* post structure  */
 365 RgMngmt  *cfm;    /* statistics confirm structure  */
 366 #endif
 367 {
 368
 369    (*RgMiLrgStsCfmMt[pst->selector])(pst, cfm);
 370
 371    return ROK;
 372
 373 }/*-- RgMiLrgStsCfm --*/
 374
 375 \f
 376 /**
 377  * @brief Layer Manager Status confirm handler.
 378  *
 379  * @details
 380  *
 381  *     Function : RgMiLrgStaCfm
 382  *
 383  *     This function handles the status
 384  *     confirm invoked by MAC to Layer Manager.
 385  *     -# Based on the pst->selector value it invokes one of the
 386  *        functions cmPkLrgStaCfm() or SmMiLrgStaCfm().
 387  *
 388  *  @param[in]  Pst *pst, the post structure
 389  *  @param[in]  RgMngmt *cfm, the status confirm structure
 390  *  @return  S16
 391  *      -# ROK
 392  **/
 393 #ifdef ANSI
 394 S16 RgMiLrgStaCfm
 395 (
 396 Pst      *pst,    /* post structure  */
 397 RgMngmt  *cfm     /* status confirm structure  */
 398 )
 399 #else
 400 S16 RgMiLrgStaCfm(pst, cfm)
 401 Pst      *pst;    /* post structure  */
 402 RgMngmt  *cfm;    /* status confirm structure  */
 403 #endif
 404 {
 405
 406    (*RgMiLrgStaCfmMt[pst->selector])(pst,cfm);
 407
 408    return ROK;
 409
 410 }/*-- RgMiLrgStaCfm --*/
 411
 412 \f
 413 /**
 414  * @brief Layer Manager Control confirm handler.
 415  *
 416  * @details
 417  *
 418  *     Function : RgMiLrgCntrlCfm
 419  *
 420  *     This function handles the control
 421  *     confirm invoked by MAC to Layer Manager.
 422  *     -# Based on the pst->selector value it invokes one of the
 423  *        functions cmPkLrgCntrlCfm() or SmMiLrgCntrlCfm().
 424  *
 425  *  @param[in]  Pst *pst, the post structure
 426  *  @param[in]  RgMngmt *cfm, the control confirm structure
 427  *  @return  S16
 428  *      -# ROK
 429  **/
 430 #ifdef ANSI
 431 S16 RgMiLrgCntrlCfm
 432 (
 433 Pst      *pst,    /* post structure  */
 434 RgMngmt  *cfm     /* control confirm structure  */
 435 )
 436 #else
 437 S16 RgMiLrgCntrlCfm(pst, cfm)
 438 Pst      *pst;    /* post structure  */
 439 RgMngmt  *cfm;    /* control confirm structure  */
 440 #endif
 441 {
 442
 443    (*RgMiLrgCntrlCfmMt[pst->selector])(pst,cfm);
 444
 445    return ROK;
 446
 447 }/*-- RgMiLrgCntrlCfm --*/
 448
 449 /**
 450  * @brief Layer Manager scheduler Control confirm handler.
 451  *
 452  * @details
 453  *
 454  *     Function : RgMiLrgSchCntrlCfm
 455  *
 456  *     This function handles the control
 457  *     confirm invoked by scheduler to Layer Manager.
 458  *     -# Based on the pst->selector value it invokes one of the
 459  *        functions cmPkLrgSchCntrlCfm() or SmMiLrgSchCntrlCfm().
 460  *
 461  *  @param[in]  Pst *pst, the post structure
 462  *  @param[in]  RgMngmt *cfm, the control confirm structure
 463  *  @return  S16
 464  *      -# ROK
 465  **/
 466 #ifdef ANSI
 467 S16 RgMiLrgSchCntrlCfm
 468 (
 469 Pst      *pst,    /* post structure  */
 470 RgMngmt  *cfm     /* control confirm structure  */
 471 )
 472 #else
 473 S16 RgMiLrgSchCntrlCfm(pst, cfm)
 474 Pst      *pst;    /* post structure  */
 475 RgMngmt  *cfm;    /* control confirm structure  */
 476 #endif
 477 {
 478
 479    (*RgMiLrgSchCntrlCfmMt[pst->selector])(pst,cfm);
 480
 481    return ROK;
 482
 483 }/*-- RgMiLrgSchCntrlCfm --*/
 484
 485 \f
 486 /**
 487  * @brief Layer Manager Unsolicited Status Indication handler.
 488  *
 489  * @details
 490  *
 491  *     Function : RgMiLrgStaInd
 492  *
 493  *     This function handles the unsolicited status
 494  *     Indication invoked by MAC to Layer Manager.
 495  *     -# Based on the pst->selector value it invokes one of the
 496  *        functions cmPkLrgStaInd() or SmMiLrgStaInd().
 497  *
 498  *  @param[in]  Pst *pst, the post structure
 499  *  @param[in]  RgMngmt *usta, the status indication structure
 500  *  @return  S16
 501  *      -# ROK
 502  **/
 503 #ifdef ANSI
 504 S16 RgMiLrgStaInd
 505 (
 506 Pst      *pst,    /* post structure  */
 507 RgMngmt  *usta    /* status indication structure  */
 508 )
 509 #else
 510 S16 RgMiLrgStaInd(pst, usta)
 511 Pst      *pst;    /* post structure  */
 512 RgMngmt  *usta;    /* status indication structure  */
 513 #endif
 514 {
 515
 516    (*RgMiLrgStaIndMt[pst->selector])(pst,usta);
 517
 518    return ROK;
 519
 520 }/*-- RgMiLrgStaInd --*/
 521
 522 /**
 523  * @brief Layer Manager Unsolicited Status Indication handler from scheduler
 524  *
 525  * @details
 526  *
 527  *     Function : RgMiLrgSchStaInd
 528  *
 529  *     This function handles the unsolicited status
 530  *     Indication invoked by Scheduler to Layer Manager.
 531  *     -# Based on the pst->selector value it invokes one of the
 532  *        functions cmPkLrgSchStaInd() or SmMiLrgSchStaInd().
 533  *
 534  *  @param[in]  Pst *pst, the post structure
 535  *  @param[in]  RgMngmt *usta, the status indication structure
 536  *  @return  S16
 537  *      -# ROK
 538  **/
 539 #ifdef ANSI
 540 S16 RgMiLrgSchStaInd
 541 (
 542 Pst      *pst,    /* post structure  */
 543 RgMngmt  *usta    /* status indication structure  */
 544 )
 545 #else
 546 S16 RgMiLrgSchStaInd(pst, usta)
 547 Pst      *pst;    /* post structure  */
 548 RgMngmt  *usta;    /* status indication structure  */
 549 #endif
 550 {
 551
 552    (*RgMiLrgSchStaIndMt[pst->selector])(pst,usta);
 553
 554    return ROK;
 555
 556 }/*-- RgMiLrgSchStaInd --*/
 557
 558 \f
 559 /**
 560  * @brief Layer Manager Trace Indication handler.
 561  *
 562  * @details
 563  *
 564  *     Function : RgMiLrgTrcInd
 565  *
 566  *     This function handles the trace
 567  *     Indication invoked by MAC to Layer Manager.
 568  *     -# Based on the pst->selector value it invokes one of the
 569  *        functions cmPkLrgTrcInd() or SmMiLrgTrcInd().
 570  *
 571  *  @param[in]  Pst *pst, the post structure
 572  *  @param[in]  RgMngmt *trc, the trace event
 573  *  @param[in]  Buffer *mBuf, the trace message
 574  *  @return  S16
 575  *      -# ROK
 576  **/
 577 #ifdef ANSI
 578 S16 RgMiLrgTrcInd
 579 (
 580 Pst      *pst,    /* post structure  */
 581 RgMngmt  *trc,    /* Trace event  */
 582 Buffer   *mBuf    /* Trace message  */
 583 )
 584 #else
 585 S16 RgMiLrgTrcInd(pst, trc, mBuf)
 586 Pst      *pst;    /* post structure  */
 587 RgMngmt  *trc;    /* Trace event  */
 588 Buffer   *mBuf;   /* Trace message  */
 589 #endif
 590 {
 591
 592    (*RgMiLrgTrcIndMt[pst->selector])(pst,trc,mBuf);
 593
 594    return ROK;
 595
 596 }/*-- RgMiLrgTrcInd --*/
 597
 598 #ifdef LTE_L2_MEAS
 599
 600 /* TODO: Function header */
 601 #ifdef ANSI
 602 S16 RgMiLrgSchL2MeasCfm
 603 (
 604 Pst               *pst,          /* post structure  */
 605 LrgSchMeasCfmInfo *cfm       /* Meas Cfm Info */
 606 )
 607 #else
 608 S16 RgMiLrgSchL2MeasCfm(pst, cfm)
 609 Pst               *pst;          /* post structure  */
 610 LrgSchMeasCfmInfo *cfm;       /* Meas Cfm Info */
 611 #endif
 612 {
 613
 614    (*RgMiLrgSchL2mMeasCfmMt[pst->selector])(pst,cfm);
 615
 616    return ROK;
 617
 618 } /* RgMiLrgSchL2MeasCfm */
 619
 620 /**
 621  * @brief This function used to send L2 measurement stop confirmation
 622  *        to Layer manager.
 623  *
 624  *
 625  * @details
 626  *
 627  *     Function : RgMiLrgSchL2MeasStopCfm
 628  *     This function sends reposnes to L2 Measurement stop request
 629  *
 630  *
 631  *  @param[in]  Pst *pst, the post structure
 632  *  @param[in]  LrgSchMeasCfmInfo *cfm, theconfirm structure
 633  *  @return  S16
 634  *      -# ROK
 635  **/
 636
 637 #ifdef ANSI
 638 S16 RgMiLrgSchL2MeasStopCfm
 639 (
 640 Pst               *pst,          /* post structure  */
 641 LrgSchMeasCfmInfo *cfm       /* Meas Cfm Info */
 642 )
 643 #else
 644 S16 RgMiLrgSchL2MeasStopCfm(pst, cfm)
 645 Pst               *pst;          /* post structure  */
 646 LrgSchMeasCfmInfo *cfm;       /* Meas Cfm Info */
 647 #endif
 648 {
 649    (*RgMiLrgSchL2mMeasStopCfmMt[pst->selector])(pst,cfm);
 650
 651    return ROK;
 652
 653 } /* RgMiLrgSchL2MeasStopCfm */
 654
 655 #endif /* LTE_L2_MEAS */
 656
 657 #endif /*-- MK --*/
 658
 659 #ifdef PTRGMILRG
 660 \f
 661 /**
 662  * @brief Portable Function definition for Layer Manager Configuration
 663  *         confirm handler.
 664  *
 665  * @details
 666  *
 667  *     Function : PtMiLrgCfgCfm
 668  *
 669  *     This function handles the configuration
 670  *     confirm invoked by MAC to Layer Manager.
 671  *     Users of MAC who intend to provide a glue logic
 672  *     for portability of Configuration Confirm are expected
 673  *     to fill in the code in this function definition.
 674  *
 675  *  @param[in]  Pst *pst, the post structure
 676  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 677  *  @return  S16
 678  *      -# ROK
 679  **/
 680 #ifdef ANSI
 681 S16 PtMiLrgCfgCfm
 682 (
 683 Pst *pst,               /* post structure */
 684 RgMngmt *cfm            /* Config Confirm */
 685 )
 686 #else
 687 S16 PtMiLrgCfgCfm  (pst, cfm)
 688 Pst *pst;               /* post structure */
 689 RgMngmt *cfm;           /* Config Confirm */
 690 #endif
 691 {
 692    return ROK;
 693 }/* end of PtMiLrgCfgCfm */
 694
 695 /**
 696  * @brief Portable Function definition for Layer Manager Configuration
 697  *         confirm handler.
 698  *
 699  * @details
 700  *
 701  *     Function : PtMiLrgSchCfgCfm
 702  *
 703  *     This function handles the configuration
 704  *     confirm invoked by scheduler to Layer Manager.
 705  *     Users of MAC who intend to provide a glue logic
 706  *     for portability of Configuration Confirm are expected
 707  *     to fill in the code in this function definition.
 708  *
 709  *  @param[in]  Pst *pst, the post structure
 710  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 711  *  @return  S16
 712  *      -# ROK
 713  **/
 714 #ifdef ANSI
 715 S16 PtMiLrgSchCfgCfm
 716 (
 717 Pst *pst,               /* post structure */
 718 RgMngmt *cfm            /* Config Confirm */
 719 )
 720 #else
 721 S16 PtMiLrgSchCfgCfm  (pst, cfm)
 722 Pst *pst;               /* post structure */
 723 RgMngmt *cfm;           /* Config Confirm */
 724 #endif
 725 {
 726
 727    return ROK;
 728 }/* end of PtMiLrgSchCfgCfm */
 729
 730
 731 \f
 732 /**
 733  * @brief Portable Function definition for Layer Manager Statistics
 734  *         confirm handler.
 735  *
 736  * @details
 737  *
 738  *     Function : PtMiLrgStsCfm
 739  *
 740  *     This function handles the statistics
 741  *     confirm invoked by MAC to Layer Manager.
 742  *     Users of MAC who intend to provide a glue logic
 743  *     for portability of statistics Confirm are expected
 744  *     to fill in the code in this function definition.
 745  *
 746  *  @param[in]  Pst *pst, the post structure
 747  *  @param[in]  RgMngmt *cfm, the statistics confirm structure
 748  *  @return  S16
 749  *      -# ROK
 750  **/
 751 #ifdef ANSI
 752 S16 PtMiLrgStsCfm
 753 (
 754 Pst *pst,               /* post structure */
 755 RgMngmt *cfm            /* Statistics Confirm */
 756 )
 757 #else
 758 S16 PtMiLrgStsCfm  (pst, cfm)
 759 Pst *pst;               /* post structure */
 760 RgMngmt *cfm;           /* Statistics Confirm */
 761 #endif
 762 {
 763
 764    return ROK;
 765 }/* end of PtMiLrgStsCfm */
 766
 767
 768 \f
 769 /**
 770  * @brief Portable Function definition for Layer Manager Status
 771  *         confirm handler.
 772  *
 773  * @details
 774  *
 775  *     Function : PtMiLrgStaCfm
 776  *
 777  *     This function handles the status
 778  *     confirm invoked by MAC to Layer Manager.
 779  *     Users of MAC who intend to provide a glue logic
 780  *     for portability of status Confirm are expected
 781  *     to fill in the code in this function definition.
 782  *
 783  *  @param[in]  Pst *pst, the post structure
 784  *  @param[in]  RgMngmt *cfm, the status confirm structure
 785  *  @return  S16
 786  *      -# ROK
 787  **/
 788 #ifdef ANSI
 789 S16 PtMiLrgStaCfm
 790 (
 791 Pst *pst,               /* post structure */
 792 RgMngmt *cfm            /* Status Confirm */
 793 )
 794 #else
 795 S16 PtMiLrgStaCfm  (pst, cfm)
 796 Pst *pst;               /* post structure */
 797 RgMngmt *cfm;           /* Status Confirm */
 798 #endif
 799 {
 800    return ROK;
 801 }/* end of PtMiLrgStaCfm */
 802
 803
 804 \f
 805 /**
 806  * @brief Portable Function definition for Layer Manager Status
 807  *        Indication handler.
 808  *
 809  * @details
 810  *
 811  *     Function : PtMiLrgStaInd
 812  *
 813  *     This function handles the status
 814  *     indication invoked by MAC to Layer Manager.
 815  *     Users of MAC who intend to provide a glue logic
 816  *     for portability of status indication are expected
 817  *     to fill in the code in this function definition.
 818  *
 819  *  @param[in]  Pst *pst, the post structure
 820  *  @param[in]  RgMngmt *cfm, the status indication structure
 821  *  @return  S16
 822  *      -# ROK
 823  **/
 824 #ifdef ANSI
 825 S16 PtMiLrgStaInd
 826 (
 827 Pst *pst,               /* post structure */
 828 RgMngmt *usta           /* Status Indication */
 829 )
 830 #else
 831 S16 PtMiLrgStaInd  (pst, usta)
 832 Pst *pst;               /* post structure */
 833 RgMngmt *usta;          /* Status indication */
 834 #endif
 835 {
 836    return ROK;
 837 }/* end of PtMiLrgStaInd */
 838
 839 /**
 840  * @brief Portable Function definition for Layer Manager Status
 841  *        Indication handler.
 842  *
 843  * @details
 844  *
 845  *     Function : PtMiLrgSchStaInd
 846  *
 847  *     This function handles the status
 848  *     indication invoked by Scheduler to Layer Manager.
 849  *     Users of MAC who intend to provide a glue logic
 850  *     for portability of status indication are expected
 851  *     to fill in the code in this function definition.
 852  *
 853  *  @param[in]  Pst *pst, the post structure
 854  *  @param[in]  RgMngmt *cfm, the status indication structure
 855  *  @return  S16
 856  *      -# ROK
 857  **/
 858 #ifdef ANSI
 859 S16 PtMiLrgSchStaInd
 860 (
 861 Pst *pst,               /* post structure */
 862 RgMngmt *usta           /* Status Indication */
 863 )
 864 #else
 865 S16 PtMiLrgSchStaInd  (pst, usta)
 866 Pst *pst;               /* post structure */
 867 RgMngmt *usta;          /* Status indication */
 868 #endif
 869 {
 870    return ROK;
 871 }/* end of PtMiLrgSchStaInd */
 872
 873 \f
 874 /**
 875  * @brief Portable Function definition for Layer Manager Control
 876  *         confirm handler.
 877  *
 878  * @details
 879  *
 880  *     Function : PtMiLrgCntrlCfm
 881  *
 882  *     This function handles the control
 883  *     confirm invoked by MAC to Layer Manager.
 884  *     Users of MAC who intend to provide a glue logic
 885  *     for portability of control Confirm are expected
 886  *     to fill in the code in this function definition.
 887  *
 888  *  @param[in]  Pst *pst, the post structure
 889  *  @param[in]  RgMngmt *cfm, the control confirm structure
 890  *  @return  S16
 891  *      -# ROK
 892  **/
 893 #ifdef ANSI
 894 S16 PtMiLrgCntrlCfm
 895 (
 896 Pst *pst,               /* post structure */
 897 RgMngmt *cfm            /* Control Confirm */
 898 )
 899 #else
 900 S16 PtMiLrgCntrlCfm (pst, cfm)
 901 Pst *pst;               /* post structure */
 902 RgMngmt *cfm;           /* Control Confirm */
 903 #endif
 904 {
 905    return ROK;
 906 }/* end of PtMiLrgCntrlCfm */
 907
 908 /**
 909  * @brief Portable Function definition for Layer Manager Control
 910  *         confirm handler.
 911  *
 912  * @details
 913  *
 914  *     Function : PtMiLrgSchCntrlCfm
 915  *
 916  *     This function handles the control
 917  *     confirm invoked by scheduler to Layer Manager.
 918  *     Users of MAC who intend to provide a glue logic
 919  *     for portability of control Confirm are expected
 920  *     to fill in the code in this function definition.
 921  *
 922  *  @param[in]  Pst *pst, the post structure
 923  *  @param[in]  RgMngmt *cfm, the control confirm structure
 924  *  @return  S16
 925  *      -# ROK
 926  **/
 927 #ifdef ANSI
 928 S16 PtMiLrgSchCntrlCfm
 929 (
 930 Pst *pst,               /* post structure */
 931 RgMngmt *cfm            /* Control Confirm */
 932 )
 933 #else
 934 S16 PtMiLrgSchCntrlCfm (pst, cfm)
 935 Pst *pst;               /* post structure */
 936 RgMngmt *cfm;           /* Control Confirm */
 937 #endif
 938 {
 939    return ROK;
 940 }/* end of PtMiLrgSchCntrlCfm */
 941
 942 \f
 943 /**
 944  * @brief Portable Function definition for Layer Manager Trace
 945  *        Indication handler.
 946  *
 947  * @details
 948  *
 949  *     Function : PtMiLrgTrcInd
 950  *
 951  *     This function handles the trace
 952  *     indication invoked by MAC to Layer Manager.
 953  *     Users of MAC who intend to provide a glue logic
 954  *     for portability of trace indication are expected
 955  *     to fill in the code in this function definition.
 956  *
 957  *  @param[in]  Pst *pst, the post structure
 958  *  @param[in]  RgMngmt *cfm, the trace indication structure
 959  *  @return  S16
 960  *      -# ROK
 961  **/
 962 #ifdef ANSI
 963 S16 PtMiLrgTrcInd
 964 (
 965 Pst *pst,               /* post structure */
 966 RgMngmt *trc,           /* Trace Event */
 967 Buffer *mBuf            /* Trace message */
 968 )
 969 #else
 970 S16 PtMiLrgTrcInd (pst, trc,mBuf)
 971 Pst *pst;               /* post structure */
 972 RgMngmt *trc;           /* Trace Event */
 973 Buffer *mBuf;           /* Trace message */
 974 #endif
 975 {
 976    return ROK;
 977 }/* end of PtMiLrgTrcInd */
 978 #ifdef LTE_L2_MEAS
 979 /**
 980  * @brief Portable Function definition for L2 Measurement Configuration
 981  *         confirm handler.
 982  *
 983  * @details
 984  *
 985  *     Function : PtMiLrgSchL2MeasCfm
 986  *
 987  *
 988  *  @param[in]  Pst *pst, the post structure
 989  *  @param[in]  *cfm, the measurement confirm structure
 990  *  @return  S16
 991  *      -# ROK
 992  **/
 993 #ifdef ANSI
 994 S16 PtMiLrgSchL2MeasCfm
 995 (
 996 Pst *pst,               /* post structure */
 997 LrgSchMeasCfmInfo *cfm  /* Measurement Confirm */
 998 )
 999 #else
1000 S16 PtMiLrgSchL2MeasCfm(pst, cfm)
1001 Pst *pst;               /* post structure */
1002 LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
1003 #endif
1004 {
1005
1006    return ROK;
1007 }/* end of PtMiLrgSchL2MeasCfm */
1008
1009 /**
1010  * @brief Portable Function definition for L2 Measurement stop
1011  *         confirm handler.
1012  *
1013  * @details
1014  *
1015  *     Function : PtMiLrgSchL2MeasStopCfm
1016  *
1017  *
1018  *  @param[in]  Pst *pst, the post structure
1019  *  @param[in]  *cfm, the measurement confirm structure
1020  *  @return  S16
1021  *      -# ROK
1022  **/
1023 #ifdef ANSI
1024 S16 PtMiLrgSchL2MeasStopCfm
1025 (
1026 Pst *pst,               /* post structure */
1027 LrgSchMeasCfmInfo *cfm  /* Measurement Confirm */
1028 )
1029 #else
1030 S16 PtMiLrgSchL2MeasStopCfm(pst, cfm)
1031 Pst *pst;               /* post structure */
1032 LrgSchMeasCfmInfo *cfm; /* Measurement Confirm */
1033 #endif
1034 {
1035
1036    return ROK;
1037 }/* end of PtMiLrgSchL2MeasStopCfm */
1038 #endif
1039 #endif /*--PTRGMILRG--*/
1040
1041 \f
1042 /**********************************************************************
1043
1044          End of file
1045 **********************************************************************/