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:    cmPkCkwCfgReq
 511 *
 512 *    Desc:    pack the primitive KwUiCkwCfgReq
 513 *
 514 *    Ret:    ROK  -ok
 515 *
 516 *    Notes:    None
 517 *
 518 *    File:     ckw.c
 519 *
 520 */
 521 #ifdef ANSI
 522 PUBLIC S16 cmPkCkwCfgReq
 523 (
 524 Pst               *pst,
 525 SpId              spId,
 526 CkwCfgInfo        *cfgInfo
 527 )
 528 #else
 529 PUBLIC S16 cmPkCkwCfgReq(pst, spId, cfgInfo)
 530 Pst               *pst;
 531 SpId              spId;
 532 CkwCfgInfo        *cfgInfo;
 533 #endif
 534 {
 535     S16 ret1;
 536     Buffer *mBuf;
 537     mBuf = NULLP;
 538     TRC3(cmPkCkwCfgReq)
 539
 540     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 541     {
 542 #if (ERRCLASS & ERRCLS_ADD_RES)
 543        if(ret1 != ROK)
 544        {
 545           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 546                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 547                (ErrVal)ECKW011, (ErrVal)0, "SGetMsg() failed");
 548        }
 549 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 550        RETVALUE(ret1);
 551     }
 552
 553     switch(pst->selector)
 554     {
 555 #ifdef LCCKW
 556        case CKW_SEL_LC:
 557           {
 558              ret1 = cmPkCkwCfgInfo( (cfgInfo), pst, mBuf);
 559 #if (ERRCLASS & ERRCLS_ADD_RES)
 560              if(ret1 != ROK)
 561              {
 562                 SPutMsg(mBuf);
 563                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 564                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 565                       (ErrVal)ECKW012, (ErrVal)ret1, "Packing failure");
 566                 RETVALUE( ret1 );
 567              }
 568 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 569              if (SPutSBuf(pst->region, pst->pool, (Data *)cfgInfo,
 570                       sizeof(CkwCfgInfo)) != ROK)
 571              {
 572                 SPutMsg(mBuf);
 573                 RETVALUE(RFAILED);
 574              }
 575
 576              break;
 577           }
 578 #endif /* LCCKW */
 579     }
 580
 581     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW013, pst);
 582     pst->event = (Event) CKW_EVT_CFG_REQ;
 583
 584     RETVALUE(SPstTsk(pst,mBuf));
 585 } /* cmPkCkwCfgReq */
 586
 587 \f
 588 /*
 589 *
 590 *    Fun:    cmPkCkwEntCfgCfmInfo
 591 *
 592 *    Desc:    pack the structure CkwEntCfgInfo
 593 *
 594 *    Ret:    ROK  -ok
 595 *
 596 *    Notes:    None
 597 *
 598 *    File:     ckw.c
 599 *
 600 */
 601 #ifdef ANSI
 602 PUBLIC S16 cmPkCkwEntCfgCfmInfo
 603 (
 604 CkwEntCfgCfmInfo  *param,
 605 Buffer            *mBuf
 606 )
 607 #else
 608 PUBLIC S16 cmPkCkwEntCfgCfmInfo(param, mBuf)
 609 CkwEntCfgCfmInfo  *param;
 610 Buffer            *mBuf;
 611 #endif
 612 {
 613     TRC3(cmPkCkwEntCfgCfmInfo)
 614
 615     CMCHKPK(cmPkCmStatus, &(param->status), mBuf);
 616     CMCHKPK(SPkU8, param->rbType, mBuf);
 617     CMCHKPK(SPkU8, param->rbId, mBuf);
 618
 619     RETVALUE(ROK);
 620 } /* cmPkCkwEntCfgCfmInfo */
 621
 622 \f
 623 /*
 624 *
 625 *    Fun:    cmPkCkwCfgCfmInfo
 626 *
 627 *    Desc:    pack the structure CkwCfgCfmInfo
 628 *
 629 *    Ret:    ROK  -ok
 630 *
 631 *    Notes:    None
 632 *
 633 *    File:     ckw.c
 634 *
 635 */
 636 #ifdef ANSI
 637 PUBLIC S16 cmPkCkwCfgCfmInfo
 638 (
 639 CkwCfgCfmInfo  *param,
 640 Pst            *pst,
 641 Buffer         *mBuf
 642 )
 643 #else
 644 PUBLIC S16 cmPkCkwCfgCfmInfo(param, pst, mBuf)
 645 CkwCfgCfmInfo  *param;
 646 Pst            *pst;
 647 Buffer         *mBuf;
 648 #endif
 649 {
 650     S16         idx;
 651
 652     TRC3(cmPkCkwCfgCfmInfo)
 653
 654     for (idx = param->numEnt-1; idx >= 0; idx--)
 655     {
 656        CMCHKPK(cmPkCkwEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
 657     }
 658
 659     CMCHKPK(SPkU8, param->numEnt, mBuf);
 660     CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 661     CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
 662     CMCHKPKLOG(SPkU32, param->transId, mBuf, ECKW014, pst);
 663
 664     RETVALUE(ROK);
 665 } /* cmPkCkwCfgCfmInfo */
 666
 667 \f
 668 /*
 669 *
 670 *    Fun:    cmPkCkwCfgCfm
 671 *
 672 *    Desc:    pack the primitive KwUiCkwCfgCfm
 673 *
 674 *    Ret:    ROK  -ok
 675 *
 676 *    Notes:    None
 677 *
 678 *    File:     ckw.c
 679 *
 680 */
 681 #ifdef ANSI
 682 PUBLIC S16 cmPkCkwCfgCfm
 683 (
 684 Pst               *pst,
 685 SuId              suId,
 686 CkwCfgCfmInfo     *cfgCfmInfo
 687 )
 688 #else
 689 PUBLIC S16 cmPkCkwCfgCfm(pst, suId, cfgCfmInfo)
 690 Pst               *pst;
 691 SuId              suId;
 692 CkwCfgCfmInfo     *cfgCfmInfo;
 693 #endif
 694 {
 695     S16 ret1;
 696     Buffer *mBuf;
 697     mBuf = NULLP;
 698     TRC3(cmPkCkwCfgCfm)
 699
 700     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 701     {
 702 #if (ERRCLASS & ERRCLS_ADD_RES)
 703        if(ret1 != ROK)
 704        {
 705           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 706                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 707                (ErrVal)ECKW015, (ErrVal)0, "SGetMsg() failed");
 708        }
 709 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 710        RETVALUE(ret1);
 711     }
 712
 713     switch(pst->selector)
 714     {
 715 #ifdef LCCKW
 716        case CKW_SEL_LC:
 717           {
 718              ret1 = cmPkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
 719 #if (ERRCLASS & ERRCLS_ADD_RES)
 720              if(ret1 != ROK)
 721              {
 722                 SPutMsg(mBuf);
 723                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 724                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 725                       (ErrVal)ECKW016, (ErrVal)ret1, "Packing failure");
 726                 RETVALUE( ret1 );
 727              }
 728 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 729              if (SPutSBuf(pst->region, pst->pool, (Data *)cfgCfmInfo,
 730                       sizeof(CkwCfgCfmInfo)) != ROK)
 731              {
 732                 SPutMsg(mBuf);
 733                 RETVALUE(RFAILED);
 734              }
 735
 736              break;
 737           }
 738 #endif /* LCCKW */
 739     }
 740
 741     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW017, pst);
 742     pst->event = (Event) CKW_EVT_CFG_CFM;
 743
 744     RETVALUE(SPstTsk(pst,mBuf));
 745 } /* cmPkCkwCfgCfm */
 746
 747 /*
 748 *
 749 *    Fun:    cmPkCkwUeInfo
 750 *
 751 *    Desc:   pack the primitive KwUiCkwUeInfo
 752 *
 753 *    Ret:    ROK  -ok
 754 *
 755 *    Notes:  None
 756 *
 757 *    File:   ckw.c
 758 *
 759 */
 760 #ifdef ANSI
 761 PUBLIC S16 cmPkCkwUeInfo
 762 (
 763 CkwUeInfo *param,
 764 Buffer    *mBuf
 765 )
 766 #else
 767 PUBLIC S16 cmPkCkwUeInfo(param, mBuf)
 768 CkwUeInfo *param;
 769 Buffer    *mBuf;
 770 #endif
 771 {
 772    TRC2(cmPkCkwUeInfo)
 773
 774    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 775    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
 776
 777    RETVALUE(ROK);
 778 }
 779
 780 /*
 781 *
 782 *    Fun:    cmPkCkwUeIdChgReq
 783 *
 784 *    Desc:   pack the primitive KwUiCkwUeIdChgReq
 785 *
 786 *    Ret:    ROK  -ok
 787 *
 788 *    Notes:  None
 789 *
 790 *    File:   ckw.c
 791 *
 792 */
 793 #ifdef ANSI
 794 PUBLIC S16 cmPkCkwUeIdChgReq
 795 (
 796 Pst               *pst,
 797 SpId              spId,
 798 U32               transId,
 799 CkwUeInfo         *ueInfo,
 800 CkwUeInfo         *newUeInfo
 801 )
 802 #else
 803 PUBLIC S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
 804 Pst               *pst;
 805 SpId              spId;
 806 U32               transId;
 807 CkwUeInfo         *ueInfo;
 808 CkwUeInfo         *newUeInfo;
 809 #endif
 810 {
 811     S16    ret1;
 812     Buffer *mBuf = NULLP;
 813
 814     TRC3(cmPkCkwUeIdChgReq)
 815
 816     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 817     {
 818 #if (ERRCLASS & ERRCLS_ADD_RES)
 819        if(ret1 != ROK)
 820        {
 821           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 822                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 823                (ErrVal)ECKW018, (ErrVal)0, "SGetMsg() failed");
 824        }
 825 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 826
 827        RETVALUE(ret1);
 828     }
 829
 830     CMCHKPK(cmPkCkwUeInfo, newUeInfo, mBuf);
 831     if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo,
 832              sizeof(CkwUeInfo)) != ROK)
 833     {
 834        SPutMsg(mBuf);
 835        RETVALUE(RFAILED);
 836     }
 837     CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
 838     if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
 839              sizeof(CkwUeInfo)) != ROK)
 840     {
 841        SPutMsg(mBuf);
 842        RETVALUE(RFAILED);
 843     }
 844     CMCHKPKLOG(SPkU32, transId, mBuf, ECKW019, pst);
 845     CMCHKPKLOG(SPkS16, spId, mBuf, ECKW020, pst);
 846     pst->event = (Event) CKW_EVT_UEIDCHG_REQ;
 847
 848     RETVALUE(SPstTsk(pst, mBuf));
 849
 850 } /* cmPkCkwUeIdChgReq */
 851
 852 /*
 853 *
 854 *    Fun:    cmPkCkwUeIdChgCfm
 855 *
 856 *    Desc:   pack the primitive KwUiCkwUeIdChgCfm
 857 *
 858 *    Ret:    ROK  -ok
 859 *
 860 *    Notes:  None
 861 *
 862 *    File:   ckw.c
 863 *
 864 */
 865 #ifdef ANSI
 866 PUBLIC S16 cmPkCkwUeIdChgCfm
 867 (
 868 Pst               *pst,
 869 SuId              suId,
 870 U32               transId,
 871 CkwUeInfo         *ueInfo,
 872 CmStatus          status
 873 )
 874 #else
 875 PUBLIC S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
 876 Pst               *pst;
 877 SuId              suId;
 878 U32               transId;
 879 CkwUeInfo         *ueInfo;
 880 CmStatus          status;
 881 #endif
 882 {
 883     S16    ret1;
 884     Buffer *mBuf = NULLP;
 885
 886     TRC3(cmPkCkwUeIdChgCfm)
 887
 888     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 889     {
 890 #if (ERRCLASS & ERRCLS_ADD_RES)
 891        if(ret1 != ROK)
 892        {
 893           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 894                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 895                (ErrVal)ECKW021, (ErrVal)0, "SGetMsg() failed");
 896        }
 897 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 898
 899        RETVALUE(ret1);
 900     }
 901
 902     CMCHKPK(cmPkCmStatus, &status, mBuf);
 903     CMCHKPK(cmPkCkwUeInfo, ueInfo, mBuf);
 904     if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo,
 905              sizeof(CkwUeInfo)) != ROK)
 906     {
 907        SPutMsg(mBuf);
 908        RETVALUE(RFAILED);
 909     }
 910     CMCHKPKLOG(SPkU32, transId, mBuf, ECKW022, pst);
 911     CMCHKPKLOG(SPkS16, suId, mBuf, ECKW023, pst);
 912     pst->event = (Event) CKW_EVT_UEIDCHG_CFM;
 913
 914     RETVALUE(SPstTsk(pst, mBuf));
 915
 916 } /* cmPkCkwUeIdChgCfm */
 917
 918
 919 /******************************************************************************
 920  *                            UNPACK FUNCTIONS
 921  *****************************************************************************/
 922 \f
 923 /*
 924 *
 925 *    Fun:    cmUnpkCkwBndReq
 926 *
 927 *    Desc:    unpack the primitive CkwBndReq
 928 *
 929 *    Ret:    ROK  -ok
 930 *
 931 *    Notes:    None
 932 *
 933 *    File:     ckw.c
 934 *
 935 */
 936 #ifdef ANSI
 937 PUBLIC S16 cmUnpkCkwBndReq
 938 (
 939 CkwBndReq      func,
 940 Pst            *pst,
 941 Buffer         *mBuf
 942 )
 943 #else
 944 PUBLIC S16 cmUnpkCkwBndReq(func, pst, mBuf)
 945 CkwBndReq      func;
 946 Pst            *pst;
 947 Buffer         *mBuf;
 948 #endif
 949 {
 950     SuId       suId = 0;
 951     SpId       spId = 0;
 952
 953     TRC3(cmUnpkCkwBndReq)
 954
 955     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW024, pst);
 956     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW025, pst);
 957     SPutMsg(mBuf);
 958
 959     RETVALUE((*func)(pst, suId, spId));
 960 } /*end of function cmUnpkCkwBndReq*/
 961 \f
 962 /*
 963 *
 964 *    Fun:    cmUnpkCkwUbndReq
 965 *
 966 *    Desc:    unpack the primitive CkwUbndReq
 967 *
 968 *    Ret:    ROK  -ok
 969 *
 970 *    Notes:    None
 971 *
 972 *    File:     ckw.c
 973 *
 974 */
 975 #ifdef ANSI
 976 PUBLIC S16 cmUnpkCkwUbndReq
 977 (
 978 CkwUbndReq     func,
 979 Pst            *pst,
 980 Buffer         *mBuf
 981 )
 982 #else
 983 PUBLIC S16 cmUnpkCkwUbndReq(func, pst, mBuf)
 984 CkwUbndReq     func;
 985 Pst            *pst;
 986 Buffer         *mBuf;
 987 #endif
 988 {
 989     SpId       spId = 0;
 990     Reason     reason = 0;
 991
 992     TRC3(cmUnpkCkwUbndReq)
 993
 994     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, ECKW026, pst);
 995     CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, ECKW027, pst);
 996     SPutMsg(mBuf);
 997     RETVALUE((*func)(pst, spId, reason));
 998 } /*end of function cmUnpkCkwUbndReq*/
 999 \f
1000 /*
1001 *
1002 *    Fun:    cmUnpkCkwBndCfm
1003 *
1004 *    Desc:    unpack the primitive CkwBndCfm
1005 *
1006 *    Ret:    ROK  -ok
1007 *
1008 *    Notes:    None
1009 *
1010 *    File:     ckw.c
1011 *
1012 */
1013 #ifdef ANSI
1014 PUBLIC S16 cmUnpkCkwBndCfm
1015 (
1016 CkwBndCfm      func,
1017 Pst            *pst,
1018 Buffer         *mBuf
1019 )
1020 #else
1021 PUBLIC S16 cmUnpkCkwBndCfm(func, pst, mBuf)
1022 CkwBndCfm      func;
1023 Pst            *pst;
1024 Buffer         *mBuf;
1025 #endif
1026 {
1027     SuId       suId = 0;
1028     U8         status = 0;
1029
1030     TRC3(cmUnpkCkwBndCfm)
1031
1032     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
1033     CMCHKUNPKLOG(SUnpkU8, &status, mBuf, ECKW029, pst);
1034     SPutMsg(mBuf);
1035
1036     RETVALUE((*func)(pst, suId, status));
1037 } /*end of function cmUnpkCkwBndCfm*/
1038
1039 \f
1040 /*
1041 *
1042 *    Fun:    cmUnpkCkwTmInfo
1043 *
1044 *    Desc:    pack the structure CkwTmInfo
1045 *
1046 *    Ret:    ROK  -ok
1047 *
1048 *    Notes:    None
1049 *
1050 *    File:     ckw.c
1051 *
1052 */
1053 #ifdef ANSI
1054 PUBLIC S16 cmUnpkCkwTmInfo
1055 (
1056 CkwTmInfo      *param,
1057 Buffer         *mBuf
1058 )
1059 #else
1060 PUBLIC S16 cmUnpkCkwTmInfo(param, mBuf)
1061 CkwTmInfo      *param;
1062 Buffer         *mBuf;
1063 #endif
1064 {
1065     TRC3(cmUnpkCkwTmInfo)
1066
1067     CMCHKUNPK(SUnpkU32, &(param->dl.buffSize), mBuf);
1068
1069     RETVALUE(ROK);
1070 } /* cmUnpkCkwTmInfo */
1071
1072 \f
1073 /*
1074 *
1075 *    Fun:    cmUnpkCkwUmInfo
1076 *
1077 *    Desc:    pack the structure CkwUmInfo
1078 *
1079 *    Ret:    ROK  -ok
1080 *
1081 *    Notes:    None
1082 *
1083 *    File:     ckw.c
1084 *
1085 */
1086 #ifdef ANSI
1087 PUBLIC S16 cmUnpkCkwUmInfo
1088 (
1089 CkwEntCfgInfo  *param,
1090 Buffer         *mBuf
1091 )
1092 #else
1093 PUBLIC S16 cmUnpkCkwUmInfo(param, mBuf)
1094 CkwEntCfgInfo  *param;
1095 Buffer         *mBuf;
1096 #endif
1097 {
1098     TRC3(cmUnpkCkwUmInfo)
1099
1100     switch(param->dir)
1101     {
1102        case CKW_CFG_DIR_DL:
1103           {
1104              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1105              break;
1106           }
1107        case CKW_CFG_DIR_UL:
1108           {
1109              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1110              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1111              break;
1112           }
1113        /* Patch ckw_c_001.main_3 */
1114        case CKW_CFG_DIR_BOTH:
1115           {
1116              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.snLen), mBuf);
1117              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.ul.reOrdTmr), mBuf);
1118              CMCHKUNPK(SUnpkU8, &(param->m.umInfo.dl.snLen), mBuf);
1119              break;
1120           }
1121     }
1122
1123     RETVALUE(ROK);
1124 } /* cmUnpkCkwUmInfo */
1125
1126 \f
1127 /*
1128 *
1129 *    Fun:    cmUnpkCkwAmInfo
1130 *
1131 *    Desc:    pack the structure CkwAmInfo
1132 *
1133 *    Ret:    ROK  -ok
1134 *
1135 *    Notes:    None
1136 *
1137 *    File:     ckw.c
1138 *
1139 */
1140 #ifdef ANSI
1141 PUBLIC S16 cmUnpkCkwAmInfo
1142 (
1143 CkwAmInfo      *param,
1144 Buffer         *mBuf
1145 )
1146 #else
1147 PUBLIC S16 cmUnpkCkwAmInfo(param, mBuf)
1148 CkwAmInfo      *param;
1149 Buffer         *mBuf;
1150 #endif
1151 {
1152     TRC3(cmUnpkCkwAmInfo)
1153
1154     /* DOWN LINK */
1155     CMCHKUNPK(SUnpkU8, &(param->dl.snLen), mBuf);
1156     CMCHKUNPK(SUnpkU16, &(param->dl.pollRetxTmr), mBuf);
1157     CMCHKUNPK(SUnpkS16, &(param->dl.pollPdu), mBuf);
1158     CMCHKUNPK(SUnpkS32, &(param->dl.pollByte), mBuf);
1159     CMCHKUNPK(SUnpkU8, &(param->dl.maxRetx), mBuf);
1160
1161     /* UP LINK */
1162     CMCHKUNPK(SUnpkU8, &(param->ul.snLen), mBuf);
1163     CMCHKUNPK(SUnpkU16, &(param->ul.staProhTmr), mBuf);
1164     CMCHKUNPK(SUnpkU8, &(param->ul.reOrdTmr), mBuf);
1165
1166     RETVALUE(ROK);
1167 } /* cmUnpkCkwAmInfo */
1168
1169 \f
1170 /*
1171 *
1172 *    Fun:    cmUnpkCkwLChInfo
1173 *
1174 *    Desc:    pack the structure CkwLChInfo
1175 *
1176 *    Ret:    ROK  -ok
1177 *
1178 *    Notes:    None
1179 *
1180 *    File:     ckw.c
1181 *
1182 */
1183 #ifdef ANSI
1184 PUBLIC S16 cmUnpkCkwLChInfo
1185 (
1186 CkwLChInfo     *param,
1187 Buffer         *mBuf
1188 )
1189 #else
1190 PUBLIC S16 cmUnpkCkwLChInfo(param, mBuf)
1191 CkwLChInfo     *param;
1192 Buffer         *mBuf;
1193 #endif
1194 {
1195     TRC3(cmUnpkCkwLChInfo)
1196
1197     CMCHKUNPK(SUnpkU8, &(param->lChId), mBuf);
1198     CMCHKUNPK(SUnpkU8, &(param->type), mBuf);
1199
1200     RETVALUE(ROK);
1201 } /* cmUnpkCkwLChInfo */
1202
1203 \f
1204 /*
1205 *
1206 *    Fun:    cmUnpkCkwEntCfgCfmInfo
1207 *
1208 *    Desc:    unpack the structure CkwEntCfgInfo
1209 *
1210 *    Ret:    ROK  -ok
1211 *
1212 *    Notes:    None
1213 *
1214 *    File:     ckw.c
1215 *
1216 */
1217 #ifdef ANSI
1218 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo
1219 (
1220 CkwEntCfgCfmInfo  *param,
1221 Buffer            *mBuf
1222 )
1223 #else
1224 PUBLIC S16 cmUnpkCkwEntCfgCfmInfo(param, mBuf)
1225 CkwEntCfgCfmInfo  *param;
1226 Buffer            *mBuf;
1227 #endif
1228 {
1229     TRC3(cmUnpkCkwEntCfgCfmInfo)
1230
1231     CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1232     CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1233     CMCHKUNPK(cmUnpkCmStatus, &(param->status), mBuf);
1234
1235     RETVALUE(ROK);
1236 } /* cmUnpkCkwEntCfgCfmInfo */
1237
1238 \f
1239 /*
1240 *
1241 *    Fun:    cmUnpkCkwCfgCfmInfo
1242 *
1243 *    Desc:    pack the structure CkwCfgCfmInfo
1244 *
1245 *    Ret:    ROK  -ok
1246 *
1247 *    Notes:    None
1248 *
1249 *    File:     ckw.c
1250 *
1251 */
1252 #ifdef ANSI
1253 PUBLIC S16 cmUnpkCkwCfgCfmInfo
1254 (
1255 CkwCfgCfmInfo  *param,
1256 Pst            *pst,
1257 Buffer         *mBuf
1258 )
1259 #else
1260 PUBLIC S16 cmUnpkCkwCfgCfmInfo(param, pst, mBuf)
1261 CkwCfgCfmInfo  *param;
1262 Pst            *pst;
1263 Buffer         *mBuf;
1264 #endif
1265 {
1266     U8         idx;
1267
1268     TRC3(cmUnpkCkwCfgCfmInfo)
1269
1270     CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW030, pst);
1271     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1272     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1273     CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1274
1275     for (idx = 0; idx < param->numEnt; idx++)
1276     {
1277        CMCHKUNPK(cmUnpkCkwEntCfgCfmInfo, &(param->entCfgCfm[idx]), mBuf);
1278     }
1279
1280     RETVALUE(ROK);
1281 } /* cmUnpkCkwCfgCfmInfo */
1282
1283 \f
1284 /*
1285 *
1286 *    Fun:    cmUnpkCkwEntCfgInfo
1287 *
1288 *    Desc:    pack the structure CkwEntCfgCfmInfo
1289 *
1290 *    Ret:    ROK  -ok
1291 *
1292 *    Notes:    None
1293 *
1294 *    File:     ckw.c
1295 *
1296 */
1297 #ifdef ANSI
1298 PUBLIC S16 cmUnpkCkwEntCfgInfo
1299 (
1300 CkwEntCfgInfo  *param,
1301 Buffer         *mBuf
1302 )
1303 #else
1304 PUBLIC S16 cmUnpkCkwEntCfgInfo(param, mBuf)
1305 CkwEntCfgInfo  *param;
1306 Buffer         *mBuf;
1307 #endif
1308 {
1309     TRC3(cmUnpkCkwEntCfgInfo)
1310
1311     CMCHKUNPK(SUnpkU8, &(param->cfgType), mBuf);
1312     CMCHKUNPK(SUnpkU8, &(param->rbId), mBuf);
1313     CMCHKUNPK(SUnpkU8, &(param->rbType), mBuf);
1314     CMCHKUNPK(SUnpkU8, &(param->qci), mBuf);
1315     CMCHKUNPK(cmUnpkLteRlcMode, &(param->entMode), mBuf);
1316     CMCHKUNPK(SUnpkU8, &(param->dir), mBuf);
1317     CMCHKUNPK(SUnpkS16, &(param->discardTmr), mBuf);
1318 #ifdef TENB_MULT_CELL_SUPPRT
1319     CMCHKUNPK(SUnpkS16, &(param->rguSapId), mBuf);
1320 #endif
1321
1322     /* Logical Channel Information */
1323     switch(param->entMode)
1324     {
1325        case CM_LTE_MODE_TM:
1326           {
1327              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1328              break;
1329           }
1330        /* ccpu00128195: Unpacking lCh[0] and lCh[1] for UM bearer as well */
1331        case CM_LTE_MODE_UM:
1332        case CM_LTE_MODE_AM:
1333           {
1334              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[0]), mBuf);
1335              CMCHKUNPK(cmUnpkCkwLChInfo, &(param->lCh[1]), mBuf);
1336              break;
1337           }
1338     }
1339
1340     /* TM/UM/AM Info */
1341     switch(param->entMode)
1342     {
1343        case CM_LTE_MODE_TM:
1344           {
1345              CMCHKUNPK(cmUnpkCkwTmInfo, &(param->m.tmInfo), mBuf);
1346              break;
1347           }
1348        case CM_LTE_MODE_UM:
1349           {
1350              CMCHKUNPK(cmUnpkCkwUmInfo, param, mBuf);
1351              break;
1352           }
1353        case CM_LTE_MODE_AM:
1354           {
1355              CMCHKUNPK(cmUnpkCkwAmInfo, &(param->m.amInfo), mBuf);
1356              break;
1357           }
1358     }
1359
1360     RETVALUE(ROK);
1361 } /* cmUnpkCkwEntCfgInfo */
1362
1363 \f
1364 /*
1365 *
1366 *    Fun:    cmUnpkCkwCfgInfo
1367 *
1368 *    Desc:    unpack the structure CkwCfgInfo
1369 *
1370 *    Ret:    ROK  -ok
1371 *
1372 *    Notes:    None
1373 *
1374 *    File:     ckw.c
1375 *
1376 */
1377 #ifdef ANSI
1378 PUBLIC S16 cmUnpkCkwCfgInfo
1379 (
1380 CkwCfgInfo     *param,
1381 Pst            *pst,
1382 Buffer         *mBuf
1383 )
1384 #else
1385 PUBLIC S16 cmUnpkCkwCfgInfo(param, pst, mBuf)
1386 CkwCfgInfo     *param;
1387 Pst            *pst;
1388 Buffer         *mBuf;
1389 #endif
1390 {
1391     U8         idx;
1392
1393     TRC3(cmUnpkCkwCfgInfo)
1394
1395     CMCHKUNPKLOG(SUnpkU32, &(param->transId), mBuf, ECKW031, pst);
1396     CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1397     CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1398     CMCHKUNPK(SUnpkU8, &(param->numEnt), mBuf);
1399
1400     for (idx = 0; idx < param->numEnt; idx++)
1401     {
1402        CMCHKUNPKLOG(cmUnpkCkwEntCfgInfo,&(param->entCfg[idx]), mBuf, ECKW032, pst);
1403     }
1404
1405     RETVALUE(ROK);
1406 } /* cmUnpkCkwCfgInfo */
1407
1408 \f
1409 /*
1410 *
1411 *    Fun:    cmUnpkCkwCfgReq
1412 *
1413 *    Desc:    unpack the primitive KwUiCkwCfgReq
1414 *
1415 *    Ret:    ROK  -ok
1416 *
1417 *    Notes:    None
1418 *
1419 *    File:     ckw.c
1420 *
1421 */
1422 #ifdef ANSI
1423 PUBLIC S16 cmUnpkCkwCfgReq
1424 (
1425 CkwCfgReq         func,
1426 Pst               *pst,
1427 Buffer            *mBuf
1428 )
1429 #else
1430 PUBLIC S16 cmUnpkCkwCfgReq(func, pst, mBuf)
1431 CkwCfgReq         func;
1432 Pst               *pst;
1433 Buffer            *mBuf;
1434 #endif
1435 {
1436     S16 ret1;
1437     SpId          spId = 0;
1438     CkwCfgInfo    *cfgInfo = NULLP;
1439
1440     TRC3(cmUnpkCkwCfgReq)
1441
1442     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgInfo,\
1443                 sizeof(CkwCfgInfo))) != ROK)
1444     {
1445 #if (ERRCLASS & ERRCLS_ADD_RES)
1446       /*MBUF_FIXX*/
1447           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1448                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1449                (ErrVal)ECKW033, (ErrVal)0, "SGetMsg() failed");
1450
1451 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1452        RETVALUE(ret1);
1453     }
1454
1455     cmMemset((U8 *)cfgInfo, 0, sizeof(CkwCfgInfo));
1456
1457     CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1458     switch(pst->selector)
1459     {
1460 #ifdef LCCKW
1461        case CKW_SEL_LC:
1462        {
1463           ret1 = cmUnpkCkwCfgInfo( (cfgInfo), pst, mBuf);
1464 #if(ERRCLASS & ERRCLS_DEBUG)
1465           if(ret1 != ROK)
1466           {
1467              SPutMsg(mBuf);
1468              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1469                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1470                   (ErrVal)ECKW034, (ErrVal)ret1, "Unpacking failure");
1471              RETVALUE( ret1 );
1472           }
1473 #endif /* ERRCLASS & ERRCLS_DEBUG */
1474           break;
1475        }
1476 #endif /* LCCKW */
1477     }
1478     SPutMsg(mBuf);
1479
1480     RETVALUE((*func)(pst, spId, cfgInfo));
1481 } /* cmUnpkCkwCfgReq */
1482
1483 \f
1484 /*
1485 *
1486 *    Fun:    cmUnpkCkwCfgCfm
1487 *
1488 *    Desc:    unpack the primitive KwUiCkwCfgCfm
1489 *
1490 *    Ret:    ROK  -ok
1491 *
1492 *    Notes:    None
1493 *
1494 *    File:     ckw.c
1495 *
1496 */
1497 #ifdef ANSI
1498 PUBLIC S16 cmUnpkCkwCfgCfm
1499 (
1500 CkwCfgCfm         func,
1501 Pst               *pst,
1502 Buffer            *mBuf
1503 )
1504 #else
1505 PUBLIC S16 cmUnpkCkwCfgCfm(func, pst, mBuf)
1506 CkwCfgCfm         func;
1507 Pst               *pst;
1508 Buffer            *mBuf;
1509 #endif
1510 {
1511     S16 ret1;
1512     SuId             suId = 0;
1513     CkwCfgCfmInfo    *cfgCfmInfo = NULLP;
1514
1515     TRC3(cmUnpkCkwCfgCfm)
1516
1517     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
1518                 sizeof(CkwCfgCfmInfo))) != ROK)
1519     {
1520 #if (ERRCLASS & ERRCLS_ADD_RES)
1521        if(ret1 != ROK)
1522        {
1523           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1524                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1525                (ErrVal)ECKW035, (ErrVal)0, "SGetMsg() failed");
1526        }
1527 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1528        RETVALUE(ret1);
1529     }
1530
1531     cmMemset((U8 *)cfgCfmInfo, 0, sizeof(CkwCfgCfmInfo));
1532
1533     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1534
1535     switch(pst->selector)
1536     {
1537 #ifdef LCCKW
1538        case CKW_SEL_LC:
1539        {
1540           ret1 = cmUnpkCkwCfgCfmInfo( (cfgCfmInfo), pst, mBuf);
1541 #if(ERRCLASS & ERRCLS_DEBUG)
1542           if(ret1 != ROK)
1543           {
1544              SPutMsg(mBuf);
1545              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1546                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1547                   (ErrVal)ECKW036, (ErrVal)ret1, "Unpacking failure");
1548              RETVALUE( ret1 );
1549           }
1550 #endif /* ERRCLASS & ERRCLS_DEBUG */
1551           break;
1552        }
1553 #endif /* LCCKW */
1554     }
1555     SPutMsg(mBuf);
1556
1557     RETVALUE((*func)(pst, suId, cfgCfmInfo));
1558 } /* cmUnpkCkwCfgCfm */
1559
1560 /*
1561 *
1562 *    Fun:    cmUnpkCkwUeInfo
1563 *
1564 *    Desc:   Unpack the primitive KwUiCkwUeInfo
1565 *
1566 *    Ret:    ROK  -ok
1567 *
1568 *    Notes:  None
1569 *
1570 *    File:   ckw.c
1571 *
1572 */
1573 #ifdef ANSI
1574 PUBLIC S16 cmUnpkCkwUeInfo
1575 (
1576 CkwUeInfo *param,
1577 Buffer    *mBuf
1578 )
1579 #else
1580 PUBLIC S16 cmUnpkCkwUeInfo(param, mBuf)
1581 CkwUeInfo *param;
1582 Buffer    *mBuf;
1583 #endif
1584 {
1585    TRC2(cmUnpkCkwUeInfo)
1586
1587    CMCHKUNPK(cmUnpkLteRnti, &(param->ueId), mBuf);
1588    CMCHKUNPK(cmUnpkLteCellId, &(param->cellId), mBuf);
1589
1590    RETVALUE(ROK);
1591 }
1592
1593 /*
1594 *
1595 *    Fun:    cmUnpkCkwUeIdChgReq
1596 *
1597 *    Desc:    unpack the primitive KwUiCkwUeIdChgReq
1598 *
1599 *    Ret:    ROK  -ok
1600 *
1601 *    Notes:    None
1602 *
1603 *    File:     ckw.c
1604 *
1605 */
1606 #ifdef ANSI
1607 PUBLIC S16 cmUnpkCkwUeIdChgReq
1608 (
1609 CkwUeIdChgReq     func,
1610 Pst               *pst,
1611 Buffer            *mBuf
1612 )
1613 #else
1614 PUBLIC S16 cmUnpkCkwUeIdChgReq(func, pst, mBuf)
1615 CkwUeIdChgReq     func;
1616 Pst               *pst;
1617 Buffer            *mBuf;
1618 #endif
1619 {
1620     S16       ret1;
1621     SpId      spId = 0;
1622     U32       transId = 0;
1623     CkwUeInfo *ueInfo = NULLP;
1624     CkwUeInfo *newUeInfo = NULLP;
1625
1626     TRC3(cmUnpkCkwUeIdChgReq)
1627
1628
1629     CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1630     CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW037, pst);
1631
1632     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1633                 sizeof(CkwUeInfo))) != ROK)
1634     {
1635 #if (ERRCLASS & ERRCLS_ADD_RES)
1636       /*MBUF_FIXX*/
1637           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1638                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1639                (ErrVal)ECKW038, (ErrVal)0, "SGetMsg() failed");
1640
1641 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1642        RETVALUE(ret1);
1643     }
1644
1645     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1646
1647     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1648 #if(ERRCLASS & ERRCLS_DEBUG)
1649     if(ret1 != ROK)
1650     {
1651        SPutMsg(mBuf);
1652        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1653              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1654              (ErrVal)ECKW039, (ErrVal)ret1, "Unpacking failure");
1655        RETVALUE( ret1 );
1656     }
1657 #endif /* ERRCLASS & ERRCLS_DEBUG */
1658
1659     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo,\
1660                 sizeof(CkwUeInfo))) != ROK)
1661     {
1662 #if (ERRCLASS & ERRCLS_ADD_RES)
1663        /*MBUF_FIXX*/
1664           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1665                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1666                (ErrVal)ECKW040, (ErrVal)0, "SGetMsg() failed");
1667
1668 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1669        RETVALUE(ret1);
1670     }
1671
1672     cmMemset((U8 *)newUeInfo, 0, sizeof(CkwUeInfo));
1673
1674     ret1 = cmUnpkCkwUeInfo((newUeInfo), mBuf);
1675 #if(ERRCLASS & ERRCLS_DEBUG)
1676     if(ret1 != ROK)
1677     {
1678        SPutMsg(mBuf);
1679        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1680              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1681              (ErrVal)ECKW041, (ErrVal)ret1, "Unpacking failure");
1682        RETVALUE( ret1 );
1683     }
1684 #endif /* ERRCLASS & ERRCLS_DEBUG */
1685
1686     SPutMsg(mBuf);
1687
1688     RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
1689
1690 } /* cmUnpkCkwUeIdChgReq */
1691
1692 /*
1693 *
1694 *    Fun:     cmUnpkCkwUeIdChgCfm
1695 *
1696 *    Desc:    unpack the primitive KwUiCkwUeIdChgCfm
1697 *
1698 *    Ret:     ROK  -ok
1699 *
1700 *    Notes:   None
1701 *
1702 *    File:    ckw.c
1703 *
1704 */
1705 #ifdef ANSI
1706 PUBLIC S16 cmUnpkCkwUeIdChgCfm
1707 (
1708 CkwUeIdChgCfm     func,
1709 Pst               *pst,
1710 Buffer            *mBuf
1711 )
1712 #else
1713 PUBLIC S16 cmUnpkCkwUeIdChgCfm(func, pst, mBuf)
1714 CkwUeIdChgCfm     func;
1715 Pst               *pst;
1716 Buffer            *mBuf;
1717 #endif
1718 {
1719     S16       ret1;
1720     SuId      suId = 0;
1721     U32       transId = 0;
1722     CkwUeInfo *ueInfo = NULLP;
1723     CmStatus  status;
1724
1725     TRC3(cmUnpkCkwUeIdChgCfm)
1726
1727     cmMemset((U8 *)&status, (U8)0, (PTR)sizeof(CmStatus));
1728
1729     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1730     CMCHKUNPKLOG(SUnpkU32, &transId, mBuf, ECKW042, pst);
1731
1732     if((ret1 = SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo,\
1733                 sizeof(CkwUeInfo))) != ROK)
1734     {
1735 #if (ERRCLASS & ERRCLS_ADD_RES)
1736        if(ret1 != ROK)
1737        {
1738           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1739                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1740                (ErrVal)ECKW043, (ErrVal)0, "SGetMsg() failed");
1741        }
1742 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1743        RETVALUE(ret1);
1744     }
1745
1746     cmMemset((U8 *)ueInfo, 0, sizeof(CkwUeInfo));
1747
1748     ret1 = cmUnpkCkwUeInfo((ueInfo), mBuf);
1749 #if(ERRCLASS & ERRCLS_DEBUG)
1750     if(ret1 != ROK)
1751     {
1752        SPutMsg(mBuf);
1753        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1754              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1755              (ErrVal)ECKW044, (ErrVal)ret1, "Unpacking failure");
1756        RETVALUE( ret1 );
1757     }
1758 #endif /* ERRCLASS & ERRCLS_DEBUG */
1759
1760     CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
1761
1762     SPutMsg(mBuf);
1763
1764     RETVALUE((*func)(pst, suId, transId, ueInfo, status));
1765
1766 } /* cmUnpkCkwUeIdChgCfm */
1767
1768 #endif /* LCCKW */
1769 #ifdef __cplusplus
1770 }
1771 #endif /* __cplusplus */
1772
1773 \f
1774 /**********************************************************************
1775          End of file
1776 **********************************************************************/