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