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 static S16 cmUnpkUdxStruct(Buffer *srcMBuf,uint32_t offset,uint8_t *dstBuf,uint32_t size)
  57 {
  58     MsgLen tmpLen;
  59
  60     return (SCpyMsgFix(srcMBuf,offset,size,dstBuf,&tmpLen));
  61
  62 } /*end of function cmPkUdxBndReq*/
  63
  64 /*
  65 *
  66 *    Fun:    cmPkUdxBndReq
  67 *
  68 *    Desc:    pack the primitive UdxBndReq
  69 *
  70 *    Ret:    ROK  -ok
  71 *
  72 *    Notes:    None
  73 *
  74 *    File:     ckw.c
  75 *
  76 */
  77 static S16 cmPkUdxStruct(uint8_t *srcBuf,MsgLen size,Buffer *dstMBuf)
  78 {
  79
  80     return (SAddPstMsgMult(srcBuf,size,dstMBuf));
  81
  82 } /*end of function cmPkUdxBndReq*/
  83 /*
  84 *
  85 *    Fun:    cmPkUdxBndReq
  86 *
  87 *    Desc:    pack the primitive UdxBndReq
  88 *
  89 *    Ret:    ROK  -ok
  90 *
  91 *    Notes:    None
  92 *
  93 *    File:     ckw.c
  94 *
  95 */
  96 S16 cmPkUdxBndReq(Pst *pst,SuId suId,SpId spId)
  97 {
  98     S16 ret1;
  99     Buffer *mBuf;
 100     mBuf = NULLP;
 101
 102     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 103     {
 104 #if (ERRCLASS & ERRCLS_ADD_RES)
 105        if(ret1 != ROK)
 106        {
 107           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 108                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 109                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 110        }
 111 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 112        return (ret1);
 113     }
 114     CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 115     CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
 116     pst->event = (Event) UDX_EVT_BND_REQ;
 117
 118     return (SPstTsk(pst,mBuf));
 119 } /*end of function cmPkUdxBndReq*/
 120 \f
 121 /*
 122 *
 123 *    Fun:    cmPkUdxUbndReq
 124 *
 125 *    Desc:    pack the primitive UdxUbndReq
 126 *
 127 *    Ret:    ROK  -ok
 128 *
 129 *    Notes:    None
 130 *
 131 *    File:     ckw.c
 132 *
 133 */
 134 S16 cmPkUdxUbndReq(Pst *pst,SpId spId,Reason reason)
 135 {
 136     S16 ret1;
 137     Buffer *mBuf;
 138     mBuf = NULLP;
 139
 140     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 141     {
 142 #if (ERRCLASS & ERRCLS_ADD_RES)
 143        if(ret1 != ROK)
 144        {
 145           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 146                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 147                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 148        }
 149 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 150        return (ret1);
 151     }
 152     CMCHKPKLOG(SPkS16, reason, mBuf, EUDXXXX, pst);
 153     CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 154     pst->event = (Event) UDX_EVT_UBND_REQ;
 155
 156     return (SPstTsk(pst,mBuf));
 157 } /*end of function cmPkUdxUbndReq*/
 158 \f
 159 /*
 160 *
 161 *    Fun:    cmPkUdxBndCfm
 162 *
 163 *    Desc:    pack the primitive UdxBndCfm
 164 *
 165 *    Ret:    ROK  -ok
 166 *
 167 *    Notes:    None
 168 *
 169 *    File:     ckw.c
 170 *
 171 */
 172 S16 cmPkUdxBndCfm(Pst *pst,SuId suId,uint8_t status)
 173 {
 174     S16 ret1;
 175     Buffer *mBuf;
 176     mBuf = NULLP;
 177
 178     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 179     {
 180 #if (ERRCLASS & ERRCLS_ADD_RES)
 181        if(ret1 != ROK)
 182        {
 183           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 184                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 185                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 186        }
 187
 188 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 189        return (ret1);
 190     }
 191     CMCHKPKLOG(oduUnpackUInt8, status, mBuf, EUDXXXX, pst);
 192     CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
 193     pst->event = (Event) UDX_EVT_BND_CFM;
 194
 195     return (SPstTsk(pst,mBuf));
 196 } /*end of function cmPkUdxBndCfm*/
 197
 198 \f
 199 /*
 200 *
 201 *    Fun:    cmPkUdxCfgReq
 202 *
 203 *    Desc:    pack the primitive KwUiUdxCfgReq
 204 *
 205 *    Ret:    ROK  -ok
 206 *
 207 *    Notes:    None
 208 *
 209 *    File:     ckw.c
 210 *
 211 */
 212 S16 cmPkUdxCfgReq(Pst *pst,SpId  spId,RlcCfgInfo *cfgInfo)
 213 {
 214     S16 ret1;
 215     Buffer *mBuf;
 216     mBuf = NULLP;
 217
 218     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 219     {
 220 #if (ERRCLASS & ERRCLS_ADD_RES)
 221        if(ret1 != ROK)
 222        {
 223           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 224                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 225                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 226        }
 227 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 228        return (ret1);
 229     }
 230
 231     switch(pst->selector)
 232     {
 233 #ifdef LCUDX
 234        case UDX_SEL_LC:
 235           {
 236              cmPkUdxStruct((uint8_t *)cfgInfo, sizeof(RlcCfgInfo),mBuf);
 237              /* Need Not free CfgInfo here as it is stored
 238                 in UL */
 239              break;
 240           }
 241         case UDX_SEL_LWLC:
 242           {
 243              CMCHKPKLOG(oduPackPointer,(PTR)cfgInfo,mBuf,EUDXXXX,pst);
 244              break;
 245           }
 246 #endif /* LCUDX */
 247     }
 248
 249     CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 250     pst->event = (Event) UDX_EVT_CFG_REQ;
 251
 252     return (SPstTsk(pst,mBuf));
 253 } /* cmPkUdxCfgReq */
 254
 255 \f
 256 /*
 257 *
 258 *    Fun:    cmPkUdxCfgCfm
 259 *
 260 *    Desc:    pack the primitive KwUiUdxCfgCfm
 261 *
 262 *    Ret:    ROK  -ok
 263 *
 264 *    Notes:    None
 265 *
 266 *    File:     ckw.c
 267 *
 268 */
 269 S16 cmPkUdxCfgCfm(Pst *pst,SuId suId,RlcCfgCfmInfo  *cfgCfmInfo)
 270 {
 271     S16 ret1;
 272     Buffer *mBuf;
 273     mBuf = NULLP;
 274
 275     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 276     {
 277 #if (ERRCLASS & ERRCLS_ADD_RES)
 278        if(ret1 != ROK)
 279        {
 280           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 281                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 282                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 283        }
 284 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 285        return (ret1);
 286     }
 287
 288     switch(pst->selector)
 289     {
 290 #ifdef LCUDX
 291        case UDX_SEL_LC:
 292           {
 293              cmPkUdxStruct((uint8_t *)cfgCfmInfo, sizeof(RlcCfgCfmInfo),mBuf);
 294              /* Need to free the cfgCfmInfo here as it is allocated
 295                                         buffer call SPutStaticBuffer */
 296              SPutStaticBuffer(pst->region,pst->pool,(Data *) cfgCfmInfo,
 297                           sizeof(RlcCfgCfmInfo),0);
 298              break;
 299           }
 300         case UDX_SEL_LWLC:
 301           {
 302              CMCHKPKLOG(oduPackPointer,(PTR)cfgCfmInfo,mBuf,EUDXXXX,pst);
 303              break;
 304           }
 305 #endif /* LCUDX */
 306     }
 307
 308     CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
 309     pst->event = (Event) UDX_EVT_CFG_CFM;
 310
 311     return (SPstTsk(pst,mBuf));
 312 } /* cmPkUdxCfgCfm */
 313
 314
 315 /*
 316 *
 317 *    Fun:    cmPkUdxUeIdChgReq
 318 *
 319 *    Desc:   pack the primitive KwUiUdxUeIdChgReq
 320 *
 321 *    Ret:    ROK  -ok
 322 *
 323 *    Notes:  None
 324 *
 325 *    File:   ckw.c
 326 *
 327 */
 328 S16 cmPkUdxUeIdChgReq
 329 (
 330 Pst        *pst,
 331 SpId       spId,
 332 uint32_t   transId,
 333 CkwUeInfo  *ueInfo,
 334 CkwUeInfo  *newUeInfo
 335 )
 336 {
 337     S16    ret1;
 338     Buffer *mBuf = NULLP;
 339
 340
 341     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 342     {
 343 #if (ERRCLASS & ERRCLS_ADD_RES)
 344        if(ret1 != ROK)
 345        {
 346           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 347                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 348                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 349        }
 350 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 351
 352        return (ret1);
 353     }
 354
 355     switch(pst->selector)
 356     {
 357 #ifdef LCUDX
 358        case UDX_SEL_LC:
 359        {
 360             cmPkUdxStruct((uint8_t *)newUeInfo, sizeof(CkwUeInfo),mBuf);
 361             cmPkUdxStruct((uint8_t *)ueInfo, sizeof(CkwUeInfo),mBuf);
 362             /* No need to free ueInfo here as it is stored */
 363             break;
 364        }
 365        case UDX_SEL_LWLC:
 366           {
 367              CMCHKPKLOG(oduPackPointer,(PTR)newUeInfo,mBuf,EUDXXXX,pst);
 368              CMCHKPKLOG(oduPackPointer,(PTR)ueInfo,mBuf,EUDXXXX,pst);
 369              break;
 370           }
 371        default:
 372        {
 373           printf("cmPkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
 374           exit(1);
 375        }
 376 #endif
 377     }
 378     CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, EUDXXXX, pst);
 379     CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 380     pst->event = (Event) UDX_EVT_UEIDCHG_REQ;
 381
 382     return (SPstTsk(pst, mBuf));
 383
 384 } /* cmPkUdxUeIdChgReq */
 385
 386 /*
 387 *
 388 *    Fun:    cmPkUdxUeIdChgCfm
 389 *
 390 *    Desc:   pack the primitive KwUiUdxUeIdChgCfm
 391 *
 392 *    Ret:    ROK  -ok
 393 *
 394 *    Notes:  None
 395 *
 396 *    File:   ckw.c
 397 *
 398 */
 399 S16 cmPkUdxUeIdChgCfm(Pst *pst,SuId suId,uint32_t transId,CmStatus status)
 400 {
 401     S16    ret1;
 402     Buffer *mBuf = NULLP;
 403
 404     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 405     {
 406 #if (ERRCLASS & ERRCLS_ADD_RES)
 407        if(ret1 != ROK)
 408        {
 409           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 410                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 411                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 412        }
 413 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 414
 415        return (ret1);
 416     }
 417
 418     CMCHKPK(cmPkCmStatus, &status, mBuf);
 419     CMCHKPKLOG(oduUnpackUInt32, transId, mBuf, EUDXXXX, pst);
 420     CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
 421     pst->event = (Event) UDX_EVT_UEIDCHG_CFM;
 422
 423     return (SPstTsk(pst, mBuf));
 424
 425 } /* cmPkUdxUeIdChgCfm */
 426
 427 /*
 428 *
 429 *    Fun:    cmPkUdxStaUpdCfm
 430 *
 431 *    Desc:   pack the primitive KwUiUdxUeIdChgCfm
 432 *
 433 *    Ret:    ROK  -ok
 434 *
 435 *    Notes:  None
 436 *
 437 *    File:   ckw.c
 438 *
 439 */
 440 S16 cmPkUdxStaUpdCfm(Pst *pst,SuId suId,CmLteRlcId *rlcId,RlcUdxBufLst *pStaPdu)
 441 {
 442     S16    ret1;
 443     Buffer *mBuf = NULLP;
 444
 445     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 446     {
 447 #if (ERRCLASS & ERRCLS_ADD_RES)
 448        if(ret1 != ROK)
 449        {
 450           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 451                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 452                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 453        }
 454 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 455
 456        return (ret1);
 457     }
 458
 459     switch (pst->selector)
 460     {
 461        case UDX_SEL_LC:
 462        {
 463          cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxBufLst),mBuf);
 464          cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
 465          break;
 466        }
 467        case UDX_SEL_LWLC:
 468        {
 469          CMCHKPK(oduPackPointer,(PTR) pStaPdu, mBuf);
 470          CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
 471          break;
 472        }
 473     }
 474     CMCHKPKLOG(SPkS16, suId, mBuf, EUDXXXX, pst);
 475     pst->event = (Event) UDX_EVT_STA_UPD_CFM;
 476
 477     return (SPstTsk(pst, mBuf));
 478
 479 } /* cmPkUdxStaUpdCfm */
 480
 481 /*
 482 *
 483 *    Fun:    cmPkUdxStaProhTmrStart
 484 *
 485 *    Desc:   pack the primitive
 486 *
 487 *    Ret:    ROK  -ok
 488 *
 489 *    Notes:  None
 490 *
 491 *    File:   Kw_udx.c
 492 *
 493 */
 494 S16 cmPkUdxStaProhTmrStart(Pst *pst,SpId spId,CmLteRlcId *rlcId)
 495 {
 496     S16    ret1;
 497     Buffer *mBuf = NULLP;
 498
 499     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 500     {
 501 #if (ERRCLASS & ERRCLS_ADD_RES)
 502        if(ret1 != ROK)
 503        {
 504           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 505                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 506                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 507        }
 508 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 509
 510        return (ret1);
 511     }
 512
 513     switch (pst->selector)
 514     {
 515        case UDX_SEL_LC:
 516        {
 517          cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
 518          break;
 519        }
 520        case UDX_SEL_LWLC:
 521        {
 522          CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
 523          break;
 524        }
 525     }
 526     CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 527     pst->event = (Event) UDX_EVT_STA_PHBT_TMR_START;
 528
 529     return (SPstTsk(pst, mBuf));
 530
 531 } /* cmPkUdxStaProhTmrStart */
 532
 533 /*
 534 *
 535 *    Fun:    cmPkUdxStaUpdReq
 536 *
 537 *    Desc:   pack the primitive KwUiUdxUeIdChgCfm
 538 *
 539 *    Ret:    ROK  -ok
 540 *
 541 *    Notes:  None
 542 *
 543 *    File:   ckw.c
 544 *
 545 */
 546 S16 cmPkUdxStaUpdReq(Pst *pst,SpId spId,CmLteRlcId *rlcId,RlcUdxStaPdu *pStaPdu)
 547 {
 548     S16    ret1;
 549     Buffer *mBuf = NULLP;
 550
 551     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 552     {
 553 #if (ERRCLASS & ERRCLS_ADD_RES)
 554        if(ret1 != ROK)
 555        {
 556           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 557                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 558                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 559        }
 560 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 561
 562        return (ret1);
 563     }
 564
 565     switch (pst->selector)
 566     {
 567        case UDX_SEL_LC:
 568        {
 569          cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxStaPdu),mBuf);
 570          cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
 571          SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
 572                           sizeof(RlcUdxStaPdu),0);
 573
 574          break;
 575        }
 576        case UDX_SEL_LWLC:
 577        {
 578          CMCHKPK(oduPackPointer,(PTR) pStaPdu, mBuf);
 579          CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
 580          break;
 581        }
 582     }
 583     CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 584     pst->event = (Event) UDX_EVT_STA_UPD_REQ;
 585
 586     return (SPstTsk(pst, mBuf));
 587
 588 } /* cmPkUdxStaUpdReq */
 589
 590 /*
 591 *
 592 *    Fun:    cmPkUdxStaPduReq
 593 *
 594 *    Desc:   pack the primitive KwUiUdxUeIdChgCfm
 595 *
 596 *    Ret:    ROK  -ok
 597 *
 598 *    Notes:  None
 599 *
 600 *    File:   ckw.c
 601 *
 602 */
 603 S16 cmPkUdxStaPduReq(Pst *pst,SpId spId,CmLteRlcId *rlcId,RlcUdxDlStaPdu *pStaPdu)
 604 {
 605     S16    ret1;
 606     Buffer *mBuf = NULLP;
 607
 608     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 609     {
 610 #if (ERRCLASS & ERRCLS_ADD_RES)
 611        if(ret1 != ROK)
 612        {
 613           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 614                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 615                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 616        }
 617 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 618
 619        return (ret1);
 620     }
 621
 622     switch (pst->selector)
 623     {
 624        case UDX_SEL_LC:
 625        {
 626          cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxDlStaPdu),mBuf);
 627          cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
 628          /* Free status Pdu here for LC */
 629          SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
 630                           sizeof(RlcUdxDlStaPdu),0);
 631          break;
 632        }
 633        case UDX_SEL_LWLC:
 634        {
 635          CMCHKPK(oduPackPointer,(PTR) pStaPdu, mBuf);
 636          CMCHKPK(oduPackPointer,(PTR) rlcId, mBuf);
 637          break;
 638        }
 639     }
 640     CMCHKPKLOG(SPkS16, spId, mBuf, EUDXXXX, pst);
 641     pst->event = (Event) UDX_EVT_STA_PDU_REQ;
 642
 643     return (SPstTsk(pst, mBuf));
 644
 645 } /* cmPkUdxStaUpdReq */
 646
 647 #ifdef LTE_L2_MEAS
 648 /*
 649 *
 650 *    Fun:    cmPkUdxL2MeasReq
 651 *
 652 *    Ret:    ROK  -ok
 653 *
 654 *    Notes:  None
 655 *
 656 *
 657 */
 658 S16 cmPkUdxL2MeasReq(Pst  *pst,RlcL2MeasReqEvt *measReqEvt)
 659 {
 660     S16    ret1;
 661     Buffer *mBuf = NULLP;
 662
 663     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 664     {
 665 #if (ERRCLASS & ERRCLS_ADD_RES)
 666        if(ret1 != ROK)
 667        {
 668           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 669                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 670                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 671        }
 672 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 673
 674        return (ret1);
 675     }
 676
 677     switch (pst->selector)
 678     {
 679        case UDX_SEL_LC:
 680        {
 681          cmPkUdxStruct((uint8_t *)measReqEvt, sizeof(RlcL2MeasReqEvt),mBuf);
 682          break;
 683        }
 684        case UDX_SEL_LWLC:
 685        {
 686          CMCHKPK(oduPackPointer,(PTR) measReqEvt, mBuf);
 687          break;
 688        }
 689     }
 690     pst->event = (Event) UDX_EVT_L2MEAS_REQ;
 691
 692     return (SPstTsk(pst, mBuf));
 693
 694 } /* cmPkUdxStaUpdReq */
 695
 696 /*
 697 *
 698 *    Fun:    cmPkUdxL2MeasReq
 699 *
 700 *    Ret:    ROK  -ok
 701 *
 702 *    Notes:  None
 703 *
 704 *
 705 */
 706 S16 cmPkUdxL2MeasSendReq(Pst  *pst,uint8_t measType)
 707 {
 708     S16    ret1;
 709     Buffer *mBuf = NULLP;
 710
 711     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 712     {
 713 #if (ERRCLASS & ERRCLS_ADD_RES)
 714        if(ret1 != ROK)
 715        {
 716           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 717                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 718                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 719        }
 720 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 721
 722        return (ret1);
 723     }
 724
 725     switch (pst->selector)
 726     {
 727        case UDX_SEL_LC:
 728        case UDX_SEL_LWLC:
 729        {
 730           CMCHKPKLOG(oduUnpackUInt8, measType, mBuf, EUDXXXX, pst);
 731           break;
 732        }
 733     }
 734     pst->event = (Event) UDX_EVT_L2MEAS_SEND_REQ;
 735
 736     return (SPstTsk(pst, mBuf));
 737
 738 }
 739
 740 /*
 741 *
 742 *    Fun:    cmPkUdxL2MeasStopReq
 743 *
 744 *    Ret:    ROK  -ok
 745 *
 746 *    Notes:  None
 747 *
 748 *
 749 */
 750 S16 cmPkUdxL2MeasStopReq(Pst *pst,uint8_t measType)
 751 {
 752     S16    ret1;
 753     Buffer *mBuf = NULLP;
 754
 755     if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 756     {
 757 #if (ERRCLASS & ERRCLS_ADD_RES)
 758        if(ret1 != ROK)
 759        {
 760           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 761                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 762                (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 763        }
 764 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 765
 766        return (ret1);
 767     }
 768
 769     switch (pst->selector)
 770     {
 771        case UDX_SEL_LC:
 772        case UDX_SEL_LWLC:
 773        {
 774           CMCHKPKLOG(oduUnpackUInt8, measType, mBuf, EUDXXXX, pst);
 775           break;
 776        }
 777     }
 778     pst->event = (Event) UDX_EVT_L2MEAS_STOP_REQ;
 779
 780     return (SPstTsk(pst, mBuf));
 781
 782 }
 783 #endif
 784 /******************************************************************************
 785  *                            UNPACK FUNCTIONS
 786  *****************************************************************************/
 787 \f
 788 /*
 789 *
 790 *    Fun:    cmUnpkUdxBndReq
 791 *
 792 *    Desc:    unpack the primitive UdxBndReq
 793 *
 794 *    Ret:    ROK  -ok
 795 *
 796 *    Notes:    None
 797 *
 798 *    File:     ckw.c
 799 *
 800 */
 801 S16 cmUnpkUdxBndReq(UdxBndReq func,Pst  *pst,Buffer *mBuf)
 802 {
 803     SuId       suId = 0;
 804     SpId       spId = 0;
 805
 806     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
 807     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
 808     SPutMsg(mBuf);
 809
 810     return ((*func)(pst, suId, spId));
 811 } /*end of function cmUnpkUdxBndReq*/
 812 \f
 813 /*
 814 *
 815 *    Fun:    cmUnpkUdxUbndReq
 816 *
 817 *    Desc:    unpack the primitive UdxUbndReq
 818 *
 819 *    Ret:    ROK  -ok
 820 *
 821 *    Notes:    None
 822 *
 823 *    File:     ckw.c
 824 *
 825 */
 826 S16 cmUnpkUdxUbndReq(UdxUbndReq func,Pst *pst,Buffer *mBuf)
 827 {
 828     SpId       spId = 0;
 829     Reason     reason = 0;
 830
 831     CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EUDXXXX, pst);
 832     CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EUDXXXX, pst);
 833     SPutMsg(mBuf);
 834     return ((*func)(pst, spId, reason));
 835 } /*end of function cmUnpkUdxUbndReq*/
 836 \f
 837 /*
 838 *
 839 *    Fun:    cmUnpkUdxBndCfm
 840 *
 841 *    Desc:    unpack the primitive UdxBndCfm
 842 *
 843 *    Ret:    ROK  -ok
 844 *
 845 *    Notes:    None
 846 *
 847 *    File:     ckw.c
 848 *
 849 */
 850 S16 cmUnpkUdxBndCfm(UdxBndCfm func,Pst *pst,Buffer *mBuf)
 851 {
 852     SuId       suId = 0;
 853     uint8_t         status = 0;
 854
 855     CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
 856     CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EUDXXXX, pst);
 857     SPutMsg(mBuf);
 858
 859     return ((*func)(pst, suId, status));
 860 } /*end of function cmUnpkUdxBndCfm*/
 861
 862 \f
 863 /*
 864 *
 865 *    Fun:    cmUnpkUdxCfgReq
 866 *
 867 *    Desc:    unpack the primitive KwUiUdxCfgReq
 868 *
 869 *    Ret:    ROK  -ok
 870 *
 871 *    Notes:    None
 872 *
 873 *    File:     ckw.c
 874 *
 875 */
 876 S16 cmUnpkUdxCfgReq(UdxCfgReq func,Pst  *pst,Buffer *mBuf)
 877 {
 878 #if(ERRCLASS & ERRCLS_DEBUG)
 879     S16           ret1;
 880 #endif /* ERRCLASS & ERRCLS_DEBUG */
 881     SpId          spId = 0;
 882     RlcCfgInfo     tmpCfgInfo;
 883     RlcCfgInfo    *cfgInfo; /*stack Variable because it is not freed */
 884
 885     CMCHKUNPK(SUnpkS16, &(spId), mBuf);
 886     switch(pst->selector)
 887     {
 888 #ifdef LCUDX
 889        case UDX_SEL_LC:
 890        {
 891 #if(ERRCLASS & ERRCLS_DEBUG)
 892           ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpCfgInfo,sizeof(RlcCfgInfo));
 893           if(ret1 != ROK)
 894           {
 895              SPutMsg(mBuf);
 896              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
 897                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
 898                   (ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
 899              return ( ret1 );
 900           }
 901 #else
 902          cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpCfgInfo,sizeof(RlcCfgInfo));
 903 #endif /* ERRCLASS & ERRCLS_DEBUG */
 904           cfgInfo = &tmpCfgInfo;
 905           break;
 906        }
 907        case UDX_SEL_LWLC:
 908        {
 909           CMCHKUNPK(oduUnpackPointer,(PTR *) &cfgInfo, mBuf);
 910           break;
 911        }
 912 #endif /* LCUDX */
 913     }
 914     SPutMsg(mBuf);
 915
 916     return ((*func)(pst, spId, cfgInfo));
 917 } /* cmUnpkUdxCfgReq */
 918
 919 \f
 920 /*
 921 *
 922 *    Fun:    cmUnpkUdxCfgCfm
 923 *
 924 *    Desc:    unpack the primitive KwUiUdxCfgCfm
 925 *
 926 *    Ret:    ROK  -ok
 927 *
 928 *    Notes:    None
 929 *
 930 *    File:     ckw.c
 931 *
 932 */
 933 S16 cmUnpkUdxCfgCfm(UdxCfgCfm func,Pst  *pst,Buffer *mBuf)
 934 {
 935     S16 ret1;
 936     SuId             suId = 0;
 937     RlcCfgCfmInfo    *cfgCfmInfo = NULLP;
 938
 939     CMCHKUNPK(SUnpkS16, &suId, mBuf);
 940
 941     switch(pst->selector)
 942     {
 943 #ifdef LCUDX
 944        case UDX_SEL_LC:
 945        {
 946            if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&cfgCfmInfo,\
 947                        sizeof(RlcCfgCfmInfo),0)) != ROK)
 948            {
 949 #if (ERRCLASS & ERRCLS_ADD_RES)
 950               if(ret1 != ROK)
 951               {
 952                  SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 953                        __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 954                       (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
 955               }
 956 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 957               return (ret1);
 958            }
 959
 960           ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)cfgCfmInfo, sizeof(RlcCfgCfmInfo));
 961 #if(ERRCLASS & ERRCLS_DEBUG)
 962           if(ret1 != ROK)
 963           {
 964              SPutMsg(mBuf);
 965              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
 966                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
 967                   (ErrVal)EUDXXXX, (ErrVal)ret1, "Unpacking failure");
 968              return ( ret1 );
 969           }
 970 #endif /* ERRCLASS & ERRCLS_DEBUG */
 971           break;
 972        }
 973        case UDX_SEL_LWLC:
 974        {
 975           CMCHKUNPK(oduUnpackPointer,(PTR *) &cfgCfmInfo, mBuf);
 976           break;
 977        }
 978 #endif /* LCUDX */
 979     }
 980     SPutMsg(mBuf);
 981
 982     return ((*func)(pst, suId, cfgCfmInfo));
 983 } /* cmUnpkUdxCfgCfm */
 984
 985 /*
 986 *
 987 *    Fun:    cmUnpkUdxUeIdChgReq
 988 *
 989 *    Desc:    unpack the primitive KwUiUdxUeIdChgReq
 990 *
 991 *    Ret:    ROK  -ok
 992 *
 993 *    Notes:    None
 994 *
 995 *    File:     ckw.c
 996 *
 997 */
 998 S16 cmUnpkUdxUeIdChgReq(UdxUeIdChgReq func,Pst *pst,Buffer *mBuf)
 999 {
1000     SpId      spId = 0;
1001     uint32_t  transId = 0;
1002     CkwUeInfo tmpUeInfo;
1003     CkwUeInfo tmpNewUeInfo;
1004     CkwUeInfo *ueInfo;
1005     CkwUeInfo *newUeInfo;
1006
1007     CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1008     CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, EUDXXXX, pst);
1009
1010     switch(pst->selector)
1011     {
1012 #ifdef LCUDX
1013        case UDX_SEL_LC:
1014        {
1015           cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpNewUeInfo, sizeof(CkwUeInfo));
1016           cmUnpkUdxStruct(mBuf,sizeof(CkwUeInfo),(uint8_t *)&tmpUeInfo, sizeof(CkwUeInfo));
1017
1018           ueInfo =  &tmpUeInfo;
1019           newUeInfo =  &tmpNewUeInfo;
1020           break;
1021        }
1022        case UDX_SEL_LWLC:
1023        {
1024           CMCHKUNPK(oduUnpackPointer,(PTR *) &ueInfo, mBuf);
1025           CMCHKUNPK(oduUnpackPointer,(PTR *) &newUeInfo, mBuf);
1026           break;
1027        }
1028        default:
1029        {
1030           printf("cmUnpkUdxUeIdChgReq()- selector =%d not supported \n", pst->selector);
1031           exit(1);
1032        }
1033
1034 #endif /* LCUDX */
1035     }
1036     SPutMsg(mBuf);
1037
1038     return ((*func)(pst, spId, transId, ueInfo, newUeInfo));
1039
1040 } /* cmUnpkUdxUeIdChgReq */
1041
1042 /*
1043 *
1044 *    Fun:     cmUnpkUdxUeIdChgCfm
1045 *
1046 *    Desc:    unpack the primitive KwUiUdxUeIdChgCfm
1047 *
1048 *    Ret:     ROK  -ok
1049 *
1050 *    Notes:   None
1051 *
1052 *    File:    ckw.c
1053 *
1054 */
1055 S16 cmUnpkUdxUeIdChgCfm(UdxUeIdChgCfm func,Pst  *pst,Buffer *mBuf)
1056 {
1057     SuId      suId = 0;
1058     uint32_t  transId = 0;
1059     CmStatus  status;
1060
1061     memset(&status, 0, sizeof(CmStatus));
1062
1063     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1064     CMCHKUNPKLOG(oduPackUInt32, &transId, mBuf, EUDXXXX, pst);
1065
1066     CMCHKUNPK(cmUnpkCmStatus, &status, mBuf);
1067
1068     SPutMsg(mBuf);
1069
1070     return ((*func)(pst, suId, transId, status));
1071
1072 } /* cmUnpkUdxUeIdChgCfm */
1073
1074 /*
1075 *
1076 *    Fun:     cmUnpkUdxStaUpdCfm
1077 *
1078 *    Desc:    unpack the primitive KwUiUdxUeIdChgCfm
1079 *
1080 *    Ret:     ROK  -ok
1081 *
1082 *    Notes:   None
1083 *
1084 *    File:    ckw.c
1085 *
1086 */
1087 S16 cmUnpkUdxStaUpdCfm(UdxStaUpdCfm func,Pst *pst,Buffer *mBuf)
1088 {
1089     SuId      suId = 0;
1090     CmLteRlcId *rlcId = NULLP;  /* KW_FIX */
1091     RlcUdxBufLst *pBufLst = NULLP; /* KW_FIX*/
1092
1093     CMCHKUNPK(SUnpkS16, &suId, mBuf);
1094     switch (pst->selector)
1095     {
1096        case UDX_SEL_LC:
1097        {
1098           break;
1099        }
1100        case UDX_SEL_LWLC:
1101        {
1102           CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
1103           CMCHKUNPK(oduUnpackPointer, (PTR *)&pBufLst,mBuf);
1104           break;
1105        }
1106     }
1107
1108     SPutMsg(mBuf);
1109
1110     return ((*func)(pst, suId, rlcId, pBufLst));
1111
1112 } /* cmUnpkUdxUeIdChgCfm */
1113
1114 /*
1115 *
1116 *    Fun:     cmUnpkUdxStaUpdReq
1117 *
1118 *    Desc:    unpack the primitive KwUiUdxUeIdChgCfm
1119 *
1120 *    Ret:     ROK  -ok
1121 *
1122 *    Notes:   None
1123 *
1124 *    File:    ckw.c
1125 *
1126 */
1127 S16 cmUnpkUdxStaUpdReq(UdxStaUpdReq func,Pst *pst,Buffer *mBuf)
1128 {
1129     SpId      spId = 0;
1130     CmLteRlcId *rlcId = NULLP; /* KW_FIX */
1131     RlcUdxStaPdu *pStaPdu = NULLP; /* KW_FIX */
1132     S16 ret1;
1133     CmLteRlcId tmpRlcId;
1134
1135     CMCHKUNPK(SUnpkS16, &spId, mBuf);
1136     switch (pst->selector)
1137     {
1138        case UDX_SEL_LC:
1139        {
1140            if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
1141                        sizeof(RlcUdxStaPdu),0)) != ROK)
1142            {
1143 #if (ERRCLASS & ERRCLS_ADD_RES)
1144               if(ret1 != ROK)
1145               {
1146                  SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1147                        __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1148                       (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
1149               }
1150 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1151               return (ret1);
1152            }
1153           ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)pStaPdu, sizeof(RlcUdxStaPdu));
1154           ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
1155           rlcId = &tmpRlcId;
1156           break;
1157        }
1158        case UDX_SEL_LWLC:
1159        {
1160           CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
1161           CMCHKUNPK(oduUnpackPointer, (PTR *)&pStaPdu,mBuf);
1162           break;
1163        }
1164     }
1165
1166     SPutMsg(mBuf);
1167
1168     return ((*func)(pst, spId, rlcId, pStaPdu));
1169
1170 } /* cmUnpkUdxUeIdChgCfm */
1171
1172 /*
1173 *
1174 *    Fun:     cmUnpkUdxStaPduReq
1175 *
1176 *    Desc:    unpack the primitive KwUiUdxUeIdChgCfm
1177 *
1178 *    Ret:     ROK  -ok
1179 *
1180 *    Notes:   None
1181 *
1182 *    File:    ckw.c
1183 *
1184 */
1185 S16 cmUnpkUdxStaPduReq(UdxStaPduReq func,Pst *pst,Buffer *mBuf)
1186 {
1187     S16       ret1;
1188     SpId      spId = 0;
1189     CmLteRlcId tmpRlcId;
1190     CmLteRlcId *rlcId = NULLP;  /* KW_FIX */
1191     RlcUdxDlStaPdu *pStaPdu = NULLP; /* KW_FIX */
1192
1193     CMCHKUNPK(SUnpkS16, &spId, mBuf);
1194     switch (pst->selector)
1195     {
1196        case UDX_SEL_LC:
1197        {
1198            if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&pStaPdu,
1199                        sizeof(RlcUdxDlStaPdu),0)) != ROK)
1200            {
1201 #if (ERRCLASS & ERRCLS_ADD_RES)
1202               if(ret1 != ROK)
1203               {
1204                  SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1205                        __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1206                       (ErrVal)EUDXXXX, (ErrVal)0, "SGetMsg() failed");
1207               }
1208 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1209               return (ret1);
1210            }
1211           ret1 = cmUnpkUdxStruct(mBuf,0, (uint8_t *)pStaPdu, sizeof(RlcUdxDlStaPdu));
1212           ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxDlStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
1213           rlcId = &tmpRlcId;
1214            break;
1215        }
1216        case UDX_SEL_LWLC:
1217        {
1218           CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
1219           CMCHKUNPK(oduUnpackPointer, (PTR *)&pStaPdu,mBuf);
1220           break;
1221        }
1222     }
1223
1224     SPutMsg(mBuf);
1225     return ((*func)(pst, spId, rlcId, pStaPdu));
1226
1227 } /* cmUnpkUdxUeIdChgCfm */
1228
1229 /*
1230 *
1231 *    Fun:     cmUnpkUdxStaProhTmrStart
1232 *
1233 *    Desc:    unpack the Status prohibit timer start Msg
1234 *
1235 *    Ret:     ROK  -ok
1236 *
1237 *    Notes:   None
1238 *
1239 *    File:    kw_udx.c
1240 *
1241 */
1242 S16 cmUnpkUdxStaProhTmrStart(UdxStaProhTmrStart func,Pst *pst,Buffer *mBuf)
1243 {
1244     SpId      spId = 0;
1245     CmLteRlcId tmpRlcId;
1246     CmLteRlcId *rlcId = NULLP; /* KW_FIX */
1247
1248     CMCHKUNPK(SUnpkS16, &spId, mBuf);
1249     switch (pst->selector)
1250     {
1251        case UDX_SEL_LC:
1252        {
1253           cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
1254           rlcId = &tmpRlcId;
1255           break;
1256        }
1257        case UDX_SEL_LWLC:
1258        {
1259           CMCHKUNPK(oduUnpackPointer, (PTR *)&rlcId,mBuf);
1260           break;
1261        }
1262     }
1263
1264     SPutMsg(mBuf);
1265
1266     return ((*func)(pst, spId, rlcId));
1267
1268 } /* cmUnpkUdxStaProhTmrStart */
1269
1270 #ifdef LTE_L2_MEAS
1271 /*
1272
1273
1274 *    Fun:    cmUnpkUdxL2MeasReq
1275 *
1276 *    Ret:    ROK  -ok
1277 *
1278 *    Notes:  None
1279 *
1280 *
1281 */
1282 S16 cmUnpkUdxL2MeasReq(UdxL2MeasReq func,Pst *pst,Buffer *mBuf)
1283 {
1284     RlcL2MeasReqEvt    tmpMeasReqEvt;
1285     RlcL2MeasReqEvt    *measReqEvt = NULLP;  /* KW_FIX */
1286
1287     switch (pst->selector)
1288     {
1289        case UDX_SEL_LC:
1290        {
1291           cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpMeasReqEvt,sizeof(RlcL2MeasReqEvt));
1292           measReqEvt = &tmpMeasReqEvt;
1293           break;
1294        }
1295        case UDX_SEL_LWLC:
1296        {
1297          CMCHKUNPK(oduUnpackPointer, (PTR *)&measReqEvt,mBuf);
1298          break;
1299        }
1300     }
1301
1302     SPutMsg(mBuf);
1303
1304     return ((*func)(pst, measReqEvt));
1305 } /* cmUnpkUdxL2MeasReq */
1306
1307 /*
1308 *
1309 *    Fun:    cmUnpkUdxL2MeasSendReq
1310 *
1311 *    Ret:    ROK  -ok
1312 *
1313 *    Notes:  None
1314 *
1315 *
1316 */
1317 S16 cmUnpkUdxL2MeasSendReq(UdxL2MeasSendReq func,Pst *pst,Buffer *mBuf)
1318 {
1319     uint8_t     measType = 0;  /* KW_FIX */
1320
1321     switch (pst->selector)
1322     {
1323        case UDX_SEL_LC:
1324        case UDX_SEL_LWLC:
1325        {
1326           CMCHKUNPK(oduPackUInt8, &measType, mBuf);
1327          break;
1328        }
1329     }
1330
1331     SPutMsg(mBuf);
1332
1333     return ((*func)(pst, measType));
1334 } /* cmUnpkUdxL2MeasReq */
1335
1336 /*
1337 *
1338 *    Fun:    cmUnpkUdxL2MeasStopReq
1339 *
1340 *    Ret:    ROK  -ok
1341 *
1342 *    Notes:  None
1343 *
1344 *
1345 */
1346 S16 cmUnpkUdxL2MeasStopReq(UdxL2MeasStopReq func,Pst *pst,Buffer *mBuf)
1347 {
1348     uint8_t     measType = 0; /* KW_FIX */
1349
1350     switch (pst->selector)
1351     {
1352        case UDX_SEL_LC:
1353        case UDX_SEL_LWLC:
1354        {
1355           CMCHKUNPK(oduPackUInt8, &measType, mBuf);
1356          break;
1357        }
1358     }
1359
1360     SPutMsg(mBuf);
1361
1362     return ((*func)(pst, measType));
1363 } /* cmUnpkUdxL2MeasStopReq */
1364 #endif
1365 #endif /* LCUDX */
1366
1367 \f
1368 /********************************************************************30**
1369          End of file
1370 **********************************************************************/