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