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