src/5gnrrlc/kw_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**
  20
  21         Name:     RLC Layer Management interface
  22
  23         Type:     C source file
  24
  25         Desc:     This file contains source code for RLC layer management
  26                   interface primitives. It includes the definition of the
  27                   following functions and their portable function
  28                   definitions.
  29                      -- PjMiLpjCfgCfm
  30                      -- PjMiLpjCntrlCfm
  31                      -- PjMiLpjStaInd
  32
  33
  34         File:     kw_ptmi.c
  35
  36 *********************************************************************21*/
  37
  38 \f
  39 /* header (.h) include files */
  40 #include "common_def.h"
  41 #include "lkw.h"           /* LKW defines */
  42 #include "ckw.h"           /* CKW defines */
  43 #include "kwu.h"           /* KWU defines */
  44 #include "rgu.h"           /* RGU defines */
  45
  46 #include "kw_env.h"        /* RLC environment options */
  47 #include "kw.h"            /* RLC defines */
  48
  49 /* extern (.x) include files */
  50 #include "lkw.x"           /* LKW */
  51 #include "ckw.x"           /* CKW */
  52 #include "kwu.x"           /* KWU */
  53 #include "rgu.x"           /* RGU */
  54
  55 #include "kw.x"
  56
  57 /* local defines */
  58 #define MAXKWMI 2               /* max. layer management interfaces */
  59
  60 #ifndef LCKWMILKW
  61 #define PTKWLKW
  62 #endif
  63
  64
  65 #ifndef SM
  66 #define PTKWLKW
  67 #endif
  68
  69
  70 \f
  71 #ifdef PTKWLKW
  72 /* portable functions */
  73
  74 PRIVATE S16 PtMiLkwCfgCfm    ARGS((Pst *pst, KwMngmt *cfm));
  75 PRIVATE S16 PtMiLkwCntrlCfm  ARGS((Pst *pst, KwMngmt *cfm));
  76 PRIVATE S16 PtMiLkwStaInd    ARGS((Pst *pst, KwMngmt *usta));
  77
  78 PRIVATE S16 PtMiLkwStaCfm    ARGS((Pst *pst, KwMngmt *cfm));
  79 PRIVATE S16 PtMiLkwStsCfm    ARGS((Pst *pst, Action action,
  80                                 KwMngmt *cfm));
  81 PRIVATE S16 PtMiLkwTrcInd    ARGS((Pst *pst, KwMngmt *trc,
  82                                 Buffer *mBuf));
  83 /* kw005.201 added support for L2 Measurement */
  84 #ifdef LTE_L2_MEAS
  85 PRIVATE S16 PtMiLkwL2MeasCfm   ARGS((Pst *pst, KwL2MeasCfmEvt *measEvt));
  86 PRIVATE S16 PtMiLkwL2MeasStopCfm   ARGS((Pst *pst, U8 measType,U8 status));
  87 #endif /*  LTE_L2_MEAS */
  88 #endif /* PTKWLKW */
  89
  90 \f
  91 /*********************************************************************
  92  *             Primitives for LKW interface
  93  ********************************************************************/
  94 /* Configuration confirmation primitive */
  95
  96 PRIVATE LkwCfgCfm kwMiLkwCfgCfmMt[MAXKWMI] =
  97 {
  98 #ifdef LCKWMILKW
  99    cmPkLkwCfgCfm,            /* 0 - loosely coupled - fc */
 100 #else
 101    PtMiLkwCfgCfm,            /* 0 - tightly coupled portable */
 102 #endif /* LCRLMILKW */
 103 #ifdef SM
 104    SmMiLkwCfgCfm,            /* 1 - tightly coupled layer management*/
 105 #else
 106    PtMiLkwCfgCfm,            /* 1 - tightly coupled portable */
 107 #endif /* SM */
 108 };
 109
 110 /* control confirmation primitives */
 111
 112 PRIVATE LkwCntrlCfm kwMiLkwCntrlCfmMt[MAXKWMI] =
 113 {
 114 #ifdef LCKWMILKW
 115    cmPkLkwCntrlCfm,          /* 0 - loosely coupled - fc */
 116 #else
 117    PtMiLkwCntrlCfm,          /* 0 - tightly coupled portable */
 118 #endif /* LCRLMILKW */
 119 #ifdef SM
 120    SmMiLkwCntrlCfm,          /* 1 - tightly coupled layer management*/
 121 #else
 122    PtMiLkwCntrlCfm,          /* 1 - tightly coupled portable */
 123 #endif /* SM */
 124 };
 125
 126 /* Status Indication primitive */
 127
 128 PRIVATE LkwStaInd kwMiLkwStaIndMt[MAXKWMI] =
 129 {
 130 #ifdef LCKWMILKW
 131    cmPkLkwStaInd,            /* 0 - loosely coupled  */
 132 #else
 133    PtMiLkwStaInd,            /* 0 - tightly coupled, portable */
 134 #endif /* LCKWMILKW */
 135 #ifdef SM
 136    SmMiLkwStaInd,            /* 1 - tightly coupled, layer management */
 137 #else
 138    PtMiLkwStaInd,            /* 1 - tightly coupled, portable */
 139 #endif /* SM */
 140 };
 141
 142 /* Status confirm primitive */
 143
 144 PRIVATE LkwStaCfm kwMiLkwStaCfmMt[MAXKWMI] =
 145 {
 146 #ifdef LCKWMILKW
 147    cmPkLkwStaCfm,            /* 0 - loosely coupled  */
 148 #else
 149    PtMiLkwStaCfm,            /* 0 - tightly coupled, portable */
 150 #endif /* LCKWMILKW */
 151 #ifdef SM
 152    SmMiLkwStaCfm,            /* 1 - tightly coupled, layer management */
 153 #else
 154    PtMiLkwStaCfm,            /* 1 - tightly coupled, portable */
 155 #endif /* SM */
 156 };
 157
 158 /* Statistics confirm primitive */
 159
 160 PRIVATE LkwStsCfm kwMiLkwStsCfmMt[MAXKWMI] =
 161 {
 162 #ifdef LCKWMILKW
 163    cmPkLkwStsCfm,            /* 0 - loosely coupled  */
 164 #else
 165    PtMiLkwStsCfm,            /* 0 - tightly coupled, portable */
 166 #endif /* LCRLMILKW */
 167 #ifdef SM
 168    SmMiLkwStsCfm,            /* 1 - tightly coupled, layer management */
 169 #else
 170    PtMiLkwStsCfm,            /* 1 - tightly coupled, portable */
 171 #endif /* SM */
 172 };
 173
 174 /* Trace indication primitive */
 175
 176 PRIVATE LkwTrcInd kwMiLkwTrcIndMt[MAXKWMI] =
 177 {
 178 #ifdef LCKWMILKW
 179    cmPkLkwTrcInd,            /* 0 - loosely coupled  */
 180 #else
 181    PtMiLkwTrcInd,            /* 0 - tightly coupled, portable */
 182 #endif /* LCKWMILKW */
 183 #ifdef SM
 184    SmMiLkwTrcInd,            /* 1 - tightly coupled, layer management */
 185 #else
 186    PtMiLkwTrcInd,            /* 1 - tightly coupled, portable */
 187 #endif /* SM */
 188 };
 189
 190 /* kw005.201 added support for L2 Measurement */
 191 #ifdef LTE_L2_MEAS
 192 PRIVATE CONSTANT LkwL2MeasCfm KwMiLkwL2MeasCfmMt[] =
 193 {
 194 #ifdef LCKWMILKW
 195    cmPkLkwL2MeasCfm,
 196 #else
 197    PtMiLkwL2MeasCfm,
 198 #endif
 199 #ifdef SM
 200    SmMiLkwL2MeasCfm,
 201 #else
 202    PtMiLkwL2MeasCfm,
 203 #endif
 204 };
 205 PRIVATE CONSTANT LkwL2MeasStopCfm KwMiLkwL2MeasStopCfmMt[] =
 206 {
 207 #ifdef LCKWMILKW
 208    cmPkLkwL2MeasStopCfm,
 209 #else
 210    PtMiLkwL2MeasStopCfm,
 211 #endif
 212 #ifdef SM
 213    SmMiLkwL2MeasStopCfm,
 214 #else
 215    PtMiLkwL2MeasStopCfm,
 216 #endif
 217 };
 218 #endif /*  LTE_L2_MEAS */
 219 \f
 220 /****************************************************************************
 221  *                         LKW Interface Mt functions
 222  ***************************************************************************/
 223 /**
 224    @brief
 225    This function is called by the KwMiLkwCfgReq function for responding
 226    to configuration requests.The cfm field in the KwMngmt  structure contains
 227  the response value.
 228
 229    - This function calls the mapping matrix for sending the configuration
 230      confirmation.
 231    - The actual function called depends on the coupling at the LKW interface.
 232    - For a loosely coupled interface, a common packing function is called.
 233    - The packing function packs the parameter in a message buffer and posts
 234      the message to the target task.
 235    - For a tightly coupled interface, the actual function called depends on
 236      the layer manager API provided.
 237
 238 */
 239 #ifdef ANSI
 240 PUBLIC S16 KwMiLkwCfgCfm
 241 (
 242 Pst        *pst,                /* post structure */
 243 KwMngmt    *cfm                 /* Layer Management structure */
 244 )
 245 #else
 246 PUBLIC S16 KwMiLkwCfgCfm(pst, cfm)
 247 Pst        *pst;                /* post structure */
 248 KwMngmt    *cfm;                /* Layer Management structure */
 249 #endif
 250 {
 251    TRC3(KwMiLkwCfgCfm);
 252
 253    /* jump to specific primitive depending on configured selector */
 254    (*kwMiLkwCfgCfmMt[pst->selector])(pst, cfm);
 255
 256    RETVALUE(ROK);
 257 }
 258
 259
 260 /**
 261    @brief
 262    This function is called by the KwMiLkwCntrlReq function to send a control confirm to the layer management module.
 263
 264    - This function calls the mapping matrix for sending the control confirmation.
 265    - Actual function called depends on the coupling of the LKW interface.
 266    - For a loosely coupled interface, a common packing function is called.
 267    - The packing function packs the parameter in a message buffer and posts the
 268      message to the target task.
 269    - For a tightly coupled interface, the actual function called depends on the
 270      layer manager API provided.
 271
 272 */
 273 #ifdef ANSI
 274 PUBLIC S16 KwMiLkwCntrlCfm
 275 (
 276 Pst *pst,                    /* post structure */
 277 KwMngmt *cfm                 /* configure */
 278 )
 279 #else
 280 PUBLIC S16 KwMiLkwCntrlCfm(pst, cfm)
 281 Pst *pst;                    /* post structure */
 282 KwMngmt *cfm;                /* confirm */
 283 #endif
 284 {
 285    TRC3(KwMiLkwCntrlCfm)
 286
 287    /* jump to specific primitive depending on configured selector */
 288    (*kwMiLkwCntrlCfmMt[pst->selector])(pst, cfm);
 289
 290    RETVALUE(ROK);
 291
 292 } /* end of KwMiLkwCntrlCfm */
 293
 294 /**
 295    @brief
 296    Description:
 297    - This function can be used by RLC to send unsolicited status information
 298      to the layer manager, when the unsolicited status flag is enabled by the
 299      layer manager through a previous control request.
 300
 301    - This function calls the mapping matrix for sending the unsolicited status
 302      indication.The actual function called depends on the coupling of the
 303      LKW interface.
 304
 305    - For a loosely coupled interface, a common packing function is called. The
 306      packing function packs the parameter in a message buffer and posts the
 307      message to the target task.
 308
 309    - For a tightly coupled interface, the actual function called depends on
 310      the layer manager API provided.
 311 */
 312 #ifdef ANSI
 313 PUBLIC S16 KwMiLkwStaInd
 314 (
 315 Pst     *pst,                /* post structure */
 316 KwMngmt *usta                /* unsolicited status */
 317 )
 318 #else
 319 PUBLIC S16 KwMiLkwStaInd(pst, usta)
 320 Pst     *pst;                /* post structure */
 321 KwMngmt *usta;               /* unsolicited status */
 322 #endif
 323 {
 324    TRC3(KwMiLkwStaInd);
 325
 326    /* jump to specific primitive depending on configured selector */
 327    (*kwMiLkwStaIndMt[pst->selector])(pst, usta);
 328
 329    RETVALUE(ROK);
 330 } /* end of KwMiLkwStaInd */
 331
 332
 333 /**
 334    @brief
 335    - This function is called by the KwMiLkwStaReq function to send
 336       the requested status information to the layer manager.
 337
 338    - This function calls the mapping matrix for sending the status
 339       confirmation. The actual function called depends on the coupling
 340       of the LKW interface.
 341
 342    - For a loosely coupled interface, a common packing function is called.
 343       The packing function packs the parameter in a message buffer and
 344       posts the message to the target task.
 345
 346    - For a tightly coupled interface, the actual function called depends
 347       on the layer manager API provided.
 348
 349 */
 350 #ifdef ANSI
 351 PUBLIC S16 KwMiLkwStaCfm
 352 (
 353 Pst *pst,                    /* post structure */
 354 KwMngmt *cfm                 /* solicited status confirmation */
 355 )
 356 #else
 357 PUBLIC S16 KwMiLkwStaCfm(pst, cfm)
 358 Pst *pst;                    /* post structure */
 359 KwMngmt *cfm;                /* solicited status confirmation */
 360 #endif
 361 {
 362    TRC3(KwMiLkwStaCfm);
 363
 364    /* jump to specific primitive depending on configured selector */
 365    (*kwMiLkwStaCfmMt[pst->selector])(pst, cfm);
 366
 367    RETVALUE(ROK);
 368
 369 } /* end of KwMiLkwStaCfm */
 370
 371
 372 /**
 373    @brief
 374    - This function is called by the KwMiLkwStsReq function for responding
 375       to statistics requests.
 376
 377    - This function calls the mapping matrix for sending the statistics
 378       confirmation. The actual function called depends on the coupling
 379       of the LKW interface.
 380
 381    - For a loosely coupled interface, a common packing function is called.
 382       The packing function packs the parameter in a message buffer and
 383       posts the message to the target task.
 384
 385    - For a tightly coupled interface, the actual function called depends
 386       on the layer manager API provided.
 387
 388 */
 389 #ifdef ANSI
 390 PUBLIC S16 KwMiLkwStsCfm
 391 (
 392 Pst *pst,                    /* post structure */
 393 Action action,               /* action */
 394 KwMngmt *cfm                 /* statistics confirmation */
 395 )
 396 #else
 397 PUBLIC S16 KwMiLkwStsCfm(pst, action, cfm)
 398 Pst *pst;                    /* post structure */
 399 Action action;               /* action */
 400 KwMngmt *cfm;                /* statistics confirmation */
 401 #endif
 402 {
 403    TRC3(KwMiLkwStsCfm);
 404
 405    /* jump to specific primitive depending on configured selector */
 406    (*kwMiLkwStsCfmMt[pst->selector])(pst, action, cfm);
 407
 408    RETVALUE(ROK);
 409
 410 } /* end of KwMiLkwStsCfm */
 411
 412 /**
 413    @brief
 414    - This function can be used by RLC module to send unsolicited trace
 415       indications to the layer manager, when tracing is enabled by the
 416       layer manager through a previous control request.
 417
 418    - This function calls the mapping matrix for sending the trace indication.
 419       The actual function called depends on the coupling of the LKW interface.
 420
 421    - For a loosely coupled interface, a common packing function is called.
 422       The packing function packs the parameter in a message buffer and posts
 423       the message to the target task.
 424
 425    - For a tightly coupled interface, the actual function called depends on
 426       the layer manager API provided.
 427
 428 */
 429 #ifdef ANSI
 430 PUBLIC S16 KwMiLkwTrcInd
 431 (
 432 Pst *pst,                    /* post structure */
 433 KwMngmt *trc,                /* trace indication */
 434 Buffer *mBuf                 /* message buffer */
 435 )
 436 #else
 437 PUBLIC S16 KwMiLkwTrcInd(pst, trc, mBuf)
 438 Pst *pst;                    /* post structure */
 439 KwMngmt *trc;                /* trace indication */
 440 Buffer *mBuf;                /* message buffer */
 441 #endif
 442 {
 443    TRC3(KwMiLkwTrcInd);
 444
 445    /* jump to specific primitive depending on configured selector */
 446    (*kwMiLkwTrcIndMt[pst->selector])(pst, trc, mBuf);
 447
 448    RETVALUE(ROK);
 449
 450 } /* end of KwMiLkwTrcInd */
 451
 452
 453 /* kw005.201 added support for L2 Measurement */
 454 #ifdef LTE_L2_MEAS
 455 #ifdef ANSI
 456 PUBLIC S16 KwMiLkwL2MeasCfm
 457 (
 458 Pst * pst,
 459 KwL2MeasCfmEvt *measEvt
 460 )
 461 #else
 462 PUBLIC S16 KwMiLkwL2MeasCfm(pst, measEvt)
 463 Pst * pst;
 464 KwL2MeasCfmEvt *measEvt;
 465 #endif
 466 {
 467
 468    TRC3(KwMiLkwL2MeasCfm)
 469
 470    (*KwMiLkwL2MeasCfmMt[pst->selector])(pst, measEvt);
 471
 472    RETVALUE(ROK);
 473
 474 }
 475 #ifdef ANSI
 476 PUBLIC S16 KwMiLkwL2MeasStopCfm
 477 (
 478 Pst *pst,
 479 U8  measType,
 480 U8  status
 481 )
 482 #else
 483 PUBLIC S16 KwMiLkwL2MeasStopCfm(pst, measType,status)
 484 Pst *pst;
 485 U8  measType;
 486 U8  status;
 487 #endif
 488 {
 489
 490    TRC3(KwMiLkwL2MeasStopCfm)
 491
 492    (*KwMiLkwL2MeasStopCfmMt[pst->selector])(pst, measType,status);
 493
 494    RETVALUE(ROK);
 495
 496 }
 497 #endif /*  LTE_L2_MEAS */
 498 #ifdef PTKWLKW
 499
 500 \f
 501 /*************************************************************************
 502  *                         Porting Functions
 503  ************************************************************************/
 504 /*
 505  *
 506  *       Fun:   configuration  Confirm
 507  *
 508  *       Desc:  This function is used to confirm the receipt of configuration
 509  *              request from layer management.
 510  *
 511  *       Ret:   ROK      - ok
 512  *
 513  *       Notes: None
 514  *
 515  *       File:  kw_ptmi.c
 516  *
 517  */
 518
 519 #ifdef ANSI
 520 PUBLIC S16 PtMiLkwCfgCfm
 521 (
 522 Pst *pst,                    /* post structure */
 523 KwMngmt *cfm                 /* Layer Management structure */
 524 )
 525 #else
 526 PUBLIC S16 PtMiLkwCfgCfm(pst, cfm)
 527 Pst *pst;                    /* post structure */
 528 KwMngmt *cfm;                /* Layer Management structure */
 529 #endif
 530 {
 531    TRC3(PtMiLkwCfgCfm)
 532
 533    UNUSED(pst);
 534    UNUSED(cfm);
 535
 536    TRC2(PtMiLkwCfgCfm() : function is not implemented)
 537
 538    RETVALUE(ROK);
 539 } /* end of PtMiLkwCfgCfm */
 540
 541 /*
 542  *
 543  *       Fun:   Control Confirmation
 544  *
 545  *       Desc:  This function is the portable version of used to
 546  *              confirm the receipt of configuration request from
 547  *              layer management.
 548  *
 549  *       Ret:   ROK      - ok
 550  *
 551  *       Notes: None
 552  *
 553  *       File:  kw_ptmi.c
 554  *
 555  */
 556
 557 #ifdef ANSI
 558 PRIVATE S16 PtMiLkwCntrlCfm
 559 (
 560 Pst *pst,                 /* Post structure */
 561 KwMngmt *cfm              /* Layer Management structure */
 562 )
 563 #else
 564 PRIVATE S16 PtMiLkwCntrlCfm(pst, cfm)
 565 Pst *pst;                 /* Post structure */
 566 KwMngmt *cfm;             /* Layer Management structure */
 567 #endif
 568 {
 569    TRC3(PtMiLkwCntrlCfm);
 570
 571    UNUSED(pst);
 572    UNUSED(cfm);
 573
 574    TRC2(PtMiLkwCntrlCfm() :  function is not implemented)
 575
 576    RETVALUE(ROK);
 577 } /* end of PtMiLkwCntrlCfm */
 578
 579
 580 /*
 581  *
 582  *       Fun:   unsolicited status indication
 583  *
 584  *       Desc:  This function is the portable version  used to
 585  *              send the status indication to the layer manager
 586  *
 587  *       Ret:   ROK      - ok
 588  *
 589  *       Notes: None
 590  *
 591  *       File:  kw_ptmi.c
 592  *
 593  */
 594 #ifdef ANSI
 595 PRIVATE S16 PtMiLkwStaInd
 596 (
 597 Pst *pst,                    /* post structure */
 598 KwMngmt *usta                /* unsolicited status */
 599 )
 600 #else
 601 PRIVATE S16 PtMiLkwStaInd(pst, usta)
 602 Pst *pst;                    /* post structure */
 603 KwMngmt *usta;               /* unsolicited status */
 604 #endif
 605 {
 606    TRC3(PtMiLkwStaInd)
 607
 608    UNUSED(pst);
 609    UNUSED(usta);
 610
 611    TRC2(PtMiLkwStaInd() : function is not implemented)
 612
 613    RETVALUE(ROK);
 614 } /* end of PtMiLkwStaInd */
 615
 616
 617 /*
 618  *
 619  *       Fun:   portable function for solicited status confirmation
 620  *
 621  *       Desc:  This function is the portable version  used to
 622  *              send the status confirmation to the layer manager
 623  *
 624  *       Ret:   ROK      - ok
 625  *
 626  *       Notes: None
 627  *
 628  *       File:  kw_ptmi.c
 629  *
 630  */
 631 #ifdef ANSI
 632 PRIVATE S16 PtMiLkwStaCfm
 633 (
 634 Pst *pst,                    /* post structure */
 635 KwMngmt *cfm                 /* solicited status confirmation */
 636 )
 637 #else
 638 PRIVATE S16 PtMiLkwStaCfm(pst, cfm)
 639 Pst *pst;                    /* post structure */
 640 KwMngmt *cfm;                /* solicited status confirmation */
 641 #endif
 642 {
 643    TRC3(PtMiLkwStaCfm)
 644
 645    UNUSED(pst);
 646    UNUSED(cfm);
 647
 648    RETVALUE(ROK);
 649 } /* end of PtMiLkwStaCfm */
 650
 651
 652 /*
 653  *
 654  *       Fun:   portable function for statistics confirmation
 655  *
 656  *       Desc:  This function is the portable version  used to
 657  *              send the statistics confirmation to the layer manager
 658  *
 659  *       Ret:   ROK      - ok
 660  *
 661  *       Notes: None
 662  *
 663  *       File:  kw_ptmi.c
 664  *
 665  */
 666 #ifdef ANSI
 667 PRIVATE S16 PtMiLkwStsCfm
 668 (
 669 Pst *pst,                    /* post structure */
 670 Action action,               /* action */
 671 KwMngmt *cfm                 /* statistics confirmation */
 672 )
 673 #else
 674 PRIVATE S16 PtMiLkwStsCfm(pst, action, cfm)
 675 Pst *pst;                    /* post structure */
 676 Action action;               /* action */
 677 KwMngmt *cfm;                /* statistics confirmation */
 678 #endif
 679 {
 680    TRC3(PtMiLkwStsCfm)
 681
 682    UNUSED(pst);
 683    UNUSED(action);
 684    UNUSED(cfm);
 685
 686    RETVALUE(ROK);
 687 } /* end of PtMiLkwStsCfm */
 688
 689
 690 /*
 691  *
 692  *       Fun:   portable function for trace indication
 693  *
 694  *       Desc:  This function is the portable version  used to
 695  *              send trace indication to the layer manager
 696  *
 697  *       Ret:   ROK      - ok
 698  *
 699  *       Notes: None
 700  *
 701  *       File:  kw_ptmi.c
 702  *
 703  */
 704 #ifdef ANSI
 705 PRIVATE S16 PtMiLkwTrcInd
 706 (
 707 Pst *pst,                    /* post structure */
 708 KwMngmt *trc,                /* trace indication */
 709 Buffer *mBuf                 /* message buffer */
 710 )
 711 #else
 712 PRIVATE S16 PtMiLkwTrcInd(pst, trc, mBuf)
 713 Pst *pst;                    /* post structure */
 714 KwMngmt *trc;                /* trace indication */
 715 Buffer *mBuf;                /* message buffer */
 716 #endif
 717 {
 718    TRC3(PtMiLkwTrcInd)
 719
 720    UNUSED(pst);
 721    UNUSED(trc);
 722    UNUSED(mBuf);
 723
 724    RETVALUE(ROK);
 725 } /* end of PtMiLkwTrcInd */
 726
 727 /* kw005.201 added support for L2 Measurement */
 728 #ifdef LTE_L2_MEAS
 729 #ifdef ANSI
 730 PRIVATE S16 PtMiLkwL2MeasCfm
 731 (
 732 Pst * pst,
 733 KwL2MeasCfmEvt * measEvt
 734 )
 735 #else
 736 PRIVATE S16 PtMiLkwL2MeasCfm(pst, measEvt)
 737 Pst * pst;
 738 KwL2MeasCfmEvt * measEvt;
 739 #endif
 740 {
 741
 742    TRC3(PtMiLkwL2MeasCfm)
 743
 744    UNUSED(pst);
 745    UNUSED(measEvt);
 746
 747    RETVALUE(ROK);
 748
 749 }
 750 #ifdef ANSI
 751 PRIVATE S16 PtMiLkwL2MeasStopCfm
 752 (
 753 Pst * pst,
 754 U8 measType,
 755 U8 status
 756 )
 757 #else
 758 PRIVATE S16 PtMiLkwL2MeasStopCfm(pst, measType,status)
 759 Pst * pst;
 760 U8  measType;
 761 U8  status;
 762 #endif
 763 {
 764
 765    TRC3(PtMiLkwL2MeasStopCfm)
 766
 767    UNUSED(pst);
 768    UNUSED(measType);
 769    UNUSED(status);
 770
 771    RETVALUE(ROK);
 772
 773 }
 774 #endif /*  LTE_L2_MEAS */
 775 #endif /* PTKWLKW */
 776
 777
 778 /********************************************************************30**
 779
 780          End of file
 781 **********************************************************************/