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