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