src/cm/ckw.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /********************************************************************20**
  20
  21         Name:    CKW RRC Control Interface
  22
  23         Type:    C file
  24
  25         Desc:    This file Contains the packing and unpacking functions for
  26                  CKW Interface
  27
  28         File:    ckw.c
  29
  30 *********************************************************************21*/
  31
  32 #include "common_def.h"
  33 #include "ckw.h"
  34 #include "ckw.x"
  35 /* extern (.x) include files */
  36
  37 \f
  38 #ifdef __cplusplus
  39 EXTERN "C" {
  40 #endif  /*for extern "C"*/
  41
  42 #ifdef LCCKW
  43 /*
  44 *
  45 *    Fun:    cmPkCkwBndReq
  46 *
  47 *    Desc:    pack the primitive CkwBndReq
  48 *
  49 *    Ret:    ROK  -ok
  50 *
  51 *    Notes:    None
  52 *
  53 *    File:     ckw.c
  54 *
  55 */
  56 #ifdef ANSI
  57 PUBLIC S16 cmPkCkwBndReq
  58 (
  59 Pst *pst,
  60 SuId suId,
  61 SpId spId
  62 )
  63 #else
  64 PUBLIC S16 cmPkCkwBndReq(pst, suId, spId)
  65 Pst *pst;
  66 SuId suId;
  67 SpId spId;
  68 #endif
  69 {
  70     S16 ret1;
  71     Buffer *mBuf;
  72     mBuf = NULLP;
  73     TRC3(cmPkCkwBndReq)
  74
  75     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
  76     {
  77 #if (ERRCLASS & ERRCLS_ADD_RES)
  78        if(ret1 != ROK)
  79        {
  80           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  81                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  82                (ErrVal)ECKW001, (ErrVal)0, "SGetMsg() failed");
  83        }
  84 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
  85        RETVALUE(ret1);
  86     }
  87     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW002, pst);
  88     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW003, pst);
  89     pst->event = (Event) CKW_EVT_BND_REQ;
  90
  91     RETVALUE(SPstTsk(pst,mBuf));
  92 } /*end of function cmPkCkwBndReq*/
  93 \f
  94 /*
  95 *
  96 *    Fun:    cmPkCkwUbndReq
  97 *
  98 *    Desc:    pack the primitive CkwUbndReq
  99 *
 100 *    Ret:    ROK  -ok
 101 *
 102 *    Notes:    None
 103 *
 104 *    File:     ckw.c
 105 *
 106 */
 107 #ifdef ANSI
 108 PUBLIC S16 cmPkCkwUbndReq
 109 (
 110 Pst *pst,
 111 SpId spId,
 112 Reason reason
 113 )
 114 #else
 115 PUBLIC S16 cmPkCkwUbndReq(pst, spId, reason)
 116 Pst *pst;
 117 SpId spId;
 118 Reason reason;
 119 #endif
 120 {
 121     S16 ret1;
 122     Buffer *mBuf;
 123     mBuf = NULLP;
 124     TRC3(cmPkCkwUbndReq)
 125
 126     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 127     {
 128 #if (ERRCLASS & ERRCLS_ADD_RES)
 129        if(ret1 != ROK)
 130        {
 131           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 132                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 133                (ErrVal)ECKW004, (ErrVal)0, "SGetMsg() failed");
 134        }
 135 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 136        RETVALUE(ret1);
 137     }
 138     CMCHKPKLOG(SPkS16, reason, mBuf, ECKW005, pst);
 139     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW006, pst);
 140     pst->event = (Event) CKW_EVT_UBND_REQ;
 141
 142     RETVALUE(SPstTsk(pst,mBuf));
 143 } /*end of function cmPkCkwUbndReq*/
 144 \f
 145 /*
 146 *
 147 *    Fun:    cmPkCkwBndCfm
 148 *
 149 *    Desc:    pack the primitive CkwBndCfm
 150 *
 151 *    Ret:    ROK  -ok
 152 *
 153 *    Notes:    None
 154 *
 155 *    File:     ckw.c
 156 *
 157 */
 158 #ifdef ANSI
 159 PUBLIC S16 cmPkCkwBndCfm
 160 (
 161 Pst *pst,
 162 SuId suId,
 163 U8 status
 164 )
 165 #else
 166 PUBLIC S16 cmPkCkwBndCfm(pst, suId, status)
 167 Pst *pst;
 168 SuId suId;
 169 U8 status;
 170 #endif
 171 {
 172     S16 ret1;
 173     Buffer *mBuf;
 174     mBuf = NULLP;
 175     TRC3(cmPkCkwBndCfm)
 176
 177     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 178     {
 179 #if (ERRCLASS & ERRCLS_ADD_RES)
 180        if(ret1 != ROK)
 181        {
 182           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 183                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 184                (ErrVal)ECKW007, (ErrVal)0, "SGetMsg() failed");
 185        }
 186
 187 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 188        RETVALUE(ret1);
 189     }
 190     CMCHKPKLOG(SPkU8, status, mBuf, ECKW008, pst);
 191     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW009, pst);
 192     pst->event = (Event) CKW_EVT_BND_CFM;
 193
 194     RETVALUE(SPstTsk(pst,mBuf));
 195 } /*end of function cmPkCkwBndCfm*/
 196
 197 \f
 198 /*
 199 *
 200 *    Fun:    cmPkCkwTmInfo
 201 *
 202 *    Desc:    pack the structure CkwTmInfo
 203 *
 204 *    Ret:    ROK  -ok
 205 *
 206 *    Notes:    None
 207 *
 208 *    File:     ckw.c
 209 *
 210 */
 211 #ifdef ANSI
 212 PUBLIC S16 cmPkCkwTmInfo
 213 (
 214 CkwTmInfo      *param,
 215 Buffer         *mBuf
 216 )
 217 #else
 218 PUBLIC S16 cmPkCkwTmInfo(param, mBuf)
 219 CkwTmInfo      *param;
 220 Buffer         *mBuf;
 221 #endif
 222 {
 223     TRC3(cmPkCkwTmInfo)
 224
 225     CMCHKPK(SPkU32, param->dl.buffSize, mBuf);
 226
 227     RETVALUE(ROK);
 228 } /* cmPkCkwTmInfo */
 229
 230 \f
 231 /*
 232 *
 233 *    Fun:    cmPkCkwUmInfo
 234 *
 235 *    Desc:    pack the structure CkwUmInfo
 236 *
 237 *    Ret:    ROK  -ok
 238 *
 239 *    Notes:    None
 240 *
 241 *    File:     ckw.c
 242 *
 243 */
 244 #ifdef ANSI
 245 PUBLIC S16 cmPkCkwUmInfo
 246 (
 247 CkwEntCfgInfo  *param,
 248 Buffer         *mBuf
 249 )
 250 #else
 251 PUBLIC S16 cmPkCkwUmInfo(param, mBuf)
 252 CkwEntCfgInfo  *param;
 253 Buffer         *mBuf;
 254 #endif
 255 {
 256     TRC3(cmPkCkwUmInfo)
 257
 258     switch(param->dir)
 259     {
 260        case CKW_CFG_DIR_DL:
 261           {
 262              CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
 263              break;
 264           }
 265        case CKW_CFG_DIR_UL:
 266           {
 267              CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
 268              CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
 269              break;
 270           }
 271        /* Patch ckw_c_001.main_3 */
 272        case CKW_CFG_DIR_BOTH:
 273           {
 274              CMCHKPK(SPkU8, param->m.umInfo.dl.snLen, mBuf);
 275              CMCHKPK(SPkU8, param->m.umInfo.ul.reOrdTmr, mBuf);
 276              CMCHKPK(SPkU8, param->m.umInfo.ul.snLen, mBuf);
 277              break;
 278           }
 279     }
 280
 281     RETVALUE(ROK);
 282 } /* cmPkCkwUmInfo */
 283
 284 \f
 285 /*
 286 *
 287 *    Fun:    cmPkCkwAmInfo
 288 *
 289 *    Desc:    pack the structure CkwAmInfo
 290 *
 291 *    Ret:    ROK  -ok
 292 *
 293 *    Notes:    None
 294 *
 295 *    File:     ckw.c
 296 *
 297 */
 298 #ifdef ANSI
 299 PUBLIC S16 cmPkCkwAmInfo
 300 (
 301 CkwAmInfo      *param,
 302 Buffer         *mBuf
 303 )
 304 #else
 305 PUBLIC S16 cmPkCkwAmInfo(param, mBuf)
 306 CkwAmInfo      *param;
 307 Buffer         *mBuf;
 308 #endif
 309 {
 310     TRC3(cmPkCkwAmInfo)
 311
 312     /* UP LINK */
 313     CMCHKPK(SPkU8, param->ul.reOrdTmr, mBuf);
 314     CMCHKPK(SPkU16, param->ul.staProhTmr, mBuf);
 315     CMCHKPK(SPkU8, param->ul.snLen, mBuf);
 316
 317     /* DOWN LINK */
 318     CMCHKPK(SPkU8, param->dl.maxRetx, mBuf);
 319     CMCHKPK(SPkS32, param->dl.pollByte, mBuf);
 320     CMCHKPK(SPkS16, param->dl.pollPdu, mBuf);
 321     CMCHKPK(SPkU16, param->dl.pollRetxTmr, mBuf);
 322     CMCHKPK(SPkU8, param->dl.snLen, mBuf);
 323
 324     RETVALUE(ROK);
 325 } /* cmPkCkwAmInfo */
 326
 327 \f
 328 /*
 329 *
 330 *    Fun:    cmPkCkwLInfo
 331 *
 332 *    Desc:    pack the structure CkwLChInfo
 333 *
 334 *    Ret:    ROK  -ok
 335 *
 336 *    Notes:    None
 337 *
 338 *    File:     ckw.c
 339 *
 340 */
 341 #ifdef ANSI
 342 PUBLIC S16 cmPkCkwLChInfo
 343 (
 344 CkwLChInfo     *param,
 345 Buffer         *mBuf
 346 )
 347 #else
 348 PUBLIC S16 cmPkCkwLChInfo(param, mBuf)
 349 CkwLChInfo     *param;
 350 Buffer         *mBuf;
 351 #endif
 352 {
 353     TRC3(cmPkCkwLChInfo)
 354
 355     CMCHKPK(SPkU8, param->type, mBuf);
 356     CMCHKPK(SPkU8, param->lChId, mBuf);
 357
 358     RETVALUE(ROK);
 359 } /* cmPkCkwLChInfo */
 360
 361 \f
 362 /*
 363 *
 364 *    Fun:    cmPkCkwEntCfgInfo
 365 *
 366 *    Desc:    pack the structure CkwEntCfgInfo
 367 *
 368 *    Ret:    ROK  -ok
 369 *
 370 *    Notes:    None
 371 *
 372 *    File:     ckw.c
 373 *
 374 */
 375 #ifdef ANSI
 376 PUBLIC S16 cmPkCkwEntCfgInfo
 377 (
 378 CkwEntCfgInfo  *param,
 379 Buffer         *mBuf
 380 )
 381 #else
 382 PUBLIC S16 cmPkCkwEntCfgInfo(param, mBuf)
 383 CkwEntCfgInfo  *param;
 384 Buffer         *mBuf;
 385 #endif
 386 {
 387     TRC3(cmPkCkwEntCfgInfo)
 388
 389     switch(param->entMode)
 390     {
 391        case CM_LTE_MODE_TM:
 392           {
 393              CMCHKPK(cmPkCkwTmInfo, &(param->m.tmInfo), mBuf);
 394              break;
 395           }
 396        case CM_LTE_MODE_UM:
 397           {
 398              CMCHKPK(cmPkCkwUmInfo, param, mBuf);
 399              break;
 400           }
 401        case CM_LTE_MODE_AM:
 402           {
 403              CMCHKPK(cmPkCkwAmInfo, &(param->m.amInfo), mBuf);
 404              break;
 405           }
 406     }
 407
 408     /* Logical Channel Information */
 409     switch(param->entMode)
 410     {
 411        case CM_LTE_MODE_TM:
 412           {
 413              CMCHKPK(cmPkCkwLChInfo, &(param->lCh[0]), mBuf);
 414              break;
 415           }
 416        /* ccpu00128195: Packing lCh[0] and lCh[1] for UM bearer as well */
 417        case CM_LTE_MODE_UM:
 418        case CM_LTE_MODE_AM:
 419           {
 420              CMCHKPK(cmPkCkwLChInfo, &(param->lCh[1]), mBuf);
 421              CMCHKPK(cmPkCkwLChInfo, &(param->lCh[0]), mBuf);
 422              break;
 423           }
 424     }
 425
 426 #ifdef TENB_MULT_CELL_SUPPRT
 427     CMCHKPK(SPkS16, param->rguSapId, mBuf);
 428 #endif
 429     CMCHKPK(SPkS16, param->discardTmr, mBuf);
 430     CMCHKPK(SPkU8, param->dir, mBuf);
 431     CMCHKPK(cmPkLteRlcMode, param->entMode, mBuf);
 432     CMCHKPK(SPkU8, param->qci, mBuf);
 433     CMCHKPK(SPkU8, param->rbType, mBuf);
 434     CMCHKPK(SPkU8, param->rbId, mBuf);
 435     CMCHKPK(SPkU8, param->cfgType, mBuf);
 436
 437     RETVALUE(ROK);
 438 } /* cmPkCkwEntCfgInfo */
 439
 440 \f
 441 /*
 442 *
 443 *    Fun:    cmPkCkwCfgInfo
 444 *
 445 *    Desc:    pack the structure CkwCfgInfo
 446 *
 447 *    Ret:    ROK  -ok
 448 *
 449 *    Notes:    None
 450 *
 451 *    File:     ckw.c
 452 *
 453 */
 454 #ifdef ANSI
 455 PUBLIC S16 cmPkCkwCfgInfo
 456 (
 457 CkwCfgInfo     *param,
 458 Pst            *pst,
 459 Buffer         *mBuf
 460 )
 461 #else
 462 PUBLIC S16 cmPkCkwCfgInfo(param, pst, mBuf)
 463 CkwCfgInfo     *param;
 464 Pst            *pst;
 465 Buffer         *mBuf;
 466 #endif
 467 {
 468    S16 idx;
 469
 470    TRC3(cmPkCkwCfgInfo)
 471
 472     for (idx = param->numEnt-1; idx >= 0; idx--)
 473     {
 474        CMCHKPK(cmPkCkwEntCfgInfo, &(param->entCfg[idx]), mBuf);
 475     }
 476
 477     CMCHKPK(SPkU8, param->numEnt, mBuf);
 478     CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 479     CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
 480     CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW010, pst);
 481
 482     RETVALUE(ROK);
 483 } /* cmPkCkwCfgInfo */
 484
 485 \f
 486 /*
 487 *
 488 *    Fun:    packUeCreateReq
 489 *
 490 *    Desc:    pack the primitive UE Create Req
 491 *
 492 *    Ret:    ROK  -ok
 493 *
 494 *    Notes:    None
 495 *
 496 *    File:     ckw.c
 497 *
 498 */
 499 #ifdef ANSI
 500 PUBLIC S16 packUeCreateReq
 501 (
 502 Pst               *pst,
 503 CkwCfgInfo        *cfgInfo
 504 )
 505 #else
 506 PUBLIC S16 packUeCreateReq(pst, cfgInfo)
 507 Pst               *pst;
 508 CkwCfgInfo        *cfgInfo;
 509 #endif
 510 {
 511     S16 ret1;
 512     Buffer *mBuf;
 513     mBuf = NULLP;
 514     TRC3(packUeCreateReq)
 515
 516     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 517     {
 518 #if (ERRCLASS & ERRCLS_ADD_RES)
 519        if(ret1 != ROK)
 520        {
 521           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 522                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 523                (ErrVal)ECKW011, (ErrVal)0, "SGetMsg() failed");
 524        }
 525 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 526        RETVALUE(ret1);
 527     }
 528
 529     switch(pst->selector)
 530     {
 531        case ODU_SELECTOR_LWLC:
 532           {
 533              CMCHKPK(cmPkPtr,(PTR) cfgInfo, mBuf);
 534              break;
 535           }
 536     }
 537     pst->event = (Event) RLC_EVT_UE_CREATE_REQ;
 538
 539     RETVALUE(SPstTsk(pst,mBuf));
 540 } /* packUeCreateReq */
 541
 542 \f
 543 /*
 544 *
 545 *    Fun:    cmPkCkwEntCfgCfmInfo
 546 *
 547 *    Desc:    pack the structure CkwEntCfgInfo
 548 *
 549 *    Ret:    ROK  -ok
 550 *
 551 *    Notes:    None
 552 *
 553 *    File:     ckw.c
 554 *
 555 */
 556 #ifdef ANSI
 557 PUBLIC S16 cmPkCkwEntCfgCfmInfo
 558 (
 559 CkwEntCfgCfmInfo  *param,
 560 Buffer            *mBuf
 561 )
 562 #else
 563 PUBLIC S16 cmPkCkwEntCfgCfmInfo(param, mBuf)
 564 CkwEntCfgCfmInfo  *param;
 565 Buffer            *mBuf;
 566 #endif
 567 {
 568     TRC3(cmPkCkwEntCfgCfmInfo)
 569
 570     CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
 571     CMCHKPK(SPkU8, param->rbType, mBuf);
 572     CMCHKPK(SPkU8, param->rbId, mBuf);
 573
 574     RETVALUE(ROK);
 575 } /* cmPkCkwEntCfgCfmInfo */
 576
 577 \f
 578 /*
 579 *
 580 *    Fun:    cmPkCkwCfgCfmInfo
 581 *
 582 *    Desc:    pack the structure CkwCfgCfmInfo
 583 *
 584 *    Ret:    ROK  -ok
 585 *
 586 *    Notes:    None
 587 *
 588 *    File:     ckw.c
 589 *
 590 */
 591 #ifdef ANSI
 592 PUBLIC S16 cmPkCkwCfgCfmInfo
 593 (
 594 CkwCfgCfmInfo  *param,
 595 Pst            *pst,
 596 Buffer         *mBuf
 597 )
 598 #else
 599 PUBLIC S16 cmPkCkwCfgCfmInfo(param, pst, mBuf)
 600 CkwCfgCfmInfo  *param;
 601 Pst            *pst;
 602 Buffer         *mBuf;
 603 #endif
 604 {
 605     S16         idx;
 606
 607     TRC3(cmPkCkwCfgCfmInfo)
 608
 609     for (idx = param->numEnt-1; idx >= 0; idx--)
 610     {
 611        CMCHKPK(cmPkCkwEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
 612     }
 613
 614     CMCHKPK(SPkU8, param->numEnt, mBuf);
 615     CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 616     CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
 617     CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW014, pst);
 618
 619     RETVALUE(ROK);
 620 } /* cmPkCkwCfgCfmInfo */
 621
 622 \f
 623 /*
 624 *
 625 *    Fun:    cmPkCkwCfgCfm
 626 *
 627 *    Desc:    pack the primitive KwUiCkwCfgCfm
 628 *
 629 *    Ret:    ROK  -ok
 630 *
 631 *    Notes:    None
 632 *
 633 *    File:     ckw.c
 634 *
 635 */
 636 #ifdef ANSI
 637 PUBLIC S16 cmPkCkwCfgCfm
 638 (
 639 Pst               *pst,
 640 SuId              suId,
 641 CkwCfgCfmInfo     *cfgCfmInfo
 642 )
 643 #else
 644 PUBLIC S16 cmPkCkwCfgCfm(pst, suId, cfgCfmInfo)
 645 Pst               *pst;
 646 SuId              suId;
 647 CkwCfgCfmInfo     *cfgCfmInfo;
 648 #endif
 649 {
 650     S16 ret1;
 651     Buffer *mBuf;
 652     mBuf = NULLP;
 653     TRC3(cmPkCkwCfgCfm)
 654
 655     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 656     {
 657 #if (ERRCLASS & ERRCLS_ADD_RES)
 658        if(ret1 != ROK)
 659        {
 660           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 661                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 662                (ErrVal)ECKW015, (ErrVal)0, "SGetMsg() failed");
 663        }
 664 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 665        RETVALUE(ret1);
 666     }
 667
 668     switch(pst->selector)
 669     {
 670 #ifdef LCCKW
 671        case ODU_SELECTOR_LC:
 672           {
 673              ret1 = cmPkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
 674 #if (ERRCLASS & ERRCLS_ADD_RES)
 675              if(ret1 != ROK)
 676              {
 677                 SPutMsg(mBuf);
 678                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 679                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 680                       (ErrVal)ECKW016, (ErrVal)ret1, "Packing failure");
 681                 RETVALUE( ret1 );
 682              }
 683 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 684              if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
 685                       sizeof(CkwCfgCfmInfo)) != ROK)
 686              {
 687                 SPutMsg(mBuf);
 688                 RETVALUE(RFAILED);
 689              }
 690
 691              break;
 692           }
 693 #endif /* LCCKW */
 694     }
 695
 696     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
 697     pst->event = (Event) CKW_EVT_CFG_CFM;
 698
 699     RETVALUE(SPstTsk(pst,mBuf));
 700 } /* cmPkCkwCfgCfm */
 701
 702 /*
 703 *
 704 *    Fun:    cmPkCkwUeInfo
 705 *
 706 *    Desc:   pack the primitive KwUiCkwUeInfo
 707 *
 708 *    Ret:    ROK  -ok
 709 *
 710 *    Notes:  None
 711 *
 712 *    File:   ckw.c
 713 *
 714 */
 715 #ifdef ANSI
 716 PUBLIC S16 cmPkCkwUeInfo
 717 (
 718 CkwUeInfo *param,
 719 Buffer    *mBuf
 720 )
 721 #else
 722 PUBLIC S16 cmPkCkwUeInfo(param, mBuf)
 723 CkwUeInfo *param;
 724 Buffer    *mBuf;
 725 #endif
 726 {
 727    TRC2(cmPkCkwUeInfo)
 728
 729    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 730    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
 731
 732    RETVALUE(ROK);
 733 }
 734
 735 /*
 736 *
 737 *    Fun:    cmPkCkwUeIdChgReq
 738 *
 739 *    Desc:   pack the primitive KwUiCkwUeIdChgReq
 740 *
 741 *    Ret:    ROK  -ok
 742 *
 743 *    Notes:  None
 744 *
 745 *    File:   ckw.c
 746 *
 747 */
 748 #ifdef ANSI
 749 PUBLIC S16 cmPkCkwUeIdChgReq
 750 (
 751 Pst               *pst,
 752 SpId              spId,
 753 U32               transId,
 754 CkwUeInfo         *ueInfo,
 755 CkwUeInfo         *newUeInfo
 756 )
 757 #else
 758 PUBLIC S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
 759 Pst               *pst;
 760 SpId              spId;
 761 U32               transId;
 762 CkwUeInfo         *ueInfo;
 763 CkwUeInfo         *newUeInfo;
 764 #endif
 765 {
 766     S16    ret1;
 767     Buffer *mBuf = NULLP;
 768
 769     TRC3(cmPkCkwUeIdChgReq)
 770
 771     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 772     {
 773 #if (ERRCLASS & ERRCLS_ADD_RES)
 774        if(ret1 != ROK)
 775        {
 776           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 777                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 778                (ErrVal)ECKW018, (ErrVal)0, "SGetMsg() failed");
 779        }
 780 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 781
 782        RETVALUE(ret1);
 783     }
 784
 785     CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
 786     if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo,
 787              sizeof(CkwUeInfo)) != ROK)
 788     {
 789        SPutMsg(mBuf);
 790        RETVALUE(RFAILED);
 791     }
 792     CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
 793     if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
 794              sizeof(CkwUeInfo)) != ROK)
 795     {
 796        SPutMsg(mBuf);
 797        RETVALUE(RFAILED);
 798     }
 799     CMCHKPKLOG(SPkU32, transId, mBuf, ECKW019, pst);
 800     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW020, pst);
 801     pst->event = (Event) CKW_EVT_UEIDCHG_REQ;
 802
 803     RETVALUE(SPstTsk(pst, mBuf));
 804
 805 } /* cmPkCkwUeIdChgReq */
 806
 807 /*
 808 *
 809 *    Fun:    cmPkCkwUeIdChgCfm
 810 *
 811 *    Desc:   pack the primitive KwUiCkwUeIdChgCfm
 812 *
 813 *    Ret:    ROK  -ok
 814 *
 815 *    Notes:  None
 816 *
 817 *    File:   ckw.c
 818 *
 819 */
 820 #ifdef ANSI
 821 PUBLIC S16 cmPkCkwUeIdChgCfm
 822 (
 823 Pst               *pst,
 824 SuId              suId,
 825 U32               transId,
 826 CkwUeInfo         *ueInfo,
 827 CmStatus          status
 828 )
 829 #else
 830 PUBLIC S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
 831 Pst               *pst;
 832 SuId              suId;
 833 U32               transId;
 834 CkwUeInfo         *ueInfo;
 835 CmStatus          status;
 836 #endif
 837 {
 838     S16    ret1;
 839     Buffer *mBuf = NULLP;
 840
 841     TRC3(cmPkCkwUeIdChgCfm)
 842
 843     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 844     {
 845 #if (ERRCLASS & ERRCLS_ADD_RES)
 846        if(ret1 != ROK)
 847        {
 848           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 849                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 850                (ErrVal)ECKW021, (ErrVal)0, "SGetMsg() failed");
 851        }
 852 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 853
 854        RETVALUE(ret1);
 855     }
 856
 857     CMCHKPK(cmPkCmStatus, &status, mBuf);
 858     CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
 859     if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
 860              sizeof(CkwUeInfo)) != ROK)
 861     {
 862        SPutMsg(mBuf);
 863        RETVALUE(RFAILED);
 864     }
 865     CMCHKPKLOG(SPkU32, transId, mBuf, ECKW022, pst);
 866     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW023, pst);
 867     pst->event = (Event) CKW_EVT_UEIDCHG_CFM;
 868
 869     RETVALUE(SPstTsk(pst, mBuf));
 870
 871 } /* cmPkCkwUeIdChgCfm */
 872
 873
 874 /******************************************************************************
 875  *                            UNPACK FUNCTIONS
 876  *****************************************************************************/
 877 \f
 878 /*
 879 *
 880 *    Fun:    cmUnpkCkwBndReq
 881 *
 882 *    Desc:    unpack the primitive CkwBndReq
 883 *
 884 *    Ret:    ROK  -ok
 885 *
 886 *    Notes:    None
 887 *
 888 *    File:     ckw.c
 889 *
 890 */
 891 #ifdef ANSI
 892 PUBLIC S16 cmUnpkCkwBndReq
 893 (
 894 CkwBndReq      func,
 895 Pst            *pst,
 896 Buffer         *mBuf
 897 )
 898 #else
 899 PUBLIC S16 cmUnpkCkwBndReq(func, pst, mBuf)
 900 CkwBndReq      func;
 901 Pst            *pst;
 902 Buffer         *mBuf;
 903 #endif
 904 {
 905     SuId       suId = 0;
 906     SpId       spId = 0;
 907
 908     TRC3(cmUnpkCkwBndReq)
 909
 910     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW024, pst);
 911     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
 912     SPutMsg(mBuf);
 913
 914     RETVALUE((*func)(pst, suId, spId));
 915 } /*end of function cmUnpkCkwBndReq*/
 916 \f
 917 /*
 918 *
 919 *    Fun:    cmUnpkCkwUbndReq
 920 *
 921 *    Desc:    unpack the primitive CkwUbndReq
 922 *
 923 *    Ret:    ROK  -ok
 924 *
 925 *    Notes:    None
 926 *
 927 *    File:     ckw.c
 928 *
 929 */
 930 #ifdef ANSI
 931 PUBLIC S16 cmUnpkCkwUbndReq
 932 (
 933 CkwUbndReq     func,
 934 Pst            *pst,
 935 Buffer         *mBuf
 936 )
 937 #else
 938 PUBLIC S16 cmUnpkCkwUbndReq(func, pst, mBuf)
 939 CkwUbndReq     func;
 940 Pst            *pst;
 941 Buffer         *mBuf;
 942 #endif
 943 {
 944     SpId       spId = 0;
 945     Reason     reason = 0;
 946
 947     TRC3(cmUnpkCkwUbndReq)
 948
 949     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW026, pst);
 950     CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, ECKW027, pst);
 951     SPutMsg(mBuf);
 952     RETVALUE((*func)(pst, spId, reason));
 953 } /*end of function cmUnpkCkwUbndReq*/
 954 \f
 955 /*
 956 *
 957 *    Fun:    cmUnpkCkwBndCfm
 958 *
 959 *    Desc:    unpack the primitive CkwBndCfm
 960 *
 961 *    Ret:    ROK  -ok
 962 *
 963 *    Notes:    None
 964 *
 965 *    File:     ckw.c
 966 *
 967 */
 968 #ifdef ANSI
 969 PUBLIC S16 cmUnpkCkwBndCfm
 970 (
 971 CkwBndCfm      func,
 972 Pst            *pst,
 973 Buffer         *mBuf
 974 )
 975 #else
 976 PUBLIC S16 cmUnpkCkwBndCfm(func, pst, mBuf)
 977 CkwBndCfm      func;
 978 Pst            *pst;
 979 Buffer         *mBuf;
 980 #endif
 981 {
 982     SuId       suId = 0;
 983     U8         status = 0;
 984
 985     TRC3(cmUnpkCkwBndCfm)
 986
 987     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
 988     CMCHKUNPKLOG(SUnpkU8, &status, mBuf, ECKW029, pst);
 989     SPutMsg(mBuf);
 990
 991     RETVALUE((*func)(pst, suId, status));
 992 } /*end of function cmUnpkCkwBndCfm*/
 993
 994 \f
 995 /*
 996 *
 997 *    Fun:    cmUnpkCkwTmInfo
 998 *
 999 *    Desc:    pack the structure CkwTmInfo
1000 *
1001 *    Ret:    ROK  -ok
1002 *
1003 *    Notes:    None
1004 *
1005 *    File:     ckw.c
1006 *
1007 */
1008 #ifdef ANSI
1009 PUBLIC S16 cmUnpkCkwTmInfo
1010 (
1011 CkwTmInfo      *param,
1012 Buffer         *mBuf
1013 )
1014 #else
1015 PUBLIC S16 cmUnpkCkwTmInfo(param, mBuf)
1016 CkwTmInfo      *param;
1017 Buffer         *mBuf;
1018 #endif
1019 {
1020     TRC3(cmUnpkCkwTmInfo)
1021
1022     CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
1023
1024     RETVALUE(ROK);
1025 } /* cmUnpkCkwTmInfo */
1026
1027 \f
1028 /*
1029 *
1030 *    Fun:    cmUnpkCkwUmInfo
1031 *
1032 *    Desc:    pack the structure CkwUmInfo
1033 *
1034 *    Ret:    ROK  -ok
1035 *
1036 *    Notes:    None
1037 *
1038 *    File:     ckw.c
1039 *
1040 */
1041 #ifdef ANSI
1042 PUBLIC S16 cmUnpkCkwUmInfo
1043 (
1044 CkwEntCfgInfo  *param,
1045 Buffer         *mBuf
1046 )
1047 #else
1048 PUBLIC S16 cmUnpkCkwUmInfo(param, mBuf)
1049 CkwEntCfgInfo  *param;
1050 Buffer         *mBuf;
1051 #endif
1052 {
1053     TRC3(cmUnpkCkwUmInfo)
1054
1055     switch(param->dir)
1056     {
1057        case CKW_CFG_DIR_DL:
1058           {
1059              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1060              break;
1061           }
1062        case CKW_CFG_DIR_UL:
1063           {
1064              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1065              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1066              break;
1067           }
1068        /* Patch ckw_c_001.main_3 */
1069        case CKW_CFG_DIR_BOTH:
1070           {
1071              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1072              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1073              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1074              break;
1075           }
1076     }
1077
1078     RETVALUE(ROK);
1079 } /* cmUnpkCkwUmInfo */
1080
1081 \f
1082 /*
1083 *
1084 *    Fun:    cmUnpkCkwAmInfo
1085 *
1086 *    Desc:    pack the structure CkwAmInfo
1087 *
1088 *    Ret:    ROK  -ok
1089 *
1090 *    Notes:    None
1091 *
1092 *    File:     ckw.c
1093 *
1094 */
1095 #ifdef ANSI
1096 PUBLIC S16 cmUnpkCkwAmInfo
1097 (
1098 CkwAmInfo      *param,
1099 Buffer         *mBuf
1100 )
1101 #else
1102 PUBLIC S16 cmUnpkCkwAmInfo(param, mBuf)
1103 CkwAmInfo      *param;
1104 Buffer         *mBuf;
1105 #endif
1106 {
1107     TRC3(cmUnpkCkwAmInfo)
1108
1109     /* DOWN LINK */
1110     CMCHKUNPK(SUnpkU8, &(param->dl.snLen), mBuf);
1111     CMCHKUNPK(SUnpkU16, &(param->dl.pollRetxTmr), mBuf);
1112     CMCHKUNPK(SUnpkS16, &(param->dl.pollPdu), mBuf);
1113     CMCHKUNPK(SUnpkS32, &(param->dl.pollByte), mBuf);
1114     CMCHKUNPK(SUnpkU8, &(param->dl.maxRetx), mBuf);
1115
1116     /* UP LINK */
1117     CMCHKUNPK(SUnpkU8, &(param->ul.snLen), mBuf);
1118     CMCHKUNPK(SUnpkU16, &(param->ul.staProhTmr), mBuf);
1119     CMCHKUNPK(SUnpkU8, &(param->ul.reOrdTmr), mBuf);
1120
1121     RETVALUE(ROK);
1122 } /* cmUnpkCkwAmInfo */
1123
1124 \f
1125 /*
1126 *
1127 *    Fun:    cmUnpkCkwLChInfo
1128 *
1129 *    Desc:    pack the structure CkwLChInfo
1130 *
1131 *    Ret:    ROK  -ok
1132 *
1133 *    Notes:    None
1134 *
1135 *    File:     ckw.c
1136 *
1137 */
1138 #ifdef ANSI
1139 PUBLIC S16 cmUnpkCkwLChInfo
1140 (
1141 CkwLChInfo     *param,
1142 Buffer         *mBuf
1143 )
1144 #else
1145 PUBLIC S16 cmUnpkCkwLChInfo(param, mBuf)
1146 CkwLChInfo     *param;
1147 Buffer         *mBuf;
1148 #endif
1149 {
1150     TRC3(cmUnpkCkwLChInfo)
1151
1152     CMCHKUNPK(SUnpkU8, &(param->lChId), mBuf);
1153     CMCHKUNPK(SUnpkU8, &(param->type), mBuf);
1154
1155     RETVALUE(ROK);
1156 } /* cmUnpkCkwLChInfo */
1157
1158 \f
1159 /*
1160 *
1161 *    Fun:    cmUnpkCkwEntCfgCfmInfo
1162 *
1163 *    Desc:    unpack the structure CkwEntCfgInfo
1164 *
1165 *    Ret:    ROK  -ok
1166 *
1167 *    Notes:    None
1168 *
1169 *    File:     ckw.c
1170 *
1171 */
1172 #ifdef ANSI
1173 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo
1174 (
1175 CkwEntCfgCfmInfo  *param,
1176 Buffer            *mBuf
1177 )
1178 #else
1179 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo(param, mBuf)
1180 CkwEntCfgCfmInfo  *param;
1181 Buffer            *mBuf;
1182 #endif
1183 {
1184     TRC3(cmUnpkCkwEntCfgCfmInfo)
1185
1186     CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1187     CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1188     CMCHKUNPK(cmUnpkCmStatus, &(param->status), mBuf);
1189
1190     RETVALUE(ROK);
1191 } /* cmUnpkCkwEntCfgCfmInfo */
1192
1193 \f
1194 /*
1195 *
1196 *    Fun:    cmUnpkCkwCfgCfmInfo
1197 *
1198 *    Desc:    pack the structure CkwCfgCfmInfo
1199 *
1200 *    Ret:    ROK  -ok
1201 *
1202 *    Notes:    None
1203 *
1204 *    File:     ckw.c
1205 *
1206 */
1207 #ifdef ANSI
1208 PUBLIC S16 cmUnpkCkwCfgCfmInfo
1209 (
1210 CkwCfgCfmInfo  *param,
1211 Pst            *pst,
1212 Buffer         *mBuf
1213 )
1214 #else
1215 PUBLIC S16 cmUnpkCkwCfgCfmInfo(param, pst, mBuf)
1216 CkwCfgCfmInfo  *param;
1217 Pst            *pst;
1218 Buffer         *mBuf;
1219 #endif
1220 {
1221     U8         idx;
1222
1223     TRC3(cmUnpkCkwCfgCfmInfo)
1224
1225     CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW030, pst);
1226     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1227     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1228     CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1229
1230     for (idx = 0; idx < param->numEnt; idx++)
1231     {
1232        CMCHKUNPK(cmUnpkCkwEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
1233     }
1234
1235     RETVALUE(ROK);
1236 } /* cmUnpkCkwCfgCfmInfo */
1237
1238 \f
1239 /*
1240 *
1241 *    Fun:    cmUnpkCkwEntCfgInfo
1242 *
1243 *    Desc:    pack the structure CkwEntCfgCfmInfo
1244 *
1245 *    Ret:    ROK  -ok
1246 *
1247 *    Notes:    None
1248 *
1249 *    File:     ckw.c
1250 *
1251 */
1252 #ifdef ANSI
1253 PUBLIC S16 cmUnpkCkwEntCfgInfo
1254 (
1255 CkwEntCfgInfo  *param,
1256 Buffer         *mBuf
1257 )
1258 #else
1259 PUBLIC S16 cmUnpkCkwEntCfgInfo(param, mBuf)
1260 CkwEntCfgInfo  *param;
1261 Buffer         *mBuf;
1262 #endif
1263 {
1264     TRC3(cmUnpkCkwEntCfgInfo)
1265
1266     CMCHKUNPK(SUnpkU8, &(param->cfgType), mBuf);
1267     CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1268     CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1269     CMCHKUNPK(SUnpkU8, &(param->qci), mBuf);
1270     CMCHKUNPK(cmUnpkLteRlcMode, &(param->entMode), mBuf);
1271     CMCHKUNPK(SUnpkU8, &(param->dir), mBuf);
1272     CMCHKUNPK(SUnpkS16, &(param->discardTmr), mBuf);
1273 #ifdef TENB_MULT_CELL_SUPPRT
1274     CMCHKUNPK(SUnpkS16, &(param->rguSapId), mBuf);
1275 #endif
1276
1277     /* Logical Channel Information */
1278     switch(param->entMode)
1279     {
1280        case CM_LTE_MODE_TM:
1281           {
1282              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1283              break;
1284           }
1285        /* ccpu00128195: Unpacking lCh[0] and lCh[1] for UM bearer as well */
1286        case CM_LTE_MODE_UM:
1287        case CM_LTE_MODE_AM:
1288           {
1289              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1290              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[1]), mBuf);
1291              break;
1292           }
1293     }
1294
1295     /* TM/UM/AM Info */
1296     switch(param->entMode)
1297     {
1298        case CM_LTE_MODE_TM:
1299           {
1300              CMCHKUNPK(cmUnpkCkwTmInfo, &(param->m.tmInfo), mBuf);
1301              break;
1302           }
1303        case CM_LTE_MODE_UM:
1304           {
1305              CMCHKUNPK(cmUnpkCkwUmInfo, param, mBuf);
1306              break;
1307           }
1308        case CM_LTE_MODE_AM:
1309           {
1310              CMCHKUNPK(cmUnpkCkwAmInfo, &(param->m.amInfo), mBuf);
1311              break;
1312           }
1313     }
1314
1315     RETVALUE(ROK);
1316 } /* cmUnpkCkwEntCfgInfo */
1317
1318 \f
1319 /*
1320 *
1321 *    Fun:    cmUnpkCkwCfgInfo
1322 *
1323 *    Desc:    unpack the structure CkwCfgInfo
1324 *
1325 *    Ret:    ROK  -ok
1326 *
1327 *    Notes:    None
1328 *
1329 *    File:     ckw.c
1330 *
1331 */
1332 #ifdef ANSI
1333 PUBLIC S16 cmUnpkCkwCfgInfo
1334 (
1335 CkwCfgInfo     *param,
1336 Pst            *pst,
1337 Buffer         *mBuf
1338 )
1339 #else
1340 PUBLIC S16 cmUnpkCkwCfgInfo(param, pst, mBuf)
1341 CkwCfgInfo     *param;
1342 Pst            *pst;
1343 Buffer         *mBuf;
1344 #endif
1345 {
1346     U8         idx;
1347
1348     TRC3(cmUnpkCkwCfgInfo)
1349
1350     CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW031, pst);
1351     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1352     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1353     CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1354
1355     for (idx = 0; idx < param->numEnt; idx++)
1356     {
1357        CMCHKUNPKLOG(cmUnpkCkwEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
1358     }
1359
1360     RETVALUE(ROK);
1361 } /* cmUnpkCkwCfgInfo */
1362
1363 \f
1364 /*
1365 *
1366 *    Fun:    unpackUeCreateReq
1367 *
1368 *    Desc:    unpack the primitive UE create request
1369 *
1370 *    Ret:    ROK  -ok
1371 *
1372 *    Notes:    None
1373 *
1374 *    File:     ckw.c
1375 *
1376 */
1377 #ifdef ANSI
1378 PUBLIC S16 unpackUeCreateReq
1379 (
1380 CkwCfgReq         func,
1381 Pst               *pst,
1382 Buffer            *mBuf
1383 )
1384 #else
1385 PUBLIC S16 cmUnpkCkwCfgReq(func, pst, mBuf)
1386 CkwCfgReq         func;
1387 Pst               *pst;
1388 Buffer            *mBuf;
1389 #endif
1390 {
1391     S16 ret1;
1392     CkwCfgInfo    *cfgInfo = NULLP;
1393
1394     TRC3(unpackUeCreateReq)
1395
1396     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgInfo,\
1397                 sizeof(CkwCfgInfo))) != ROK)
1398     {
1399 #if (ERRCLASS & ERRCLS_ADD_RES)
1400       /*MBUF_FIXX*/
1401           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1402                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1403                (ErrVal)ECKW033, (ErrVal)0, "SGetMsg() failed");
1404
1405 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1406        RETVALUE(ret1);
1407     }
1408
1409     switch(pst->selector)
1410     {
1411        case ODU_SELECTOR_LWLC:
1412           {
1413              CMCHKUNPK(cmUnpkPtr,(PTR *) &cfgInfo, mBuf);
1414              break;
1415           }
1416     }
1417     SPutMsg(mBuf);
1418
1419     RETVALUE((*func)(pst, cfgInfo));
1420 } /* cmUnpkCkwCfgReq */
1421
1422 \f
1423 /*
1424 *
1425 *    Fun:    cmUnpkCkwCfgCfm
1426 *
1427 *    Desc:    unpack the primitive KwUiCkwCfgCfm
1428 *
1429 *    Ret:    ROK  -ok
1430 *
1431 *    Notes:    None
1432 *
1433 *    File:     ckw.c
1434 *
1435 */
1436 #ifdef ANSI
1437 PUBLIC S16 cmUnpkCkwCfgCfm
1438 (
1439 CkwCfgCfm         func,
1440 Pst               *pst,
1441 Buffer            *mBuf
1442 )
1443 #else
1444 PUBLIC S16 cmUnpkCkwCfgCfm(func, pst, mBuf)
1445 CkwCfgCfm         func;
1446 Pst               *pst;
1447 Buffer            *mBuf;
1448 #endif
1449 {
1450     S16 ret1;
1451     SuId             suId = 0;
1452     CkwCfgCfmInfo    *cfgCfmInfo = NULLP;
1453
1454     TRC3(cmUnpkCkwCfgCfm)
1455
1456     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
1457                 sizeof(CkwCfgCfmInfo))) != ROK)
1458     {
1459 #if (ERRCLASS & ERRCLS_ADD_RES)
1460        if(ret1 != ROK)
1461        {
1462           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1463                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1464                (ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
1465        }
1466 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1467        RETVALUE(ret1);
1468     }
1469
1470     cmMemset((U8 *)cfgCfmInfo, 0, sizeof(CkwCfgCfmInfo));
1471
1472     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1473
1474     switch(pst->selector)
1475     {
1476 #ifdef LCCKW
1477        case ODU_SELECTOR_LC:
1478        {
1479           ret1 = cmUnpkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
1480 #if(ERRCLASS & ERRCLS_DEBUG)
1481           if(ret1 != ROK)
1482           {
1483              SPutMsg(mBuf);
1484              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1485                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1486                   (ErrVal)ECKW036, (ErrVal)ret1, "Unpacking failure");
1487              RETVALUE( ret1 );
1488           }
1489 #endif /* ERRCLASS & ERRCLS_DEBUG */
1490           break;
1491        }
1492 #endif /* LCCKW */
1493     }
1494     SPutMsg(mBuf);
1495
1496     RETVALUE((*func)(pst, suId, cfgCfmInfo));
1497 } /* cmUnpkCkwCfgCfm */
1498
1499 /*
1500 *
1501 *    Fun:    cmUnpkCkwUeInfo
1502 *
1503 *    Desc:   Unpack the primitive KwUiCkwUeInfo
1504 *
1505 *    Ret:    ROK  -ok
1506 *
1507 *    Notes:  None
1508 *
1509 *    File:   ckw.c
1510 *
1511 */
1512 #ifdef ANSI
1513 PUBLIC S16 cmUnpkCkwUeInfo
1514 (
1515 CkwUeInfo *param,
1516 Buffer    *mBuf
1517 )
1518 #else
1519 PUBLIC S16 cmUnpkCkwUeInfo(param, mBuf)
1520 CkwUeInfo *param;
1521 Buffer    *mBuf;
1522 #endif
1523 {
1524    TRC2(cmUnpkCkwUeInfo)
1525
1526    CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1527    CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1528
1529    RETVALUE(ROK);
1530 }
1531
1532 /*
1533 *
1534 *    Fun:    cmUnpkCkwUeIdChgReq
1535 *
1536 *    Desc:    unpack the primitive KwUiCkwUeIdChgReq
1537 *
1538 *    Ret:    ROK  -ok
1539 *
1540 *    Notes:    None
1541 *
1542 *    File:     ckw.c
1543 *
1544 */
1545 #ifdef ANSI
1546 PUBLIC S16 cmUnpkCkwUeIdChgReq
1547 (
1548 CkwUeIdChgReq     func,
1549 Pst               *pst,
1550 Buffer            *mBuf
1551 )
1552 #else
1553 PUBLIC S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
1554 CkwUeIdChgReq     func;
1555 Pst               *pst;
1556 Buffer            *mBuf;
1557 #endif
1558 {
1559     S16       ret1;
1560     SpId      spId = 0;
1561     U32       transId = 0;
1562     CkwUeInfo *ueInfo = NULLP;
1563     CkwUeInfo *newUeInfo = NULLP;
1564
1565     TRC3(cmUnpkCkwUeIdChgReq)
1566
1567
1568     CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1569     CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW037, pst);
1570
1571     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1572                 sizeof(CkwUeInfo))) != ROK)
1573     {
1574 #if (ERRCLASS & ERRCLS_ADD_RES)
1575       /*MBUF_FIXX*/
1576           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1577                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1578                (ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
1579
1580 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1581        RETVALUE(ret1);
1582     }
1583
1584     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1585
1586     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1587 #if(ERRCLASS & ERRCLS_DEBUG)
1588     if(ret1 != ROK)
1589     {
1590        SPutMsg(mBuf);
1591        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1592              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1593              (ErrVal)ECKW039, (ErrVal)ret1, "Unpacking failure");
1594        RETVALUE( ret1 );
1595     }
1596 #endif /* ERRCLASS & ERRCLS_DEBUG */
1597
1598     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo,\
1599                 sizeof(CkwUeInfo))) != ROK)
1600     {
1601 #if (ERRCLASS & ERRCLS_ADD_RES)
1602        /*MBUF_FIXX*/
1603           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1604                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1605                (ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
1606
1607 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1608        RETVALUE(ret1);
1609     }
1610
1611     cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
1612
1613     ret1 = cmUnpkCkwUeInfo((newUeInfo), mBuf);
1614 #if(ERRCLASS & ERRCLS_DEBUG)
1615     if(ret1 != ROK)
1616     {
1617        SPutMsg(mBuf);
1618        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1619              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1620              (ErrVal)ECKW041, (ErrVal)ret1, "Unpacking failure");
1621        RETVALUE( ret1 );
1622     }
1623 #endif /* ERRCLASS & ERRCLS_DEBUG */
1624
1625     SPutMsg(mBuf);
1626
1627     RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
1628
1629 } /* cmUnpkCkwUeIdChgReq */
1630
1631 /*
1632 *
1633 *    Fun:     cmUnpkCkwUeIdChgCfm
1634 *
1635 *    Desc:    unpack the primitive KwUiCkwUeIdChgCfm
1636 *
1637 *    Ret:     ROK  -ok
1638 *
1639 *    Notes:   None
1640 *
1641 *    File:    ckw.c
1642 *
1643 */
1644 #ifdef ANSI
1645 PUBLIC S16 cmUnpkCkwUeIdChgCfm
1646 (
1647 CkwUeIdChgCfm     func,
1648 Pst               *pst,
1649 Buffer            *mBuf
1650 )
1651 #else
1652 PUBLIC S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
1653 CkwUeIdChgCfm     func;
1654 Pst               *pst;
1655 Buffer            *mBuf;
1656 #endif
1657 {
1658     S16       ret1;
1659     SuId      suId = 0;
1660     U32       transId = 0;
1661     CkwUeInfo *ueInfo = NULLP;
1662     CmStatus  status;
1663
1664     TRC3(cmUnpkCkwUeIdChgCfm)
1665
1666     cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
1667
1668     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1669     CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW042, pst);
1670
1671     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1672                 sizeof(CkwUeInfo))) != ROK)
1673     {
1674 #if (ERRCLASS & ERRCLS_ADD_RES)
1675        if(ret1 != ROK)
1676        {
1677           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1678                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1679                (ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
1680        }
1681 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1682        RETVALUE(ret1);
1683     }
1684
1685     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1686
1687     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1688 #if(ERRCLASS & ERRCLS_DEBUG)
1689     if(ret1 != ROK)
1690     {
1691        SPutMsg(mBuf);
1692        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1693              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1694              (ErrVal)ECKW044, (ErrVal)ret1, "Unpacking failure");
1695        RETVALUE( ret1 );
1696     }
1697 #endif /* ERRCLASS & ERRCLS_DEBUG */
1698
1699     CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
1700
1701     SPutMsg(mBuf);
1702
1703     RETVALUE((*func)(pst, suId, transId, ueInfo, status));
1704
1705 } /* cmUnpkCkwUeIdChgCfm */
1706
1707 #endif /* LCCKW */
1708 #ifdef __cplusplus
1709 }
1710 #endif /* __cplusplus */
1711
1712 \f
1713 /**********************************************************************
1714          End of file
1715 **********************************************************************/