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