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