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