src/cm/ctf.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:     CTF Interface
  22
  23      Type:     C file
  24
  25      Desc:     This file contains the packing/unpacking functions
  26                for control plane primitives on CTF interface.
  27
  28      File:     ctf.c
  29
  30 *********************************************************************21*/
  31
  32 /* header include files (.h) */
  33 #include "envopt.h"        /* Environment options             */
  34 #include "envdep.h"        /* Environment dependent options   */
  35 #include "envind.h"        /* Environment independent options */
  36 #include "gen.h"           /* General layer                   */
  37 #include "ssi.h"           /* System service interface        */
  38 #include "cm5.h"           /* Common timer library            */
  39 #include "cm_llist.h"      /* Common linked list library      */
  40 #include "cm_hash.h"       /* Common hash library             */
  41 #include "cm_tkns.h"       /* Common tokens                   */
  42 #include "cm_lte.h"        /* Common LTE Defines              */
  43 #include "ctf.h"           /* CTF interface defines           */
  44
  45 /* header/extern include files (.x) */
  46 #include "gen.x"           /* General layer                   */
  47 #include "ssi.x"           /* System services interface       */
  48 #include "cm_lib.x"        /* Common linrary function         */
  49 #include "cm_llist.x"      /* Common link list library        */
  50 #include "cm_hash.x"       /* Common hash list library        */
  51 #include "cm_tkns.x"       /* Common tokens                   */
  52 #include "cm_lte.x"        /* Common LTE library              */
  53 #ifdef TENB_AS_SECURITY
  54 #include "cm_mblk.x"
  55 #endif
  56 #include "ctf.x"
  57
  58 #ifdef TENB_AS_SECURITY
  59 #define cmPkCtfCrnti SPkU16
  60 #define cmPkCtfCellId SPkU16
  61 #define cmUnpkCtfCellId SUnpkU16
  62 #define cmUnpkCtfCrnti SUnpkU16
  63 #endif
  64
  65
  66 #if (defined(LCCTF) || defined(LWLCCTF))
  67
  68 \f
  69 /**
  70 * @brief Request from RRC to PHY to bind the CTF interface SAP.
  71 *
  72 * @details
  73 *
  74 *     Function: cmPkCtfBndReq
  75 *
  76 *  @param[in]   Pst*  pst
  77 *  @param[in]   SuId  suId
  78 *  @param[in]   SpId  spId
  79 *  @return   S16
  80 *      -# ROK
  81 **/
  82 #ifdef ANSI
  83 PUBLIC S16 cmPkCtfBndReq
  84 (
  85 Pst* pst,
  86 SuId suId,
  87 SpId spId
  88 )
  89 #else
  90 PUBLIC S16 cmPkCtfBndReq(pst, suId, spId)
  91 Pst* pst;
  92 SuId suId;
  93 SpId spId;
  94 #endif
  95 {
  96    Buffer *mBuf = NULLP;
  97    TRC3(cmPkCtfBndReq)
  98
  99    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 100 #if (ERRCLASS & ERRCLS_ADD_RES)
 101       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 102       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 103          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 104          (ErrVal)ECTF001, (ErrVal)0, (Txt*)&"Packing failed");
 105 #endif
 106       RETVALUE(RFAILED);
 107    }
 108    if (SPkS16(spId, mBuf) != ROK) {
 109 #if (ERRCLASS & ERRCLS_ADD_RES)
 110       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 111       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 112          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 113          (ErrVal)ECTF002, (ErrVal)0, (Txt*)&"Packing failed");
 114 #endif
 115       SPutMsg(mBuf);
 116       RETVALUE(RFAILED);
 117    }
 118    if (SPkS16(suId, mBuf) != ROK) {
 119 #if (ERRCLASS & ERRCLS_ADD_RES)
 120       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 121       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 122          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 123          (ErrVal)ECTF003, (ErrVal)0, (Txt*)&"Packing failed");
 124 #endif
 125       SPutMsg(mBuf);
 126       RETVALUE(RFAILED);
 127    }
 128    pst->event = (Event) EVTCTFBNDREQ;
 129    RETVALUE(SPstTsk(pst,mBuf));
 130 }
 131
 132 \f
 133 /**
 134 * @brief Request from RRC to PHY to bind the CTF interface SAP.
 135 *
 136 * @details
 137 *
 138 *     Function: cmUnpkCtfBndReq
 139 *
 140 *  @param[in]   Pst*  pst
 141 *  @param[in]   SuId  suId
 142 *  @param[in]   SpId  spId
 143 *  @return   S16
 144 *      -# ROK
 145 **/
 146 #ifdef ANSI
 147 PUBLIC S16 cmUnpkCtfBndReq
 148 (
 149 CtfBndReq func,
 150 Pst *pst,
 151 Buffer *mBuf
 152 )
 153 #else
 154 PUBLIC S16 cmUnpkCtfBndReq(func, pst, mBuf)
 155 CtfBndReq func;
 156 Pst *pst;
 157 Buffer *mBuf;
 158 #endif
 159 {
 160    SuId suId = 0;
 161    SpId spId = 0;
 162
 163    TRC3(cmUnpkCtfBndReq)
 164
 165    if (SUnpkS16(&suId, mBuf) != ROK) {
 166       SPutMsg(mBuf);
 167 #if (ERRCLASS & ERRCLS_ADD_RES)
 168       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 169       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 170          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 171          (ErrVal)ECTF004, (ErrVal)0, (Txt*)&"Packing failed");
 172 #endif
 173       RETVALUE(RFAILED);
 174    }
 175    if (SUnpkS16(&spId, mBuf) != ROK) {
 176       SPutMsg(mBuf);
 177 #if (ERRCLASS & ERRCLS_ADD_RES)
 178       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 179       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 180          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 181          (ErrVal)ECTF005, (ErrVal)0, (Txt*)&"Packing failed");
 182 #endif
 183       RETVALUE(RFAILED);
 184    }
 185    SPutMsg(mBuf);
 186    RETVALUE((*func)(pst, suId, spId));
 187 }
 188
 189 \f
 190 /**
 191 * @brief Confirmation from PHY to RRC for the bind
 192  * request for the CTF interface SAP.
 193 *
 194 * @details
 195 *
 196 *     Function: cmPkCtfBndCfm
 197 *
 198 *  @param[in]   Pst*  pst
 199 *  @param[in]   SuId  suId
 200 *  @param[in]   U8  status
 201 *  @return   S16
 202 *      -# ROK
 203 **/
 204 #ifdef ANSI
 205 PUBLIC S16 cmPkCtfBndCfm
 206 (
 207 Pst* pst,
 208 SuId suId,
 209 U8 status
 210 )
 211 #else
 212 PUBLIC S16 cmPkCtfBndCfm(pst, suId, status)
 213 Pst* pst;
 214 SuId suId;
 215 U8 status;
 216 #endif
 217 {
 218    Buffer *mBuf = NULLP;
 219    TRC3(cmPkCtfBndCfm)
 220
 221    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 222 #if (ERRCLASS & ERRCLS_ADD_RES)
 223       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 224       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 225          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 226          (ErrVal)ECTF006, (ErrVal)0, (Txt*)&"Packing failed");
 227 #endif
 228       RETVALUE(RFAILED);
 229    }
 230    if (SPkU8(status, mBuf) != ROK) {
 231 #if (ERRCLASS & ERRCLS_ADD_RES)
 232       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 233       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 234          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 235          (ErrVal)ECTF007, (ErrVal)0, (Txt*)&"Packing failed");
 236 #endif
 237       SPutMsg(mBuf);
 238       RETVALUE(RFAILED);
 239    }
 240    if (SPkS16(suId, mBuf) != ROK) {
 241 #if (ERRCLASS & ERRCLS_ADD_RES)
 242       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 243       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 244          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 245          (ErrVal)ECTF008, (ErrVal)0, (Txt*)&"Packing failed");
 246 #endif
 247       SPutMsg(mBuf);
 248       RETVALUE(RFAILED);
 249    }
 250    pst->event = (Event) EVTCTFBNDCFM;
 251    RETVALUE(SPstTsk(pst,mBuf));
 252 }
 253
 254 \f
 255 /**
 256 * @brief Confirmation from PHY to RRC for the bind
 257  * request for the CTF interface SAP.
 258 *
 259 * @details
 260 *
 261 *     Function: cmUnpkCtfBndCfm
 262 *
 263 *  @param[in]   Pst*  pst
 264 *  @param[in]   SuId  suId
 265 *  @param[in]   U8  status
 266 *  @return   S16
 267 *      -# ROK
 268 **/
 269 #ifdef ANSI
 270 PUBLIC S16 cmUnpkCtfBndCfm
 271 (
 272 CtfBndCfm func,
 273 Pst *pst,
 274 Buffer *mBuf
 275 )
 276 #else
 277 PUBLIC S16 cmUnpkCtfBndCfm(func, pst, mBuf)
 278 CtfBndCfm func;
 279 Pst *pst;
 280 Buffer *mBuf;
 281 #endif
 282 {
 283    SuId suId = 0;
 284    U8 status;
 285
 286    TRC3(cmUnpkCtfBndCfm)
 287
 288    if (SUnpkS16(&suId, mBuf) != ROK) {
 289       SPutMsg(mBuf);
 290 #if (ERRCLASS & ERRCLS_ADD_RES)
 291       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 292       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 293          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 294          (ErrVal)ECTF009, (ErrVal)0, (Txt*)&"Packing failed");
 295 #endif
 296       RETVALUE(RFAILED);
 297    }
 298    if (SUnpkU8(&status, mBuf) != ROK) {
 299       SPutMsg(mBuf);
 300 #if (ERRCLASS & ERRCLS_ADD_RES)
 301       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 302       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 303          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 304          (ErrVal)ECTF010, (ErrVal)0, (Txt*)&"Packing failed");
 305 #endif
 306       RETVALUE(RFAILED);
 307    }
 308    SPutMsg(mBuf);
 309    RETVALUE((*func)(pst, suId, status));
 310 }
 311
 312 \f
 313 /**
 314 * @brief Request from RRC to PHY to Unbind the CTF interface SAP.
 315 *
 316 * @details
 317 *
 318 *     Function: cmPkCtfUbndReq
 319 *
 320 *  @param[in]   Pst*  pst
 321 *  @param[in]   SpId  spId
 322 *  @param[in]   Reason  reason
 323 *  @return   S16
 324 *      -# ROK
 325 **/
 326 #ifdef ANSI
 327 PUBLIC S16 cmPkCtfUbndReq
 328 (
 329 Pst* pst,
 330 SpId spId,
 331 Reason reason
 332 )
 333 #else
 334 PUBLIC S16 cmPkCtfUbndReq(pst, spId, reason)
 335 Pst* pst;
 336 SpId spId;
 337 Reason reason;
 338 #endif
 339 {
 340    Buffer *mBuf = NULLP;
 341    TRC3(cmPkCtfUbndReq)
 342
 343    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 344 #if (ERRCLASS & ERRCLS_ADD_RES)
 345       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 346       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 347          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 348          (ErrVal)ECTF011, (ErrVal)0, (Txt*)&"Packing failed");
 349 #endif
 350       RETVALUE(RFAILED);
 351    }
 352    if (SPkS16(reason, mBuf) != ROK) {
 353 #if (ERRCLASS & ERRCLS_ADD_RES)
 354       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 355       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 356          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 357          (ErrVal)ECTF012, (ErrVal)0, (Txt*)&"Packing failed");
 358 #endif
 359       SPutMsg(mBuf);
 360       RETVALUE(RFAILED);
 361    }
 362    if (SPkS16(spId, mBuf) != ROK) {
 363 #if (ERRCLASS & ERRCLS_ADD_RES)
 364       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 365       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 366          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 367          (ErrVal)ECTF013, (ErrVal)0,(Txt*)&"Packing failed");
 368 #endif
 369       SPutMsg(mBuf);
 370       RETVALUE(RFAILED);
 371    }
 372    pst->event = (Event) EVTCTFUBNDREQ;
 373    RETVALUE(SPstTsk(pst,mBuf));
 374 }
 375
 376 \f
 377 /**
 378 * @brief Request from RRC to PHY to Unbind the CTF interface SAP.
 379 *
 380 * @details
 381 *
 382 *     Function: cmUnpkCtfUbndReq
 383 *
 384 *  @param[in]   Pst*  pst
 385 *  @param[in]   SpId  spId
 386 *  @param[in]   Reason  reason
 387 *  @return   S16
 388 *      -# ROK
 389 **/
 390 #ifdef ANSI
 391 PUBLIC S16 cmUnpkCtfUbndReq
 392 (
 393 CtfUbndReq func,
 394 Pst *pst,
 395 Buffer *mBuf
 396 )
 397 #else
 398 PUBLIC S16 cmUnpkCtfUbndReq(func, pst, mBuf)
 399 CtfUbndReq func;
 400 Pst *pst;
 401 Buffer *mBuf;
 402 #endif
 403 {
 404    SpId spId = 0;
 405    Reason reason = 0;
 406
 407    TRC3(cmUnpkCtfUbndReq)
 408
 409    if (SUnpkS16(&spId, mBuf) != ROK) {
 410       SPutMsg(mBuf);
 411 #if (ERRCLASS & ERRCLS_ADD_RES)
 412       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 413       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 414          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 415          (ErrVal)ECTF014, (ErrVal)0, (Txt*)&"Packing failed");
 416 #endif
 417       RETVALUE(RFAILED);
 418    }
 419    if (SUnpkS16(&reason, mBuf) != ROK) {
 420       SPutMsg(mBuf);
 421 #if (ERRCLASS & ERRCLS_ADD_RES)
 422       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 423       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 424          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 425          (ErrVal)ECTF015, (ErrVal)0, (Txt*)&"Packing failed");
 426 #endif
 427       RETVALUE(RFAILED);
 428    }
 429    SPutMsg(mBuf);
 430    RETVALUE((*func)(pst, spId, reason));
 431 }
 432
 433 \f
 434 /***********************************************************
 435 *
 436 *     Func: cmRelCtfCfgReq
 437 *
 438 *
 439 *     Desc:  This fucntion will release the memory used for ctf cfg req
 440 *
 441 *     Ret: S16
 442 *
 443 *     Notes:
 444 *
 445 *     File:
 446 *
 447 **********************************************************/
 448 #ifdef ANSI
 449 PRIVATE S16 cmRelCtfCfgReq
 450 (
 451 Pst  *pst,
 452 CtfCfgReqInfo *cfgReqInfo
 453 )
 454 #else
 455 PRIVATE S16 cmRelCtfCfgReq(pst,cfgReqInfo)
 456 Pst  *pst;
 457 CtfCfgReqInfo *param;
 458 #endif
 459 {
 460    /* ctf_c_001.main_4: Added support for vendor specific parameters */
 461 #ifdef CTF_VER3
 462    if(cfgReqInfo->vendorParams.paramBuffer != NULLP) {
 463       SPutSBuf(pst->region, pst->pool,
 464                    (Data *)cfgReqInfo->vendorParams.paramBuffer,
 465                    cfgReqInfo->vendorParams.buffLen);
 466    }
 467 #endif
 468    SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCfgReqInfo));
 469    RETVALUE(ROK);
 470 }
 471
 472 #ifdef TENB_AS_SECURITY
 473 /***********************************************************
 474 *
 475 *     Func: cmPkCtfNhKeyInfo
 476 *
 477 *
 478 *     Desc:   Pack keNB* input parameter information
 479  * @details This is one of the main structure in the KDF request primitive.
 480  *    -# This structure contains the configuration information as given by
 481  *       the Application to trigger key derivation at PHY layer for generation of kENB*.
 482  *    -# It take Next Hop key, DL Frequency and Physical cell Id as input.
 483  *    -# The result of configuration is indicated in KdfCfgCfm.
 484 *
 485 *
 486 *     Ret: S16
 487 *
 488 *     Notes:
 489 *
 490 *     File:
 491 *
 492 **********************************************************/
 493 #ifdef ANSI
 494 PUBLIC S16 cmPkCtfNhKeyInfo
 495 (
 496 CtfNhKeyInfo *param,
 497 Buffer *mBuf
 498 )
 499 #else
 500 PUBLIC S16 cmPkCtfNhKeyInfo(param, mBuf)
 501 CtfNhKeyInfo *param;
 502 Buffer *mBuf;
 503 #endif
 504 {
 505
 506    S16  idx;
 507
 508    TRC3(cmPkCtfNhKeyInfo)
 509
 510    for(idx=31;idx>=0;idx--)
 511    {
 512       CMCHKPK(SPkU8,param->secKey[idx],mBuf);
 513    }
 514    CMCHKPK(SPkU16, param->physCellId, mBuf);
 515    CMCHKPK(SPkU16, param->dlCarrFreq, mBuf);
 516
 517    RETVALUE(ROK);
 518 }
 519
 520 /***********************************************************
 521 *
 522 *     Func: cmPkCtfKenbStarInfo
 523 *
 524 *
 525 *     Desc:   Pack keNB* input parameter information
 526  * @details This is one of the main structure in the KDF request primitive.
 527  *    -# This structure contains the configuration information as given by
 528  *       the Application to trigger key derivation at PHY layer for generation of kENB*.
 529  *    -# It take existing kENB, DL Frequency and Physical cell Id as input.
 530  *    -# The result of configuration is indicated in KdfCfgCfm.
 531 *
 532 *
 533 *     Ret: S16
 534 *
 535 *     Notes:
 536 *
 537 *     File:
 538 *
 539 **********************************************************/
 540 #ifdef ANSI
 541 PUBLIC S16 cmPkCtfKenbStarInfo
 542 (
 543 CtfKenbStarInfo *param,
 544 Buffer *mBuf
 545 )
 546 #else
 547 PUBLIC S16 cmPkCtfKenbStarInfo(param, mBuf)
 548 CtfKenbStarInfo *param;
 549 Buffer *mBuf;
 550 #endif
 551 {
 552
 553    S16  idx;
 554
 555    TRC3(cmPkCtfKenbStarInfo)
 556
 557    for(idx=31;idx>=0;idx--)
 558    {
 559       CMCHKPK(SPkU8,param->secKey[idx],mBuf);
 560    }
 561    CMCHKPK(SPkU16, param->physCellId, mBuf);
 562    CMCHKPK(SPkU16, param->dlCarrFreq, mBuf);
 563
 564    RETVALUE(ROK);
 565 }
 566
 567
 568 /***********************************************************
 569 *
 570 *     Func: cmPkCtfAskeyInfo
 571 *
 572 *
 573 *     Desc:   Pack AS key generation input parameter information.
 574  * @details This is one of the main structure in the KDF request primitive.
 575  *    -# This structure contains the configuration information as given by
 576  *       the Application to trigger key derivation at PHY layer for generation of AS Security keys.
 577  *    -# It take existing kENB, and integrity/cipherig Algorithm as input.
 578  *    -# The result of configuration is indicated in KdfCfgCfm.
 579 *
 580 *
 581 *     Ret: S16
 582 *
 583 *     Notes:
 584 *
 585 *     File:
 586 *
 587 **********************************************************/
 588 #ifdef ANSI
 589 PUBLIC S16 cmPkCtfAskeyInfo
 590 (
 591 CtfAsKeyInfo *param,
 592 Buffer *mBuf
 593 )
 594 #else
 595 PUBLIC S16 cmPkCtfAskeyInfo(param, mBuf)
 596 CtfAsKeyInfo *param;
 597 Buffer *mBuf;
 598 #endif
 599 {
 600
 601    S16  idx;
 602
 603    TRC3(cmPkCtfAskeyInfo)
 604
 605
 606    for(idx=31;idx>=0;idx--)
 607    {
 608       CMCHKPK(SPkU8,param->secKey[idx],mBuf);
 609    }
 610    CMCHKPK(SPkU8, param->ciphAlgoType, mBuf);
 611    CMCHKPK(SPkU8, param->intgAlgoType, mBuf);
 612
 613    RETVALUE(ROK);
 614 }
 615
 616 /***********************************************************
 617 *
 618 *     Func: cmPkCtfKdfReqInfo
 619 *
 620 *
 621 *     Desc:   Pack one of the 3 Key Derivation types.
 622  * @details This is the encompassing structure in the KDF request primitive.
 623  *    -# This structure contains the configuration information as given by
 624  *       the Application to trigger key derivation at PHY layer for generation of keys.
 625  *    -# It takes key derivation type as input.
 626  *    -# The result of configuration is indicated in KdfCfgCfm.
 627 *
 628 *
 629 *     Ret: S16
 630 *
 631 *     Notes:
 632 *
 633 *     File:
 634 *
 635 **********************************************************/
 636 #ifdef ANSI
 637 PUBLIC S16 cmPkCtfKdfReqInfo
 638 (
 639 CtfKdfReqInfo *param,
 640 Buffer *mBuf
 641  )
 642 #else
 643 PUBLIC S16 cmPkCtfKdfReqInfo(param, mBuf)
 644 CtfKdfReqInfo *param;
 645 Buffer *mBuf;
 646 #endif
 647 {
 648
 649    TRC3(cmPkCtfKdfReqInfo)
 650
 651    switch (param->keyDerType)
 652     {
 653          case CTF_KDF_TYPE1:
 654              CMCHKPK(cmPkCtfAskeyInfo, &param->u.kEnbInf, mBuf);
 655              break;
 656          case CTF_KDF_TYPE2:
 657             CMCHKPK(cmPkCtfKenbStarInfo, &param->u.kEnbStarInf, mBuf);
 658             break;
 659          case CTF_KDF_TYPE3:
 660             CMCHKPK(cmPkCtfNhKeyInfo , &param->u.nhKeyInf, mBuf);
 661              break;
 662          default :
 663             RETVALUE(RFAILED);
 664     }
 665     CMCHKPK(SPkU8, param->keyDerType, mBuf);
 666
 667    RETVALUE(ROK);
 668 }
 669
 670 /**
 671 * @brief Primitive Request from Application to PHY for
 672  * security key derivation.
 673 *
 674 * @details
 675 *
 676 *     Function: cmPkCtfKdfReq
 677 *
 678 *  @param[in]   Pst*  pst
 679 *  @param[in]   SpId  spId
 680 *  @param[in]   CtfCfgTransId  transId
 681 *  @param[in]   CtfCfgReqInfo*  cfgReqInfo
 682 *  @return   S16
 683 *      -# ROK
 684 **/
 685 #ifdef ANSI
 686 PUBLIC S16 cmPkCtfKdfReq
 687 (
 688 Pst* pst,
 689 SpId spId,
 690 CtfCfgTransId transId,
 691 CtfKdfReqInfo* kdfReqInfo
 692 )
 693 #else
 694 PUBLIC S16 cmPkCtfKdfReq(pst, spId, transId, kdfReqInfo)
 695 Pst* pst;
 696 SpId spId;
 697 CtfCfgTransId transId;
 698 CtfKdfReqInfo* kdfReqInfo;
 699 #endif
 700 {
 701    Buffer *mBuf = NULLP;
 702
 703
 704    TRC3(cmPkCtfKdfReq)
 705
 706    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 707 #if (ERRCLASS & ERRCLS_ADD_RES)
 708       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 709       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 710          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 711          (ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
 712 #endif
 713       SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
 714       RETVALUE(RFAILED);
 715    }
 716    if (pst->selector == CTF_SEL_LC) {
 717       if (cmPkCtfKdfReqInfo(kdfReqInfo, mBuf) != ROK) {
 718 #if (ERRCLASS & ERRCLS_ADD_RES)
 719       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 720          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 721             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 722             (ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
 723 #endif
 724          SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
 725          SPutMsg(mBuf);
 726          RETVALUE(RFAILED);
 727       }
 728    }
 729    else if (pst->selector == CTF_SEL_LWLC) {
 730         #if 0
 731       if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
 732 #if (ERRCLASS & ERRCLS_ADD_RES)
 733       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 734          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 735             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 736             (ErrVal)ECTF018, (ErrVal)0, (Txt*)&"Packing failed");
 737 #endif
 738          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCfgReqInfo));
 739          SPutMsg(mBuf);
 740          RETVALUE(RFAILED);
 741       }
 742           #endif
 743    }
 744    if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
 745 #if (ERRCLASS & ERRCLS_ADD_RES)
 746       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 747       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 748          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 749          (ErrVal)ECTF019, (ErrVal)0, (Txt*)&"Packing failed");
 750 #endif
 751       SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
 752       SPutMsg(mBuf);
 753       RETVALUE(RFAILED);
 754    }
 755    if (SPkS16(spId, mBuf) != ROK) {
 756 #if (ERRCLASS & ERRCLS_ADD_RES)
 757       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 758       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 759          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 760          (ErrVal)ECTF020, (ErrVal)0, (Txt*)&"Packing failed");
 761 #endif
 762       SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
 763       SPutMsg(mBuf);
 764       RETVALUE(RFAILED);
 765    }
 766    if (pst->selector != CTF_SEL_LWLC) {
 767       if (SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo)) != ROK) {
 768 #if (ERRCLASS & ERRCLS_ADD_RES)
 769       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 770       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 771          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 772          (ErrVal)ECTF021, (ErrVal)0, (Txt*)&"Packing failed");
 773 #endif
 774          SPutMsg(mBuf);
 775          RETVALUE(RFAILED);
 776       }
 777    }
 778    pst->event = (Event) EVTCTFKDFREQ;
 779    RETVALUE(SPstTsk(pst,mBuf));
 780 }
 781 #endif
 782
 783 /********************************************************************************************************************************/
 784                               /*START OF CNM PACK & UNPACK FUNCTIONS*/
 785 /********************************************************************************************************************************/
 786 #ifdef ANSI
 787 PUBLIC S16 cmPkCtfCnmVendorSpecificInfo
 788 (
 789 CtfCnmVendorSpecificInfo *param,
 790 Buffer *mBuf
 791 )
 792 #else
 793 CtfCnmVendorSpecificInfo *param;
 794 Buffer *mBuf;
 795 #endif
 796 {
 797    S32 i;
 798    TRC3(cmPkCtfCnmVendorSpecificInfo);
 799    if(param->numOfVendorSpecifcParam <= CTF_CNM_MAX_VENDOR_PARAMS)
 800    {
 801       for(i= param->numOfVendorSpecifcParam-1; i >= 0; i--)
 802       {
 803          CMCHKPK(SPkU32,(U32)param->vendorSpecifcParam[i], mBuf);
 804       }
 805    }
 806    CMCHKPK(SPkU16, param->numOfVendorSpecifcParam, mBuf);
 807    RETVALUE(ROK);
 808 }
 809
 810 #ifdef ANSI
 811 PUBLIC S16 cmPkCtfCtfCnmCellSyncReq
 812 (
 813 CtfCnmCellSyncReq *param,
 814 Buffer *mBuf
 815 )
 816 #else
 817 PUBLIC S16 cmPkCtfCtfCnmCellSyncReq(param, mBuf)
 818 CtfCnmCellSyncReq *param;
 819 Buffer *mBuf;
 820 #endif
 821 {
 822
 823    TRC3(cmPkCtfCtfCnmCellSyncReq);
 824    CMCHKPK(SPkU16, param->nbrEarfcn, mBuf);
 825    CMCHKPK(SPkU16, param->nbrPCellId, mBuf);
 826    CMCHKPK(SPkU8, param->nbrTxAntCount, mBuf);
 827    CMCHKPK(SPkU8, param->nbrCellCp, mBuf);
 828    CMCHKPK(SPkU8, param->nbrCellNRb, mBuf);
 829    CMCHKPK(SPkU8, param->nbrSpecSfCfg, mBuf);
 830    CMCHKPK(cmPkCtfCnmVendorSpecificInfo, &param->ctfCnmVendorSpecificInfo, mBuf);
 831    RETVALUE(ROK);
 832
 833 }
 834
 835 #ifdef ANSI
 836 PUBLIC S16 cmPkCtfcfgReqInfo
 837 (
 838 CtfCnmInitSyncReq *param,
 839 Buffer *mBuf
 840 )
 841 #else
 842 PUBLIC S16 cmPkCtfcfgReqInfo(param, mBuf)
 843 CtfCnmInitSyncReq *param;
 844 Buffer *mBuf;
 845 #endif
 846 {
 847    S32 i;
 848    TRC3(cmPkCtfcfgReqInfo);
 849
 850    CMCHKPK(SPkU8, param->searchType, mBuf);
 851    CMCHKPK(SPkU8, param->mibRequest, mBuf);
 852    CMCHKPK(SPkU16, param->earfcn, mBuf);
 853    CMCHKPK(SPkU8, param->measBandWidth, mBuf);
 854    if(param->numOfPciList <= CTF_CNM_MAX_CELL_SEARCH)
 855    {
 856       for(i= param->numOfPciList-1; i >= 0; i--)
 857       {
 858          CMCHKPK(cmPkCtfCtfCnmCellSyncReq, &param->pciList[i], mBuf);
 859       }
 860    }
 861    CMCHKPK(SPkU16, param->numOfPciList, mBuf);
 862    RETVALUE(ROK);
 863
 864 }
 865 #ifdef ANSI
 866 PUBLIC S16 cmUnpkCtfCnmVendorSpecificInfo
 867 (
 868 CtfCnmVendorSpecificInfo *param,
 869 Buffer *mBuf
 870 )
 871 #else
 872 PUBLIC S16 cmUnpkCtfCnmVendorSpecificInfo(param, mBuf)
 873 CtfCnmVendorSpecificInfo *param;
 874 Buffer *mBuf;
 875 #endif
 876 {
 877    S32 i;
 878    TRC3(cmUnpkCtfCnmVendorSpecificInfo);
 879
 880    CMCHKUNPK(SUnpkU16, &param->numOfVendorSpecifcParam, mBuf);
 881    for(i=0; (i<param->numOfVendorSpecifcParam)&&(i < CTF_CNM_MAX_VENDOR_PARAMS); i++)
 882    {
 883       CMCHKUNPK(SUnpkU32, &param->vendorSpecifcParam[i], mBuf);
 884    }
 885    RETVALUE(ROK);
 886 }
 887
 888 #ifdef ANSI
 889 PUBLIC S16 cmUnpkCtfCtfCnmCellSyncReq
 890 (
 891 CtfCnmCellSyncReq *param,
 892 Buffer *mBuf
 893 )
 894 #else
 895 PUBLIC S16 cmUnpkCtfCtfCnmCellSyncReq(param, mBuf)
 896 CtfCnmCellSyncReq *param;
 897 Buffer *mBuf;
 898 #endif
 899 {
 900    TRC3(cmUnpkCtfCtfCnmCellSyncReq);
 901
 902
 903    CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, &param->ctfCnmVendorSpecificInfo, mBuf);
 904    CMCHKUNPK(SUnpkU8, &param->nbrSpecSfCfg, mBuf);
 905    CMCHKUNPK(SUnpkU8, &param->nbrCellNRb, mBuf);
 906    CMCHKUNPK(SUnpkU8, &param->nbrCellCp, mBuf);
 907    CMCHKUNPK(SUnpkU8, &param->nbrTxAntCount, mBuf);
 908    CMCHKUNPK(SUnpkU16, &param->nbrPCellId, mBuf);
 909    CMCHKUNPK(SUnpkU16, &param->nbrEarfcn, mBuf);
 910    RETVALUE(ROK);
 911
 912 }
 913
 914 #ifdef ANSI
 915 PUBLIC S16 cmUnpkCtfsyncReqInfo
 916 (
 917 CtfCnmInitSyncReq *param,
 918 Buffer *mBuf
 919 )
 920 #else
 921 PUBLIC S16 cmUnpkCtfsyncReqInfo(param, mBuf)
 922 CtfCnmInitSyncReq *param;
 923 Buffer *mBuf;
 924 #endif
 925 {
 926    S32 i;
 927    TRC3(cmUnpkCtfsyncReqInfo);
 928
 929    CMCHKUNPK(SUnpkU16, &param->numOfPciList, mBuf);
 930    for(i=0; (i < param->numOfPciList)&&(i < CTF_CNM_MAX_CELL_SEARCH); i++)
 931    {
 932       CMCHKUNPK(cmUnpkCtfCtfCnmCellSyncReq, &param->pciList[i], mBuf);
 933    }
 934
 935    CMCHKUNPK(SUnpkU8, &param->measBandWidth, mBuf);
 936    CMCHKUNPK(SUnpkU16, &param->earfcn, mBuf);
 937    CMCHKUNPK(SUnpkU8, &param->mibRequest, mBuf);
 938    CMCHKUNPK(SUnpkU8, &param->searchType, mBuf);
 939    RETVALUE(ROK);
 940 }
 941 /**
 942 * @brief Configuration Request from App to CL for
 943  * cnm Cell Sync request.
 944 *
 945 * @details
 946 *
 947 *     Function: cmPkCtfCnmCellSyncReq
 948 *
 949 *  @param[in]   Pst*  pst
 950 *  @param[in]   SpId  spId
 951 *  @param[in]   CtfCfgTransId  * transId
 952 *  @param[in]   CtfCnmCellSyncReq* ctfcnmCellSyncReq
 953 *  @return   S16
 954 *      -# ROK
 955 **/
 956 #ifdef ANSI
 957 PUBLIC S16 cmPkCtfCnmCellSyncReq
 958 (
 959 Pst* pst,
 960 SpId spId,
 961 CtfCfgTransId *transId,
 962 CtfCnmCellSyncReq * cfgReqInfo
 963 )
 964 #else
 965 PUBLIC S16 cmPkCtfCnmCellSyncReq(pst, spId, transId, cfgReqInfo)
 966 Pst* pst;
 967 SpId spId;
 968 CtfCfgTransId *transId;
 969 CtfCnmCellSyncReq * cfgReqInfo;
 970 #endif
 971 {
 972
 973    Buffer *mBuf = NULLP;
 974
 975    TRC3(cmPkCtfCnmCellSyncReq)
 976
 977    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 978 #if (ERRCLASS & ERRCLS_ADD_RES)
 979       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 980       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 981          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 982          (ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
 983 #endif
 984       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
 985       RETVALUE(RFAILED);
 986    }
 987    if (pst->selector == CTF_SEL_LC) {
 988       if (cmPkCtfCtfCnmCellSyncReq(cfgReqInfo, mBuf) != ROK) {
 989 #if (ERRCLASS & ERRCLS_ADD_RES)
 990       /* ctf_c_001.main_3 Compilation warning fix with g++ */
 991          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 992             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 993             (ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
 994 #endif
 995          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
 996          SPutMsg(mBuf);
 997          RETVALUE(RFAILED);
 998       }
 999    }
1000    else if (pst->selector == CTF_SEL_LWLC) {
1001
1002    if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
1003 #if (ERRCLASS & ERRCLS_ADD_RES)
1004       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1005          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1006             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1007             (ErrVal)ECTF018, (ErrVal)0, "Packing failed");
1008 #endif
1009          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
1010          SPutMsg(mBuf);
1011          RETVALUE(RFAILED);
1012       }
1013
1014    }
1015    if(cmPkCtfCfgTransId(transId, mBuf) != ROK) {
1016 #if (ERRCLASS & ERRCLS_ADD_RES)
1017       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1018       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1019          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1020          (ErrVal)ECTF019, (ErrVal)0, "Packing failed");
1021 #endif
1022       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
1023       SPutMsg(mBuf);
1024       RETVALUE(RFAILED);
1025    }
1026  if (SPkS16(spId, mBuf) != ROK) {
1027 #if (ERRCLASS & ERRCLS_ADD_RES)
1028       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1029       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1030          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1031          (ErrVal)ECTF020, (ErrVal)0, "Packing failed");
1032 #endif
1033       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
1034       SPutMsg(mBuf);
1035       RETVALUE(RFAILED);
1036    }
1037    if (pst->selector != CTF_SEL_LWLC) {
1038       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmCellSyncReq));
1039    }
1040    pst->event = (Event)EVTCTFCNMSYNCREQ;
1041    RETVALUE(SPstTsk(pst,mBuf));
1042
1043 }
1044 /**
1045 * @brief Configuration Request from RRC to PHY for
1046  * cell or dedicated configuration.
1047 *
1048 * @details
1049 *
1050 *     Function: cmUnpkCtfCnmCellSyncReq
1051 *
1052 *  @param[in]   CtfCnmCellSyncReqMsg func
1053 *  @param[in]   Pst*  pst
1054 *  @param[in]   Buffer *mBuf
1055 *  @return   S16
1056 *      -# ROK
1057 **/
1058 #ifdef ANSI
1059 PUBLIC S16 cmUnpkCtfCnmCellSyncReq
1060 (
1061 CtfCnmCellSyncReqMsg func,
1062 Pst *pst,
1063 Buffer *mBuf
1064 )
1065 #else
1066 PUBLIC S16 cmUnpkCtfCnmCellSyncReq(func, pst, mBuf)
1067 CtfCnmCellSyncReqMsg func;
1068 Pst *pst;
1069 Buffer *mBuf;
1070 #endif
1071 {
1072
1073    SpId spId = 0;
1074    CtfCfgTransId transId;
1075    CtfCnmCellSyncReq *SyncReqMsg = NULLP;
1076    TRC3(cmUnpkCtfCnmCellSyncReq)
1077
1078    if (SUnpkS16(&spId, mBuf) != ROK) {
1079       SPutMsg(mBuf);
1080 #if (ERRCLASS & ERRCLS_ADD_RES)
1081       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1082       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1083          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1084          (ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
1085 #endif
1086       RETVALUE(RFAILED);
1087    }
1088    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
1089       SPutMsg(mBuf);
1090 #if (ERRCLASS & ERRCLS_ADD_RES)
1091       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1092       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1093          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1094          (ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
1095 #endif
1096       RETVALUE(RFAILED);
1097    }
1098    if (pst->selector != CTF_SEL_LWLC) {
1099       if ((SGetSBuf(pst->region, pst->pool, (Data **)&SyncReqMsg, sizeof(CtfCnmCellSyncReq))) != ROK) {
1100 #if (ERRCLASS & ERRCLS_ADD_RES)
1101       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1102          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1103             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1104             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
1105 #endif
1106          SPutMsg(mBuf);
1107          RETVALUE(RFAILED);
1108       }
1109    }
1110    if (pst->selector == CTF_SEL_LWLC) {
1111       if (cmUnpkPtr((PTR *)&SyncReqMsg, mBuf) != ROK) {
1112          SPutMsg(mBuf);
1113          RETVALUE(RFAILED);
1114       }
1115    }
1116   else if (pst->selector == CTF_SEL_LC)
1117       if (cmUnpkCtfCtfCnmCellSyncReq(SyncReqMsg, mBuf) != ROK) {
1118       SPutSBuf(pst->region, pst->pool, (Data *)SyncReqMsg, sizeof(CtfCnmCellSyncReq));
1119       SPutMsg(mBuf);
1120 #if (ERRCLASS & ERRCLS_ADD_RES)
1121       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1122       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1123          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1124          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
1125 #endif
1126       RETVALUE(RFAILED);
1127    }
1128    SPutMsg(mBuf);
1129    RETVALUE((*func)(pst, spId, &transId, SyncReqMsg));
1130
1131 }
1132 /*-----------------------------------------------------*/
1133
1134
1135 /**
1136 * @brief Configuration Request from App to CL for
1137  * cnm Init Sync request.
1138 *
1139 * @details
1140 *
1141 *     Function: cmPkCtfCnmInitSyncReq
1142 *
1143 *  @param[in]   Pst*  pst
1144 *  @param[in]   SpId  spId
1145 *  @param[in]   CtfCfgTransId  * transId
1146 *  @param[in]   CtfCnmInitSyncReq* ctfcnmInitSyncReq
1147 *  @return   S16
1148 *      -# ROK
1149 **/
1150 #ifdef ANSI
1151 PUBLIC S16 cmPkCtfCnmInitSyncReq
1152 (
1153 Pst* pst,
1154 SpId spId,
1155 CtfCfgTransId *transId,
1156 CtfCnmInitSyncReq * cfgReqInfo
1157 )
1158 #else
1159 PUBLIC S16 cmPkCtfCnmInitSyncReq(pst, spId, transId, cfgReqInfo)
1160 Pst* pst;
1161 SpId spId;
1162 CtfCfgTransId *transId;
1163 CtfCnmInitSyncReq * cfgReqInfo;
1164 #endif
1165 {
1166    Buffer *mBuf = NULLP;
1167
1168    TRC3(cmPkCtfCnmInitSyncReq)
1169
1170    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1171 #if (ERRCLASS & ERRCLS_ADD_RES)
1172       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1173       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1174          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1175          (ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
1176 #endif
1177       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
1178       RETVALUE(RFAILED);
1179    }
1180    if (pst->selector == CTF_SEL_LC) {
1181       if (cmPkCtfcfgReqInfo(cfgReqInfo, mBuf) != ROK) {
1182 #if (ERRCLASS & ERRCLS_ADD_RES)
1183       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1184          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1185             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1186             (ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
1187 #endif
1188          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
1189          SPutMsg(mBuf);
1190          RETVALUE(RFAILED);
1191       }
1192    }
1193    else if (pst->selector == CTF_SEL_LWLC) {
1194
1195    if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
1196 #if (ERRCLASS & ERRCLS_ADD_RES)
1197       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1198          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1199             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1200             (ErrVal)ECTF018, (ErrVal)0, "Packing failed");
1201 #endif
1202          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
1203          SPutMsg(mBuf);
1204          RETVALUE(RFAILED);
1205       }
1206
1207    }
1208    if(cmPkCtfCfgTransId(transId, mBuf) != ROK) {
1209 #if (ERRCLASS & ERRCLS_ADD_RES)
1210       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1211       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1212          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1213          (ErrVal)ECTF019, (ErrVal)0, "Packing failed");
1214 #endif
1215       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
1216       SPutMsg(mBuf);
1217       RETVALUE(RFAILED);
1218    }
1219  if (SPkS16(spId, mBuf) != ROK) {
1220 #if (ERRCLASS & ERRCLS_ADD_RES)
1221       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1222       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1223          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1224          (ErrVal)ECTF020, (ErrVal)0, "Packing failed");
1225 #endif
1226       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
1227       SPutMsg(mBuf);
1228       RETVALUE(RFAILED);
1229    }
1230    if (pst->selector != CTF_SEL_LWLC) {
1231       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CtfCnmInitSyncReq));
1232    }
1233    pst->event = (Event)EVTCTFCNMINITSYNCREQ;
1234    RETVALUE(SPstTsk(pst,mBuf));
1235
1236 }
1237 /*-----------------------------------------------------------------*/
1238
1239 /**
1240 * @brief Configuration Request from RRC to PHY for
1241  * cell or dedicated configuration.
1242 *
1243 * @details
1244 *
1245 *     Function: cmUnpkCtfCnmInitSyncReq
1246 *
1247 *  @param[in]   CtfCnmInitSyncReqMsg func
1248 *  @param[in]   Pst*  pst
1249 *  @param[in]   Buffer *mBuf
1250 *  @return   S16
1251 *      -# ROK
1252 **/
1253 #ifdef ANSI
1254 PUBLIC S16 cmUnpkCtfCnmInitSyncReq
1255 (
1256 CtfCnmInitSyncReqMsg func,
1257 Pst *pst,
1258 Buffer *mBuf
1259 )
1260 #else
1261 PUBLIC S16 cmUnpkCtfCnmInitSyncReq(func, pst, mBuf)
1262 CtfCnmInitSyncReqMsg func;
1263 Pst *pst;
1264 Buffer *mBuf;
1265 #endif
1266 {
1267
1268    SpId spId = 0;
1269    CtfCfgTransId transId;
1270    CtfCnmInitSyncReq *syncReqInfo = NULLP;
1271    TRC3(cmUnpkCtfCnmInitSyncReq)
1272
1273    if (SUnpkS16(&spId, mBuf) != ROK) {
1274       SPutMsg(mBuf);
1275 #if (ERRCLASS & ERRCLS_ADD_RES)
1276       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1277       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1278          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1279          (ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
1280 #endif
1281       RETVALUE(RFAILED);
1282    }
1283    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
1284       SPutMsg(mBuf);
1285 #if (ERRCLASS & ERRCLS_ADD_RES)
1286       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1287       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1288          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1289          (ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
1290 #endif
1291       RETVALUE(RFAILED);
1292    }
1293    if (pst->selector != CTF_SEL_LWLC) {
1294       if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncReqInfo, sizeof(CtfCnmInitSyncReq))) != ROK) {
1295 #if (ERRCLASS & ERRCLS_ADD_RES)
1296       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1297          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1298             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1299             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
1300 #endif
1301          SPutMsg(mBuf);
1302          RETVALUE(RFAILED);
1303       }
1304    }
1305    if (pst->selector == CTF_SEL_LWLC) {
1306       if (cmUnpkPtr((PTR *)&syncReqInfo, mBuf) != ROK) {
1307          SPutMsg(mBuf);
1308          RETVALUE(RFAILED);
1309       }
1310    }
1311   else if (pst->selector == CTF_SEL_LC)
1312       if (cmUnpkCtfsyncReqInfo(syncReqInfo, mBuf) != ROK) {
1313       SPutSBuf(pst->region, pst->pool, (Data *)syncReqInfo, sizeof(CtfCnmInitSyncReq));
1314       SPutMsg(mBuf);
1315 #if (ERRCLASS & ERRCLS_ADD_RES)
1316       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1317       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1318          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1319          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
1320 #endif
1321       RETVALUE(RFAILED);
1322    }
1323    SPutMsg(mBuf);
1324    RETVALUE((*func)(pst, spId, &transId, syncReqInfo));
1325 }
1326 /*-----------------------------------------------------------------------------*/
1327
1328 #ifdef ANSI
1329 PUBLIC S16 cmPkCtfctfCnmMibInfo
1330 (
1331 CtfCnmMibInfo *param,
1332 Buffer *mBuf
1333 )
1334 #else
1335 PUBLIC S16 cmPkCtfctfCnmMibInfo(param, mBuf)
1336 CtfCnmMibInfo *param;
1337 Buffer *mBuf;
1338 #endif
1339 {
1340    TRC3(cmPkCtfctfCnmMibInfo)
1341
1342    CMCHKPK(SPkU16, param->sfn, mBuf);
1343    CMCHKPK(SPkU8, param->numTxAntennas, mBuf);
1344    CMCHKPK(SPkU8, param->phichDuration, mBuf);
1345    CMCHKPK(SPkU8, param->phichResource, mBuf);
1346    CMCHKPK(SPkU8, param->dlSystemBandWidht, mBuf);
1347    RETVALUE(ROK);
1348
1349 }
1350
1351 #ifdef ANSI
1352 PUBLIC S16 cmPkCtfctfCnmInitSyncInfo
1353 (
1354 CtfCnmInitSyncInfo *param,
1355 Buffer *mBuf
1356 )
1357 #else
1358 PUBLIC S16 cmPkCtfctfCnmInitSyncInfo(param, mBuf)
1359 CtfCnmInitSyncInfo *param;
1360 Buffer *mBuf;
1361 #endif
1362 {
1363    TRC3(cmPkCtfctfCnmInitSyncInfo)
1364
1365    CMCHKPK(SPkU16, param->pci, mBuf);
1366    CMCHKPK(SPkU8, param->rsrp, mBuf);
1367    CMCHKPK(SPkU8, param->mibValidFlag, mBuf);
1368    CMCHKPK(SPkU16, param->localSfn, mBuf);
1369    CMCHKPK(cmPkCtfctfCnmMibInfo, &param->ctfCnmMibInfo, mBuf);
1370    CMCHKPK(cmPkCtfCnmVendorSpecificInfo, &param->ctfCnmVendorSpecificInfo, mBuf);
1371    RETVALUE(ROK);
1372
1373 }
1374
1375 #ifdef ANSI
1376 PUBLIC S16 cmPkCtfcfgRspInfo
1377 (
1378 CtfCnmInitSyncRsp *param,
1379 Buffer *mBuf
1380 )
1381 #else
1382 PUBLIC S16 cmPkCtfcfgRspInfo(param, mBuf)
1383 CtfCnmInitSyncRsp *param;
1384 Buffer *mBuf;
1385 #endif
1386 {
1387    S32 i;
1388    TRC3(cmPkCtfcfgRspInfo)
1389
1390
1391    CMCHKPK(SPkU8, param->status, mBuf);
1392    CMCHKPK(SPkU16, param->earfcn, mBuf);
1393    if(param->numOfNeighbourInfo <= CTF_CNM_MAX_CELL_SEARCH)
1394    {
1395       for(i= param->numOfNeighbourInfo-1; i >= 0; i--)
1396       {
1397          CMCHKPK(cmPkCtfctfCnmInitSyncInfo, &param->ctfCnmInitSyncInfo[i], mBuf);
1398       }
1399    }
1400    CMCHKPK(SPkU8, param->numOfNeighbourInfo, mBuf);
1401    RETVALUE(ROK);
1402
1403 }
1404
1405 /**
1406 * @brief Configuration Request from App to CL for
1407  * cnm Init Sync responce
1408 *
1409 * @details
1410 *
1411 *     Function: cmPkCtfCnmInitSyncRsp
1412 *
1413 *  @param[in]   Pst*  pst
1414 *  @param[in]   SpId  spId
1415 *  @param[in]   CtfCfgTransId  * transId
1416 *  @param[in]   CtfCnmInitSyncRsp* ctfcnmInitSyncRsp
1417 *  @return   S16
1418 *      -# ROK
1419 **/
1420 #ifdef ANSI
1421 PUBLIC S16 cmPkCtfCnmInitSyncRsp
1422 (
1423 Pst* pst,
1424 SpId spId,
1425 CtfCfgTransId *transId,
1426 CtfCnmInitSyncRsp * cfgRspInfo
1427 )
1428 #else
1429 PUBLIC S16 cmPkCtfCnmInitSyncRsp(pst, spId, transId, cfgRspInfo)
1430 Pst* pst;
1431 SpId spId;
1432 CtfCfgTransId *transId;
1433 CtfCnmInitSyncRsp * cfgRspInfo;
1434 #endif
1435 {
1436    Buffer *mBuf = NULLP;
1437    TRC3(cmPkCtfCnmInitSyncRsp)
1438
1439    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1440 #if (ERRCLASS & ERRCLS_ADD_RES)
1441       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1442       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1443          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1444          (ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
1445 #endif
1446       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
1447       RETVALUE(RFAILED);
1448    }
1449    if (pst->selector == CTF_SEL_LC) {
1450       if (cmPkCtfcfgRspInfo(cfgRspInfo, mBuf) != ROK) {
1451 #if (ERRCLASS & ERRCLS_ADD_RES)
1452       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1453          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1454             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1455             (ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
1456 #endif
1457          SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
1458          SPutMsg(mBuf);
1459          RETVALUE(RFAILED);
1460       }
1461    }
1462    else if (pst->selector == CTF_SEL_LWLC) {
1463
1464    if (cmPkPtr((PTR)cfgRspInfo, mBuf) != ROK) {
1465 #if (ERRCLASS & ERRCLS_ADD_RES)
1466       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1467          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1468             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1469             (ErrVal)ECTF018, (ErrVal)0, "Packing failed");
1470 #endif
1471          SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
1472          SPutMsg(mBuf);
1473          RETVALUE(RFAILED);
1474       }
1475
1476    }
1477  if(cmPkCtfCfgTransId(transId, mBuf) != ROK) {
1478 #if (ERRCLASS & ERRCLS_ADD_RES)
1479       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1480       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1481          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1482          (ErrVal)ECTF019, (ErrVal)0, "Packing failed");
1483 #endif
1484       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
1485       SPutMsg(mBuf);
1486       RETVALUE(RFAILED);
1487    }
1488  if (SPkS16(spId, mBuf) != ROK) {
1489 #if (ERRCLASS & ERRCLS_ADD_RES)
1490       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1491       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1492          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1493          (ErrVal)ECTF020, (ErrVal)0, "Packing failed");
1494 #endif
1495       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
1496       SPutMsg(mBuf);
1497       RETVALUE(RFAILED);
1498    }
1499    if (pst->selector != CTF_SEL_LWLC) {
1500       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmInitSyncRsp));
1501    }
1502    pst->event = (Event)EVTCTFCNMINITSYNCRSP;
1503    RETVALUE(SPstTsk(pst,mBuf));
1504
1505 }
1506 /*-----------------------------------------------------------------------------*/
1507
1508 #ifdef ANSI
1509 PUBLIC S16 cmUnpkCtfctfCnmMibInfo
1510 (
1511 CtfCnmMibInfo *param,
1512 Buffer *mBuf
1513 )
1514 #else
1515 PUBLIC S16 cmUnpkCtfctfCnmMibInfo(param, mBuf)
1516 CtfCnmMibInfo *param;
1517 Buffer *mBuf;
1518 #endif
1519 {
1520    TRC3(cmUnpkCtfctfCnmMibInfo);
1521
1522
1523    CMCHKUNPK(SUnpkU8, &param->dlSystemBandWidht, mBuf);
1524    CMCHKUNPK(SUnpkU8, &param->phichResource, mBuf);
1525    CMCHKUNPK(SUnpkU8, &param->phichDuration, mBuf);
1526    CMCHKUNPK(SUnpkU8, &param->numTxAntennas, mBuf);
1527    CMCHKUNPK(SUnpkU16, &param->sfn, mBuf);
1528    RETVALUE(ROK);
1529
1530 }
1531
1532 #ifdef ANSI
1533 PUBLIC S16 cmUnpkctfCnmInitSyncInfo
1534 (
1535 CtfCnmInitSyncInfo *param,
1536 Buffer *mBuf
1537 )
1538 #else
1539 PUBLIC S16 cmUnpkctfCnmInitSyncInfo(param, mBuf)
1540 CtfCnmInitSyncInfo *param;
1541 Buffer *mBuf;
1542 #endif
1543 {
1544    TRC3(cmUnpkctfCnmInitSyncInfo);
1545
1546    CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, &param->ctfCnmVendorSpecificInfo, mBuf);
1547    CMCHKUNPK(cmUnpkCtfctfCnmMibInfo, &param->ctfCnmMibInfo, mBuf);
1548    CMCHKUNPK(SUnpkU16, &param->localSfn, mBuf);
1549    CMCHKUNPK(SUnpkU8, &param->mibValidFlag, mBuf);
1550    CMCHKUNPK(SUnpkU8, &param->rsrp, mBuf);
1551    CMCHKUNPK(SUnpkU16, &param->pci, mBuf);
1552    RETVALUE(ROK);
1553
1554 }
1555
1556 #ifdef ANSI
1557 PUBLIC S16 cmUnpkCtfCnmInitSyncRspMsg
1558 (
1559 CtfCnmInitSyncRsp *param,
1560 Buffer *mBuf
1561 )
1562 #else
1563 PUBLIC S16 cmUnpkCtfCnmInitSyncRspMsg(param, mBuf)
1564 CtfCnmInitSyncRsp *param;
1565 Buffer *mBuf;
1566 #endif
1567 {
1568     S32 i;
1569     TRC3(cmUnpkCtfCnmInitSyncRspMsg);
1570
1571
1572     CMCHKUNPK(SUnpkU8, &param->numOfNeighbourInfo, mBuf);
1573     for(i=0; (i < param->numOfNeighbourInfo)&&(i < CTF_CNM_MAX_CELL_SEARCH); i++)
1574     {
1575          CMCHKUNPK(cmUnpkctfCnmInitSyncInfo, &param->ctfCnmInitSyncInfo[i], mBuf);
1576     }
1577     CMCHKUNPK(SUnpkU16, &param->earfcn, mBuf);
1578     CMCHKUNPK(SUnpkU8, &param->status, mBuf);
1579     RETVALUE(ROK);
1580
1581 }
1582 /**
1583 * @brief Configuration Request from RRC to PHY for
1584  * cell or dedicated configuration.
1585 *
1586 * @details
1587 *
1588 *     Function: cmUnpkCtfCnmInitSyncRsp
1589 *
1590 *  @param[in]   CtfCnmInitSyncRspMsg func
1591 *  @param[in]   Pst*  pst
1592 *  @param[in]   Buffer *mBuf
1593 *  @return   S16
1594 *      -# ROK
1595 **/
1596 #ifdef ANSI
1597 PUBLIC S16 cmUnpkCtfCnmInitSyncRsp
1598 (
1599 CtfCnmInitSyncRspMsg func,
1600 Pst *pst,
1601 Buffer *mBuf
1602 )
1603 #else
1604 PUBLIC S16 cmUnpkCtfCnmInitSyncRsp(func, pst, mBuf)
1605 CtfCnmInitSyncRspMsg func;
1606 Pst *pst;
1607 Buffer *mBuf;
1608 #endif
1609 {
1610
1611    SpId spId = 0;
1612    CtfCfgTransId transId;
1613    CtfCnmInitSyncRsp *syncRspInfo = NULLP;
1614    TRC3(cmUnpkCtfCnmInitSyncRsp)
1615
1616    if (SUnpkS16(&spId, mBuf) != ROK) {
1617       SPutMsg(mBuf);
1618 #if (ERRCLASS & ERRCLS_ADD_RES)
1619       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1620       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1621          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1622          (ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
1623 #endif
1624       RETVALUE(RFAILED);
1625    }
1626    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
1627       SPutMsg(mBuf);
1628 #if (ERRCLASS & ERRCLS_ADD_RES)
1629       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1630       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1631          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1632          (ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
1633 #endif
1634       RETVALUE(RFAILED);
1635    }
1636    if (pst->selector != CTF_SEL_LWLC) {
1637       if((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspInfo, sizeof(CtfCnmInitSyncRsp))) != ROK) {
1638 #if (ERRCLASS & ERRCLS_ADD_RES)
1639       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1640          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1641             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1642             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
1643 #endif
1644          SPutMsg(mBuf);
1645          RETVALUE(RFAILED);
1646       }
1647    }
1648    if (pst->selector == CTF_SEL_LWLC) {
1649       if(cmUnpkPtr((PTR *)&syncRspInfo, mBuf) != ROK) {
1650          SPutMsg(mBuf);
1651          RETVALUE(RFAILED);
1652       }
1653    }
1654   else if (pst->selector == CTF_SEL_LC)
1655       if(cmUnpkCtfCnmInitSyncRspMsg(syncRspInfo, mBuf) != ROK) {
1656       SPutSBuf(pst->region, pst->pool, (Data *)syncRspInfo, sizeof(CtfCnmInitSyncRsp));
1657       SPutMsg(mBuf);
1658 #if (ERRCLASS & ERRCLS_ADD_RES)
1659       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1660       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1661          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1662          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
1663 #endif
1664       RETVALUE(RFAILED);
1665    }
1666    SPutMsg(mBuf);
1667    RETVALUE((*func)(pst, spId, &transId, syncRspInfo));
1668
1669 }
1670 /*-----------------------------------------------------------------------*/
1671
1672 #ifdef ANSI
1673 PUBLIC S16 cmPkCtfCellSyncRsp
1674 (
1675 CtfCnmCellSyncRsp *param,
1676 Buffer *mBuf
1677 )
1678 #else
1679 PUBLIC S16 cmPkCtfCellSyncRsp(param, mBuf)
1680 CtfCnmCellSyncRsp *param;
1681 Buffer *mBuf;
1682 #endif
1683 {
1684
1685    TRC3(cmPkCtfCellSyncRsp)
1686
1687    CMCHKPK(SPkU8, param->status, mBuf);
1688    RETVALUE(ROK);
1689
1690 }
1691 /**
1692 * @brief Configuration Request from App to CL for
1693 * cnm Init Sync responce.
1694 *
1695 * @details
1696 *
1697 *     Function: cmPkCtfCnmCellSyncRsp
1698 *
1699 *  @param[in]   Pst*  pst
1700 *  @param[in]   SpId  spId
1701 *  @param[in]   CtfCfgTransId  * transId
1702 *  @param[in]   CtfCnmCellSyncRsp* ctfcnmCellSyncRsp
1703 *  @return   S16
1704 *      -# ROK
1705 **/
1706 #ifdef ANSI
1707 PUBLIC S16 cmPkCtfCnmCellSyncRsp
1708 (
1709 Pst* pst,
1710 SpId spId,
1711 CtfCfgTransId *transId,
1712 CtfCnmCellSyncRsp * cfgRspInfo
1713 )
1714 #else
1715 PUBLIC S16 cmPkCtfCnmCellSyncRsp(pst, spId, transId, cfgRspInfo)
1716 Pst* pst;
1717 SpId spId;
1718 CtfCfgTransId *transId;
1719 CtfCnmCellSyncRsp * cfgRspInfo;
1720 #endif
1721 {
1722
1723    Buffer *mBuf = NULLP;
1724    TRC3(cmPkCtfCnmCellSyncRsp)
1725
1726    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1727 #if (ERRCLASS & ERRCLS_ADD_RES)
1728       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1729       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1730          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1731          (ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
1732 #endif
1733       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
1734       RETVALUE(RFAILED);
1735    }
1736    if (pst->selector == CTF_SEL_LC) {
1737       if (cmPkCtfCellSyncRsp(cfgRspInfo, mBuf) != ROK) {
1738 #if (ERRCLASS & ERRCLS_ADD_RES)
1739       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1740          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1741             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1742             (ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
1743 #endif
1744          SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
1745          SPutMsg(mBuf);
1746          RETVALUE(RFAILED);
1747       }
1748    }
1749    else if (pst->selector == CTF_SEL_LWLC) {
1750
1751    if (cmPkPtr((PTR)cfgRspInfo, mBuf) != ROK) {
1752 #if (ERRCLASS & ERRCLS_ADD_RES)
1753       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1754          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1755             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1756             (ErrVal)ECTF018, (ErrVal)0, "Packing failed");
1757 #endif
1758          SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
1759          SPutMsg(mBuf);
1760          RETVALUE(RFAILED);
1761       }
1762
1763    }
1764  if(cmPkCtfCfgTransId(transId, mBuf) != ROK) {
1765 #if (ERRCLASS & ERRCLS_ADD_RES)
1766       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1767       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1768          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1769          (ErrVal)ECTF019, (ErrVal)0, "Packing failed");
1770 #endif
1771       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
1772       SPutMsg(mBuf);
1773       RETVALUE(RFAILED);
1774    }
1775  if (SPkS16(spId, mBuf) != ROK) {
1776 #if (ERRCLASS & ERRCLS_ADD_RES)
1777       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1778       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1779          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1780          (ErrVal)ECTF020, (ErrVal)0, "Packing failed");
1781 #endif
1782       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
1783       SPutMsg(mBuf);
1784       RETVALUE(RFAILED);
1785    }
1786    if (pst->selector != CTF_SEL_LWLC) {
1787       SPutSBuf(pst->region, pst->pool, (Data *)cfgRspInfo, sizeof(CtfCnmCellSyncRsp));
1788    }
1789    pst->event = (Event)EVTCTFCNMSYNCRSP;
1790    RETVALUE(SPstTsk(pst,mBuf));
1791
1792
1793 }
1794 /*------------------------------------------------------------*/
1795
1796 #ifdef ANSI
1797 PUBLIC S16 cmUnpkCtfCnmSyncRspMsg
1798 (
1799 CtfCnmCellSyncRsp *param,
1800 Buffer *mBuf
1801 )
1802 #else
1803 PUBLIC S16 cmUnpkCtfCnmSyncRspMsg(param, mBuf)
1804 CtfCnmCellSyncRsp *param;
1805 Buffer *mBuf;
1806 #endif
1807 {
1808
1809    TRC3(cmUnpkCtfCnmSyncRspMsg);
1810
1811    CMCHKUNPK(SUnpkU8, &param->status, mBuf);
1812    RETVALUE(ROK);
1813
1814 }
1815 /**
1816 * @brief Configuration Request from RRC to PHY for
1817  * cell or dedicated configuration.
1818 *
1819 * @details
1820 *
1821 *     Function: cmUnpkCtfCnmCellSyncRsp
1822 *
1823 *  @param[in]   CtfCnmCellSyncRspMsg func
1824 *  @param[in]   Pst*  pst
1825 *  @param[in]   Buffer *mBuf
1826 *  @return   S16
1827 *      -# ROK
1828 **/
1829 #ifdef ANSI
1830 PUBLIC S16 cmUnpkCtfCnmCellSyncRsp
1831 (
1832 CtfCnmCellSyncRspMsg func,
1833 Pst *pst,
1834 Buffer *mBuf
1835 )
1836 #else
1837 PUBLIC S16 cmUnpkCtfCnmCellSyncRsp(func, pst, mBuf)
1838 CtfCnmCellSyncRspMsg func;
1839 Pst *pst;
1840 Buffer *mBuf;
1841 #endif
1842 {
1843
1844    SpId spId = 0;
1845    CtfCfgTransId transId;
1846    CtfCnmCellSyncRsp *syncRspMsg = NULLP;
1847    TRC3(cmUnpkCtfCnmCellSyncRsp)
1848
1849    if (SUnpkS16(&spId, mBuf) != ROK) {
1850       SPutMsg(mBuf);
1851 #if (ERRCLASS & ERRCLS_ADD_RES)
1852       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1853       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1854          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1855          (ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
1856 #endif
1857       RETVALUE(RFAILED);
1858    }
1859    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
1860       SPutMsg(mBuf);
1861 #if (ERRCLASS & ERRCLS_ADD_RES)
1862       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1863       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1864          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1865          (ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
1866 #endif
1867       RETVALUE(RFAILED);
1868    }
1869    if (pst->selector != CTF_SEL_LWLC) {
1870       if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncRspMsg, sizeof(CtfCnmCellSyncRsp))) != ROK) {
1871 #if (ERRCLASS & ERRCLS_ADD_RES)
1872       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1873          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1874             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1875             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
1876 #endif
1877          SPutMsg(mBuf);
1878          RETVALUE(RFAILED);
1879       }
1880    }
1881    if (pst->selector == CTF_SEL_LWLC) {
1882       if (cmUnpkPtr((PTR *)&syncRspMsg, mBuf) != ROK) {
1883          SPutMsg(mBuf);
1884          RETVALUE(RFAILED);
1885       }
1886    }
1887   else if (pst->selector == CTF_SEL_LC)
1888       if (cmUnpkCtfCnmSyncRspMsg(syncRspMsg, mBuf) != ROK) {
1889       SPutSBuf(pst->region, pst->pool, (Data *)syncRspMsg, sizeof(CtfCnmCellSyncRsp));
1890       SPutMsg(mBuf);
1891 #if (ERRCLASS & ERRCLS_ADD_RES)
1892       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1893       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1894          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1895          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
1896 #endif
1897       RETVALUE(RFAILED);
1898    }
1899    SPutMsg(mBuf);
1900    RETVALUE((*func)(pst, spId, &transId, syncRspMsg));
1901
1902 }
1903 /*---------------------------------------------------------------*/
1904
1905 #ifdef ANSI
1906 PUBLIC S16 cmPkCtfcfgIndInfo
1907 (
1908 CtfCnmCellSyncInd *param,
1909 Buffer *mBuf
1910 )
1911 #else
1912 PUBLIC S16 cmPkCtfcfgIndInfo(param, mBuf)
1913 CtfCnmCellSyncInd *param;
1914 Buffer *mBuf;
1915 #endif
1916 {
1917
1918    TRC3(cmPkCtfcfgIndInfo);
1919
1920    CMCHKPK(SPkU8, param->status, mBuf);
1921    CMCHKPK(cmPkCtfCnmVendorSpecificInfo, &param->ctfCnmVendorSpecificInfo, mBuf);
1922    RETVALUE(ROK);
1923
1924 }
1925 /**
1926 * @brief Configuration Request from App to CL for
1927 * cnm Init Sync responce.
1928 *
1929 * @details
1930 *
1931 *     Function: cmPkCtfCnmCellSyncInd
1932 *
1933 *  @param[in]   Pst*  pst
1934 *  @param[in]   SpId  spId
1935 *  @param[in]   CtfCfgTransId  * transId
1936 *  @param[in]   CtfCnmCellSyncInd* ctfcnmCellSyncInd
1937 *  @return   S16
1938 *      -# ROK
1939 **/
1940 #ifdef ANSI
1941 PUBLIC S16 cmPkCtfCnmCellSyncInd
1942 (
1943 Pst* pst,
1944 SpId spId,
1945 CtfCfgTransId *transId,
1946 CtfCnmCellSyncInd * cfgIndInfo
1947 )
1948 #else
1949 PUBLIC S16 cmPkCtfCnmCellSyncInd(pst, spId, transId, cfgIndInfo)
1950 Pst* pst;
1951 SpId spId;
1952 CtfCfgTransId *transId;
1953 CtfCnmCellSyncInd * cfgIndInfo;
1954 #endif
1955 {
1956
1957    Buffer *mBuf = NULLP;
1958    TRC3(cmPkCtfCnmCellSyncInd)
1959
1960    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1961 #if (ERRCLASS & ERRCLS_ADD_RES)
1962       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1963       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1964          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1965          (ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
1966 #endif
1967       SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
1968       RETVALUE(RFAILED);
1969    }
1970    if (pst->selector == CTF_SEL_LC) {
1971       if (cmPkCtfcfgIndInfo(cfgIndInfo, mBuf) != ROK) {
1972 #if (ERRCLASS & ERRCLS_ADD_RES)
1973       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1974          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1975             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1976             (ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
1977 #endif
1978          SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
1979          SPutMsg(mBuf);
1980          RETVALUE(RFAILED);
1981       }
1982    }
1983    else if (pst->selector == CTF_SEL_LWLC) {
1984
1985    if (cmPkPtr((PTR)cfgIndInfo, mBuf) != ROK) {
1986 #if (ERRCLASS & ERRCLS_ADD_RES)
1987       /* ctf_c_001.main_3 Compilation warning fix with g++ */
1988          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1989             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1990             (ErrVal)ECTF018, (ErrVal)0, "Packing failed");
1991 #endif
1992          SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
1993          SPutMsg(mBuf);
1994          RETVALUE(RFAILED);
1995       }
1996
1997    }
1998  if(cmPkCtfCfgTransId(transId, mBuf) != ROK) {
1999 #if (ERRCLASS & ERRCLS_ADD_RES)
2000       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2001       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2002          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2003          (ErrVal)ECTF019, (ErrVal)0, "Packing failed");
2004 #endif
2005       SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
2006       SPutMsg(mBuf);
2007       RETVALUE(RFAILED);
2008    }
2009  if (SPkS16(spId, mBuf) != ROK) {
2010 #if (ERRCLASS & ERRCLS_ADD_RES)
2011       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2012       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2013          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2014          (ErrVal)ECTF020, (ErrVal)0, "Packing failed");
2015 #endif
2016       SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
2017       SPutMsg(mBuf);
2018       RETVALUE(RFAILED);
2019    }
2020    if (pst->selector != CTF_SEL_LWLC) {
2021       SPutSBuf(pst->region, pst->pool, (Data *)cfgIndInfo, sizeof(CtfCnmCellSyncInd));
2022    }
2023    pst->event = (Event)EVTCTFCNMSYNCIND;
2024    RETVALUE(SPstTsk(pst,mBuf));
2025
2026 }
2027
2028 /*---------------------------------------------------------------*/
2029
2030 #ifdef ANSI
2031 PUBLIC S16 cmUnpkCtfCnmSyncIndMsg
2032 (
2033 CtfCnmCellSyncInd *param,
2034 Buffer *mBuf
2035 )
2036 #else
2037 PUBLIC S16 cmUnpkCtfCnmSyncIndMsg(param, mBuf)
2038 CtfCnmCellSyncInd *param;
2039 Buffer *mBuf;
2040 #endif
2041 {
2042
2043    TRC3(cmUnpkCtfCnmSyncIndMsg);
2044
2045    CMCHKUNPK(cmUnpkCtfCnmVendorSpecificInfo, &param->ctfCnmVendorSpecificInfo, mBuf);
2046    CMCHKUNPK(SUnpkU8, &param->status, mBuf);
2047    RETVALUE(ROK);
2048
2049 }
2050 /**
2051 * @brief Configuration Request from RRC to PHY for
2052  * cell or dedicated configuration.
2053 *
2054 * @details
2055 *
2056 *     Function: cmUnpkCtfCnmCellSyncInd
2057 *
2058 *  @param[in]   CtfCnmCellSyncIndMsg func
2059 *  @param[in]   Pst*  pst
2060 *  @param[in]   Buffer *mBuf
2061 *  @return   S16
2062 *      -# ROK
2063 **/
2064 #ifdef ANSI
2065 PUBLIC S16 cmUnpkCtfCnmCellSyncInd
2066 (
2067 CtfCnmCellSyncIndMsg func,
2068 Pst *pst,
2069 Buffer *mBuf
2070 )
2071 #else
2072 PUBLIC S16 cmUnpkCtfCnmCellSyncInd(func, pst, mBuf)
2073 CtfCnmCellSyncIndMsg func;
2074 Pst *pst;
2075 Buffer *mBuf;
2076 #endif
2077 {
2078
2079    SpId spId = 0;
2080    CtfCfgTransId transId;
2081    CtfCnmCellSyncInd *syncIndMsg = NULLP;
2082    TRC3(cmUnpkCtfCnmInitSyncRsp)
2083
2084    if (SUnpkS16(&spId, mBuf) != ROK) {
2085       SPutMsg(mBuf);
2086 #if (ERRCLASS & ERRCLS_ADD_RES)
2087       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2088       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2089          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2090          (ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
2091 #endif
2092       RETVALUE(RFAILED);
2093    }
2094    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
2095       SPutMsg(mBuf);
2096 #if (ERRCLASS & ERRCLS_ADD_RES)
2097       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2098       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2099          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2100          (ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
2101 #endif
2102       RETVALUE(RFAILED);
2103    }
2104    if (pst->selector != CTF_SEL_LWLC) {
2105       if ((SGetSBuf(pst->region, pst->pool, (Data **)&syncIndMsg, sizeof(CtfCnmCellSyncInd))) != ROK) {
2106 #if (ERRCLASS & ERRCLS_ADD_RES)
2107       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2108          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2109             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2110             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
2111 #endif
2112          SPutMsg(mBuf);
2113          RETVALUE(RFAILED);
2114       }
2115    }
2116    if (pst->selector == CTF_SEL_LWLC) {
2117       if (cmUnpkPtr((PTR *)&syncIndMsg, mBuf) != ROK) {
2118          SPutMsg(mBuf);
2119          RETVALUE(RFAILED);
2120       }
2121    }
2122   else if (pst->selector == CTF_SEL_LC)
2123       if (cmUnpkCtfCnmSyncIndMsg(syncIndMsg, mBuf) != ROK) {
2124       SPutSBuf(pst->region, pst->pool, (Data *)syncIndMsg, sizeof(CtfCnmCellSyncInd));
2125       SPutMsg(mBuf);
2126 #if (ERRCLASS & ERRCLS_ADD_RES)
2127       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2128       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2129          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2130          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
2131 #endif
2132       RETVALUE(RFAILED);
2133    }
2134    SPutMsg(mBuf);
2135    RETVALUE((*func)(pst, spId, &transId, syncIndMsg));
2136
2137 }
2138
2139 /********************************************************************************************************************************/
2140                               /*END OF CNM PACK & UNPACK FUNCTIONS*/
2141 /********************************************************************************************************************************/
2142
2143
2144
2145 \f
2146 /**
2147 * @brief Configuration Request from RRC to PHY for
2148  * cell or dedicated configuration.
2149 *
2150 * @details
2151 *
2152 *     Function: cmPkCtfCfgReq
2153 *
2154 *  @param[in]   Pst*  pst
2155 *  @param[in]   SpId  spId
2156 *  @param[in]   CtfCfgTransId  transId
2157 *  @param[in]   CtfCfgReqInfo*  cfgReqInfo
2158 *  @return   S16
2159 *      -# ROK
2160 **/
2161 #ifdef ANSI
2162 PUBLIC S16 cmPkCtfCfgReq
2163 (
2164 Pst* pst,
2165 SpId spId,
2166 CtfCfgTransId transId,
2167 CtfCfgReqInfo* cfgReqInfo
2168 )
2169 #else
2170 PUBLIC S16 cmPkCtfCfgReq(pst, spId, transId, cfgReqInfo)
2171 Pst* pst;
2172 SpId spId;
2173 CtfCfgTransId transId;
2174 CtfCfgReqInfo* cfgReqInfo;
2175 #endif
2176 {
2177    Buffer *mBuf = NULLP;
2178    TRC3(cmPkCtfCfgReq)
2179
2180    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2181 #if (ERRCLASS & ERRCLS_ADD_RES)
2182       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2183       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2184          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2185          (ErrVal)ECTF016, (ErrVal)0, "Packing failed");
2186 #endif
2187       cmRelCtfCfgReq(pst, cfgReqInfo);
2188       RETVALUE(RFAILED);
2189    }
2190    if (pst->selector == CTF_SEL_LC) {
2191       if (cmPkCtfCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
2192 #if (ERRCLASS & ERRCLS_ADD_RES)
2193       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2194          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2195             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2196             (ErrVal)ECTF017, (ErrVal)0, "Packing failed");
2197 #endif
2198          cmRelCtfCfgReq(pst, cfgReqInfo);
2199          SPutMsg(mBuf);
2200          RETVALUE(RFAILED);
2201       }
2202    }
2203    else if (pst->selector == CTF_SEL_LWLC) {
2204       if (cmPkPtr((PTR)cfgReqInfo, mBuf) != ROK) {
2205 #if (ERRCLASS & ERRCLS_ADD_RES)
2206       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2207          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2208             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2209             (ErrVal)ECTF018, (ErrVal)0, "Packing failed");
2210 #endif
2211          cmRelCtfCfgReq(pst, cfgReqInfo);
2212          SPutMsg(mBuf);
2213          RETVALUE(RFAILED);
2214       }
2215    }
2216    if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
2217 #if (ERRCLASS & ERRCLS_ADD_RES)
2218       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2219       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2220          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2221          (ErrVal)ECTF019, (ErrVal)0, "Packing failed");
2222 #endif
2223       cmRelCtfCfgReq(pst, cfgReqInfo);
2224       SPutMsg(mBuf);
2225       RETVALUE(RFAILED);
2226    }
2227    if (SPkS16(spId, mBuf) != ROK) {
2228 #if (ERRCLASS & ERRCLS_ADD_RES)
2229       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2230       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2231          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2232          (ErrVal)ECTF020, (ErrVal)0, "Packing failed");
2233 #endif
2234       cmRelCtfCfgReq(pst, cfgReqInfo);
2235       SPutMsg(mBuf);
2236       RETVALUE(RFAILED);
2237    }
2238    if (pst->selector != CTF_SEL_LWLC) {
2239          cmRelCtfCfgReq(pst, cfgReqInfo);
2240    }
2241    pst->event = (Event) EVTCTFCFGREQ;
2242    RETVALUE(SPstTsk(pst,mBuf));
2243 }
2244
2245 #ifdef TENB_AS_SECURITY
2246 /***********************************************************
2247 *
2248 *     Func: cmPkCtfKenbCfgInfo
2249 *
2250 *
2251 *     Desc:   Key derivation funtion Input Information
2252  * @details This funtion packs the the CtfKenbCfgInfo structure
2253  *           which contains the eNodeB key and Algorithm Type for
2254  *           deriving AS security keys.
2255  *
2256  *
2257  *     Ret : S16
2258  *
2259  *     Notes:
2260  *
2261  *     File:
2262  *
2263  **********************************************************/
2264 #ifdef ANSI
2265 PUBLIC S16 cmUnpkCtfNhKeyInfo
2266 (
2267 CtfNhKeyInfo *param,
2268 Buffer *mBuf
2269 )
2270 #else
2271 PUBLIC S16 cmUnpkCtfNhKeyInfo(param, mBuf)
2272 CtfNhKeyInfo *param;
2273 Buffer *mBuf;
2274 #endif
2275 {
2276
2277    U8  idx;
2278
2279    TRC3(cmUnpkCtfNhKeyInfo)
2280
2281    CMCHKUNPK(SUnpkU16, &param->dlCarrFreq, mBuf);
2282    CMCHKUNPK(SUnpkU16, &param->physCellId, mBuf);
2283    for(idx=0;idx<32;idx++)
2284    {
2285       CMCHKUNPK(SUnpkU8,&param->secKey[idx],mBuf);
2286    }
2287    RETVALUE(ROK);
2288 }
2289
2290 /***********************************************************
2291 *
2292 *     Func: cmPkCtfKenbCfgInfo
2293 *
2294 *
2295 *     Desc:   Key derivation funtion Input Information
2296  * @details This funtion packs the the CtfKenbCfgInfo structure
2297  *           which contains the eNodeB key and Algorithm Type for
2298  *           deriving AS security keys.
2299  *
2300  *
2301  *     Ret : S16
2302  *
2303  *     Notes:
2304  *
2305  *     File:
2306  *
2307  **********************************************************/
2308 #ifdef ANSI
2309 PUBLIC S16 cmUnpkCtfKenbStarInfo
2310 (
2311 CtfKenbStarInfo *param,
2312 Buffer *mBuf
2313 )
2314 #else
2315 PUBLIC S16 cmUnpkCtfKenbStarInfo(param, mBuf)
2316 CtfKenbStarInfo *param;
2317 Buffer *mBuf;
2318 #endif
2319 {
2320
2321    U8  idx;
2322
2323    TRC3(cmUnpkCtfKenbStarInfo)
2324
2325    CMCHKUNPK(SUnpkU16, &param->dlCarrFreq, mBuf);
2326    CMCHKUNPK(SUnpkU16, &param->physCellId, mBuf);
2327    for(idx=0;idx<32;idx++)
2328    {
2329       CMCHKUNPK(SUnpkU8,&param->secKey[idx],mBuf);
2330    }
2331    RETVALUE(ROK);
2332 }
2333
2334
2335 /***********************************************************
2336 *
2337 *     Func: cmPkCtfKenbCfgInfo
2338 *
2339 *
2340 *     Desc:   Key derivation funtion Input Information
2341  * @details This funtion packs the the CtfKenbCfgInfo structure
2342  *           which contains the eNodeB key and Algorithm Type for
2343  *           deriving AS security keys.
2344  *
2345  *
2346  *     Ret : S16
2347  *
2348  *     Notes:
2349  *
2350  *     File:
2351  *
2352  **********************************************************/
2353 #ifdef ANSI
2354 PUBLIC S16 cmUnpkCtfAskeyInfo
2355 (
2356 CtfAsKeyInfo *param,
2357 Buffer *mBuf
2358 )
2359 #else
2360 PUBLIC S16 cmUnpkCtfAskeyInfo(param, mBuf)
2361 CtfAskeyInfo *param;
2362 Buffer *mBuf;
2363 #endif
2364 {
2365
2366    U8  idx;
2367
2368    TRC3(cmUnpkCtfAskeyInfo)
2369
2370    CMCHKUNPK(SUnpkU8, &param->intgAlgoType, mBuf);
2371    CMCHKUNPK(SUnpkU8, &param->ciphAlgoType, mBuf);
2372    for(idx=0;idx<32;idx++)
2373    {
2374       CMCHKUNPK(SUnpkU8,&param->secKey[idx],mBuf);
2375    }
2376    RETVALUE(ROK);
2377 }
2378
2379 /***********************************************************
2380  *
2381  *    Func: cmPkCtfKenbCfgInfo
2382  *
2383  *
2384  *    Desc:   Key derivation funtion Input Information
2385  * @details This funtion packs the the CtfKenbCfgInfo structure
2386  *           which contains the eNodeB key and Algorithm Type for
2387  *           deriving AS security keys.
2388  *
2389  *
2390  *     Ret : S16
2391  *
2392  *     Notes:
2393  *
2394  *     File:
2395  *
2396  *  **********************************************************/
2397 #ifdef ANSI
2398 PUBLIC S16 cmUnpkCtfKdfReqInfo
2399 (
2400 CtfKdfReqInfo *param,
2401 Buffer *mBuf
2402  )
2403 #else
2404 PUBLIC S16 cmUnpkCtfKdfReqInfo(param, mBuf)
2405 CtfKdfReqInfo *param;
2406 Buffer *mBuf;
2407 #endif
2408 {
2409
2410    TRC3(cmUnpkCtfKdfReqInfo)
2411
2412     CMCHKUNPK(SUnpkU8, &param->keyDerType, mBuf);
2413      switch (param->keyDerType)
2414     {
2415        case CTF_KDF_TYPE1:
2416            CMCHKUNPK(cmUnpkCtfAskeyInfo, &param->u.kEnbInf, mBuf);
2417            break;
2418        case CTF_KDF_TYPE2:
2419           CMCHKUNPK(cmUnpkCtfKenbStarInfo, &param->u.kEnbStarInf, mBuf);
2420           break;
2421        case CTF_KDF_TYPE3:
2422           CMCHKUNPK(cmUnpkCtfNhKeyInfo, &param->u.nhKeyInf, mBuf);
2423            break;
2424        default :
2425           RETVALUE(RFAILED);
2426     }
2427    RETVALUE(ROK);
2428 }
2429
2430 /**
2431 * @brief Configuration Request from RRC to PHY for
2432  * cell or dedicated configuration.
2433 *
2434 * @details
2435 *
2436 *     Function: cmUnpkCtfCfgReq
2437 *
2438 *  @param[in]   Pst*  pst
2439 *  @param[in]   SpId  spId
2440 *  @param[in]   CtfCfgTransId  transId
2441 *  @param[in]   CtfCfgReqInfo*  cfgReqInfo
2442 *  @return   S16
2443 *      -# ROK
2444 **/
2445 #ifdef ANSI
2446 PUBLIC S16 cmUnpkCtfKdfReq
2447 (
2448 CtfKdfReq func,
2449 Pst *pst,
2450 Buffer *mBuf
2451 )
2452 #else
2453 PUBLIC S16 cmUnpkCtfKdfReq(func, pst, mBuf)
2454 CtfKdfReq func;
2455 Pst *pst;
2456 Buffer *mBuf;
2457 #endif
2458 {
2459    SpId spId = 0;
2460    CtfCfgTransId transId;
2461    CtfKdfReqInfo *kdfReqInfo = NULLP;
2462
2463    TRC3(cmUnpkCtfKdfReq)
2464
2465    if (SUnpkS16(&spId, mBuf) != ROK) {
2466       SPutMsg(mBuf);
2467 #if (ERRCLASS & ERRCLS_ADD_RES)
2468       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2469       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2470          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2471          (ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
2472 #endif
2473       RETVALUE(RFAILED);
2474    }
2475
2476    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
2477       SPutMsg(mBuf);
2478 #if (ERRCLASS & ERRCLS_ADD_RES)
2479       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2480       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2481          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2482          (ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
2483 #endif
2484       RETVALUE(RFAILED);
2485    }
2486
2487    if (pst->selector != CTF_SEL_LWLC) {
2488       if ((SGetSBuf(pst->region, pst->pool, (Data **)&kdfReqInfo, sizeof(CtfKdfReqInfo))) != ROK) {
2489 #if (ERRCLASS & ERRCLS_ADD_RES)
2490       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2491          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2492             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2493             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
2494 #endif
2495          SPutMsg(mBuf);
2496          RETVALUE(RFAILED);
2497       }
2498
2499    }
2500
2501    if (pst->selector == CTF_SEL_LWLC) {
2502       /*if (cmUnpkPtr((PTR *)&cfgReqInfo, mBuf) != ROK) {
2503          SPutMsg(mBuf);
2504          RETVALUE(RFAILED);
2505       }*/
2506    }
2507    else if (pst->selector == CTF_SEL_LC)
2508       if (cmUnpkCtfKdfReqInfo(kdfReqInfo, mBuf) != ROK) {
2509       SPutSBuf(pst->region, pst->pool, (Data *)kdfReqInfo, sizeof(CtfKdfReqInfo));
2510       SPutMsg(mBuf);
2511           #if (ERRCLASS & ERRCLS_ADD_RES)
2512       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2513       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2514          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2515          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
2516 #endif
2517       RETVALUE(RFAILED);
2518    }
2519            SPutMsg(mBuf);
2520    RETVALUE((*func)(pst, spId, transId, kdfReqInfo));
2521 }
2522 #endif
2523
2524
2525 \f
2526 /**
2527 * @brief Configuration Request from RRC to PHY for
2528  * cell or dedicated configuration.
2529 *
2530 * @details
2531 *
2532 *     Function: cmUnpkCtfCfgReq
2533 *
2534 *  @param[in]   Pst*  pst
2535 *  @param[in]   SpId  spId
2536 *  @param[in]   CtfCfgTransId  transId
2537 *  @param[in]   CtfCfgReqInfo*  cfgReqInfo
2538 *  @return   S16
2539 *      -# ROK
2540 **/
2541 #ifdef ANSI
2542 PUBLIC S16 cmUnpkCtfCfgReq
2543 (
2544 CtfCfgReq func,
2545 Pst *pst,
2546 Buffer *mBuf
2547 )
2548 #else
2549 PUBLIC S16 cmUnpkCtfCfgReq(func, pst, mBuf)
2550 CtfCfgReq func;
2551 Pst *pst;
2552 Buffer *mBuf;
2553 #endif
2554 {
2555    SpId spId = 0;
2556    CtfCfgTransId transId;
2557    CtfCfgReqInfo *cfgReqInfo = NULLP;
2558
2559    TRC3(cmUnpkCtfCfgReq)
2560
2561    if (SUnpkS16(&spId, mBuf) != ROK) {
2562       SPutMsg(mBuf);
2563 #if (ERRCLASS & ERRCLS_ADD_RES)
2564       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2565       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2566          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2567          (ErrVal)ECTF022, (ErrVal)0, (Txt*)&"Packing failed");
2568 #endif
2569       RETVALUE(RFAILED);
2570    }
2571    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
2572       SPutMsg(mBuf);
2573 #if (ERRCLASS & ERRCLS_ADD_RES)
2574       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2575       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2576          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2577          (ErrVal)ECTF023, (ErrVal)0, (Txt*)&"Packing failed");
2578 #endif
2579       RETVALUE(RFAILED);
2580    }
2581    if (pst->selector != CTF_SEL_LWLC) {
2582       if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CtfCfgReqInfo))) != ROK) {
2583 #if (ERRCLASS & ERRCLS_ADD_RES)
2584       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2585          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2586             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2587             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
2588 #endif
2589          SPutMsg(mBuf);
2590          RETVALUE(RFAILED);
2591       }
2592    }
2593    if (pst->selector == CTF_SEL_LWLC) {
2594       if (cmUnpkPtr((PTR *)&cfgReqInfo, mBuf) != ROK) {
2595          SPutMsg(mBuf);
2596          RETVALUE(RFAILED);
2597       }
2598    }
2599    else if (pst->selector == CTF_SEL_LC)
2600       if (cmUnpkCtfCfgReqInfo(pst,cfgReqInfo, mBuf) != ROK) {
2601       cmRelCtfCfgReq(pst, cfgReqInfo);
2602       SPutMsg(mBuf);
2603 #if (ERRCLASS & ERRCLS_ADD_RES)
2604       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2605       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2606          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2607          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
2608 #endif
2609       RETVALUE(RFAILED);
2610    }
2611    SPutMsg(mBuf);
2612    RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
2613 }
2614
2615 #ifdef TENB_AS_SECURITY
2616 /***********************************************************
2617 *
2618 *     Func: cmPkCtfKenbCfgInfo
2619 *
2620 *
2621 *     Desc:   Key derivation funtion Input Information
2622  * @details This funtion packs the the CtfKenbCfgInfo structure
2623  *           which contains the eNodeB key and Algorithm Type for
2624  *           deriving AS security keys.
2625  *
2626  *
2627  *     Ret : S16
2628  *
2629  *     Notes:
2630  *
2631  *     File:
2632  *
2633  **********************************************************/
2634 #ifdef ANSI
2635 PUBLIC S16 cmPkCtfNhKeyCfmInfo
2636 (
2637 CtfNhKeyCfmInfo *param,
2638 Buffer *mBuf
2639 )
2640 #else
2641 PUBLIC S16 cmPkCtfNhKeyCfmInfo(param, mBuf)
2642 CtfNhKeyCfmInfo *param;
2643 Buffer *mBuf;
2644 #endif
2645 {
2646
2647    S16  idx;
2648
2649    TRC3(cmPkCtfNhKeyCfmInfo)
2650
2651    for(idx=31;idx>=0;idx--)
2652    {
2653       CMCHKPK(SPkU8,param->secKey[idx],mBuf);
2654    }
2655    RETVALUE(ROK);
2656 }
2657
2658 /***********************************************************
2659 *
2660 *     Func: cmPkCtfKenbCfgInfo
2661 *
2662 *
2663 *     Desc:   Key derivation funtion Input Information
2664  * @details This funtion packs the the CtfKenbCfgInfo structure
2665  *           which contains the eNodeB key and Algorithm Type for
2666  *           deriving AS security keys.
2667  *
2668  *
2669  *     Ret : S16
2670  *
2671  *     Notes:
2672  *
2673  *     File:
2674  *
2675  **********************************************************/
2676 #ifdef ANSI
2677 PUBLIC S16 cmPkCtfKenbStarCfmInfo
2678 (
2679 CtfKenbStarCfmInfo *param,
2680 Buffer *mBuf
2681 )
2682 #else
2683 PUBLIC S16 cmPkCtfKenbStarCfmInfo(param, mBuf)
2684 CtfKenbStarCfmInfo *param;
2685 Buffer *mBuf;
2686 #endif
2687 {
2688
2689    S16  idx;
2690
2691    TRC3(cmPkCtfKenbStarCfmInfo)
2692
2693    for(idx=31;idx>=0;idx--)
2694    {
2695       CMCHKPK(SPkU8,param->secKey[idx],mBuf);
2696    }
2697    RETVALUE(ROK);
2698 }
2699
2700
2701 /***********************************************************
2702 *
2703 *     Func: cmPkCtfKenbCfgInfo
2704 *
2705 *
2706 *     Desc:   Key derivation funtion Input Information
2707  * @details This funtion packs the the CtfKenbCfgInfo structure
2708  *           which contains the eNodeB key and Algorithm Type for
2709  *           deriving AS security keys.
2710  *
2711  *
2712  *     Ret : S16
2713  *
2714  *     Notes:
2715  *
2716  *     File:
2717  *
2718  **********************************************************/
2719 #ifdef ANSI
2720 PUBLIC S16 cmPkCtfAskeyCfmInfo
2721 (
2722 CtfAskeyCfmInfo *param,
2723 Buffer *mBuf
2724 )
2725 #else
2726 PUBLIC S16 cmPkCtfAskeyCfmInfo(param, mBuf)
2727 CtfAskeyCfmInfo *param;
2728 Buffer *mBuf;
2729 #endif
2730 {
2731
2732    S16  idx;
2733
2734    TRC3(cmPkCtfCtfAskeyCfmInfo)
2735
2736    for(idx=15;idx>=0;idx--)
2737    {
2738       CMCHKPK(SPkU8,param->cpCiphKey[idx],mBuf);
2739    }
2740    for(idx=15;idx>=0;idx--)
2741    {
2742       CMCHKPK(SPkU8,param->upCiphKey[idx],mBuf);
2743    }
2744    for(idx=15;idx>=0;idx--)
2745    {
2746       CMCHKPK(SPkU8,param->intKey[idx],mBuf);
2747    }
2748    RETVALUE(ROK);
2749 }
2750
2751 /***********************************************************
2752  *
2753  *    Func: cmPkCtfKenbCfgInfo
2754  *
2755  *
2756  *    Desc:   Key derivation funtion Input Information
2757  * @details This funtion packs the the CtfKenbCfgInfo structure
2758  *           which contains the eNodeB key and Algorithm Type for
2759  *           deriving AS security keys.
2760  *
2761  *
2762  *     Ret : S16
2763  *
2764  *     Notes:
2765  *
2766  *     File:
2767  *
2768  *  **********************************************************/
2769 #ifdef ANSI
2770 PUBLIC S16 cmPkCtfKdfCfmInfo
2771 (
2772 CtfKdfCfmInfo *param,
2773 Buffer *mBuf
2774  )
2775 #else
2776 PUBLIC S16 cmPkCtfKdfCfmInfo(param, mBuf)
2777 CtfKdfCfmInfo *param;
2778 Buffer *mBuf;
2779 #endif
2780 {
2781
2782    TRC3(cmPkCtfKdfCfmInfo)
2783
2784    switch (param->keyDerType)
2785     {
2786          case CTF_KDF_TYPE1:
2787              CMCHKPK(cmPkCtfAskeyCfmInfo, &param->u.kEnbInf, mBuf);
2788              break;
2789          case CTF_KDF_TYPE2:
2790             CMCHKPK(cmPkCtfKenbStarCfmInfo, &param->u.kEnbStarInf, mBuf);
2791             break;
2792          case CTF_KDF_TYPE3:
2793             CMCHKPK(cmPkCtfNhKeyCfmInfo, &param->u.nhKeyInf, mBuf);
2794              break;
2795          default :
2796             RETVALUE(RFAILED);
2797     }
2798     CMCHKPK(SPkU8, param->keyDerType, mBuf);
2799    RETVALUE(ROK);
2800 }
2801
2802 /**
2803 * @brief Configuration Confirm from PHY to RRC.
2804 *
2805 * @details
2806 *
2807 *     Function: cmPkCtfCfgCfm
2808 *
2809 *  @param[in]   Pst*  pst
2810 *  @param[in]   SuId  suId
2811 *  @param[in]   CtfCfgTransId  transId
2812 *  @param[in]   U8  status
2813 *  @return   S16
2814 *      -# ROK
2815 **/
2816 #ifdef ANSI
2817 PUBLIC S16 cmPkCtfKdfCfm
2818 (
2819 Pst* pst,
2820 SuId suId,
2821 CtfCfgTransId transId,
2822 CtfKdfCfmInfo *kdfCfmInfo,
2823 U8 status
2824 )
2825 #else
2826 PUBLIC S16 cmPkCtfKdfCfm(pst, suId, transId, status)
2827 Pst* pst;
2828 SuId suId;
2829 CtfCfgTransId transId;
2830 U8 status;
2831 #endif
2832 {
2833    Buffer *mBuf = NULLP;
2834    TRC3(cmPkCtfKdfCfm)
2835
2836    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2837 #if (ERRCLASS & ERRCLS_ADD_RES)
2838       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2839       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2840          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2841          (ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
2842 #endif
2843       SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
2844       RETVALUE(RFAILED);
2845    }
2846
2847    if (SPkU8(status, mBuf) != ROK) {
2848 #if (ERRCLASS & ERRCLS_ADD_RES)
2849       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2850       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2851          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2852          (ErrVal)ECTF027, (ErrVal)0, (Txt*)&"Packing failed");
2853 #endif
2854       SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
2855       SPutMsg(mBuf);
2856       RETVALUE(RFAILED);
2857    }
2858
2859    if (cmPkCtfKdfCfmInfo(kdfCfmInfo, mBuf) != ROK) {
2860 #if (ERRCLASS & ERRCLS_ADD_RES)
2861       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2862       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2863          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2864          (ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
2865 #endif
2866       SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
2867       SPutMsg(mBuf);
2868       RETVALUE(RFAILED);
2869    }
2870
2871    if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
2872 #if (ERRCLASS & ERRCLS_ADD_RES)
2873       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2874       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2875          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2876          (ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
2877 #endif
2878       SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
2879       SPutMsg(mBuf);
2880       RETVALUE(RFAILED);
2881    }
2882
2883    if (SPkS16(suId, mBuf) != ROK) {
2884 #if (ERRCLASS & ERRCLS_ADD_RES)
2885       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2886       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2887          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2888          (ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
2889 #endif
2890       SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo));
2891       SPutMsg(mBuf);
2892       RETVALUE(RFAILED);
2893    }
2894
2895    if (SPutSBuf(pst->region, pst->pool, (Data *)kdfCfmInfo, sizeof(CtfKdfCfmInfo)) != ROK)
2896    {
2897 #if (ERRCLASS & ERRCLS_ADD_RES)
2898    /* ctf_c_001.main_3 Compilation warning fix with g++ */
2899    SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2900       (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2901       (ErrVal)ECTF021, (ErrVal)0, (Txt*)&"Packing failed");
2902 #endif
2903      SPutMsg(mBuf);
2904      RETVALUE(RFAILED);
2905    }
2906
2907    pst->event = (Event) EVTCTFKDFCFM;
2908    RETVALUE(SPstTsk(pst,mBuf));
2909 }
2910 #endif
2911 \f
2912 /**
2913 * @brief Configuration Confirm from PHY to RRC.
2914 *
2915 * @details
2916 *
2917 *     Function: cmPkCtfCfgCfm
2918 *
2919 *  @param[in]   Pst*  pst
2920 *  @param[in]   SuId  suId
2921 *  @param[in]   CtfCfgTransId  transId
2922 *  @param[in]   U8  status
2923 *  @return   S16
2924 *      -# ROK
2925 **/
2926 #ifdef ANSI
2927 PUBLIC S16 cmPkCtfCfgCfm
2928 (
2929 Pst* pst,
2930 SuId suId,
2931 CtfCfgTransId transId,
2932 U8 status
2933 )
2934 #else
2935 PUBLIC S16 cmPkCtfCfgCfm(pst, suId, transId, status)
2936 Pst* pst;
2937 SuId suId;
2938 CtfCfgTransId transId;
2939 U8 status;
2940 #endif
2941 {
2942    Buffer *mBuf = NULLP;
2943    TRC3(cmPkCtfCfgCfm)
2944
2945    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
2946 #if (ERRCLASS & ERRCLS_ADD_RES)
2947       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2948       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2949          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2950          (ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
2951 #endif
2952       RETVALUE(RFAILED);
2953    }
2954    if (SPkU8(status, mBuf) != ROK) {
2955 #if (ERRCLASS & ERRCLS_ADD_RES)
2956       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2957       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2958          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2959          (ErrVal)ECTF027, (ErrVal)0, (Txt*)&"Packing failed");
2960 #endif
2961       SPutMsg(mBuf);
2962       RETVALUE(RFAILED);
2963    }
2964    if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
2965 #if (ERRCLASS & ERRCLS_ADD_RES)
2966       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2967       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2968          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2969          (ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
2970 #endif
2971       SPutMsg(mBuf);
2972       RETVALUE(RFAILED);
2973    }
2974    if (SPkS16(suId, mBuf) != ROK) {
2975 #if (ERRCLASS & ERRCLS_ADD_RES)
2976       /* ctf_c_001.main_3 Compilation warning fix with g++ */
2977       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2978          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2979          (ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
2980 #endif
2981       SPutMsg(mBuf);
2982       RETVALUE(RFAILED);
2983    }
2984    pst->event = (Event) EVTCTFCFGCFM;
2985    RETVALUE(SPstTsk(pst,mBuf));
2986 }
2987
2988 /**
2989 * @brief ENB STOP Indication from PHY to ENB-APP.
2990 *
2991 * @details
2992 *
2993 *     Function: cmPkCtfEnbStopInd
2994 *
2995 *  @param[in]   Pst*  pst
2996 *  @param[in]   SuId  suId
2997 *  @param[in]   CtfCfgTransId  transId
2998 *  @return   S16
2999 *      -# ROK
3000 **/
3001 #ifdef ANSI
3002 PUBLIC S16 cmPkCtfEnbStopInd
3003 (
3004 Pst* pst,
3005 SuId suId,
3006 CtfCfgTransId transId
3007 )
3008 #else
3009 PUBLIC S16 cmPkCtfEnbStopInd(pst, suId, transId)
3010 Pst* pst;
3011 SuId suId;
3012 CtfCfgTransId transId;
3013 #endif
3014 {
3015    Buffer *mBuf = NULLP;
3016    TRC3(cmPkCtfEnbStopInd)
3017
3018    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3019 #if (ERRCLASS & ERRCLS_ADD_RES)
3020       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3021       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3022          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3023          (ErrVal)ECTF026, (ErrVal)0, (Txt*)&"Packing failed");
3024 #endif
3025       RETVALUE(RFAILED);
3026    }
3027    if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
3028 #if (ERRCLASS & ERRCLS_ADD_RES)
3029       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3030       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3031          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3032          (ErrVal)ECTF028, (ErrVal)0, (Txt*)&"Packing failed");
3033 #endif
3034       SPutMsg(mBuf);
3035       RETVALUE(RFAILED);
3036    }
3037    if (SPkS16(suId, mBuf) != ROK) {
3038 #if (ERRCLASS & ERRCLS_ADD_RES)
3039       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3040       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3041          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3042          (ErrVal)ECTF029, (ErrVal)0, (Txt*)&"Packing failed");
3043 #endif
3044       SPutMsg(mBuf);
3045       RETVALUE(RFAILED);
3046    }
3047    pst->event = (Event) EVTCTFENBSTOPIND;
3048    RETVALUE(SPstTsk(pst,mBuf));
3049 }
3050
3051 #ifdef TENB_AS_SECURITY
3052 /***********************************************************
3053 *
3054 *     Func: cmPkCtfKenbCfgInfo
3055 *
3056 *
3057 *     Desc:   Key derivation funtion Input Information
3058  * @details This funtion packs the the CtfKenbCfgInfo structure
3059  *           which contains the eNodeB key and Algorithm Type for
3060  *           deriving AS security keys.
3061  *
3062  *
3063  *     Ret : S16
3064  *
3065  *     Notes:
3066  *
3067  *     File:
3068  *
3069  **********************************************************/
3070 #ifdef ANSI
3071 PUBLIC S16 cmUnpkCtfNhKeyCfmInfo
3072 (
3073 CtfNhKeyCfmInfo *param,
3074 Buffer *mBuf
3075 )
3076 #else
3077 PUBLIC S16 cmUnpkCtfNhKeyCfmInfo(param, mBuf)
3078 CtfNhKeyCfmInfo *param;
3079 Buffer *mBuf;
3080 #endif
3081 {
3082
3083    U8  idx;
3084
3085    TRC3(cmUnpkCtfNhKeyCfmInfo)
3086
3087    for(idx=0;idx<32;idx++)
3088    {
3089       CMCHKUNPK(SUnpkU8,&param->secKey[idx],mBuf);
3090    }
3091    RETVALUE(ROK);
3092 }
3093
3094 /***********************************************************
3095 *
3096 *     Func: cmPkCtfKenbCfgInfo
3097 *
3098 *
3099 *     Desc:   Key derivation funtion Input Information
3100  * @details This funtion packs the the CtfKenbCfgInfo structure
3101  *           which contains the eNodeB key and Algorithm Type for
3102  *           deriving AS security keys.
3103  *
3104  *
3105  *     Ret : S16
3106  *
3107  *     Notes:
3108  *
3109  *     File:
3110  *
3111  **********************************************************/
3112 #ifdef ANSI
3113 PUBLIC S16 cmUnpkCtfKenbStarCfmInfo
3114 (
3115 CtfKenbStarCfmInfo *param,
3116 Buffer *mBuf
3117 )
3118 #else
3119 PUBLIC S16 cmUnpkCtfKenbStarCfmInfo(param, mBuf)
3120 CtfKenbStarCfmInfo *param;
3121 Buffer *mBuf;
3122 #endif
3123 {
3124
3125    U8  idx;
3126
3127    TRC3(cmUnpkCtfKenbStarCfmInfo)
3128
3129    for(idx=0;idx<32;idx++)
3130    {
3131       CMCHKUNPK(SUnpkU8,&param->secKey[idx],mBuf);
3132    }
3133    RETVALUE(ROK);
3134 }
3135
3136
3137 /***********************************************************
3138 *
3139 *     Func: cmPkCtfKenbCfgInfo
3140 *
3141 *
3142 *     Desc:   Key derivation funtion Input Information
3143  * @details This funtion packs the the CtfKenbCfgInfo structure
3144  *           which contains the eNodeB key and Algorithm Type for
3145  *           deriving AS security keys.
3146  *
3147  *
3148  *     Ret : S16
3149  *
3150  *     Notes:
3151  *
3152  *     File:
3153  *
3154  **********************************************************/
3155 #ifdef ANSI
3156 PUBLIC S16 cmUnpkCtfAskeyCfmInfo
3157 (
3158 CtfAskeyCfmInfo *param,
3159 Buffer *mBuf
3160 )
3161 #else
3162 PUBLIC S16 cmUnpkCtfAskeyCfmInfo(param, mBuf)
3163 CtfAskeyCfmInfo *param;
3164 Buffer *mBuf;
3165 #endif
3166 {
3167
3168    U8  idx;
3169
3170    TRC3(cmUnpkCtfCtfAskeyCfmInfo)
3171
3172    for(idx=0;idx<16;idx++)
3173    {
3174       CMCHKUNPK(SUnpkU8,&param->intKey[idx],mBuf);
3175    }
3176    for(idx=0;idx<16;idx++)
3177    {
3178       CMCHKUNPK(SUnpkU8,&param->upCiphKey[idx],mBuf);
3179    }
3180    for(idx=0;idx<16;idx++)
3181    {
3182       CMCHKUNPK(SUnpkU8,&param->cpCiphKey[idx],mBuf);
3183    }
3184    RETVALUE(ROK);
3185 }
3186
3187 /***********************************************************
3188  *
3189  *    Func: cmPkCtfKenbCfgInfo
3190  *
3191  *
3192  *    Desc:   Key derivation funtion Input Information
3193  * @details This funtion packs the the CtfKenbCfgInfo structure
3194  *           which contains the eNodeB key and Algorithm Type for
3195  *           deriving AS security keys.
3196  *
3197  *
3198  *     Ret : S16
3199  *
3200  *     Notes:
3201  *
3202  *     File:
3203  *
3204  *  **********************************************************/
3205 #ifdef ANSI
3206 PUBLIC S16 cmUnpkCtfKdfCfmInfo
3207 (
3208 CtfKdfCfmInfo *param,
3209 Buffer *mBuf
3210  )
3211 #else
3212 PUBLIC S16 cmUnpkCtfKdfCfmInfo(param, mBuf)
3213 CtfKdfCfmInfo *param;
3214 Buffer *mBuf;
3215 #endif
3216 {
3217
3218    TRC3(cmUnpkCtfKdfCfmInfo)
3219
3220     CMCHKUNPK(SUnpkU8, &param->keyDerType, mBuf);
3221    switch (param->keyDerType)
3222     {
3223          case CTF_KDF_TYPE1:
3224              CMCHKUNPK(cmUnpkCtfAskeyCfmInfo, &param->u.kEnbInf, mBuf);
3225              break;
3226          case CTF_KDF_TYPE2:
3227             CMCHKUNPK(cmUnpkCtfKenbStarCfmInfo, &param->u.kEnbStarInf, mBuf);
3228             break;
3229          case CTF_KDF_TYPE3:
3230             CMCHKUNPK(cmUnpkCtfNhKeyCfmInfo, &param->u.nhKeyInf, mBuf);
3231              break;
3232          default :
3233             RETVALUE(RFAILED);
3234     }
3235    RETVALUE(ROK);
3236 }
3237
3238 /**
3239 * @brief Configuration Confirm from PHY to RRC.
3240 *
3241 * @details
3242 *
3243 *     Function: cmUnpkCtfCfgCfm
3244 *
3245 *  @param[in]   Pst*  pst
3246 *  @param[in]   SuId  suId
3247 *  @param[in]   CtfCfgTransId  transId
3248 *  @param[in]   U8  status
3249 *  @return   S16
3250 *      -# ROK
3251 **/
3252 #ifdef ANSI
3253 PUBLIC S16 cmUnpkCtfKdfCfm
3254 (
3255 CtfKdfCfm func,
3256 Pst *pst,
3257 Buffer *mBuf
3258 )
3259 #else
3260 PUBLIC S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
3261 CtfKdfCfm func;
3262 Pst *pst;
3263 Buffer *mBuf;
3264 #endif
3265 {
3266    SuId suId = 0;
3267    CtfCfgTransId transId;
3268    U8 status;
3269    CtfKdfCfmInfo kdfCfmInfo;
3270
3271    TRC3(cmUnpkCtfKdfCfm)
3272
3273    if (SUnpkS16(&suId, mBuf) != ROK) {
3274       SPutMsg(mBuf);
3275 #if (ERRCLASS & ERRCLS_ADD_RES)
3276       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3277       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3278          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3279          (ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
3280 #endif
3281       RETVALUE(RFAILED);
3282    }
3283    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
3284       SPutMsg(mBuf);
3285 #if (ERRCLASS & ERRCLS_ADD_RES)
3286       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3287       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3288          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3289          (ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
3290 #endif
3291       RETVALUE(RFAILED);
3292    }
3293    if (cmUnpkCtfKdfCfmInfo(&kdfCfmInfo, mBuf) != ROK) {
3294       SPutMsg(mBuf);
3295 #if (ERRCLASS & ERRCLS_ADD_RES)
3296       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3297       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3298          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3299          (ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
3300 #endif
3301       RETVALUE(RFAILED);
3302    }
3303
3304    if (SUnpkU8(&status, mBuf) != ROK) {
3305       SPutMsg(mBuf);
3306 #if (ERRCLASS & ERRCLS_ADD_RES)
3307       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3308       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3309          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3310          (ErrVal)ECTF032, (ErrVal)0, (Txt*)&"Packing failed");
3311 #endif
3312       RETVALUE(RFAILED);
3313    }
3314    SPutMsg(mBuf);
3315    RETVALUE((*func)(pst, suId, transId,&kdfCfmInfo, status));
3316 }
3317 #endif
3318
3319 \f
3320 /**
3321 * @brief Configuration Confirm from PHY to RRC.
3322 *
3323 * @details
3324 *
3325 *     Function: cmUnpkCtfCfgCfm
3326 *
3327 *  @param[in]   Pst*  pst
3328 *  @param[in]   SuId  suId
3329 *  @param[in]   CtfCfgTransId  transId
3330 *  @param[in]   U8  status
3331 *  @return   S16
3332 *      -# ROK
3333 **/
3334 #ifdef ANSI
3335 PUBLIC S16 cmUnpkCtfCfgCfm
3336 (
3337 CtfCfgCfm func,
3338 Pst *pst,
3339 Buffer *mBuf
3340 )
3341 #else
3342 PUBLIC S16 cmUnpkCtfCfgCfm(func, pst, mBuf)
3343 CtfCfgCfm func;
3344 Pst *pst;
3345 Buffer *mBuf;
3346 #endif
3347 {
3348    SuId suId = 0;
3349    CtfCfgTransId transId;
3350    U8 status;
3351
3352    TRC3(cmUnpkCtfCfgCfm)
3353
3354    if (SUnpkS16(&suId, mBuf) != ROK) {
3355       SPutMsg(mBuf);
3356 #if (ERRCLASS & ERRCLS_ADD_RES)
3357       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3358       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3359          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3360          (ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
3361 #endif
3362       RETVALUE(RFAILED);
3363    }
3364    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
3365       SPutMsg(mBuf);
3366 #if (ERRCLASS & ERRCLS_ADD_RES)
3367       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3368       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3369          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3370          (ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
3371 #endif
3372       RETVALUE(RFAILED);
3373    }
3374    if (SUnpkU8(&status, mBuf) != ROK) {
3375       SPutMsg(mBuf);
3376 #if (ERRCLASS & ERRCLS_ADD_RES)
3377       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3378       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3379          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3380          (ErrVal)ECTF032, (ErrVal)0, (Txt*)&"Packing failed");
3381 #endif
3382       RETVALUE(RFAILED);
3383    }
3384    SPutMsg(mBuf);
3385    RETVALUE((*func)(pst, suId, transId, status));
3386 }
3387
3388 /**
3389 * @brief ENB STOP Indication from PHY to ENB-APP
3390 *
3391 * @details
3392 *
3393 *     Function: cmUnpkCtfEnbStopInd
3394 *
3395 *  @param[in]   Pst*  pst
3396 *  @param[in]   SuId  suId
3397 *  @param[in]   CtfCfgTransId  transId
3398 *  @return   S16
3399 *      -# ROK
3400 **/
3401 #ifdef ANSI
3402 PUBLIC S16 cmUnpkCtfEnbStopInd
3403 (
3404 CtfEnbStopInd func,
3405 Pst *pst,
3406 Buffer *mBuf
3407 )
3408 #else
3409 PUBLIC S16 cmUnpkCtfEnbStopInd(func, pst, mBuf)
3410 CtfEnbStopInd func;
3411 Pst *pst;
3412 Buffer *mBuf;
3413 #endif
3414 {
3415    SuId suId = 0;
3416    CtfCfgTransId transId;
3417
3418    TRC3(cmUnpkCtfCfgCfm)
3419
3420    if (SUnpkS16(&suId, mBuf) != ROK) {
3421       SPutMsg(mBuf);
3422 #if (ERRCLASS & ERRCLS_ADD_RES)
3423       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3424       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3425          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3426          (ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
3427 #endif
3428       RETVALUE(RFAILED);
3429    }
3430    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
3431       SPutMsg(mBuf);
3432 #if (ERRCLASS & ERRCLS_ADD_RES)
3433       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3434       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3435          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3436          (ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
3437 #endif
3438       RETVALUE(RFAILED);
3439    }
3440    SPutMsg(mBuf);
3441    RETVALUE((*func)(pst, suId, transId));
3442 }
3443
3444 \f
3445 /**
3446 * @brief UE ID Change Request from RRC to PHY.
3447 *
3448 * @details
3449 *
3450 *     Function: cmPkCtfUeIdChgReq
3451 *
3452 *  @param[in]   Pst*  pst
3453 *  @param[in]   SpId  spId
3454 *  @param[in]   CtfCfgTransId  transId
3455 *  @param[in]   CtfUeInfo *  ueInfo
3456 *  @param[in]   CtfUeInfo *  newUeInfo
3457 *  @return   S16
3458 *      -# ROK
3459 **/
3460 #ifdef ANSI
3461 PUBLIC S16 cmPkCtfUeIdChgReq
3462 (
3463 Pst* pst,
3464 SpId spId,
3465 CtfCfgTransId transId,
3466 CtfUeInfo * ueInfo,
3467 CtfUeInfo * newUeInfo
3468 )
3469 #else
3470 PUBLIC S16 cmPkCtfUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
3471 Pst* pst;
3472 SpId spId;
3473 CtfCfgTransId transId;
3474 CtfUeInfo * ueInfo;
3475 CtfUeInfo * newUeInfo;
3476 #endif
3477 {
3478    Buffer *mBuf = NULLP;
3479    TRC3(cmPkCtfUeIdChgReq)
3480
3481    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3482 #if (ERRCLASS & ERRCLS_ADD_RES)
3483       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3484       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3485          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3486          (ErrVal)ECTF033, (ErrVal)0, (Txt*)&"Packing failed");
3487 #endif
3488       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3489       SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3490       RETVALUE(RFAILED);
3491    }
3492    if (pst->selector == CTF_SEL_LC) {
3493       if (cmPkCtfUeInfo(newUeInfo, mBuf) != ROK) {
3494 #if (ERRCLASS & ERRCLS_ADD_RES)
3495       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3496          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3497             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3498             (ErrVal)ECTF034, (ErrVal)0, (Txt*)&"Packing failed");
3499 #endif
3500          SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3501          SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3502          SPutMsg(mBuf);
3503          RETVALUE(RFAILED);
3504       }
3505    }
3506    else if (pst->selector == CTF_SEL_LWLC) {
3507       if (cmPkPtr((PTR)newUeInfo, mBuf) != ROK) {
3508 #if (ERRCLASS & ERRCLS_ADD_RES)
3509       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3510          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3511             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3512             (ErrVal)ECTF035, (ErrVal)0, (Txt*)&"Packing failed");
3513 #endif
3514          SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3515          SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3516          SPutMsg(mBuf);
3517          RETVALUE(RFAILED);
3518       }
3519    }
3520    if (pst->selector == CTF_SEL_LC) {
3521       if (cmPkCtfUeInfo(ueInfo, mBuf) != ROK) {
3522 #if (ERRCLASS & ERRCLS_ADD_RES)
3523       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3524          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3525             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3526             (ErrVal)ECTF036, (ErrVal)0, (Txt*)&"Packing failed");
3527 #endif
3528          SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3529          SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3530          SPutMsg(mBuf);
3531          RETVALUE(RFAILED);
3532       }
3533    }
3534    else if (pst->selector == CTF_SEL_LWLC) {
3535       if (cmPkPtr((PTR)ueInfo, mBuf) != ROK) {
3536 #if (ERRCLASS & ERRCLS_ADD_RES)
3537       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3538          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3539             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3540             (ErrVal)ECTF037, (ErrVal)0, (Txt*)&"Packing failed");
3541 #endif
3542          SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3543          SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3544          SPutMsg(mBuf);
3545          RETVALUE(RFAILED);
3546       }
3547    }
3548    if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
3549 #if (ERRCLASS & ERRCLS_ADD_RES)
3550       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3551       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3552          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3553          (ErrVal)ECTF038, (ErrVal)0, (Txt*)&"Packing failed");
3554 #endif
3555       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3556       SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3557       SPutMsg(mBuf);
3558       RETVALUE(RFAILED);
3559    }
3560    if (SPkS16(spId, mBuf) != ROK) {
3561 #if (ERRCLASS & ERRCLS_ADD_RES)
3562       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3563       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3564          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3565          (ErrVal)ECTF039, (ErrVal)0, (Txt*)&"Packing failed");
3566 #endif
3567       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3568       SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3569       SPutMsg(mBuf);
3570       RETVALUE(RFAILED);
3571    }
3572    if (pst->selector != CTF_SEL_LWLC) {
3573       if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
3574 #if (ERRCLASS & ERRCLS_ADD_RES)
3575       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3576       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3577          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3578          (ErrVal)ECTF040, (ErrVal)0, (Txt*)&"Packing failed");
3579 #endif
3580          SPutMsg(mBuf);
3581          RETVALUE(RFAILED);
3582       }
3583       if (SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo)) != ROK) {
3584 #if (ERRCLASS & ERRCLS_ADD_RES)
3585       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3586       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3587          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3588          (ErrVal)ECTF041, (ErrVal)0, (Txt*)&"Packing failed");
3589 #endif
3590          SPutMsg(mBuf);
3591          RETVALUE(RFAILED);
3592       }
3593    }
3594    pst->event = (Event) EVTCTFUEIDCHGREQ;
3595    RETVALUE(SPstTsk(pst,mBuf));
3596 }
3597
3598 \f
3599 /**
3600 * @brief UE ID Change Request from RRC to PHY.
3601 *
3602 * @details
3603 *
3604 *     Function: cmUnpkCtfUeIdChgReq
3605 *
3606 *  @param[in]   Pst*  pst
3607 *  @param[in]   SpId  spId
3608 *  @param[in]   CtfCfgTransId  transId
3609 *  @param[in]   CtfUeInfo *  ueInfo
3610 *  @param[in]   CtfUeInfo *  newUeInfo
3611 *  @return   S16
3612 *      -# ROK
3613 **/
3614 #ifdef ANSI
3615 PUBLIC S16 cmUnpkCtfUeIdChgReq
3616 (
3617 CtfUeIdChgReq func,
3618 Pst *pst,
3619 Buffer *mBuf
3620 )
3621 #else
3622 PUBLIC S16 cmUnpkCtfUeIdChgReq(func, pst, mBuf)
3623 CtfUeIdChgReq func;
3624 Pst *pst;
3625 Buffer *mBuf;
3626 #endif
3627 {
3628    SpId spId = 0;
3629    CtfCfgTransId transId;
3630    CtfUeInfo *ueInfo = NULLP;
3631    CtfUeInfo *newUeInfo = NULLP;
3632
3633    TRC3(cmUnpkCtfUeIdChgReq)
3634
3635    if (SUnpkS16(&spId, mBuf) != ROK) {
3636       SPutMsg(mBuf);
3637 #if (ERRCLASS & ERRCLS_ADD_RES)
3638       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3639       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3640         (Txt*)& __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3641          (ErrVal)ECTF042, (ErrVal)0, (Txt*)&"Packing failed");
3642 #endif
3643       RETVALUE(RFAILED);
3644    }
3645    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
3646       SPutMsg(mBuf);
3647 #if (ERRCLASS & ERRCLS_ADD_RES)
3648       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3649       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3650          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3651          (ErrVal)ECTF043, (ErrVal)0, (Txt*)&"Packing failed");
3652 #endif
3653       RETVALUE(RFAILED);
3654    }
3655    if (pst->selector != CTF_SEL_LWLC) {
3656       if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
3657 #if (ERRCLASS & ERRCLS_ADD_RES)
3658       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3659          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3660             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3661             (ErrVal)ECTF044, (ErrVal)0, (Txt*)&"Packing failed");
3662 #endif
3663          SPutMsg(mBuf);
3664          RETVALUE(RFAILED);
3665       }
3666    }
3667    if (pst->selector == CTF_SEL_LWLC) {
3668       if (cmUnpkPtr((PTR *)&ueInfo, mBuf) != ROK) {
3669          SPutMsg(mBuf);
3670          RETVALUE(RFAILED);
3671       }
3672    }
3673    else if (pst->selector == CTF_SEL_LC)
3674       if (cmUnpkCtfUeInfo(ueInfo, mBuf) != ROK) {
3675       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3676       SPutMsg(mBuf);
3677 #if (ERRCLASS & ERRCLS_ADD_RES)
3678       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3679       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3680          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3681          (ErrVal)ECTF045, (ErrVal)0, (Txt*)&"Packing failed");
3682 #endif
3683       RETVALUE(RFAILED);
3684    }
3685    if (pst->selector != CTF_SEL_LWLC) {
3686       if ((SGetSBuf(pst->region, pst->pool, (Data **)&newUeInfo, sizeof(CtfUeInfo))) != ROK) {
3687 #if (ERRCLASS & ERRCLS_ADD_RES)
3688       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3689          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3690             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3691             (ErrVal)ECTF046, (ErrVal)0, (Txt*)&"Packing failed");
3692 #endif
3693          SPutMsg(mBuf);
3694          SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3695          RETVALUE(RFAILED);
3696       }
3697    }
3698    if (pst->selector == CTF_SEL_LWLC) {
3699       if (cmUnpkPtr((PTR *)&newUeInfo, mBuf) != ROK) {
3700          SPutMsg(mBuf);
3701          RETVALUE(RFAILED);
3702       }
3703    }
3704    else if (pst->selector == CTF_SEL_LC)
3705       if (cmUnpkCtfUeInfo(newUeInfo, mBuf) != ROK) {
3706       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3707       SPutSBuf(pst->region, pst->pool, (Data *)newUeInfo, sizeof(CtfUeInfo));
3708       SPutMsg(mBuf);
3709 #if (ERRCLASS & ERRCLS_ADD_RES)
3710       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3711       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3712          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3713          (ErrVal)ECTF047, (ErrVal)0, (Txt*)&"Packing failed");
3714 #endif
3715       RETVALUE(RFAILED);
3716    }
3717    SPutMsg(mBuf);
3718    RETVALUE((*func)(pst, spId, transId, ueInfo, newUeInfo));
3719 }
3720
3721 \f
3722 /**
3723 * @brief UE ID Change Confirm from PHY to RRC.
3724 *
3725 * @details
3726 *
3727 *     Function: cmPkCtfUeIdChgCfm
3728 *
3729 *  @param[in]   Pst*  pst
3730 *  @param[in]   SuId  suId
3731 *  @param[in]   CtfCfgTransId  transId
3732 *  @param[in]   CtfUeInfo *  ueInfo
3733 *  @param[in]   U8  status
3734 *  @return   S16
3735 *      -# ROK
3736 **/
3737 #ifdef ANSI
3738 PUBLIC S16 cmPkCtfUeIdChgCfm
3739 (
3740 Pst* pst,
3741 SuId suId,
3742 CtfCfgTransId transId,
3743 CtfUeInfo * ueInfo,
3744 CmStatus status
3745 )
3746 #else
3747 PUBLIC S16 cmPkCtfUeIdChgCfm(pst, suId, transId, ueInfo, status)
3748 Pst* pst;
3749 SuId suId;
3750 CtfCfgTransId transId;
3751 CtfUeInfo * ueInfo;
3752 CmStatus status;
3753 #endif
3754 {
3755    Buffer *mBuf = NULLP;
3756    TRC3(cmPkCtfUeIdChgCfm)
3757
3758    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3759 #if (ERRCLASS & ERRCLS_ADD_RES)
3760       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3761       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3762          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3763          (ErrVal)ECTF048, (ErrVal)0, (Txt*)&"Packing failed");
3764 #endif
3765       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3766       RETVALUE(RFAILED);
3767    }
3768    if (cmPkCmStatus(&status, mBuf) != ROK) {
3769 #if (ERRCLASS & ERRCLS_ADD_RES)
3770       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3771       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3772          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3773          (ErrVal)ECTF049, (ErrVal)0, (Txt*)&"Packing failed");
3774 #endif
3775       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3776       SPutMsg(mBuf);
3777       RETVALUE(RFAILED);
3778    }
3779    if (pst->selector == CTF_SEL_LC) {
3780       if (cmPkCtfUeInfo(ueInfo, mBuf) != ROK) {
3781 #if (ERRCLASS & ERRCLS_ADD_RES)
3782       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3783          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3784             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3785             (ErrVal)ECTF050, (ErrVal)0, (Txt*)&"Packing failed");
3786 #endif
3787          SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3788          SPutMsg(mBuf);
3789          RETVALUE(RFAILED);
3790       }
3791    }
3792    else if (pst->selector == CTF_SEL_LWLC) {
3793       if (cmPkPtr((PTR)ueInfo, mBuf) != ROK) {
3794 #if (ERRCLASS & ERRCLS_ADD_RES)
3795       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3796          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3797             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3798             (ErrVal)ECTF051, (ErrVal)0, (Txt*)&"Packing failed");
3799 #endif
3800          SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3801          SPutMsg(mBuf);
3802          RETVALUE(RFAILED);
3803       }
3804    }
3805    if (cmPkCtfCfgTransId(&transId, mBuf) != ROK) {
3806 #if (ERRCLASS & ERRCLS_ADD_RES)
3807       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3808       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3809          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3810          (ErrVal)ECTF052, (ErrVal)0, (Txt*)&"Packing failed");
3811 #endif
3812       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3813       SPutMsg(mBuf);
3814       RETVALUE(RFAILED);
3815    }
3816    if (SPkS16(suId, mBuf) != ROK) {
3817 #if (ERRCLASS & ERRCLS_ADD_RES)
3818       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3819       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3820          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3821          (ErrVal)ECTF053, (ErrVal)0, (Txt*)&"Packing failed");
3822 #endif
3823       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3824       SPutMsg(mBuf);
3825       RETVALUE(RFAILED);
3826    }
3827    if (pst->selector != CTF_SEL_LWLC) {
3828       if (SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo)) != ROK) {
3829 #if (ERRCLASS & ERRCLS_ADD_RES)
3830       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3831       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3832          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3833          (ErrVal)ECTF054, (ErrVal)0, (Txt*)&"Packing failed");
3834 #endif
3835          SPutMsg(mBuf);
3836          RETVALUE(RFAILED);
3837       }
3838    }
3839    pst->event = (Event) EVTCTFUEIDCHGCFM;
3840    RETVALUE(SPstTsk(pst,mBuf));
3841 }
3842
3843 \f
3844 /**
3845 * @brief UE ID Change Confirm from PHY to RRC.
3846 *
3847 * @details
3848 *
3849 *     Function: cmUnpkCtfUeIdChgCfm
3850 *
3851 *  @param[in]   Pst*  pst
3852 *  @param[in]   SuId  suId
3853 *  @param[in]   CtfCfgTransId  transId
3854 *  @param[in]   CtfUeInfo *  ueInfo
3855 *  @param[in]   U8  status
3856 *  @return   S16
3857 *      -# ROK
3858 **/
3859 #ifdef ANSI
3860 PUBLIC S16 cmUnpkCtfUeIdChgCfm
3861 (
3862 CtfUeIdChgCfm func,
3863 Pst *pst,
3864 Buffer *mBuf
3865 )
3866 #else
3867 PUBLIC S16 cmUnpkCtfUeIdChgCfm(func, pst, mBuf)
3868 CtfUeIdChgCfm func;
3869 Pst *pst;
3870 Buffer *mBuf;
3871 #endif
3872 {
3873    SuId suId = 0;
3874    CtfCfgTransId transId;
3875    CtfUeInfo *ueInfo = NULLP;
3876    CmStatus status;
3877
3878    TRC3(cmUnpkCtfUeIdChgCfm)
3879
3880    if (SUnpkS16(&suId, mBuf) != ROK) {
3881       SPutMsg(mBuf);
3882 #if (ERRCLASS & ERRCLS_ADD_RES)
3883       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3884       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3885          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3886          (ErrVal)ECTF055, (ErrVal)0, (Txt*)&"Packing failed");
3887 #endif
3888       RETVALUE(RFAILED);
3889    }
3890    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
3891       SPutMsg(mBuf);
3892 #if (ERRCLASS & ERRCLS_ADD_RES)
3893       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3894       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3895          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3896          (ErrVal)ECTF056, (ErrVal)0, (Txt*)&"Packing failed");
3897 #endif
3898       RETVALUE(RFAILED);
3899    }
3900    if (pst->selector != CTF_SEL_LWLC) {
3901       if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueInfo, sizeof(CtfUeInfo))) != ROK) {
3902 #if (ERRCLASS & ERRCLS_ADD_RES)
3903       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3904          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3905             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3906             (ErrVal)ECTF057, (ErrVal)0, (Txt*)&"Packing failed");
3907 #endif
3908          SPutMsg(mBuf);
3909          RETVALUE(RFAILED);
3910       }
3911    }
3912    if (pst->selector == CTF_SEL_LWLC) {
3913       if (cmUnpkPtr((PTR *)&ueInfo, mBuf) != ROK) {
3914          SPutMsg(mBuf);
3915          RETVALUE(RFAILED);
3916       }
3917    }
3918    else if (pst->selector == CTF_SEL_LC)
3919       if (cmUnpkCtfUeInfo(ueInfo, mBuf) != ROK) {
3920       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3921       SPutMsg(mBuf);
3922 #if (ERRCLASS & ERRCLS_ADD_RES)
3923       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3924       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3925          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3926          (ErrVal)ECTF058, (ErrVal)0, (Txt*)&"Packing failed");
3927 #endif
3928       RETVALUE(RFAILED);
3929    }
3930    if (cmUnpkCmStatus(&status, mBuf) != ROK) {
3931       SPutSBuf(pst->region, pst->pool, (Data *)ueInfo, sizeof(CtfUeInfo));
3932       SPutMsg(mBuf);
3933 #if (ERRCLASS & ERRCLS_ADD_RES)
3934       /* ctf_c_001.main_3 Compilation warning fix with g++ */
3935       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3936          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3937          (ErrVal)ECTF059, (ErrVal)0, (Txt*)&"Packing failed");
3938 #endif
3939       RETVALUE(RFAILED);
3940    }
3941    SPutMsg(mBuf);
3942    RETVALUE((*func)(pst, suId, transId, ueInfo, status));
3943 }
3944
3945 \f
3946 /***********************************************************
3947 *
3948 *     Func: cmPkCtfCfgTransId
3949 *
3950 *
3951 *     Desc: Transaction ID between CTF and RRC.
3952 *
3953 *
3954 *     Ret: S16
3955 *
3956 *     Notes:
3957 *
3958 *     File:
3959 *
3960 **********************************************************/
3961 #ifdef ANSI
3962 PUBLIC S16 cmPkCtfCfgTransId
3963 (
3964 CtfCfgTransId *param,
3965 Buffer *mBuf
3966 )
3967 #else
3968 PUBLIC S16 cmPkCtfCfgTransId(param, mBuf)
3969 CtfCfgTransId *param;
3970 Buffer *mBuf;
3971 #endif
3972 {
3973
3974    S32 i;
3975    TRC3(cmPkCtfCfgTransId)
3976
3977    for (i=CTF_CFG_TRANSID_SIZE-1; i >= 0; i--) {
3978       CMCHKPK(SPkU8, param->trans[i], mBuf);
3979    }
3980    RETVALUE(ROK);
3981 }
3982
3983
3984 \f
3985 /***********************************************************
3986 *
3987 *     Func: cmUnpkCtfCfgTransId
3988 *
3989 *
3990 *     Desc: Transaction ID between CTF and RRC.
3991 *
3992 *
3993 *     Ret: S16
3994 *
3995 *     Notes:
3996 *
3997 *     File:
3998 *
3999 **********************************************************/
4000 #ifdef ANSI
4001 PUBLIC S16 cmUnpkCtfCfgTransId
4002 (
4003 CtfCfgTransId *param,
4004 Buffer *mBuf
4005 )
4006 #else
4007 PUBLIC S16 cmUnpkCtfCfgTransId(param, mBuf)
4008 CtfCfgTransId *param;
4009 Buffer *mBuf;
4010 #endif
4011 {
4012
4013    S32 i;
4014    TRC3(cmUnpkCtfCfgTransId)
4015
4016    for (i=0; i<CTF_CFG_TRANSID_SIZE; i++) {
4017       CMCHKUNPK(SUnpkU8, &param->trans[i], mBuf);
4018    }
4019    RETVALUE(ROK);
4020 }
4021
4022
4023 \f
4024 /***********************************************************
4025 *
4026 *     Func: cmPkCtfUeInfo
4027 *
4028 *
4029 *     Desc: *  UE ID information
4030 *
4031 *
4032 *     Ret: S16
4033 *
4034 *     Notes:
4035 *
4036 *     File:
4037 *
4038 **********************************************************/
4039 #ifdef ANSI
4040 PUBLIC S16 cmPkCtfUeInfo
4041 (
4042 CtfUeInfo *param,
4043 Buffer *mBuf
4044 )
4045 #else
4046 PUBLIC S16 cmPkCtfUeInfo(param, mBuf)
4047 CtfUeInfo *param;
4048 Buffer *mBuf;
4049 #endif
4050 {
4051
4052    TRC3(cmPkCtfUeInfo)
4053
4054    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
4055    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4056    RETVALUE(ROK);
4057 }
4058
4059
4060 \f
4061 /***********************************************************
4062 *
4063 *     Func: cmUnpkCtfUeInfo
4064 *
4065 *
4066 *     Desc: *  UE ID information
4067 *
4068 *
4069 *     Ret: S16
4070 *
4071 *     Notes:
4072 *
4073 *     File:
4074 *
4075 **********************************************************/
4076 #ifdef ANSI
4077 PUBLIC S16 cmUnpkCtfUeInfo
4078 (
4079 CtfUeInfo *param,
4080 Buffer *mBuf
4081 )
4082 #else
4083 PUBLIC S16 cmUnpkCtfUeInfo(param, mBuf)
4084 CtfUeInfo *param;
4085 Buffer *mBuf;
4086 #endif
4087 {
4088
4089    TRC3(cmUnpkCtfUeInfo)
4090
4091    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4092    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
4093    RETVALUE(ROK);
4094 }
4095
4096
4097 \f
4098 /***********************************************************
4099 *
4100 *     Func: cmPkCtfBwCfgInfo
4101 *
4102 *
4103 *     Desc:   Bandwidth Configuration
4104  * @details This structure contains the uplink and downlink bandwidth
4105  *          information for configuration at PHY.
4106 *
4107 *
4108 *     Ret: S16
4109 *
4110 *     Notes:
4111 *
4112 *     File:
4113 *
4114 **********************************************************/
4115 #ifdef ANSI
4116 PUBLIC S16 cmPkCtfBwCfgInfo
4117 (
4118 CtfBwCfgInfo *param,
4119 Buffer *mBuf
4120 )
4121 #else
4122 PUBLIC S16 cmPkCtfBwCfgInfo(param, mBuf)
4123 CtfBwCfgInfo *param;
4124 Buffer *mBuf;
4125 #endif
4126 {
4127
4128    TRC3(cmPkCtfBwCfgInfo)
4129
4130    CMCHKPK(SPkU8, param->eUtraBand, mBuf);
4131    CMCHKPK(SPkU32, param->ulBw, mBuf);
4132    CMCHKPK(SPkU32, param->dlBw, mBuf);
4133    /* ctf_c_001.main_4: Removed packing of param->pres */
4134    RETVALUE(ROK);
4135 }
4136
4137
4138 \f
4139 /***********************************************************
4140 *
4141 *     Func: cmUnpkCtfBwCfgInfo
4142 *
4143 *
4144 *     Desc:   Bandwidth Configuration
4145  * @details This structure contains the uplink and downlink bandwidth
4146  *          information for configuration at PHY.
4147 *
4148 *
4149 *     Ret: S16
4150 *
4151 *     Notes:
4152 *
4153 *     File:
4154 *
4155 **********************************************************/
4156 #ifdef ANSI
4157 PUBLIC S16 cmUnpkCtfBwCfgInfo
4158 (
4159 CtfBwCfgInfo *param,
4160 Buffer *mBuf
4161 )
4162 #else
4163 PUBLIC S16 cmUnpkCtfBwCfgInfo(param, mBuf)
4164 CtfBwCfgInfo *param;
4165 Buffer *mBuf;
4166 #endif
4167 {
4168
4169    U32 tmpEnum;
4170    TRC3(cmUnpkCtfBwCfgInfo)
4171
4172    /* ctf_c_001.main_4: Removed UnPacking of param->pres */
4173    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4174    param->dlBw = (CtfBandwidth)tmpEnum;
4175    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4176    param->ulBw = (CtfBandwidth)tmpEnum;
4177    CMCHKUNPK(SUnpkU8, &param->eUtraBand, mBuf);
4178    RETVALUE(ROK);
4179 }
4180
4181
4182 \f
4183 /***********************************************************
4184 *
4185 *     Func: cmPkCtfTxSchemeCfg
4186 *
4187 *
4188 *     Desc:   Transmission Scheme Configuration
4189  * @details This structure contains the transmission scheme related information.
4190 *
4191 *
4192 *     Ret: S16
4193 *
4194 *     Notes:
4195 *
4196 *     File:
4197 *
4198 **********************************************************/
4199 #ifdef ANSI
4200 PUBLIC S16 cmPkCtfTxSchemeCfg
4201 (
4202 CtfTxSchemeCfg *param,
4203 Buffer *mBuf
4204 )
4205 #else
4206 PUBLIC S16 cmPkCtfTxSchemeCfg(param, mBuf)
4207 CtfTxSchemeCfg *param;
4208 Buffer *mBuf;
4209 #endif
4210 {
4211
4212    TRC3(cmPkCtfTxSchemeCfg)
4213
4214    CMCHKPK(SPkU32, param->cycPfx, mBuf);
4215    CMCHKPK(SPkU32, param->scSpacing, mBuf);
4216    CMCHKPK(SPkU32, param->duplexMode, mBuf);
4217    /* ctf_c_001.main_4: Removed packing of param->pres */
4218    RETVALUE(ROK);
4219 }
4220
4221
4222 \f
4223 /***********************************************************
4224 *
4225 *     Func: cmUnpkCtfTxSchemeCfg
4226 *
4227 *
4228 *     Desc:   Transmission Scheme Configuration
4229  * @details This structure contains the transmission scheme related information.
4230 *
4231 *
4232 *     Ret: S16
4233 *
4234 *     Notes:
4235 *
4236 *     File:
4237 *
4238 **********************************************************/
4239 #ifdef ANSI
4240 PUBLIC S16 cmUnpkCtfTxSchemeCfg
4241 (
4242 CtfTxSchemeCfg *param,
4243 Buffer *mBuf
4244 )
4245 #else
4246 PUBLIC S16 cmUnpkCtfTxSchemeCfg(param, mBuf)
4247 CtfTxSchemeCfg *param;
4248 Buffer *mBuf;
4249 #endif
4250 {
4251    U32 tmpEnum;
4252
4253    TRC3(cmUnpkCtfTxSchemeCfg)
4254
4255    /* ctf_c_001.main_4: Removed UnPacking of param->pres */
4256    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4257    param->duplexMode = (CtfDuplexMode)tmpEnum;
4258    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4259    param->scSpacing = (CtfSCSpacing)tmpEnum;
4260    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4261    param->cycPfx = (CtfCPCfg)tmpEnum;
4262    RETVALUE(ROK);
4263 }
4264
4265
4266 \f
4267 /***********************************************************
4268 *
4269 *     Func: cmPkCtfAntennaCfgInfo
4270 *
4271 *
4272 *     Desc:   Antenna Ports configuration
4273  * @details This structure contains the antenna configuration information for
4274  *          configuration at PHY.
4275 *
4276 *
4277 *     Ret: S16
4278 *
4279 *     Notes:
4280 *
4281 *     File:
4282 *
4283 **********************************************************/
4284 #ifdef ANSI
4285 PUBLIC S16 cmPkCtfAntennaCfgInfo
4286 (
4287 CtfAntennaCfgInfo *param,
4288 Buffer *mBuf
4289 )
4290 #else
4291 PUBLIC S16 cmPkCtfAntennaCfgInfo(param, mBuf)
4292 CtfAntennaCfgInfo *param;
4293 Buffer *mBuf;
4294 #endif
4295 {
4296
4297    TRC3(cmPkCtfAntennaCfgInfo)
4298
4299    CMCHKPK(SPkU32, param->antPortsCnt, mBuf);
4300    RETVALUE(ROK);
4301 }
4302
4303
4304 \f
4305 /***********************************************************
4306 *
4307 *     Func: cmUnpkCtfAntennaCfgInfo
4308 *
4309 *
4310 *     Desc:   Antenna Ports configuration
4311  * @details This structure contains the antenna configuration information for
4312  *          configuration at PHY.
4313 *
4314 *
4315 *     Ret: S16
4316 *
4317 *     Notes:
4318 *
4319 *     File:
4320 *
4321 **********************************************************/
4322 #ifdef ANSI
4323 PUBLIC S16 cmUnpkCtfAntennaCfgInfo
4324 (
4325 CtfAntennaCfgInfo *param,
4326 Buffer *mBuf
4327 )
4328 #else
4329 PUBLIC S16 cmUnpkCtfAntennaCfgInfo(param, mBuf)
4330 CtfAntennaCfgInfo *param;
4331 Buffer *mBuf;
4332 #endif
4333 {
4334    U32 tmpEnum;
4335
4336    TRC3(cmUnpkCtfAntennaCfgInfo)
4337    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4338    param->antPortsCnt = (CtfAntennaPortsCount)tmpEnum;
4339    RETVALUE(ROK);
4340 }
4341
4342
4343 \f
4344 /***********************************************************
4345 *
4346 *     Func: cmPkCtfPrachCfgInfo
4347 *
4348 *
4349 *     Desc:   PRACH configuration
4350  * @details This structure contains the configuration information for PRACH at PHY.
4351  *          -# PRACH preamble sequences are generated by PHY using Zadoff-Chu
4352  *             sequences.[Ref: 36.211, 5.7.2]
4353  *          -# PRACH preamble format is derived from PRACH Configuration Index.
4354  *             [Ref: 36.211, Table 5.7.1-2]
4355  *          -# PrachFreqOffset is the first physical resource block allocated to
4356  *             the PRACH opportunity considered for preamble format 0, 1, 2, and 3.
4357  *             [Ref: 36.211, 5.7.1]
4358 *
4359 *
4360 *     Ret: S16
4361 *
4362 *     Notes:
4363 *
4364 *     File:
4365 *
4366 **********************************************************/
4367 #ifdef ANSI
4368 PUBLIC S16 cmPkCtfPrachCfgInfo
4369 (
4370 CtfPrachCfgInfo *param,
4371 Buffer *mBuf
4372 )
4373 #else
4374 PUBLIC S16 cmPkCtfPrachCfgInfo(param, mBuf)
4375 CtfPrachCfgInfo *param;
4376 Buffer *mBuf;
4377 #endif
4378 {
4379
4380    TRC3(cmPkCtfPrachCfgInfo)
4381
4382    /*ctf_c_001.main_1*/
4383    if(param->pres != FALSE)
4384    {
4385       CMCHKPK(SPkU8, param->prachFreqOffset, mBuf);
4386       CMCHKPK(SPkU8, param->highSpeedFlag, mBuf);
4387       CMCHKPK(SPkU8, param->zeroCorrelationZoneCfg, mBuf);
4388       CMCHKPK(SPkU8, param->prachCfgIndex, mBuf);
4389       CMCHKPK(SPkU16, param->rootSequenceIndex, mBuf);
4390    }
4391    CMCHKPK(SPkU8, param->pres, mBuf);
4392    RETVALUE(ROK);
4393 }
4394
4395
4396 \f
4397 /***********************************************************
4398 *
4399 *     Func: cmUnpkCtfPrachCfgInfo
4400 *
4401 *
4402 *     Desc:   PRACH configuration
4403  * @details This structure contains the configuration information for PRACH at PHY.
4404  *          -# PRACH preamble sequences are generated by PHY using Zadoff-Chu
4405  *             sequences.[Ref: 36.211, 5.7.2]
4406  *          -# PRACH preamble format is derived from PRACH Configuration Index.
4407  *             [Ref: 36.211, Table 5.7.1-2]
4408  *          -# PrachFreqOffset is the first physical resource block allocated to
4409  *             the PRACH opportunity considered for preamble format 0, 1, 2, and 3.
4410  *             [Ref: 36.211, 5.7.1]
4411 *
4412 *
4413 *     Ret: S16
4414 *
4415 *     Notes:
4416 *
4417 *     File:
4418 *
4419 **********************************************************/
4420 #ifdef ANSI
4421 PUBLIC S16 cmUnpkCtfPrachCfgInfo
4422 (
4423 CtfPrachCfgInfo *param,
4424 Buffer *mBuf
4425 )
4426 #else
4427 PUBLIC S16 cmUnpkCtfPrachCfgInfo(param, mBuf)
4428 CtfPrachCfgInfo *param;
4429 Buffer *mBuf;
4430 #endif
4431 {
4432
4433    TRC3(cmUnpkCtfPrachCfgInfo)
4434
4435    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
4436 /*ctf_c_001.main_1*/
4437    if(param->pres != FALSE)
4438    {
4439       CMCHKUNPK(SUnpkU16, &param->rootSequenceIndex, mBuf);
4440       CMCHKUNPK(SUnpkU8, &param->prachCfgIndex, mBuf);
4441       CMCHKUNPK(SUnpkU8, &param->zeroCorrelationZoneCfg, mBuf);
4442       CMCHKUNPK(SUnpkU8, &param->highSpeedFlag, mBuf);
4443       CMCHKUNPK(SUnpkU8, &param->prachFreqOffset, mBuf);
4444    }
4445    RETVALUE(ROK);
4446 }
4447
4448
4449 \f
4450 /***********************************************************
4451 *
4452 *     Func: cmPkCtfPdschCfgInfo
4453 *
4454 *
4455 *     Desc:   PDSCH configuration
4456  * @details This structure contains the PDSCH configuration information for
4457  *          configuration at PHY.
4458 *
4459 *
4460 *     Ret: S16
4461 *
4462 *     Notes:
4463 *
4464 *     File:
4465 *
4466 **********************************************************/
4467 #ifdef ANSI
4468 PUBLIC S16 cmPkCtfPdschCfgInfo
4469 (
4470 CtfPdschCfgInfo *param,
4471 Buffer *mBuf
4472 )
4473 #else
4474 PUBLIC S16 cmPkCtfPdschCfgInfo(param, mBuf)
4475 CtfPdschCfgInfo *param;
4476 Buffer *mBuf;
4477 #endif
4478 {
4479
4480    TRC3(cmPkCtfPdschCfgInfo)
4481 /*ctf_c_001.main_1*/
4482    if(param->pres != FALSE)
4483    {
4484       CMCHKPK(SPkU8, param->p_b, mBuf);
4485       CMCHKPK(SPkS16, param->refSigPwr, mBuf);
4486    }
4487    CMCHKPK(SPkU8, param->pres, mBuf);
4488    RETVALUE(ROK);
4489 }
4490
4491
4492 \f
4493 /***********************************************************
4494 *
4495 *     Func: cmUnpkCtfPdschCfgInfo
4496 *
4497 *
4498 *     Desc:   PDSCH configuration
4499  * @details This structure contains the PDSCH configuration information for
4500  *          configuration at PHY.
4501 *
4502 *
4503 *     Ret: S16
4504 *
4505 *     Notes:
4506 *
4507 *     File:
4508 *
4509 **********************************************************/
4510 #ifdef ANSI
4511 PUBLIC S16 cmUnpkCtfPdschCfgInfo
4512 (
4513 CtfPdschCfgInfo *param,
4514 Buffer *mBuf
4515 )
4516 #else
4517 PUBLIC S16 cmUnpkCtfPdschCfgInfo(param, mBuf)
4518 CtfPdschCfgInfo *param;
4519 Buffer *mBuf;
4520 #endif
4521 {
4522
4523    TRC3(cmUnpkCtfPdschCfgInfo)
4524
4525    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
4526 /*ctf_c_001.main_1*/
4527    if(param->pres != FALSE)
4528    {
4529      CMCHKUNPK(SUnpkS16, &param->refSigPwr, mBuf);
4530      CMCHKUNPK(SUnpkU8, &param->p_b, mBuf);
4531    }
4532    RETVALUE(ROK);
4533 }
4534
4535
4536 \f
4537 /***********************************************************
4538 *
4539 *     Func: cmPkCtfPuschCfgBasic
4540 *
4541 *
4542 *     Desc:   Basic PUSCH configuration
4543  * @details This structure contains the basic PUSCH configuration information for
4544  *          configuration at PHY.
4545 *
4546 *
4547 *     Ret: S16
4548 *
4549 *     Notes:
4550 *
4551 *     File:
4552 *
4553 **********************************************************/
4554 #ifdef ANSI
4555 PUBLIC S16 cmPkCtfPuschCfgBasic
4556 (
4557 CtfPuschCfgBasic *param,
4558 Buffer *mBuf
4559 )
4560 #else
4561 PUBLIC S16 cmPkCtfPuschCfgBasic(param, mBuf)
4562 CtfPuschCfgBasic *param;
4563 Buffer *mBuf;
4564 #endif
4565 {
4566
4567    TRC3(cmPkCtfPuschCfgBasic)
4568
4569    CMCHKPK(SPkU8, param->enable64QAM, mBuf);
4570    CMCHKPK(SPkU8, param->hoppingOffset, mBuf);
4571    CMCHKPK(SPkU32, param->hoppingMode, mBuf);
4572    CMCHKPK(SPkU8, param->noOfsubBands, mBuf);
4573    RETVALUE(ROK);
4574 }
4575
4576
4577 \f
4578 /***********************************************************
4579 *
4580 *     Func: cmUnpkCtfPuschCfgBasic
4581 *
4582 *
4583 *     Desc:   Basic PUSCH configuration
4584  * @details This structure contains the basic PUSCH configuration information for
4585  *          configuration at PHY.
4586 *
4587 *
4588 *     Ret: S16
4589 *
4590 *     Notes:
4591 *
4592 *     File:
4593 *
4594 **********************************************************/
4595 #ifdef ANSI
4596 PUBLIC S16 cmUnpkCtfPuschCfgBasic
4597 (
4598 CtfPuschCfgBasic *param,
4599 Buffer *mBuf
4600 )
4601 #else
4602 PUBLIC S16 cmUnpkCtfPuschCfgBasic(param, mBuf)
4603 CtfPuschCfgBasic *param;
4604 Buffer *mBuf;
4605 #endif
4606 {
4607    U32 tmpEnum;
4608
4609    TRC3(cmUnpkCtfPuschCfgBasic)
4610
4611    CMCHKUNPK(SUnpkU8, &param->noOfsubBands, mBuf);
4612    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4613    param->hoppingMode = (CtfPuschHoppingMode)tmpEnum;
4614    CMCHKUNPK(SUnpkU8, &param->hoppingOffset, mBuf);
4615    CMCHKUNPK(SUnpkU8, &param->enable64QAM, mBuf);
4616    RETVALUE(ROK);
4617 }
4618
4619
4620 \f
4621 /***********************************************************
4622 *
4623 *     Func: cmPkCtfPuschUlRS
4624 *
4625 *
4626 *     Desc:   PUSCH Uplink Reference Signals configuration
4627  * @details This structure contains the PUSCH configuration information for
4628  *          uplink reference signals configuration at PHY.
4629 *
4630 *
4631 *     Ret: S16
4632 *
4633 *     Notes:
4634 *
4635 *     File:
4636 *
4637 **********************************************************/
4638 #ifdef ANSI
4639 PUBLIC S16 cmPkCtfPuschUlRS
4640 (
4641 CtfPuschUlRS *param,
4642 Buffer *mBuf
4643 )
4644 #else
4645 PUBLIC S16 cmPkCtfPuschUlRS(param, mBuf)
4646 CtfPuschUlRS *param;
4647 Buffer *mBuf;
4648 #endif
4649 {
4650
4651    TRC3(cmPkCtfPuschUlRS)
4652
4653    CMCHKPK(SPkU8, param->cycShift, mBuf);
4654    CMCHKPK(SPkU8, param->grpNum, mBuf);
4655    CMCHKPK(SPkU8, param->seqHopEnabled, mBuf);
4656    CMCHKPK(SPkU8, param->grpHopEnabled, mBuf);
4657    RETVALUE(ROK);
4658 }
4659
4660
4661 \f
4662 /***********************************************************
4663 *
4664 *     Func: cmUnpkCtfPuschUlRS
4665 *
4666 *
4667 *     Desc:   PUSCH Uplink Reference Signals configuration
4668  * @details This structure contains the PUSCH configuration information for
4669  *          uplink reference signals configuration at PHY.
4670 *
4671 *
4672 *     Ret: S16
4673 *
4674 *     Notes:
4675 *
4676 *     File:
4677 *
4678 **********************************************************/
4679 #ifdef ANSI
4680 PUBLIC S16 cmUnpkCtfPuschUlRS
4681 (
4682 CtfPuschUlRS *param,
4683 Buffer *mBuf
4684 )
4685 #else
4686 PUBLIC S16 cmUnpkCtfPuschUlRS(param, mBuf)
4687 CtfPuschUlRS *param;
4688 Buffer *mBuf;
4689 #endif
4690 {
4691
4692    TRC3(cmUnpkCtfPuschUlRS)
4693
4694    CMCHKUNPK(SUnpkU8, &param->grpHopEnabled, mBuf);
4695    CMCHKUNPK(SUnpkU8, &param->seqHopEnabled, mBuf);
4696    CMCHKUNPK(SUnpkU8, &param->grpNum, mBuf);
4697    CMCHKUNPK(SUnpkU8, &param->cycShift, mBuf);
4698    RETVALUE(ROK);
4699 }
4700
4701
4702 \f
4703 /***********************************************************
4704 *
4705 *     Func: cmPkCtfPuschCfgInfo
4706 *
4707 *
4708 *     Desc:   PUSCH configuration
4709  * @details This structure contains the information for PUSCH
4710  *          configuration at PHY.
4711 *
4712 *
4713 *     Ret: S16
4714 *
4715 *     Notes:
4716 *
4717 *     File:
4718 *
4719 **********************************************************/
4720 #ifdef ANSI
4721 PUBLIC S16 cmPkCtfPuschCfgInfo
4722 (
4723 CtfPuschCfgInfo *param,
4724 Buffer *mBuf
4725 )
4726 #else
4727 PUBLIC S16 cmPkCtfPuschCfgInfo(param, mBuf)
4728 CtfPuschCfgInfo *param;
4729 Buffer *mBuf;
4730 #endif
4731 {
4732
4733    TRC3(cmPkCtfPuschCfgInfo)
4734
4735 /*ctf_c_001.main_1*/
4736    if(param->pres != FALSE)
4737    {
4738      CMCHKPK(cmPkCtfPuschUlRS, &param->puschUlRS, mBuf);
4739      CMCHKPK(cmPkCtfPuschCfgBasic, &param->puschBasicCfg, mBuf);
4740    }
4741    CMCHKPK(SPkU8, param->pres, mBuf);
4742    RETVALUE(ROK);
4743 }
4744
4745
4746 \f
4747 /***********************************************************
4748 *
4749 *     Func: cmUnpkCtfPuschCfgInfo
4750 *
4751 *
4752 *     Desc:   PUSCH configuration
4753  * @details This structure contains the information for PUSCH
4754  *          configuration at PHY.
4755 *
4756 *
4757 *     Ret: S16
4758 *
4759 *     Notes:
4760 *
4761 *     File:
4762 *
4763 **********************************************************/
4764 #ifdef ANSI
4765 PUBLIC S16 cmUnpkCtfPuschCfgInfo
4766 (
4767 CtfPuschCfgInfo *param,
4768 Buffer *mBuf
4769 )
4770 #else
4771 PUBLIC S16 cmUnpkCtfPuschCfgInfo(param, mBuf)
4772 CtfPuschCfgInfo *param;
4773 Buffer *mBuf;
4774 #endif
4775 {
4776
4777    TRC3(cmUnpkCtfPuschCfgInfo)
4778
4779    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
4780 /*ctf_c_001.main_1*/
4781    if(param->pres != FALSE)
4782    {
4783      CMCHKUNPK(cmUnpkCtfPuschCfgBasic, &param->puschBasicCfg, mBuf);
4784      CMCHKUNPK(cmUnpkCtfPuschUlRS, &param->puschUlRS, mBuf);
4785    }
4786    RETVALUE(ROK);
4787 }
4788
4789
4790 \f
4791 /***********************************************************
4792 *
4793 *     Func: cmPkCtfPhichCfgInfo
4794 *
4795 *
4796 *     Desc:   PHICH configuration
4797  * @details This structure contains the duration and resource information for
4798  *          PHICH configuration at PHY.
4799 *
4800 *
4801 *     Ret: S16
4802 *
4803 *     Notes:
4804 *
4805 *     File:
4806 *
4807 **********************************************************/
4808 #ifdef ANSI
4809 PUBLIC S16 cmPkCtfPhichCfgInfo
4810 (
4811 CtfPhichCfgInfo *param,
4812 Buffer *mBuf
4813 )
4814 #else
4815 PUBLIC S16 cmPkCtfPhichCfgInfo(param, mBuf)
4816 CtfPhichCfgInfo *param;
4817 Buffer *mBuf;
4818 #endif
4819 {
4820
4821    TRC3(cmPkCtfPhichCfgInfo)
4822
4823 /*ctf_c_001.main_1*/
4824    if(param->pres != FALSE)
4825    {
4826       CMCHKPK(SPkU32, param->resource, mBuf);
4827       CMCHKPK(SPkU32, param->duration, mBuf);
4828    }
4829    CMCHKPK(SPkU8, param->pres, mBuf);
4830    RETVALUE(ROK);
4831 }
4832
4833
4834 \f
4835 /***********************************************************
4836 *
4837 *     Func: cmUnpkCtfPhichCfgInfo
4838 *
4839 *
4840 *     Desc:   PHICH configuration
4841  * @details This structure contains the duration and resource information for
4842  *          PHICH configuration at PHY.
4843 *
4844 *
4845 *     Ret: S16
4846 *
4847 *     Notes:
4848 *
4849 *     File:
4850 *
4851 **********************************************************/
4852 #ifdef ANSI
4853 PUBLIC S16 cmUnpkCtfPhichCfgInfo
4854 (
4855 CtfPhichCfgInfo *param,
4856 Buffer *mBuf
4857 )
4858 #else
4859 PUBLIC S16 cmUnpkCtfPhichCfgInfo(param, mBuf)
4860 CtfPhichCfgInfo *param;
4861 Buffer *mBuf;
4862 #endif
4863 {
4864    U32 tmpEnum;
4865
4866    TRC3(cmUnpkCtfPhichCfgInfo)
4867
4868    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
4869 /*ctf_c_001.main_1*/
4870    if(param->pres != FALSE)
4871    {
4872      CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4873      param->duration = (CtfPhichDuration)tmpEnum;
4874      CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4875      param->resource = (CtfPhichResource)tmpEnum;
4876    }
4877    RETVALUE(ROK);
4878 }
4879
4880
4881 \f
4882 /***********************************************************
4883 *
4884 *     Func: cmPkCtfPucchCfgInfo
4885 *
4886 *
4887 *     Desc:   PUCCH configuration
4888  * @details This structure contains the information for PUCCH
4889  *          configuration at PHY.
4890 *
4891 *
4892 *     Ret: S16
4893 *
4894 *     Notes:
4895 *
4896 *     File:
4897 *
4898 **********************************************************/
4899 #ifdef ANSI
4900 PUBLIC S16 cmPkCtfPucchCfgInfo
4901 (
4902 CtfPucchCfgInfo *param,
4903 Buffer *mBuf
4904 )
4905 #else
4906 PUBLIC S16 cmPkCtfPucchCfgInfo(param, mBuf)
4907 CtfPucchCfgInfo *param;
4908 Buffer *mBuf;
4909 #endif
4910 {
4911
4912    TRC3(cmPkCtfPucchCfgInfo)
4913
4914 /*ctf_c_001.main_1*/
4915    if(param->pres != FALSE)
4916    {
4917       CMCHKPK(SPkU32, param->deltaShift, mBuf);
4918       CMCHKPK(SPkU16, param->n1PUCCH, mBuf);
4919       CMCHKPK(SPkU8, param->nCS, mBuf);
4920       CMCHKPK(SPkU8, param->nRB, mBuf);
4921    }
4922    CMCHKPK(SPkU8, param->pres, mBuf);
4923    RETVALUE(ROK);
4924 }
4925
4926
4927 \f
4928 /***********************************************************
4929 *
4930 *     Func: cmUnpkCtfPucchCfgInfo
4931 *
4932 *
4933 *     Desc:   PUCCH configuration
4934  * @details This structure contains the information for PUCCH
4935  *          configuration at PHY.
4936 *
4937 *
4938 *     Ret: S16
4939 *
4940 *     Notes:
4941 *
4942 *     File:
4943 *
4944 **********************************************************/
4945 #ifdef ANSI
4946 PUBLIC S16 cmUnpkCtfPucchCfgInfo
4947 (
4948 CtfPucchCfgInfo *param,
4949 Buffer *mBuf
4950 )
4951 #else
4952 PUBLIC S16 cmUnpkCtfPucchCfgInfo(param, mBuf)
4953 CtfPucchCfgInfo *param;
4954 Buffer *mBuf;
4955 #endif
4956 {
4957    U32 tmpEnum;
4958
4959    TRC3(cmUnpkCtfPucchCfgInfo)
4960
4961    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
4962 /*ctf_c_001.main_1*/
4963    if(param->pres != FALSE)
4964    {
4965       CMCHKUNPK(SUnpkU8, &param->nRB, mBuf);
4966       CMCHKUNPK(SUnpkU8, &param->nCS, mBuf);
4967       CMCHKUNPK(SUnpkU16, &param->n1PUCCH, mBuf);
4968       CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
4969       param->deltaShift = (CtfPucchDeltaShift)tmpEnum;
4970    }
4971    RETVALUE(ROK);
4972 }
4973
4974
4975 \f
4976 /***********************************************************
4977 *
4978 *     Func: cmPkCtfSrsUlCfgInfo
4979 *
4980 *
4981 *     Desc:   SRS uplink configuration
4982  * @details This structure contains the information for setting-up/release
4983  *          of uplink SRS configuration at PHY.
4984 *
4985 *
4986 *     Ret: S16
4987 *
4988 *     Notes:
4989 *
4990 *     File:
4991 *
4992 **********************************************************/
4993 #ifdef ANSI
4994 PUBLIC S16 cmPkCtfSrsUlCfgInfo
4995 (
4996 CtfSrsUlCfgInfo *param,
4997 Buffer *mBuf
4998 )
4999 #else
5000 PUBLIC S16 cmPkCtfSrsUlCfgInfo(param, mBuf)
5001 CtfSrsUlCfgInfo *param;
5002 Buffer *mBuf;
5003 #endif
5004 {
5005
5006    TRC3(cmPkCtfSrsUlCfgInfo)
5007
5008 /*ctf_c_001.main_1*/
5009    if(param->pres != FALSE)
5010    {
5011       CMCHKPK(SPkU8, param->srsSetup.srsMaxUpPts, mBuf);
5012       CMCHKPK(SPkU8, param->srsSetup.srsANSimultTx, mBuf);
5013       CMCHKPK(SPkU8, param->srsSetup.sfCfg, mBuf);
5014       CMCHKPK(SPkU8, param->srsSetup.srsBw, mBuf);
5015       CMCHKPK(SPkU8, param->srsCfgType, mBuf);
5016    }
5017    CMCHKPK(SPkU8, param->pres, mBuf);
5018    RETVALUE(ROK);
5019 }
5020
5021
5022 \f
5023 /***********************************************************
5024 *
5025 *     Func: cmUnpkCtfSrsUlCfgInfo
5026 *
5027 *
5028 *     Desc:   SRS uplink configuration
5029  * @details This structure contains the information for setting-up/release
5030  *          of uplink SRS configuration at PHY.
5031 *
5032 *
5033 *     Ret: S16
5034 *
5035 *     Notes:
5036 *
5037 *     File:
5038 *
5039 **********************************************************/
5040 #ifdef ANSI
5041 PUBLIC S16 cmUnpkCtfSrsUlCfgInfo
5042 (
5043 CtfSrsUlCfgInfo *param,
5044 Buffer *mBuf
5045 )
5046 #else
5047 PUBLIC S16 cmUnpkCtfSrsUlCfgInfo(param, mBuf)
5048 CtfSrsUlCfgInfo *param;
5049 Buffer *mBuf;
5050 #endif
5051 {
5052
5053    TRC3(cmUnpkCtfSrsUlCfgInfo)
5054
5055    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
5056 /*ctf_c_001.main_1*/
5057    if(param->pres != FALSE)
5058    {
5059       CMCHKUNPK(SUnpkU8, &param->srsCfgType, mBuf);
5060       CMCHKUNPK(SUnpkU8, &param->srsSetup.srsBw, mBuf);
5061       CMCHKUNPK(SUnpkU8, &param->srsSetup.sfCfg, mBuf);
5062       CMCHKUNPK(SUnpkU8, &param->srsSetup.srsANSimultTx, mBuf);
5063       CMCHKUNPK(SUnpkU8, &param->srsSetup.srsMaxUpPts, mBuf);
5064    }
5065    RETVALUE(ROK);
5066 }
5067
5068
5069 \f
5070 /***********************************************************
5071 *
5072 *     Func: cmPkCtfTddSfCfgInfo
5073 *
5074 *
5075 *     Desc:   Subframe Configuration for TDD mode.
5076  * @details This structure contains the information for setting-up
5077  *          the subframe for TDD mode at PHY.
5078 *
5079 *
5080 *     Ret: S16
5081 *
5082 *     Notes:
5083 *
5084 *     File:
5085 *
5086 **********************************************************/
5087 #ifdef ANSI
5088 PUBLIC S16 cmPkCtfTddSfCfgInfo
5089 (
5090 CtfTddSfCfgInfo *param,
5091 Buffer *mBuf
5092 )
5093 #else
5094 PUBLIC S16 cmPkCtfTddSfCfgInfo(param, mBuf)
5095 CtfTddSfCfgInfo *param;
5096 Buffer *mBuf;
5097 #endif
5098 {
5099
5100    TRC3(cmPkCtfTddSfCfgInfo)
5101
5102 /*ctf_c_001.main_1*/
5103    if(param->pres != FALSE)
5104    {
5105       CMCHKPK(SPkU8, param->spclSfPatterns, mBuf);
5106       CMCHKPK(SPkU8, param->sfAssignment, mBuf);
5107    }
5108    CMCHKPK(SPkU8, param->pres, mBuf);
5109    RETVALUE(ROK);
5110 }
5111
5112 /* ctf_c_001.main_4: Added support for vendor specific parameters */
5113 #ifdef CTF_VER3
5114 /***********************************************************
5115 *
5116 *     Func: cmPkCtfVendorSpecParams
5117 *
5118 *
5119 *     Desc: Vendor Specific Parameter configuration
5120 *   @details This structure contains the Parameters which is spaciftc to
5121 *            Vendor.
5122 *
5123 *
5124 *     Ret: S16
5125 *
5126 *     Notes:
5127 *
5128 *     File:
5129 *
5130 **********************************************************/
5131 #ifdef ANSI
5132 PUBLIC S16 cmPkCtfVendorSpecParams
5133 (
5134 CtfVendorSpecific *param,
5135 Buffer *mBuf
5136 )
5137 #else
5138 PUBLIC S16 cmPkCtfVendorSpecParams(param, mBuf)
5139 CtfVendorSpecific *param;
5140 Buffer *mBuf;
5141 #endif
5142 {
5143
5144    TRC3(cmPkCtfVendorSpecParams)
5145    if( param->buffLen != 0) {
5146      SAddPreMsgMultInOrder(param->paramBuffer,param->buffLen,mBuf);
5147    }
5148    CMCHKPK(SPkU16,param->buffLen,mBuf);
5149
5150    RETVALUE(ROK);
5151 }
5152 \f
5153 /***********************************************************
5154 *
5155 *     Func: cmUnpkCtfVendorSpecParams
5156 *
5157 *
5158 *     Desc: Vendor Specific Parameter configuration
5159 * @details  This structure contains the Parameters which is spaciftc to
5160 *           Vendor.
5161 *
5162 *
5163 *     Ret: S16
5164 *
5165 *     Notes:
5166 *
5167 *     File:
5168 *
5169 **********************************************************/
5170 #ifdef ANSI
5171 PUBLIC S16 cmUnpkCtfVendorSpecParams
5172 (
5173 Pst *pst,
5174 CtfVendorSpecific *param,
5175 Buffer *mBuf
5176 )
5177 #else
5178 PUBLIC S16 cmUnpkCtfVendorSpecParams(pst, param, mBuf)
5179 Pst *pst;
5180 CtfVendorSpecific *param;
5181 Buffer *mBuf;
5182 #endif
5183 {
5184
5185    TRC3(cmUnpkCtfVendorSpecParams)
5186
5187    CMCHKUNPK(SUnpkU16, &param->buffLen, mBuf);
5188
5189    if(param->buffLen != 0) {
5190       if ((SGetSBuf(pst->region, pst->pool, (Data **)&param->paramBuffer, param->buffLen)) != ROK) {
5191 #if (ERRCLASS & ERRCLS_ADD_RES)
5192          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
5193                (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
5194                (ErrVal)ECTF060, (ErrVal)0, (Txt*)&"Unpacking failed");
5195 #endif
5196          RETVALUE(RFAILED) ;
5197       }
5198       SRemPreMsgMult(param->paramBuffer, param->buffLen,mBuf) ;
5199    }
5200    else {
5201       param->paramBuffer = NULLP ;
5202    }
5203
5204    RETVALUE(ROK);
5205 }
5206 #endif
5207 \f
5208 /***********************************************************
5209 *
5210 *     Func: cmUnpkCtfTddSfCfgInfo
5211 *
5212 *
5213 *     Desc:   Subframe Configuration for TDD mode.
5214  * @details This structure contains the information for setting-up
5215  *          the subframe for TDD mode at PHY.
5216 *
5217 *
5218 *     Ret: S16
5219 *
5220 *     Notes:
5221 *
5222 *     File:
5223 *
5224 **********************************************************/
5225 #ifdef ANSI
5226 PUBLIC S16 cmUnpkCtfTddSfCfgInfo
5227 (
5228 CtfTddSfCfgInfo *param,
5229 Buffer *mBuf
5230 )
5231 #else
5232 PUBLIC S16 cmUnpkCtfTddSfCfgInfo(param, mBuf)
5233 CtfTddSfCfgInfo *param;
5234 Buffer *mBuf;
5235 #endif
5236 {
5237
5238    TRC3(cmUnpkCtfTddSfCfgInfo)
5239
5240    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
5241 /*ctf_c_001.main_1*/
5242    if(param->pres != FALSE)
5243    {
5244       CMCHKUNPK(SUnpkU8, &param->sfAssignment, mBuf);
5245       CMCHKUNPK(SUnpkU8, &param->spclSfPatterns, mBuf);
5246    }
5247    RETVALUE(ROK);
5248 }
5249 /***********************************************************
5250 *
5251 *     Func: cmPkCtfUnLicnsdCellParam
5252 *
5253 *
5254 *     Desc:   Packing unlicensed SDL cell specific parameter
5255 *
5256 *
5257 *     Ret: S16
5258 *
5259 *     Notes:
5260 *
5261 *     File:
5262 *
5263 **********************************************************/
5264 #ifdef ANSI
5265 PRIVATE S16 cmPkCtfUnLicnsdCellParam
5266 (
5267 CtfUnLicnsdCfgInfo *param,
5268 Buffer *mBuf
5269 )
5270 #else
5271 PRIVATE S16 cmPkCtfUnLicnsdCellParam(param, mBuf)
5272 CtfUnLicnsdCfgInfo  *param;
5273 Buffer *mBuf;
5274 #endif
5275 {
5276    U8  idx;
5277
5278    TRC3(cmPkCtfUnLicnsdCellParam)
5279
5280    CMCHKPK(SPkS32, param->txPowerLimit, mBuf);
5281    CMCHKPK(SPkU8, param->coExistMethod, mBuf);
5282    CMCHKPK(SPkU8, param->lteOnPeriod, mBuf);
5283    CMCHKPK(SPkU8, param->ccaMethod, mBuf);
5284    CMCHKPK(SPkU8, param->adaptiveTx, mBuf);
5285    CMCHKPK(SPkU16, param->transPeriod, mBuf);
5286    CMCHKPK(SPkU16, param->listenPrd, mBuf);
5287    CMCHKPK(SPkS16, param->energyTh, mBuf);
5288    CMCHKPK(SPkU16, param->scanTimePrd, mBuf);
5289    CMCHKPK(SPkU16, param->activityTh, mBuf);
5290
5291    for(idx = 0; idx < param->numFreq; idx++)
5292    {
5293       CMCHKPK(SPkU32, param->earfcn[idx], mBuf);
5294    }
5295
5296    CMCHKPK(SPkU8, param->numFreq, mBuf);
5297
5298    RETVALUE(ROK);
5299 }
5300 \f
5301 /***********************************************************
5302 *
5303 *     Func: cmPkCtfCellCfgInfo
5304 *
5305 *
5306 *     Desc:   Cell Configuration Information
5307  * @details This structure contains the information for setting-up
5308  *          of a cell and its associated resources at PHY.
5309 *
5310 *
5311 *     Ret: S16
5312 *
5313 *     Notes:
5314 *
5315 *     File:
5316 *
5317 **********************************************************/
5318 #ifdef ANSI
5319 PUBLIC S16 cmPkCtfCellCfgInfo
5320 (
5321 CtfCellCfgInfo *param,
5322 Buffer *mBuf
5323 )
5324 #else
5325 PUBLIC S16 cmPkCtfCellCfgInfo(param, mBuf)
5326 CtfCellCfgInfo *param;
5327 Buffer *mBuf;
5328 #endif
5329 {
5330 #ifdef EMTC_ENABLE
5331    S32 i;
5332 #endif
5333    TRC3(cmPkCtfCellCfgInfo)
5334
5335 #ifdef EMTC_ENABLE
5336    for (i = CTF_MAX_CE_LEVEL-1; i >= 0; i--) {
5337       CMCHKPK(SPkU8, param->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
5338       CMCHKPK(SPkU8, param->ceLevelInfo[i].lastPreamble, mBuf);
5339       CMCHKPK(SPkU8, param->ceLevelInfo[i].firstPreamble, mBuf);
5340    }
5341    CMCHKPK(SPkU8, param->mPdcchStart, mBuf);
5342    CMCHKPK(SPkU8, param->catMenabled, mBuf);
5343 #endif
5344    if(param->unLicnsdCfgPres)
5345    {
5346       printf("pverma param->unLicnsdCfgPres cm/ctf -->%d\n",param->unLicnsdCfgPres);
5347       CMCHKPK(cmPkCtfUnLicnsdCellParam, &param->lteUCfg, mBuf);
5348    }
5349    CMCHKPK(SPkU8, param->unLicnsdCfgPres, mBuf);
5350    /*Added for rgu dynamic delta*/
5351    CMCHKPK(SPkU8, param->numDlUePerTti, mBuf);
5352    CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
5353    CMCHKPK(SPkU16, param->ulEarfcn, mBuf);
5354    CMCHKPK(SPkU16, param->dlEarfcn, mBuf);
5355    CMCHKPK(SPkS16, param->priSigPwr, mBuf);
5356    CMCHKPK(SPkS16, param->secSigPwr, mBuf);
5357    /* Packing PHY configuration parameters */
5358    CMCHKPK(SPkU32, param->period, mBuf);
5359    CMCHKPK(SPkU32, param->counter, mBuf);
5360    CMCHKPK(SPkU16, param->opMode, mBuf);
5361
5362    /* ctf_c_001.main_3: Added the pack for newly added fileds inside the CFG structure*/
5363    CMCHKPK(SPkU8, param->rachSrRepModePres, mBuf);
5364    CMCHKPK(SPkU16, param->rachSrRepMode, mBuf);
5365
5366    CMCHKPK(SPkU8, param->dataRepModePres, mBuf);
5367    CMCHKPK(SPkU16, param->dataRepMode, mBuf);
5368
5369    CMCHKPK(SPkU8, param->phySyncModePres, mBuf);
5370    CMCHKPK(SPkU16, param->phySyncMode, mBuf);
5371
5372    CMCHKPK(SPkU8, param->rxAntennaPortsPres, mBuf);
5373    CMCHKPK(SPkU16, param->rxAntennaPorts, mBuf);
5374
5375    CMCHKPK(SPkU8, param->txAntennaPortsPres, mBuf);
5376    CMCHKPK(SPkU16, param->txAntennaPorts, mBuf);
5377
5378    CMCHKPK(SPkU8, param->pucchProbDtxAckPres, mBuf);
5379    CMCHKPK(SPkU16, param->pucchProbDtxAck, mBuf);
5380
5381    CMCHKPK(SPkU8, param->puschProbDtxAckPres, mBuf);
5382    CMCHKPK(SPkU16, param->puschProbDtxAck, mBuf);
5383
5384    CMCHKPK(SPkU8, param->srsDopEstFactorPres, mBuf);
5385    CMCHKPK(SPkU16, param->srsDopEstFactor, mBuf);
5386
5387    CMCHKPK(SPkU8, param->prachPkRatio0Pres, mBuf);
5388    CMCHKPK(SPkU16, param->prachPkRatio0, mBuf);
5389
5390    CMCHKPK(SPkU8, param->prachPkRatio4Pres, mBuf);
5391    CMCHKPK(SPkU16, param->prachPkRatio4, mBuf);
5392
5393    CMCHKPK(SPkU8, param->pucchNoiseGammaPres, mBuf);
5394    CMCHKPK(SPkU16, param->pucchNoiseGamma, mBuf);
5395
5396    CMCHKPK(SPkU8, param->extWinMarginPres, mBuf);
5397    CMCHKPK(SPkU16, param->extWinMargin, mBuf);
5398
5399    CMCHKPK(SPkU8, param->dciPowOsPres, mBuf);
5400    CMCHKPK(SPkU16, param->dciPowOs, mBuf);
5401
5402    CMCHKPK(SPkU8, param->cfiPowOsPres, mBuf);
5403    CMCHKPK(SPkU16, param->cfiPowOs, mBuf);
5404
5405    CMCHKPK(SPkU8, param->syncSigPowOsPres, mBuf);
5406    CMCHKPK(SPkU16, param->syncSigPowOs, mBuf);
5407
5408    CMCHKPK(cmPkCtfTddSfCfgInfo, &param->tddSfCfg, mBuf);
5409    CMCHKPK(cmPkCtfSrsUlCfgInfo, &param->srsUlCfg, mBuf);
5410    CMCHKPK(cmPkCtfPucchCfgInfo, &param->pucchCfg, mBuf);
5411    CMCHKPK(cmPkCtfPhichCfgInfo, &param->phichCfg, mBuf);
5412    CMCHKPK(cmPkCtfPuschCfgInfo, &param->puschCfg, mBuf);
5413    CMCHKPK(cmPkCtfPdschCfgInfo, &param->pdschCfg, mBuf);
5414    CMCHKPK(cmPkCtfPrachCfgInfo, &param->prachCfg, mBuf);
5415    CMCHKPK(cmPkCtfAntennaCfgInfo, &param->antennaCfg, mBuf);
5416    CMCHKPK(cmPkCtfTxSchemeCfg, &param->txCfg, mBuf);
5417    CMCHKPK(cmPkCtfBwCfgInfo, &param->bwCfg, mBuf);
5418    CMCHKPK(SPkU8, param->physCellId, mBuf);
5419    CMCHKPK(SPkU8, param->physCellIdPres, mBuf);
5420
5421    CMCHKPK(SPkS16, param->macSapId, mBuf);
5422    CMCHKPK(SPkS16, param->schSapId, mBuf);
5423
5424    CMCHKPK(SPkU8, param->cellIdGrpId, mBuf);
5425    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
5426    RETVALUE(ROK);
5427 }
5428 /***********************************************************
5429 *
5430 *     Func: cmUnpkCtfUnLicnsdCellParam
5431 *
5432 *
5433 *     Desc:   Unpacking unLicensed SDL cell specific parameter
5434 *
5435 *
5436 *     Ret: S16
5437 *
5438 *     Notes:
5439 *
5440 *     File:
5441 *
5442 **********************************************************/
5443 #ifdef ANSI
5444 PRIVATE S16 cmUnpkCtfUnLicnsdCellParam
5445 (
5446 CtfUnLicnsdCfgInfo *param,
5447 Buffer *mBuf
5448 )
5449 #else
5450 PRIVATE S16 cmUnpkCtfUnLicnsdCellParam(param, mBuf)
5451 CtfUnLicnsdCfgInfo  *param;
5452 Buffer *mBuf;
5453 #endif
5454 {
5455    U8  idx;
5456
5457    TRC3(cmPkCtfUnLicnsdCellParam)
5458
5459    CMCHKUNPK(SUnpkU8, &param->numFreq, mBuf);
5460
5461    for(idx = 0; idx < param->numFreq; idx++)
5462    {
5463       CMCHKUNPK(SUnpkU32, &param->earfcn[idx], mBuf);
5464    }
5465
5466    CMCHKUNPK(SUnpkU16, &param->activityTh, mBuf);
5467    CMCHKUNPK(SUnpkU16, &param->scanTimePrd, mBuf);
5468    CMCHKUNPK(SUnpkS16, &param->energyTh, mBuf);
5469    CMCHKUNPK(SUnpkU16, &param->listenPrd, mBuf);
5470    CMCHKUNPK(SUnpkU16, &param->transPeriod, mBuf);
5471    CMCHKUNPK(SUnpkU8, &param->adaptiveTx, mBuf);
5472    CMCHKUNPK(SUnpkU8, &param->ccaMethod, mBuf);
5473    CMCHKUNPK(SUnpkU8, &param->lteOnPeriod, mBuf);
5474    CMCHKUNPK(SUnpkU8, &param->coExistMethod, mBuf);
5475    CMCHKUNPK(SUnpkS32, &param->txPowerLimit, mBuf);
5476
5477    RETVALUE(ROK);
5478 }
5479
5480 \f
5481 /***********************************************************
5482 *
5483 *     Func: cmUnpkCtfCellCfgInfo
5484 *
5485 *
5486 *     Desc:   Cell Configuration Information
5487  * @details This structure contains the information for setting-up
5488  *          of a cell and its associated resources at PHY.
5489 *
5490 *
5491 *     Ret: S16
5492 *
5493 *     Notes:
5494 *
5495 *     File:
5496 *
5497 **********************************************************/
5498 #ifdef ANSI
5499 PUBLIC S16 cmUnpkCtfCellCfgInfo
5500 (
5501 CtfCellCfgInfo *param,
5502 Buffer *mBuf
5503 )
5504 #else
5505 PUBLIC S16 cmUnpkCtfCellCfgInfo(param, mBuf)
5506 CtfCellCfgInfo *param;
5507 Buffer *mBuf;
5508 #endif
5509 {
5510 #ifdef EMTC_ENABLE
5511    S32 i;
5512 #endif
5513    TRC3(cmUnpkCtfCellCfgInfo)
5514
5515    /* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
5516    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5517    CMCHKUNPK(SUnpkU8, &param->cellIdGrpId, mBuf);
5518
5519    CMCHKUNPK(SUnpkS16, &param->schSapId, mBuf);
5520    CMCHKUNPK(SUnpkS16, &param->macSapId, mBuf);
5521
5522    CMCHKUNPK(SUnpkU8, &param->physCellIdPres, mBuf);
5523    CMCHKUNPK(SUnpkU8, &param->physCellId, mBuf);
5524    CMCHKUNPK(cmUnpkCtfBwCfgInfo, &param->bwCfg, mBuf);
5525    CMCHKUNPK(cmUnpkCtfTxSchemeCfg, &param->txCfg, mBuf);
5526    CMCHKUNPK(cmUnpkCtfAntennaCfgInfo, &param->antennaCfg, mBuf);
5527    CMCHKUNPK(cmUnpkCtfPrachCfgInfo, &param->prachCfg, mBuf);
5528    CMCHKUNPK(cmUnpkCtfPdschCfgInfo, &param->pdschCfg, mBuf);
5529    CMCHKUNPK(cmUnpkCtfPuschCfgInfo, &param->puschCfg, mBuf);
5530    CMCHKUNPK(cmUnpkCtfPhichCfgInfo, &param->phichCfg, mBuf);
5531    CMCHKUNPK(cmUnpkCtfPucchCfgInfo, &param->pucchCfg, mBuf);
5532    CMCHKUNPK(cmUnpkCtfSrsUlCfgInfo, &param->srsUlCfg, mBuf);
5533    CMCHKUNPK(cmUnpkCtfTddSfCfgInfo, &param->tddSfCfg, mBuf);
5534
5535    CMCHKUNPK(SUnpkU16, &param->syncSigPowOs, mBuf);
5536    CMCHKUNPK(SUnpkU8, &param->syncSigPowOsPres, mBuf);
5537
5538    CMCHKUNPK(SUnpkU16, &param->cfiPowOs, mBuf);
5539    CMCHKUNPK(SUnpkU8, &param->cfiPowOsPres, mBuf);
5540
5541    CMCHKUNPK(SUnpkU16, &param->dciPowOs, mBuf);
5542    CMCHKUNPK(SUnpkU8, &param->dciPowOsPres, mBuf);
5543
5544    CMCHKUNPK(SUnpkU16, &param->extWinMargin, mBuf);
5545    CMCHKUNPK(SUnpkU8, &param->extWinMarginPres, mBuf);
5546
5547    CMCHKUNPK(SUnpkU16, &param->pucchNoiseGamma, mBuf);
5548    CMCHKUNPK(SUnpkU8, &param->pucchNoiseGammaPres, mBuf);
5549
5550    CMCHKUNPK(SUnpkU16, &param->prachPkRatio4, mBuf);
5551    CMCHKUNPK(SUnpkU8, &param->prachPkRatio4Pres, mBuf);
5552
5553    CMCHKUNPK(SUnpkU16, &param->prachPkRatio0, mBuf);
5554    CMCHKUNPK(SUnpkU8, &param->prachPkRatio0Pres, mBuf);
5555
5556    CMCHKUNPK(SUnpkU16, &param->srsDopEstFactor, mBuf);
5557    CMCHKUNPK(SUnpkU8, &param->srsDopEstFactorPres, mBuf);
5558
5559    CMCHKUNPK(SUnpkU16, &param->puschProbDtxAck, mBuf);
5560    CMCHKUNPK(SUnpkU8, &param->puschProbDtxAckPres, mBuf);
5561
5562    CMCHKUNPK(SUnpkU16, &param->pucchProbDtxAck, mBuf);
5563    CMCHKUNPK(SUnpkU8, &param->pucchProbDtxAckPres, mBuf);
5564
5565    CMCHKUNPK(SUnpkU16, &param->txAntennaPorts, mBuf);
5566    CMCHKUNPK(SUnpkU8, &param->txAntennaPortsPres, mBuf);
5567
5568    CMCHKUNPK(SUnpkU16, &param->rxAntennaPorts, mBuf);
5569    CMCHKUNPK(SUnpkU8, &param->rxAntennaPortsPres, mBuf);
5570
5571    CMCHKUNPK(SUnpkU16, &param->phySyncMode, mBuf);
5572    CMCHKUNPK(SUnpkU8, &param->phySyncModePres, mBuf);
5573
5574    CMCHKUNPK(SUnpkU16, &param->dataRepMode, mBuf);
5575    CMCHKUNPK(SUnpkU8, &param->dataRepModePres, mBuf);
5576
5577    CMCHKUNPK(SUnpkU16, &param->rachSrRepMode, mBuf);
5578    CMCHKUNPK(SUnpkU8, &param->rachSrRepModePres, mBuf);
5579
5580    /* UnPacking PHY configuration parameters */
5581    CMCHKUNPK(SUnpkU16, &param->opMode, mBuf);
5582    CMCHKUNPK(SUnpkU32, &param->counter, mBuf);
5583    CMCHKUNPK(SUnpkU32, &param->period, mBuf);
5584    CMCHKUNPK(SUnpkS16, &param->priSigPwr, mBuf);
5585    CMCHKUNPK(SUnpkS16, &param->secSigPwr, mBuf);
5586    CMCHKUNPK(SUnpkU16, &param->dlEarfcn, mBuf);
5587    CMCHKUNPK(SUnpkU16, &param->ulEarfcn, mBuf);
5588    CMCHKUNPK(SUnpkS16, &param->pilotSigPwr, mBuf);
5589    /* Added for rgu dynamic delta change*/
5590    CMCHKUNPK(SUnpkU8, &param->numDlUePerTti, mBuf);
5591    CMCHKUNPK(SUnpkU8, &param->unLicnsdCfgPres, mBuf);
5592
5593    if(param->unLicnsdCfgPres)
5594    {
5595       printf("pverma param->unLicnsdCfgPres 2 -->%d \n",param->unLicnsdCfgPres);
5596       CMCHKUNPK(cmUnpkCtfUnLicnsdCellParam, &param->lteUCfg, mBuf);
5597    }
5598 #ifdef EMTC_ENABLE
5599    CMCHKUNPK(SUnpkU8, &param->catMenabled, mBuf);
5600    CMCHKUNPK(SUnpkU8, &param->mPdcchStart, mBuf);
5601
5602    for (i = 0; i < CTF_MAX_CE_LEVEL; i++) {
5603       CMCHKUNPK(SUnpkU8, &param->ceLevelInfo[i].firstPreamble, mBuf);
5604       CMCHKUNPK(SUnpkU8, &param->ceLevelInfo[i].lastPreamble, mBuf);
5605       CMCHKUNPK(SUnpkU8, &param->ceLevelInfo[i].emtcNumRepPerPreambleAtt, mBuf);
5606    }
5607 #endif
5608    RETVALUE(ROK);
5609 }
5610
5611
5612 \f
5613 /* ctf_c_001.main_4: Modified cmPkCtfCellRecfgInfo() to Add support for
5614  * vendor specific parameters */
5615 /***********************************************************
5616 *
5617 *     Func: cmPkCtfCellRecfgInfo
5618 *
5619 *
5620 *     Desc:   Cell Re-configuration Information
5621  * @details This structure contains the information for reconfiguration
5622  *          of a cell and its associated resources at PHY.
5623 *
5624 *
5625 *     Ret: S16
5626 *
5627 *     Notes:
5628 *
5629 *     File:
5630 *
5631 **********************************************************/
5632 #ifdef ANSI
5633 PUBLIC S16 cmPkCtfCellRecfgInfo
5634 (
5635 CtfCellRecfgInfo *param,
5636 Buffer *mBuf
5637 )
5638 #else
5639 PUBLIC S16 cmPkCtfCellRecfgInfo(param, mBuf)
5640 CtfCellRecfgInfo *param;
5641 Buffer *mBuf;
5642 #endif
5643 {
5644
5645    TRC3(cmPkCtfCellRecfgInfo)
5646
5647 #ifdef ENABLE_API_LOG
5648    CMCHKPK(SPkU8, param->enableAPILog, mBuf);
5649 #endif /* ENABLE_API_LOG */
5650    /* ctf_c_001.main_3: Added the pack for newly added fileds inside the CFG structure*/
5651    CMCHKPK(SPkS16, param->secSigPwr, mBuf);
5652    CMCHKPK(SPkS16, param->priSigPwr, mBuf);
5653    CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
5654    CMCHKPK(SPkU8, param->rachSrRepModePres, mBuf);
5655    CMCHKPK(SPkU16, param->rachSrRepMode, mBuf);
5656
5657    CMCHKPK(SPkU8, param->dataRepModePres, mBuf);
5658    CMCHKPK(SPkU16, param->dataRepMode, mBuf);
5659
5660    CMCHKPK(SPkU8, param->phySyncModePres, mBuf);
5661    CMCHKPK(SPkU16, param->phySyncMode, mBuf);
5662
5663    CMCHKPK(SPkU8, param->rxAntennaPortsPres, mBuf);
5664    CMCHKPK(SPkU16, param->rxAntennaPorts, mBuf);
5665
5666    CMCHKPK(SPkU8, param->txAntennaPortsPres, mBuf);
5667    CMCHKPK(SPkU16, param->txAntennaPorts, mBuf);
5668
5669    CMCHKPK(SPkU8, param->pucchProbDtxAckPres, mBuf);
5670    CMCHKPK(SPkU16, param->pucchProbDtxAck, mBuf);
5671
5672
5673    CMCHKPK(SPkU8, param->puschProbDtxAckPres, mBuf);
5674    CMCHKPK(SPkU16, param->puschProbDtxAck, mBuf);
5675
5676    CMCHKPK(SPkU8, param->srsDopEstFactorPres, mBuf);
5677    CMCHKPK(SPkU16, param->srsDopEstFactor, mBuf);
5678
5679    CMCHKPK(SPkU8, param->prachPkRatio0Pres, mBuf);
5680    CMCHKPK(SPkU16, param->prachPkRatio0, mBuf);
5681
5682    CMCHKPK(SPkU8, param->prachPkRatio4Pres, mBuf);
5683    CMCHKPK(SPkU16, param->prachPkRatio4, mBuf);
5684
5685    CMCHKPK(SPkU8, param->pucchNoiseGammaPres, mBuf);
5686    CMCHKPK(SPkU16, param->pucchNoiseGamma, mBuf);
5687
5688    CMCHKPK(SPkU8, param->extWinMarginPres, mBuf);
5689    CMCHKPK(SPkU16, param->extWinMargin, mBuf);
5690
5691    CMCHKPK(SPkU8, param->dciPowOsPres, mBuf);
5692    CMCHKPK(SPkU16, param->dciPowOs, mBuf);
5693
5694    CMCHKPK(SPkU8, param->cfiPowOsPres, mBuf);
5695    CMCHKPK(SPkU16, param->cfiPowOs, mBuf);
5696
5697    CMCHKPK(SPkU8, param->syncSigPowOsPres, mBuf);
5698    CMCHKPK(SPkU16, param->syncSigPowOs, mBuf);
5699
5700    CMCHKPK(cmPkCtfTddSfCfgInfo, &param->tddSfCfg, mBuf);
5701    CMCHKPK(cmPkCtfSrsUlCfgInfo, &param->srsUlCfg, mBuf);
5702    CMCHKPK(cmPkCtfPucchCfgInfo, &param->pucchCfg, mBuf);
5703    CMCHKPK(cmPkCtfPhichCfgInfo, &param->phichCfg, mBuf);
5704    CMCHKPK(cmPkCtfPuschCfgInfo, &param->puschCfg, mBuf);
5705    CMCHKPK(cmPkCtfPdschCfgInfo, &param->pdschCfg, mBuf);
5706    CMCHKPK(cmPkCtfPrachCfgInfo, &param->prachCfg, mBuf);
5707    CMCHKPK(cmPkLteTimingInfo, &param->actvnTime, mBuf);
5708
5709    CMCHKPK(cmPkCtfAntennaCfgInfo, &param->antennaCfg, mBuf);
5710    CMCHKPK(cmPkCtfTxSchemeCfg, &param->txCfg, mBuf);
5711    CMCHKPK(cmPkCtfBwCfgInfo, &param->bwCfg, mBuf);
5712    CMCHKPK(SPkU8, param->physCellId, mBuf);
5713    CMCHKPK(SPkU8, param->physCellIdPres, mBuf);
5714    CMCHKPK(SPkU8, param->cellIdGrpId, mBuf);
5715    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
5716    CMCHKPK(SPkU32, param->ctfReCfgType, mBuf);
5717    RETVALUE(ROK);
5718 }
5719
5720
5721 \f
5722 /***********************************************************
5723 *
5724 *     Func: cmUnpkCtfCellRecfgInfo
5725 *
5726 *
5727 *     Desc:   Cell Re-configuration Information
5728  * @details This structure contains the information for reconfiguration
5729  *          of a cell and its associated resources at PHY.
5730 *
5731 *
5732 *     Ret: S16
5733 *
5734 *     Notes:
5735 *
5736 *     File:
5737 *
5738 **********************************************************/
5739 #ifdef ANSI
5740 PUBLIC S16 cmUnpkCtfCellRecfgInfo
5741 (
5742 CtfCellRecfgInfo *param,
5743 Buffer *mBuf
5744 )
5745 #else
5746 PUBLIC S16 cmUnpkCtfCellRecfgInfo(param, mBuf)
5747 CtfCellRecfgInfo *param;
5748 Buffer *mBuf;
5749 #endif
5750 {
5751
5752    U32 tmpEnum;
5753    TRC3(cmUnpkCtfCellRecfgInfo)
5754
5755    /* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
5756    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
5757    param->ctfReCfgType = (CtfReCfgType)tmpEnum;
5758    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5759    CMCHKUNPK(SUnpkU8, &param->cellIdGrpId, mBuf);
5760    CMCHKUNPK(SUnpkU8, &param->physCellIdPres, mBuf);
5761    CMCHKUNPK(SUnpkU8, &param->physCellId, mBuf);
5762    CMCHKUNPK(cmUnpkCtfBwCfgInfo, &param->bwCfg, mBuf);
5763    CMCHKUNPK(cmUnpkCtfTxSchemeCfg, &param->txCfg, mBuf);
5764    CMCHKUNPK(cmUnpkCtfAntennaCfgInfo, &param->antennaCfg, mBuf);
5765
5766    CMCHKUNPK(cmUnpkLteTimingInfo, &param->actvnTime, mBuf);
5767    CMCHKUNPK(cmUnpkCtfPrachCfgInfo, &param->prachCfg, mBuf);
5768    CMCHKUNPK(cmUnpkCtfPdschCfgInfo, &param->pdschCfg, mBuf);
5769    CMCHKUNPK(cmUnpkCtfPuschCfgInfo, &param->puschCfg, mBuf);
5770    CMCHKUNPK(cmUnpkCtfPhichCfgInfo, &param->phichCfg, mBuf);
5771    CMCHKUNPK(cmUnpkCtfPucchCfgInfo, &param->pucchCfg, mBuf);
5772    CMCHKUNPK(cmUnpkCtfSrsUlCfgInfo, &param->srsUlCfg, mBuf);
5773    CMCHKUNPK(cmUnpkCtfTddSfCfgInfo, &param->tddSfCfg, mBuf);
5774
5775    CMCHKUNPK(SUnpkU16, &param->syncSigPowOs, mBuf);
5776    CMCHKUNPK(SUnpkU8, &param->syncSigPowOsPres, mBuf);
5777
5778    CMCHKUNPK(SUnpkU16, &param->cfiPowOs, mBuf);
5779    CMCHKUNPK(SUnpkU8, &param->cfiPowOsPres, mBuf);
5780
5781    CMCHKUNPK(SUnpkU16, &param->dciPowOs, mBuf);
5782    CMCHKUNPK(SUnpkU8, &param->dciPowOsPres, mBuf);
5783
5784    CMCHKUNPK(SUnpkU16, &param->extWinMargin, mBuf);
5785    CMCHKUNPK(SUnpkU8, &param->extWinMarginPres, mBuf);
5786
5787    CMCHKUNPK(SUnpkU16, &param->pucchNoiseGamma, mBuf);
5788    CMCHKUNPK(SUnpkU8, &param->pucchNoiseGammaPres, mBuf);
5789
5790    CMCHKUNPK(SUnpkU16, &param->prachPkRatio4, mBuf);
5791    CMCHKUNPK(SUnpkU8, &param->prachPkRatio4Pres, mBuf);
5792
5793    CMCHKUNPK(SUnpkU16, &param->prachPkRatio0, mBuf);
5794    CMCHKUNPK(SUnpkU8, &param->prachPkRatio0Pres, mBuf);
5795
5796    CMCHKUNPK(SUnpkU16, &param->srsDopEstFactor, mBuf);
5797    CMCHKUNPK(SUnpkU8, &param->srsDopEstFactorPres, mBuf);
5798
5799    CMCHKUNPK(SUnpkU16, &param->puschProbDtxAck, mBuf);
5800    CMCHKUNPK(SUnpkU8, &param->puschProbDtxAckPres, mBuf);
5801
5802    CMCHKUNPK(SUnpkU16, &param->pucchProbDtxAck, mBuf);
5803    CMCHKUNPK(SUnpkU8, &param->pucchProbDtxAckPres, mBuf);
5804
5805    CMCHKUNPK(SUnpkU16, &param->txAntennaPorts, mBuf);
5806    CMCHKUNPK(SUnpkU8, &param->txAntennaPortsPres, mBuf);
5807
5808    CMCHKUNPK(SUnpkU16, &param->rxAntennaPorts, mBuf);
5809    CMCHKUNPK(SUnpkU8, &param->rxAntennaPortsPres, mBuf);
5810
5811    CMCHKUNPK(SUnpkU16, &param->phySyncMode, mBuf);
5812    CMCHKUNPK(SUnpkU8, &param->phySyncModePres, mBuf);
5813
5814    CMCHKUNPK(SUnpkU16, &param->dataRepMode, mBuf);
5815    CMCHKUNPK(SUnpkU8, &param->dataRepModePres, mBuf);
5816
5817    CMCHKUNPK(SUnpkU16, &param->rachSrRepMode, mBuf);
5818    CMCHKUNPK(SUnpkU8, &param->rachSrRepModePres, mBuf);
5819
5820    CMCHKUNPK(SUnpkS16, &param->pilotSigPwr, mBuf);
5821    CMCHKUNPK(SUnpkS16, &param->priSigPwr, mBuf);
5822    CMCHKUNPK(SUnpkS16, &param->secSigPwr, mBuf);
5823    printf("param->pilotSigPwr = %d\nparam->priSigPwr = %d\n param->secSigPwr = %d\n",param->pilotSigPwr,param->priSigPwr,param->secSigPwr);
5824 #ifdef ENABLE_API_LOG
5825    CMCHKUNPK(SUnpkU8, &param->enableAPILog, mBuf);
5826 #endif /* ENABLE_API_LOG */
5827    RETVALUE(ROK);
5828 }
5829
5830
5831 \f
5832 /***********************************************************
5833 *
5834 *     Func: cmPkCtfDedPdschCfgInfo
5835 *
5836 *
5837 *     Desc:   Dedicated PDSCH Configuration
5838  * @details This structure contains the information for PDSCH configuration
5839  *          specific to an UE.
5840 *
5841 *
5842 *     Ret: S16
5843 *
5844 *     Notes:
5845 *
5846 *     File:
5847 *
5848 **********************************************************/
5849 #ifdef ANSI
5850 PUBLIC S16 cmPkCtfDedPdschCfgInfo
5851 (
5852 CtfDedPdschCfgInfo *param,
5853 Buffer *mBuf
5854 )
5855 #else
5856 PUBLIC S16 cmPkCtfDedPdschCfgInfo(param, mBuf)
5857 CtfDedPdschCfgInfo *param;
5858 Buffer *mBuf;
5859 #endif
5860 {
5861
5862    TRC3(cmPkCtfDedPdschCfgInfo)
5863
5864 /*ctf_c_001.main_1*/
5865    if(param->pres != FALSE)
5866       CMCHKPK(SPkU32, param->pA, mBuf);
5867    CMCHKPK(SPkU8, param->pres, mBuf);
5868    RETVALUE(ROK);
5869 }
5870
5871
5872 \f
5873 /***********************************************************
5874 *
5875 *     Func: cmUnpkCtfDedPdschCfgInfo
5876 *
5877 *
5878 *     Desc:   Dedicated PDSCH Configuration
5879  * @details This structure contains the information for PDSCH configuration
5880  *          specific to an UE.
5881 *
5882 *
5883 *     Ret: S16
5884 *
5885 *     Notes:
5886 *
5887 *     File:
5888 *
5889 **********************************************************/
5890 #ifdef ANSI
5891 PUBLIC S16 cmUnpkCtfDedPdschCfgInfo
5892 (
5893 CtfDedPdschCfgInfo *param,
5894 Buffer *mBuf
5895 )
5896 #else
5897 PUBLIC S16 cmUnpkCtfDedPdschCfgInfo(param, mBuf)
5898 CtfDedPdschCfgInfo *param;
5899 Buffer *mBuf;
5900 #endif
5901 {
5902    U32 tmpEnum;
5903    TRC3(cmUnpkCtfDedPdschCfgInfo)
5904
5905    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
5906 /*ctf_c_001.main_1*/
5907    if(param->pres != FALSE)
5908    {
5909       CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
5910       param->pA = (CtfPdschPaParam)tmpEnum;
5911    }
5912    RETVALUE(ROK);
5913 }
5914
5915
5916 \f
5917 /***********************************************************
5918 *
5919 *     Func: cmPkCtfDedPucchCfgInfo
5920 *
5921 *
5922 *     Desc:   Dedicated PUCCH Configuration
5923  * @details This structure contains the information for setting-up/release
5924  *          PUCCH configuration specific to an UE.
5925 *
5926 *
5927 *     Ret: S16
5928 *
5929 *     Notes:
5930 *
5931 *     File:
5932 *
5933 **********************************************************/
5934 #ifdef ANSI
5935 PUBLIC S16 cmPkCtfDedPucchCfgInfo
5936 (
5937 CtfDedPucchCfgInfo *param,
5938 Buffer *mBuf
5939 )
5940 #else
5941 PUBLIC S16 cmPkCtfDedPucchCfgInfo(param, mBuf)
5942 CtfDedPucchCfgInfo *param;
5943 Buffer *mBuf;
5944 #endif
5945 {
5946
5947    TRC3(cmPkCtfDedPucchCfgInfo)
5948
5949 /*ctf_c_001.main_1*/
5950   if(param->pres != FALSE)
5951   {
5952 #ifdef CTF_VER3
5953      /*ctf_c_001.main_4:115549: packing tddAckNackFBMode and tddAckNackCfgPres */
5954        if (param->tddAckNackCfgPres != FALSE)
5955        {
5956           CMCHKPK(SPkU32, param->tddAckNackFBMode, mBuf);
5957        }
5958
5959        CMCHKPK(SPkU8, param->tddAckNackCfgPres, mBuf);
5960 #endif /* CTF_VER3 */
5961       CMCHKPK(SPkU16, param->pucchSetup.n1PUCCHRep, mBuf);
5962 #ifdef CTF_VER3
5963       /*ctf_c_001.main_4:115549: packing pucchSetup.repFactPres */
5964        if (param->pucchSetup.repFactPres)
5965        {
5966           CMCHKPK(SPkU32, param->pucchSetup.repFact, mBuf);
5967        }
5968
5969        CMCHKPK(SPkU8, param->pucchSetup.repFactPres, mBuf);
5970 #else
5971         CMCHKPK(SPkU32, param->pucchSetup.repFact, mBuf);
5972 #endif /* CTF_VER3 */
5973       CMCHKPK(SPkU8, param->dedPucchCfgType, mBuf);
5974   }
5975   CMCHKPK(SPkU8, param->pres, mBuf);
5976   RETVALUE(ROK);
5977 }
5978
5979
5980 \f
5981 /***********************************************************
5982 *
5983 *     Func: cmUnpkCtfDedPucchCfgInfo
5984 *
5985 *
5986 *     Desc:   Dedicated PUCCH Configuration
5987  * @details This structure contains the information for setting-up/release
5988  *          PUCCH configuration specific to an UE.
5989 *
5990 *
5991 *     Ret: S16
5992 *
5993 *     Notes:
5994 *
5995 *     File:
5996 *
5997 **********************************************************/
5998 #ifdef ANSI
5999 PUBLIC S16 cmUnpkCtfDedPucchCfgInfo
6000 (
6001 CtfDedPucchCfgInfo *param,
6002 Buffer *mBuf
6003 )
6004 #else
6005 PUBLIC S16 cmUnpkCtfDedPucchCfgInfo(param, mBuf)
6006 CtfDedPucchCfgInfo *param;
6007 Buffer *mBuf;
6008 #endif
6009 {
6010
6011    TRC3(cmUnpkCtfDedPucchCfgInfo)
6012
6013    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
6014 /*ctf_c_001.main_1*/
6015    if(param->pres != FALSE)
6016    {
6017       CMCHKUNPK(SUnpkU8, &param->dedPucchCfgType, mBuf);
6018 #ifdef CTF_VER3
6019       /* ctf_c_001.main_4:115549: unpacking pucchSetup.repFactPres */
6020        CMCHKUNPK(SUnpkU8, &param->pucchSetup.repFactPres, mBuf);
6021
6022        if (param->pucchSetup.repFactPres)
6023        {
6024           CMCHKUNPK(SUnpkU32, (U32 *)&param->pucchSetup.repFact, mBuf);
6025        }
6026 #else
6027         CMCHKUNPK(SUnpkU32, (U32 *)&param->pucchSetup.repFact, mBuf);
6028 #endif /*CTF_VER3 */
6029       CMCHKUNPK(SUnpkU16, &param->pucchSetup.n1PUCCHRep, mBuf);
6030 #ifdef CTF_VER3
6031       /*ctf_c_001.main_4:115549: unpacking tddAckNackCfgPres and tddAckNackFBMode */
6032       CMCHKUNPK(SUnpkU8, &param->tddAckNackCfgPres, mBuf);
6033
6034       if (param->tddAckNackCfgPres != FALSE)
6035       {
6036          CMCHKUNPK(SUnpkU32, (U32 *)&param->tddAckNackFBMode, mBuf);
6037       }
6038 #endif /* CTF_VER3 */
6039    }
6040    RETVALUE(ROK);
6041 }
6042
6043
6044 \f
6045 /***********************************************************
6046 *
6047 *     Func: cmPkCtfDedPuschCfgInfo
6048 *
6049 *
6050 *     Desc:   Dedicated PUSCH Configuration
6051  * @details This structure contains the information for PUCCH
6052  *          configuration specific to an UE.
6053 *
6054 *
6055 *     Ret: S16
6056 *
6057 *     Notes:
6058 *
6059 *     File:
6060 *
6061 **********************************************************/
6062 #ifdef ANSI
6063 PUBLIC S16 cmPkCtfDedPuschCfgInfo
6064 (
6065 CtfDedPuschCfgInfo *param,
6066 Buffer *mBuf
6067 )
6068 #else
6069 PUBLIC S16 cmPkCtfDedPuschCfgInfo(param, mBuf)
6070 CtfDedPuschCfgInfo *param;
6071 Buffer *mBuf;
6072 #endif
6073 {
6074
6075    TRC3(cmPkCtfDedPuschCfgInfo)
6076
6077 /*ctf_c_001.main_1*/
6078    if(param->pres != FALSE)
6079    {
6080       CMCHKPK(SPkU8, param->betaOffsetCqiIdx, mBuf);
6081       CMCHKPK(SPkU8, param->betaOffsetRiIdx, mBuf);
6082       CMCHKPK(SPkU8, param->betaOffsetAckIdx, mBuf);
6083    }
6084    CMCHKPK(SPkU8, param->pres, mBuf);
6085    RETVALUE(ROK);
6086 }
6087
6088
6089 \f
6090 /***********************************************************
6091 *
6092 *     Func: cmUnpkCtfDedPuschCfgInfo
6093 *
6094 *
6095 *     Desc:   Dedicated PUSCH Configuration
6096  * @details This structure contains the information for PUCCH
6097  *          configuration specific to an UE.
6098 *
6099 *
6100 *     Ret: S16
6101 *
6102 *     Notes:
6103 *
6104 *     File:
6105 *
6106 **********************************************************/
6107 #ifdef ANSI
6108 PUBLIC S16 cmUnpkCtfDedPuschCfgInfo
6109 (
6110 CtfDedPuschCfgInfo *param,
6111 Buffer *mBuf
6112 )
6113 #else
6114 PUBLIC S16 cmUnpkCtfDedPuschCfgInfo(param, mBuf)
6115 CtfDedPuschCfgInfo *param;
6116 Buffer *mBuf;
6117 #endif
6118 {
6119
6120    TRC3(cmUnpkCtfDedPuschCfgInfo)
6121
6122    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
6123 /*ctf_c_001.main_1*/
6124    if(param->pres != FALSE)
6125    {
6126       CMCHKUNPK(SUnpkU8, &param->betaOffsetAckIdx, mBuf);
6127       CMCHKUNPK(SUnpkU8, &param->betaOffsetRiIdx, mBuf);
6128       CMCHKUNPK(SUnpkU8, &param->betaOffsetCqiIdx, mBuf);
6129    }
6130    RETVALUE(ROK);
6131 }
6132
6133
6134 #ifndef TFU_UPGRADE
6135 \f
6136 /***********************************************************
6137 *
6138 *     Func: cmPkCtfCqiRptModePeriodic
6139 *
6140 *
6141 *     Desc:   Periodic CQI Report Configuration
6142  * @details This structure contains the information for periodic CQI report
6143  *          related configuration specific to an UE.
6144 *
6145 *
6146 *     Ret: S16
6147 *
6148 *     Notes:
6149 *
6150 *     File:
6151 *
6152 **********************************************************/
6153 #ifdef ANSI
6154 PUBLIC S16 cmPkCtfCqiRptModePeriodic
6155 (
6156 CtfCqiRptModePeriodic *param,
6157 Buffer *mBuf
6158 )
6159 #else
6160 PUBLIC S16 cmPkCtfCqiRptModePeriodic(param, mBuf)
6161 CtfCqiRptModePeriodic *param;
6162 Buffer *mBuf;
6163 #endif
6164 {
6165
6166    TRC3(cmPkCtfCqiRptModePeriodic)
6167 /* ctf_c_001.main_2: added packning for cqiMask*/
6168 #ifdef CTF_VER1
6169       CMCHKPK(SPkU32, (U32 )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
6170       CMCHKPK(SPkU8, param->cqiSetup.cqiMask.pres, mBuf);
6171 #endif /* CTF_VER1 */
6172       CMCHKPK(SPkU8, param->cqiSetup.simultaneousAckNack, mBuf);
6173       CMCHKPK(SPkU16, param->cqiSetup.riCfgIndx, mBuf);
6174       CMCHKPK(SPkU8, param->cqiSetup.riCfgPres, mBuf);
6175       CMCHKPK(SPkU8, param->cqiSetup.subbandCqi.k, mBuf);
6176       CMCHKPK(SPkU8, param->cqiSetup.formatIndicator, mBuf);
6177       CMCHKPK(SPkU16, param->cqiSetup.cqiPmiCfgIndx, mBuf);
6178       CMCHKPK(SPkU16, param->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
6179    CMCHKPK(SPkU8, param->cqiPeriodicCfgType, mBuf);
6180    RETVALUE(ROK);
6181 }
6182
6183
6184 \f
6185 /***********************************************************
6186 *
6187 *     Func: cmUnpkCtfCqiRptModePeriodic
6188 *
6189 *
6190 *     Desc:   Periodic CQI Report Configuration
6191  * @details This structure contains the information for periodic CQI report
6192  *          related configuration specific to an UE.
6193 *
6194 *
6195 *     Ret: S16
6196 *
6197 *     Notes:
6198 *
6199 *     File:
6200 *
6201 **********************************************************/
6202 #ifdef ANSI
6203 PUBLIC S16 cmUnpkCtfCqiRptModePeriodic
6204 (
6205 CtfCqiRptModePeriodic *param,
6206 Buffer *mBuf
6207 )
6208 #else
6209 PUBLIC S16 cmUnpkCtfCqiRptModePeriodic(param, mBuf)
6210 CtfCqiRptModePeriodic *param;
6211 Buffer *mBuf;
6212 #endif
6213 {
6214 #ifdef CTF_VER1
6215    U32 tmpEnum;
6216 #endif
6217    TRC3(cmUnpkCtfCqiRptModePeriodic)
6218
6219    CMCHKUNPK(SUnpkU8, &param->cqiPeriodicCfgType, mBuf);
6220       CMCHKUNPK(SUnpkU16, &param->cqiSetup.cqiPUCCHRsrcIndx, mBuf);
6221       CMCHKUNPK(SUnpkU16, &param->cqiSetup.cqiPmiCfgIndx, mBuf);
6222       CMCHKUNPK(SUnpkU8, &param->cqiSetup.formatIndicator, mBuf);
6223          CMCHKUNPK(SUnpkU8, &param->cqiSetup.subbandCqi.k, mBuf);
6224       CMCHKUNPK(SUnpkU8, &param->cqiSetup.riCfgPres, mBuf);
6225       CMCHKUNPK(SUnpkU16, &param->cqiSetup.riCfgIndx, mBuf);
6226       CMCHKUNPK(SUnpkU8, &param->cqiSetup.simultaneousAckNack, mBuf);
6227 /* ctf_c_001.main_2: added Unpackning for cqiMask*/
6228 #ifdef CTF_VER1
6229       CMCHKUNPK(SUnpkU8, &param->cqiSetup.cqiMask.pres, mBuf);
6230       CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
6231       param->cqiSetup.cqiMask.cqiMaskSetup = tmpEnum;
6232 #endif /* CTF_VER1 */
6233    RETVALUE(ROK);
6234 }
6235
6236
6237 \f
6238 /***********************************************************
6239 *
6240 *     Func: cmPkCtfCqiReportCfgInfo
6241 *
6242 *
6243 *     Desc:   CQI Report Configuration
6244  * @details This structure contains the information for CQI report
6245  *          related configuration specific to an UE.
6246 *
6247 *
6248 *     Ret: S16
6249 *
6250 *     Notes:
6251 *
6252 *     File:
6253 *
6254 **********************************************************/
6255 #ifdef ANSI
6256 PUBLIC S16 cmPkCtfCqiReportCfgInfo
6257 (
6258 CtfCqiReportCfgInfo *param,
6259 Buffer *mBuf
6260 )
6261 #else
6262 PUBLIC S16 cmPkCtfCqiReportCfgInfo(param, mBuf)
6263 CtfCqiReportCfgInfo *param;
6264 Buffer *mBuf;
6265 #endif
6266 {
6267
6268    TRC3(cmPkCtfCqiReportCfgInfo)
6269
6270 /*ctf_c_001.main_1*/
6271    if(param->pres != FALSE)
6272    {
6273 #ifdef CTF_VER2
6274       /*
6275        * ctf_c_001.main_2: Added provision to send Periodic and aPeriodic CQI
6276        *report configuration in the same message
6277        */
6278        if(param->reportMode.aPeriodicRpt.pres != FALSE)
6279        {
6280            CMCHKPK(SPkU32, param->reportMode.aPeriodicRpt.aPeriodicRptMode, mBuf);
6281        }
6282        CMCHKPK(SPkU8, param->reportMode.aPeriodicRpt.pres, mBuf);
6283
6284        if(param->reportMode.periodicRpt.pres != FALSE)
6285        {
6286            CMCHKPK(cmPkCtfCqiRptModePeriodic, &param->reportMode.periodicRpt, mBuf);
6287        }
6288        CMCHKPK(SPkU8, param->reportMode.periodicRpt.pres, mBuf);
6289
6290 #else /* CTF_VER2 */
6291
6292       switch(param->reportingMode) {
6293          case CTF_CQI_RPTMODE_PRDIOC:
6294             CMCHKPK(cmPkCtfCqiRptModePeriodic, &param->reportMode.periodicRpt, mBuf);
6295             break;
6296          case CTF_CQI_RPTMODE_APRDIOC:
6297             CMCHKPK(SPkU32, param->reportMode.aPeriodicRpt, mBuf);
6298             break;
6299          default :
6300             RETVALUE(RFAILED);
6301       }
6302       CMCHKPK(SPkU8, param->reportingMode, mBuf);
6303 #endif /* CTF_VER2 */
6304
6305 /* ctf_c_001.main_2: added packning for pmiRiRpt*/
6306 #ifdef CTF_VER1
6307        CMCHKPK(SPkU32, param->pmiRiRpt.pmiRiRptSetup, mBuf);
6308        CMCHKPK(SPkU8, param->pmiRiRpt.pres, mBuf);
6309 #endif /* CTF_VER1 */
6310    }
6311
6312    CMCHKPK(SPkU8, param->pres, mBuf);
6313    RETVALUE(ROK);
6314 }
6315
6316
6317 \f
6318 /***********************************************************
6319 *
6320 *     Func: cmUnpkCtfCqiReportCfgInfo
6321 *
6322 *
6323 *     Desc:   CQI Report Configuration
6324  * @details This structure contains the information for CQI report
6325  *          related configuration specific to an UE.
6326 *
6327 *
6328 *     Ret: S16
6329 *
6330 *     Notes:
6331 *
6332 *     File:
6333 *
6334 **********************************************************/
6335 #ifdef ANSI
6336 PUBLIC S16 cmUnpkCtfCqiReportCfgInfo
6337 (
6338 CtfCqiReportCfgInfo *param,
6339 Buffer *mBuf
6340 )
6341 #else
6342 PUBLIC S16 cmUnpkCtfCqiReportCfgInfo(param, mBuf)
6343 CtfCqiReportCfgInfo *param;
6344 Buffer *mBuf;
6345 #endif
6346 {
6347 #if defined (CTF_VER1) || defined (CTF_VER2)
6348    U32 tmpEnum;
6349 #endif
6350    TRC3(cmUnpkCtfCqiReportCfgInfo)
6351
6352    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
6353 /*ctf_c_001.main_1*/
6354    if(param->pres != FALSE)
6355    {
6356 /* ctf_c_001.main_2: added Unpackning for cqiMask*/
6357 #ifdef CTF_VER1
6358       CMCHKUNPK(SUnpkU8, &param->pmiRiRpt.pres, mBuf);
6359       CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
6360       param->pmiRiRpt.pmiRiRptSetup = tmpEnum;
6361 #endif /* CTF_VER1 */
6362
6363 #ifdef CTF_VER2
6364       /*
6365        *ctf_c_001.main_2: Added provision to send Periodic and aPeriodic CQI
6366        *report configuration in the same message
6367        */
6368       CMCHKUNPK(SUnpkU8, &param->reportMode.periodicRpt.pres, mBuf)
6369       if(param->reportMode.periodicRpt.pres != FALSE)
6370       {
6371          CMCHKUNPK(cmUnpkCtfCqiRptModePeriodic, &param->reportMode.periodicRpt, mBuf);
6372       }
6373
6374       CMCHKUNPK(SUnpkU8, &param->reportMode.aPeriodicRpt.pres, mBuf)
6375       if(param->reportMode.aPeriodicRpt.pres != FALSE)
6376       {
6377          CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
6378          param->reportMode.aPeriodicRpt.aPeriodicRptMode =
6379             (CtfCqiRptModeAperiodic)tmpEnum;
6380       }
6381
6382 #else /* CTF_VER2 */
6383
6384       CMCHKUNPK(SUnpkU8, &param->reportingMode, mBuf);
6385       switch(param->reportingMode) {
6386          case CTF_CQI_RPTMODE_APRDIOC:
6387             CMCHKUNPK(SUnpkU32, (U32 *)&param->reportMode.aPeriodicRpt, mBuf);
6388             break;
6389          case CTF_CQI_RPTMODE_PRDIOC:
6390             CMCHKUNPK(cmUnpkCtfCqiRptModePeriodic, &param->reportMode.periodicRpt, mBuf);
6391             break;
6392          default :
6393             RETVALUE(RFAILED);
6394       }
6395 #endif /* CTF_VER2 */
6396    }
6397    RETVALUE(ROK);
6398 }
6399
6400
6401 \f
6402 /***********************************************************
6403 *
6404 *     Func: cmPkCtfDedSrsUlCfgInfo
6405 *
6406 *
6407 *     Desc:   Dedicated Uplink SRS Configuration
6408  * @details This structure contains the information for setting-up/release
6409  *          UL SRS configuration specific to an UE.
6410 *
6411 *
6412 *     Ret: S16
6413 *
6414 *     Notes:
6415 *
6416 *     File:
6417 *
6418 **********************************************************/
6419 #ifdef ANSI
6420 PUBLIC S16 cmPkCtfDedSrsUlCfgInfo
6421 (
6422 CtfDedSrsUlCfgInfo *param,
6423 Buffer *mBuf
6424 )
6425 #else
6426 PUBLIC S16 cmPkCtfDedSrsUlCfgInfo(param, mBuf)
6427 CtfDedSrsUlCfgInfo *param;
6428 Buffer *mBuf;
6429 #endif
6430 {
6431
6432    TRC3(cmPkCtfDedSrsUlCfgInfo)
6433
6434 /*ctf_c_001.main_1*/
6435    if(param->pres != FALSE)
6436    {
6437       CMCHKPK(SPkU8, param->dedSrsSetup.cyclicShift, mBuf);
6438       CMCHKPK(SPkU8, param->dedSrsSetup.txComb, mBuf);
6439       CMCHKPK(SPkU16, param->dedSrsSetup.srsCfgIdx, mBuf);
6440       CMCHKPK(SPkU8, param->dedSrsSetup.duration, mBuf);
6441       CMCHKPK(SPkU8, param->dedSrsSetup.freqDmnPos, mBuf);
6442       CMCHKPK(SPkU8, param->dedSrsSetup.srsHopngBw, mBuf);
6443       CMCHKPK(SPkU8, param->dedSrsSetup.srsBw, mBuf);
6444       CMCHKPK(SPkU8, param->dedSrsUlCfgType, mBuf);
6445    }
6446    CMCHKPK(SPkU8, param->pres, mBuf);
6447    RETVALUE(ROK);
6448 }
6449
6450
6451 \f
6452 /***********************************************************
6453 *
6454 *     Func: cmUnpkCtfDedSrsUlCfgInfo
6455 *
6456 *
6457 *     Desc:   Dedicated Uplink SRS Configuration
6458  * @details This structure contains the information for setting-up/release
6459  *          UL SRS configuration specific to an UE.
6460 *
6461 *
6462 *     Ret: S16
6463 *
6464 *     Notes:
6465 *
6466 *     File:
6467 *
6468 **********************************************************/
6469 #ifdef ANSI
6470 PUBLIC S16 cmUnpkCtfDedSrsUlCfgInfo
6471 (
6472 CtfDedSrsUlCfgInfo *param,
6473 Buffer *mBuf
6474 )
6475 #else
6476 PUBLIC S16 cmUnpkCtfDedSrsUlCfgInfo(param, mBuf)
6477 CtfDedSrsUlCfgInfo *param;
6478 Buffer *mBuf;
6479 #endif
6480 {
6481
6482    TRC3(cmUnpkCtfDedSrsUlCfgInfo)
6483
6484    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
6485 /*ctf_c_001.main_1*/
6486    if(param->pres != FALSE)
6487    {
6488       CMCHKUNPK(SUnpkU8, &param->dedSrsUlCfgType, mBuf);
6489       CMCHKUNPK(SUnpkU8, &param->dedSrsSetup.srsBw, mBuf);
6490       CMCHKUNPK(SUnpkU8, &param->dedSrsSetup.srsHopngBw, mBuf);
6491       CMCHKUNPK(SUnpkU8, &param->dedSrsSetup.freqDmnPos, mBuf);
6492       CMCHKUNPK(SUnpkU8, &param->dedSrsSetup.duration, mBuf);
6493       CMCHKUNPK(SUnpkU16, &param->dedSrsSetup.srsCfgIdx, mBuf);
6494       CMCHKUNPK(SUnpkU8, &param->dedSrsSetup.txComb, mBuf);
6495       CMCHKUNPK(SUnpkU8, &param->dedSrsSetup.cyclicShift, mBuf);
6496    }
6497    RETVALUE(ROK);
6498 }
6499
6500
6501 \f
6502 /***********************************************************
6503 *
6504 *     Func: cmPkCtfDedSRCfgInfo
6505 *
6506 *
6507 *     Desc:   Dedicated SR Configuration
6508  * @details This structure contains the information for setting-up/release
6509  *          SR configuration specific to an UE at PHY.
6510 *
6511 *
6512 *     Ret: S16
6513 *
6514 *     Notes:
6515 *
6516 *     File:
6517 *
6518 **********************************************************/
6519 #ifdef ANSI
6520 PUBLIC S16 cmPkCtfDedSRCfgInfo
6521 (
6522 CtfDedSRCfgInfo *param,
6523 Buffer *mBuf
6524 )
6525 #else
6526 PUBLIC S16 cmPkCtfDedSRCfgInfo(param, mBuf)
6527 CtfDedSRCfgInfo *param;
6528 Buffer *mBuf;
6529 #endif
6530 {
6531
6532    TRC3(cmPkCtfDedSRCfgInfo)
6533
6534 /*ctf_c_001.main_1*/
6535   if(param->pres != FALSE)
6536   {
6537      CMCHKPK(SPkU8, param->dedSrSetup.srCfgIdx, mBuf);
6538      CMCHKPK(SPkU16, param->dedSrSetup.srPUCCHRi, mBuf);
6539      CMCHKPK(SPkU8, param->dedSRCfgType, mBuf);
6540   }
6541   CMCHKPK(SPkU8, param->pres, mBuf);
6542   RETVALUE(ROK);
6543 }
6544
6545
6546 \f
6547 /***********************************************************
6548 *
6549 *     Func: cmUnpkCtfDedSRCfgInfo
6550 *
6551 *
6552 *     Desc:   Dedicated SR Configuration
6553  * @details This structure contains the information for setting-up/release
6554  *          SR configuration specific to an UE at PHY.
6555 *
6556 *
6557 *     Ret: S16
6558 *
6559 *     Notes:
6560 *
6561 *     File:
6562 *
6563 **********************************************************/
6564 #ifdef ANSI
6565 PUBLIC S16 cmUnpkCtfDedSRCfgInfo
6566 (
6567 CtfDedSRCfgInfo *param,
6568 Buffer *mBuf
6569 )
6570 #else
6571 PUBLIC S16 cmUnpkCtfDedSRCfgInfo(param, mBuf)
6572 CtfDedSRCfgInfo *param;
6573 Buffer *mBuf;
6574 #endif
6575 {
6576
6577    TRC3(cmUnpkCtfDedSRCfgInfo)
6578
6579    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
6580 /*ctf_c_001.main_1*/
6581    if(param->pres != FALSE)
6582    {
6583       CMCHKUNPK(SUnpkU8, &param->dedSRCfgType, mBuf);
6584       CMCHKUNPK(SUnpkU16, &param->dedSrSetup.srPUCCHRi, mBuf);
6585       CMCHKUNPK(SUnpkU8, &param->dedSrSetup.srCfgIdx, mBuf);
6586    }
6587    RETVALUE(ROK);
6588 }
6589
6590 #endif /* TFU_UPGRADE */
6591
6592 \f
6593 /***********************************************************
6594 *
6595 *     Func: cmPkCtfDedAntCfgInfo
6596 *
6597 *
6598 *     Desc:   Dedicated Antenna Configuration
6599  * @details This structure contains the information for antenna related
6600  *          configuration specific to an UE at PHY.
6601 *
6602 *
6603 *     Ret : S16
6604 *
6605 *     Notes:
6606 *
6607 *     File:
6608 *
6609 **********************************************************/
6610 #ifdef ANSI
6611 PUBLIC S16 cmPkCtfDedAntCfgInfo
6612 (
6613 CtfDedAntCfgInfo *param,
6614 Buffer *mBuf
6615 )
6616 #else
6617 PUBLIC S16 cmPkCtfDedAntCfgInfo(param, mBuf)
6618 CtfDedAntCfgInfo *param;
6619 Buffer *mBuf;
6620 #endif
6621 {
6622
6623 #ifdef CTF_VER2
6624    U8  idx;
6625 #endif  /* CTF_VER2 */
6626
6627    TRC3(cmPkCtfDedAntCfgInfo)
6628
6629 /*ctf_c_001.main_1*/
6630    if(param->pres != FALSE)
6631    {
6632       CMCHKPK(SPkU32, param->ueTxAntSelection.txAntSelect, mBuf);
6633       CMCHKPK(SPkU8, param->ueTxAntSelection.cfgType, mBuf);
6634      /* ctf_c_001.main_3 txMode is of type enum and is 32bit length */
6635       CMCHKPK(SPkU32, (U32)param->txMode, mBuf);
6636 #ifdef CTF_VER2
6637       /*
6638        *ctf_c_001.main_2: Added Packing of CodeBookSubsetRestriction parameter
6639        */
6640       switch(param->codeBookSubsetRes.ctfCdBkRestType)
6641       {
6642           case N2TX_ANT_TM3:
6643               CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
6644                              n2TxAntTm3, mBuf);
6645               break;
6646
6647           case N4TX_ANT_TM3:
6648               CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
6649                              n4TxAntTm3, mBuf);
6650               break;
6651
6652           case N2TX_ANT_TM4:
6653               CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
6654                              n2TxAntTm4, mBuf);
6655               break;
6656
6657           case N4TX_ANT_TM4:
6658               for(idx = 0; idx < 8; idx++)
6659                   CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
6660                                  n4TxAntTm4[idx], mBuf);
6661               break;
6662
6663           case N2TX_ANT_TM5:
6664               CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
6665                              n2TxAntTm5, mBuf);
6666               break;
6667
6668           case N4TX_ANT_TM5:
6669               CMCHKPK(SPkU16, param->codeBookSubsetRes.codeBookSubsetRestn.
6670                               n4TxAntTm5, mBuf);
6671               break;
6672
6673           case N2TX_ANT_TM6:
6674               CMCHKPK(SPkU8, param->codeBookSubsetRes.codeBookSubsetRestn.
6675                              n2TxAntTm6, mBuf);
6676               break;
6677
6678           case N4TX_ANT_TM6:
6679               CMCHKPK(SPkU16, param->codeBookSubsetRes.codeBookSubsetRestn.
6680                               n4TxAntTm6, mBuf);
6681               break;
6682           default :
6683               break;
6684
6685       }
6686       CMCHKPK(SPkU32, param->codeBookSubsetRes.ctfCdBkRestType, mBuf);
6687 #endif /* CTF_VER2 */
6688    }
6689    CMCHKPK(SPkU8, param->pres, mBuf);
6690    RETVALUE(ROK);
6691 }
6692
6693
6694 \f
6695 /***********************************************************
6696 *
6697 *     Func: cmUnpkCtfDedAntCfgInfo
6698 *
6699 *
6700 *     Desc:   Dedicated Antenna Configuration
6701  * @details This structure contains the information for antenna related
6702  *          configuration specific to an UE at PHY.
6703 *
6704 *
6705 *     Ret: S16
6706 *
6707 *     Notes:
6708 *
6709 *     File:
6710 *
6711 **********************************************************/
6712 #ifdef ANSI
6713 PUBLIC S16 cmUnpkCtfDedAntCfgInfo
6714 (
6715 CtfDedAntCfgInfo *param,
6716 Buffer *mBuf
6717 )
6718 #else
6719 PUBLIC S16 cmUnpkCtfDedAntCfgInfo(param, mBuf)
6720 CtfDedAntCfgInfo *param;
6721 Buffer *mBuf;
6722 #endif
6723 {
6724 #ifdef CTF_VER2
6725    S16  idx;
6726 #endif /* CTF_VER2 */
6727
6728    U32 tmpEnum;
6729
6730    TRC3(cmUnpkCtfDedAntCfgInfo)
6731
6732    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
6733 /*ctf_c_001.main_1*/
6734    if(param->pres != FALSE)
6735    {
6736 #ifdef CTF_VER2
6737       /*
6738        * Added Unpacking for CodeBookSubsetRestriction parameter
6739        */
6740       CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
6741       param->codeBookSubsetRes.ctfCdBkRestType = (CtfCdBkSubsetRestnType)tmpEnum;
6742       switch(param->codeBookSubsetRes.ctfCdBkRestType)
6743       {
6744           case N2TX_ANT_TM3:
6745               CMCHKUNPK(SUnpkU8, &param->codeBookSubsetRes.codeBookSubsetRestn.
6746                              n2TxAntTm3, mBuf);
6747               break;
6748
6749           case N4TX_ANT_TM3:
6750               CMCHKUNPK(SUnpkU8, &param->codeBookSubsetRes.codeBookSubsetRestn.
6751                              n4TxAntTm3, mBuf);
6752               break;
6753
6754           case N2TX_ANT_TM4:
6755               CMCHKUNPK(SUnpkU8, &param->codeBookSubsetRes.codeBookSubsetRestn.
6756                              n2TxAntTm4, mBuf);
6757               break;
6758
6759           case N4TX_ANT_TM4:
6760               for(idx = 7; idx >= 0; idx--)
6761               {
6762                  CMCHKUNPK(SUnpkU8, &(param->codeBookSubsetRes.codeBookSubsetRestn.
6763                        n4TxAntTm4[idx]), mBuf);
6764               }
6765               break;
6766
6767           case N2TX_ANT_TM5:
6768               CMCHKUNPK(SUnpkU8, &param->codeBookSubsetRes.codeBookSubsetRestn.
6769                              n2TxAntTm5, mBuf);
6770               break;
6771
6772           case N4TX_ANT_TM5:
6773               CMCHKUNPK(SUnpkU16, &param->codeBookSubsetRes.codeBookSubsetRestn.
6774                               n4TxAntTm5, mBuf);
6775               break;
6776
6777           case N2TX_ANT_TM6:
6778               CMCHKUNPK(SUnpkU8, &param->codeBookSubsetRes.codeBookSubsetRestn.
6779                              n2TxAntTm6, mBuf);
6780               break;
6781
6782           case N4TX_ANT_TM6:
6783               CMCHKUNPK(SUnpkU16, &param->codeBookSubsetRes.codeBookSubsetRestn.
6784                               n4TxAntTm6, mBuf);
6785               break;
6786           default :
6787               break;
6788       }
6789 #endif /* CTF_VER2 */
6790       /* ctf_c_001.main_3 Enum is 32bit length */
6791       CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
6792       param->txMode = (CtfUeTxAntMode)tmpEnum;
6793       CMCHKUNPK(SUnpkU8, &param->ueTxAntSelection.cfgType, mBuf);
6794       CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
6795       param->ueTxAntSelection.txAntSelect = (CtfUeTxAntSelectType)tmpEnum;
6796    }
6797    RETVALUE(ROK);
6798 }
6799
6800 \f
6801 /***********************************************************
6802 *
6803 *     Func: cmPkCtfUeSecCellCfgInfo
6804 *
6805 *
6806 *     Desc:   Secondary Cell Configuration for a UE
6807  * @details This structure contains the information for
6808 *           secondary cells for the UE
6809 *
6810 *     Ret: S16
6811 *
6812 *     Notes:
6813 *
6814 *     File:
6815 *
6816 **********************************************************/
6817 #ifdef ANSI
6818 PUBLIC S16 cmPkCtfUeSecCellCfgInfo
6819 (
6820 CtfUeSecCellCfgInfo *param,
6821 Buffer *mBuf
6822 )
6823 #else
6824 PUBLIC S16 cmPkCtfUeSecCellCfgInfo(*param, mBuf)
6825 CtfUeSecCellCfgInfo *param;
6826 Buffer *mBuf;
6827 #endif
6828 {
6829    CMCHKPK(SPkU16, param->sCellId, mBuf);
6830    CMCHKPK(SPkU8, param->sCellIdx, mBuf);
6831
6832    RETVALUE(ROK);
6833 }
6834 /***********************************************************
6835 *
6836 *     Func: cmPkCtfSecCellCfgInfo
6837 *
6838 *
6839 *     Desc:   Secondary Cell Configuration for a UE
6840  * @details This structure contains the information for
6841 *           secondary cells for the UE
6842 *
6843 *     Ret: S16
6844 *
6845 *     Notes:
6846 *
6847 *     File:
6848 *
6849 **********************************************************/
6850 #ifdef ANSI
6851 PUBLIC S16 cmPkCtfSecCellCfgInfo
6852 (
6853 CtfSecCellCfgInfo *param,
6854 Buffer *mBuf
6855 )
6856 #else
6857 PUBLIC S16 cmPkCtfSecCellCfgInfo(*param, mBuf)
6858 CtfSecCellCfgInfo *param;
6859 Buffer *mBuf;
6860 #endif
6861 {
6862    S8 idx;
6863
6864    for(idx = param->numSCells - 1; idx >= 0; idx--)
6865    {
6866       CMCHKPK(cmPkCtfUeSecCellCfgInfo, &param->ueSCellDedCfg[(U8)idx], mBuf);
6867    }
6868    CMCHKPK(SPkU32, param->sCellAction, mBuf);
6869    CMCHKPK(SPkU8, param->numSCells, mBuf);
6870
6871    RETVALUE(ROK);
6872 }
6873
6874 /***********************************************************
6875 *
6876 *     Func: cmUnpkCtfUeSecCellCfgInfo
6877 *
6878 *
6879 *     Desc:   Secondary Cell Configuration for a UE
6880  * @details This structure contains the information for
6881 *           secondary cells for the UE
6882 *
6883 *     Ret: S16
6884 *
6885 *     Notes:
6886 *
6887 *     File:
6888 *
6889 **********************************************************/
6890 #ifdef ANSI
6891 PUBLIC S16 cmUnpkCtfUeSecCellCfgInfo
6892 (
6893 CtfUeSecCellCfgInfo *param,
6894 Buffer *mBuf
6895 )
6896 #else
6897 PUBLIC S16 cmUnpkCtfUeSecCellCfgInfo(*param, mBuf)
6898 CtfUeSecCellCfgInfo *param;
6899 Buffer *mBuf;
6900 #endif
6901 {
6902    CMCHKUNPK(SUnpkU8, &param->sCellIdx, mBuf);
6903    CMCHKUNPK(SUnpkU16, &param->sCellId, mBuf);
6904
6905    RETVALUE(ROK);
6906 }
6907 \f
6908 /***********************************************************
6909 *
6910 *     Func: cmUnpkCtfSecCellCfgInfo
6911 *
6912 *
6913 *     Desc:   Secondary Cell Configuration for a UE
6914  * @details This structure contains the information for
6915 *           secondary cells for the UE
6916 *
6917 *     Ret: S16
6918 *
6919 *     Notes:
6920 *
6921 *     File:
6922 *
6923 **********************************************************/
6924
6925 #ifdef ANSI
6926 PUBLIC S16 cmUnpkCtfSecCellCfgInfo
6927 (
6928 CtfSecCellCfgInfo *param,
6929 Buffer *mBuf
6930 )
6931 #else
6932 PUBLIC S16 cmUnpkCtfSecCellCfgInfo(*param, mBuf)
6933 CtfSecCellCfgInfo *param;
6934 Buffer *mBuf;
6935 #endif
6936 {
6937    U8 idx;
6938
6939    CMCHKUNPK(SUnpkU8, &param->numSCells, mBuf);
6940    CMCHKUNPK(SUnpkU32, (U32*)&param->sCellAction, mBuf);
6941    for(idx = 0 ; idx < param->numSCells; idx++)
6942    {
6943       CMCHKUNPK(cmUnpkCtfUeSecCellCfgInfo, &param->ueSCellDedCfg[idx], mBuf);
6944    }
6945
6946    RETVALUE(ROK);
6947 }
6948
6949 \f
6950 /***********************************************************
6951 *
6952 *     Func: cmPkCtfUeCatCfgInfo
6953 *
6954 *
6955 *     Desc:   UE Category Configuration
6956  * @details This structure contains the information for configuring
6957  *          the UE category at PHY.
6958 *
6959 *
6960 *     Ret : S16
6961 *
6962 *     Notes:
6963 *
6964 *     File:
6965 *
6966 **********************************************************/
6967 #ifdef ANSI
6968 PUBLIC S16 cmPkCtfUeCatCfgInfo
6969 (
6970 CtfUeCatCfgInfo *param,
6971 Buffer *mBuf
6972 )
6973 #else
6974 PUBLIC S16 cmPkCtfUeCatCfgInfo(param, mBuf)
6975 CtfUeCatCfgInfo *param;
6976 Buffer *mBuf;
6977 #endif
6978 {
6979
6980    TRC3(cmPkCtfUeCatCfgInfo)
6981
6982 /*ctf_c_001.main_1*/
6983    if(param->pres != FALSE)
6984       CMCHKPK(SPkU32, param->ueCategory, mBuf);
6985    CMCHKPK(SPkU8, param->pres, mBuf);
6986    RETVALUE(ROK);
6987 }
6988
6989
6990 \f
6991 /***********************************************************
6992 *
6993 *     Func: cmUnpkCtfUeCatCfgInfo
6994 *
6995 *
6996 *     Desc:   UE Category Configuration
6997  * @details This structure contains the information for configuring
6998  *          the UE category at PHY.
6999 *
7000 *
7001 *     Ret: S16
7002 *
7003 *     Notes:
7004 *
7005 *     File:
7006 *
7007 **********************************************************/
7008 #ifdef ANSI
7009 PUBLIC S16 cmUnpkCtfUeCatCfgInfo
7010 (
7011 CtfUeCatCfgInfo *param,
7012 Buffer *mBuf
7013 )
7014 #else
7015 PUBLIC S16 cmUnpkCtfUeCatCfgInfo(param, mBuf)
7016 CtfUeCatCfgInfo *param;
7017 Buffer *mBuf;
7018 #endif
7019 {
7020
7021    TRC3(cmUnpkCtfUeCatCfgInfo)
7022
7023    CMCHKUNPK(SUnpkU8, &param->pres, mBuf);
7024 /*ctf_c_001.main_1*/
7025    if(param->pres != FALSE)
7026       CMCHKUNPK(SUnpkU32, (U32 *)&param->ueCategory, mBuf);
7027    RETVALUE(ROK);
7028 }
7029
7030
7031 \f
7032 /***********************************************************
7033 *
7034 *     Func: cmPkCtfDedCfgInfo
7035 *
7036 *
7037 *     Desc:   Dedicated Configuration Information
7038  * @details This structure contains the information for configuration
7039  *          of UE-specific physical channel resources at PHY.
7040 *
7041 *
7042 *     Ret: S16
7043 *
7044 *     Notes:
7045 *
7046 *     File:
7047 *
7048 **********************************************************/
7049 #ifdef ANSI
7050 PUBLIC S16 cmPkCtfDedCfgInfo
7051 (
7052 CtfDedCfgInfo *param,
7053 Buffer *mBuf
7054 )
7055 #else
7056 PUBLIC S16 cmPkCtfDedCfgInfo(param, mBuf)
7057 CtfDedCfgInfo *param;
7058 Buffer *mBuf;
7059 #endif
7060 {
7061
7062    TRC3(cmPkCtfDedCfgInfo)
7063 #ifdef EMTC_ENABLE
7064    CMCHKPK(SPkU8, param->isEmtcUe, mBuf);
7065 #endif
7066    CMCHKPK(cmPkCtfDedAntCfgInfo, &param->antInfo, mBuf);
7067 #ifndef TFU_UPGRADE
7068    CMCHKPK(cmPkCtfDedSRCfgInfo, &param->dedSRCfg, mBuf);
7069    CMCHKPK(cmPkCtfDedSrsUlCfgInfo, &param->srsUlCfg, mBuf);
7070    CMCHKPK(cmPkCtfCqiReportCfgInfo, &param->cqiRptCfg, mBuf);
7071 #endif /* TFU_UPGRADE */
7072    CMCHKPK(cmPkCtfDedPuschCfgInfo, &param->puschCfg, mBuf);
7073    CMCHKPK(cmPkCtfDedPucchCfgInfo, &param->pucchCfg, mBuf);
7074    CMCHKPK(cmPkCtfDedPdschCfgInfo, &param->pdschCfg, mBuf);
7075    CMCHKPK(cmPkCtfUeCatCfgInfo, &param->ueCatCfg, mBuf);
7076    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
7077    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7078    RETVALUE(ROK);
7079 }
7080
7081
7082 \f
7083 /***********************************************************
7084 *
7085 *     Func: cmUnpkCtfDedCfgInfo
7086 *
7087 *
7088 *     Desc:   Dedicated Configuration Information
7089  * @details This structure contains the information for configuration
7090  *          of UE-specific physical channel resources at PHY.
7091 *
7092 *
7093 *     Ret: S16
7094 *
7095 *     Notes:
7096 *
7097 *     File:
7098 *
7099 **********************************************************/
7100 #ifdef ANSI
7101 PUBLIC S16 cmUnpkCtfDedCfgInfo
7102 (
7103 CtfDedCfgInfo *param,
7104 Buffer *mBuf
7105 )
7106 #else
7107 PUBLIC S16 cmUnpkCtfDedCfgInfo(param, mBuf)
7108 CtfDedCfgInfo *param;
7109 Buffer *mBuf;
7110 #endif
7111 {
7112
7113    TRC3(cmUnpkCtfDedCfgInfo)
7114
7115    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7116    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
7117    CMCHKUNPK(cmUnpkCtfUeCatCfgInfo, &param->ueCatCfg, mBuf);
7118    CMCHKUNPK(cmUnpkCtfDedPdschCfgInfo, &param->pdschCfg, mBuf);
7119    CMCHKUNPK(cmUnpkCtfDedPucchCfgInfo, &param->pucchCfg, mBuf);
7120    CMCHKUNPK(cmUnpkCtfDedPuschCfgInfo, &param->puschCfg, mBuf);
7121 #ifndef TFU_UPGRADE
7122    CMCHKUNPK(cmUnpkCtfCqiReportCfgInfo, &param->cqiRptCfg, mBuf);
7123    CMCHKUNPK(cmUnpkCtfDedSrsUlCfgInfo, &param->srsUlCfg, mBuf);
7124    CMCHKUNPK(cmUnpkCtfDedSRCfgInfo, &param->dedSRCfg, mBuf);
7125 #endif /* TFU_UPGRADE */
7126    CMCHKUNPK(cmUnpkCtfDedAntCfgInfo, &param->antInfo, mBuf);
7127 #ifdef EMTC_ENABLE
7128    CMCHKUNPK(SUnpkU8, &param->isEmtcUe, mBuf);
7129 #endif
7130    RETVALUE(ROK);
7131 }
7132
7133
7134 \f
7135 /***********************************************************
7136 *
7137 *     Func: cmPkCtfDedRecfgInfo
7138 *
7139 *
7140 *     Desc:   Dedicated Re-configuration Information
7141  * @details This structure contains the information for re-configuration
7142  *          of UE-specific physical channel resources at PHY.
7143 *
7144 *
7145 *     Ret: S16
7146 *
7147 *     Notes:
7148 *
7149 *     File:
7150 *
7151 **********************************************************/
7152 #ifdef ANSI
7153 PUBLIC S16 cmPkCtfDedRecfgInfo
7154 (
7155 CtfDedRecfgInfo *param,
7156 Buffer *mBuf
7157 )
7158 #else
7159 PUBLIC S16 cmPkCtfDedRecfgInfo(param, mBuf)
7160 CtfDedRecfgInfo *param;
7161 Buffer *mBuf;
7162 #endif
7163 {
7164
7165    TRC3(cmPkCtfDedRecfgInfo)
7166
7167    CMCHKPK(cmPkCtfSecCellCfgInfo, &param->sCellInfo,mBuf);
7168    /*ctf_c_001.main_1*/
7169    CMCHKPK(cmPkCtfDedAntCfgInfo, &param->antInfo, mBuf);
7170 #ifndef TFU_UPGRADE
7171    CMCHKPK(cmPkCtfCqiReportCfgInfo, &param->cqiRptCfg, mBuf);
7172    CMCHKPK(cmPkCtfDedSRCfgInfo, &param->dedSRCfg, mBuf);
7173    CMCHKPK(cmPkCtfDedSrsUlCfgInfo, &param->srsUlCfg, mBuf);
7174 #endif /* TFU_UPGRADE */
7175    CMCHKPK(cmPkCtfDedPuschCfgInfo, &param->puschCfg, mBuf);
7176    CMCHKPK(cmPkCtfDedPucchCfgInfo, &param->pucchCfg, mBuf);
7177    CMCHKPK(cmPkCtfDedPdschCfgInfo, &param->pdschCfg, mBuf);
7178    CMCHKPK(cmPkCtfUeCatCfgInfo, &param->ueCatCfg, mBuf);
7179    /* ctf_c_001.main_4: ReEst Fix */
7180 #ifdef CTF_VER3
7181    CMCHKPK(cmPkLteRnti, param->newUeId, mBuf);
7182 #else
7183    CMCHKPK(cmPkLteRnti, param->newUeId, mBuf);
7184 #endif
7185    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
7186    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7187    RETVALUE(ROK);
7188 }
7189
7190
7191 \f
7192 /***********************************************************
7193 *
7194 *     Func: cmUnpkCtfDedRecfgInfo
7195 *
7196 *
7197 *     Desc:   Dedicated Re-configuration Information
7198  * @details This structure contains the information for re-configuration
7199  *          of UE-specific physical channel resources at PHY.
7200 *
7201 *
7202 *     Ret: S16
7203 *
7204 *     Notes:
7205 *
7206 *     File:
7207 *
7208 **********************************************************/
7209 #ifdef ANSI
7210 PUBLIC S16 cmUnpkCtfDedRecfgInfo
7211 (
7212 CtfDedRecfgInfo *param,
7213 Buffer *mBuf
7214 )
7215 #else
7216 PUBLIC S16 cmUnpkCtfDedRecfgInfo(param, mBuf)
7217 CtfDedRecfgInfo *param;
7218 Buffer *mBuf;
7219 #endif
7220 {
7221
7222    TRC3(cmUnpkCtfDedRecfgInfo)
7223
7224    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7225    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
7226    /* ctf_c_001.main_4: ReEst Fix */
7227 #ifdef CTF_VER3
7228    CMCHKUNPK(cmUnpkLteRnti, &param->newUeId, mBuf);
7229 #else
7230    CMCHKUNPK(cmUnpkLteRnti, &param->newUeId, mBuf);
7231 #endif
7232    CMCHKUNPK(cmUnpkCtfUeCatCfgInfo, &param->ueCatCfg, mBuf);
7233    CMCHKUNPK(cmUnpkCtfDedPdschCfgInfo, &param->pdschCfg, mBuf);
7234    CMCHKUNPK(cmUnpkCtfDedPucchCfgInfo, &param->pucchCfg, mBuf);
7235    CMCHKUNPK(cmUnpkCtfDedPuschCfgInfo, &param->puschCfg, mBuf);
7236 #ifndef TFU_UPGRADE
7237    CMCHKUNPK(cmUnpkCtfDedSrsUlCfgInfo, &param->srsUlCfg, mBuf);
7238    CMCHKUNPK(cmUnpkCtfDedSRCfgInfo, &param->dedSRCfg, mBuf);
7239    /*ctf_c_001.main_1*/
7240    CMCHKUNPK(cmUnpkCtfCqiReportCfgInfo, &param->cqiRptCfg, mBuf);
7241 #endif /* TFU_UPGRADE */
7242    CMCHKUNPK(cmUnpkCtfDedAntCfgInfo, &param->antInfo, mBuf);
7243
7244    CMCHKUNPK(cmUnpkCtfSecCellCfgInfo, &param->sCellInfo,mBuf);
7245
7246    RETVALUE(ROK);
7247 }
7248
7249
7250 \f
7251 /***********************************************************
7252 *
7253 *     Func: cmPkCtfCellReleaseInfo
7254 *
7255 *
7256 *     Desc:   Cell Release Information
7257  * @details This structure contains the information for release/removal
7258  *          of a cell and its assocated resources at PHY.
7259 *
7260 *
7261 *     Ret: S16
7262 *
7263 *     Notes:
7264 *
7265 *     File:
7266 *
7267 **********************************************************/
7268 #ifdef ANSI
7269 PUBLIC S16 cmPkCtfCellReleaseInfo
7270 (
7271 CtfCellReleaseInfo *param,
7272 Buffer *mBuf
7273 )
7274 #else
7275 PUBLIC S16 cmPkCtfCellReleaseInfo(param, mBuf)
7276 CtfCellReleaseInfo *param;
7277 Buffer *mBuf;
7278 #endif
7279 {
7280
7281    TRC3(cmPkCtfCellReleaseInfo)
7282
7283    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7284    RETVALUE(ROK);
7285 }
7286
7287
7288 \f
7289 /***********************************************************
7290 *
7291 *     Func: cmUnpkCtfCellReleaseInfo
7292 *
7293 *
7294 *     Desc:   Cell Release Information
7295  * @details This structure contains the information for release/removal
7296  *          of a cell and its assocated resources at PHY.
7297 *
7298 *
7299 *     Ret: S16
7300 *
7301 *     Notes:
7302 *
7303 *     File:
7304 *
7305 **********************************************************/
7306 #ifdef ANSI
7307 PUBLIC S16 cmUnpkCtfCellReleaseInfo
7308 (
7309 CtfCellReleaseInfo *param,
7310 Buffer *mBuf
7311 )
7312 #else
7313 PUBLIC S16 cmUnpkCtfCellReleaseInfo(param, mBuf)
7314 CtfCellReleaseInfo *param;
7315 Buffer *mBuf;
7316 #endif
7317 {
7318
7319    TRC3(cmUnpkCtfCellReleaseInfo)
7320
7321    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7322    RETVALUE(ROK);
7323 }
7324
7325
7326 \f
7327 /***********************************************************
7328 *
7329 *     Func: cmPkCtfDedReleaseInfo
7330 *
7331 *
7332 *     Desc:   Dedicated Release Information
7333  * @details This structure contains the information for release/removal
7334  *          of dedicated/UE-specific configuration at PHY.
7335 *
7336 *
7337 *     Ret: S16
7338 *
7339 *     Notes:
7340 *
7341 *     File:
7342 *
7343 **********************************************************/
7344 #ifdef ANSI
7345 PUBLIC S16 cmPkCtfDedReleaseInfo
7346 (
7347 CtfDedReleaseInfo *param,
7348 Buffer *mBuf
7349 )
7350 #else
7351 PUBLIC S16 cmPkCtfDedReleaseInfo(param, mBuf)
7352 CtfDedReleaseInfo *param;
7353 Buffer *mBuf;
7354 #endif
7355 {
7356
7357    TRC3(cmPkCtfDedReleaseInfo)
7358    CMCHKPK(cmPkCtfSecCellCfgInfo, &param->sCellInfo,mBuf);
7359    CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
7360    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7361    RETVALUE(ROK);
7362 }
7363
7364
7365 \f
7366 /***********************************************************
7367 *
7368 *     Func: cmUnpkCtfDedReleaseInfo
7369 *
7370 *
7371 *     Desc:   Dedicated Release Information
7372  * @details This structure contains the information for release/removal
7373  *          of dedicated/UE-specific configuration at PHY.
7374 *
7375 *
7376 *     Ret: S16
7377 *
7378 *     Notes:
7379 *
7380 *     File:
7381 *
7382 **********************************************************/
7383 #ifdef ANSI
7384 PUBLIC S16 cmUnpkCtfDedReleaseInfo
7385 (
7386 CtfDedReleaseInfo *param,
7387 Buffer *mBuf
7388 )
7389 #else
7390 PUBLIC S16 cmUnpkCtfDedReleaseInfo(param, mBuf)
7391 CtfDedReleaseInfo *param;
7392 Buffer *mBuf;
7393 #endif
7394 {
7395
7396    TRC3(cmUnpkCtfDedReleaseInfo)
7397
7398    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7399    CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
7400    CMCHKUNPK(cmUnpkCtfSecCellCfgInfo, &param->sCellInfo,mBuf);
7401    RETVALUE(ROK);
7402 }
7403
7404
7405 \f
7406 /***********************************************************
7407 *
7408 *     Func: cmPkCtfCfgInfo
7409 *
7410 *
7411 *     Desc:   Configuration Information
7412  * @details This structure contains the information for setting-up
7413  *          cell or UE-specific configuration at PHY.
7414 *
7415 *
7416 *     Ret: S16
7417 *
7418 *     Notes:
7419 *
7420 *     File:
7421 *
7422 **********************************************************/
7423 #ifdef ANSI
7424 PUBLIC S16 cmPkCtfCfgInfo
7425 (
7426 CtfCfgInfo *param,
7427 Buffer *mBuf
7428 )
7429 #else
7430 PUBLIC S16 cmPkCtfCfgInfo(param, mBuf)
7431 CtfCfgInfo *param;
7432 Buffer *mBuf;
7433 #endif
7434 {
7435
7436    TRC3(cmPkCtfCfgInfo)
7437
7438       switch(param->cfgElem) {
7439          case CTF_UE_CFG:
7440             CMCHKPK(cmPkCtfDedCfgInfo, &param->u.dedCfg, mBuf);
7441             break;
7442          case CTF_CELL_CFG:
7443             CMCHKPK(cmPkCtfCellCfgInfo, &param->u.cellCfg, mBuf);
7444             break;
7445          default :
7446             RETVALUE(RFAILED);
7447       }
7448    CMCHKPK(SPkU8, param->cfgElem, mBuf);
7449    RETVALUE(ROK);
7450 }
7451
7452
7453 \f
7454 /***********************************************************
7455 *
7456 *     Func: cmUnpkCtfCfgInfo
7457 *
7458 *
7459 *     Desc:   Configuration Information
7460  * @details This structure contains the information for setting-up
7461  *          cell or UE-specific configuration at PHY.
7462 *
7463 *
7464 *     Ret: S16
7465 *
7466 *     Notes:
7467 *
7468 *     File:
7469 *
7470 **********************************************************/
7471 #ifdef ANSI
7472 PUBLIC S16 cmUnpkCtfCfgInfo
7473 (
7474 CtfCfgInfo *param,
7475 Buffer *mBuf
7476 )
7477 #else
7478 PUBLIC S16 cmUnpkCtfCfgInfo(param, mBuf)
7479 CtfCfgInfo *param;
7480 Buffer *mBuf;
7481 #endif
7482 {
7483
7484    TRC3(cmUnpkCtfCfgInfo)
7485
7486    CMCHKUNPK(SUnpkU8, &param->cfgElem, mBuf);
7487       switch(param->cfgElem) {
7488          case CTF_CELL_CFG:
7489             CMCHKUNPK(cmUnpkCtfCellCfgInfo, &param->u.cellCfg, mBuf);
7490             break;
7491          case CTF_UE_CFG:
7492             CMCHKUNPK(cmUnpkCtfDedCfgInfo, &param->u.dedCfg, mBuf);
7493             break;
7494          default :
7495             RETVALUE(RFAILED);
7496       }
7497    RETVALUE(ROK);
7498 }
7499
7500
7501 \f
7502 /***********************************************************
7503 *
7504 *     Func: cmPkCtfReCfgInfo
7505 *
7506 *
7507 *     Desc:   Re-configuration Information
7508  * @details This structure contains the information for re-configuring
7509  *          cell or UE-specific configuration at PHY.
7510 *
7511 *
7512 *     Ret: S16
7513 *
7514 *     Notes:
7515 *
7516 *     File:
7517 *
7518 **********************************************************/
7519 #ifdef ANSI
7520 PUBLIC S16 cmPkCtfReCfgInfo
7521 (
7522 CtfReCfgInfo *param,
7523 Buffer *mBuf
7524 )
7525 #else
7526 PUBLIC S16 cmPkCtfReCfgInfo(param, mBuf)
7527 CtfReCfgInfo *param;
7528 Buffer *mBuf;
7529 #endif
7530 {
7531
7532    TRC3(cmPkCtfReCfgInfo)
7533
7534       switch(param->cfgElem) {
7535          case CTF_UE_CFG:
7536             CMCHKPK(cmPkCtfDedRecfgInfo, &param->u.dedRecfg, mBuf);
7537             break;
7538          case CTF_CELL_CFG:
7539             CMCHKPK(cmPkCtfCellRecfgInfo, &param->u.cellRecfg, mBuf);
7540             break;
7541          /* Starts - Fix for CR ccpu00123185 */
7542          case CTF_TX_PWR_CFG:
7543             CMCHKPK(cmPkCtfCellPwrcfgInfo, &param->u.cellRecfg, mBuf);
7544             break;
7545          /* ends - Fix for CR ccpu00123185 */
7546          case CTF_CELL_STOP:
7547             CMCHKPK(cmPkCtfCellStop, &param->u.cellRecfg, mBuf);
7548             break;
7549
7550          default :
7551             RETVALUE(RFAILED);
7552       }
7553    CMCHKPK(SPkU8, param->cfgElem, mBuf);
7554    RETVALUE(ROK);
7555 }
7556
7557
7558 \f
7559 /***********************************************************
7560 *
7561 *     Func: cmUnpkCtfReCfgInfo
7562 *
7563 *
7564 *     Desc:   Re-configuration Information
7565  * @details This structure contains the information for re-configuring
7566  *          cell or UE-specific configuration at PHY.
7567 *
7568 *
7569 *     Ret: S16
7570 *
7571 *     Notes:
7572 *
7573 *     File:
7574 *
7575 **********************************************************/
7576 #ifdef ANSI
7577 PUBLIC S16 cmUnpkCtfReCfgInfo
7578 (
7579 CtfReCfgInfo *param,
7580 Buffer *mBuf
7581 )
7582 #else
7583 PUBLIC S16 cmUnpkCtfReCfgInfo(param, mBuf)
7584 CtfReCfgInfo *param;
7585 Buffer *mBuf;
7586 #endif
7587 {
7588
7589    TRC3(cmUnpkCtfReCfgInfo)
7590
7591    CMCHKUNPK(SUnpkU8, &param->cfgElem, mBuf);
7592       switch(param->cfgElem) {
7593          case CTF_CELL_CFG:
7594             CMCHKUNPK(cmUnpkCtfCellRecfgInfo, &param->u.cellRecfg, mBuf);
7595             break;
7596          case CTF_UE_CFG:
7597             CMCHKUNPK(cmUnpkCtfDedRecfgInfo, &param->u.dedRecfg, mBuf);
7598             break;
7599          /* Starts - Fix for CR ccpu00123185 */
7600          case CTF_TX_PWR_CFG:
7601             CMCHKUNPK(cmUnpkCtfCellPwrcfgInfo, &param->u.cellRecfg, mBuf);
7602             break;
7603          /* ends - Fix for CR ccpu00123185 */
7604          case CTF_CELL_STOP:
7605             CMCHKUNPK(cmUnpkCtfCellStop, &param->u.cellRecfg, mBuf);
7606             break;
7607          default :
7608             RETVALUE(RFAILED);
7609       }
7610    RETVALUE(ROK);
7611 }
7612
7613
7614 \f
7615 /***********************************************************
7616 *
7617 *     Func: cmPkCtfReleaseInfo
7618 *
7619 *
7620 *     Desc:   Release configuration Information
7621  * @details This structure contains the information for releasing
7622  *          cell or UE-specific configuration at PHY.
7623 *
7624 *
7625 *     Ret: S16
7626 *
7627 *     Notes:
7628 *
7629 *     File:
7630 *
7631 **********************************************************/
7632 #ifdef ANSI
7633 PUBLIC S16 cmPkCtfReleaseInfo
7634 (
7635 CtfReleaseInfo *param,
7636 Buffer *mBuf
7637 )
7638 #else
7639 PUBLIC S16 cmPkCtfReleaseInfo(param, mBuf)
7640 CtfReleaseInfo *param;
7641 Buffer *mBuf;
7642 #endif
7643 {
7644
7645    TRC3(cmPkCtfReleaseInfo)
7646
7647       switch(param->cfgElem) {
7648          case CTF_UE_CFG:
7649             CMCHKPK(cmPkCtfDedReleaseInfo, &param->u.dedRel, mBuf);
7650             break;
7651          case CTF_CELL_CFG:
7652             CMCHKPK(cmPkCtfCellReleaseInfo, &param->u.cellRel, mBuf);
7653             break;
7654          default :
7655             RETVALUE(RFAILED);
7656       }
7657    CMCHKPK(SPkU8, param->cfgElem, mBuf);
7658    RETVALUE(ROK);
7659 }
7660
7661
7662 \f
7663 /***********************************************************
7664 *
7665 *     Func: cmUnpkCtfReleaseInfo
7666 *
7667 *
7668 *     Desc:   Release configuration Information
7669  * @details This structure contains the information for releasing
7670  *          cell or UE-specific configuration at PHY.
7671 *
7672 *
7673 *     Ret: S16
7674 *
7675 *     Notes:
7676 *
7677 *     File:
7678 *
7679 **********************************************************/
7680 #ifdef ANSI
7681 PUBLIC S16 cmUnpkCtfReleaseInfo
7682 (
7683 CtfReleaseInfo *param,
7684 Buffer *mBuf
7685 )
7686 #else
7687 PUBLIC S16 cmUnpkCtfReleaseInfo(param, mBuf)
7688 CtfReleaseInfo *param;
7689 Buffer *mBuf;
7690 #endif
7691 {
7692
7693    TRC3(cmUnpkCtfReleaseInfo)
7694
7695    CMCHKUNPK(SUnpkU8, &param->cfgElem, mBuf);
7696       switch(param->cfgElem) {
7697          case CTF_CELL_CFG:
7698             CMCHKUNPK(cmUnpkCtfCellReleaseInfo, &param->u.cellRel, mBuf);
7699             break;
7700          case CTF_UE_CFG:
7701             CMCHKUNPK(cmUnpkCtfDedReleaseInfo, &param->u.dedRel, mBuf);
7702             break;
7703          default :
7704             RETVALUE(RFAILED);
7705       }
7706    RETVALUE(ROK);
7707 }
7708
7709
7710 \f
7711 /***********************************************************
7712 *
7713 *     Func: cmPkCtfCfgReqInfo
7714 *
7715 *
7716 *     Desc:   Configuration Request information
7717  * @details This is the main structure in the Configuration request primitive.
7718  *    -# This structure contains the configuration information as given by
7719  *       the RRC to configure PHY layer for common/dedicated resources.
7720  *    -# It can contain Config/Reconfig/Release.
7721  *    -# The result of configuration is indicated in TfUiCtfCfgCfm.
7722 *
7723 *
7724 *     Ret: S16
7725 *
7726 *     Notes:
7727 *
7728 *     File:
7729 *
7730 **********************************************************/
7731 #ifdef ANSI
7732 PUBLIC S16 cmPkCtfCfgReqInfo
7733 (
7734 CtfCfgReqInfo *param,
7735 Buffer *mBuf
7736 )
7737 #else
7738 PUBLIC S16 cmPkCtfCfgReqInfo(param, mBuf)
7739 CtfCfgReqInfo *param;
7740 Buffer *mBuf;
7741 #endif
7742 {
7743
7744    TRC3(cmPkCtfCfgReqInfo)
7745
7746    /* ctf_c_001.main_4: Added support for vendor specific parameters */
7747 #ifdef CTF_VER3
7748    CMCHKPK(cmPkCtfVendorSpecParams, &param->vendorParams, mBuf);
7749 #endif
7750       switch(param->cfgType) {
7751          case CTF_DELETE:
7752             CMCHKPK(cmPkCtfReleaseInfo, &param->u.release, mBuf);
7753             break;
7754          case CTF_RECONFIG:
7755             CMCHKPK(cmPkCtfReCfgInfo, &param->u.reCfg, mBuf);
7756             break;
7757          case CTF_CONFIG:
7758             CMCHKPK(cmPkCtfCfgInfo, &param->u.cfg, mBuf);
7759             break;
7760          default :
7761             RETVALUE(RFAILED);
7762       }
7763    CMCHKPK(SPkU8, param->cfgType, mBuf);
7764    RETVALUE(ROK);
7765 }
7766
7767
7768 \f
7769    /* ctf_c_001.main_4: Modified cmUnpkCtfCfgReqInfo() to add support
7770     * for vendor specific parameters */
7771 /***********************************************************
7772 *
7773 *     Func: cmUnpkCtfCfgReqInfo
7774 *
7775 *
7776 *     Desc:   Configuration Request information
7777  * @details This is the main structure in the Configuration request primitive.
7778  *    -# This structure contains the configuration information as given by
7779  *       the RRC to configure PHY layer for common/dedicated resources.
7780  *    -# It can contain Config/Reconfig/Release.
7781  *    -# The result of configuration is indicated in TfUiCtfCfgCfm.
7782 *
7783 *
7784 *     Ret: S16
7785 *
7786 *     Notes:
7787 *
7788 *     File:
7789 *
7790 **********************************************************/
7791 #ifdef ANSI
7792 PUBLIC S16 cmUnpkCtfCfgReqInfo
7793 (
7794 Pst  *pst,
7795 CtfCfgReqInfo *param,
7796 Buffer *mBuf
7797 )
7798 #else
7799 PUBLIC S16 cmUnpkCtfCfgReqInfo(param, mBuf)
7800 Pst  *pst;
7801 CtfCfgReqInfo *param;
7802 Buffer *mBuf;
7803 #endif
7804 {
7805
7806 #ifdef CTF_VER3
7807    S16 retVal;
7808 #endif
7809
7810    TRC3(cmUnpkCtfCfgReqInfo)
7811
7812    CMCHKUNPK(SUnpkU8, &param->cfgType, mBuf);
7813       switch(param->cfgType) {
7814          case CTF_CONFIG:
7815             CMCHKUNPK(cmUnpkCtfCfgInfo, &param->u.cfg, mBuf);
7816             break;
7817          case CTF_RECONFIG:
7818             CMCHKUNPK(cmUnpkCtfReCfgInfo, &param->u.reCfg, mBuf);
7819             break;
7820          case CTF_DELETE:
7821             CMCHKUNPK(cmUnpkCtfReleaseInfo, &param->u.release, mBuf);
7822             break;
7823          default :
7824             RETVALUE(RFAILED);
7825       }
7826 #ifdef CTF_VER3
7827     if((retVal = cmUnpkCtfVendorSpecParams(pst, &param->vendorParams, mBuf)) != ROK)
7828         RETVALUE(retVal);
7829 #endif
7830    RETVALUE(ROK);
7831 }
7832
7833          /* Starts - Fix for CR ccpu00123185 */
7834 /***********************************************************
7835 *
7836 *     Func: cmPkCtfCellPwrcfgInfo
7837 *
7838 *
7839 *     Desc:   Cell Re-configuration Information
7840  * @details This structure contains the information for reconfiguration of Reference Signal Power
7841  *          of a cell and its associated resources at PHY.
7842 *
7843 *
7844 *     Ret: S16
7845 *
7846 *     Notes:
7847 *
7848 *     File:
7849 *
7850 **********************************************************/
7851 #ifdef ANSI
7852 PUBLIC S16 cmPkCtfCellPwrcfgInfo
7853 (
7854 CtfCellRecfgInfo *param,
7855 Buffer *mBuf
7856 )
7857 #else
7858 PUBLIC S16 cmPkCtfCellPwrcfgInfo(param, mBuf)
7859 CtfCellRecfgInfo *param;
7860 Buffer *mBuf;
7861 #endif
7862 {
7863
7864    TRC3(cmPkCtfCellPwrcfgInfo)
7865
7866    /* Added the pack for newly added reference signal Power*/
7867    CMCHKPK(SPkU32, (U32)param->ctfCellStatus, mBuf);
7868    CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
7869    CMCHKPK(SPkS16, param->priSigPwr, mBuf);
7870    CMCHKPK(SPkS16, param->secSigPwr, mBuf);
7871
7872    CMCHKPK(SPkS16, param->pdschCfg.refSigPwr, mBuf);
7873    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7874    RETVALUE(ROK);
7875 }
7876
7877
7878 \f
7879 /***********************************************************
7880 *
7881 *     Func: cmUnpkCtfCellPwrcfgInfo
7882 *
7883 *
7884 *     Desc:   Cell Re-configuration Information
7885  * @details This structure contains the information for reconfiguration
7886  *          of a cell and its associated resources at PHY.
7887 *
7888 *
7889 *     Ret: S16
7890 *
7891 *     Notes:
7892 *
7893 *     File:
7894 *
7895 **********************************************************/
7896 #ifdef ANSI
7897 PUBLIC S16 cmUnpkCtfCellPwrcfgInfo
7898 (
7899 CtfCellRecfgInfo *param,
7900 Buffer *mBuf
7901 )
7902 #else
7903 PUBLIC S16 cmUnpkCtfCellPwrcfgInfo(param, mBuf)
7904 CtfCellRecfgInfo *param;
7905 Buffer *mBuf;
7906 #endif
7907 {
7908
7909    TRC3(cmUnpkCtfCellPwrcfgInfo)
7910
7911    /* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
7912    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7913
7914    CMCHKUNPK(SUnpkS16, &param->pdschCfg.refSigPwr, mBuf);
7915    CMCHKUNPK(SUnpkS16, &param->secSigPwr, mBuf);
7916    CMCHKUNPK(SUnpkS16, &param->priSigPwr, mBuf);
7917    CMCHKUNPK(SUnpkS16, &param->pilotSigPwr, mBuf);
7918    CMCHKUNPK(SUnpkU32, (U32 *)&param->ctfCellStatus, mBuf);
7919
7920    RETVALUE(ROK);
7921 }
7922
7923 /***********************************************************
7924 *
7925 *     Func: cmPkCtfCellStop
7926 *
7927 *
7928 *     Desc:   Cell Re-configuration Information
7929  * @details This structure contains the information for reconfiguration of Reference Signal Power
7930  *          of a cell and its associated resources at PHY.
7931 *
7932 *
7933 *     Ret: S16
7934 *
7935 *     Notes:
7936 *
7937 *     File:
7938 *
7939 **********************************************************/
7940 #ifdef ANSI
7941 PUBLIC S16 cmPkCtfCellStop
7942 (
7943 CtfCellRecfgInfo *param,
7944 Buffer *mBuf
7945 )
7946 #else
7947 PUBLIC S16 cmPkCtfCellStop(param, mBuf)
7948 CtfCellRecfgInfo *param;
7949 Buffer *mBuf;
7950 #endif
7951 {
7952
7953    TRC3(cmPkCtfCellStop)
7954
7955    /* Added the pack for newly added reference signal Power*/
7956    CMCHKPK(SPkU32, (U32)param->ctfCellStatus, mBuf);
7957    CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
7958    CMCHKPK(SPkS16, param->priSigPwr, mBuf);
7959    CMCHKPK(SPkS16, param->secSigPwr, mBuf);
7960
7961    CMCHKPK(SPkS16, param->pdschCfg.refSigPwr, mBuf);
7962    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7963    RETVALUE(ROK);
7964 }
7965
7966 /***********************************************************
7967 *
7968 *     Func: cmUnpkCtfCellStop
7969 *
7970 *
7971 *     Desc:   Cell Re-configuration Information
7972  * @details This structure contains the information for reconfiguration
7973  *          of a cell and its associated resources at PHY.
7974 *
7975 *
7976 *     Ret: S16
7977 *
7978 *     Notes:
7979 *
7980 *     File:
7981 *
7982 **********************************************************/
7983 #ifdef ANSI
7984 PUBLIC S16 cmUnpkCtfCellStop
7985 (
7986 CtfCellRecfgInfo *param,
7987 Buffer *mBuf
7988 )
7989 #else
7990 PUBLIC S16 cmUnpkCtfCellStop(param, mBuf)
7991 CtfCellRecfgInfo *param;
7992 Buffer *mBuf;
7993 #endif
7994 {
7995
7996    TRC3(cmUnpkCtfCellStop)
7997
7998    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7999
8000    CMCHKUNPK(SUnpkS16, &param->pdschCfg.refSigPwr, mBuf);
8001    CMCHKUNPK(SUnpkS16, &param->secSigPwr, mBuf);
8002    CMCHKUNPK(SUnpkS16, &param->priSigPwr, mBuf);
8003    CMCHKUNPK(SUnpkS16, &param->pilotSigPwr, mBuf);
8004    CMCHKUNPK(SUnpkU32, (U32 *)&param->ctfCellStatus, mBuf);
8005
8006    RETVALUE(ROK);
8007 }
8008
8009 /* Periodic REM Scan for TPM */
8010 /***********************************************************
8011 *
8012 *     Func: cmPkPerRemScanCellInfo
8013 *
8014 *
8015 *     Desc: Periodic REM cell search response
8016 *     @details This Message contains cell search results.
8017 *
8018 *
8019 *     Ret: S16
8020 *
8021 *     Notes:
8022 *
8023 *     File:
8024 *
8025 **********************************************************/
8026 #ifdef ANSI
8027 PUBLIC S16 cmPkPerRemScanCellInfo
8028 (
8029 CtfPeriodicRemCellInfo *param,
8030 Buffer *mBuf
8031 )
8032 #else
8033 PUBLIC S16 cmPkPerRemScanCellInfo(param, mBuf)
8034 CtfPeriodicRemCellInfo *param;
8035 Buffer *mBuf;
8036 #endif
8037 {
8038    TRC3(cmPkPerRemScanCellInfo)
8039
8040    CMCHKPK(SPkU16,param->pci, mBuf);
8041    CMCHKPK(SPkU8, param->rsrp, mBuf);
8042    CMCHKPK(SPkU8, param->dlBw, mBuf);
8043    CMCHKPK(SPkU8, param->numTx, mBuf);
8044    RETVALUE(ROK);
8045 }
8046
8047
8048 /***********************************************************
8049 *
8050 *     Func: cmPkCtfPeriodicCellSearchRsp
8051 *
8052 *
8053 *     Desc: Periodic REM cell search response
8054 *     @details This Message contains Periodic REM scan results.
8055 *
8056 *
8057 *     Ret: S16
8058 *
8059 *     Notes:
8060 *
8061 *     File:
8062 *
8063 **********************************************************/
8064 #ifdef ANSI
8065 PUBLIC S16 cmPkCtfPeriodicCellSearchRsp
8066 (
8067 CtfPeriodicRemCellSearchRsp *param,
8068 Buffer *mBuf
8069 )
8070 #else
8071 PUBLIC S16 cmPkCtfPeriodicCellSearchRsp(param, mBuf)
8072 CtfPeriodicRemCellSearchRsp *param;
8073 Buffer *mBuf;
8074 #endif
8075 {
8076    S16 idx;
8077    TRC3(cmPkCtfPeriodicCellSearchRsp)
8078
8079    for(idx = param->numCells - 1; idx >=0; idx--)
8080    {
8081       CMCHKPK(cmPkPerRemScanCellInfo, &param->cellInfo[idx], mBuf);
8082    }
8083    CMCHKPK(SPkU8, param->numCells, mBuf);
8084
8085    RETVALUE(ROK);
8086 }
8087
8088 /**
8089 * @brief Configuration Request from App to CL for
8090  * cnm Init Sync responce
8091 *
8092 * @details
8093 *
8094 *     Function: cmPkCtfPeriodicRemCellSearchRsp
8095 *
8096 *  @param[in]   Pst*  pst
8097 *  @param[in]   SpId  spId
8098 *  @param[in]   CtfCfgTransId  * transId
8099 *  @param[in]   CtfCnmInitSyncRsp* ctfcnmInitSyncRsp
8100 *  @return   S16
8101 *      -# ROK
8102 **/
8103 #ifdef ANSI
8104 PUBLIC S16 cmPkCtfPeriodicRemCellSearchRsp
8105 (
8106 Pst* pst,
8107 SpId spId,
8108 CtfCfgTransId *transId,
8109 CtfPeriodicRemCellSearchRsp *CellCfgRsp
8110 )
8111 #else
8112 PUBLIC S16 cmPkCtfPeriodicRemCellSearchRsp(pst, spId, transId, CellCfgRsp)
8113 Pst* pst;
8114 SpId spId;
8115 CtfCfgTransId *transId;
8116 CtfPeriodicRemCellSearchRsp *CellCfgRsp;
8117 #endif
8118 {
8119    Buffer *mBuf = NULLP;
8120    TRC3(cmPkCtfPeriodicRemCellSearchRsp)
8121
8122    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
8123 #if (ERRCLASS & ERRCLS_ADD_RES)
8124       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8125       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8126          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8127          (ErrVal)ECTF016, (ErrVal)0, (Txt*)&"Packing failed");
8128 #endif
8129       SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
8130             sizeof(CtfPeriodicRemCellSearchRsp));
8131       RETVALUE(RFAILED);
8132    }
8133    if (pst->selector == CTF_SEL_LC) {
8134       if (cmPkCtfPeriodicCellSearchRsp(CellCfgRsp, mBuf) != ROK) {
8135 #if (ERRCLASS & ERRCLS_ADD_RES)
8136       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8137          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8138             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8139             (ErrVal)ECTF017, (ErrVal)0, (Txt*)&"Packing failed");
8140 #endif
8141          SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
8142                sizeof(CtfPeriodicRemCellSearchRsp));
8143          SPutMsg(mBuf);
8144          RETVALUE(RFAILED);
8145       }
8146    }
8147    else if (pst->selector == CTF_SEL_LWLC) {
8148
8149    if (cmPkPtr((PTR)CellCfgRsp, mBuf) != ROK) {
8150 #if (ERRCLASS & ERRCLS_ADD_RES)
8151       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8152          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8153             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8154             (ErrVal)ECTF018, (ErrVal)0, "Packing failed");
8155 #endif
8156          SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
8157                sizeof(CtfPeriodicRemCellSearchRsp));
8158          SPutMsg(mBuf);
8159          RETVALUE(RFAILED);
8160       }
8161
8162    }
8163  if(cmPkCtfCfgTransId(transId, mBuf) != ROK) {
8164 #if (ERRCLASS & ERRCLS_ADD_RES)
8165       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8166       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8167          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8168          (ErrVal)ECTF019, (ErrVal)0, "Packing failed");
8169 #endif
8170       SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
8171             sizeof(CtfPeriodicRemCellSearchRsp));
8172       SPutMsg(mBuf);
8173       RETVALUE(RFAILED);
8174    }
8175  if (SPkS16(spId, mBuf) != ROK) {
8176 #if (ERRCLASS & ERRCLS_ADD_RES)
8177       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8178       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8179          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8180          (ErrVal)ECTF020, (ErrVal)0, "Packing failed");
8181 #endif
8182       SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
8183             sizeof(CtfPeriodicRemCellSearchRsp));
8184       SPutMsg(mBuf);
8185       RETVALUE(RFAILED);
8186    }
8187    if (pst->selector != CTF_SEL_LWLC) {
8188       SPutSBuf(pst->region, pst->pool, (Data *)CellCfgRsp,
8189             sizeof(CtfPeriodicRemCellSearchRsp));
8190    }
8191    pst->event = (Event)EVTCTFPREMCELLSRCHRSP;
8192    RETVALUE(SPstTsk(pst,mBuf));
8193 }
8194
8195 #ifdef ANSI
8196 PUBLIC S16 cmUnpkCtfPerRemScanCellInfo
8197 (
8198 CtfPeriodicRemCellInfo *param,
8199 Buffer *mBuf
8200 )
8201 #else
8202 PUBLIC S16 cmUnpkCtfPerRemScanCellInfo(param, mBuf)
8203 CtfPeriodicRemCellInfo *param;
8204 Buffer *mBuf;
8205 #endif
8206 {
8207    TRC3(cmUnpkCtfPerRemScanCellInfo);
8208
8209    CMCHKUNPK(SUnpkU8, &param->numTx, mBuf);
8210    CMCHKUNPK(SUnpkU8, &param->dlBw, mBuf);
8211    CMCHKUNPK(SUnpkU8, &param->rsrp, mBuf);
8212    CMCHKUNPK(SUnpkU16, &param->pci, mBuf);
8213    RETVALUE(ROK);
8214 }
8215
8216 #ifdef ANSI
8217 PUBLIC S16 cmUnpkCtfPerRemCellSrch
8218 (
8219 CtfPeriodicRemCellSearchRsp *param,
8220 Buffer *mBuf
8221 )
8222 #else
8223 PUBLIC S16 cmUnpkCtfPerRemCellSrch(param, mBuf)
8224 CtfPeriodicRemCellSearchRsp *param;
8225 Buffer *mBuf;
8226 #endif
8227 {
8228    S16 idx;
8229    TRC3(cmUnpkCtfPerRemCellSrch);
8230
8231    CMCHKUNPK(SUnpkU8, &param->numCells, mBuf);
8232    for(idx = 0; idx < (param->numCells); idx++)
8233    {
8234       CMCHKUNPK(cmUnpkCtfPerRemScanCellInfo, &param->cellInfo[idx], mBuf);
8235    }
8236
8237    RETVALUE(ROK);
8238 }
8239
8240 /**
8241 * @brief ENB STOP Indication from PHY to ENB-APP
8242 *
8243 * @details
8244 *
8245 *     Function: cmUnpkPerRemCellSrchRsp
8246 *
8247 *  @param[in]   Pst*  pst
8248 *  @param[in]   SuId  suId
8249 *  @param[in]   CtfCfgTransId  transId
8250 *  @return   S16
8251 *      -# ROK
8252 **/
8253 #ifdef ANSI
8254 PUBLIC S16 cmUnpkPerRemCellSrchRsp
8255 (
8256 CtfPerRemCellSrchRsp func,
8257 Pst *pst,
8258 Buffer *mBuf
8259 )
8260 #else
8261 PUBLIC S16 cmUnpkPerRemCellSrchRsp(func, pst, mBuf)
8262 CtfPerRemCellSrchRsp func;
8263 Pst *pst;
8264 Buffer *mBuf;
8265 #endif
8266 {
8267    SuId suId = 0;
8268    CtfCfgTransId transId;
8269    CtfPeriodicRemCellSearchRsp *CellSrchRsp = NULLP;
8270    TRC3(cmUnpkPerRemCellSrchRsp)
8271
8272    if (SUnpkS16(&suId, mBuf) != ROK) {
8273       SPutMsg(mBuf);
8274 #if (ERRCLASS & ERRCLS_ADD_RES)
8275       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8276       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8277          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8278          (ErrVal)ECTF030, (ErrVal)0, (Txt*)&"Packing failed");
8279 #endif
8280       RETVALUE(RFAILED);
8281    }
8282    if (cmUnpkCtfCfgTransId(&transId, mBuf) != ROK) {
8283       SPutMsg(mBuf);
8284 #if (ERRCLASS & ERRCLS_ADD_RES)
8285       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8286       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8287          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8288          (ErrVal)ECTF031, (ErrVal)0, (Txt*)&"Packing failed");
8289 #endif
8290       RETVALUE(RFAILED);
8291    }
8292    if (pst->selector != CTF_SEL_LWLC) {
8293       if ((SGetSBuf(pst->region, pst->pool, (Data **)&CellSrchRsp,
8294                   sizeof(CtfPeriodicRemCellSearchRsp))) != ROK) {
8295 #if (ERRCLASS & ERRCLS_ADD_RES)
8296       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8297          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8298             (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8299             (ErrVal)ECTF024, (ErrVal)0, (Txt*)&"Packing failed");
8300 #endif
8301          SPutMsg(mBuf);
8302          RETVALUE(RFAILED);
8303       }
8304    }
8305    if (pst->selector == CTF_SEL_LWLC) {
8306       if (cmUnpkPtr((PTR *)&CellSrchRsp, mBuf) != ROK) {
8307          SPutMsg(mBuf);
8308          RETVALUE(RFAILED);
8309       }
8310    }
8311   else if (pst->selector == CTF_SEL_LC)
8312       if (cmUnpkCtfPerRemCellSrch(CellSrchRsp, mBuf) != ROK) {
8313       SPutSBuf(pst->region, pst->pool, (Data *)CellSrchRsp,
8314             sizeof(CtfPeriodicRemCellSearchRsp));
8315       SPutMsg(mBuf);
8316 #if (ERRCLASS & ERRCLS_ADD_RES)
8317       /* ctf_c_001.main_3 Compilation warning fix with g++ */
8318       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8319          (Txt*)&__FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8320          (ErrVal)ECTF025, (ErrVal)0, (Txt*)&"Packing failed");
8321 #endif
8322       RETVALUE(RFAILED);
8323    }
8324
8325    SPutMsg(mBuf);
8326    RETVALUE((*func)(pst, suId, &transId, CellSrchRsp));
8327 }
8328 /* Periodic REM Scan for TPM End */
8329
8330 /* ends - Fix for CR ccpu00123185 */
8331 #endif
8332
8333 /**********************************************************************
8334          End of file
8335 **********************************************************************/