src/cm/lkw.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 \f
  19 /********************************************************************20**
  20
  21         Name:     LTE-RLC Layer
  22
  23         Type:     C source file
  24
  25         Desc:     C Source code for common packing and unpacking functions
  26                   for RLC Layer Manager Interfaces.  It contains the
  27                   following function definitions
  28
  29                      -- cmPkLkwCfgReq
  30                      -- cmPkLkwCntrlReq
  31                      -- cmPkLkwCntrlCfm
  32                      -- cmPkLkwCfgCfm
  33                      -- cmPkLkwStaInd
  34
  35                      -- cmUnpkLkwCfgReq
  36                      -- cmUnpkLkwCntrlReq
  37                      -- cmUnpkLkwCntrlCfm
  38                      -- cmUnpkLkwCfgCfm
  39                      -- cmUnpkLkwStaInd
  40
  41         File:     lkw.c
  42
  43 *********************************************************************21*/
  44
  45 \f
  46 /* header include files (.h) */
  47
  48 #include "envopt.h"             /* environment options */
  49 #include "envdep.h"             /* environment dependent */
  50 #include "envind.h"             /* environment independent */
  51
  52 #include "gen.h"                /* general */
  53 #include "ssi.h"                /* system services interface */
  54 #include "cm_lte.h"                /* layer manager */
  55 #include "lkw.h"                /* Layer manager */
  56
  57 /* header/extern include files (.x) */
  58
  59 #include "gen.x"                /* general */
  60 #include "ssi.x"                /* system services interface */
  61 #include "cm_lib.x"             /* common library header file */
  62 #include "cm_lte.x"                /* layer manager */
  63 #include "lkw.x"                /* layer manager */
  64
  65 #ifdef LCLKW
  66
  67 Txt ptNmb[LKW_PART_NUM_STR_LEN];         /* Part number */
  68
  69 \f
  70 /* forward references */
  71
  72 PRIVATE S16 cmPkKwMngmt ARGS ((KwMngmt *param ,Event eventType,
  73                                Buffer *mBuf));
  74 PRIVATE S16 cmPkKwCfg ARGS ((KwMngmt *param ,Elmnt elmnt, Buffer *mBuf));
  75 PRIVATE S16 cmPkKwCntrl ARGS ((KwMngmt *cntrl, Elmnt elmnt, Buffer *mBuf));
  76 PRIVATE S16 cmPkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
  77 PRIVATE S16 cmPkKwSsta ARGS ((KwMngmt *ssta, Elmnt etmnt, Event eventType,
  78                               Buffer *mBuf));
  79 PRIVATE S16 cmPkKwSts ARGS ((KwMngmt *sts, Elmnt elmnt, Buffer *mBuf));
  80 PRIVATE S16 cmPkGenSts ARGS ((KwGenSts *gen, Buffer *mBuf));
  81 PRIVATE S16 cmPkCkwSapSts ARGS ((KwCkwCntSts *rcSap, Buffer *mBuf));
  82 PRIVATE S16 cmPkKwuSapSts ARGS ((KwKwuSapSts *ruSap, Buffer *mBuf));
  83 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
  84  * in general statstics.
  85  * */
  86 PRIVATE S16 cmPkKwTrc ARGS ((KwMngmt *trc, Buffer *mBuf));
  87
  88 PRIVATE S16 cmUnpkKwMngmt ARGS ((KwMngmt *param, Event eventType,
  89                                  Buffer * mBuf));
  90 PRIVATE S16 cmUnpkKwCfg ARGS ((KwMngmt *cfg, Elmnt elmnt, Buffer *mBuf));
  91 PRIVATE S16 cmUnpkKwCntrl ARGS ((KwMngmt *param, Elmnt elmnt, Buffer *mBuf));
  92 PRIVATE S16 cmUnpkKwUsta ARGS ((KwMngmt *usta, Elmnt elmnt, Buffer *mBuf));
  93 PRIVATE S16 cmUnpkKwSsta ARGS ((KwMngmt *ssta, Elmnt elmnt, Event eventType,
  94                                 Buffer *mBuf));
  95 PRIVATE S16 cmUnpkKwSts ARGS ((KwMngmt *sts, Elmnt elmnt, Buffer *mBuf));
  96 PRIVATE S16 cmUnpkGenSts ARGS ((KwGenSts *gen, Buffer *mBuf));
  97 PRIVATE S16 cmUnpkCkwSapSts ARGS ((KwCkwCntSts *rcSap, Buffer *mBuf));
  98 PRIVATE S16 cmUnpkKwuSapSts ARGS ((KwKwuSapSts *ruSap, Buffer *mBuf));
  99 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
 100  * in general statstics.
 101  * */
 102 PRIVATE S16 cmUnpkKwTrc ARGS ((KwMngmt *trc, Buffer *mBuf));
 103
 104
 105 PRIVATE S16 cmPkCkwSapSta ARGS ((KwCkwCntSapSta *rcSap, Buffer *mBuf));
 106 PRIVATE S16 cmUnpkCkwSapSta ARGS ((KwCkwCntSapSta *rcSap, Buffer *mBuf));
 107
 108 PRIVATE S16 cmPkKwuSapSta ARGS ((KwKwuSapSta *rlSap, Buffer *mBuf));
 109 PRIVATE S16 cmUnpkKwuSapSta ARGS ((KwKwuSapSta *rlSap, Buffer *mBuf));
 110
 111 PRIVATE S16 cmPkRguSapSta ARGS ((KwRguSapSta *mkSap, Buffer *mBuf));
 112 PRIVATE S16 cmUnpkRguSapSta ARGS ((KwRguSapSta *mkSap, Buffer *mBuf));
 113
 114 /**
 115  * @brief
 116      Pack Config Request
 117  *
 118  * @param[in] pst  : post structure
 119  * @param[in] cfg  : RLC LM structure
 120  *  @return  S16
 121  *      -# Success : ROK
 122  *      -# Failure : RFAILED
 123  */
 124
 125 #ifdef ANSI
 126 PUBLIC S16 cmPkLkwCfgReq
 127 (
 128 Pst *pst,                    /* post structure */
 129 KwMngmt *cfg                 /* RLC LM structure */
 130 )
 131 #else
 132 PUBLIC S16 cmPkLkwCfgReq(pst, cfg)
 133 Pst *pst;                    /* post structure */
 134 KwMngmt *cfg;                /* RLC LM structure */
 135 #endif
 136 {
 137    Buffer *mBuf;             /* message buffer */
 138    S16 ret1;                 /* return value */
 139
 140    TRC3(cmPkLkwCfgReq)
 141
 142    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
 143    if (ret1 != ROK)
 144    {
 145 #if (ERRCLASS & ERRCLS_ADD_RES)
 146        if(ret1 != ROK)
 147        {
 148           LKWLOGERROR(pst, ERRCLS_ADD_RES, ELKW001, (ErrVal) ret1,
 149              "SGetMsg failed ...!\n");
 150        }
 151 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 152       RETVALUE(ret1);
 153    }
 154
 155    ret1 = cmPkKwMngmt(cfg, LKW_EVT_CFG_REQ, mBuf);
 156
 157    if(ret1 != ROK)
 158    {
 159       SPutMsg(mBuf);
 160 #if (ERRCLASS & ERRCLS_ADD_RES)
 161        if(ret1 != ROK)
 162        {
 163           LKWLOGERROR(pst, ERRCLS_ADD_RES, ELKW002, (ErrVal) ret1,
 164                "cmPkKwMngmt failure ......!");
 165        }
 166 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 167       RETVALUE(RFAILED);
 168    }
 169
 170    pst->event = (Event) LKW_EVT_CFG_REQ;   /* event */
 171    SPstTsk(pst, mBuf);
 172
 173    RETVALUE(ROK);
 174
 175 }  /* end of cmPkLkwCfgReq */
 176
 177 /**
 178  * @brief
 179      Unpack Config Request
 180  *
 181  * @param[in] func  : primitive to call
 182  * @param[in] pst   : post structure
 183  * @param[in] mBuf  : message buffer
 184  *  @return  S16
 185  *      -# Success : ROK
 186  *      -# Failure : RFAILED
 187  */
 188
 189 #ifdef ANSI
 190 PUBLIC S16 cmUnpkLkwCfgReq
 191 (
 192 LkwCfgReq func,              /* primitive to call */
 193 Pst *pst,                    /* post structure */
 194 Buffer *mBuf                 /* message buffer */
 195 )
 196 #else
 197 PUBLIC S16 cmUnpkLkwCfgReq(func, pst, mBuf)
 198 LkwCfgReq func;              /* primitive to call */
 199 Pst *pst;                    /* post structure */
 200 Buffer *mBuf;                /* message buffer */
 201 #endif
 202 {
 203    S16 ret1;                 /* Return value */
 204    KwMngmt cfg;              /* RLC LM structure */
 205
 206    TRC3(cmUnpkLkwCfgReq)
 207
 208    cmMemset((U8 *) &cfg, (U8) 0, (S16) sizeof(KwMngmt));
 209    ret1 = cmUnpkKwMngmt(&cfg, LKW_EVT_CFG_REQ, mBuf);
 210
 211     if(ret1 != ROK)
 212     {
 213        SPutMsg(mBuf);
 214 #if (ERRCLASS & ERRCLS_DEBUG)
 215       /*MBUF_FIXX*/
 216           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW003, (ErrVal) ret1,
 217                "cmUnpkKwMngmt failure ......!");
 218
 219 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 220        RETVALUE(RFAILED);
 221     }
 222
 223    SPutMsg(mBuf);
 224    (Void) (*func)(pst, &cfg);
 225
 226    RETVALUE(ROK);
 227
 228 } /* end of cmUnpkLkwCfgReq */
 229
 230
 231
 232 /**
 233  * @brief
 234      Pack Control Request
 235  *
 236  * @param[in] pst  : post structure
 237  * @param[in] cntrl  : RLC LM structure
 238  *  @return  S16
 239  *      -# Success : ROK
 240  *      -# Failure : RFAILED
 241  */
 242
 243 #ifdef ANSI
 244 PUBLIC S16 cmPkLkwCntrlReq
 245 (
 246 Pst *pst,                    /* post structure */
 247 KwMngmt *cntrl               /* RLC LM structure */
 248 )
 249 #else
 250 PUBLIC S16 cmPkLkwCntrlReq(pst,cntrl)
 251 Pst *pst;                    /* post structure */
 252 KwMngmt *cntrl;              /* RLC LM structure */
 253 #endif
 254 {
 255    Buffer *mBuf;             /* message buffer */
 256    S16 ret1;                 /* return value */
 257
 258    TRC3(cmPkLkwCntrlReq)
 259
 260    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
 261    if (ret1 != ROK)
 262    {
 263 #if (ERRCLASS & ERRCLS_ADD_RES)
 264        if(ret1 != ROK)
 265        {
 266           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW004, (ErrVal) ret1,
 267                "SGetMsg failure ......!");
 268        }
 269 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 270       RETVALUE(ret1);
 271    }
 272
 273    ret1 = cmPkKwMngmt(cntrl, LKW_EVT_CNTRL_REQ, mBuf);
 274
 275    if(ret1 != ROK)
 276    {
 277       SPutMsg(mBuf);
 278 #if (ERRCLASS & ERRCLS_ADD_RES)
 279        if(ret1 != ROK)
 280        {
 281           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW005, (ErrVal) ret1,
 282                "cmPkKwMngmt failure ......!");
 283        }
 284 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 285       RETVALUE(ret1);
 286    }
 287
 288    pst->event = (Event) LKW_EVT_CNTRL_REQ;   /* event */
 289    SPstTsk(pst, mBuf);
 290
 291    RETVALUE(ROK);
 292
 293 }  /* end of cmPkLkwCntrlReq */
 294
 295 /**
 296  * @brief
 297      Unpack Control Request
 298  *
 299  * @param[in] func  : primitive to call
 300  * @param[in] pst   : post structure
 301  * @param[in] mBuf  : message buffer
 302  *  @return  S16
 303  *      -# Success : ROK
 304  *      -# Failure : RFAILED
 305  */
 306
 307 #ifdef ANSI
 308 PUBLIC S16 cmUnpkLkwCntrlReq
 309 (
 310 LkwCntrlReq func,            /* primitive to call */
 311 Pst *pst,                    /* post structure */
 312 Buffer *mBuf                 /* message buffer */
 313 )
 314 #else
 315 PUBLIC S16 cmUnpkLkwCntrlReq(func, pst, mBuf)
 316 LkwCntrlReq func;            /* primitive to call */
 317 Pst *pst;                    /* post structure */
 318 Buffer *mBuf;                /* message buffer */
 319 #endif
 320 {
 321    S16 ret1;                 /* return value */
 322    KwMngmt cfm;              /* Confirmation */
 323
 324    TRC3(cmUnpkLkwCntrlReq)
 325
 326    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CNTRL_REQ, mBuf);
 327
 328     if(ret1 != ROK)
 329     {
 330        SPutMsg(mBuf);
 331 #if (ERRCLASS & ERRCLS_DEBUG)
 332       /*MBUF_FIXX*/
 333           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW006, (ErrVal) ret1,
 334                "cmUnpkKwMngmt failure ......!");
 335
 336 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 337        RETVALUE(RFAILED);
 338     }
 339
 340    SPutMsg(mBuf);
 341    RETVALUE((*func)(pst, &cfm));
 342
 343 } /* end of cmUnpkLkwCntrlReq */
 344
 345 /**
 346  * @brief
 347      Pack Control Confirm
 348  *
 349  * @param[in] pst  : post structure
 350  * @param[in] cfg  : RLC LM structure
 351  *  @return  S16
 352  *      -# Success : ROK
 353  *      -# Failure : RFAILED
 354  */
 355
 356 #ifdef ANSI
 357 PUBLIC S16 cmPkLkwCntrlCfm
 358 (
 359 Pst *pst,                    /* post structure */
 360 KwMngmt *cfm                 /* RLC LM structure */
 361 )
 362 #else
 363 PUBLIC S16 cmPkLkwCntrlCfm(pst, cfm)
 364 Pst *pst;                    /* post structure */
 365 KwMngmt *cfm;                /* RLC LM structure */
 366 #endif
 367 {
 368    Buffer *mBuf;             /* message buffer */
 369    S16 ret1;                 /* return value */
 370
 371    TRC3(cmPkLkwCntrlCfm)
 372
 373    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
 374    if (ret1 != ROK)
 375    {
 376 #if (ERRCLASS & ERRCLS_ADD_RES)
 377        if(ret1 != ROK)
 378        {
 379           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW007, (ErrVal) ret1,
 380                "SGetMsg failure ......!");
 381        }
 382 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 383       RETVALUE(ret1);
 384    }
 385
 386    ret1 = cmPkKwMngmt(cfm, LKW_EVT_CNTRL_CFM, mBuf);
 387
 388    if(ret1 != ROK)
 389    {
 390       SPutMsg(mBuf);
 391 #if (ERRCLASS & ERRCLS_ADD_RES)
 392        if(ret1 != ROK)
 393        {
 394           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW008, (ErrVal) ret1,
 395                "Packing failure ......!");
 396        }
 397 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 398       RETVALUE(RFAILED);
 399    }
 400
 401    pst->event = (Event) LKW_EVT_CNTRL_CFM;   /* event */
 402    SPstTsk(pst, mBuf);
 403
 404    RETVALUE(ROK);
 405
 406 }  /* end of cmPkLkwCntrlCfm */
 407
 408
 409 /**
 410  * @brief
 411      Unpack Control confirm
 412  *
 413  * @param[in] func  : primitive to call
 414  * @param[in] pst   : post structure
 415  * @param[in] mBuf  : message buffer
 416  *  @return  S16
 417  *      -# Success : ROK
 418  *      -# Failure : RFAILED
 419  */
 420
 421 #ifdef ANSI
 422 PUBLIC S16 cmUnpkLkwCntrlCfm
 423 (
 424 LkwCntrlCfm func,            /* primitive to call */
 425 Pst *pst,                    /* post structure */
 426 Buffer *mBuf                 /* message buffer */
 427 )
 428 #else
 429 PUBLIC S16 cmUnpkLkwCntrlCfm(func, pst, mBuf)
 430 LkwCntrlCfm func;            /* primitive to call */
 431 Pst *pst;                    /* post structure */
 432 Buffer *mBuf;                /* message buffer */
 433 #endif
 434 {
 435    KwMngmt cfm;              /* RLC LM structure */
 436    S16 ret1;                 /* return value */
 437
 438    TRC3(cmUnpkLkwCntrlCfm)
 439
 440    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CNTRL_CFM, mBuf);
 441
 442    if(ret1 != ROK)
 443    {
 444       SPutMsg(mBuf);
 445 #if (ERRCLASS & ERRCLS_DEBUG)
 446        if(ret1 != ROK)
 447        {
 448           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW009, (ErrVal) ret1,
 449                "cmUnpkKwMngmt failure ......!");
 450        }
 451 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 452       RETVALUE(RFAILED);
 453    }
 454
 455    SPutMsg(mBuf);
 456
 457    RETVALUE((*func)(pst, &cfm));
 458
 459 } /* end of cmUnpkLkwCntrlCfm */
 460
 461 /**
 462  * @brief
 463      Unpack statistics Confirm
 464  *
 465  * @param[in] func  : primitive to call
 466  * @param[in] pst   : post structure
 467  * @param[in] mBuf  : message buffer
 468  *  @return  S16
 469  *      -# Success : ROK
 470  *      -# Failure : RFAILED
 471  */
 472 #ifdef ANSI
 473 PUBLIC S16 cmUnpkLkwStsCfm
 474 (
 475 LkwStsCfm func,              /* primitive to call */
 476 Pst *pst,                    /* post structure */
 477 Buffer *mBuf                 /* message buffer */
 478 )
 479 #else
 480 PUBLIC S16 cmUnpkLkwStsCfm(func, pst, mBuf)
 481 LkwStsCfm func;              /* primitive to call */
 482 Pst *pst;                    /* post structure */
 483 Buffer *mBuf;                /* message buffer */
 484 #endif
 485 {
 486    KwMngmt cfm;              /* RLC LM structure */
 487    S16 ret1;                 /* return value */
 488
 489    TRC3(cmUnpkLkwStsCfm)
 490
 491    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_STS_CFM, mBuf);
 492
 493    if(ret1 != ROK)
 494    {
 495       SPutMsg(mBuf);
 496 #if (ERRCLASS & ERRCLS_DEBUG)
 497        if(ret1 != ROK)
 498        {
 499           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW010, (ErrVal) ret1,
 500                "SPutMsg failure ......!");
 501        }
 502 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 503       RETVALUE(RFAILED);
 504    }
 505
 506    SPutMsg(mBuf);
 507
 508    RETVALUE((*func)(pst, 0, &cfm));
 509
 510 } /* end of cmUnpkLkwStsCfm */
 511
 512 /**
 513  * @brief
 514      Pack Config Confirm
 515  *
 516  * @param[in] pst  : post structure
 517  * @param[in] cfg  : RLC LM structure
 518  *  @return  S16
 519  *      -# Success : ROK
 520  *      -# Failure : RFAILED
 521  */
 522
 523
 524 #ifdef ANSI
 525 PUBLIC S16 cmPkLkwCfgCfm
 526 (
 527 Pst *pst,                    /* post structure */
 528 KwMngmt *cfm                 /* RLC LM structure */
 529 )
 530 #else
 531 PUBLIC S16 cmPkLkwCfgCfm(pst,cfm)
 532 Pst *pst;                    /* post structure */
 533 KwMngmt *cfm;                /* RLC LM structure */
 534 #endif
 535 {
 536    Buffer *mBuf;             /* message buffer */
 537    S16 ret1;                 /* return value */
 538
 539    TRC3(cmPkLkwCfgCfm)
 540
 541    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
 542    if (ret1 != ROK)
 543    {
 544 #if (ERRCLASS & ERRCLS_ADD_RES)
 545        if(ret1 != ROK)
 546        {
 547           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW011, (ErrVal) ret1,
 548                "SGetMsg failure ......!");
 549        }
 550 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 551       RETVALUE(ret1);
 552    }
 553
 554    ret1 = cmPkKwMngmt(cfm, LKW_EVT_CFG_CFM, mBuf);
 555
 556    if(ret1 != ROK)
 557    {
 558       SPutMsg(mBuf);
 559 #if (ERRCLASS & ERRCLS_ADD_RES)
 560        if(ret1 != ROK)
 561        {
 562           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW012, (ErrVal) ret1,
 563                "SPutMsg failure ......!");
 564        }
 565 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 566       RETVALUE(RFAILED);
 567    }
 568
 569    pst->event = (Event) LKW_EVT_CFG_CFM;   /* event */
 570    SPstTsk(pst, mBuf);
 571
 572    RETVALUE(ROK);
 573
 574 }  /* end of cmPkLkwCfgCfm */
 575
 576
 577 /**
 578  * @brief
 579      Unpack Config Confirm
 580  *
 581  * @param[in] func  : primitive to call
 582  * @param[in] pst   : post structure
 583  * @param[in] mBuf  : message buffer
 584  *  @return  S16
 585  *      -# Success : ROK
 586  *      -# Failure : RFAILED
 587  */
 588 #ifdef ANSI
 589 PUBLIC S16 cmUnpkLkwCfgCfm
 590 (
 591 LkwCfgCfm func,              /* primitive to call */
 592 Pst *pst,                    /* post structure */
 593 Buffer *mBuf                 /* message buffer */
 594 )
 595 #else
 596 PUBLIC S16 cmUnpkLkwCfgCfm(func, pst, mBuf)
 597 LkwCfgCfm func;              /* primitive to call */
 598 Pst *pst;                    /* post structure */
 599 Buffer *mBuf;                /* message buffer */
 600 #endif
 601 {
 602    S16 ret1;                 /* return value */
 603    KwMngmt cfm;              /* RLC LM structure */
 604
 605    TRC3(cmUnpkLkwCfgCfm)
 606
 607    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_CFG_CFM, mBuf);
 608
 609    if(ret1 != ROK)
 610    {
 611       SPutMsg(mBuf);
 612 #if (ERRCLASS & ERRCLS_DEBUG)
 613        if(ret1 != ROK)
 614        {
 615           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW013, (ErrVal) ret1,
 616                "SPutMsg failure ......!");
 617        }
 618 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 619       RETVALUE(RFAILED);
 620    }
 621
 622    SPutMsg(mBuf);
 623    RETVALUE((*func)(pst, &cfm));
 624
 625 } /* end of cmUnpkLkwCfgCfm */
 626
 627
 628
 629 /**
 630  * @brief
 631      Pack Status Indication
 632  *
 633  * @param[in] pst  : post structure
 634  * @param[in] usta  : RLC LM structure
 635  *  @return  S16
 636  *      -# Success : ROK
 637  *      -# Failure : RFAILED
 638  */
 639
 640 #ifdef ANSI
 641 PUBLIC S16 cmPkLkwStaInd
 642 (
 643 Pst *pst,                    /* post structure */
 644 KwMngmt *usta                /* RLC LM structure */
 645 )
 646 #else
 647 PUBLIC S16 cmPkLkwStaInd(pst,usta)
 648 Pst *pst;                    /* post structure */
 649 KwMngmt *usta;               /* RLC LM structure */
 650 #endif
 651 {
 652    Buffer *mBuf;             /* message buffer */
 653    S16 ret1;                 /* return value */
 654
 655    TRC3(cmPkLkwStaInd)
 656
 657    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
 658    if (ret1 != ROK)
 659    {
 660 #if (ERRCLASS & ERRCLS_ADD_RES)
 661        if(ret1 != ROK)
 662        {
 663           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW014, (ErrVal) ret1,
 664                "SGetMsg() failed");
 665        }
 666 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 667       RETVALUE(ret1);
 668    }
 669
 670    ret1 = cmPkKwMngmt(usta, LKW_EVT_STA_IND, mBuf);
 671
 672    if(ret1 != ROK)
 673    {
 674       SPutMsg(mBuf);
 675 #if (ERRCLASS & ERRCLS_ADD_RES)
 676        if(ret1 != ROK)
 677        {
 678           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW015, (ErrVal) ret1,
 679                "cmPkKwMngmt failure ......!");
 680        }
 681 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 682       RETVALUE(ret1);
 683    }
 684
 685    pst->event = (Event) LKW_EVT_STA_IND;   /* event */
 686    SPstTsk(pst, mBuf);
 687
 688    RETVALUE(ROK);
 689
 690 }  /* end of cmPkLkwStaInd */
 691
 692
 693 /**
 694  * @brief
 695      Unpack Unsolicited Status indication
 696  *
 697  * @param[in] func  : primitive to call
 698  * @param[in] pst   : post structure
 699  * @param[in] mBuf  : message buffer
 700  *  @return  S16
 701  *      -# Success : ROK
 702  *      -# Failure : RFAILED
 703  */
 704
 705 #ifdef ANSI
 706 PUBLIC S16 cmUnpkLkwStaInd
 707 (
 708 LkwStaInd func,             /* primitive pointer */
 709 Pst *pst,                   /* post structure */
 710 Buffer *mBuf                /* message buffer */
 711 )
 712 #else
 713 PUBLIC S16 cmUnpkLkwStaInd(func, pst, mBuf)
 714 LkwStaInd func;             /* primitive pointer */
 715 Pst *pst;                   /* post structure */
 716 Buffer *mBuf;               /* message buffer */
 717 #endif
 718 {
 719    KwMngmt usta;            /* RLC LM structure */
 720    S16 ret1;                /* return value */
 721
 722    TRC3(cmUnpkLkwStaInd)
 723
 724    ret1 = cmUnpkKwMngmt(&usta, LKW_EVT_STA_IND, mBuf);
 725
 726    if(ret1 != ROK)
 727    {
 728       SPutMsg(mBuf);
 729 #if (ERRCLASS & ERRCLS_DEBUG)
 730        if(ret1 != ROK)
 731        {
 732           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW016, (ErrVal) ret1,
 733                "cmUnpkKwMngmt failure ......!");
 734        }
 735 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 736       RETVALUE(RFAILED);
 737    }
 738
 739    SPutMsg(mBuf);
 740
 741    RETVALUE((*func)(pst, &usta));
 742 } /* end of cmUnpkLsnStaInd */
 743
 744 /**
 745  * @brief
 746      Pack Status Request
 747  *
 748  * @param[in] pst  : post structure
 749  * @param[in] sta : RLC LM structure
 750  *  @return  S16
 751  *      -# Success : ROK
 752  *      -# Failure : RFAILED
 753  */
 754
 755 #ifdef ANSI
 756 PUBLIC S16 cmPkLkwStaReq
 757 (
 758 Pst *pst,                    /* post structure */
 759 KwMngmt *sta                 /* status */
 760 )
 761 #else
 762 PUBLIC S16 cmPkLkwStaReq(pst,sta)
 763 Pst *pst;                    /* post structure */
 764 KwMngmt *sta;                /* status */
 765 #endif
 766 {
 767    Buffer *mBuf;             /* message buffer */
 768    S16 ret1;                 /* return value */
 769
 770    TRC3(cmPkLkwStaReq)
 771
 772    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
 773    if (ret1 != ROK)
 774    {
 775 #if (ERRCLASS & ERRCLS_ADD_RES)
 776        if(ret1 != ROK)
 777        {
 778           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW017, (ErrVal) ret1,
 779                "SGetMsg failure ......!");
 780        }
 781 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 782       RETVALUE(RFAILED);
 783    }
 784
 785    ret1 = cmPkKwMngmt(sta, LKW_EVT_STA_REQ, mBuf);
 786
 787    if(ret1 != ROK)
 788    {
 789       SPutMsg(mBuf);
 790 #if (ERRCLASS & ERRCLS_ADD_RES)
 791        if(ret1 != ROK)
 792        {
 793           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW018, (ErrVal) ret1,
 794                "SGetMsg() failure ......!");
 795        }
 796 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 797       RETVALUE(RFAILED);
 798    }
 799
 800    pst->event = (Event) LKW_EVT_STA_REQ;   /* event */
 801    SPstTsk(pst, mBuf);
 802
 803    RETVALUE(ROK);
 804
 805 }  /* end of cmPkLkwStaReq */
 806
 807 /**
 808  * @brief
 809      Unpack status confirmation
 810  *
 811  * @param[in] func  : primitive to call
 812  * @param[in] pst   : post structure
 813  * @param[in] mBuf  : message buffer
 814  *  @return  S16
 815  *      -# Success : ROK
 816  *      -# Failure : RFAILED
 817  */
 818 #ifdef ANSI
 819 PUBLIC S16 cmUnpkLkwStaCfm
 820 (
 821 LkwStaReq func,              /* primitive pointer */
 822 Pst *pst,                    /* post structure */
 823 Buffer *mBuf                 /* message buffer */
 824 )
 825 #else
 826 PUBLIC S16 cmUnpkLkwStaCfm(func, pst, mBuf)
 827 LkwStaReq func;              /* primitive pointer */
 828 Pst *pst;                    /* post structure */
 829 Buffer *mBuf;                /* message buffer */
 830 #endif
 831 {
 832    KwMngmt cfm;              /* RLC LM structure */
 833    S16 ret1;                 /* return value */
 834
 835    TRC3(cmUnpkLkwStaReq)
 836
 837    ret1 = cmUnpkKwMngmt(&cfm, LKW_EVT_STA_CFM, mBuf);
 838
 839     if(ret1 != ROK)
 840     {
 841        SPutMsg(mBuf);
 842 #if (ERRCLASS & ERRCLS_DEBUG)
 843        if(ret1 != ROK)
 844        {
 845           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW019, (ErrVal) ret1,
 846                "Unpacking failure ......!");
 847        }
 848 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 849        RETVALUE(RFAILED);
 850     }
 851
 852    SPutMsg(mBuf);
 853
 854    RETVALUE((*func)(pst, &cfm));
 855
 856 } /* end of function cmUnpkLkwStaCfm */
 857
 858 /**
 859  * @brief
 860      Unpack Status request
 861  *
 862  * @param[in] func  : primitive to call
 863  * @param[in] pst   : post structure
 864  * @param[in] mBuf  : message buffer
 865  *  @return  S16
 866  *      -# Success : ROK
 867  *      -# Failure : RFAILED
 868  */
 869 #ifdef ANSI
 870 PUBLIC S16 cmUnpkLkwStsReq
 871 (
 872 LkwStsReq func,              /* primitive pointer */
 873 Pst *pst,                    /* post structure */
 874 Buffer *mBuf                 /* message buffer */
 875 )
 876 #else
 877 PUBLIC S16 cmUnpkLkwStsReq(func, pst, mBuf)
 878 LkwStsReq func;              /* primitive pointer */
 879 Pst *pst;                    /* post structure */
 880 Buffer *mBuf;                /* message buffer */
 881 #endif
 882 {
 883    KwMngmt sts;              /* RLC LM structure */
 884    S16 ret1;                 /* return value */
 885    Action action;            /* Action */
 886
 887    TRC3(cmUnpkLkwStsReq)
 888
 889    CMCHKUNPK(SUnpkS16, &action, mBuf);
 890
 891    ret1 = cmUnpkKwMngmt(&sts, LKW_EVT_STS_REQ, mBuf);
 892
 893     if(ret1 != ROK)
 894     {
 895        SPutMsg(mBuf);
 896 #if (ERRCLASS & ERRCLS_DEBUG)
 897        /*MBUF_FIXX*/
 898           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW020, (ErrVal) ret1,
 899                "Unpacking failure ......!");
 900
 901 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 902        RETVALUE(RFAILED);
 903     }
 904
 905    SPutMsg(mBuf);
 906
 907    RETVALUE((*func)(pst, action, &sts));
 908
 909 } /* end of function cmUnpkLkwStsReq */
 910
 911
 912 /**
 913  * @brief
 914      Unpack ssta
 915  *
 916  * @param[in] func  : primitive to call
 917  * @param[in] pst   : post structure
 918  * @param[in] mBuf  : message buffer
 919  *  @return  S16
 920  *      -# Success : ROK
 921  *      -# Failure : RFAILED
 922  */
 923 #ifdef ANSI
 924 PUBLIC S16 cmUnpkLkwStaReq
 925 (
 926 LkwStaReq func,              /* primitive pointer */
 927 Pst *pst,                    /* post structure */
 928 Buffer *mBuf                 /* message buffer */
 929 )
 930 #else
 931 PUBLIC S16 cmUnpkLkwStaReq(func, pst, mBuf)
 932 LkwStaReq func;              /* primitive pointer */
 933 Pst *pst;                    /* post structure */
 934 Buffer *mBuf;                /* message buffer */
 935 #endif
 936 {
 937    KwMngmt sta;              /* RLC LM structure */
 938    S16 ret1;                 /* return value */
 939
 940    TRC3(cmUnpkLkwStaReq)
 941
 942    ret1 = cmUnpkKwMngmt(&sta, LKW_EVT_STA_REQ, mBuf);
 943
 944     if(ret1 != ROK)
 945     {
 946        SPutMsg(mBuf);
 947 #if (ERRCLASS & ERRCLS_DEBUG)
 948       /*MBUF_FIXX*/
 949           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW021, (ErrVal) ret1,
 950                "Unpacking failure ......!");
 951
 952 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
 953        RETVALUE(RFAILED);
 954     }
 955
 956    SPutMsg(mBuf);
 957
 958    RETVALUE((*func)(pst, &sta));
 959
 960 } /* end of function cmUnpkLkwStaReq */
 961
 962
 963 /**
 964  * @brief
 965      Unpack Trace Indication
 966  *
 967  * @param[in] func  : primitive to call
 968  * @param[in] pst   : post structure
 969  * @param[in] mBuf  : message buffer
 970  *  @return  S16
 971  *      -# Success : ROK
 972  *      -# Failure : RFAILED
 973  */
 974
 975 #ifdef ANSI
 976 PUBLIC S16 cmUnpkLkwTrcInd
 977 (
 978 LkwTrcInd func,              /* primitive to call */
 979 Pst *pst,                    /* post structure */
 980 Buffer *mBuf                 /* message buffer */
 981 )
 982 #else
 983 PUBLIC S16 cmUnpkLkwTrcInd(func, pst, mBuf)
 984 LkwTrcInd func;              /* primitive to call */
 985 Pst *pst;                    /* post structure */
 986 Buffer *mBuf;                /* message buffer */
 987 #endif
 988 {
 989    S16 ret1;                 /* return value */
 990    KwMngmt trc;              /* RLC LM structure */
 991
 992    TRC3(cmUnpkLkwTrcInd)
 993
 994    ret1 = cmUnpkKwMngmt(&trc, LKW_EVT_TRC_IND, mBuf);
 995
 996     if(ret1 != ROK)
 997     {
 998        SPutMsg(mBuf);
 999 #if (ERRCLASS & ERRCLS_DEBUG)
1000        if(ret1 != ROK)
1001        {
1002           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW022, (ErrVal) ret1,
1003                "Unpacking failure ......!");
1004        }
1005 #endif /*  ERRCLASS & ERRCLS_DEBUG  */
1006        RETVALUE(RFAILED);
1007     }
1008
1009    (Void) (*func)(pst, &trc, mBuf);
1010
1011    RETVALUE(ROK);
1012
1013 } /* end of cmUnpkLkwTrcInd */
1014
1015
1016 /**
1017  * @brief
1018      Pack Config Request
1019  *
1020  * @param[in] pst  : post structure
1021  * @param[in] cfg  : RLC LM structure
1022  *  @return  S16
1023  *      -# Success : ROK
1024  *      -# Failure : RFAILED
1025  */
1026
1027 #ifdef ANSI
1028 PRIVATE S16 cmPkCkwSapSta
1029 (
1030 KwCkwCntSapSta *rcSap,         /* SAP statistics */
1031 Buffer *mBuf                 /* Message buffer */
1032 )
1033 #else
1034 PRIVATE S16 cmPkCkwSapSta(rcSap, mBuf)
1035 KwCkwCntSapSta *rcSap;         /* SAP statistics */
1036 Buffer *mBuf;                /* Message buffer */
1037 #endif
1038 {
1039    TRC3(cmPkCkwSapSta)
1040
1041    CMCHKPK(cmPkState, rcSap->state, mBuf);
1042    CMCHKPK(SPkS16, rcSap->spId, mBuf);
1043
1044    RETVALUE(ROK);
1045
1046 } /* end of cmPkCkwSapSta */
1047
1048 /**
1049  * @brief
1050      Unpack CKW sap Sta
1051  *
1052  * @param[out] rcSap: RLC LM structure
1053  * @param[in] buffer: Buffer
1054  *  @return  S16
1055  *      -# Success : ROK
1056  *      -# Failure : RFAILED
1057  */
1058 #ifdef ANSI
1059 PRIVATE S16 cmUnpkCkwSapSta
1060 (
1061 KwCkwCntSapSta *rcSap,         /* SAP statistics */
1062 Buffer *mBuf                 /* Message buffer */
1063 )
1064 #else
1065 PRIVATE S16 cmUnpkCkwSapSta(rcSap, mBuf)
1066 KwCkwCntSapSta *rcSap;         /* SAP statistics */
1067 Buffer *mBuf;                /* Message buffer */
1068 #endif
1069 {
1070    TRC3(cmUnpkCkwSapSta)
1071
1072    CMCHKUNPK(SUnpkS16, &rcSap->spId, mBuf);
1073    CMCHKUNPK(cmUnpkState, &rcSap->state, mBuf);
1074
1075    RETVALUE(ROK);
1076 } /* end of function cmUnpkCkwSapSta */
1077
1078 /**
1079  * @brief
1080      Pack Config Request
1081  *
1082  * @param[in] pst  : post structure
1083  * @param[in] cfg  : RLC LM structure
1084  *  @return  S16
1085  *      -# Success : ROK
1086  *      -# Failure : RFAILED
1087  */
1088 #ifdef ANSI
1089 PRIVATE S16 cmPkKwuSapSta
1090 (
1091 KwKwuSapSta *rlSap,           /* SAP statistics */
1092 Buffer *mBuf                 /* Message buffer */
1093 )
1094 #else
1095 PRIVATE S16 cmPkKwuSapSta(rlSap, mBuf)
1096 KwKwuSapSta *rlSap;           /* SAP statistics */
1097 Buffer *mBuf;                /* Message buffer */
1098 #endif
1099 {
1100    TRC3(cmPkKwuSapSta)
1101
1102    CMCHKPK(cmPkState, rlSap->state, mBuf);
1103    CMCHKPK(SPkS16, rlSap->spId, mBuf);
1104
1105    RETVALUE(ROK);
1106
1107 } /* end of cmPkKwuSapSta */
1108
1109 /**
1110  * @brief
1111      Unpack Kwu Sap Sta
1112  *
1113  * @param[out] rlSap  : KwRLSapSta structure
1114  * @param[in] mBuf  : message buffer
1115  *  @return  S16
1116  *      -# Success : ROK
1117  *      -# Failure : RFAILED
1118  */
1119 #ifdef ANSI
1120 PRIVATE S16 cmUnpkKwuSapSta
1121 (
1122 KwKwuSapSta *rlSap,           /* SAP statistics */
1123 Buffer *mBuf                 /* Message buffer */
1124 )
1125 #else
1126 PRIVATE S16 cmUnpkKwuSapSta(rlSap, mBuf)
1127 KwKwuSapSta *rlSap;           /* SAP statistics */
1128 Buffer *mBuf;                /* Message buffer */
1129 #endif
1130 {
1131    TRC3(cmUnpkKwuSapSta)
1132
1133    CMCHKUNPK(SUnpkS16, &rlSap->spId, mBuf);
1134    CMCHKUNPK(cmUnpkState, &rlSap->state, mBuf);
1135
1136    RETVALUE(ROK);
1137
1138 } /* end of function cmUnpkKwuSapSta */
1139
1140 /**
1141  * @brief
1142      Pack
1143  *
1144  * @param[in] pst  : post structure
1145  * @param[in] cfg  : RLC LM structure
1146  *  @return  S16
1147  *      -# Success : ROK
1148  *      -# Failure : RFAILED
1149  */
1150 #ifdef ANSI
1151 PRIVATE S16 cmPkRguSapSta
1152 (
1153 KwRguSapSta *mkSap,           /* SAP statistics */
1154 Buffer *mBuf                 /* Message buffer */
1155 )
1156 #else
1157 PRIVATE S16 cmPkRguSapSta(mkSap, mBuf)
1158 KwRguSapSta *mkSap;           /* SAP statistics */
1159 Buffer *mBuf;                /* Message buffer */
1160 #endif
1161 {
1162    TRC3(cmPkRguSapSta)
1163
1164    CMCHKPK(cmPkState, mkSap->state, mBuf);
1165    CMCHKPK(cmPkSuId, mkSap->suId, mBuf);
1166
1167    RETVALUE(ROK);
1168
1169 } /* end of cmPkRguSapSta */
1170
1171 /**
1172  * @brief
1173      Unpack Rgu Sap Sta
1174  *
1175  * @param[out] mkSap: KwRguSapSta structure
1176  * @param[in] mBuf  : message buffer
1177  *  @return  S16
1178  *      -# Success : ROK
1179  *      -# Failure : RFAILED
1180  */
1181 #ifdef ANSI
1182 PRIVATE S16 cmUnpkRguSapSta
1183 (
1184 KwRguSapSta *mkSap,           /* SAP statistics */
1185 Buffer *mBuf                 /* Message buffer */
1186 )
1187 #else
1188 PRIVATE S16 cmUnpkRguSapSta(mkSap, mBuf)
1189 KwRguSapSta *mkSap;           /* SAP statistics */
1190 Buffer *mBuf;                /* Message buffer */
1191 #endif
1192 {
1193    TRC3(cmUnpkRguSapSta)
1194
1195    CMCHKUNPK(cmUnpkSuId, &mkSap->suId, mBuf);
1196    CMCHKUNPK(cmUnpkState, &mkSap->state, mBuf);
1197
1198    RETVALUE(ROK);
1199
1200 } /* end of function cmUnpkRguSapSta */
1201
1202 /**
1203  * @brief
1204      Pack
1205  *
1206  * @param[in] pst  : post structure
1207  * @param[in] cfg  : RLC LM structure
1208  *  @return  S16
1209  *      -# Success : ROK
1210  *      -# Failure : RFAILED
1211  */
1212 #ifdef ANSI
1213 PUBLIC S16 cmPkLkwStaCfm
1214 (
1215 Pst *pst,                    /* post structure */
1216 KwMngmt *cfm                 /* solicited status confirm */
1217 )
1218 #else
1219 PUBLIC S16 cmPkLkwStaCfm(pst, cfm)
1220 Pst *pst;                    /* post structure */
1221 KwMngmt *cfm;                /* solicited status confirm */
1222 #endif
1223 {
1224    Buffer *mBuf;             /* message buffer */
1225    S16 ret1;                 /* return value */
1226
1227    TRC3(cmPkLkwStaCfm);
1228
1229    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1230    if (ret1 != ROK)
1231    {
1232 #if (ERRCLASS & ERRCLS_ADD_RES)
1233        if(ret1 != ROK)
1234        {
1235           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW023, (ErrVal) ret1,
1236                "SGetMsg() failure ......!");
1237        }
1238 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1239       RETVALUE(RFAILED);
1240    }
1241
1242    ret1 = cmPkKwMngmt(cfm, LKW_EVT_STA_CFM, mBuf);
1243
1244    if(ret1 != ROK)
1245    {
1246       SPutMsg(mBuf);
1247 #if (ERRCLASS & ERRCLS_ADD_RES)
1248        if(ret1 != ROK)
1249        {
1250           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW024, (ErrVal) ret1,
1251                "packing failure ......!");
1252        }
1253 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1254       RETVALUE(RFAILED);
1255    }
1256
1257    pst->event = (Event) LKW_EVT_STA_CFM;   /* event */
1258    SPstTsk(pst, mBuf);
1259
1260    RETVALUE(ROK);
1261 } /* end of cmPkLkwStaCfm */
1262
1263
1264 /**
1265  * @brief
1266      Pack
1267  *
1268  * @param[in] pst  : post structure
1269  * @param[in] cfg  : RLC LM structure
1270  *  @return  S16
1271  *      -# Success : ROK
1272  *      -# Failure : RFAILED
1273  */
1274 #ifdef ANSI
1275 PUBLIC S16 cmPkLkwTrcInd
1276 (
1277 Pst *pst,                    /* post structure */
1278 KwMngmt *trc,                /* trace */
1279 Buffer *trcBuf                 /* trace buffer */
1280 )
1281 #else
1282 PUBLIC S16 cmPkLkwTrcInd(pst, trc, trcBuf)
1283 Pst *pst;                     /* post structure */
1284 KwMngmt *trc;                 /* trace */
1285 Buffer *trcBuf;               /* trace buffer */
1286 #endif
1287 {
1288    S16      ret1 = ROK;       /* return value */
1289    Buffer   *mBuf = NULLP;    /* Buffer to trace */
1290
1291    TRC3(cmPkLkwTrcInd);
1292
1293    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1294    if (ret1 != ROK)
1295    {
1296 #if (ERRCLASS & ERRCLS_ADD_RES)
1297       if(ret1 != ROK)
1298       {
1299          LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW025, (ErrVal) ret1,
1300                "SGetMsg() failure ......!");
1301       }
1302 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1303       RETVALUE(RFAILED);
1304    }
1305
1306    if (trcBuf)
1307    {
1308       ret1 = SCatMsg(mBuf, trcBuf, M1M2);
1309       if (ret1 != ROK)
1310       {
1311          SPutMsg(mBuf);
1312          SPutMsg(trcBuf);
1313 #if (ERRCLASS & ERRCLS_ADD_RES)
1314          if(ret1 != ROK)
1315          {
1316             LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW026, (ErrVal) ret1,
1317                   "SGetMsg() failure ......!");
1318          }
1319 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1320          RETVALUE(RFAILED);
1321       }
1322
1323       SPutMsg(trcBuf);
1324    }
1325
1326    ret1 = cmPkKwMngmt(trc, LKW_EVT_TRC_IND, mBuf);
1327
1328    if(ret1 != ROK)
1329    {
1330       SPutMsg(mBuf);
1331 #if (ERRCLASS & ERRCLS_ADD_RES)
1332       if(ret1 != ROK)
1333       {
1334          LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW027, (ErrVal) ret1,
1335                "packing failure ......!");
1336       }
1337 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1338       /* log error */
1339       RETVALUE(RFAILED);
1340    }
1341
1342    pst->event = (Event) LKW_EVT_TRC_IND;   /* event */
1343    SPstTsk(pst, mBuf);
1344
1345    RETVALUE(ROK);
1346
1347 } /* end of cmPkLkwTrcInd */
1348
1349
1350 /**
1351  * @brief
1352      Pack
1353  *
1354  * @param[in] pst  : post structure
1355  * @param[in] cfg  : RLC LM structure
1356  *  @return  S16
1357  *      -# Success : ROK
1358  *      -# Failure : RFAILED
1359  */
1360 #ifdef ANSI
1361 PUBLIC S16 cmPkLkwStsReq
1362 (
1363 Pst *pst,                    /* post structure */
1364 Action action,               /* action */
1365 KwMngmt *sts                 /* statistics request */
1366 )
1367 #else
1368 PUBLIC S16 cmPkLkwStsReq(pst, action, sts)
1369 Pst *pst;                    /* post structure */
1370 Action action;               /* action */
1371 KwMngmt *sts;                /* statistics request */
1372 #endif
1373 {
1374
1375    Buffer *mBuf;             /* message buffer */
1376    S16 ret1;                 /* return value */
1377
1378    TRC3(cmPkLkwStsReq)
1379
1380    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1381    if (ret1 != ROK)
1382    {
1383 #if (ERRCLASS & ERRCLS_ADD_RES)
1384        if(ret1 != ROK)
1385        {
1386           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW028, (ErrVal) ret1,
1387                "SGetMsg() failure ......!");
1388        }
1389 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1390       RETVALUE(RFAILED);
1391    }
1392
1393    ret1 = cmPkKwMngmt(sts, LKW_EVT_STS_REQ, mBuf);
1394
1395    if(ret1 != ROK)
1396    {
1397       SPutMsg(mBuf);
1398 #if (ERRCLASS & ERRCLS_ADD_RES)
1399        if(ret1 != ROK)
1400        {
1401           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW029, (ErrVal) ret1,
1402                "Packing failure ......!");
1403        }
1404 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1405       RETVALUE(RFAILED);
1406    }
1407
1408    CMCHKPK(SPkS16, action, mBuf);
1409    pst->event = (Event) LKW_EVT_STS_REQ;   /* event */
1410    SPstTsk(pst, mBuf);
1411
1412    RETVALUE(ROK);
1413
1414 } /* end of cmPkLkwStsReq */
1415
1416
1417 /**
1418  * @brief
1419      Pack
1420  *
1421  * @param[in] pst  : post structure
1422  * @param[in] cfg  : RLC LM structure
1423  *  @return  S16
1424  *      -# Success : ROK
1425  *      -# Failure : RFAILED
1426  */
1427 #ifdef ANSI
1428 PUBLIC S16 cmPkLkwStsCfm
1429 (
1430 Pst *pst,                    /* post structure */
1431 Action action,               /* action */
1432 KwMngmt *cfm                 /* statistics confirmation */
1433 )
1434 #else
1435 PUBLIC S16 cmPkLkwStsCfm(pst, action, cfm)
1436 Pst *pst;                    /* post structure */
1437 Action action;               /* action */
1438 KwMngmt *cfm;                /* statistics confirmation */
1439 #endif
1440 {
1441    Buffer *mBuf;             /* message buffer */
1442    S16 ret1;                 /* return value */
1443
1444    TRC3(cmPkLkwStsCfm);
1445    /* lkw_c_001.main_2 removed warning */
1446    UNUSED(action);
1447    ret1 = SGetMsg(pst->region, pst->pool, &mBuf);
1448    if (ret1 != ROK)
1449    {
1450 #if (ERRCLASS & ERRCLS_ADD_RES)
1451        if(ret1 != ROK)
1452        {
1453           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW030, (ErrVal) ret1,
1454                "SGetMsg() failure ......!");
1455        }
1456 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1457       RETVALUE(RFAILED);
1458    }
1459
1460    ret1 = cmPkKwMngmt(cfm, LKW_EVT_STS_CFM, mBuf);
1461
1462    if(ret1 != ROK)
1463    {
1464       SPutMsg(mBuf);
1465 #if (ERRCLASS & ERRCLS_ADD_RES)
1466        if(ret1 != ROK)
1467        {
1468           LKWLOGERROR(pst, ERRCLS_INT_PAR, ELKW031, (ErrVal) ret1,
1469                "Packing  failure ......!");
1470        }
1471 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1472       RETVALUE(RFAILED);
1473    }
1474
1475    pst->event = (Event) LKW_EVT_STS_CFM;   /* event */
1476    SPstTsk(pst, mBuf);
1477
1478    RETVALUE(ROK);
1479 } /* end of cmPkLkwStsCfm */
1480
1481
1482 /**
1483  * @brief
1484      Pack
1485  *
1486  * @param[in] pst  : post structure
1487  * @param[in] cfg  : RLC LM structure
1488  *  @return  S16
1489  *      -# Success : ROK
1490  *      -# Failure : RFAILED
1491  */
1492
1493 #ifdef ANSI
1494 PRIVATE S16 cmPkKwMngmt
1495 (
1496 KwMngmt *param,              /* Managment */
1497 Event eventType,             /* Event type */
1498 Buffer *mBuf                 /* Message Buffer */
1499 )
1500 #else
1501 PRIVATE S16 cmPkKwMngmt(param ,eventType, mBuf)
1502 KwMngmt *param;              /* Managment */
1503 Event eventType;             /* Event type */
1504 Buffer *mBuf;                /* Message Buffer */
1505 #endif
1506 {
1507     S16 ret1;                /* return value */
1508
1509     TRC3(cmPkKwMngmt)
1510
1511     switch( eventType )
1512     {
1513        case LKW_EVT_CFG_REQ:
1514           ret1 = cmPkKwCfg(param, param->hdr.elmId.elmnt ,mBuf);
1515           if (ret1 != ROK)
1516           {
1517              RETVALUE(RFAILED);
1518           }
1519           break;
1520
1521        case LKW_EVT_CNTRL_REQ:
1522          ret1 = cmPkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
1523           if (ret1 != ROK)
1524           {
1525              RETVALUE(RFAILED);
1526           }
1527           break;
1528
1529        case LKW_EVT_STA_IND:
1530           ret1 = cmPkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
1531           if (ret1 != ROK)
1532           {
1533              RETVALUE(RFAILED);
1534           }
1535           break;
1536
1537        case LKW_EVT_STA_REQ:
1538        case LKW_EVT_STA_CFM:
1539           ret1 = cmPkKwSsta(param, param->hdr.elmId.elmnt , eventType, mBuf);
1540           if (ret1 != ROK)
1541           {
1542              RETVALUE(RFAILED);
1543           }
1544           break;
1545
1546        case LKW_EVT_STS_REQ:
1547        case LKW_EVT_STS_CFM:
1548           ret1 = cmPkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
1549           if (ret1 != ROK)
1550           {
1551              RETVALUE(RFAILED);
1552           }
1553           break;
1554        case LKW_EVT_TRC_IND:
1555           ret1 = cmPkKwTrc(param, mBuf);
1556           if (ret1 != ROK)
1557           {
1558              RETVALUE(RFAILED);
1559           }
1560           break;
1561        case LKW_EVT_CNTRL_CFM:
1562        case LKW_EVT_CFG_CFM:
1563           break;
1564     }
1565
1566    CMCHKPK(cmPkCmStatus, &param->cfm, mBuf);
1567    CMCHKPK(cmPkHeader, &param->hdr, mBuf);
1568
1569    RETVALUE(ROK);
1570 } /* end of function cmPkKwMngmt */
1571
1572
1573 /**
1574  * @brief
1575      Pack
1576  *
1577  * @param[in] pst  : post structure
1578  * @param[in] cfg  : RLC LM structure
1579  *  @return  S16
1580  *      -# Success : ROK
1581  *      -# Failure : RFAILED
1582  */
1583 #ifdef ANSI
1584 PRIVATE S16 cmPkKwCfg
1585 (
1586 KwMngmt *cfg,
1587 Elmnt elmnt,
1588 Buffer *mBuf
1589 )
1590 #else
1591 PRIVATE S16 cmPkKwCfg(cfg, elmnt, mBuf)
1592 KwMngmt *cfg;
1593 Elmnt elmnt;
1594 Buffer *mBuf;
1595 #endif
1596 {
1597     TRC3(cmPkKwCfg)
1598
1599     switch( elmnt )
1600     {
1601       case STGEN:
1602       {
1603          CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxRguSaps, mBuf);
1604          CMCHKPK(SPkU8, cfg->t.cfg.s.gen.rlcMode, mBuf);
1605          CMCHKPK(SPkU32, cfg->t.cfg.s.gen.timeRes, mBuf);
1606          CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
1607          CMCHKPK(SPkU16, cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
1608          CMCHKPK(SPkU32, cfg->t.cfg.s.gen.maxUe, mBuf);
1609          CMCHKPK(cmPkPst, &cfg->t.cfg.s.gen.lmPst,mBuf);
1610
1611          break;
1612       }
1613       case STCKWSAP:
1614       case STKWUSAP:
1615       case STUDXSAP:
1616       case STRGUSAP:
1617       {
1618          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.route,mBuf);
1619          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.priority,mBuf);
1620          CMCHKPK(SPkU16, cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
1621          CMCHKPK(SPkS16, cfg->t.cfg.s.sap.sapId, mBuf);
1622          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.inst, mBuf);
1623          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.ent, mBuf);
1624          CMCHKPK(SPkU16, cfg->t.cfg.s.sap.procId, mBuf);
1625          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.mem.pool, mBuf);
1626          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.mem.region, mBuf);
1627          CMCHKPK(SPkU8, cfg->t.cfg.s.sap.selector, mBuf);
1628          break;
1629       }
1630        default:
1631           RETVALUE(RFAILED);
1632     }
1633     RETVALUE(ROK);
1634 } /*end of function cmPkKwCfg*/
1635
1636
1637 /**
1638  * @brief
1639      Pack kw control request
1640  *
1641  * @param[in] cntrl  : LM management structure
1642  * @param[in] elmnt  : element
1643  * @param[in] mBuf   : Buffer
1644  *  @return  S16
1645  *      -# Success : ROK
1646  *      -# Failure : RFAILED
1647  */
1648 #ifdef ANSI
1649 PRIVATE S16 cmPkKwCntrl
1650 (
1651 KwMngmt *cntrl,
1652 Elmnt elmnt,
1653 Buffer *mBuf
1654 )
1655 #else
1656 PRIVATE S16 cmPkKwCntrl(cntrl, elmnt, mBuf)
1657 KwMngmt *cntrl;
1658 Elmnt elmnt;
1659 Buffer *mBuf;
1660 #endif
1661 {
1662     U8 subAction;            /* sub action */
1663
1664     TRC3(cmPkKwCntrl)
1665
1666     switch( elmnt )
1667     {
1668       case STGEN:
1669          {
1670             subAction = cntrl->t.cntrl.subAction;
1671             switch(subAction)
1672             {
1673                case SAUSTA:
1674                   break;
1675                case SADBG:
1676                   {
1677                       CMCHKPK(SPkU32, cntrl->t.cntrl.s.dbgCntrl.dbgMask,
1678                                                            mBuf);
1679                   }
1680                   break;
1681                case SATRC:
1682                   {
1683                      CMCHKPK(SPkS16, cntrl->t.cntrl.s.trcCntrl.trcLen,
1684                                                            mBuf);
1685                      CMCHKPK(SPkU8, cntrl->t.cntrl.s.trcCntrl.trcMask,
1686                                                            mBuf);
1687                   }
1688                   break;
1689 #ifdef SS_DIAG
1690                case SALOG:
1691                   {
1692                       CMCHKPK(SPkU32, cntrl->t.cntrl.s.logMask,  mBuf);
1693                   }
1694                   break;
1695 #endif
1696                default:
1697                   break;
1698             }
1699             break;
1700          }
1701       case STRGUSAP:
1702       case STUDXSAP:
1703          CMCHKPK(SPkS16, cntrl->t.cntrl.s.sapCntrl.spId, mBuf);
1704          CMCHKPK(SPkS16, cntrl->t.cntrl.s.sapCntrl.suId, mBuf);
1705          break;
1706       default:
1707          break;
1708    }
1709
1710    CMCHKPK(SPkU8, cntrl->t.cntrl.action, mBuf);
1711    CMCHKPK(SPkU8, cntrl->t.cntrl.subAction, mBuf);
1712    CMCHKPK(cmPkDateTime, &cntrl->t.cntrl.dt, mBuf);
1713
1714    RETVALUE(ROK);
1715 } /*end of function cmPkKwCntrl */
1716
1717 /**
1718  * @brief
1719      Pack unsolicit status
1720  *
1721  * @param[in] usta  : RLC LM structure
1722  * @param[in] elmnt : element
1723  * @param[in] mBuf  : Buffer
1724  *  @return  S16
1725  *      -# Success : ROK
1726  *      -# Failure : RFAILED
1727  */
1728 #ifdef ANSI
1729 PRIVATE S16 cmPkKwUsta
1730 (
1731 KwMngmt *usta,
1732 Elmnt elmnt,
1733 Buffer *mBuf
1734 )
1735 #else
1736 PRIVATE S16 cmPkKwUsta(usta, elmnt, mBuf)
1737 KwMngmt *usta;
1738 Elmnt elmnt;
1739 Buffer *mBuf;
1740 #endif
1741 {
1742    TRC3(cmPkKwUsta)
1743
1744    /* lkw_c_001.main_2 removed warning */
1745    UNUSED(elmnt);
1746    /* lkw_c_001.main_2 added support for L2 Measurement */
1747 #ifdef LTE_L2_MEAS
1748    CMCHKPK(SPkU8, usta->t.usta.qci, mBuf);
1749 #endif
1750    CMCHKPK(SPkU32, usta->t.usta.ueId, mBuf);
1751    CMCHKPK(SPkS16, usta->t.usta.suId, mBuf);
1752    CMCHKPK(cmPkCmAlarm, &usta->t.usta.alarm,mBuf);
1753    CMCHKPK(cmPkDateTime, &usta->t.usta.dt, mBuf);
1754
1755    RETVALUE(ROK);
1756
1757 } /* end of cmPkKwUsta */
1758
1759
1760 /**
1761  * @brief
1762      Pack
1763  *
1764  * @param[in] pst  : post structure
1765  * @param[in] cfg  : RLC LM structure
1766  *  @return  S16
1767  *      -# Success : ROK
1768  *      -# Failure : RFAILED
1769  */
1770 #ifdef ANSI
1771 PRIVATE S16 cmPkKwSsta
1772 (
1773 KwMngmt *ssta,
1774 Elmnt elmnt,
1775 Event eventType,
1776 Buffer *mBuf
1777 )
1778 #else
1779 PRIVATE S16 cmPkKwSsta(ssta, elmnt, eventType, mBuf)
1780 KwMngmt *ssta;
1781 Elmnt elmnt;
1782 Event eventType;
1783 Buffer *mBuf;
1784 #endif
1785 {
1786    S16 ret1;
1787    TRC3(cmPkKwSsta)
1788
1789    ret1 = RFAILED;
1790    switch(elmnt)
1791    {
1792       case STSID:
1793          ret1 = ROK;
1794          if(eventType == LKW_EVT_STA_CFM)
1795          {
1796             CMCHKPK(cmPkSystemId, &ssta->t.ssta.s.sysId,mBuf);
1797          }
1798          break;
1799       case STCKWSAP:
1800          ret1 = cmPkCkwSapSta(&ssta->t.ssta.s.ckwSap, mBuf);
1801          break;
1802       case STKWUSAP:
1803          ret1 = cmPkKwuSapSta(&ssta->t.ssta.s.kwuSap, mBuf);
1804          break;
1805       case STRGUSAP:
1806       case STUDXSAP:
1807          ret1 = cmPkRguSapSta(&ssta->t.ssta.s.rguSap, mBuf);
1808          break;
1809       default:
1810          ret1 = RFAILED;
1811         break;
1812    }
1813
1814    if(ret1 != ROK)
1815    {
1816       RETVALUE(RFAILED);
1817    }
1818
1819    CMCHKPK(cmPkDateTime, &ssta->t.ssta.dt, mBuf);
1820
1821    RETVALUE(ROK);
1822
1823 } /* end of cmPkKwSsta */
1824
1825 /**
1826  * @brief
1827      Pack Trace Indication
1828  *
1829  * @param[in] trc  : RLC LM structure
1830  * @param[in] mBuf : Buffer
1831  *  @return  S16
1832  *      -# Success : ROK
1833  *      -# Failure : RFAILED
1834  */
1835 #ifdef ANSI
1836 PRIVATE S16 cmPkKwTrc
1837 (
1838 KwMngmt *trc,                /* trace */
1839 Buffer *mBuf                 /* data buffer */
1840 )
1841 #else
1842 PRIVATE S16 cmPkKwTrc(trc, mBuf)
1843 KwMngmt *trc;                /* trace */
1844 Buffer *mBuf;                /* data buffer */
1845 #endif
1846 {
1847    TRC3(cmPkKwTrc)
1848
1849    CMCHKPK(SPkU16, trc->t.trc.event, mBuf);
1850    CMCHKPK(cmPkDateTime, &trc->t.trc.dt, mBuf);
1851
1852    RETVALUE(ROK);
1853 } /* end of cmPkKwTrc */
1854
1855
1856 /**
1857  * @brief
1858      Pack Statistics request
1859  *
1860  * @param[in] pst  : post structure
1861  * @param[in] cfg  : RLC LM structure
1862  *  @return  S16
1863  *      -# Success : ROK
1864  *      -# Failure : RFAILED
1865  */
1866
1867 #ifdef ANSI
1868 PRIVATE S16 cmPkKwSts
1869 (
1870 KwMngmt *sts,
1871 Elmnt elmnt,
1872 Buffer *mBuf
1873 )
1874 #else
1875 PRIVATE S16 cmPkKwSts(sts, elmnt, mBuf)
1876 KwMngmt *sts;
1877 Elmnt elmnt;
1878 Buffer *mBuf;
1879 #endif
1880 {
1881    S16 ret1;
1882    TRC3(cmPkKwSts)
1883
1884    ret1 = RFAILED;
1885    switch(elmnt)
1886    {
1887       case STGEN:
1888          ret1 = cmPkGenSts(&sts->t.sts.s.gen, mBuf);
1889          break;
1890       case STCKWSAP:
1891          ret1 = cmPkCkwSapSts(&sts->t.sts.s.ckwSap, mBuf);
1892          break;
1893       case STKWUSAP:
1894          ret1 = cmPkKwuSapSts(&sts->t.sts.s.kwuSap, mBuf);
1895          break;
1896 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
1897  * in general statstics.
1898  * */
1899       default:
1900          ret1 = RFAILED;
1901         break;
1902    } /* end of switch */
1903
1904    if(ret1 != ROK)
1905    {
1906       RETVALUE(RFAILED);
1907    }
1908
1909    CMCHKPK(cmPkDateTime, &sts->t.sts.dt, mBuf);
1910
1911    RETVALUE(ROK);
1912 } /* end of cmPkKwSts */
1913
1914
1915
1916 /**
1917  * @brief
1918      Pack general statistics
1919  *
1920  * @param[in] gen  : KwGenSts structure
1921  * @param[in] mBuf : Buffer
1922  *  @return  S16
1923  *      -# Success : ROK
1924  *      -# Failure : RFAILED
1925  */
1926 #ifdef ANSI
1927 PRIVATE S16 cmPkGenSts
1928 (
1929 KwGenSts *gen,
1930 Buffer *mBuf
1931 )
1932 #else
1933 PRIVATE S16 cmPkGenSts(gen, mBuf)
1934 KwGenSts *gen;
1935 Buffer *mBuf;
1936 #endif
1937 {
1938    TRC3(cmPkGenSts)
1939
1940    CMCHKPK(SPkU32, gen->numSduDisc, mBuf);
1941    CMCHKPK(SPkU32, gen->numOfRb, mBuf);
1942    CMCHKPK(SPkU32, gen->protTimeOut, mBuf);
1943    CMCHKPK(SPkU32, gen->errorPdusRecv, mBuf);
1944    CMCHKPK(SPkU32, gen->unexpPdusRecv, mBuf);
1945    CMCHKPK(SPkU32, gen->bytesSent, mBuf);
1946    CMCHKPK(SPkU32, gen->bytesRecv, mBuf);
1947    CMCHKPK(SPkU32, gen->pdusRetx, mBuf);
1948    CMCHKPK(SPkU32, gen->pdusSent, mBuf);
1949    CMCHKPK(SPkU32, gen->pdusRecv, mBuf);
1950    CMCHKPK(SPkU32, gen->numUe, mBuf);
1951
1952    RETVALUE(ROK);
1953
1954 } /* end of cmPkGenSts */
1955
1956 /**
1957  * @brief
1958      Pack CKW statistics
1959  *
1960  * @param[in] pst  : post structure
1961  * @param[in] cfg  : RLC LM structure
1962  *  @return  S16
1963  *      -# Success : ROK
1964  *      -# Failure : RFAILED
1965  */
1966 #ifdef ANSI
1967 PRIVATE S16 cmPkCkwSapSts
1968 (
1969 KwCkwCntSts *rcSap,
1970 Buffer *mBuf
1971 )
1972 #else
1973 PRIVATE S16 cmPkCkwSapSts(rcSap, mBuf)
1974 KwCkwCntSts *rcSap;
1975 Buffer *mBuf;
1976 #endif
1977 {
1978    TRC3(cmPkCkwSapSts)
1979
1980    CMCHKPK(SPkU32, rcSap->statMsgs, mBuf);
1981
1982    RETVALUE(ROK);
1983 } /* end of cmPkCkwSapSts */
1984
1985 /**
1986  * @brief
1987      Pack Config Request
1988  *
1989  * @param[in] pst  : post structure
1990  * @param[in] cfg  : RLC LM structure
1991  *  @return  S16
1992  *      -# Success : ROK
1993  *      -# Failure : RFAILED
1994  */
1995 #ifdef ANSI
1996 PRIVATE S16 cmPkKwuSapSts
1997 (
1998 KwKwuSapSts *ruSap,
1999 Buffer *mBuf
2000 )
2001 #else
2002 PRIVATE S16 cmPkKwuSapSts(ruSap, mBuf)
2003 KwKwuSapSts *ruSap;
2004 Buffer *mBuf;
2005 #endif
2006 {
2007    TRC3(cmPkCkwSapSts)
2008
2009    CMCHKPK(SPkU32, ruSap->sduTx, mBuf);
2010    CMCHKPK(SPkU32, ruSap->sduRx, mBuf);
2011    /* lkw_c_001.main_2 changed from suId to spId */
2012    CMCHKPK(cmPkSuId, ruSap->spId, mBuf);
2013
2014    RETVALUE(ROK);
2015 } /* end of cmPkCkwSapSts */
2016
2017 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
2018  * in general statstics.
2019  * */
2020
2021 /**
2022  * @brief
2023      Unpack RLC Layer Management structure
2024  *
2025  * @param[in] param  : RLC LM structure
2026  * @param[in] eventType   : event type
2027  * @param[in] mBuf  : message buffer
2028  *  @return  S16
2029  *      -# Success : ROK
2030  *      -# Failure : RFAILED
2031  */
2032 #ifdef ANSI
2033 PRIVATE S16 cmUnpkKwMngmt
2034 (
2035 KwMngmt *param,
2036 Event eventType,
2037 Buffer *mBuf
2038 )
2039 #else
2040 PRIVATE S16 cmUnpkKwMngmt(param ,eventType, mBuf)
2041 KwMngmt *param;
2042 Event eventType;
2043 Buffer *mBuf;
2044 #endif
2045 {
2046     S16 ret1;
2047     TRC3(cmUnpkKwMngmt)
2048
2049    cmMemset((U8 *) param, (U8) 0, (S16) sizeof(KwMngmt));
2050
2051    CMCHKUNPK(cmUnpkHeader, &param->hdr, mBuf);
2052    CMCHKUNPK(cmUnpkCmStatus, &param->cfm, mBuf);
2053
2054     switch( eventType )
2055     {
2056        case  LKW_EVT_CFG_REQ:
2057           ret1 = cmUnpkKwCfg(param, param->hdr.elmId.elmnt ,mBuf);
2058           if (ret1 != ROK)
2059           {
2060              RETVALUE(RFAILED);
2061           }
2062           break;
2063        case LKW_EVT_CNTRL_REQ:
2064           ret1 = cmUnpkKwCntrl(param, param->hdr.elmId.elmnt ,mBuf);
2065           if (ret1 != ROK)
2066           {
2067              RETVALUE(RFAILED);
2068           }
2069           break;
2070
2071        case LKW_EVT_STA_IND:
2072           ret1 = cmUnpkKwUsta(param, param->hdr.elmId.elmnt ,mBuf);
2073           if (ret1 != ROK)
2074           {
2075              RETVALUE(RFAILED);
2076           }
2077           break;
2078
2079        case LKW_EVT_STA_REQ:
2080        case LKW_EVT_STA_CFM:
2081           ret1 = cmUnpkKwSsta(param, param->hdr.elmId.elmnt, eventType,mBuf);
2082           if (ret1 != ROK)
2083           {
2084              RETVALUE(RFAILED);
2085           }
2086           break;
2087
2088        case LKW_EVT_STS_REQ:
2089        case LKW_EVT_STS_CFM:
2090
2091           ret1 = cmUnpkKwSts(param, param->hdr.elmId.elmnt ,mBuf);
2092           if (ret1 != ROK)
2093           {
2094              RETVALUE(RFAILED);
2095           }
2096           break;
2097        case LKW_EVT_TRC_IND:
2098           ret1 = cmUnpkKwTrc(param, mBuf);
2099           if (ret1 != ROK)
2100           {
2101              RETVALUE(RFAILED);
2102           }
2103           break;
2104
2105        case LKW_EVT_CNTRL_CFM:
2106        case LKW_EVT_CFG_CFM:
2107        break;
2108
2109        default:
2110           break;
2111     }
2112     RETVALUE(ROK);
2113 } /*end of function cmUnpkKwMngmt*/
2114
2115 /**
2116  * @brief
2117      Unpack Kw configuration structure
2118  *
2119  * @param[out] cfg  : RLC LM structure
2120  * @param[in] elmnt  : element
2121  * @param[in] mBuf  : message buffer
2122  *  @return  S16
2123  *      -# Success : ROK
2124  *      -# Failure : RFAILED
2125  */
2126 #ifdef ANSI
2127 PRIVATE S16 cmUnpkKwCfg
2128 (
2129 KwMngmt *cfg,
2130 Elmnt elmnt,
2131 Buffer *mBuf
2132 )
2133 #else
2134 PRIVATE S16 cmUnpkKwCfg(cfg ,elmnt, mBuf)
2135 KwMngmt *cfg;
2136 Elmnt elmnt;
2137 Buffer *mBuf;
2138 #endif
2139 {
2140    TRC3(cmUnpkKwCfg)
2141
2142    switch(elmnt)
2143    {
2144       case STGEN:
2145       {
2146          CMCHKUNPK(cmUnpkPst, &cfg->t.cfg.s.gen.lmPst,mBuf);
2147          CMCHKUNPK(SUnpkU32, &cfg->t.cfg.s.gen.maxUe, mBuf);
2148          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxKwuSaps, mBuf);
2149          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxUdxSaps, mBuf);
2150          CMCHKUNPK(SUnpkU32, &cfg->t.cfg.s.gen.timeRes, mBuf);
2151          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.gen.rlcMode, mBuf);
2152          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.gen.maxRguSaps, mBuf);
2153       }
2154       break;
2155
2156       case STCKWSAP:
2157       case STKWUSAP:
2158       case STRGUSAP:
2159       case STUDXSAP:
2160       {
2161          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.selector, mBuf);
2162          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.mem.region, mBuf);
2163          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.mem.pool, mBuf);
2164          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.sap.procId, mBuf);
2165          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.ent, mBuf);
2166          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.inst, mBuf);
2167          CMCHKUNPK(SUnpkS16, &cfg->t.cfg.s.sap.sapId, mBuf);
2168          CMCHKUNPK(SUnpkU16, &cfg->t.cfg.s.sap.bndTmrIntvl, mBuf);
2169          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.priority,mBuf);
2170          CMCHKUNPK(SUnpkU8, &cfg->t.cfg.s.sap.route,mBuf);
2171       }
2172       break;
2173       default:
2174         RETVALUE(RFAILED);
2175    } /* end of switch */
2176
2177    RETVALUE(ROK);
2178 } /* end of cmUnpkKwCfg */
2179
2180 /**
2181  * @brief
2182      Unpack Control Structure
2183  *
2184  * @param[in] cfm   : RLC LM structure
2185  * @param[in] elmnt : element
2186  * @param[in] mBuf  : message buffer
2187  *  @return  S16
2188  *      -# Success : ROK
2189  *      -# Failure : RFAILED
2190  */
2191 #ifdef ANSI
2192 PRIVATE S16 cmUnpkKwCntrl
2193 (
2194 KwMngmt *cfm,
2195 Elmnt elmnt,
2196 Buffer *mBuf
2197 )
2198 #else
2199 PRIVATE S16 cmUnpkKwCntrl(cfm, elmnt, mBuf)
2200 KwMngmt *cfm;
2201 Elmnt elmnt;
2202 Buffer *mBuf;
2203 #endif
2204 {
2205    U8 subAction;
2206    KwDbgCntrl *dbgCntrl;
2207    KwTrcCntrl *trcCntrl;
2208
2209    TRC3(cmUnpkKwCntrl);
2210
2211    /* lkw_c_001.main_2 removed warning */
2212    UNUSED(elmnt);
2213
2214    CMCHKUNPK(cmUnpkDateTime, &cfm->t.cntrl.dt, mBuf);
2215    CMCHKUNPK(SUnpkU8, &cfm->t.cntrl.subAction, mBuf);
2216    CMCHKUNPK(SUnpkU8, &cfm->t.cntrl.action, mBuf);
2217
2218    subAction = cfm->t.cntrl.subAction;
2219
2220    switch(cfm->hdr.elmId.elmnt)
2221    {
2222       case STGEN:
2223          {
2224             switch(subAction)
2225             {
2226                case SAUSTA:
2227                   break;
2228                case SADBG:
2229                   {
2230                      dbgCntrl = &cfm->t.cntrl.s.dbgCntrl;
2231                      CMCHKUNPK(SUnpkU32, &dbgCntrl->dbgMask, mBuf);
2232                   }
2233                   break;
2234                case SATRC:
2235                   {
2236                     trcCntrl = &cfm->t.cntrl.s.trcCntrl;
2237                     CMCHKUNPK(SUnpkU8, &trcCntrl->trcMask, mBuf);
2238                     CMCHKUNPK(SUnpkS16,&trcCntrl->trcLen, mBuf);
2239                   }
2240                   break;
2241 #ifdef SS_DIAG
2242                case SALOG:
2243                   {
2244                       CMCHKUNPK(SUnpkU32, &cfm->t.cntrl.s.logMask, mBuf);
2245                   }
2246                   break;
2247 #endif
2248                default:
2249                   break;
2250             }
2251             break;
2252          }
2253       case STRGUSAP:
2254       case STUDXSAP:
2255            CMCHKUNPK(SUnpkS16, &cfm->t.cntrl.s.sapCntrl.suId, mBuf);
2256            CMCHKUNPK(SUnpkS16, &cfm->t.cntrl.s.sapCntrl.spId, mBuf);
2257            break;
2258       default:
2259            break;
2260    }
2261
2262    RETVALUE(ROK);
2263
2264 } /* end of cmUnpkKwCntrl */
2265
2266
2267 /**
2268  * @brief
2269      Unpack USta
2270  *
2271  * @param[in] usta  : RLC LM Structure
2272  * @param[in] elmnt : element
2273  * @param[out] mBuf  : message buffer
2274  *  @return  S16
2275  *      -# Success : ROK
2276  *      -# Failure : RFAILED
2277  */
2278 #ifdef ANSI
2279 PRIVATE S16 cmUnpkKwUsta
2280 (
2281 KwMngmt *usta,
2282 Elmnt elmnt,
2283 Buffer *mBuf
2284 )
2285 #else
2286 PRIVATE S16 cmUnpkKwUsta(usta ,elmnt, mBuf)
2287 KwMngmt *usta;
2288 Elmnt elmnt;
2289 Buffer *mBuf;
2290 #endif
2291 {
2292    TRC3(cmUnpkKwUsta);
2293
2294    /* lkw_c_001.main_2 removed warning */
2295    UNUSED(elmnt);
2296
2297    CMCHKUNPK(cmUnpkDateTime, &usta->t.usta.dt, mBuf);
2298    CMCHKUNPK(cmUnpkCmAlarm, &usta->t.usta.alarm,mBuf);
2299    CMCHKUNPK(SUnpkS16, &usta->t.usta.suId, mBuf);
2300    CMCHKUNPK(SUnpkU32, &usta->t.usta.ueId, mBuf);
2301    /* lkw_c_001.main_2 added support for L2 Measurement */
2302 #ifdef LTE_L2_MEAS
2303    CMCHKUNPK(SUnpkU8, &usta->t.usta.qci, mBuf);
2304 #endif
2305    RETVALUE(ROK);
2306 }
2307
2308 /**
2309  * @brief
2310      Unpack SSta
2311  *
2312  * @param[out] ssta: RLC LM structure
2313  * @param[in] elmnt  : element
2314  * @param[in] mBuf  : message buffer
2315  *  @return  S16
2316  *      -# Success : ROK
2317  *      -# Failure : RFAILED
2318  */
2319 #ifdef ANSI
2320 PRIVATE S16 cmUnpkKwSsta
2321 (
2322 KwMngmt *ssta,
2323 Elmnt elmnt,
2324 Event eventType,
2325 Buffer *mBuf
2326 )
2327 #else
2328 PRIVATE S16 cmUnpkKwSsta(ssta ,elmnt, eventType, mBuf)
2329 KwMngmt *ssta;
2330 Elmnt elmnt;
2331 Event eventType;
2332 Buffer *mBuf;
2333 #endif
2334 {
2335    S16 ret1;           /* return value */
2336    TRC3(cmUnpkKwSsta);
2337
2338    CMCHKUNPK(cmUnpkDateTime, &ssta->t.ssta.dt, mBuf);
2339    switch(elmnt)
2340    {
2341       case STSID:
2342          ret1 = ROK;
2343          if(eventType == LKW_EVT_STA_CFM)
2344          {
2345             cmMemset((U8 *) ptNmb, (U8) 0, LKW_PART_NUM_STR_LEN);
2346             ssta->t.ssta.s.sysId.ptNmb = ptNmb;
2347             CMCHKUNPK(cmUnpkSystemId, &ssta->t.ssta.s.sysId,mBuf);
2348          }
2349          break;
2350       case STCKWSAP:
2351          ret1 = cmUnpkCkwSapSta(&ssta->t.ssta.s.ckwSap, mBuf);
2352          break;
2353       case STKWUSAP:
2354          ret1 = cmUnpkKwuSapSta(&ssta->t.ssta.s.kwuSap, mBuf);
2355          break;
2356       case STRGUSAP:
2357       case STUDXSAP:
2358          ret1 = cmUnpkRguSapSta(&ssta->t.ssta.s.rguSap, mBuf);
2359          break;
2360       default:
2361          ret1 = RFAILED;
2362         break;
2363    }
2364
2365    if(ret1 != ROK)
2366    {
2367       RETVALUE(RFAILED);
2368    }
2369
2370    RETVALUE(ROK);
2371 }
2372
2373
2374 /**
2375  * @brief
2376      Unpack trace Indication
2377  *
2378  * @param[out] trc   : RLC LM Structure
2379  * @param[in] mBuf  : message buffer
2380  *  @return  S16
2381  *      -# Success : ROK
2382  *      -# Failure : RFAILED
2383  */
2384 #ifdef ANSI
2385 PRIVATE S16 cmUnpkKwTrc
2386 (
2387 KwMngmt *trc,
2388 Buffer *mBuf
2389 )
2390 #else
2391 PRIVATE S16 cmUnpkKwTrc(trc, mBuf)
2392 KwMngmt *trc;
2393 Buffer *mBuf;
2394 #endif
2395 {
2396    TRC3(cmUnpkKwTrc);
2397
2398    CMCHKUNPK(cmUnpkDateTime, &trc->t.trc.dt, mBuf);
2399    CMCHKUNPK(SUnpkU16, &trc->t.trc.event, mBuf);
2400
2401    RETVALUE(ROK);
2402 } /* end of cmUnpkKwTrc */
2403
2404
2405 /**
2406  * @brief
2407      Unpack Statistics
2408  *
2409  * @param[out] sts  : RLC LM structure
2410  * @param[in] elmnt : element
2411  * @param[in] mBuf  : message buffer
2412  *  @return  S16
2413  *      -# Success : ROK
2414  *      -# Failure : RFAILED
2415  */
2416 #ifdef ANSI
2417 PRIVATE S16 cmUnpkKwSts
2418 (
2419 KwMngmt *sts,
2420 Elmnt elmnt,
2421 Buffer *mBuf
2422 )
2423 #else
2424 PRIVATE S16 cmUnpkKwSts(sts ,elmnt, mBuf)
2425 KwMngmt *sts;
2426 Elmnt elmnt;
2427 Buffer *mBuf;
2428 #endif
2429 {
2430    S16 ret1;           /* return value */
2431    TRC3(cmUnpkKwSts);
2432
2433    CMCHKUNPK(cmUnpkDateTime, &sts->t.sts.dt, mBuf);
2434
2435    switch(elmnt)
2436    {
2437       case STGEN:
2438          ret1 = cmUnpkGenSts(&sts->t.sts.s.gen, mBuf);
2439          break;
2440       case STCKWSAP:
2441          ret1 = cmUnpkCkwSapSts(&sts->t.sts.s.ckwSap, mBuf);
2442          break;
2443       case STKWUSAP:
2444          ret1 = cmUnpkKwuSapSts(&sts->t.sts.s.kwuSap, mBuf);
2445          break;
2446 /* lkw_c_001.main_2 removed support of RGU sap statistics as it is reflecting
2447  * in general statstics.
2448  * */
2449       default:
2450          ret1 = RFAILED;
2451         break;
2452    } /* end of switch */
2453
2454    if(ret1 != ROK)
2455    {
2456       RETVALUE(RFAILED);
2457    }
2458
2459    RETVALUE(ROK);
2460 } /* end of cmUnpkKwSts */
2461
2462
2463 /**
2464  * @brief
2465      Unpack General statistics
2466  *
2467  * @param[out] gen  : KwGenSts structure
2468  * @param[in] mBuf  : message buffer
2469  *  @return  S16
2470  *      -# Success : ROK
2471  *      -# Failure : RFAILED
2472  */
2473 #ifdef ANSI
2474 PRIVATE S16 cmUnpkGenSts
2475 (
2476 KwGenSts *gen,
2477 Buffer *mBuf
2478 )
2479 #else
2480 PRIVATE S16 cmUnpkGenSts(gen, mBuf)
2481 KwGenSts *gen;
2482 Buffer *mBuf;
2483 #endif
2484 {
2485    TRC3(cmUnpkGenSts);
2486
2487    CMCHKUNPK(SUnpkU32, &gen->numUe, mBuf);
2488    CMCHKUNPK(SUnpkU32, &gen->pdusRecv, mBuf);
2489    CMCHKUNPK(SUnpkU32, &gen->pdusSent, mBuf);
2490    CMCHKUNPK(SUnpkU32, &gen->pdusRetx, mBuf);
2491    CMCHKUNPK(SUnpkU32, &gen->bytesRecv, mBuf);
2492    CMCHKUNPK(SUnpkU32, &gen->bytesSent, mBuf);
2493    CMCHKUNPK(SUnpkU32, &gen->unexpPdusRecv, mBuf);
2494    CMCHKUNPK(SUnpkU32, &gen->errorPdusRecv, mBuf);
2495    CMCHKUNPK(SUnpkU32, &gen->protTimeOut, mBuf);
2496    CMCHKUNPK(SUnpkU32, &gen->numOfRb, mBuf);
2497    CMCHKUNPK(SUnpkU32, &gen->numSduDisc, mBuf);
2498
2499    RETVALUE(ROK);
2500 } /* end of cmUnpkGenSts */
2501
2502 /**
2503  * @brief
2504      Unpack Ckw Sap Statistics
2505  *
2506  * @param[out] rcSap  : KwCkwCntSts structure
2507  * @param[in] mBuf  : message buffer
2508  *  @return  S16
2509  *      -# Success : ROK
2510  *      -# Failure : RFAILED
2511  */
2512 #ifdef ANSI
2513 PRIVATE S16 cmUnpkCkwSapSts
2514 (
2515 KwCkwCntSts *rcSap,
2516 Buffer *mBuf
2517 )
2518 #else
2519 PRIVATE S16 cmUnpkCkwSapSts(rcSap ,mBuf)
2520 KwCkwCntSts *rcSap;
2521 Buffer *mBuf;
2522 #endif
2523 {
2524
2525    TRC3(cmUnpkCkwSapSts);
2526
2527    CMCHKUNPK(SUnpkU32, &rcSap->statMsgs, mBuf);
2528
2529    RETVALUE(ROK);
2530
2531 } /* end of cmUnpkCkwSapSts */
2532
2533 /**
2534  * @brief
2535      Unpack Kwu Sap statistics
2536  *
2537  * @param[out]       : KwKwuSapSts structure
2538  * @param[in] mBuf  : message buffer
2539  *  @return  S16
2540  *      -# Success : ROK
2541  *      -# Failure : RFAILED
2542  */
2543 #ifdef ANSI
2544 PRIVATE S16 cmUnpkKwuSapSts
2545 (
2546 KwKwuSapSts *ruSap,
2547 Buffer *mBuf
2548 )
2549 #else
2550 PRIVATE S16 cmUnpkKwuSapSts(ruSap, mBuf)
2551 KwKwuSapSts *ruSap;
2552 Buffer *mBuf;
2553 #endif
2554 {
2555    TRC3(cmUnpkKwuSapSts)
2556
2557    /* lkw_c_001.main_2 changed from suId to spId */
2558    CMCHKUNPK(cmUnpkSuId, &ruSap->spId, mBuf);
2559    CMCHKUNPK(SUnpkU32, &ruSap->sduRx, mBuf);
2560    CMCHKUNPK(SUnpkU32, &ruSap->sduTx, mBuf);
2561
2562    RETVALUE(ROK);
2563
2564 } /* end of cmUnpkKwuSapSts */
2565
2566 /* lkw_c_001.main_2 added support for L2 Measurement */
2567 #ifdef LTE_L2_MEAS
2568 #ifdef ANSI
2569 PUBLIC S16 cmPkLkwL2MeasReq
2570 (
2571 Pst * pst,
2572 KwL2MeasReqEvt *measReqEvt
2573 )
2574 #else
2575 PUBLIC S16 cmPkLkwL2MeasReq(pst, measReqEvt)
2576 Pst * pst;
2577 KwL2MeasReqEvt *measReqEvt;
2578 #endif
2579 {
2580    Buffer *mBuf = NULLP;
2581    TRC3(cmPkLkwL2MeasReq)
2582
2583    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2584 #if (ERRCLASS & ERRCLS_ADD_RES)
2585       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2586             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2587             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2588 #endif
2589       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2590       RETVALUE(RFAILED);
2591    }
2592    if (cmPkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK) {
2593 #if (ERRCLASS & ERRCLS_ADD_RES)
2594       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2595             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2596             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2597 #endif
2598       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2599       SPutMsg(mBuf);
2600       RETVALUE(RFAILED);
2601    }
2602    if (SPkU16(measReqEvt->measPeriod, mBuf) != ROK) {
2603 #if (ERRCLASS & ERRCLS_ADD_RES)
2604       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2605             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2606             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2607 #endif
2608       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2609       SPutMsg(mBuf);
2610       RETVALUE(RFAILED);
2611    }
2612    if (SPkU32(measReqEvt->transId, mBuf) != ROK) {
2613 #if (ERRCLASS & ERRCLS_ADD_RES)
2614       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2615             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2616             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2617 #endif
2618       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2619       SPutMsg(mBuf);
2620       RETVALUE(RFAILED);
2621    }
2622
2623    pst->event = (Event) LKW_EVT_L2MEAS_REQ;
2624    RETVALUE(SPstTsk(pst,mBuf));
2625 }
2626
2627 #ifdef ANSI
2628 PUBLIC S16 cmPkKwL2MeasReqInfo
2629 (
2630 KwL2MeasReqInfo *param,
2631 Buffer *mBuf
2632 )
2633 #else
2634 PUBLIC S16 cmPkKwL2MeasReqInfo(param, mBuf)
2635 KwL2MeasReqInfo *param;
2636 Buffer *mBuf;
2637 #endif
2638 {
2639    U8 idx;
2640    U16 idx1;
2641
2642    TRC3(cmPkKwL2MeasReqInfo)
2643
2644    if((param->measType & LKW_L2MEAS_DL_IP) ||
2645          (param->measType & LKW_L2MEAS_UL_IP))
2646    {
2647       for(idx1 = 0;idx1 < param->val.ipThMeas.numUes;idx1++)
2648       {
2649
2650          CMCHKPK(cmPkLteCellId, param->val.ipThMeas.ueInfoLst[idx1].cellId, mBuf);
2651          CMCHKPK(cmPkLteRnti,   param->val.ipThMeas.ueInfoLst[idx1].ueId, mBuf);
2652          for(idx = 0; idx < param->val.ipThMeas.ueInfoLst[idx1].numQci; idx++)
2653          {
2654             CMCHKPK(SPkU8, param->val.ipThMeas.ueInfoLst[idx1].qci[idx], mBuf);
2655          }
2656          CMCHKPK(SPkU8, param->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
2657       }
2658       CMCHKPK(SPkU16, param->val.ipThMeas.numUes, mBuf);
2659       CMCHKPK(SPkU8, param->measType, mBuf);
2660       RETVALUE(ROK);
2661    }
2662    else
2663    {
2664       for(idx = 0; idx < param->val.nonIpThMeas.numQci; idx++)
2665       {
2666          CMCHKPK(SPkU8, param->val.nonIpThMeas.qci[idx], mBuf);
2667       }
2668       CMCHKPK(SPkU8, param->val.nonIpThMeas.numQci, mBuf);
2669       CMCHKPK(SPkU16, param->val.nonIpThMeas.numSamples, mBuf);
2670    }
2671    CMCHKPK(SPkU8, param->measType, mBuf);
2672    RETVALUE(ROK);
2673 }
2674
2675 #ifdef ANSI
2676 PUBLIC S16 cmPkLkwL2MeasStopReq
2677 (
2678 Pst *pst,
2679 U8  measType
2680 )
2681 #else
2682 PUBLIC S16 cmPkLkwL2MeasStopReq(pst, measType)
2683 Pst *pst;
2684 U8 measType;
2685 #endif
2686 {
2687    Buffer *mBuf = NULLP;
2688
2689    TRC3(cmPkLkwL2MeasStopReq)
2690    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2691 #if (ERRCLASS & ERRCLS_ADD_RES)
2692       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2693             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2694             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2695 #endif
2696       RETVALUE(RFAILED);
2697    }
2698    CMCHKPK(SPkU8, measType, mBuf);
2699    pst->event = (Event) LKW_EVT_L2MEAS_STOP_REQ;
2700    RETVALUE(SPstTsk(pst,mBuf));
2701 }
2702
2703 #ifdef ANSI
2704 PUBLIC S16 cmPkLkwL2MeasSendReq
2705 (
2706 Pst *pst,
2707 U8  measType
2708 )
2709 #else
2710 PUBLIC S16 cmPkLkwL2MeasSendReq(pst, measType)
2711 Pst *pst;
2712 U8 measType;
2713 #endif
2714 {
2715    Buffer *mBuf = NULLP;
2716
2717    TRC3(cmPkLkwL2MeasSendReq)
2718    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2719 #if (ERRCLASS & ERRCLS_ADD_RES)
2720       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2721             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2722             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2723 #endif
2724       RETVALUE(RFAILED);
2725    }
2726    CMCHKPK(SPkU8, measType, mBuf);
2727    pst->event = (Event) LKW_EVT_L2MEAS_SEND_REQ;
2728    RETVALUE(SPstTsk(pst,mBuf));
2729 }
2730 #ifdef TENB_SPLIT_ARCH
2731 #ifdef ANSI
2732 PUBLIC S16 cmUnpkLkwL2MeasReq
2733 (
2734 LkwL2MeasReq func,
2735 Pst *pst,
2736 Buffer *mBuf
2737 )
2738 #else
2739 PUBLIC S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
2740 LkwL2MeasReq func;
2741 Pst *pst;
2742 Buffer *mBuf;
2743 #endif
2744 {
2745    KwL2MeasReqEvt measReqEvt;
2746
2747    TRC3(cmUnpkLkwL2MeasReq)
2748
2749    if (SUnpkU32(&measReqEvt.transId, mBuf) != ROK) {
2750       SPutMsg(mBuf);
2751 #if (ERRCLASS & ERRCLS_ADD_RES)
2752       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2753          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2754          (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2755 #endif
2756       RETVALUE(RFAILED);
2757    }
2758    if (SUnpkU16(&measReqEvt.measPeriod, mBuf) != ROK) {
2759       SPutMsg(mBuf);
2760 #if (ERRCLASS & ERRCLS_ADD_RES)
2761       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2762          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2763          (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2764 #endif
2765       RETVALUE(RFAILED);
2766    }
2767    if (cmUnpkKwL2MeasReqInfo(&measReqEvt.measReq, mBuf) != ROK)
2768    {
2769       /*SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));*/
2770       SPutMsg(mBuf);
2771 #if (ERRCLASS & ERRCLS_ADD_RES)
2772       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2773            __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2774            (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2775 #endif
2776       RETVALUE(RFAILED);
2777    }
2778    SPutMsg(mBuf);
2779    RETVALUE((*func)(pst, &measReqEvt));
2780 }
2781 #else
2782 #ifdef ANSI
2783 PUBLIC S16 cmUnpkLkwL2MeasReq
2784 (
2785 LkwL2MeasReq func,
2786 Pst *pst,
2787 Buffer *mBuf
2788 )
2789 #else
2790 PUBLIC S16 cmUnpkLkwL2MeasReq(func, pst, mBuf)
2791 LkwL2MeasReq func;
2792 Pst *pst;
2793 Buffer *mBuf;
2794 #endif
2795 {
2796    S16   ret;
2797    KwL2MeasReqEvt *measReqEvt;
2798
2799    TRC3(cmUnpkLkwL2MeasReq)
2800
2801
2802    if((ret = SGetSBuf(pst->region, pst->pool, (Data **)&measReqEvt,\
2803                sizeof(KwL2MeasReqEvt))) != ROK)
2804    {
2805 #if (ERRCLASS & ERRCLS_ADD_RES)
2806       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2807             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2808             (ErrVal)ERRLKW, (ErrVal)0, "SGetMsg() failed");
2809 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
2810       RETVALUE(ret);
2811    }
2812
2813    if (SUnpkU32(&measReqEvt->transId, mBuf) != ROK) {
2814       SPutMsg(mBuf);
2815 #if (ERRCLASS & ERRCLS_ADD_RES)
2816       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2817             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2818             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2819 #endif
2820       RETVALUE(RFAILED);
2821    }
2822    if (SUnpkU16(&measReqEvt->measPeriod, mBuf) != ROK) {
2823       SPutMsg(mBuf);
2824 #if (ERRCLASS & ERRCLS_ADD_RES)
2825       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2826             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2827             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2828 #endif
2829       RETVALUE(RFAILED);
2830    }
2831    if (cmUnpkKwL2MeasReqInfo(&measReqEvt->measReq, mBuf) != ROK)
2832    {
2833       SPutSBuf(pst->region, pst->pool, (Data *)measReqEvt, sizeof(KwL2MeasReqEvt));
2834       SPutMsg(mBuf);
2835 #if (ERRCLASS & ERRCLS_ADD_RES)
2836       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2837             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2838             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2839 #endif
2840       RETVALUE(RFAILED);
2841    }
2842    SPutMsg(mBuf);
2843    RETVALUE((*func)(pst, measReqEvt));
2844 }
2845 #endif
2846
2847 #ifdef ANSI
2848 PUBLIC S16 cmUnpkKwL2MeasReqInfo
2849 (
2850 KwL2MeasReqInfo *param,
2851 Buffer *mBuf
2852 )
2853 #else
2854 PUBLIC S16 cmUnpkKwL2MeasReqInfo(param, mBuf)
2855 KwL2MeasReqInfo *param;
2856 Buffer *mBuf;
2857 #endif
2858 {
2859    U8 idx;
2860    U16 idx1;
2861
2862    TRC3(cmUnpkKwL2MeasReqInfo)
2863
2864    CMCHKUNPK(SUnpkU8, &param->measType, mBuf);
2865
2866    if((param->measType & LKW_L2MEAS_DL_IP) ||
2867          (param->measType & LKW_L2MEAS_UL_IP))
2868    {
2869       CMCHKUNPK(SUnpkU16, &param->val.ipThMeas.numUes, mBuf);
2870       for(idx1 = 0;idx1 < param->val.ipThMeas.numUes;idx1++)
2871       {
2872          CMCHKUNPK(SUnpkU8, &param->val.ipThMeas.ueInfoLst[idx1].numQci, mBuf);
2873          for(idx = param->val.ipThMeas.ueInfoLst[idx1].numQci; idx > 0; idx--)
2874          {
2875             CMCHKUNPK(SUnpkU8, &param->val.ipThMeas.ueInfoLst[idx1].\
2876                   qci[idx - 1], mBuf);
2877          }
2878          CMCHKUNPK(cmUnpkLteRnti, &param->val.ipThMeas.ueInfoLst[idx1].\
2879                ueId, mBuf);
2880          CMCHKUNPK(cmUnpkLteCellId, &param->val.ipThMeas.\
2881                ueInfoLst[idx1].cellId, mBuf);
2882       }
2883       RETVALUE(ROK);
2884    }
2885    else
2886    {
2887       CMCHKUNPK(SUnpkU16, &param->val.nonIpThMeas.numSamples, mBuf);
2888       CMCHKUNPK(SUnpkU8, &param->val.nonIpThMeas.numQci, mBuf);
2889       for(idx = param->val.nonIpThMeas.numQci; idx > 0; idx--)
2890       {
2891          CMCHKUNPK(SUnpkU8, &param->val.nonIpThMeas.qci[idx - 1], mBuf);
2892       }
2893    }
2894    RETVALUE(ROK);
2895 }
2896
2897 #ifdef ANSI
2898 PUBLIC S16 cmUnpkLkwL2MeasStopReq
2899 (
2900 LkwL2MeasStopReq func,
2901 Pst *pst,
2902 Buffer *mBuf
2903 )
2904 #else
2905 PUBLIC S16 cmUnpkLkwL2MeasStopReq(func, pst, mBuf)
2906 LkwL2MeasStopReq func;
2907 Pst *pst;
2908 Buffer *mBuf;
2909 #endif
2910 {
2911    U8 measType;
2912    TRC3(cmUnpkLkwL2MeasReq)
2913
2914    CMCHKUNPK(SUnpkU8, &measType, mBuf);
2915    SPutMsg(mBuf);
2916    RETVALUE((*func)(pst, measType));
2917 }
2918
2919 #ifdef ANSI
2920 PUBLIC S16 cmUnpkLkwL2MeasSendReq
2921 (
2922 LkwL2MeasSendReq func,
2923 Pst *pst,
2924 Buffer *mBuf
2925 )
2926 #else
2927 PUBLIC S16 cmUnpkLkwL2MeasSendReq(func, pst, mBuf)
2928 LkwL2MeasSendReq func;
2929 Pst *pst;
2930 Buffer *mBuf;
2931 #endif
2932 {
2933    U8    measType;
2934
2935    TRC3(cmUnpkLkwL2MeasSendReq)
2936
2937    CMCHKUNPK(SUnpkU8, &measType, mBuf);
2938    SPutMsg(mBuf);
2939    RETVALUE((*func)(pst, measType));
2940 }
2941
2942 #ifdef ANSI
2943 PUBLIC S16 cmPkLkwL2MeasCfm
2944 (
2945 Pst * pst,
2946 KwL2MeasCfmEvt *measCfmEvt
2947 )
2948 #else
2949 PUBLIC S16 cmPkLkwL2MeasCfm(pst, measCfmEvt)
2950 Pst * pst;
2951 KwL2MeasCfmEvt *measCfmEvt;
2952 #endif
2953 {
2954    Buffer *mBuf = NULLP;
2955    U8 idx;
2956    U8 idx1;
2957
2958    TRC3(cmPkLkwL2MeasCfm)
2959
2960    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2961 #if (ERRCLASS & ERRCLS_ADD_RES)
2962       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2963             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2964             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2965 #endif
2966       SPutSBuf(pst->region, pst->pool, (Data *)measCfmEvt, sizeof(KwL2MeasCfmEvt));
2967       RETVALUE(RFAILED);
2968    }
2969
2970    if((measCfmEvt->measType & LKW_L2MEAS_ACT_UE) || \
2971          (measCfmEvt->measType & LKW_L2MEAS_UU_LOSS) || \
2972          (measCfmEvt->measType & LKW_L2MEAS_DL_DISC) ||  \
2973          (measCfmEvt->measType & LKW_L2MEAS_DL_DELAY))
2974    {
2975       for(idx = 0; idx < measCfmEvt->val.nonIpThMeas.numCfm; idx++)
2976       {
2977          if (cmPkKwL2MeasCfmInfo(&measCfmEvt->val.nonIpThMeas.measCfm[idx], \
2978                   mBuf, measCfmEvt->measType) != ROK) {
2979 #if (ERRCLASS & ERRCLS_ADD_RES)
2980             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2981                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2982                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2983 #endif
2984             SPutMsg(mBuf);
2985             RETVALUE(RFAILED);
2986          }
2987       }
2988
2989       if (SPkU16(measCfmEvt->val.nonIpThMeas.numCfm, mBuf) != ROK) {
2990 #if (ERRCLASS & ERRCLS_ADD_RES)
2991          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2992                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2993                (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
2994 #endif
2995          SPutMsg(mBuf);
2996          RETVALUE(RFAILED);
2997       }
2998    }
2999    else
3000    {
3001       for(idx1 =0 ;idx1< measCfmEvt->val.ipThMeas.numUes;idx1++)
3002       {
3003
3004          for(idx = 0; idx < measCfmEvt->val.ipThMeas.ueInfoLst[idx1].numCfm; idx++)
3005          {
3006             if (cmPkKwL2MeasCfmInfo(&measCfmEvt->val.ipThMeas.ueInfoLst[idx1].\
3007                      measCfm[idx], mBuf, measCfmEvt->measType) != ROK) {
3008 #if (ERRCLASS & ERRCLS_ADD_RES)
3009                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3010                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3011                      (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3012 #endif
3013                SPutMsg(mBuf);
3014                RETVALUE(RFAILED);
3015             }
3016          }
3017
3018          if (SPkU16(measCfmEvt->val.ipThMeas.ueInfoLst[idx1].numCfm, mBuf) != ROK) {
3019 #if (ERRCLASS & ERRCLS_ADD_RES)
3020             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3021                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3022                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3023 #endif
3024             SPutMsg(mBuf);
3025             RETVALUE(RFAILED);
3026          }
3027
3028          CMCHKPK(cmPkLteCellId, measCfmEvt->val.ipThMeas.ueInfoLst[idx1].cellId, mBuf);
3029          CMCHKPK(cmPkLteRnti,   measCfmEvt->val.ipThMeas.ueInfoLst[idx1].ueId, mBuf);
3030       }
3031       SPkU16(measCfmEvt->val.ipThMeas.numUes, mBuf);
3032    }
3033
3034    CMCHKPK(SPkU8, measCfmEvt->measType, mBuf);
3035    CMCHKPK(cmPkCmStatus, &measCfmEvt->status, mBuf);
3036    if (SPkU32(measCfmEvt->transId, mBuf) != ROK) {
3037 #if (ERRCLASS & ERRCLS_ADD_RES)
3038       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3039             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3040             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3041 #endif
3042       SPutMsg(mBuf);
3043       RETVALUE(RFAILED);
3044    }
3045    pst->event = (Event) LKW_EVT_L2MEAS_CFM;
3046    RETVALUE(SPstTsk(pst,mBuf));
3047 }
3048
3049 #ifdef ANSI
3050 PUBLIC S16 cmPkKwL2MeasCfmInfo
3051 (
3052 KwL2MeasCfmInfo *param,
3053 Buffer *mBuf,
3054 U8 measType
3055 )
3056 #else
3057 PUBLIC S16 cmPkKwL2MeasCfmInfo(param, mBuf, measType)
3058 KwL2MeasCfmInfo *param;
3059 Buffer *mBuf;
3060 U8 measType;
3061 #endif
3062 {
3063    TRC3(cmPkKwL2MeasCfmInfo)
3064
3065    if((measType & LKW_L2MEAS_DL_IP) ||
3066          (measType & LKW_L2MEAS_UL_IP))
3067    {
3068       CMCHKPK(SPkF32, param->val.ipThrput.ulIpThPut, mBuf);
3069       CMCHKPK(SPkF32, param->val.ipThrput.dlIpThPut, mBuf);
3070       CMCHKPK(SPkU8, param->qci, mBuf);
3071       RETVALUE(ROK);
3072    }
3073    else
3074    {
3075       CMCHKPK(SPkU32, param->val.nonIpThrput.dlDiscRate, mBuf);
3076       CMCHKPK(SPkU32, param->val.nonIpThrput.uuLoss, mBuf);
3077       CMCHKPK(SPkU32, param->val.nonIpThrput.numActUe, mBuf);
3078       CMCHKPK(SPkU32, param->val.nonIpThrput.dlSduDelay, mBuf);
3079       CMCHKPK(SPkU8,  param->qci, mBuf);
3080    }
3081    RETVALUE(ROK);
3082 }
3083
3084 #ifdef ANSI
3085 PUBLIC S16 cmUnpkLkwL2MeasCfm
3086 (
3087 LkwL2MeasCfm func,
3088 Pst *pst,
3089 Buffer *mBuf
3090 )
3091 #else
3092 PUBLIC S16 cmUnpkLkwL2MeasCfm(func, pst, mBuf)
3093 LkwL2MeasCfm func;
3094 Pst *pst;
3095 Buffer *mBuf;
3096 #endif
3097 {
3098    U8 idx;
3099    U16 idx1;
3100    KwL2MeasCfmEvt measCfmEvt;
3101
3102    TRC3(cmUnpkLkwL2MeasCfm)
3103
3104    cmMemset((U8 *)&measCfmEvt, 0 , sizeof(KwL2MeasCfmEvt));
3105
3106    if (SUnpkU32(&measCfmEvt.transId, mBuf) != ROK) {
3107       SPutMsg(mBuf);
3108 #if (ERRCLASS & ERRCLS_ADD_RES)
3109       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3110             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3111             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3112 #endif
3113       RETVALUE(RFAILED);
3114    }
3115    CMCHKUNPK(cmUnpkCmStatus, &measCfmEvt.status, mBuf);
3116    CMCHKUNPK(SUnpkU8, &measCfmEvt.measType, mBuf);
3117
3118    if(measCfmEvt.measType & LKW_L2MEAS_DL_IP || measCfmEvt.measType & LKW_L2MEAS_UL_IP)
3119    {
3120       CMCHKUNPK(SUnpkU16, &measCfmEvt.val.ipThMeas.numUes, mBuf);
3121       for(idx1 = 0;idx1<measCfmEvt.val.ipThMeas.numUes;idx1++)
3122       {
3123          CMCHKUNPK(cmUnpkLteRnti, &measCfmEvt.val.ipThMeas.\
3124                ueInfoLst[idx1].ueId, mBuf);
3125          CMCHKUNPK(cmUnpkLteCellId, &measCfmEvt.val.ipThMeas.\
3126                ueInfoLst[idx1].cellId, mBuf);
3127          if (SUnpkU16(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
3128                   numCfm, mBuf) != ROK) {
3129             SPutMsg(mBuf);
3130 #if (ERRCLASS & ERRCLS_ADD_RES)
3131             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3132                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3133                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3134 #endif
3135             RETVALUE(RFAILED);
3136          }
3137          for(idx = measCfmEvt.val.ipThMeas.ueInfoLst[idx1].numCfm; idx > 0; idx--)
3138          {
3139             if (cmUnpkKwL2MeasCfmInfo(&measCfmEvt.val.ipThMeas.ueInfoLst[idx1].\
3140                      measCfm[idx - 1], mBuf, measCfmEvt.measType) != ROK) {
3141                SPutMsg(mBuf);
3142 #if (ERRCLASS & ERRCLS_ADD_RES)
3143                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3144                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3145                      (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3146 #endif
3147                RETVALUE(RFAILED);
3148             }
3149          }
3150       }
3151    }
3152    else
3153    {
3154       if (SUnpkU16(&measCfmEvt.val.nonIpThMeas.numCfm, mBuf) != ROK) {
3155          SPutMsg(mBuf);
3156 #if (ERRCLASS & ERRCLS_ADD_RES)
3157          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3158                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3159                (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3160 #endif
3161          RETVALUE(RFAILED);
3162       }
3163       for(idx = measCfmEvt.val.nonIpThMeas.numCfm; idx > 0; idx--)
3164       {
3165          if (cmUnpkKwL2MeasCfmInfo(&measCfmEvt.val.nonIpThMeas.measCfm[idx - 1], \
3166                   mBuf, measCfmEvt.measType) != ROK) {
3167             SPutMsg(mBuf);
3168 #if (ERRCLASS & ERRCLS_ADD_RES)
3169             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3170                   __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3171                   (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3172 #endif
3173             RETVALUE(RFAILED);
3174          }
3175       }
3176    }
3177    SPutMsg(mBuf);
3178    RETVALUE((*func)(pst, &measCfmEvt));
3179 }
3180
3181 #ifdef ANSI
3182 PUBLIC S16 cmUnpkKwL2MeasCfmInfo
3183 (
3184 KwL2MeasCfmInfo *param,
3185 Buffer *mBuf,
3186 U8 measType
3187 )
3188 #else
3189 PUBLIC S16 cmUnpkKwL2MeasCfmInfo(param, mBuf, measType)
3190 KwL2MeasCfmInfo *param;
3191 Buffer *mBuf;
3192 U8 measType;
3193 #endif
3194 {
3195    TRC3(cmUnpkKwL2MeasCfmInfo)
3196
3197    if((measType & LKW_L2MEAS_DL_IP) ||
3198          (measType & LKW_L2MEAS_UL_IP))
3199    {
3200       CMCHKUNPK(SUnpkU8,  &param->qci, mBuf);
3201       CMCHKUNPK(SUnpkF32, &param->val.ipThrput.dlIpThPut, mBuf);
3202       CMCHKUNPK(SUnpkF32, &param->val.ipThrput.ulIpThPut, mBuf);
3203    }
3204    else
3205
3206    {
3207       CMCHKUNPK(SUnpkU8,  &param->qci, mBuf);
3208       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.dlSduDelay, mBuf);
3209       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.numActUe, mBuf);
3210       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.uuLoss, mBuf);
3211       CMCHKUNPK(SUnpkU32, &param->val.nonIpThrput.dlDiscRate, mBuf);
3212    }
3213    RETVALUE(ROK);
3214 }
3215
3216
3217 #ifdef ANSI
3218 PUBLIC S16 cmPkLkwL2MeasStopCfm
3219 (
3220 Pst * pst,
3221 U8 measType,
3222 U8 status
3223 )
3224 #else
3225 PUBLIC S16 cmPkLkwL2MeasStopCfm(pst, measType,status)
3226 Pst * pst;
3227 U8  measType;
3228 U8  status
3229 #endif
3230 {
3231    Buffer *mBuf = NULLP;
3232    TRC3(cmPkLkwL2MeasStopCfm)
3233
3234    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3235 #if (ERRCLASS & ERRCLS_ADD_RES)
3236       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3237             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3238             (ErrVal)ERRLKW, (ErrVal)0, "Packing failed");
3239 #endif
3240       RETVALUE(RFAILED);
3241    }
3242    CMCHKPK(SPkU8, status, mBuf);
3243    CMCHKPK(SPkU8, measType, mBuf);
3244    pst->event = (Event) LKW_EVT_L2MEAS_STOP_CFM;
3245    RETVALUE(SPstTsk(pst,mBuf));
3246 }
3247
3248 #ifdef ANSI
3249 PUBLIC S16 cmUnpkLkwL2MeasStopCfm
3250 (
3251 LkwL2MeasStopCfm func,
3252 Pst *pst,
3253 Buffer *mBuf
3254 )
3255 #else
3256 PUBLIC S16 cmUnpkLkwL2MeasStopCfm(func, pst, mBuf)
3257 LkwL2MeasStopCfm func;
3258 Pst *pst;
3259 Buffer *mBuf;
3260 #endif
3261 {
3262    U8 measType;
3263    U8 status;
3264    TRC3(cmUnpkLkwL2MeasCfm)
3265    CMCHKUNPK(SUnpkU8,  &measType, mBuf);
3266    CMCHKUNPK(SUnpkU8,  &status, mBuf);
3267    SPutMsg(mBuf);
3268    RETVALUE((*func)(pst, measType,status));
3269 }
3270 #endif /* LTE_L2_MEAS */
3271 #endif /* LCLKW */
3272
3273 \f
3274 /**********************************************************************
3275          End of file
3276  **********************************************************************/