src/cm/rgr.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 \f
  19
  20 /************************************************************************
  21
  22      Name:     LTE-MAC layer
  23
  24      Type:     C source file
  25
  26      Desc:     C source code for pack/unpack of RGR interface primitives.
  27
  28      File:     rgr.c
  29
  30 **********************************************************************/
  31
  32 /** @file rgr.c
  33 @brief This file contains the packing/unpacking code for the RGR interface
  34        primitives.
  35 */
  36 /* LTE_ADV_FLAG_REMOVED_END */
  37 #include "common_def.h"
  38 #include "rgr.h"           /* RGR Interface defines */
  39 /* LTE_ADV_FLAG_REMOVED_END */
  40 #include "rgr.x"           /* RGR Interface includes */
  41
  42 #if defined(LCRGR)
  43
  44 \f
  45 /***********************************************************
  46 *
  47 *     Func : cmUnpkRgrCfgReq
  48 *
  49 *
  50 *     Desc : Configuration Request from RRM to MAC for
  51  * configuring Cell/Ue/Lc
  52 *
  53 *
  54 *     Ret  : S16
  55 *
  56 *     Notes:
  57 *
  58 *     File  :
  59 *
  60 **********************************************************/
  61 S16 cmUnpkRgrCfgReq
  62 (
  63 RgrCfgReq func,
  64 Pst *pst,
  65 Buffer *mBuf
  66 )
  67 {
  68    RgrCfgTransId transId;
  69    RgrCfgReqInfo *cfgReqInfo;
  70
  71 #if 0
  72    if (SUnpkS16(&spId, mBuf) != ROK) {
  73       SPutMsg(mBuf);
  74 #if (ERRCLASS & ERRCLS_ADD_RES)
  75       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  76          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  77          (ErrVal)ERGR021, (ErrVal)0, "Packing failed");
  78 #endif
  79       return RFAILED;
  80    }
  81 #endif
  82
  83    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
  84       SPutMsg(mBuf);
  85 #if (ERRCLASS & ERRCLS_ADD_RES)
  86       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  87          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  88          (ErrVal)ERGR022, (ErrVal)0, "Packing failed");
  89 #endif
  90       return RFAILED;
  91    }
  92    if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&cfgReqInfo,sizeof(RgrCfgReqInfo))) != ROK) {
  93 #if (ERRCLASS & ERRCLS_ADD_RES)
  94       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  95             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  96             (ErrVal)ERGR023, (ErrVal)0, "Packing failed");
  97 #endif
  98       SPutMsg(mBuf);
  99       return RFAILED;
 100    }
 101    memset(cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
 102    if (pst->selector == ODU_SELECTOR_LC)
 103       if (cmUnpkRgrCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
 104          SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
 105          SPutMsg(mBuf);
 106 #if (ERRCLASS & ERRCLS_ADD_RES)
 107          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 108                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 109                (ErrVal)ERGR024, (ErrVal)0, "Packing failed");
 110 #endif
 111          return RFAILED;
 112       }
 113    SPutMsg(mBuf);
 114    return ((*func)(pst, transId, cfgReqInfo));
 115 }
 116
 117 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
 118 \f
 119 /***********************************************************
 120 *
 121 *     Func : cmPkRgrTtiIndInfo
 122 *
 123 *
 124 *     Desc : Packs the TTI indication information.
 125 *
 126 *
 127 *     Ret  : S16
 128 *
 129 *     Notes:
 130 *
 131 *     File  :
 132 *
 133 **********************************************************/
 134 S16 cmPkRgrTtiIndInfo
 135 (
 136 RgrTtiIndInfo *param,
 137 Buffer        *mBuf
 138 )
 139 {
 140    CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
 141    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 142    return ROK;
 143 }
 144 \f
 145 /***********************************************************
 146 *
 147 *     Func : cmUnpkRgrTtiIndInfo
 148 *
 149 *
 150 *     Desc : Unpacking for RgrTtiIndInfo
 151 *
 152 *     Ret  : S16
 153 *
 154 *     Notes:
 155 *
 156 *     File  :
 157 *
 158 **********************************************************/
 159 S16 cmUnpkRgrTtiIndInfo
 160 (
 161 RgrTtiIndInfo *param,
 162 Buffer *mBuf
 163 )
 164 {
 165
 166    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 167    CMCHKUNPK(oduPackUInt16, &param->sfn, mBuf);
 168    return ROK;
 169 }
 170
 171 \f
 172 /***********************************************************
 173 *
 174 *     Func : cmPkRgrTtiInd
 175 *
 176 *
 177 *     Desc : TTI indication  from MAC to RRM
 178 *
 179 *
 180 *     Ret  : S16
 181 *
 182 *     Notes:
 183 *
 184 *     File  :
 185 *
 186 **********************************************************/
 187 S16 cmPkRgrTtiInd
 188 (
 189 Pst* pst,
 190 SuId suId,
 191 RgrTtiIndInfo *ttiInd
 192 )
 193 {
 194    Buffer *mBuf = NULLP;
 195
 196    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 197 #if (ERRCLASS & ERRCLS_ADD_RES)
 198       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 199          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 200          (ErrVal)ERGR025, (ErrVal)0, "Packing failed");
 201 #endif
 202       return RFAILED;
 203    }
 204    if (cmPkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
 205 #if (ERRCLASS & ERRCLS_ADD_RES)
 206       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 207          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 208          (ErrVal)ERGR026, (ErrVal)0, "Packing failed");
 209 #endif
 210       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
 211       SPutMsg(mBuf);
 212       return RFAILED;
 213    }
 214    if (SPkS16(suId, mBuf) != ROK) {
 215 #if (ERRCLASS & ERRCLS_ADD_RES)
 216       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 217          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 218          (ErrVal)ERGR027, (ErrVal)0, "Packing failed");
 219 #endif
 220       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
 221       SPutMsg(mBuf);
 222       return RFAILED;
 223    }
 224    SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
 225    pst->event = (Event) EVTRGRTTIIND;
 226    return (SPstTsk(pst,mBuf));
 227 }
 228
 229 \f
 230 /***********************************************************
 231 *
 232 *     Func : cmUnpkRgrTtiInd
 233 *
 234 *
 235 *     Desc : TTI indication from MAC to RRM
 236 *
 237 *
 238 *     Ret  : S16
 239 *
 240 *     Notes:
 241 *
 242 *     File  :
 243 *
 244 **********************************************************/
 245 S16 cmUnpkRgrTtiInd
 246 (
 247 RgrTtiInd func,
 248 Pst *pst,
 249 Buffer *mBuf
 250 )
 251 {
 252    SuId suId;
 253    RgrTtiIndInfo *ttiInd;
 254
 255
 256    if (SUnpkS16(&suId, mBuf) != ROK) {
 257       SPutMsg(mBuf);
 258 #if (ERRCLASS & ERRCLS_ADD_RES)
 259       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 260          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 261          (ErrVal)ERGR028, (ErrVal)0, "Packing failed");
 262 #endif
 263       return RFAILED;
 264    }
 265    if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ttiInd, sizeof(RgrTtiIndInfo))) != ROK)
 266    {
 267 #if (ERRCLASS & ERRCLS_ADD_RES)
 268       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 269           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 270           (ErrVal)ERGR029, (ErrVal)0, "UnPacking failed");
 271 #endif
 272       SPutMsg(mBuf);
 273       return RFAILED;
 274    }
 275
 276    if (cmUnpkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
 277       /*ccpu00114888- Memory Leak issue- Start*/
 278       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ttiInd,
 279             sizeof(RgrTtiIndInfo));
 280       /*ccpu00114888- Memory Leak issue- End*/
 281       SPutMsg(mBuf);
 282 #if (ERRCLASS & ERRCLS_ADD_RES)
 283       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 284          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 285          (ErrVal)ERGR030, (ErrVal)0, "Packing failed");
 286 #endif
 287       return RFAILED;
 288    }
 289    SPutMsg(mBuf);
 290    return ((*func)(pst, suId, ttiInd));
 291 }
 292
 293 \f
 294 /***********************************************************
 295 *
 296 *     Func : cmPkRgrCfgCfm
 297 *
 298 *
 299 *     Desc : Configuration Confirm from MAC to RRM
 300 *
 301 *
 302 *     Ret  : S16
 303 *
 304 *     Notes:
 305 *
 306 *     File  :
 307 *
 308 **********************************************************/
 309 S16 cmPkRgrCfgCfm
 310 (
 311 Pst* pst,
 312 RgrCfgTransId transId,
 313 uint8_t status
 314 )
 315 {
 316    Buffer *mBuf = NULLP;
 317
 318    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 319 #if (ERRCLASS & ERRCLS_ADD_RES)
 320       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 321          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 322          (ErrVal)ERGR031, (ErrVal)0, "Packing failed");
 323 #endif
 324       return RFAILED;
 325    }
 326    if (oduUnpackUInt8(status, mBuf) != ROK) {
 327 #if (ERRCLASS & ERRCLS_ADD_RES)
 328       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 329          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 330          (ErrVal)ERGR032, (ErrVal)0, "Packing failed");
 331 #endif
 332       SPutMsg(mBuf);
 333       return RFAILED;
 334    }
 335    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
 336 #if (ERRCLASS & ERRCLS_ADD_RES)
 337       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 338          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 339          (ErrVal)ERGR033, (ErrVal)0, "Packing failed");
 340 #endif
 341       SPutMsg(mBuf);
 342       return RFAILED;
 343    }
 344    pst->event = (Event) EVTMACSCHCFGCFM;
 345    return (SPstTsk(pst,mBuf));
 346 }
 347
 348 \f
 349 /***********************************************************
 350 *
 351 *     Func : cmUnpkRgrCfgCfm
 352 *
 353 *
 354 *     Desc : Configuration Confirm from MAC to RRM
 355 *
 356 *
 357 *     Ret  : S16
 358 *
 359 *     Notes:
 360 *
 361 *     File  :
 362 *
 363 **********************************************************/
 364 S16 cmUnpkRgrCfgCfm
 365 (
 366 RgrCfgCfm func,
 367 Pst *pst,
 368 Buffer *mBuf
 369 )
 370 {
 371    RgrCfgTransId transId;
 372    uint8_t status;
 373
 374
 375    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
 376       SPutMsg(mBuf);
 377 #if (ERRCLASS & ERRCLS_ADD_RES)
 378       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 379          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 380          (ErrVal)ERGR036, (ErrVal)0, "Packing failed");
 381 #endif
 382       return RFAILED;
 383    }
 384    if (oduPackUInt8(&status, mBuf) != ROK) {
 385       SPutMsg(mBuf);
 386 #if (ERRCLASS & ERRCLS_ADD_RES)
 387       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 388          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 389          (ErrVal)ERGR037, (ErrVal)0, "Packing failed");
 390 #endif
 391       return RFAILED;
 392    }
 393    SPutMsg(mBuf);
 394    return ((*func)(pst, transId, status));
 395 }
 396
 397 \f
 398 /***********************************************************
 399 *
 400 *     Func : cmPkRgrCfgTransId
 401 *
 402 *
 403 *     Desc : Transaction ID between MAC and RRM
 404 *
 405 *
 406 *     Ret  : S16
 407 *
 408 *     Notes:
 409 *
 410 *     File  :
 411 *
 412 **********************************************************/
 413 S16 cmPkRgrCfgTransId
 414 (
 415 RgrCfgTransId *param,
 416 Buffer *mBuf
 417 )
 418 {
 419
 420    S32 i;
 421
 422    for (i=RGR_CFG_TRANSID_SIZE-1; i >= 0; i--) {
 423       CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
 424    }
 425    return ROK;
 426 }
 427
 428
 429 \f
 430 /***********************************************************
 431 *
 432 *     Func : cmUnpkRgrCfgTransId
 433 *
 434 *
 435 *     Desc : Transaction ID between MAC and RRM
 436 *
 437 *
 438 *     Ret  : S16
 439 *
 440 *     Notes:
 441 *
 442 *     File  :
 443 *
 444 **********************************************************/
 445 S16 cmUnpkRgrCfgTransId
 446 (
 447 RgrCfgTransId *param,
 448 Buffer *mBuf
 449 )
 450 {
 451
 452    S32 i;
 453
 454    for (i=0; i<RGR_CFG_TRANSID_SIZE; i++) {
 455       CMCHKUNPK(oduPackUInt8, &param->trans[i], mBuf);
 456    }
 457    return ROK;
 458 }
 459
 460
 461 \f
 462 /***********************************************************
 463 *
 464 *     Func : cmPkRgrDlHqCfg
 465 *
 466 *
 467 *     Desc :  Downlink HARQ configuration per Cell
 468 *
 469 *
 470 *     Ret  : S16
 471 *
 472 *     Notes:
 473 *
 474 *     File  :
 475 *
 476 **********************************************************/
 477 S16 cmPkRgrDlHqCfg
 478 (
 479 RgrDlHqCfg *param,
 480 Buffer *mBuf
 481 )
 482 {
 483
 484
 485    CMCHKPK(oduUnpackUInt8, param->maxMsg4HqTx, mBuf);
 486    CMCHKPK(oduUnpackUInt8, param->maxDlHqTx, mBuf);
 487    return ROK;
 488 }
 489
 490
 491 \f
 492 /***********************************************************
 493 *
 494 *     Func : cmUnpkRgrDlHqCfg
 495 *
 496 *
 497 *     Desc :  Downlink HARQ configuration per Cell
 498 *
 499 *
 500 *     Ret  : S16
 501 *
 502 *     Notes:
 503 *
 504 *     File  :
 505 *
 506 **********************************************************/
 507 S16 cmUnpkRgrDlHqCfg
 508 (
 509 RgrDlHqCfg *param,
 510 Buffer *mBuf
 511 )
 512 {
 513
 514
 515    CMCHKUNPK(oduPackUInt8, &param->maxDlHqTx, mBuf);
 516    CMCHKUNPK(oduPackUInt8, &param->maxMsg4HqTx, mBuf);
 517    return ROK;
 518 }
 519
 520
 521 \f
 522 /***********************************************************
 523 *
 524 *     Func : cmPkRgrRntiCfg
 525 *
 526 *
 527 *     Desc : Range of RNTIs managed by MAC
 528 *
 529 *
 530 *     Ret  : S16
 531 *
 532 *     Notes:
 533 *
 534 *     File  :
 535 *
 536 **********************************************************/
 537 S16 cmPkRgrRntiCfg
 538 (
 539 RgrRntiCfg *param,
 540 Buffer *mBuf
 541 )
 542 {
 543
 544    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
 545    CMCHKPK(cmPkLteRnti, param->startRnti, mBuf);
 546    return ROK;
 547 }
 548
 549
 550 \f
 551 /***********************************************************
 552 *
 553 *     Func : cmUnpkRgrRntiCfg
 554 *
 555 *
 556 *     Desc : Range of RNTIs managed by MAC
 557 *
 558 *
 559 *     Ret  : S16
 560 *
 561 *     Notes:
 562 *
 563 *     File  :
 564 *
 565 **********************************************************/
 566 S16 cmUnpkRgrRntiCfg
 567 (
 568 RgrRntiCfg *param,
 569 Buffer *mBuf
 570 )
 571 {
 572
 573
 574    CMCHKUNPK(cmUnpkLteRnti, &param->startRnti, mBuf);
 575    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
 576    return ROK;
 577 }
 578
 579 #ifdef EMTC_ENABLE
 580 /***********************************************************
 581 *
 582 *     Func : cmPkRgrEmtcRntiCfg
 583 *
 584 *
 585 *     Desc : Range of Emtc RNTIs managed by MAC
 586 *
 587 *
 588 *     Ret  : S16
 589 *
 590 *     Notes:
 591 *
 592 *     File  :
 593 *
 594 **********************************************************/
 595 S16 cmPkRgrEmtcRntiCfg
 596 (
 597 RgrEmtcRntiCfg *param,
 598 Buffer *mBuf
 599 )
 600 {
 601
 602
 603    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
 604    CMCHKPK(cmPkLteRnti, param->rntiCeModeBRange, mBuf);
 605    CMCHKPK(cmPkLteRnti, param->rntiCeModeBStart, mBuf);
 606    CMCHKPK(cmPkLteRnti, param->rntiCeModeARange, mBuf);
 607    CMCHKPK(cmPkLteRnti, param->rntiCeModeAStart, mBuf);
 608    return ROK;
 609 }
 610
 611
 612 \f
 613 /***********************************************************
 614 *
 615 *     Func : cmUnpkRgrEmtcRntiCfg
 616 *
 617 *
 618 *     Desc : Range of Emtc RNTIs managed by MAC
 619 *
 620 *
 621 *     Ret  : S16
 622 *
 623 *     Notes:
 624 *
 625 *     File  :
 626 *
 627 **********************************************************/
 628 S16 cmUnpkRgrEmtcRntiCfg
 629 (
 630 RgrEmtcRntiCfg *param,
 631 Buffer *mBuf
 632 )
 633 {
 634
 635
 636    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeAStart, mBuf);
 637    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeARange, mBuf);
 638    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeBStart, mBuf);
 639    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeBRange, mBuf);
 640    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
 641
 642    return ROK;
 643 }
 644 #endif
 645
 646 \f
 647 /***********************************************************
 648 *
 649 *     Func : cmPkRgrDlCmnCodeRateCfg
 650 *
 651 *
 652 *     Desc : Downlink common channel code rate configuration per cell
 653 *
 654 *
 655 *     Ret  : S16
 656 *
 657 *     Notes:
 658 *
 659 *     File  :
 660 *
 661 **********************************************************/
 662 S16 cmPkRgrDlCmnCodeRateCfg
 663 (
 664 RgrDlCmnCodeRateCfg *param,
 665 Buffer *mBuf
 666 )
 667 {
 668
 669    CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
 670    CMCHKPK(oduUnpackUInt16, param->pdcchCodeRate, mBuf);
 671    CMCHKPK(oduUnpackUInt16, param->bcchPchRaCodeRate, mBuf);
 672    return ROK;
 673 }
 674
 675
 676 \f
 677 /***********************************************************
 678 *
 679 *     Func : cmUnpkRgrDlCmnCodeRateCfg
 680 *
 681 *
 682 *     Desc : Downlink common channel code rate configuration per cell
 683 *
 684 *
 685 *     Ret  : S16
 686 *
 687 *     Notes:
 688 *
 689 *     File  :
 690 *
 691 **********************************************************/
 692 S16 cmUnpkRgrDlCmnCodeRateCfg
 693 (
 694 RgrDlCmnCodeRateCfg *param,
 695 Buffer *mBuf
 696 )
 697 {
 698
 699    CMCHKUNPK(oduPackUInt16, &param->bcchPchRaCodeRate, mBuf);
 700    CMCHKUNPK(oduPackUInt16, &param->pdcchCodeRate, mBuf);
 701    CMCHKUNPK(oduPackUInt8, &param->ccchCqi, mBuf);
 702    return ROK;
 703 }
 704
 705
 706 \f
 707 /***********************************************************
 708 *
 709 *     Func : cmPkRgrCfiCfg
 710 *
 711 *
 712 *     Desc : Control Format Indicator (CFI) configuration per cell
 713 *
 714 *
 715 *     Ret  : S16
 716 *
 717 *     Notes:
 718 *
 719 *     File  :
 720 *
 721 **********************************************************/
 722 S16 cmPkRgrCfiCfg
 723 (
 724 RgrCfiCfg *param,
 725 Buffer *mBuf
 726 )
 727 {
 728    CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
 729    return ROK;
 730 }
 731
 732
 733 \f
 734 /***********************************************************
 735 *
 736 *     Func : cmUnpkRgrCfiCfg
 737 *
 738 *
 739 *     Desc : Control Format Indicator (CFI) configuration per cell
 740 *
 741 *
 742 *     Ret  : S16
 743 *
 744 *     Notes:
 745 *
 746 *     File  :
 747 *
 748 **********************************************************/
 749 S16 cmUnpkRgrCfiCfg
 750 (
 751 RgrCfiCfg *param,
 752 Buffer *mBuf
 753 )
 754 {
 755
 756    CMCHKUNPK(oduPackUInt8, &param->cfi, mBuf);
 757    return ROK;
 758 }
 759
 760
 761 \f
 762 /***********************************************************
 763 *
 764 *     Func : cmPkRgrPuschSubBandCfg
 765 *
 766 *
 767 *     Desc : PUSCH sub-band configuration per cell
 768 *
 769 *
 770 *     Ret  : S16
 771 *
 772 *     Notes:
 773 *
 774 *     File  :
 775 *
 776 **********************************************************/
 777 S16 cmPkRgrPuschSubBandCfg
 778 (
 779 RgrPuschSubBandCfg *param,
 780 Buffer *mBuf
 781 )
 782 {
 783
 784    S32 i;
 785
 786    for (i=param->numSubbands-1; i >= 0; i--) {
 787       CMCHKPK(oduUnpackUInt8, param->dmrs[i], mBuf);
 788    }
 789    CMCHKPK(oduUnpackUInt8, param->size, mBuf);
 790    CMCHKPK(oduUnpackUInt8, param->numSubbands, mBuf);
 791    CMCHKPK(oduUnpackUInt8, param->subbandStart, mBuf);
 792    return ROK;
 793 }
 794
 795
 796 \f
 797 /***********************************************************
 798 *
 799 *     Func : cmUnpkRgrPuschSubBandCfg
 800 *
 801 *
 802 *     Desc : PUSCH sub-band configuration per cell
 803 *
 804 *
 805 *     Ret  : S16
 806 *
 807 *     Notes:
 808 *
 809 *     File  :
 810 *
 811 **********************************************************/
 812 S16 cmUnpkRgrPuschSubBandCfg
 813 (
 814 RgrPuschSubBandCfg *param,
 815 Buffer *mBuf
 816 )
 817 {
 818
 819    S32 i;
 820    CMCHKUNPK(oduPackUInt8, &param->subbandStart, mBuf);
 821    CMCHKUNPK(oduPackUInt8, &param->numSubbands, mBuf);
 822    CMCHKUNPK(oduPackUInt8, &param->size, mBuf);
 823    for (i=0; i<param->numSubbands; i++) {
 824       CMCHKUNPK(oduPackUInt8, &param->dmrs[i], mBuf);
 825    }
 826    return ROK;
 827 }
 828
 829
 830 \f
 831 /***********************************************************
 832 *
 833 *     Func : cmPkRgrUlCmnCodeRateCfg
 834 *
 835 *
 836 *     Desc : Uplink common channel code rate configuration per cell
 837 *
 838 *
 839 *     Ret  : S16
 840 *
 841 *     Notes:
 842 *
 843 *     File  :
 844 *
 845 **********************************************************/
 846 S16 cmPkRgrUlCmnCodeRateCfg
 847 (
 848 RgrUlCmnCodeRateCfg *param,
 849 Buffer *mBuf
 850 )
 851 {
 852    CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
 853    return ROK;
 854 }
 855
 856
 857 \f
 858 /***********************************************************
 859 *
 860 *     Func : cmUnpkRgrUlCmnCodeRateCfg
 861 *
 862 *
 863 *     Desc : Uplink common channel code rate configuration per cell
 864 *
 865 *
 866 *     Ret  : S16
 867 *
 868 *     Notes:
 869 *
 870 *     File  :
 871 *
 872 **********************************************************/
 873 S16 cmUnpkRgrUlCmnCodeRateCfg
 874 (
 875 RgrUlCmnCodeRateCfg *param,
 876 Buffer *mBuf
 877 )
 878 {
 879
 880    CMCHKUNPK(oduPackUInt8, &param->ccchCqi, mBuf);
 881    return ROK;
 882 }
 883
 884
 885 \f
 886 /***********************************************************
 887 *
 888 *     Func : cmPkRgrUlTrgCqiCfg
 889 *
 890 *
 891 *     Desc : Target Uplink CQI to achieve through group power control configured per cell
 892 *
 893 *
 894 *     Ret  : S16
 895 *
 896 *     Notes:
 897 *
 898 *     File  :
 899 *
 900 **********************************************************/
 901 S16 cmPkRgrUlTrgCqiCfg
 902 (
 903 RgrUlTrgCqiCfg *param,
 904 Buffer *mBuf
 905 )
 906 {
 907    CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
 908    return ROK;
 909 }
 910
 911
 912 \f
 913 /***********************************************************
 914 *
 915 *     Func : cmUnpkRgrUlTrgCqiCfg
 916 *
 917 *
 918 *     Desc : Target Uplink CQI to achieve through group power control configured per cell
 919 *
 920 *
 921 *     Ret  : S16
 922 *
 923 *     Notes:
 924 *
 925 *     File  :
 926 *
 927 **********************************************************/
 928 S16 cmUnpkRgrUlTrgCqiCfg
 929 (
 930 RgrUlTrgCqiCfg *param,
 931 Buffer *mBuf
 932 )
 933 {
 934
 935    CMCHKUNPK(oduPackUInt8, &param->trgCqi, mBuf);
 936    return ROK;
 937 }
 938
 939
 940 \f
 941 /***********************************************************
 942 *
 943 *     Func : cmPkRgrBwCfg
 944 *
 945 *
 946 *     Desc : Bandwidth configuration per cell
 947 *
 948 *
 949 *     Ret  : S16
 950 *
 951 *     Notes:
 952 *
 953 *     File  :
 954 *
 955 **********************************************************/
 956 S16 cmPkRgrBwCfg
 957 (
 958 RgrBwCfg *param,
 959 Buffer *mBuf
 960 )
 961 {
 962
 963    CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
 964    CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
 965    return ROK;
 966 }
 967
 968
 969 #ifdef EMTC_ENABLE
 970 /* EMTC related pack changes start*/
 971
 972 S16 cmPkRgrEmtcSiCfg
 973 (
 974 RgrEmtcSiCfg *param,
 975 Buffer *mBuf
 976 )
 977 {
 978
 979    S32 i;
 980
 981    CMCHKPK(oduUnpackUInt8, param->siHoppingEnable, mBuf);
 982    CMCHKPK(oduUnpackUInt32, param->modPrd, mBuf);
 983    CMCHKPK(oduUnpackUInt8, param->siWinSizeBr, mBuf);
 984    CMCHKPK(oduUnpackUInt8, param->sib1Repetition, mBuf);
 985    CMCHKPK(oduUnpackUInt8, param->siRepetition, mBuf);
 986
 987    CMCHKPK(oduUnpackUInt16, param->startSymbolLc, mBuf);
 988    //CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
 989    /*Changes by SIMRAN*/
 990     if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
 991     {
 992       CMCHKPK(oduUnpackUInt16, param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
 993     }
 994     else
 995    {
 996       //CMCHKPK(SPkU64,param->fddDLOrTddSfBitmapLC.u.ptn40, mBuf);
 997       for (i=0; i<2; i++) {
 998          CMCHKPK(oduUnpackUInt32, param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
 999       }
1000
1001    }
1002    CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
1003    //CMCHKPK(oduUnpackUInt16, param->fddDlOrTddSfBitmapBR, mBuf);
1004
1005      for (i= (param->numSi-1); i >= 0; i--) {
1006                  CMCHKPK(oduUnpackUInt8, param->schdInfo[i].emtcSiNarrowBand, mBuf);
1007                  CMCHKPK(oduUnpackUInt16, param->schdInfo[i].emtcSiTbs, mBuf);
1008      }
1009
1010      for (i= (param->numSi-1); i >= 0; i--) {
1011           CMCHKPK(oduUnpackUInt32, param->siPeriodicity[i], mBuf);
1012         }
1013
1014      CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
1015
1016  return ROK;
1017 }
1018
1019
1020
1021
1022 S16 cmPkRgrEmtcRachCfg
1023 (
1024 RgrEmtcRachCfg *param,
1025 Buffer *mBuf
1026 )
1027 {
1028
1029    S32 i;
1030
1031    CMCHKPK(oduUnpackUInt8, param->emtcCeLvlSupported, mBuf);
1032
1033    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
1034           CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcRarHopping, mBuf);
1035           CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcWinSize, mBuf);
1036           CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcContResTmr, mBuf);
1037           CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].emtcPreambleTransMax, mBuf);
1038           CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.firstPreamble, mBuf);
1039           CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.lastPreamble, mBuf);
1040         }
1041
1042  return ROK;
1043 }
1044
1045
1046 S16 cmPkRgrEmtcPdschCfg
1047 (
1048 RgrEmtcPdschCfg*param,
1049 Buffer *mBuf
1050 )
1051 {
1052
1053    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
1054    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
1055
1056  return ROK;
1057 }
1058
1059 S16 cmPkRgrEmtcPuschCfg
1060 (
1061 RgrEmtcPuschCfg*param,
1062 Buffer *mBuf
1063 )
1064 {
1065    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
1066    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
1067    CMCHKPK(oduUnpackUInt8,  param->emtcHoppingOffset, mBuf);
1068    return ROK;
1069 }
1070
1071
1072
1073 S16 cmPkRgrEmtcPucchCfg
1074 (
1075 RgrEmtcPucchCfg *param,
1076 Buffer *mBuf
1077 )
1078 {
1079
1080    S32 i;
1081    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--)
1082    {
1083           CMCHKPK(oduUnpackUInt16, param->emtcN1pucchAnInfoLst[i], mBuf);
1084    }
1085
1086         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
1087         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
1088         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
1089         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
1090
1091  return ROK;
1092 }
1093
1094
1095 S16 cmPkRgrEmtcPrachCeParamCfg
1096 (
1097 RgrEmtcPrachCEParamLst *param,
1098 Buffer *mBuf
1099 )
1100 {
1101    CMCHKPK(oduUnpackUInt8, param->emtcPrachCfgIdx, mBuf);
1102    CMCHKPK(oduUnpackUInt8, param->emtcPrachFreqOffset, mBuf);
1103    CMCHKPK(oduUnpackUInt16,  param->emtcPrachStartSubFrame, mBuf);
1104    CMCHKPK(oduUnpackUInt8, param->emtcMaxPremAttemptCE, mBuf);
1105    CMCHKPK(oduUnpackUInt8, param->emtcNumRepPerPreambleAtt, mBuf);
1106    CMCHKPK(oduUnpackUInt8,  param->emtcNumMpdcchNBtoMonitor, mBuf);
1107    CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNBtoMonitor[0], mBuf);
1108    CMCHKPK(oduUnpackUInt8,  param->emtcMpdcchNBtoMonitor[1], mBuf);
1109    CMCHKPK(oduUnpackUInt16, param->emtcMpdcchNumRep, mBuf);
1110    CMCHKPK(oduUnpackUInt8,  param->emtcPrachHoppingCfg, mBuf);
1111    return ROK;
1112 }
1113
1114
1115
1116 S16 cmPkRgrEmtcPrachCfg
1117 (
1118 RgrEmtcPrachCfg *param,
1119 Buffer *mBuf
1120 )
1121 {
1122
1123    S32 i;
1124         CMCHKPK(oduUnpackUInt8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
1125         CMCHKPK(oduUnpackUInt8, param->emtcPrachHopingOffset, mBuf);
1126         CMCHKPK(oduUnpackUInt8, param->emtcInitialCElevel, mBuf);
1127    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
1128         CMCHKPK(cmPkRgrEmtcPrachCeParamCfg, &param->emtcPrachCEparmLst[i], mBuf);
1129         }
1130
1131  return ROK;
1132 }
1133
1134
1135
1136
1137 S16 cmPkRgrEmtcCfg
1138 (
1139 RgrEmtcCellCfg *param,
1140 Buffer *mBuf
1141 )
1142 {
1143    CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
1144    CMCHKPK(oduUnpackUInt32, param->emtcT300Tmr, mBuf);
1145    CMCHKPK(oduUnpackUInt32, param->emtcT301Tmr, mBuf);
1146    CMCHKPK(cmPkRgrEmtcSiCfg, &param->emtcSiCfg, mBuf);
1147    CMCHKPK(cmPkRgrEmtcRachCfg, &param->emtcRachCfg, mBuf);
1148    CMCHKPK(cmPkRgrEmtcPdschCfg, &param->emtcPdschCfg, mBuf);
1149    CMCHKPK(cmPkRgrEmtcPuschCfg, &param->emtcPuschCfg, mBuf);
1150    CMCHKPK(cmPkRgrEmtcPrachCfg, &param->emtcPrachCfg, mBuf);
1151    CMCHKPK(cmPkRgrEmtcPucchCfg, &param->emtcPucchCfg, mBuf);
1152    CMCHKPK(cmPkRgrEmtcRntiCfg, &param->emtcMacRnti, mBuf);
1153    CMCHKPK(oduUnpackUInt8, param->emtcPdschNbIdx, mBuf);
1154    CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNbIdx, mBuf);
1155    CMCHKPK(oduUnpackUInt8, param->emtcPuschNbIdx, mBuf);
1156
1157    return ROK;
1158 }
1159
1160 /* EMTC related pack changes end*/
1161
1162 /* EMTC related unpack changes start*/
1163
1164 S16 cmUnpkRgrEmtcSiCfg
1165 (
1166 RgrEmtcSiCfg *param,
1167 Buffer *mBuf
1168 )
1169 {
1170
1171      S32 i;
1172      uint32_t tmpEnum;
1173      CMCHKUNPK(oduPackUInt8, &param->numSi, mBuf);
1174
1175      for (i=0; i < param->numSi ; i++)
1176      {
1177          CMCHKUNPK(oduPackUInt32,(uint32_t*)&tmpEnum,mBuf);
1178          param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
1179      }
1180
1181      for (i=0; i < param->numSi ; i++)
1182      {
1183          CMCHKUNPK(oduPackUInt16, &param->schdInfo[i].emtcSiTbs, mBuf);
1184          CMCHKUNPK(oduPackUInt8, &param->schdInfo[i].emtcSiNarrowBand, mBuf);
1185      }
1186      //CMCHKUNPK(oduPackUInt16, &param->fddDlOrTddSfBitmapBR, mBuf);
1187      CMCHKUNPK(oduPackUInt8, &param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
1188      /*Changes by SIMRAN*/
1189        if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
1190        {
1191         CMCHKUNPK(oduPackUInt16, &param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
1192        }
1193        else
1194        {
1195           for (i=1; i>=0; i--) {
1196             CMCHKUNPK(oduPackUInt32, &param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
1197             }
1198      }
1199
1200      CMCHKUNPK(oduPackUInt16, &param->startSymbolLc, mBuf);
1201      CMCHKUNPK(oduPackUInt8, &param->siRepetition, mBuf);
1202      CMCHKUNPK(oduPackUInt8, &param->sib1Repetition, mBuf);
1203      CMCHKUNPK(oduPackUInt8, &param->siWinSizeBr, mBuf);
1204      CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
1205      param->modPrd = (RgrModPeriodicity) tmpEnum;
1206      CMCHKUNPK(oduPackUInt8, &param->siHoppingEnable, mBuf);
1207
1208           return ROK;
1209 }
1210
1211
1212
1213
1214 S16 cmUnpkRgrEmtcRachCfg
1215 (
1216 RgrEmtcRachCfg *param,
1217 Buffer *mBuf
1218 )
1219 {
1220
1221    S32 i;
1222    for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
1223           CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
1224           CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
1225           CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].emtcPreambleTransMax), mBuf);
1226           CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcContResTmr), mBuf);
1227           CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcWinSize), mBuf);
1228           CMCHKUNPK(oduPackUInt8,&(param->ceLevelInfo[i].emtcRarHopping), mBuf);
1229         }
1230     CMCHKUNPK(oduPackUInt8, &param->emtcCeLvlSupported, mBuf);
1231  return ROK;
1232 }
1233
1234
1235 S16 cmUnpkRgrEmtcPdschCfg
1236 (
1237 RgrEmtcPdschCfg*param,
1238 Buffer *mBuf
1239 )
1240 {
1241
1242    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeB, mBuf);
1243    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeA, mBuf);
1244  return ROK;
1245 }
1246
1247 S16 cmUnpkRgrEmtcPuschCfg
1248 (
1249 RgrEmtcPuschCfg*param,
1250 Buffer *mBuf
1251 )
1252 {
1253    CMCHKUNPK(oduPackUInt8,  &param->emtcHoppingOffset, mBuf);
1254    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeB, mBuf);
1255    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeA, mBuf);
1256    return ROK;
1257 }
1258
1259
1260
1261 S16 cmUnpkRgrEmtcPucchCfg
1262 (
1263 RgrEmtcPucchCfg *param,
1264 Buffer *mBuf
1265 )
1266 {
1267
1268    S32 i;
1269
1270
1271         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
1272         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
1273         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
1274         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
1275
1276    for (i=0; i <  RGR_MAX_CE_LEVEL ; i++) {
1277           CMCHKUNPK(oduPackUInt16, &param->emtcN1pucchAnInfoLst[i], mBuf);
1278         }
1279  return ROK;
1280 }
1281
1282
1283 S16 cmUnpkRgrEmtcPrachCeParamCfg
1284 (
1285 RgrEmtcPrachCEParamLst *param,
1286 Buffer *mBuf
1287 )
1288 {
1289    CMCHKUNPK(oduPackUInt8,  &param->emtcPrachHoppingCfg, mBuf);
1290    CMCHKUNPK(oduPackUInt16, &param->emtcMpdcchNumRep, mBuf);
1291    CMCHKUNPK(oduPackUInt8,  &param->emtcMpdcchNBtoMonitor[1], mBuf);
1292    CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchNBtoMonitor[0], mBuf);
1293    CMCHKUNPK(oduPackUInt8,  &param->emtcNumMpdcchNBtoMonitor, mBuf);
1294    CMCHKUNPK(oduPackUInt8, &param->emtcNumRepPerPreambleAtt, mBuf);
1295    CMCHKUNPK(oduPackUInt8, &param->emtcMaxPremAttemptCE, mBuf);
1296    CMCHKUNPK(oduPackUInt16,  &param->emtcPrachStartSubFrame, mBuf);
1297    CMCHKUNPK(oduPackUInt8, &param->emtcPrachFreqOffset, mBuf);
1298    CMCHKUNPK(oduPackUInt8, &param->emtcPrachCfgIdx, mBuf);
1299    return ROK;
1300 }
1301
1302
1303
1304 S16 cmUnpkRgrEmtcPrachCfg
1305 (
1306 RgrEmtcPrachCfg *param,
1307 Buffer *mBuf
1308 )
1309 {
1310
1311    S32 i;
1312    for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
1313         CMCHKUNPK(cmUnpkRgrEmtcPrachCeParamCfg, &param->emtcPrachCEparmLst[i], mBuf);
1314         }
1315         CMCHKUNPK(oduPackUInt8, &param->emtcInitialCElevel, mBuf);
1316         CMCHKUNPK(oduPackUInt8, &param->emtcPrachHopingOffset, mBuf);
1317         CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchStartSFCssRaFdd, mBuf);
1318
1319  return ROK;
1320 }
1321
1322 S16 cmUnpkRgrEmtcCfg
1323 (
1324 RgrEmtcCellCfg *param,
1325 Buffer *mBuf
1326 )
1327 {
1328
1329    CMCHKUNPK(oduPackUInt8, &param->emtcPuschNbIdx, mBuf);
1330    CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchNbIdx, mBuf);
1331    CMCHKUNPK(oduPackUInt8, &param->emtcPdschNbIdx, mBuf);
1332    CMCHKUNPK(cmUnpkRgrEmtcRntiCfg, &param->emtcMacRnti, mBuf);
1333    CMCHKUNPK(cmUnpkRgrEmtcPucchCfg, &param->emtcPucchCfg, mBuf);
1334    CMCHKUNPK(cmUnpkRgrEmtcPrachCfg, &param->emtcPrachCfg, mBuf);
1335    CMCHKUNPK(cmUnpkRgrEmtcPuschCfg, &param->emtcPuschCfg, mBuf);
1336    CMCHKUNPK(cmUnpkRgrEmtcPdschCfg, &param->emtcPdschCfg, mBuf);
1337    CMCHKUNPK(cmUnpkRgrEmtcRachCfg, &param->emtcRachCfg, mBuf);
1338    CMCHKUNPK(cmUnpkRgrEmtcSiCfg, &param->emtcSiCfg, mBuf);
1339    CMCHKUNPK(oduPackUInt32,&param->emtcT301Tmr, mBuf);
1340    CMCHKUNPK(oduPackUInt32, &param->emtcT300Tmr, mBuf);
1341    CMCHKUNPK(oduPackUInt16, &param->pci, mBuf);
1342
1343
1344
1345
1346
1347    return ROK;
1348 }
1349
1350 /* EMTC related unpack changes end*/
1351
1352
1353 #endif
1354
1355 \f
1356 /***********************************************************
1357 *
1358 *     Func : cmUnpkRgrBwCfg
1359 *
1360 *
1361 *     Desc : Bandwidth configuration per cell
1362 *
1363 *
1364 *     Ret  : S16
1365 *
1366 *     Notes:
1367 *
1368 *     File  :
1369 *
1370 **********************************************************/
1371 S16 cmUnpkRgrBwCfg
1372 (
1373 RgrBwCfg *param,
1374 Buffer *mBuf
1375 )
1376 {
1377
1378    CMCHKUNPK(oduPackUInt8, &param->dlTotalBw, mBuf);
1379    CMCHKUNPK(oduPackUInt8, &param->ulTotalBw, mBuf);
1380    return ROK;
1381 }
1382
1383
1384 \f
1385 /***********************************************************
1386 *
1387 *     Func : cmPkRgrPhichCfg
1388 *
1389 *
1390 *     Desc : PHICH configuration per cell
1391 *
1392 *
1393 *     Ret  : S16
1394 *
1395 *     Notes:
1396 *
1397 *     File  :
1398 *
1399 **********************************************************/
1400 S16 cmPkRgrPhichCfg
1401 (
1402 RgrPhichCfg *param,
1403 Buffer *mBuf
1404 )
1405 {
1406
1407    CMCHKPK(oduUnpackUInt8, param->isDurExtend, mBuf);
1408    CMCHKPK(oduUnpackUInt32, param->ngEnum, mBuf);
1409    return ROK;
1410 }
1411
1412
1413 \f
1414 /***********************************************************
1415 *
1416 *     Func : cmUnpkRgrPhichCfg
1417 *
1418 *
1419 *     Desc : PHICH configuration per cell
1420 *
1421 *
1422 *     Ret  : S16
1423 *
1424 *     Notes:
1425 *
1426 *     File  :
1427 *
1428 **********************************************************/
1429 S16 cmUnpkRgrPhichCfg
1430 (
1431 RgrPhichCfg *param,
1432 Buffer *mBuf
1433 )
1434 {
1435    uint32_t tmpEnum;
1436
1437
1438    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
1439    param->ngEnum = (RgrPhichNg) tmpEnum;
1440    CMCHKUNPK(oduPackUInt8, &param->isDurExtend, mBuf);
1441    return ROK;
1442 }
1443
1444
1445 \f
1446 /***********************************************************
1447 *
1448 *     Func : cmPkRgrPucchCfg
1449 *
1450 *
1451 *     Desc : PUCCH configuration per cell
1452 *
1453 *
1454 *     Ret  : S16
1455 *
1456 *     Notes:
1457 *
1458 *     File  :
1459 *
1460 **********************************************************/
1461 S16 cmPkRgrPucchCfg
1462 (
1463 RgrPucchCfg *param,
1464 Buffer *mBuf
1465 )
1466 {
1467
1468    CMCHKPK(oduUnpackUInt8, param->maxPucchRb, mBuf);
1469    CMCHKPK(oduUnpackUInt8, param->cyclicShift, mBuf);
1470    CMCHKPK(oduUnpackUInt8, param->deltaShift, mBuf);
1471    CMCHKPK(oduUnpackUInt16, param->n1PucchAn, mBuf);
1472    CMCHKPK(oduUnpackUInt8, param->resourceSize, mBuf);
1473
1474    return ROK;
1475 }
1476
1477
1478 \f
1479 /***********************************************************
1480 *
1481 *     Func : cmUnpkRgrPucchCfg
1482 *
1483 *
1484 *     Desc : PUCCH configuration per cell
1485 *
1486 *
1487 *     Ret  : S16
1488 *
1489 *     Notes:
1490 *
1491 *     File  :
1492 *
1493 **********************************************************/
1494 S16 cmUnpkRgrPucchCfg
1495 (
1496 RgrPucchCfg *param,
1497 Buffer *mBuf
1498 )
1499 {
1500
1501    CMCHKUNPK(oduPackUInt8, &param->resourceSize, mBuf);
1502    CMCHKUNPK(oduPackUInt16, &param->n1PucchAn, mBuf);
1503    CMCHKUNPK(oduPackUInt8, &param->deltaShift, mBuf);
1504    CMCHKUNPK(oduPackUInt8, &param->cyclicShift, mBuf);
1505    CMCHKUNPK(oduPackUInt8, &param->maxPucchRb, mBuf);
1506
1507    return ROK;
1508 }
1509
1510
1511 \f
1512 /***********************************************************
1513 *
1514 *     Func : cmPkRgrSrsCfg
1515 *
1516 *
1517 *     Desc : SRS configuration per cell
1518 *
1519 *
1520 *     Ret  : S16
1521 *
1522 *     Notes:
1523 *
1524 *     File  :
1525 *
1526 **********************************************************/
1527 S16 cmPkRgrSrsCfg
1528 (
1529 RgrSrsCfg *param,
1530 Buffer *mBuf
1531 )
1532 {
1533
1534
1535    CMCHKPK(oduUnpackUInt8, param->srsSubFrameCfg, mBuf);
1536    CMCHKPK(oduUnpackUInt32, param->srsBwEnum, mBuf);
1537    CMCHKPK(oduUnpackUInt32, param->srsCfgPrdEnum, mBuf);
1538    CMCHKPK(oduUnpackUInt8, param->isSrsCfgSetup, mBuf);
1539    return ROK;
1540 }
1541
1542
1543 \f
1544 /***********************************************************
1545 *
1546 *     Func : cmUnpkRgrSrsCfg
1547 *
1548 *
1549 *     Desc : SRS configuration per cell
1550 *
1551 *
1552 *     Ret  : S16
1553 *
1554 *     Notes:
1555 *
1556 *     File  :
1557 *
1558 **********************************************************/
1559 S16 cmUnpkRgrSrsCfg
1560 (
1561 RgrSrsCfg *param,
1562 Buffer *mBuf
1563 )
1564 {
1565    uint32_t tmpEnum;
1566
1567    CMCHKUNPK(oduPackUInt8, &param->isSrsCfgSetup, mBuf);
1568    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
1569    param->srsCfgPrdEnum = (RgrSrsCfgPrd) tmpEnum;
1570    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
1571    param->srsBwEnum = (RgrSrsBwCfg) tmpEnum;
1572    CMCHKUNPK(oduPackUInt8, &param->srsSubFrameCfg, mBuf);
1573    return ROK;
1574 }
1575
1576
1577 \f
1578 /***********************************************************
1579 *
1580 *     Func : cmPkRgrRachCfg
1581 *
1582 *
1583 *     Desc : RACH configuration per cell
1584 *
1585 *
1586 *     Ret  : S16
1587 *
1588 *     Notes:
1589 *
1590 *     File  :
1591 *
1592 **********************************************************/
1593 S16 cmPkRgrRachCfg
1594 (
1595 RgrRachCfg *param,
1596 Buffer *mBuf
1597 )
1598 {
1599
1600    S32 i;
1601
1602    CMCHKPK(oduUnpackUInt8, param->prachResource, mBuf);
1603    CMCHKPK(oduUnpackUInt16, param->msgSizeGrpA, mBuf);
1604    CMCHKPK(oduUnpackUInt8, param->sizeRaPreambleGrpA, mBuf);
1605    CMCHKPK(oduUnpackUInt8, param->numRaPreamble, mBuf);
1606    CMCHKPK(oduUnpackUInt8, param->maxMsg3Tx, mBuf);
1607       for (i=param->raOccasion.size-1; i >= 0; i--) {
1608          CMCHKPK(oduUnpackUInt8, param->raOccasion.subFrameNum[i], mBuf);
1609       }
1610       CMCHKPK(oduUnpackUInt32, param->raOccasion.sfnEnum, mBuf);
1611       CMCHKPK(oduUnpackUInt8, param->raOccasion.size, mBuf);
1612    CMCHKPK(oduUnpackUInt8, param->raWinSize, mBuf);
1613    CMCHKPK(oduUnpackUInt8, param->preambleFormat, mBuf);
1614 #ifdef RGR_V1
1615    /* rgr_c_001.main_5: cccpu00112372: Added contention resolution
1616     * timer configuration */
1617    CMCHKPK(oduUnpackUInt8, param->contResTmr, mBuf);
1618 #endif
1619    return ROK;
1620 }
1621
1622
1623 \f
1624 /***********************************************************
1625 *
1626 *     Func : cmUnpkRgrRachCfg
1627 *
1628 *
1629 *     Desc : RACH configuration per cell
1630 *
1631 *
1632 *     Ret  : S16
1633 *
1634 *     Notes:
1635 *
1636 *     File  :
1637 *
1638 **********************************************************/
1639 S16 cmUnpkRgrRachCfg
1640 (
1641 RgrRachCfg *param,
1642 Buffer *mBuf
1643 )
1644 {
1645    uint32_t tmpEnum;
1646
1647    S32 i;
1648 #ifdef RGR_V1
1649    /* rgr_c_001.main_5: cccpu00112372: Added contention resolution
1650     * timer configuration */
1651    CMCHKUNPK(oduPackUInt8, &param->contResTmr, mBuf);
1652 #endif
1653    CMCHKUNPK(oduPackUInt8, &param->preambleFormat, mBuf);
1654    CMCHKUNPK(oduPackUInt8, &param->raWinSize, mBuf);
1655       CMCHKUNPK(oduPackUInt8, &param->raOccasion.size, mBuf);
1656    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
1657    param->raOccasion.sfnEnum = (RgrRaSfn) tmpEnum;
1658       for (i=0; i<param->raOccasion.size; i++) {
1659          CMCHKUNPK(oduPackUInt8, &param->raOccasion.subFrameNum[i], mBuf);
1660       }
1661    CMCHKUNPK(oduPackUInt8, &param->maxMsg3Tx, mBuf);
1662    CMCHKUNPK(oduPackUInt8, &param->numRaPreamble, mBuf);
1663    CMCHKUNPK(oduPackUInt8, &param->sizeRaPreambleGrpA, mBuf);
1664    CMCHKUNPK(oduPackUInt16, &param->msgSizeGrpA, mBuf);
1665    CMCHKUNPK(oduPackUInt8, &param->prachResource, mBuf);
1666    return ROK;
1667 }
1668
1669
1670 \f
1671 /***********************************************************
1672 *
1673 *     Func : cmPkRgrSiCfg
1674 *
1675 *
1676 *     Desc : SI Configuration per cell
1677 *
1678 *
1679 *     Ret  : S16
1680 *
1681 *     Notes:
1682 *
1683 *     File  :
1684 *
1685 **********************************************************/
1686 S16 cmPkRgrSiCfg
1687 (
1688 RgrSiCfg *param,
1689 Buffer *mBuf
1690 )
1691 {
1692    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
1693 #ifdef RGR_SI_SCH
1694    S16 idx;
1695 #endif/*RGR_SI_SCH*/
1696
1697
1698 #ifdef RGR_SI_SCH
1699    if(param->numSi > sizeof(param->siPeriodicity)/
1700                        sizeof(param->siPeriodicity[0]))
1701       param->numSi = sizeof(param->siPeriodicity)/
1702                        sizeof(param->siPeriodicity[0]);
1703
1704    for (idx=param->numSi-1; idx >= 0; idx--) {
1705    /* Enum to be packed/unpacked as uint32_t instead of S32 */
1706       CMCHKPK(oduUnpackUInt32, param->siPeriodicity[idx], mBuf);
1707    }
1708    CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
1709    /*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
1710    CMCHKPK(oduUnpackUInt32, (uint32_t)param->modPrd, mBuf);
1711 #endif/*RGR_SI_SCH*/
1712    CMCHKPK(oduUnpackUInt8, param->retxCnt, mBuf);
1713    CMCHKPK(oduUnpackUInt8, param->siWinSize, mBuf);
1714    return ROK;
1715 }
1716
1717
1718 \f
1719 /***********************************************************
1720 *
1721 *     Func : cmUnpkRgrSiCfg
1722 *
1723 *
1724 *     Desc : SI Configuration per cell
1725 *
1726 *
1727 *     Ret  : S16
1728 *
1729 *     Notes:
1730 *
1731 *     File  :
1732 *
1733 **********************************************************/
1734 S16 cmUnpkRgrSiCfg
1735 (
1736 RgrSiCfg *param,
1737 Buffer *mBuf
1738 )
1739 {
1740    uint32_t tmpEnum;
1741    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
1742 #ifdef RGR_SI_SCH
1743    S16 idx;
1744 #endif/*RGR_SI_SCH*/
1745
1746
1747    CMCHKUNPK(oduPackUInt8, &param->siWinSize, mBuf);
1748    CMCHKUNPK(oduPackUInt8, &param->retxCnt, mBuf);
1749 #ifdef RGR_SI_SCH
1750    /*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
1751    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
1752    param->modPrd = (RgrModPeriodicity) tmpEnum;
1753    CMCHKUNPK(oduPackUInt8, &param->numSi, mBuf);
1754
1755    if(param->numSi > sizeof(param->siPeriodicity)/
1756                        sizeof(param->siPeriodicity[0]))
1757       param->numSi = sizeof(param->siPeriodicity)/
1758                        sizeof(param->siPeriodicity[0]);
1759
1760    /* Enum to be packed/unpacked as uint32_t instead of S32 */
1761    for (idx=0; idx < param->numSi; idx++) {
1762       CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
1763       param->siPeriodicity[idx] = (RgrSiPeriodicity) tmpEnum;
1764    }
1765 #endif/*RGR_SI_SCH*/
1766
1767    return ROK;
1768 }
1769
1770
1771 \f
1772 /***********************************************************
1773 *
1774 *     Func : cmPkRgrTpcRntiCfg
1775 *
1776 *
1777 *     Desc : TPC RNTI Range
1778 *
1779 *
1780 *     Ret  : S16
1781 *
1782 *     Notes:
1783 *
1784 *     File  :
1785 *
1786 **********************************************************/
1787 S16 cmPkRgrTpcRntiCfg
1788 (
1789 RgrTpcRntiCfg *param,
1790 Buffer *mBuf
1791 )
1792 {
1793
1794
1795    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
1796    CMCHKPK(cmPkLteRnti, param->startTpcRnti, mBuf);
1797    return ROK;
1798 }
1799
1800
1801 \f
1802 /***********************************************************
1803 *
1804 *     Func : cmUnpkRgrTpcRntiCfg
1805 *
1806 *
1807 *     Desc : TPC RNTI Range
1808 *
1809 *
1810 *     Ret  : S16
1811 *
1812 *     Notes:
1813 *
1814 *     File  :
1815 *
1816 **********************************************************/
1817 S16 cmUnpkRgrTpcRntiCfg
1818 (
1819 RgrTpcRntiCfg *param,
1820 Buffer *mBuf
1821 )
1822 {
1823
1824
1825    CMCHKUNPK(cmUnpkLteRnti, &param->startTpcRnti, mBuf);
1826    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
1827    return ROK;
1828 }
1829
1830
1831 \f
1832 /***********************************************************
1833 *
1834 *     Func : cmPkRgrUlPwrCfg
1835 *
1836 *
1837 *     Desc : Cell specific power configuration
1838 *
1839 *
1840 *     Ret  : S16
1841 *
1842 *     Notes:
1843 *
1844 *     File  :
1845 *
1846 **********************************************************/
1847 S16 cmPkRgrUlPwrCfg
1848 (
1849 RgrUlPwrCfg *param,
1850 Buffer *mBuf
1851 )
1852 {
1853
1854    CMCHKPK(cmPkRgrTpcRntiCfg, &param->puschPwrFmt3a, mBuf);
1855    CMCHKPK(cmPkRgrTpcRntiCfg, &param->puschPwrFmt3, mBuf);
1856    CMCHKPK(cmPkRgrTpcRntiCfg, &param->pucchPwrFmt3a, mBuf);
1857    CMCHKPK(cmPkRgrTpcRntiCfg, &param->pucchPwrFmt3, mBuf);
1858    CMCHKPK(SPkS8, param->deltaPreambleMsg3, mBuf);
1859    CMCHKPK(SPkS8, param->p0NominalPucch, mBuf);
1860    CMCHKPK(oduUnpackUInt32, param->alpha, mBuf);
1861    CMCHKPK(SPkS8, param->p0NominalPusch, mBuf);
1862    return ROK;
1863 }
1864
1865
1866 \f
1867 /***********************************************************
1868 *
1869 *     Func : cmUnpkRgrUlPwrCfg
1870 *
1871 *
1872 *     Desc : Cell specific power configuration
1873 *
1874 *
1875 *     Ret  : S16
1876 *
1877 *     Notes:
1878 *
1879 *     File  :
1880 *
1881 **********************************************************/
1882 S16 cmUnpkRgrUlPwrCfg
1883 (
1884 RgrUlPwrCfg *param,
1885 Buffer *mBuf
1886 )
1887 {
1888    uint32_t tmpEnum;
1889
1890
1891    CMCHKUNPK(SUnpkS8, &param->p0NominalPusch, mBuf);
1892    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
1893    param->alpha = (RgrPwrAlpha) tmpEnum;
1894    CMCHKUNPK(SUnpkS8, &param->p0NominalPucch, mBuf);
1895    CMCHKUNPK(SUnpkS8, &param->deltaPreambleMsg3, mBuf);
1896    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->pucchPwrFmt3, mBuf);
1897    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->pucchPwrFmt3a, mBuf);
1898    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->puschPwrFmt3, mBuf);
1899    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->puschPwrFmt3a, mBuf);
1900    return ROK;
1901 }
1902
1903
1904 \f
1905 /***********************************************************
1906 *
1907 *     Func : cmPkRgrPuschCfg
1908 *
1909 *
1910 *     Desc : brief cell specific hopping configuration
1911 *
1912 *
1913 *     Ret  : S16
1914 *
1915 *     Notes:
1916 *
1917 *     File  :
1918 *
1919 **********************************************************/
1920 S16 cmPkRgrPuschCfg
1921 (
1922 RgrPuschCfg *param,
1923 Buffer *mBuf
1924 )
1925 {
1926
1927
1928    CMCHKPK(oduUnpackUInt8, param->hopOffst, mBuf);
1929    CMCHKPK(oduUnpackUInt8, param->isIntraHop, mBuf);
1930    CMCHKPK(oduUnpackUInt8, param->numSubBands, mBuf);
1931    return ROK;
1932 }
1933
1934
1935 \f
1936 /***********************************************************
1937 *
1938 *     Func : cmUnpkRgrPuschCfg
1939 *
1940 *
1941 *     Desc : brief cell specific hopping configuration
1942 *
1943 *
1944 *     Ret  : S16
1945 *
1946 *     Notes:
1947 *
1948 *     File  :
1949 *
1950 **********************************************************/
1951 S16 cmUnpkRgrPuschCfg
1952 (
1953 RgrPuschCfg *param,
1954 Buffer *mBuf
1955 )
1956 {
1957
1958
1959    CMCHKUNPK(oduPackUInt8, &param->numSubBands, mBuf);
1960    CMCHKUNPK(oduPackUInt8, &param->isIntraHop, mBuf);
1961    CMCHKUNPK(oduPackUInt8, &param->hopOffst, mBuf);
1962    return ROK;
1963 }
1964
1965
1966 \f
1967 /***********************************************************
1968 *
1969 *     Func : cmPkRgrCodeBookRstCfg
1970 *
1971 *
1972 *     Desc : Number of bits in code book for different transmission modes
1973 *
1974 *
1975 *     Ret  : S16
1976 *
1977 *     Notes:
1978 *
1979 *     File  :
1980 *
1981 **********************************************************/
1982 S16 cmPkRgrCodeBookRstCfg
1983 (
1984 RgrCodeBookRstCfg *param,
1985 Buffer *mBuf
1986 )
1987 {
1988
1989    S32 i;
1990
1991    for (i=1-1; i >= 0; i--) {
1992       CMCHKPK(oduUnpackUInt32, param->pmiBitMap[i], mBuf);
1993    }
1994    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
1995    return ROK;
1996 }
1997
1998
1999 \f
2000 /***********************************************************
2001 *
2002 *     Func : cmUnpkRgrCodeBookRstCfg
2003 *
2004 *
2005 *     Desc : Number of bits in code book for different transmission modes
2006 *
2007 *
2008 *     Ret  : S16
2009 *
2010 *     Notes:
2011 *
2012 *     File  :
2013 *
2014 **********************************************************/
2015 S16 cmUnpkRgrCodeBookRstCfg
2016 (
2017 RgrCodeBookRstCfg *param,
2018 Buffer *mBuf
2019 )
2020 {
2021
2022    S32 i;
2023
2024    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
2025    for (i=0; i<1; i++) {
2026       CMCHKUNPK(oduPackUInt32, &param->pmiBitMap[i], mBuf);
2027    }
2028    return ROK;
2029 }
2030
2031
2032 \f
2033 /***********************************************************
2034 *
2035 *     Func : cmPkRgrPreambleSetCfg
2036 *
2037 *
2038 *     Desc : Range of PDCCH Order Preamble Set managed by MAC
2039 *
2040 *
2041 *     Ret  : S16
2042 *
2043 *     Notes:
2044 *
2045 *     File  :
2046 *
2047 **********************************************************/
2048 S16 cmPkRgrPreambleSetCfg
2049 (
2050 RgrPreambleSetCfg *param,
2051 Buffer *mBuf
2052 )
2053 {
2054
2055
2056    CMCHKPK(oduUnpackUInt8, param->size, mBuf);
2057    CMCHKPK(oduUnpackUInt8, param->start, mBuf);
2058    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
2059    return ROK;
2060 }
2061
2062
2063 \f
2064 /***********************************************************
2065 *
2066 *     Func : cmUnpkRgrPreambleSetCfg
2067 *
2068 *
2069 *     Desc : Range of PDCCH Order Preamble Set managed by MAC
2070 *
2071 *
2072 *     Ret  : S16
2073 *
2074 *     Notes:
2075 *
2076 *     File  :
2077 *
2078 **********************************************************/
2079 S16 cmUnpkRgrPreambleSetCfg
2080 (
2081 RgrPreambleSetCfg *param,
2082 Buffer *mBuf
2083 )
2084 {
2085
2086
2087    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
2088    CMCHKUNPK(oduPackUInt8, &param->start, mBuf);
2089    CMCHKUNPK(oduPackUInt8, &param->size, mBuf);
2090    return ROK;
2091 }
2092
2093
2094 \f
2095 /***********************************************************
2096 *
2097 *     Func : cmPkRgrCmnLchCfg
2098 *
2099 *
2100 *     Desc : Logical channel configuration info for common channels
2101 *
2102 *
2103 *     Ret  : S16
2104 *
2105 *     Notes:
2106 *
2107 *     File  :
2108 *
2109 **********************************************************/
2110 S16 cmPkRgrCmnLchCfg
2111 (
2112 RgrCmnLchCfg *param,
2113 Buffer *mBuf
2114 )
2115 {
2116
2117    CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
2118    CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
2119    CMCHKPK(oduUnpackUInt8, param->dir, mBuf);
2120    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
2121    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2122    return ROK;
2123 }
2124
2125
2126 \f
2127 /***********************************************************
2128 *
2129 *     Func : cmUnpkRgrCmnLchCfg
2130 *
2131 *
2132 *     Desc : Logical channel configuration info for common channels
2133 *
2134 *
2135 *     Ret  : S16
2136 *
2137 *     Notes:
2138 *
2139 *     File  :
2140 *
2141 **********************************************************/
2142 S16 cmUnpkRgrCmnLchCfg
2143 (
2144 RgrCmnLchCfg *param,
2145 Buffer *mBuf
2146 )
2147 {
2148
2149
2150    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
2151    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
2152    CMCHKUNPK(oduPackUInt8, &param->dir, mBuf);
2153    CMCHKUNPK(oduPackUInt8, &param->dlTrchType, mBuf);
2154    CMCHKUNPK(oduPackUInt8, &param->ulTrchType, mBuf);
2155    return ROK;
2156 }
2157
2158
2159 \f
2160 /***********************************************************
2161 *
2162 *     Func : cmPkRgrDlfsCfg
2163 *
2164 *
2165 *     Desc : RGR configuration for DLFS scheduler
2166 *
2167 *
2168 *     Ret  : S16
2169 *
2170 *     Notes:
2171 *
2172 *     File  :
2173 *
2174 **********************************************************/
2175 S16 cmPkRgrDlfsCfg
2176 (
2177 RgrDlfsCfg *param,
2178 Buffer *mBuf
2179 )
2180 {
2181
2182
2183    CMCHKPK(oduUnpackUInt8, param->thresholdCqi, mBuf);
2184    CMCHKPK(oduUnpackUInt8, param->isDlFreqSel, mBuf);
2185    return ROK;
2186 }
2187
2188
2189 \f
2190 /***********************************************************
2191 *
2192 *     Func : cmUnpkRgrDlfsCfg
2193 *
2194 *
2195 *     Desc : RGR configuration for DLFS scheduler
2196 *
2197 *
2198 *     Ret  : S16
2199 *
2200 *     Notes:
2201 *
2202 *     File  :
2203 *
2204 **********************************************************/
2205 S16 cmUnpkRgrDlfsCfg
2206 (
2207 RgrDlfsCfg *param,
2208 Buffer *mBuf
2209 )
2210 {
2211
2212
2213    CMCHKUNPK(oduPackUInt8, &param->isDlFreqSel, mBuf);
2214    CMCHKUNPK(oduPackUInt8, &param->thresholdCqi, mBuf);
2215    return ROK;
2216 }
2217
2218
2219 #ifdef LTE_TDD
2220
2221 #ifdef LTE_TDD
2222
2223 \f
2224 /***********************************************************
2225 *
2226 *     Func : cmPkRgrTddPrachInfo
2227 *
2228 *
2229 *     Desc : PRACH resource information for TDD
2230 *
2231 *
2232 *     Ret  : S16
2233 *
2234 *     Notes:
2235 *
2236 *     File  :
2237 *
2238 **********************************************************/
2239 S16 cmPkRgrTddPrachInfo
2240 (
2241 RgrTddPrachInfo *param,
2242 Buffer *mBuf
2243 )
2244 {
2245
2246
2247    CMCHKPK(oduUnpackUInt8, param->ulStartSfIdx, mBuf);
2248    CMCHKPK(oduUnpackUInt8, param->halfFrm, mBuf);
2249    CMCHKPK(oduUnpackUInt32, param->sfn, mBuf);
2250    CMCHKPK(oduUnpackUInt8, param->freqIdx, mBuf);
2251    return ROK;
2252 }
2253
2254
2255 \f
2256 /***********************************************************
2257 *
2258 *     Func : cmUnpkRgrTddPrachInfo
2259 *
2260 *
2261 *     Desc : PRACH resource information for TDD
2262 *
2263 *
2264 *     Ret  : S16
2265 *
2266 *     Notes:
2267 *
2268 *     File  :
2269 *
2270 **********************************************************/
2271 S16 cmUnpkRgrTddPrachInfo
2272 (
2273 RgrTddPrachInfo *param,
2274 Buffer *mBuf
2275 )
2276 {
2277    uint32_t tmpEnum;
2278
2279
2280    CMCHKUNPK(oduPackUInt8, &param->freqIdx, mBuf);
2281    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2282    param->sfn = tmpEnum;
2283    CMCHKUNPK(oduPackUInt8, &param->halfFrm, mBuf);
2284    CMCHKUNPK(oduPackUInt8, &param->ulStartSfIdx, mBuf);
2285    return ROK;
2286 }
2287
2288
2289 \f
2290 /***********************************************************
2291 *
2292 *     Func : cmPkRgrTddPrachRscInfo
2293 *
2294 *
2295 *     Desc : Set of PRACH Information for TDD
2296 *
2297 *
2298 *     Ret  : S16
2299 *
2300 *     Notes:
2301 *
2302 *     File  :
2303 *
2304 **********************************************************/
2305 S16 cmPkRgrTddPrachRscInfo
2306 (
2307 RgrTddPrachRscInfo *param,
2308 Buffer *mBuf
2309 )
2310 {
2311
2312    S32 i;
2313
2314    for (i=param->numRsc-1; i >= 0; i--) {
2315       CMCHKPK(cmPkRgrTddPrachInfo, &param->prachInfo[i], mBuf);
2316    }
2317    CMCHKPK(oduUnpackUInt8, param->numRsc, mBuf);
2318    return ROK;
2319 }
2320
2321
2322 \f
2323 /***********************************************************
2324 *
2325 *     Func : cmUnpkRgrTddPrachRscInfo
2326 *
2327 *
2328 *     Desc : Set of PRACH Information for TDD
2329 *
2330 *
2331 *     Ret  : S16
2332 *
2333 *     Notes:
2334 *
2335 *     File  :
2336 *
2337 **********************************************************/
2338 S16 cmUnpkRgrTddPrachRscInfo
2339 (
2340 RgrTddPrachRscInfo *param,
2341 Buffer *mBuf
2342 )
2343 {
2344
2345    S32 i;
2346
2347    CMCHKUNPK(oduPackUInt8, &param->numRsc, mBuf);
2348    for (i=0; i<param->numRsc; i++) {
2349       CMCHKUNPK(cmUnpkRgrTddPrachInfo, &param->prachInfo[i], mBuf);
2350    }
2351    return ROK;
2352 }
2353
2354
2355 #endif
2356
2357 #endif
2358
2359 \f
2360 /***********************************************************
2361 *
2362 *     Func : cmPkRgrEnbPfs
2363 *
2364 *
2365 *     Desc : PFS Configuration
2366 *
2367 *
2368 *     Ret  : S16
2369 *
2370 *     Notes:
2371 *
2372 *     File  :
2373 *
2374 **********************************************************/
2375 S16 cmPkRgrEnbPfs
2376 (
2377 RgrEnbPfs  *param,
2378 Buffer    *mBuf
2379 )
2380 {
2381    S32 idx;
2382    for(idx = RGR_MAX_NUM_QCI-1; idx >= 0; idx--)
2383    {
2384       CMCHKPK(oduUnpackUInt32, param->qciWgt[idx], mBuf);
2385    }
2386    CMCHKPK(oduUnpackUInt8, param->fairCoeffi, mBuf);
2387    CMCHKPK(oduUnpackUInt8, param->tptCoeffi, mBuf);
2388
2389    return ROK;
2390 }
2391
2392
2393 \f
2394 /***********************************************************
2395 *
2396 *     Func : cmUnpkRgrEnbPfs
2397 *
2398 *
2399 *     Desc : PFS Configuration
2400 *
2401 *
2402 *     Ret  : S16
2403 *
2404 *     Notes:
2405 *
2406 *     File  :
2407 *
2408 **********************************************************/
2409 S16 cmUnpkRgrEnbPfs
2410 (
2411 RgrEnbPfs *param,
2412 Buffer   *mBuf
2413 )
2414 {
2415    S32 idx;
2416
2417    CMCHKUNPK(oduPackUInt8, &param->tptCoeffi, mBuf);
2418    CMCHKUNPK(oduPackUInt8, &param->fairCoeffi, mBuf);
2419    for(idx = 0; idx < RGR_MAX_NUM_QCI; idx++)
2420    {
2421       CMCHKUNPK(oduPackUInt32, &param->qciWgt[idx], mBuf);
2422    }
2423    return ROK;
2424 }
2425
2426 /*rgr_c_001.main_7 - Added support for SPS*/
2427 \f
2428 /***********************************************************
2429 *
2430 *     Func : cmPkRgrSpsCellCfg
2431 *
2432 *
2433 *     Desc : DL SPS configuration parameters per UE
2434 TODO: Check if this is to be added to re-configuration as well
2435 *
2436 *
2437 *     Ret  : S16
2438 *
2439 *     Notes:
2440 *
2441 *     File  :
2442 *
2443 **********************************************************/
2444 S16 cmPkRgrSpsCellCfg
2445 (
2446 RgrSpsCellCfg *param,
2447 Buffer *mBuf
2448 )
2449 {
2450
2451    CMCHKPK(oduUnpackUInt16, param->maxSpsUePerUlSf, mBuf);
2452    CMCHKPK(oduUnpackUInt16, param->maxSpsUePerDlSf, mBuf);
2453    CMCHKPK(oduUnpackUInt8, param->maxSpsDlBw, mBuf);
2454
2455    return ROK;
2456 }
2457
2458
2459 \f
2460 /***********************************************************
2461 *
2462 *     Func : cmUnpkRgrSpsDlCellCfg
2463 *
2464 *
2465 *     Desc : DL SPS configuration parameters per UE
2466 TODO: Check if this is to be added to re-configuration as well
2467 *
2468 *
2469 *     Ret  : S16
2470 *
2471 *     Notes:
2472 *
2473 *     File  :
2474 *
2475 **********************************************************/
2476 S16 cmUnpkRgrSpsDlCellCfg
2477 (
2478 RgrSpsCellCfg *param,
2479 Buffer *mBuf
2480 )
2481 {
2482
2483
2484    CMCHKUNPK(oduPackUInt8, &param->maxSpsDlBw, mBuf);
2485    CMCHKUNPK(oduPackUInt16, &param->maxSpsUePerDlSf, mBuf);
2486    CMCHKUNPK(oduPackUInt16, &param->maxSpsUePerUlSf, mBuf);
2487
2488    return ROK;
2489 }
2490
2491 #ifdef RG_5GTF
2492 S16 cmPkRgr5gtfCellCfg
2493 (
2494 Rgr5gtfCellCfg   *param,
2495 Buffer           *mBuf
2496 )
2497 {
2498    S8 idx = 0;
2499    for (idx = MAX_5GTF_SUBFRAME_INFO - 1; idx >= 0 ;--idx)
2500    {
2501
2502       CMCHKPK(oduUnpackUInt32, param->dynConfig[(uint8_t)idx], mBuf);
2503    }
2504    CMCHKPK(oduUnpackUInt8, param->uePerGrp, mBuf);
2505    CMCHKPK(oduUnpackUInt8, param->ueGrpPerTti, mBuf);
2506    CMCHKPK(oduUnpackUInt8, param->numUes, mBuf);
2507    CMCHKPK(oduUnpackUInt8, param->numOfCC, mBuf);
2508    CMCHKPK(oduUnpackUInt8, param->bwPerCC, mBuf);
2509    CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
2510    return ROK;
2511 }
2512
2513 S16 cmUnPkRgr5gtfCellCfg
2514 (
2515 Rgr5gtfCellCfg   *param,
2516 Buffer           *mBuf
2517 )
2518 {
2519    S8 idx = 0;
2520
2521    CMCHKUNPK(oduPackUInt8, &param->cfi, mBuf);
2522    CMCHKUNPK(oduPackUInt8, &param->bwPerCC, mBuf);
2523    CMCHKUNPK(oduPackUInt8, &param->numOfCC, mBuf);
2524    CMCHKUNPK(oduPackUInt8, &param->numUes, mBuf);
2525    CMCHKUNPK(oduPackUInt8, &param->ueGrpPerTti, mBuf);
2526    CMCHKUNPK(oduPackUInt8, &param->uePerGrp, mBuf);
2527    for (idx = 0; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
2528    {
2529
2530       CMCHKUNPK(oduPackUInt32, &param->dynConfig[(uint8_t)idx], mBuf);
2531    }
2532    return ROK;
2533 }
2534 #endif
2535
2536
2537 /*LAA : functions to pack and unpack LAA params*/
2538 /***********************************************************
2539 *
2540 *     Func : cmPkRgrLteUCellCfg
2541 *
2542 *
2543 *     Desc : LAA configuration for the Cell
2544 *
2545 *
2546 *     Ret  : S16
2547 *
2548 *     Notes:
2549 *
2550 *     File  :
2551 *
2552 **********************************************************/
2553 static S16 cmPkRgrLteUCellCfg
2554 (
2555 RgrLteUCfg *param,
2556 Buffer *mBuf
2557 )
2558 {
2559
2560    CMCHKPK(oduUnpackUInt8, param->isLaaCell, mBuf);
2561
2562    return ROK;
2563 }
2564
2565 /***********************************************************
2566 *
2567 *     Func : cmUnpkRgrLteUCellCfg
2568 *
2569 *
2570 *     Desc : LAA configuration for the cell
2571 *
2572 *
2573 *     Ret  : S16
2574 *
2575 *     Notes:
2576 *
2577 *     File  :
2578 *
2579 **********************************************************/
2580 static S16 cmUnpkRgrLteUCellCfg
2581 (
2582 RgrLteUCfg *param,
2583 Buffer *mBuf
2584 )
2585 {
2586
2587
2588    CMCHKUNPK(oduPackUInt8, &param->isLaaCell, mBuf);
2589
2590    return ROK;
2591 }
2592
2593 /* LTE_ADV_FLAG_REMOVED_START */
2594 /***********************************************************
2595  *
2596  *     Func : cmPkRgrLteAdvancedUeConfig
2597  *
2598  *
2599  *     Desc : PAcks LteAdvancedUeConfig
2600  *
2601  *
2602  *     Ret  : S16
2603  *
2604  *     Notes:
2605  *
2606  *     File  :
2607  *
2608  **********************************************************/
2609 S16 cmPkRgrLteAdvancedUeConfig
2610 (
2611 RgrLteAdvancedUeConfig *param,
2612 Buffer *mBuf
2613 )
2614 {
2615
2616    CMCHKPK(oduUnpackUInt8, param->isUeCellEdge, mBuf);
2617    CMCHKPK(oduUnpackUInt8, param->isAbsUe, mBuf);
2618    CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
2619    return ROK;
2620 }
2621
2622 /***********************************************************
2623  *
2624  *     Func : cmUnpkRgrLteAdvancedUeConfig
2625  *
2626  *
2627  *     Desc : unpacks LteAdvancedUeConfig
2628  *
2629  *
2630  *     Ret  : S16
2631  *
2632  *     Notes:
2633  *
2634  *     File  :
2635  *
2636  **********************************************************/
2637 S16 cmUnpkRgrLteAdvancedUeConfig
2638 (
2639 RgrLteAdvancedUeConfig *param,
2640 Buffer *mBuf
2641 )
2642 {
2643
2644    CMCHKUNPK(oduPackUInt32, &param->pres, mBuf);
2645    CMCHKUNPK(oduPackUInt8, &param->isAbsUe, mBuf);
2646    CMCHKUNPK(oduPackUInt8, &param->isUeCellEdge, mBuf);
2647    return ROK;
2648 }
2649
2650 /***********************************************************
2651  *
2652  *     Func : cmPkRgrAbsConfig
2653  *
2654  *
2655  *     Desc : Packs RgrAbsConfig
2656  *
2657  *
2658  *     Ret  : S16
2659  *
2660  *     Notes:
2661  *
2662  *     File  :
2663  *
2664  **********************************************************/
2665 S16 cmPkRgrAbsConfig
2666 (
2667 RgrAbsConfig *param,
2668 Buffer *mBuf
2669 )
2670 {
2671    S8   indx = 0;
2672
2673    CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
2674    for (indx = RGR_ABS_PATTERN_LEN-1; indx >= 0; indx--)
2675    {
2676       CMCHKPK(oduUnpackUInt8, param->absPattern[(uint8_t)indx], mBuf);
2677    }
2678
2679    CMCHKPK(oduUnpackUInt32, param->absPatternType, mBuf);
2680    CMCHKPK(oduUnpackUInt32, param->absLoadPeriodicity, mBuf);
2681
2682    return ROK;
2683
2684 }
2685 /***********************************************************
2686  *
2687  *     Func : cmPkRgrSfrConfig
2688  *
2689  *
2690  *     Desc : Packs RgrSfrConfig
2691  *
2692  *
2693  *     Ret  : S16
2694  *
2695  *     Notes:
2696  *
2697  *     File  :
2698  *
2699  **********************************************************/
2700 S16 cmPkRgrSfrConfig
2701 (
2702 RgrSfrConfig *param,
2703 Buffer *mBuf
2704 )
2705 {
2706
2707    CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
2708 #ifdef TFU_UPGRADE
2709    CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pHigh, mBuf);
2710    CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pLow, mBuf);
2711 #endif
2712    CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.endRb, mBuf);
2713    CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.startRb, mBuf);
2714
2715    return ROK;
2716
2717 }
2718
2719
2720 /***********************************************************
2721  *
2722  *     Func : cmPkRgrDsfrConfig
2723  *
2724  *
2725  *     Desc : Packs RgrDsfrConfig
2726  *
2727  *
2728  *     Ret  : S16
2729  *
2730  *     Notes:  AIRSPAN_LTE_ADV_DSFR
2731  *
2732  *     File  :
2733  *
2734  **********************************************************/
2735 S16 cmPkRgrDsfrConfig
2736 (
2737 RgrDsfrConfig *param,
2738 Buffer *mBuf
2739 )
2740 {
2741
2742    CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
2743
2744    return ROK;
2745
2746 }
2747
2748
2749 /***********************************************************
2750  *
2751  *     Func : cmUnpkRgrDsfrConfig
2752  *
2753  *
2754  *     Desc : UnPacks RgrDsfrConfig
2755  *
2756  *
2757  *     Ret  : S16
2758  *
2759  *     Notes:  AIRSPAN_LTE_ADV_DSFR
2760  *
2761  *     File  :
2762  *
2763  **********************************************************/
2764 S16 cmUnpkRgrDsfrConfig
2765 (
2766 RgrDsfrConfig *param,
2767 Buffer *mBuf
2768 )
2769 {
2770
2771    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->status, mBuf);
2772    return ROK;
2773
2774 }
2775
2776
2777 /***********************************************************
2778  *
2779  *     Func : cmPkRgrCellLteAdvancedFeatureCfg
2780  *
2781  *
2782  *     Desc : Cell LteAdvancedFeatureCfg
2783  *
2784  *
2785  *     Ret  : S16
2786  *
2787  *     Notes:
2788  *
2789  *     File  :
2790  *
2791  **********************************************************/
2792
2793 S16 cmPkRgrCellLteAdvancedFeatureCfg
2794 (
2795 RgrLteAdvancedCellConfig *param,
2796 Buffer *mBuf
2797 )
2798 {
2799
2800    CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
2801    CMCHKPK(cmPkRgrDsfrConfig, &param->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
2802    CMCHKPK(cmPkRgrSfrConfig,  &param->sfrCfg, mBuf);
2803    CMCHKPK(cmPkRgrAbsConfig,  &param->absCfg, mBuf);
2804
2805    return ROK;
2806
2807 }
2808
2809
2810 /***********************************************************
2811  *
2812  *     Func : cmUnpkRgrAbsConfig
2813  *
2814  *
2815  *     Desc : Unpacks AbsConfig
2816  *
2817  *
2818  *     Ret  : S16
2819  *
2820  *     Notes:
2821  *
2822  *     File  :
2823  *
2824  **********************************************************/
2825 S16 cmUnpkRgrAbsConfig
2826 (
2827 RgrAbsConfig *param,
2828 Buffer *mBuf
2829 )
2830 {
2831
2832    S8 indx = 0;
2833
2834    CMCHKUNPK(oduPackUInt32, &param->absLoadPeriodicity, mBuf);
2835    CMCHKUNPK(oduPackUInt32, &param->absPatternType, mBuf);
2836    for (indx = 0; indx <RGR_ABS_PATTERN_LEN; indx++)
2837    {
2838       CMCHKUNPK(oduPackUInt8, &param->absPattern[(uint8_t)indx], mBuf);
2839    }
2840    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->status, mBuf);
2841
2842    return ROK;
2843
2844 }
2845
2846 /***********************************************************
2847  *
2848  *     Func : cmUnpkRgrSfrConfig
2849  *
2850  *
2851  *     Desc : Unpacks SfrConfig
2852  *
2853  *
2854  *     Ret  : S16
2855  *
2856  *     Notes:
2857  *
2858  *     File  :
2859  *
2860  **********************************************************/
2861 S16 cmUnpkRgrSfrConfig
2862 (
2863 RgrSfrConfig *param,
2864 Buffer *mBuf
2865 )
2866 {
2867
2868
2869    CMCHKUNPK(oduPackUInt8, &param->cellEdgeRbRange.startRb, mBuf);
2870    CMCHKUNPK(oduPackUInt8, &param->cellEdgeRbRange.endRb, mBuf);
2871 #ifdef TFU_UPGRADE
2872    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pwrThreshold.pLow, mBuf);
2873    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pwrThreshold.pHigh, mBuf);
2874 #endif
2875    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->status, mBuf);
2876
2877    return ROK;
2878 }
2879
2880 /***********************************************************
2881  *
2882  *     Func : cmUnpkRgrCellLteAdvancedFeatureCfg
2883  *
2884  *
2885  *     Desc : unpacks LteAdvancedFeatureCfg per cell
2886  *
2887  *
2888  *     Ret  : S16
2889  *
2890  *     Notes:
2891  *
2892  *     File  :
2893  *
2894  **********************************************************/
2895 S16 cmUnpkRgrCellLteAdvancedFeatureCfg
2896 (
2897 RgrLteAdvancedCellConfig *param,
2898 Buffer *mBuf
2899 )
2900 {
2901
2902    CMCHKUNPK(cmUnpkRgrAbsConfig, &param->absCfg, mBuf);
2903    CMCHKUNPK(cmUnpkRgrSfrConfig, &param->sfrCfg, mBuf);
2904    CMCHKUNPK(cmUnpkRgrDsfrConfig, &param->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
2905    CMCHKUNPK(oduPackUInt32, &param->pres, mBuf);
2906
2907    return ROK;
2908 }
2909
2910 /* LTE_ADV_FLAG_REMOVED_END */
2911
2912 /***********************************************************
2913 *
2914 *     Func : cmPkMacSchedGnbCfg
2915 *
2916 *     Desc : SCH GNB Configurations
2917 *
2918 *     Ret  : S16
2919 *
2920 *     Notes:
2921 *
2922 *     File  :
2923 *
2924 **********************************************************/
2925 S16 cmPkMacSchedGnbCfg
2926 (
2927 MacSchedGnbCfg *param,
2928 Buffer         *mBuf
2929 )
2930 {
2931
2932    CMCHKPK(oduUnpackUInt8, param->maxDlUePerTti, mBuf);
2933    CMCHKPK(oduUnpackUInt8, param->maxUlUePerTti, mBuf);
2934    CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
2935    CMCHKPK(oduUnpackUInt8, param->dlSchdType, mBuf);
2936    CMCHKPK(oduUnpackUInt8, param->ulSchdType, mBuf);
2937    CMCHKPK(oduUnpackUInt8, param->numTxAntPorts, mBuf);
2938    return ROK;
2939 } /* cmPkRgrSchedEnbCfg */
2940
2941 /***********************************************************
2942 *
2943 *     Func : cmUnpkMacSchedGnbCfg
2944 *
2945 *
2946 *     Desc : SCH Gnodeb Configuration to SCH
2947 *
2948 *
2949 *     Ret  : S16
2950 *
2951 *     Notes:
2952 *
2953 *     File  :
2954 *
2955 **********************************************************/
2956 S16 cmUnpkMacSchedGnbCfg
2957 (
2958 MacSchedGnbCfg *param,
2959 Buffer         *mBuf
2960 )
2961 {
2962
2963
2964    CMCHKUNPK(oduPackUInt8, &param->numTxAntPorts, mBuf);
2965    CMCHKUNPK(oduPackUInt8, &param->ulSchdType, mBuf);
2966    CMCHKUNPK(oduPackUInt8, &param->dlSchdType, mBuf);
2967    CMCHKUNPK(oduPackUInt8, &param->numCells, mBuf);
2968    CMCHKUNPK(oduPackUInt8, &param->maxUlUePerTti, mBuf);
2969    CMCHKUNPK(oduPackUInt8, &param->maxDlUePerTti, mBuf);
2970    return ROK;
2971 } /* cmUnpkMacSchedGnbCfg */
2972
2973 \f
2974 /***********************************************************
2975 *
2976 *     Func : cmPkRgrCellCfg
2977 *
2978 *
2979 *     Desc : Cell Configuration at RRM
2980 *
2981 *
2982 *     Ret  : S16
2983 *
2984 *     Notes:
2985 *
2986 *     File  :
2987 *
2988 **********************************************************/
2989 S16 cmPkRgrCellCfg
2990 (
2991 RgrCellCfg *param,
2992 Buffer *mBuf
2993 )
2994 {
2995
2996    S32 i;
2997
2998 #ifdef EMTC_ENABLE
2999 /* EMTC related changes start*/
3000
3001
3002 /* EMTC related changes ends*/
3003 #endif
3004
3005 #ifdef RG_5GTF
3006    CMCHKPK(cmPkRgr5gtfCellCfg, &param->Cell5gtfCfg, mBuf);
3007 #endif
3008 #ifdef LTE_ADV
3009    CMCHKPK(oduUnpackUInt8, param->isPucchFormat3Sptd, mBuf);
3010 #endif
3011 /*LAA: Pack LAA params*/
3012    CMCHKPK(cmPkRgrLteUCellCfg, &param->lteUCfg, mBuf);
3013    CMCHKPK(oduUnpackUInt32, param->msg4pAVal, mBuf);
3014    CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
3015    CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
3016    CMCHKPK(oduUnpackUInt16, param->phichTxPwrOffset, mBuf);
3017    CMCHKPK(oduUnpackUInt16, param->rarTxPwrOffset, mBuf);
3018    CMCHKPK(oduUnpackUInt16, param->pcchTxPwrOffset, mBuf);
3019    CMCHKPK(oduUnpackUInt16, param->bcchTxPwrOffset, mBuf);
3020
3021    CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
3022 /*rgr_c_001.main_7 - Added support for SPS*/
3023    CMCHKPK(cmPkRgrSpsCellCfg, &param->spsCfg, mBuf);
3024
3025 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
3026    CMCHKPK(oduUnpackUInt8, param->rrmTtiIndPrd, mBuf);
3027 #ifdef LTE_TDD
3028    CMCHKPK(cmPkRgrTddPrachRscInfo, &param->prachRscInfo, mBuf);
3029    CMCHKPK(oduUnpackUInt8, param->spclSfCfgIdx, mBuf);
3030    CMCHKPK(oduUnpackUInt8, param->ulDlCfgIdx, mBuf);
3031
3032 #endif
3033    CMCHKPK(cmPkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
3034    for (i=param->numCmnLcs-1; i >= 0; i--) {
3035       CMCHKPK(cmPkRgrCmnLchCfg, &param->cmnLcCfg[i], mBuf);
3036    }
3037    CMCHKPK(oduUnpackUInt8, param->numCmnLcs, mBuf);
3038    CMCHKPK(cmPkRgrPreambleSetCfg, &param->macPreambleSet, mBuf);
3039    CMCHKPK(cmPkRgrPuschCfg, &param->puschCfg, mBuf);
3040    CMCHKPK(cmPkRgrUlPwrCfg, &param->pwrCfg, mBuf);
3041    CMCHKPK(cmPkRgrSiCfg, &param->siCfg, mBuf);
3042    CMCHKPK(cmPkRgrRachCfg, &param->rachCfg, mBuf);
3043    CMCHKPK(cmPkRgrSrsCfg, &param->srsCfg, mBuf);
3044    CMCHKPK(cmPkRgrPucchCfg, &param->pucchCfg, mBuf);
3045    CMCHKPK(cmPkRgrPhichCfg, &param->phichCfg, mBuf);
3046    /* LTE_ADV_FLAG_REMOVED_START */
3047    CMCHKPK(cmPkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
3048    /* LTE_ADV_FLAG_REMOVED_END */
3049    CMCHKPK(cmPkRgrBwCfg, &param->bwCfg, mBuf);
3050    CMCHKPK(cmPkRgrDlfsCfg, &param->dlfsCfg, mBuf);
3051    CMCHKPK(cmPkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
3052    CMCHKPK(cmPkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
3053    CMCHKPK(cmPkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
3054    CMCHKPK(cmPkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
3055    CMCHKPK(cmPkRgrCfiCfg, &param->cfiCfg, mBuf);
3056    CMCHKPK(cmPkRgrRntiCfg, &param->macRnti, mBuf);
3057    CMCHKPK(cmPkRgrDlHqCfg, &param->dlHqCfg, mBuf);
3058    CMCHKPK(oduUnpackUInt8, param->dlfsSchdType, mBuf);
3059
3060    CMCHKPK(SPkS8, param->pMax, mBuf);
3061    CMCHKPK(oduUnpackUInt8, param->cellModSchm, mBuf);
3062    CMCHKPK(oduUnpackUInt8, param->isCpDlExtend, mBuf);
3063    CMCHKPK(oduUnpackUInt8, param->isCpUlExtend, mBuf);
3064    CMCHKPK(oduUnpackUInt8, param->maxUlUeNewTxPerTti, mBuf);
3065    CMCHKPK(oduUnpackUInt8, param->maxDlUeNewTxPerTti, mBuf);
3066    CMCHKPK(oduUnpackUInt8, param->maxDlRetxBw, mBuf);
3067    CMCHKPK(oduUnpackUInt8, param->maxDlBwPerUe, mBuf);
3068    CMCHKPK(oduUnpackUInt8, param->maxUlBwPerUe, mBuf);
3069    CMCHKPK(oduUnpackUInt8, param->maxCcchPerDlSf, mBuf);
3070    CMCHKPK(oduUnpackUInt8, param->maxUePerDlSf, mBuf);
3071    CMCHKPK(oduUnpackUInt8, param->maxUePerUlSf, mBuf);
3072 #ifdef RGR_V1
3073    /* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
3074       of  MSG3s */
3075    CMCHKPK(oduUnpackUInt8, param->maxMsg3PerUlSf, mBuf);
3076 #endif
3077    CMCHKPK(oduUnpackUInt8, param->macInst, mBuf);
3078    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
3079
3080 #ifdef EMTC_ENABLE
3081 /* EMTC related changes start*/
3082    CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
3083    CMCHKPK(cmPkRgrEmtcCfg, &param->emtcCellCfg, mBuf);
3084 /* EMTC related changes ends*/
3085 #endif
3086
3087    return ROK;
3088 }
3089
3090
3091 \f
3092 /***********************************************************
3093 *
3094 *     Func : cmUnpkRgrCellCfg
3095 *
3096 *
3097 *     Desc : Cell Configuration at RRM
3098 *
3099 *
3100 *     Ret  : S16
3101 *
3102 *     Notes:
3103 *
3104 *     File  :
3105 *
3106 **********************************************************/
3107 S16 cmUnpkRgrCellCfg
3108 (
3109 RgrCellCfg *param,
3110 Buffer *mBuf
3111 )
3112 {
3113
3114    S32 i;
3115
3116 #ifdef EMTC_ENABLE
3117 /* EMTC related changes start*/
3118    CMCHKUNPK(cmUnpkRgrEmtcCfg, &param->emtcCellCfg, mBuf);
3119    CMCHKUNPK(oduPackUInt8, &param->emtcEnable, mBuf);
3120 /* EMTC related changes ends*/
3121 #endif
3122
3123    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
3124    CMCHKUNPK(oduPackUInt8, &param->macInst, mBuf);
3125 #ifdef RGR_V1
3126    /* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
3127       of  MSG3s */
3128    CMCHKUNPK(oduPackUInt8, &param->maxMsg3PerUlSf, mBuf);
3129 #endif
3130    CMCHKUNPK(oduPackUInt8, &param->maxUePerUlSf, mBuf);
3131    CMCHKUNPK(oduPackUInt8, &param->maxUePerDlSf, mBuf);
3132    CMCHKUNPK(oduPackUInt8, &param->maxCcchPerDlSf, mBuf);
3133    CMCHKUNPK(oduPackUInt8, &param->maxUlBwPerUe, mBuf);
3134    CMCHKUNPK(oduPackUInt8, &param->maxDlBwPerUe, mBuf);
3135    CMCHKUNPK(oduPackUInt8, &param->maxDlRetxBw, mBuf);
3136    CMCHKUNPK(oduPackUInt8, &param->maxDlUeNewTxPerTti, mBuf);
3137    CMCHKUNPK(oduPackUInt8, &param->maxUlUeNewTxPerTti, mBuf);
3138    CMCHKUNPK(oduPackUInt8, &param->isCpUlExtend, mBuf);
3139    CMCHKUNPK(oduPackUInt8, &param->isCpDlExtend, mBuf);
3140    CMCHKUNPK(oduPackUInt8, &param->cellModSchm, mBuf);
3141    CMCHKUNPK(SUnpkS8, &param->pMax, mBuf);
3142    CMCHKUNPK(oduPackUInt8, &param->dlfsSchdType, mBuf);
3143    CMCHKUNPK(cmUnpkRgrDlHqCfg, &param->dlHqCfg, mBuf);
3144    CMCHKUNPK(cmUnpkRgrRntiCfg, &param->macRnti, mBuf);
3145    CMCHKUNPK(cmUnpkRgrCfiCfg, &param->cfiCfg, mBuf);
3146    CMCHKUNPK(cmUnpkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
3147    CMCHKUNPK(cmUnpkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
3148    CMCHKUNPK(cmUnpkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
3149    CMCHKUNPK(cmUnpkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
3150    CMCHKUNPK(cmUnpkRgrDlfsCfg, &param->dlfsCfg, mBuf);
3151    CMCHKUNPK(cmUnpkRgrBwCfg, &param->bwCfg, mBuf);
3152    /* LTE_ADV_FLAG_REMOVED_START */
3153    CMCHKUNPK(cmUnpkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
3154    /* LTE_ADV_FLAG_REMOVED_END */
3155    CMCHKUNPK(cmUnpkRgrPhichCfg, &param->phichCfg, mBuf);
3156    CMCHKUNPK(cmUnpkRgrPucchCfg, &param->pucchCfg, mBuf);
3157    CMCHKUNPK(cmUnpkRgrSrsCfg, &param->srsCfg, mBuf);
3158    CMCHKUNPK(cmUnpkRgrRachCfg, &param->rachCfg, mBuf);
3159    CMCHKUNPK(cmUnpkRgrSiCfg, &param->siCfg, mBuf);
3160    CMCHKUNPK(cmUnpkRgrUlPwrCfg, &param->pwrCfg, mBuf);
3161    CMCHKUNPK(cmUnpkRgrPuschCfg, &param->puschCfg, mBuf);
3162    CMCHKUNPK(cmUnpkRgrPreambleSetCfg, &param->macPreambleSet, mBuf);
3163    CMCHKUNPK(oduPackUInt8, &param->numCmnLcs, mBuf);
3164    for (i=0; i<param->numCmnLcs; i++) {
3165       CMCHKUNPK(cmUnpkRgrCmnLchCfg, &param->cmnLcCfg[i], mBuf);
3166    }
3167    CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
3168
3169 #ifdef LTE_TDD
3170    CMCHKUNPK(oduPackUInt8, &param->ulDlCfgIdx, mBuf);
3171    CMCHKUNPK(oduPackUInt8, &param->spclSfCfgIdx, mBuf);
3172    CMCHKUNPK(cmUnpkRgrTddPrachRscInfo, &param->prachRscInfo, mBuf);
3173
3174 #endif
3175 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
3176    CMCHKUNPK(oduPackUInt8, &param->rrmTtiIndPrd, mBuf);
3177    /*rgr_c_001.main_7 - Added support for SPS*/
3178    CMCHKUNPK(cmUnpkRgrSpsDlCellCfg, &param->spsCfg, mBuf);
3179
3180    CMCHKUNPK(oduPackUInt16, &param->t300TmrVal, mBuf);
3181    CMCHKPK(oduPackUInt16, &param->bcchTxPwrOffset, mBuf);
3182    CMCHKPK(oduPackUInt16, &param->pcchTxPwrOffset, mBuf);
3183    CMCHKPK(oduPackUInt16, &param->rarTxPwrOffset, mBuf);
3184    CMCHKPK(oduPackUInt16, &param->phichTxPwrOffset, mBuf);
3185    CMCHKUNPK(oduPackUInt8, &param->isDynCfiEnb, mBuf);
3186    CMCHKUNPK(oduPackUInt8, &param->isAutoCfgModeEnb, mBuf);
3187    CMCHKPK(oduPackUInt32, (uint32_t*)&param->msg4pAVal, mBuf);
3188    /*LAA: Unpack LAA Cell params*/
3189    CMCHKUNPK(cmUnpkRgrLteUCellCfg, &param->lteUCfg, mBuf);
3190    #ifdef LTE_ADV
3191    CMCHKUNPK(oduPackUInt8, &param->isPucchFormat3Sptd, mBuf);
3192 #endif
3193 #ifdef RG_5GTF
3194    CMCHKUNPK(cmUnPkRgr5gtfCellCfg, &param->Cell5gtfCfg, mBuf);
3195 #endif
3196    return ROK;
3197 }
3198
3199
3200 \f
3201 /***********************************************************
3202 *
3203 *     Func : cmPkRgrUeAprdDlCqiCfg
3204 *
3205 *
3206 *     Desc : Downlink Aperiodic CQI reporting related configuration per UE
3207 *
3208 *
3209 *     Ret  : S16
3210 *
3211 *     Notes:
3212 *
3213 *     File  :
3214 *
3215 **********************************************************/
3216 S16 cmPkRgrUeAprdDlCqiCfg
3217 (
3218 RgrUeAprdDlCqiCfg *param,
3219 Buffer *mBuf
3220 )
3221 {
3222
3223    /*Pack Aperiodic Trigger List only for Pcell */
3224 #ifdef LTE_ADV
3225    CMCHKPK(oduUnpackUInt8, param->triggerSet2, mBuf);
3226    CMCHKPK(oduUnpackUInt8, param->triggerSet1, mBuf);
3227 #endif
3228
3229    CMCHKPK(oduUnpackUInt32, param->aprdModeEnum, mBuf);
3230    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
3231    return ROK;
3232 }
3233
3234
3235 \f
3236 /***********************************************************
3237 *
3238 *     Func : cmUnpkRgrUeAprdDlCqiCfg
3239 *
3240 *
3241 *     Desc : Downlink Aperiodic CQI reporting related configuration per UE
3242 *
3243 *
3244 *     Ret  : S16
3245 *
3246 *     Notes:
3247 *
3248 *     File  :
3249 *
3250 **********************************************************/
3251 S16 cmUnpkRgrUeAprdDlCqiCfg
3252 (
3253 RgrUeAprdDlCqiCfg *param,
3254 Buffer *mBuf
3255 )
3256 {
3257    uint32_t tmpEnum;
3258
3259
3260    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
3261    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3262    param->aprdModeEnum = (RgrAprdCqiMode) tmpEnum;
3263
3264 #ifdef LTE_ADV
3265    CMCHKUNPK(oduPackUInt8, &param->triggerSet1, mBuf);
3266    CMCHKUNPK(oduPackUInt8, &param->triggerSet2, mBuf);
3267 #endif
3268
3269    return ROK;
3270 }
3271
3272
3273 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
3274 #ifndef TFU_UPGRADE
3275
3276 \f
3277 /***********************************************************
3278 *
3279 *     Func : cmPkRgrUePrdDlCqiCfg
3280 *
3281 *
3282 *     Desc : Downlink Periodic CQI reporting related configuration per UE
3283 *
3284 *
3285 *     Ret  : S16
3286 *
3287 *     Notes:
3288 *
3289 *     File  :
3290 *
3291 **********************************************************/
3292 S16 cmPkRgrUePrdDlCqiCfg
3293 (
3294 RgrUePrdDlCqiCfg *param,
3295 Buffer *mBuf
3296 )
3297 {
3298
3299
3300    CMCHKPK(oduUnpackUInt16, param->cqiPmiCfgIdx, mBuf);
3301    CMCHKPK(oduUnpackUInt8, param->k, mBuf);
3302    CMCHKPK(SPkS8, param->cqiOffst, mBuf);
3303    CMCHKPK(oduUnpackUInt8, param->subframeOffst, mBuf);
3304    CMCHKPK(oduUnpackUInt32, param->prdicityEnum, mBuf);
3305    CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
3306    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
3307    return ROK;
3308 }
3309
3310
3311 \f
3312 /***********************************************************
3313 *
3314 *     Func : cmUnpkRgrUePrdDlCqiCfg
3315 *
3316 *
3317 *     Desc : Downlink Periodic CQI reporting related configuration per UE
3318 *
3319 *
3320 *     Ret  : S16
3321 *
3322 *     Notes:
3323 *
3324 *     File  :
3325 *
3326 **********************************************************/
3327 S16 cmUnpkRgrUePrdDlCqiCfg
3328 (
3329 RgrUePrdDlCqiCfg *param,
3330 Buffer *mBuf
3331 )
3332 {
3333    uint32_t tmpEnum;
3334
3335
3336    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
3337    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3338    param->prdModeEnum = tmpEnum;
3339    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3340    param->prdicityEnum = tmpEnum;
3341    CMCHKUNPK(oduPackUInt8, &param->subframeOffst, mBuf);
3342    CMCHKUNPK(SUnpkS8, &param->cqiOffst, mBuf);
3343    CMCHKUNPK(oduPackUInt8, &param->k, mBuf);
3344    CMCHKUNPK(oduPackUInt16, &param->cqiPmiCfgIdx, mBuf);
3345    return ROK;
3346 }
3347
3348
3349 #endif
3350
3351 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
3352 #ifdef TFU_UPGRADE
3353 /***********************************************************
3354 *
3355 *     Func : cmPkRgrUeDlPCqiSetup
3356 *
3357 *
3358 *     Desc : Periodic CQI Setup configuration parameters information
3359 *
3360 *
3361 *     Ret  : S16
3362 *
3363 *     Notes:
3364 *
3365 *     File  :
3366 *
3367 **********************************************************/
3368 S16 cmPkRgrUeDlPCqiSetup
3369 (
3370 RgrUeDlPCqiSetup *param,
3371 Buffer *mBuf
3372 )
3373 {
3374
3375
3376    CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
3377    CMCHKPK(oduUnpackUInt8, param->sANCQI, mBuf);
3378    /*rgr_c_001.main_9 DEL removed unwanted comments*/
3379    CMCHKPK(oduUnpackUInt16, param->riCfgIdx, mBuf);
3380    CMCHKPK(oduUnpackUInt8, param->riEna, mBuf);
3381    CMCHKPK(oduUnpackUInt8, param->k, mBuf);
3382    CMCHKPK(oduUnpackUInt8, param->cqiRepType, mBuf);
3383    CMCHKPK(oduUnpackUInt16, param->cqiPCfgIdx, mBuf);
3384    CMCHKPK(oduUnpackUInt16, param->cqiPResIdx, mBuf);
3385    return ROK;
3386 }
3387
3388
3389 \f
3390 /***********************************************************
3391 *
3392 *     Func : cmUnpkRgrUeDlPCqiSetup
3393 *
3394 *
3395 *     Desc : Periodic CQI Setup configuration parameters information
3396 *
3397 *
3398 *     Ret  : S16
3399 *
3400 *     Notes:
3401 *
3402 *     File  :
3403 *
3404 **********************************************************/
3405 S16 cmUnpkRgrUeDlPCqiSetup
3406 (
3407 RgrUeDlPCqiSetup *param,
3408 Buffer *mBuf
3409 )
3410 {
3411    uint32_t tmpEnum;
3412
3413
3414    CMCHKUNPK(oduPackUInt16, &param->cqiPResIdx, mBuf);
3415    CMCHKUNPK(oduPackUInt16, &param->cqiPCfgIdx, mBuf);
3416    CMCHKUNPK(oduPackUInt8, &param->cqiRepType, mBuf);
3417    CMCHKUNPK(oduPackUInt8, &param->k, mBuf);
3418    CMCHKUNPK(oduPackUInt8, &param->riEna, mBuf);
3419    /*rgr_c_001.main_9 DEL removed unwanted comments*/
3420    CMCHKUNPK(oduPackUInt16, &param->riCfgIdx, mBuf);
3421    CMCHKUNPK(oduPackUInt8, &param->sANCQI, mBuf);
3422    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3423    param->prdModeEnum = (RgrPrdCqiMode) tmpEnum;
3424    return ROK;
3425 }
3426
3427
3428 \f
3429 /***********************************************************
3430 *
3431 *     Func : cmPkRgrUePrdDlCqiCfg
3432 *
3433 *
3434 *     Desc : Periodic CQI/PMI/RI configuration parameters information
3435 *
3436 *
3437 *     Ret  : S16
3438 *
3439 *     Notes:
3440 *
3441 *     File  :
3442 *
3443 **********************************************************/
3444 S16 cmPkRgrUePrdDlCqiCfg
3445 (
3446 RgrUePrdDlCqiCfg *param,
3447 Buffer *mBuf
3448 )
3449 {
3450
3451
3452    CMCHKPK(cmPkRgrUeDlPCqiSetup, &param->cqiSetup, mBuf);
3453    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
3454    return ROK;
3455 }
3456
3457
3458 \f
3459 /***********************************************************
3460 *
3461 *     Func : cmUnpkRgrUePrdDlCqiCfg
3462 *
3463 *
3464 *     Desc : Periodic CQI/PMI/RI configuration parameters information
3465 *
3466 *
3467 *     Ret  : S16
3468 *
3469 *     Notes:
3470 *
3471 *     File  :
3472 *
3473 **********************************************************/
3474 S16 cmUnpkRgrUePrdDlCqiCfg
3475 (
3476 RgrUePrdDlCqiCfg *param,
3477 Buffer *mBuf
3478 )
3479 {
3480
3481
3482    CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
3483    CMCHKUNPK(cmUnpkRgrUeDlPCqiSetup, &param->cqiSetup, mBuf);
3484    return ROK;
3485 }
3486
3487
3488 \f
3489 /***********************************************************
3490 *
3491 *     Func : cmPkRgrUeUlSrsSetupCfg
3492 *
3493 *
3494 *     Desc : SRS configuration setup parameters information.
3495    Reference 36.313 SoundingRS-UL-Config
3496 *
3497 *
3498 *     Ret  : S16
3499 *
3500 *     Notes:
3501 *
3502 *     File  :
3503 *
3504 **********************************************************/
3505 S16 cmPkRgrUeUlSrsSetupCfg
3506 (
3507 RgrUeUlSrsSetupCfg *param,
3508 Buffer *mBuf
3509 )
3510 {
3511
3512
3513    CMCHKPK(oduUnpackUInt8, param->fDomPosi, mBuf);
3514    CMCHKPK(oduUnpackUInt8, param->txComb, mBuf);
3515    CMCHKPK(oduUnpackUInt8, param->sANSrs, mBuf);
3516    CMCHKPK(oduUnpackUInt8, param->duration, mBuf);
3517    CMCHKPK(oduUnpackUInt32, param->cycShift, mBuf);
3518    CMCHKPK(oduUnpackUInt32, param->srsHopBw, mBuf);
3519    CMCHKPK(oduUnpackUInt32, param->srsBw, mBuf);
3520    /*rgr_c_001.main_9 DEL removed unwanted comments*/
3521    CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
3522    return ROK;
3523 }
3524
3525
3526 \f
3527 /***********************************************************
3528 *
3529 *     Func : cmUnpkRgrUeUlSrsSetupCfg
3530 *
3531 *
3532 *     Desc : SRS configuration setup parameters information.
3533    Reference 36.313 SoundingRS-UL-Config
3534 *
3535 *
3536 *     Ret  : S16
3537 *
3538 *     Notes:
3539 *
3540 *     File  :
3541 *
3542 **********************************************************/
3543 S16 cmUnpkRgrUeUlSrsSetupCfg
3544 (
3545 RgrUeUlSrsSetupCfg *param,
3546 Buffer *mBuf
3547 )
3548 {
3549    uint32_t tmpEnum;
3550
3551
3552    /*rgr_c_001.main_9 DEL removed unwanted comments*/
3553    CMCHKUNPK(oduPackUInt16, &param->srsCfgIdx, mBuf);
3554    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3555    param->srsBw = (RgrUlSrsBwInfo) tmpEnum;
3556    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3557    param->srsHopBw = (RgrUlSrsHoBwInfo) tmpEnum;
3558    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3559    param->cycShift = (RgrUlSrsCycShiftInfo) tmpEnum;
3560    CMCHKUNPK(oduPackUInt8, &param->duration, mBuf);
3561    CMCHKUNPK(oduPackUInt8, &param->sANSrs, mBuf);
3562    CMCHKUNPK(oduPackUInt8, &param->txComb, mBuf);
3563    CMCHKUNPK(oduPackUInt8, &param->fDomPosi, mBuf);
3564    return ROK;
3565 }
3566
3567
3568 \f
3569 /***********************************************************
3570 *
3571 *     Func : cmPkRgrUeSrSetupCfg
3572 *
3573 *
3574 *     Desc : SR Setup configuration parameters information
3575 *
3576 *
3577 *     Ret  : S16
3578 *
3579 *     Notes:
3580 *
3581 *     File  :
3582 *
3583 **********************************************************/
3584 S16 cmPkRgrUeSrSetupCfg
3585 (
3586 RgrUeSrSetupCfg *param,
3587 Buffer *mBuf
3588 )
3589 {
3590
3591
3592    /* ccpu00131601:DEL - dTMax Packing removed since this param will not
3593     * be required by Scheduler*/
3594    CMCHKPK(oduUnpackUInt8, param->srCfgIdx, mBuf);
3595    CMCHKPK(oduUnpackUInt16, param->srResIdx, mBuf);
3596    return ROK;
3597 }
3598
3599
3600 \f
3601 /***********************************************************
3602 *
3603 *     Func : cmUnpkRgrUeSrSetupCfg
3604 *
3605 *
3606 *     Desc : SR Setup configuration parameters information
3607 *
3608 *
3609 *     Ret  : S16
3610 *
3611 *     Notes:
3612 *
3613 *     File  :
3614 *
3615 **********************************************************/
3616 S16 cmUnpkRgrUeSrSetupCfg
3617 (
3618 RgrUeSrSetupCfg *param,
3619 Buffer *mBuf
3620 )
3621 {
3622
3623    CMCHKUNPK(oduPackUInt16, &param->srResIdx, mBuf);
3624    CMCHKUNPK(oduPackUInt8, &param->srCfgIdx, mBuf);
3625    /* ccpu00131601:DEL - dTMax UnPacking removed since this param will not
3626     * be required by Scheduler*/
3627    return ROK;
3628 }
3629
3630
3631 \f
3632 /***********************************************************
3633 *
3634 *     Func : cmPkRgrUeSrCfg
3635 *
3636 *
3637 *     Desc : SR configuration parameters information
3638 *
3639 *
3640 *     Ret  : S16
3641 *
3642 *     Notes:
3643 *
3644 *     File  :
3645 *
3646 **********************************************************/
3647 S16 cmPkRgrUeSrCfg
3648 (
3649 RgrUeSrCfg *param,
3650 Buffer *mBuf
3651 )
3652 {
3653
3654
3655    CMCHKPK(cmPkRgrUeSrSetupCfg, &param->srSetup, mBuf);
3656    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
3657    return ROK;
3658 }
3659
3660
3661 \f
3662 /***********************************************************
3663 *
3664 *     Func : cmUnpkRgrUeSrCfg
3665 *
3666 *
3667 *     Desc : SR configuration parameters information
3668 *
3669 *
3670 *     Ret  : S16
3671 *
3672 *     Notes:
3673 *
3674 *     File  :
3675 *
3676 **********************************************************/
3677 S16 cmUnpkRgrUeSrCfg
3678 (
3679 RgrUeSrCfg *param,
3680 Buffer *mBuf
3681 )
3682 {
3683
3684
3685    CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
3686    CMCHKUNPK(cmUnpkRgrUeSrSetupCfg, &param->srSetup, mBuf);
3687    return ROK;
3688 }
3689
3690
3691 \f
3692 /***********************************************************
3693 *
3694 *     Func : cmPkRgrUeUlSrsCfg
3695 *
3696 *
3697 *     Desc : SRS configuration parameters information.
3698   Reference 36.313 SoundingRS-UL-Config
3699 *
3700 *
3701 *     Ret  : S16
3702 *
3703 *     Notes:
3704 *
3705 *     File  :
3706 *
3707 **********************************************************/
3708 S16 cmPkRgrUeUlSrsCfg
3709 (
3710 RgrUeUlSrsCfg *param,
3711 Buffer *mBuf
3712 )
3713 {
3714
3715
3716    /*rgr_c_001.main_9 DEL removed unwanted comments*/
3717    CMCHKPK(cmPkRgrUeUlSrsSetupCfg, &param->srsSetup, mBuf);
3718    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
3719    return ROK;
3720 }
3721
3722
3723 \f
3724 /***********************************************************
3725 *
3726 *     Func : cmUnpkRgrUeUlSrsCfg
3727 *
3728 *
3729 *     Desc : SRS configuration parameters information.
3730   Reference 36.313 SoundingRS-UL-Config
3731 *
3732 *
3733 *     Ret  : S16
3734 *
3735 *     Notes:
3736 *
3737 *     File  :
3738 *
3739 **********************************************************/
3740 S16 cmUnpkRgrUeUlSrsCfg
3741 (
3742 RgrUeUlSrsCfg *param,
3743 Buffer *mBuf
3744 )
3745 {
3746
3747
3748    CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
3749    /*rgr_c_001.main_9 DEL removed unwanted comments*/
3750    CMCHKUNPK(cmUnpkRgrUeUlSrsSetupCfg, &param->srsSetup, mBuf);
3751    return ROK;
3752 }
3753
3754
3755 #endif /*TFU_UPGRADE */
3756
3757 \f
3758 /***********************************************************
3759 *
3760 *     Func : cmPkRgrUeDlCqiCfg
3761 *
3762 *
3763 *     Desc : Downlink CQI reporting related configuration per UE
3764 *
3765 *
3766 *     Ret  : S16
3767 *
3768 *     Notes:
3769 *
3770 *     File  :
3771 *
3772 **********************************************************/
3773 S16 cmPkRgrUeDlCqiCfg
3774 (
3775 RgrUeDlCqiCfg *param,
3776 Buffer *mBuf
3777 )
3778 {
3779
3780
3781
3782 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
3783 #ifdef TFU_UPGRADE
3784    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
3785 #endif
3786
3787 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
3788 #ifndef TFU_UPGRADE
3789    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
3790 #endif
3791    CMCHKPK(cmPkRgrUeAprdDlCqiCfg, &param->aprdCqiCfg, mBuf);
3792    return ROK;
3793 }
3794
3795
3796 \f
3797 /***********************************************************
3798 *
3799 *     Func : cmUnpkRgrUeDlCqiCfg
3800 *
3801 *
3802 *     Desc : Downlink CQI reporting related configuration per UE
3803 *
3804 *
3805 *     Ret  : S16
3806 *
3807 *     Notes:
3808 *
3809 *     File  :
3810 *
3811 **********************************************************/
3812 S16 cmUnpkRgrUeDlCqiCfg
3813 (
3814 RgrUeDlCqiCfg *param,
3815 Buffer *mBuf
3816 )
3817 {
3818
3819
3820    CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, &param->aprdCqiCfg, mBuf);
3821    CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
3822    return ROK;
3823 }
3824
3825
3826 \f
3827 /***********************************************************
3828 *
3829 *     Func : cmPkRgrUeMeasGapCfg
3830 *
3831 *
3832 *     Desc : Measurement gap configuration for UE
3833 *
3834 *
3835 *     Ret  : S16
3836 *
3837 *     Notes:
3838 *
3839 *     File  :
3840 *
3841 **********************************************************/
3842 S16 cmPkRgrUeMeasGapCfg
3843 (
3844 RgrUeMeasGapCfg *param,
3845 Buffer *mBuf
3846 )
3847 {
3848
3849
3850    CMCHKPK(oduUnpackUInt8, param->gapOffst, mBuf);
3851    CMCHKPK(oduUnpackUInt8, param->gapPrd, mBuf);
3852    CMCHKPK(oduUnpackUInt8, param->isMesGapEnabled, mBuf);
3853    return ROK;
3854 }
3855
3856
3857 \f
3858 /***********************************************************
3859 *
3860 *     Func : cmUnpkRgrUeMeasGapCfg
3861 *
3862 *
3863 *     Desc : Measurement gap configuration for UE
3864 *
3865 *
3866 *     Ret  : S16
3867 *
3868 *     Notes:
3869 *
3870 *     File  :
3871 *
3872 **********************************************************/
3873 S16 cmUnpkRgrUeMeasGapCfg
3874 (
3875 RgrUeMeasGapCfg *param,
3876 Buffer *mBuf
3877 )
3878 {
3879
3880
3881    CMCHKUNPK(oduPackUInt8, &param->isMesGapEnabled, mBuf);
3882    CMCHKUNPK(oduPackUInt8, &param->gapPrd, mBuf);
3883    CMCHKUNPK(oduPackUInt8, &param->gapOffst, mBuf);
3884    return ROK;
3885 }
3886
3887 /*rgr_c_001.main_9 ADD DRX functionality under flag*/
3888 \f
3889 /***********************************************************
3890 *
3891 *     Func : cmPkRgrDrxLongCycleOffst
3892 *
3893 *
3894 *     Desc : DRX Long Cycle Offset
3895 *
3896 *
3897 *     Ret  : S16
3898 *
3899 *     Notes:
3900 *
3901 *     File  :
3902 *
3903 **********************************************************/
3904 S16 cmPkRgrDrxLongCycleOffst
3905 (
3906 RgrDrxLongCycleOffst *param,
3907 Buffer *mBuf
3908 )
3909 {
3910
3911
3912    CMCHKPK(oduUnpackUInt16, param->drxStartOffst, mBuf);
3913    CMCHKPK(oduUnpackUInt16, param->longDrxCycle, mBuf);
3914    return ROK;
3915 }
3916
3917
3918 \f
3919 /***********************************************************
3920 *
3921 *     Func : cmUnpkRgrDrxLongCycleOffst
3922 *
3923 *
3924 *     Desc : DRX Long Cycle Offset
3925 *
3926 *
3927 *     Ret  : S16
3928 *
3929 *     Notes:
3930 *
3931 *     File  :
3932 *
3933 **********************************************************/
3934 S16 cmUnpkRgrDrxLongCycleOffst
3935 (
3936 RgrDrxLongCycleOffst *param,
3937 Buffer *mBuf
3938 )
3939 {
3940
3941
3942    CMCHKUNPK(oduPackUInt16, &param->longDrxCycle, mBuf);
3943    CMCHKUNPK(oduPackUInt16, &param->drxStartOffst, mBuf);
3944    return ROK;
3945 }
3946
3947
3948 \f
3949 /***********************************************************
3950 *
3951 *     Func : cmPkRgrDrxShortDrx
3952 *
3953 *
3954 *     Desc : DRX Short Cycle Offset
3955 *
3956 *
3957 *     Ret  : S16
3958 *
3959 *     Notes:
3960 *
3961 *     File  :
3962 *
3963 **********************************************************/
3964 S16 cmPkRgrDrxShortDrx
3965 (
3966 RgrDrxShortDrx *param,
3967 Buffer *mBuf
3968 )
3969 {
3970
3971
3972    CMCHKPK(oduUnpackUInt8, param->drxShortCycleTmr, mBuf);
3973    CMCHKPK(oduUnpackUInt16, param->shortDrxCycle, mBuf);
3974    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
3975    return ROK;
3976 }
3977
3978
3979 \f
3980 /***********************************************************
3981 *
3982 *     Func : cmUnpkRgrDrxShortDrx
3983 *
3984 *
3985 *     Desc : DRX Short Cycle Offset
3986 *
3987 *
3988 *     Ret  : S16
3989 *
3990 *     Notes:
3991 *
3992 *     File  :
3993 *
3994 **********************************************************/
3995 S16 cmUnpkRgrDrxShortDrx
3996 (
3997 RgrDrxShortDrx *param,
3998 Buffer *mBuf
3999 )
4000 {
4001
4002
4003    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4004    CMCHKUNPK(oduPackUInt16, &param->shortDrxCycle, mBuf);
4005    CMCHKUNPK(oduPackUInt8, &param->drxShortCycleTmr, mBuf);
4006    return ROK;
4007 }
4008 \f
4009 /***********************************************************
4010 *
4011 *     Func : cmPkRgrUeDrxCfg
4012 *
4013 *
4014 *     Desc : DRX configuration for UE
4015 *
4016 *
4017 *     Ret  : S16
4018 *
4019 *     Notes:
4020 *
4021 *     File  :
4022 *
4023 **********************************************************/
4024 S16 cmPkRgrUeDrxCfg
4025 (
4026 RgrUeDrxCfg *param,
4027 Buffer *mBuf
4028 )
4029 {
4030
4031
4032    CMCHKPK(cmPkRgrDrxShortDrx, &param->drxShortDrx, mBuf);
4033    CMCHKPK(cmPkRgrDrxLongCycleOffst, &param->drxLongCycleOffst, mBuf);
4034    CMCHKPK(oduUnpackUInt16, param->drxRetxTmr, mBuf);
4035 #ifdef EMTC_ENABLE
4036    CMCHKPK(oduUnpackUInt8,  param->drxRetxTmrR13Pres, mBuf);
4037    CMCHKPK(oduUnpackUInt8,  param->drxOnDurTmrR13Pres, mBuf);
4038    CMCHKPK(oduUnpackUInt16, param->emtcDrxUlRetxTmr, mBuf);
4039    CMCHKPK(oduUnpackUInt8,  param->isEmtcUe, mBuf);
4040 #endif
4041    CMCHKPK(oduUnpackUInt16, param->drxInactvTmr, mBuf);
4042    CMCHKPK(oduUnpackUInt16, param->drxOnDurTmr, mBuf);
4043 /*rgr_c_001.main_9 ADD added changes for R9*/
4044 #ifdef LTEMAC_R9
4045    CMCHKPK(cmPkTknS32, &param->cqiMask, mBuf);
4046 #endif
4047    return ROK;
4048 }
4049
4050
4051 \f
4052 /***********************************************************
4053 *
4054 *     Func : cmUnpkRgrUeDrxCfg
4055 *
4056 *
4057 *     Desc : DRX configuration for UE
4058 *
4059 *
4060 *     Ret  : S16
4061 *
4062 *     Notes:
4063 *
4064 *     File  :
4065 *
4066 **********************************************************/
4067 S16 cmUnpkRgrUeDrxCfg
4068 (
4069 RgrUeDrxCfg *param,
4070 Buffer *mBuf
4071 )
4072 {
4073
4074
4075 /*rgr_c_001.main_9 ADD added changes for R9*/
4076 #ifdef LTEMAC_R9
4077    CMCHKUNPK(cmUnpkTknS32, &param->cqiMask, mBuf);
4078 #endif
4079    CMCHKUNPK(oduPackUInt16, &param->drxOnDurTmr, mBuf);
4080    CMCHKUNPK(oduPackUInt16, &param->drxInactvTmr, mBuf);
4081 #ifdef EMTC_ENABLE
4082    CMCHKUNPK(oduPackUInt8, &param->isEmtcUe, mBuf);
4083    CMCHKUNPK(oduPackUInt16,&param->emtcDrxUlRetxTmr, mBuf);
4084    CMCHKUNPK(oduPackUInt8, &param->drxOnDurTmrR13Pres, mBuf);
4085    CMCHKUNPK(oduPackUInt8, &param->drxRetxTmrR13Pres, mBuf);
4086 #endif
4087    CMCHKUNPK(oduPackUInt16, &param->drxRetxTmr, mBuf);
4088    CMCHKUNPK(cmUnpkRgrDrxLongCycleOffst, &param->drxLongCycleOffst, mBuf);
4089    CMCHKUNPK(cmUnpkRgrDrxShortDrx, &param->drxShortDrx, mBuf);
4090    return ROK;
4091 }
4092
4093 /*rgr_c_001.main_9 ADD added DRX changes under DRX*/
4094 \f
4095 /***********************************************************
4096 *
4097 *     Func : cmPkRgrUeCapCfg
4098 *
4099 *
4100 *     Desc : RgrUeCapCfg
4101 *
4102 *
4103 *     Ret  : S16
4104 *
4105 *     Notes:
4106 *
4107 *     File  :
4108 *
4109 **********************************************************/
4110 S16 cmPkRgrUeCapCfg
4111 (
4112 RgrUeCapCfg *param,
4113 Buffer *mBuf
4114 )
4115 {
4116
4117
4118    CMCHKPK(oduUnpackUInt8, param->txAntSel, mBuf);
4119    CMCHKPK(oduUnpackUInt8, param->simCqiAckNack, mBuf);
4120    CMCHKPK(oduUnpackUInt8, param->resAloocType1, mBuf);
4121    CMCHKPK(oduUnpackUInt8, param->intraSfFeqHop, mBuf);
4122    CMCHKPK(oduUnpackUInt8, param->pwrClass, mBuf);
4123    return ROK;
4124 }
4125
4126
4127 \f
4128 /***********************************************************
4129 *
4130 *     Func : cmUnpkRgrUeCapCfg
4131 *
4132 *
4133 *     Desc : RgrUeCapCfg
4134 *
4135 *
4136 *     Ret  : S16
4137 *
4138 *     Notes:
4139 *
4140 *     File  :
4141 *
4142 **********************************************************/
4143 S16 cmUnpkRgrUeCapCfg
4144 (
4145 RgrUeCapCfg *param,
4146 Buffer *mBuf
4147 )
4148 {
4149
4150
4151    CMCHKUNPK(oduPackUInt8, &param->pwrClass, mBuf);
4152    CMCHKUNPK(oduPackUInt8, &param->intraSfFeqHop, mBuf);
4153    CMCHKUNPK(oduPackUInt8, &param->resAloocType1, mBuf);
4154    CMCHKUNPK(oduPackUInt8, &param->simCqiAckNack, mBuf);
4155    CMCHKUNPK(oduPackUInt8, &param->txAntSel, mBuf);
4156
4157    return ROK;
4158 }
4159
4160 \f
4161 /***********************************************************
4162 *
4163 *     Func : cmPkRgrUeAckNackRepCfg
4164 *
4165 *
4166 *     Desc : rgrUeAckNackRepCfg
4167 *
4168 *
4169 *     Ret  : S16
4170 *
4171 *     Notes:
4172 *
4173 *     File  :
4174 *
4175 **********************************************************/
4176 S16 cmPkRgrUeAckNackRepCfg
4177 (
4178 RgrUeAckNackRepCfg *param,
4179 Buffer *mBuf
4180 )
4181 {
4182
4183
4184    CMCHKPK(oduUnpackUInt32, param->ackNackRepFactor, mBuf);
4185    CMCHKPK(oduUnpackUInt16, param->pucchAckNackRep, mBuf);
4186    CMCHKPK(oduUnpackUInt8, param->isAckNackEnabled, mBuf);
4187    return ROK;
4188 }
4189
4190
4191 \f
4192 /***********************************************************
4193 *
4194 *     Func : cmUnpkRgrUeAckNackRepCfg
4195 *
4196 *
4197 *     Desc : rgrUeAckNackRepCfg
4198 *
4199 *
4200 *     Ret  : S16
4201 *
4202 *     Notes:
4203 *
4204 *     File  :
4205 *
4206 **********************************************************/
4207 S16 cmUnpkRgrUeAckNackRepCfg
4208 (
4209 RgrUeAckNackRepCfg *param,
4210 Buffer *mBuf
4211 )
4212 {
4213    uint32_t tmpEnum;
4214
4215
4216    CMCHKUNPK(oduPackUInt8, &param->isAckNackEnabled, mBuf);
4217    CMCHKUNPK(oduPackUInt16, &param->pucchAckNackRep, mBuf);
4218    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4219    param->ackNackRepFactor = (RgrAckNackRepFactor) tmpEnum;
4220    return ROK;
4221 }
4222
4223
4224 \f
4225 /***********************************************************
4226 *
4227 *     Func : cmPkRgrUeTxModeCfg
4228 *
4229 *
4230 *     Desc : Transmission mode configuration per UE
4231 *
4232 *
4233 *     Ret  : S16
4234 *
4235 *     Notes:
4236 *
4237 *     File  :
4238 *
4239 **********************************************************/
4240 S16 cmPkRgrUeTxModeCfg
4241 (
4242 RgrUeTxModeCfg *param,
4243 Buffer *mBuf
4244 )
4245 {
4246
4247
4248    CMCHKPK(oduUnpackUInt32, param->txModeEnum, mBuf);
4249    CMCHKPK(oduUnpackUInt32, param->tmTrnstnState, mBuf);
4250    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
4251
4252    return ROK;
4253 }
4254
4255
4256 \f
4257 /***********************************************************
4258 *
4259 *     Func : cmUnpkRgrUeTxModeCfg
4260 *
4261 *
4262 *     Desc : Transmission mode configuration per UE
4263 *
4264 *
4265 *     Ret  : S16
4266 *
4267 *     Notes:
4268 *
4269 *     File  :
4270 *
4271 **********************************************************/
4272 S16 cmUnpkRgrUeTxModeCfg
4273 (
4274 RgrUeTxModeCfg *param,
4275 Buffer *mBuf
4276 )
4277 {
4278    uint32_t tmpEnum;
4279
4280
4281    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4282    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4283    param->tmTrnstnState = (RgrTxModeTrnstn) tmpEnum;
4284
4285    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4286    param->txModeEnum = (RgrTxMode) tmpEnum;
4287    return ROK;
4288 }
4289
4290
4291 \f
4292 /***********************************************************
4293 *
4294 *     Func : cmPkRgrUeUlHqCfg
4295 *
4296 *
4297 *     Desc : Uplink HARQ configuration per UE
4298 *
4299 *
4300 *     Ret  : S16
4301 *
4302 *     Notes:
4303 *
4304 *     File  :
4305 *
4306 **********************************************************/
4307 S16 cmPkRgrUeUlHqCfg
4308 (
4309 RgrUeUlHqCfg *param,
4310 Buffer *mBuf
4311 )
4312 {
4313
4314
4315    CMCHKPK(oduUnpackUInt8, param->deltaHqOffst, mBuf);
4316    CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
4317    return ROK;
4318 }
4319
4320
4321 \f
4322 /***********************************************************
4323 *
4324 *     Func : cmUnpkRgrUeUlHqCfg
4325 *
4326 *
4327 *     Desc : Uplink HARQ configuration per UE
4328 *
4329 *
4330 *     Ret  : S16
4331 *
4332 *     Notes:
4333 *
4334 *     File  :
4335 *
4336 **********************************************************/
4337 S16 cmUnpkRgrUeUlHqCfg
4338 (
4339 RgrUeUlHqCfg *param,
4340 Buffer *mBuf
4341 )
4342 {
4343
4344
4345    CMCHKUNPK(oduPackUInt8, &param->maxUlHqTx, mBuf);
4346    CMCHKUNPK(oduPackUInt8, &param->deltaHqOffst, mBuf);
4347    return ROK;
4348 }
4349
4350
4351 \f
4352 /***********************************************************
4353 *
4354 *     Func : cmPkRgrUeGrpPwrCfg
4355 *
4356 *
4357 *     Desc : Group power configuration per UE for PUCCH and PUSCH group power control
4358 *
4359 *
4360 *     Ret  : S16
4361 *
4362 *     Notes:
4363 *
4364 *     File  :
4365 *
4366 **********************************************************/
4367 S16 cmPkRgrUeGrpPwrCfg
4368 (
4369 RgrUeGrpPwrCfg *param,
4370 Buffer *mBuf
4371 )
4372 {
4373
4374
4375    CMCHKPK(oduUnpackUInt8, param->idx, mBuf);
4376    CMCHKPK(cmPkLteRnti, param->tpcRnti, mBuf);
4377    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
4378    return ROK;
4379 }
4380
4381
4382 \f
4383 /***********************************************************
4384 *
4385 *     Func : cmUnpkRgrUeGrpPwrCfg
4386 *
4387 *
4388 *     Desc : Group power configuration per UE for PUCCH and PUSCH group power control
4389 *
4390 *
4391 *     Ret  : S16
4392 *
4393 *     Notes:
4394 *
4395 *     File  :
4396 *
4397 **********************************************************/
4398 S16 cmUnpkRgrUeGrpPwrCfg
4399 (
4400 RgrUeGrpPwrCfg *param,
4401 Buffer *mBuf
4402 )
4403 {
4404
4405
4406    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4407    CMCHKUNPK(cmUnpkLteRnti, &param->tpcRnti, mBuf);
4408    CMCHKUNPK(oduPackUInt8, &param->idx, mBuf);
4409    return ROK;
4410 }
4411
4412 /*rgr_c_001.main_7 - Added support for SPS*/
4413
4414 \f
4415 /***********************************************************
4416 *
4417 *     Func : cmPkRgrUeSpsDlCfg
4418 *
4419 *
4420 *     Desc : DL SPS configuration parameters per UE
4421 *
4422 *
4423 *     Ret  : S16
4424 *
4425 *     Notes:
4426 *
4427 *     File  :
4428 *
4429 **********************************************************/
4430 S16 cmPkRgrUeSpsDlCfg
4431 (
4432 RgrUeSpsDlCfg *param,
4433 Buffer *mBuf
4434 )
4435 {
4436
4437    S32 i;
4438    CMCHKPK(oduUnpackUInt16, param->explicitRelCnt, mBuf);
4439    CMCHKPK(oduUnpackUInt32, param->dlSpsPrdctyEnum, mBuf);
4440    for (i=param->numPucchVal-1; i >= 0; i--) {
4441       CMCHKPK(oduUnpackUInt32, param->n1PucchVal[i], mBuf);
4442    }
4443    CMCHKPK(oduUnpackUInt8, param->numPucchVal, mBuf);
4444    CMCHKPK(oduUnpackUInt8, param->numSpsHqProc, mBuf);
4445    CMCHKPK(oduUnpackUInt8, param->isDlSpsEnabled, mBuf);
4446    return ROK;
4447 }
4448
4449
4450 \f
4451 /***********************************************************
4452 *
4453 *     Func : cmUnpkRgrUeSpsDlCfg
4454 *
4455 *
4456 *     Desc : DL SPS configuration parameters per UE
4457 *
4458 *
4459 *     Ret  : S16
4460 *
4461 *     Notes:
4462 *
4463 *     File  :
4464 *
4465 **********************************************************/
4466 S16 cmUnpkRgrUeSpsDlCfg
4467 (
4468 RgrUeSpsDlCfg *param,
4469 Buffer *mBuf
4470 )
4471 {
4472    uint32_t tmpEnum;
4473
4474    S32 i;
4475
4476    CMCHKUNPK(oduPackUInt8, &param->isDlSpsEnabled, mBuf);
4477    CMCHKUNPK(oduPackUInt8, &param->numSpsHqProc, mBuf);
4478    CMCHKUNPK(oduPackUInt8, &param->numPucchVal, mBuf);
4479    for (i=0; i<param->numPucchVal; i++) {
4480       CMCHKUNPK(oduPackUInt32, &param->n1PucchVal[i], mBuf);
4481    }
4482    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4483    param->dlSpsPrdctyEnum = tmpEnum;
4484    CMCHKUNPK(oduPackUInt16, &param->explicitRelCnt, mBuf);
4485    return ROK;
4486 }
4487
4488
4489 \f
4490 /***********************************************************
4491 *
4492 *     Func : cmPkRgrUeSpsUlCfg
4493 *
4494 *
4495 *     Desc : UL SPS configuration parameters per UE
4496 *
4497 *
4498 *     Ret  : S16
4499 *
4500 *     Notes:
4501 *
4502 *     File  :
4503 *
4504 **********************************************************/
4505 S16 cmPkRgrUeSpsUlCfg
4506 (
4507 RgrUeSpsUlCfg *param,
4508 Buffer *mBuf
4509 )
4510 {
4511
4512    S32 i;
4513
4514    CMCHKPK(oduUnpackUInt8, param->isLcSRMaskEnab, mBuf);
4515    for (i=param->lcCnt-1; i >= 0; i--) {
4516       /* SPS Changes starts */
4517       CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].isSpsEnabled, mBuf);
4518       CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].lcId, mBuf);
4519       /* SPS Changes ends */
4520    }
4521    CMCHKPK(oduUnpackUInt8, param->lcCnt, mBuf);
4522    CMCHKPK(oduUnpackUInt32, param->ulSpsPrdctyEnum, mBuf);
4523       CMCHKPK(SPkS8, param->pwrCfg.p0UePuschVal, mBuf);
4524       CMCHKPK(SPkS8, param->pwrCfg.p0NominalPuschVal, mBuf);
4525    CMCHKPK(oduUnpackUInt8, param->pwrCfgPres, mBuf);
4526
4527 #ifdef LTE_TDD
4528    CMCHKPK(oduUnpackUInt8, param->twoIntervalCfg, mBuf);
4529
4530 #endif
4531    CMCHKPK(oduUnpackUInt32, param->implicitRelCnt, mBuf);
4532    CMCHKPK(oduUnpackUInt8, param->isUlSpsEnabled, mBuf);
4533    return ROK;
4534 }
4535
4536
4537 \f
4538 /***********************************************************
4539 *
4540 *     Func : cmUnpkRgrUeSpsUlCfg
4541 *
4542 *
4543 *     Desc : UL SPS configuration parameters per UE
4544 *
4545 *
4546 *     Ret  : S16
4547 *
4548 *     Notes:
4549 *
4550 *     File  :
4551 *
4552 **********************************************************/
4553 S16 cmUnpkRgrUeSpsUlCfg
4554 (
4555 RgrUeSpsUlCfg *param,
4556 Buffer *mBuf
4557 )
4558 {
4559    uint32_t tmpEnum;
4560
4561    S32 i;
4562
4563    CMCHKUNPK(oduPackUInt8, &param->isUlSpsEnabled, mBuf);
4564    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4565    param->implicitRelCnt = tmpEnum;
4566
4567 #ifdef LTE_TDD
4568    CMCHKUNPK(oduPackUInt8, &param->twoIntervalCfg, mBuf);
4569
4570 #endif
4571    CMCHKUNPK(oduPackUInt8, &param->pwrCfgPres, mBuf);
4572       CMCHKUNPK(SUnpkS8, &param->pwrCfg.p0NominalPuschVal, mBuf);
4573       CMCHKUNPK(SUnpkS8, &param->pwrCfg.p0UePuschVal, mBuf);
4574    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4575    param->ulSpsPrdctyEnum = tmpEnum;
4576    CMCHKUNPK(oduPackUInt8, &param->lcCnt, mBuf);
4577    for (i=0; i<param->lcCnt; i++) {
4578       CMCHKUNPK(oduPackUInt8, &param->spsLcInfo[i].lcId, mBuf);
4579       CMCHKUNPK(oduPackUInt8, &param->spsLcInfo[i].isSpsEnabled, mBuf);
4580    }
4581    CMCHKUNPK(oduPackUInt8, &param->isLcSRMaskEnab, mBuf);
4582    return ROK;
4583 }
4584
4585
4586 \f
4587 /***********************************************************
4588 *
4589 *     Func : cmPkRgrUeSpsCfg
4590 *
4591 *
4592 *     Desc : SPS configuration parameters per UE
4593 *
4594 *
4595 *     Ret  : S16
4596 *
4597 *     Notes:
4598 *
4599 *     File  :
4600 *
4601 **********************************************************/
4602 S16 cmPkRgrUeSpsCfg
4603 (
4604 RgrUeSpsCfg *param,
4605 Buffer *mBuf
4606 )
4607 {
4608
4609
4610    CMCHKPK(cmPkRgrUeSpsUlCfg, &param->ulSpsCfg, mBuf);
4611    CMCHKPK(cmPkRgrUeSpsDlCfg, &param->dlSpsCfg, mBuf);
4612    CMCHKPK(cmPkLteRnti, param->spsRnti, mBuf);
4613    return ROK;
4614 }
4615
4616
4617 \f
4618 /***********************************************************
4619 *
4620 *     Func : cmUnpkRgrUeSpsCfg
4621 *
4622 *
4623 *     Desc : SPS configuration parameters per UE
4624 *
4625 *
4626 *     Ret  : S16
4627 *
4628 *     Notes:
4629 *
4630 *     File  :
4631 *
4632 **********************************************************/
4633 S16 cmUnpkRgrUeSpsCfg
4634 (
4635 RgrUeSpsCfg *param,
4636 Buffer *mBuf
4637 )
4638 {
4639
4640
4641    CMCHKUNPK(cmUnpkLteRnti, &param->spsRnti, mBuf);
4642    CMCHKUNPK(cmUnpkRgrUeSpsDlCfg, &param->dlSpsCfg, mBuf);
4643    CMCHKUNPK(cmUnpkRgrUeSpsUlCfg, &param->ulSpsCfg, mBuf);
4644    return ROK;
4645 }
4646
4647
4648 /***********************************************************
4649 *
4650 *     Func : cmPkRgrUeUlPwrCfg
4651 *
4652 *
4653 *     Desc : Uplink power configuration per UE
4654 *
4655 *
4656 *     Ret  : S16
4657 *
4658 *     Notes:
4659 *
4660 *     File  :
4661 *
4662 **********************************************************/
4663 S16 cmPkRgrUeUlPwrCfg
4664 (
4665 RgrUeUlPwrCfg *param,
4666 Buffer *mBuf
4667 )
4668 {
4669
4670
4671    CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
4672    CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
4673    CMCHKPK(SPkS8, param->p0UePucch, mBuf);
4674    CMCHKPK(SPkS8, param->p0UePusch, mBuf);
4675    CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
4676    CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
4677    CMCHKPK(cmPkRgrUeGrpPwrCfg, &param->uePucchPwr, mBuf);
4678    CMCHKPK(cmPkRgrUeGrpPwrCfg, &param->uePuschPwr, mBuf);
4679    return ROK;
4680 }
4681
4682
4683 \f
4684 /***********************************************************
4685 *
4686 *     Func : cmUnpkRgrUeUlPwrCfg
4687 *
4688 *
4689 *     Desc : Uplink power configuration per UE
4690 *
4691 *
4692 *     Ret  : S16
4693 *
4694 *     Notes:
4695 *
4696 *     File  :
4697 *
4698 **********************************************************/
4699 S16 cmUnpkRgrUeUlPwrCfg
4700 (
4701 RgrUeUlPwrCfg *param,
4702 Buffer *mBuf
4703 )
4704 {
4705
4706
4707    CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, &param->uePuschPwr, mBuf);
4708    CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, &param->uePucchPwr, mBuf);
4709    CMCHKUNPK(oduPackUInt8, &param->isAccumulated, mBuf);
4710    CMCHKUNPK(oduPackUInt8, &param->isDeltaMCSEnabled, mBuf);
4711    CMCHKUNPK(SUnpkS8, &param->p0UePusch, mBuf);
4712    CMCHKUNPK(SUnpkS8, &param->p0UePucch, mBuf);
4713    CMCHKUNPK(oduPackUInt8, &param->pSRSOffset, mBuf);
4714    CMCHKUNPK(oduPackUInt8, &param->trgCqi, mBuf);
4715    return ROK;
4716 }
4717
4718
4719 \f
4720 /***********************************************************
4721 *
4722 *     Func : cmPkRgrUeQosCfg
4723 *
4724 *
4725 *     Desc : Downlink/Uplink QoS configuration per UE
4726 *
4727 *
4728 *     Ret  : S16
4729 *
4730 *     Notes:
4731 *
4732 *     File  :
4733 *
4734 **********************************************************/
4735 S16 cmPkRgrUeQosCfg
4736 (
4737 RgrUeQosCfg *param,
4738 Buffer *mBuf
4739 )
4740 {
4741
4742
4743    CMCHKPK(oduUnpackUInt32, param->ueBr, mBuf);
4744    CMCHKPK(oduUnpackUInt32, param->dlAmbr, mBuf);
4745    CMCHKPK(oduUnpackUInt8, param->ambrPres, mBuf);
4746    return ROK;
4747 }
4748
4749
4750 \f
4751 /***********************************************************
4752 *
4753 *     Func : cmUnpkRgrUeQosCfg
4754 *
4755 *
4756 *     Desc : Downlink/Uplink QoS configuration per UE
4757 *
4758 *
4759 *     Ret  : S16
4760 *
4761 *     Notes:
4762 *
4763 *     File  :
4764 *
4765 **********************************************************/
4766 S16 cmUnpkRgrUeQosCfg
4767 (
4768 RgrUeQosCfg *param,
4769 Buffer *mBuf
4770 )
4771 {
4772
4773
4774    CMCHKUNPK(oduPackUInt8, &param->ambrPres, mBuf);
4775    CMCHKUNPK(oduPackUInt32, &param->dlAmbr, mBuf);
4776    CMCHKUNPK(oduPackUInt32, &param->ueBr, mBuf);
4777    return ROK;
4778 }
4779
4780 /***********************************************************
4781 *
4782 *     Func : cmPkRgrUePuschDedCfg
4783 *
4784 *
4785 *     Desc : PUSCH Config Dedication for UE
4786 *
4787 *
4788 *     Ret  : S16
4789 *
4790 *     Notes:
4791 *
4792 *     File  :
4793 *
4794 **********************************************************/
4795 S16 cmPkRgrUePuschDedCfg
4796 (
4797 RgrUePuschDedCfg *param,
4798 Buffer *mBuf
4799 )
4800 {
4801
4802
4803    CMCHKPK(oduUnpackUInt8, param->bCQIIdx, mBuf);
4804    CMCHKPK(oduUnpackUInt8, param->bRIIdx, mBuf);
4805    CMCHKPK(oduUnpackUInt8, param->bACKIdx, mBuf);
4806    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
4807    return ROK;
4808 }
4809
4810
4811 /***********************************************************
4812 *
4813 *     Func : cmUnpkRgrUePuschDedCfg
4814 *
4815 *
4816 *     Desc : PUSCH Config Dedication for UE
4817 *
4818 *
4819 *
4820 *     Ret  : S16
4821 *
4822 *     Notes:
4823 *
4824 *     File  :
4825 *
4826 **********************************************************/
4827 S16 cmUnpkRgrUePuschDedCfg
4828 (
4829 RgrUePuschDedCfg *param,
4830 Buffer *mBuf
4831 )
4832 {
4833
4834
4835    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4836    CMCHKUNPK(oduPackUInt8, &param->bACKIdx, mBuf);
4837    CMCHKUNPK(oduPackUInt8, &param->bRIIdx, mBuf);
4838    CMCHKUNPK(oduPackUInt8, &param->bCQIIdx, mBuf);
4839    return ROK;
4840 }
4841
4842 /***********************************************************
4843 *
4844 *     Func : cmPkRgrUeTxAntSelCfg
4845 *
4846 *
4847 *     Desc : UE Transmit Antenna selection related configuration
4848 *
4849 *
4850 *     Ret  : S16
4851 *
4852 *     Notes:
4853 *
4854 *     File  :
4855 *
4856 **********************************************************/
4857 S16 cmPkRgrUeTxAntSelCfg
4858 (
4859 RgrUeTxAntSelCfg *param,
4860 Buffer *mBuf
4861 )
4862 {
4863
4864
4865    CMCHKPK(oduUnpackUInt32, param->selType, mBuf);
4866    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
4867    return ROK;
4868 }
4869
4870
4871 \f
4872 /***********************************************************
4873 *
4874 *     Func : cmUnpkRgrUeTxAntSelCfg
4875 *
4876 *
4877 *     Desc : UE Transmit Antenna selection related configuration
4878 *
4879 *
4880 *     Ret  : S16
4881 *
4882 *     Notes:
4883 *
4884 *     File  :
4885 *
4886 **********************************************************/
4887 S16 cmUnpkRgrUeTxAntSelCfg
4888 (
4889 RgrUeTxAntSelCfg *param,
4890 Buffer *mBuf
4891 )
4892 {
4893    uint32_t tmpEnum;
4894
4895
4896    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4897    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4898    param->selType = (RgrUeTxAntSelType) tmpEnum;
4899    return ROK;
4900 }
4901
4902
4903 /***********************************************************
4904 *
4905 *     Func : cmPkRgrUeTaTmrCfg
4906 *
4907 *
4908 *     Desc : Time Alignment timer configuration per UE
4909 *
4910 *
4911 *     Ret  : S16
4912 *
4913 *     Notes:
4914 *
4915 *     File  :
4916 *
4917 **********************************************************/
4918 S16 cmPkRgrUeTaTmrCfg
4919 (
4920 RgrUeTaTmrCfg *param,
4921 Buffer *mBuf
4922 )
4923 {
4924
4925
4926    CMCHKPK(oduUnpackUInt16, param->taTmr, mBuf);
4927    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
4928    return ROK;
4929 }
4930
4931
4932 \f
4933 /***********************************************************
4934 *
4935 *     Func : cmUnpkRgrUeTaTmrCfg
4936 *
4937 *
4938 *     Desc : Time Alignment timer configuration per UE
4939 *
4940 *
4941 *     Ret  : S16
4942 *
4943 *     Notes:
4944 *
4945 *     File  :
4946 *
4947 **********************************************************/
4948 S16 cmUnpkRgrUeTaTmrCfg
4949 (
4950 RgrUeTaTmrCfg *param,
4951 Buffer *mBuf
4952 )
4953 {
4954
4955
4956    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4957    CMCHKUNPK(oduPackUInt16, &param->taTmr, mBuf);
4958    return ROK;
4959 }
4960
4961
4962 #ifdef EMTC_ENABLE
4963 S16 cmUnpkRgrEmtcUeCfg
4964 (
4965 RgrUeEmtcCfg *param,
4966 Buffer *mBuf
4967 )
4968 {
4969    S32 indx=0;
4970    S32 idx=0;
4971    RgrEpdcchConfigRel11 *emtcEpdcchCfg = &(param->emtcEpdcchCfg);
4972    RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
4973    RgrEpdcchAddModLst *epdcchAddModLst;
4974
4975    CMCHKUNPK(oduPackUInt8,&param->pdschReptLevModeA,mBuf);
4976    /*UnPacking PUCCH Rep */
4977    CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat2),mBuf);
4978    CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat1),mBuf);
4979    CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->isPucchRepPres),mBuf);
4980
4981
4982
4983    for(indx = 0; indx < RGR_MAX_EPDCCH_SET; indx++)
4984    {
4985       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
4986       CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->extaddgrp2.mpddchNB),mBuf);
4987       CMCHKUNPK(oduPackUInt16,&(epdcchAddModLst->extaddgrp2.mpdcchNumRep),mBuf);
4988       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD),mBuf);
4989       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
4990       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
4991       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
4992       CMCHKUNPK(cmUnpkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
4993       CMCHKUNPK(cmUnpkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
4994       CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
4995       CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
4996       for(idx = 0; idx < 5; idx++)
4997       {
4998          CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.rbAssignment[idx]),mBuf);
4999       }
5000
5001       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.numPRBpairs),mBuf);
5002       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->transmissionType),mBuf);
5003       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->setConfigId),mBuf);
5004
5005    }
5006    CMCHKUNPK(cmUnpkTknUInt32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
5007    for(indx = 0; indx < 5; indx++)
5008    {
5009       CMCHKUNPK(oduPackUInt8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
5010    }
5011    CMCHKUNPK(oduPackUInt8, &(emtcEpdcchCfg->sfPtn.pres), mBuf);
5012    CMCHKUNPK(oduPackUInt8, &(param->pres), mBuf);
5013    CMCHKUNPK(oduPackUInt8, &(param->isHdFddEnbld), mBuf);
5014
5015 #ifdef EMTC_DEBUG_CONSOLE_PRINTS
5016    printf("\n EMTC RGR UE unpack\n");
5017    printf("\nemtcEpdcchCfg->sfPtn.pres %d ",emtcEpdcchCfg->sfPtn.pres);
5018
5019    for(indx = 0; indx < 5; indx++)
5020    {
5021       printf("\nemtcEpdcchCfg->sfPtn.measSfPatFDD[%d] %d ",indx,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]);
5022    }
5023    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.pres);
5024    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.val);
5025
5026    for(indx = 0 ; indx < RGR_MAX_EPDCCH_SET; indx++)
5027    {
5028       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
5029       printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.pres);
5030       printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.val);
5031       printf("\nepdcchAddModLst->setConfigId %d ", epdcchAddModLst->setConfigId);
5032       printf("\nepdcchAddModLst->transmissionType %d ",epdcchAddModLst->transmissionType);
5033       printf("\nepdcchAddModLst->resBlkAssignment.numPRBpairs %d ",epdcchAddModLst->resBlkAssignment.numPRBpairs);
5034       for(idx = 0; idx < 5 ; idx++)
5035       {
5036          printf("\nepdcchAddModLst->resBlkAssignment.rbAssignment[idx] %d ",epdcchAddModLst->resBlkAssignment.rbAssignment[idx]);
5037       }
5038       printf("\nepdcchAddModLst->dmrsScrambSeq %d ",epdcchAddModLst->dmrsScrambSeq);
5039       printf("\nepdcchAddModLst->pucchResStartoffset %d ",epdcchAddModLst->pucchResStartoffset);
5040       printf("\nepdcchAddModLst->pdschRemapQLcfgId.pres %d ",epdcchAddModLst->pdschRemapQLcfgId.pres);
5041       printf("\nepdcchAddModLst->pdschRemapQLcfgId.val %d ", epdcchAddModLst->pdschRemapQLcfgId.val);
5042       printf("\nepdcchAddModLst->mpdcchNumPRBpair.pres %d ",  epdcchAddModLst->mpdcchNumPRBpair.pres);
5043       printf("\nepdcchAddModLst->mpdcchNumPRBpair.val %d ",  epdcchAddModLst->mpdcchNumPRBpair.val);
5044       printf("\nepdcchAddModLst->extaddgrp2.pres %d ",       epdcchAddModLst->extaddgrp2.pres);
5045       printf("\nepdcchAddModLst->extaddgrp2.csiNumRep %d ",   epdcchAddModLst->extaddgrp2.csiNumRep);
5046       printf("\nepdcchAddModLst->extaddgrp2.mpddchPdschHop %d ", epdcchAddModLst->extaddgrp2.mpddchPdschHop);
5047       printf("\nepdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD %d ",epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD);
5048       printf("\nepdcchAddModLst->extaddgrp2.mpdcchNumRep %d ", epdcchAddModLst->extaddgrp2.mpdcchNumRep);
5049       printf("\nepdcchAddModLst->extaddgrp2.mpddchNB %d ",  epdcchAddModLst->extaddgrp2.mpddchNB);
5050    }
5051
5052 #endif
5053
5054    return ROK;
5055 }
5056
5057
5058
5059 S16 cmPkRgrEmtcUeCfg
5060 (
5061  RgrUeEmtcCfg *param,
5062  Buffer *mBuf
5063  )
5064 {
5065    S32 indx=0;
5066    S32 idx=0;
5067    RgrEpdcchConfigRel11 *emtcEpdcchCfg = &(param->emtcEpdcchCfg);
5068    RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
5069    RgrEpdcchAddModLst *epdcchAddModLst;
5070
5071    CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
5072    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
5073    CMCHKPK(oduUnpackUInt8, emtcEpdcchCfg->sfPtn.pres, mBuf);
5074    for(indx = 4; indx >=0; indx--)
5075    {
5076       CMCHKPK(oduUnpackUInt8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
5077    }
5078    CMCHKPK(cmPkTknUInt32,&emtcEpdcchCfg->startSymbolr11,mBuf);
5079    for(indx = RGR_MAX_EPDCCH_SET-1 ; indx >= 0; indx--)
5080    {
5081       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
5082
5083       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->setConfigId,mBuf);
5084       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->transmissionType,mBuf);
5085       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.numPRBpairs,mBuf);
5086       for(idx = 4; idx >= 0; idx--)
5087       {
5088          CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.rbAssignment[idx],mBuf);
5089       }
5090       CMCHKPK(oduUnpackUInt32,epdcchAddModLst->dmrsScrambSeq,mBuf);
5091       CMCHKPK(oduUnpackUInt32,epdcchAddModLst->pucchResStartoffset,mBuf);
5092       CMCHKPK(cmPkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
5093       CMCHKPK(cmPkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
5094       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.pres,mBuf);
5095       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
5096       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,mBuf);
5097       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD,mBuf);
5098       CMCHKPK(oduUnpackUInt16,epdcchAddModLst->extaddgrp2.mpdcchNumRep,mBuf);
5099       CMCHKPK(oduUnpackUInt32,epdcchAddModLst->extaddgrp2.mpddchNB,mBuf);
5100    }
5101
5102 /*Packing PUCCH Rep */
5103    CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->isPucchRepPres, mBuf);
5104    CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat1,mBuf);
5105    CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat2,mBuf);
5106    CMCHKPK(oduUnpackUInt8,param->pdschReptLevModeA,mBuf);
5107
5108 #ifdef EMTC_DEBUG_CONSOLE_PRINTS
5109    printf("\n EMTC RGR UE pack\n");
5110    printf("\nemtcEpdcchCfg->sfPtn.pres %d ",emtcEpdcchCfg->sfPtn.pres);
5111
5112    for(indx = 0; indx < 5; indx++)
5113    {
5114       printf("\nemtcEpdcchCfg->sfPtn.measSfPatFDD[%d] %d ",indx,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]);
5115    }
5116    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.pres);
5117    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.val);
5118
5119    for(indx = 0 ; indx < RGR_MAX_EPDCCH_SET; indx++)
5120    {
5121       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
5122      /* printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.pres);
5123       printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.val);*/
5124       printf("\nepdcchAddModLst->setConfigId %d ", epdcchAddModLst->setConfigId);
5125       printf("\nepdcchAddModLst->transmissionType %d ",epdcchAddModLst->transmissionType);
5126       printf("\nepdcchAddModLst->resBlkAssignment.numPRBpairs %d ",epdcchAddModLst->resBlkAssignment.numPRBpairs);
5127       for(idx = 0; idx < 5 ; idx++)
5128       {
5129          printf("\nepdcchAddModLst->resBlkAssignment.rbAssignment[idx] %d ",epdcchAddModLst->resBlkAssignment.rbAssignment[idx]);
5130       }
5131       printf("\nepdcchAddModLst->dmrsScrambSeq %d ",epdcchAddModLst->dmrsScrambSeq);
5132       printf("\nepdcchAddModLst->pucchResStartoffset %d ",epdcchAddModLst->pucchResStartoffset);
5133       printf("\nepdcchAddModLst->pdschRemapQLcfgId.pres %d ",epdcchAddModLst->pdschRemapQLcfgId.pres);
5134       printf("\nepdcchAddModLst->pdschRemapQLcfgId.val %d ", epdcchAddModLst->pdschRemapQLcfgId.val);
5135       printf("\nepdcchAddModLst->mpdcchNumPRBpair.pres %d ",  epdcchAddModLst->mpdcchNumPRBpair.pres);
5136       printf("\nepdcchAddModLst->mpdcchNumPRBpair.val %d ",  epdcchAddModLst->mpdcchNumPRBpair.val);
5137       printf("\nepdcchAddModLst->extaddgrp2.pres %d ",       epdcchAddModLst->extaddgrp2.pres);
5138       printf("\nepdcchAddModLst->extaddgrp2.csiNumRep %d ",   epdcchAddModLst->extaddgrp2.csiNumRep);
5139       printf("\nepdcchAddModLst->extaddgrp2.mpddchPdschHop %d ", epdcchAddModLst->extaddgrp2.mpddchPdschHop);
5140       printf("\nepdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD %d ",epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD);
5141       printf("\nepdcchAddModLst->extaddgrp2.mpdcchNumRep %d ", epdcchAddModLst->extaddgrp2.mpdcchNumRep);
5142       printf("\nepdcchAddModLst->extaddgrp2.mpddchNB %d ",  epdcchAddModLst->extaddgrp2.mpddchNB);
5143    }
5144
5145 #endif
5146
5147
5148
5149    return ROK;
5150 }
5151 #endif
5152
5153 #ifdef RG_5GTF
5154 S16 cmUnpkRgr5gtfUeCfg
5155 (
5156  RgrUe5gtfCfg *param,
5157  Buffer       *mBuf
5158 )
5159 {
5160    CMCHKUNPK(oduPackUInt8, &param->grpId, mBuf);
5161    CMCHKUNPK(oduPackUInt8, &param->BeamId, mBuf);
5162    CMCHKUNPK(oduPackUInt8, &param->numCC, mBuf);
5163    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
5164    CMCHKUNPK(oduPackUInt8, &param->maxPrb, mBuf);
5165    return ROK;
5166 }
5167
5168 S16 cmPkRgr5gtfUeCfg
5169 (
5170  RgrUe5gtfCfg *param,
5171  Buffer       *mBuf
5172 )
5173 {
5174    CMCHKPK(oduUnpackUInt8, param->maxPrb, mBuf);
5175    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
5176    CMCHKPK(oduUnpackUInt8, param->numCC, mBuf);
5177    CMCHKPK(oduUnpackUInt8, param->BeamId, mBuf);
5178    CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
5179    return ROK;
5180 }
5181 #endif
5182
5183 \f
5184 /***********************************************************
5185 *
5186 *     Func : cmPkRgrUeCfg
5187 *
5188 *
5189 *     Desc : UE configuration
5190 *
5191 *
5192 *     Ret  : S16
5193 *
5194 *     Notes:
5195 *
5196 *     File  :
5197 *
5198 **********************************************************/
5199 S16 cmPkRgrUeCfg
5200 (
5201 RgrUeCfg *param,
5202 Buffer *mBuf
5203 )
5204 {
5205
5206 #ifdef RG_5GTF
5207    CMCHKPK(cmPkRgr5gtfUeCfg, &param->ue5gtfCfg, mBuf);
5208 #endif
5209 #ifdef EMTC_ENABLE
5210  CMCHKPK(cmPkRgrEmtcUeCfg, &param->emtcUeCfg, mBuf);
5211 #endif
5212    CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
5213
5214    CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
5215    /* LTE_ADV_FLAG_REMOVED_START */
5216    CMCHKPK(cmPkRgrLteAdvancedUeConfig, &param->ueLteAdvCfg, mBuf);
5217    /* LTE_ADV_FLAG_REMOVED_END */
5218 #ifdef TFU_UPGRADE
5219 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
5220    CMCHKPK(cmPkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
5221 #endif
5222    /*rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
5223    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
5224 #ifdef RGR_CQI_REPT
5225    CMCHKPK(cmPkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
5226 #endif
5227    CMCHKPK(cmPkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
5228
5229 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
5230    CMCHKPK(cmPkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
5231
5232 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
5233 #ifdef LTEMAC_HDFDD
5234    CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
5235 #endif
5236
5237 #ifdef TFU_UPGRADE
5238    CMCHKPK(cmPkRgrUeSrCfg, &param->srCfg, mBuf);
5239    CMCHKPK(cmPkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
5240 #endif
5241
5242
5243
5244    CMCHKPK(cmPkRgrUeSpsCfg, &param->ueSpsCfg, mBuf);
5245
5246 #ifdef LTE_TDD
5247    CMCHKPK(oduUnpackUInt32, param->ackNackModeEnum, mBuf);
5248
5249 #endif
5250    CMCHKPK(cmPkTknUInt8, &param->dedPreambleId, mBuf);
5251    CMCHKPK(cmPkRgrCodeBookRstCfg, &param->ueCodeBookRstCfg, mBuf);
5252    CMCHKPK(cmPkRgrUeCapCfg, &param->ueCapCfg, mBuf);
5253    CMCHKPK(cmPkRgrUeMeasGapCfg, &param->ueMesGapCfg, mBuf);
5254    CMCHKPK(cmPkRgrUeAckNackRepCfg, &param->ueAckNackCfg, mBuf);
5255    CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
5256 /*rgr_c_001.main_9 ADD added changes for DRX*/
5257
5258    /* Anshika - Pack only if DRX is enabled */
5259    if(TRUE == param->ueDrxCfg.isDrxEnabled)
5260    {
5261     CMCHKPK(cmPkRgrUeDrxCfg, &param->ueDrxCfg, mBuf);
5262    }
5263    CMCHKPK(oduUnpackUInt8, param->ueDrxCfg.isDrxEnabled, mBuf); /* This has to be packed even if
5264                                                  DRX is disabled */
5265    CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
5266 #ifdef RGR_V1
5267    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
5268     * retxBSR-timer */
5269    CMCHKPK(cmPkRgrUeBsrTmrCfg, &param->ueBsrTmrCfg, mBuf);
5270 #endif
5271    CMCHKPK(cmPkRgrUeTaTmrCfg, &param->ueTaTmrCfg, mBuf);
5272    CMCHKPK(cmPkRgrUeQosCfg, &param->ueQosCfg, mBuf);
5273    CMCHKPK(cmPkRgrUeUlPwrCfg, &param->ueUlPwrCfg, mBuf);
5274    CMCHKPK(cmPkRgrUeUlHqCfg, &param->ueUlHqCfg, mBuf);
5275    CMCHKPK(cmPkRgrUeDlCqiCfg, &param->ueDlCqiCfg, mBuf);
5276    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
5277    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
5278    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
5279    return ROK;
5280 }
5281
5282
5283 \f
5284 /***********************************************************
5285 *
5286 *     Func : cmUnpkRgrUeCfg
5287 *
5288 *
5289 *     Desc : UE configuration
5290 *
5291 *
5292 *     Ret  : S16
5293 *
5294 *     Notes:
5295 *
5296 *     File  :
5297 *
5298 **********************************************************/
5299 S16 cmUnpkRgrUeCfg
5300 (
5301 RgrUeCfg *param,
5302 Buffer *mBuf
5303 )
5304 {
5305    uint32_t tmpEnum;
5306
5307
5308    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5309    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
5310    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
5311    CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, &param->ueDlCqiCfg, mBuf);
5312    CMCHKUNPK(cmUnpkRgrUeUlHqCfg, &param->ueUlHqCfg, mBuf);
5313    CMCHKUNPK(cmUnpkRgrUeUlPwrCfg, &param->ueUlPwrCfg, mBuf);
5314    CMCHKUNPK(cmUnpkRgrUeQosCfg, &param->ueQosCfg, mBuf);
5315    CMCHKUNPK(cmUnpkRgrUeTaTmrCfg, &param->ueTaTmrCfg, mBuf);
5316 #ifdef RGR_V1
5317    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
5318     * retxBSR-timer */
5319    CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, &param->ueBsrTmrCfg, mBuf);
5320 #endif
5321    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5322    param->ueCatEnum = (CmLteUeCategory) tmpEnum;
5323 /*rgr_c_001.main_9 ADD added changes for DRX*/
5324
5325    /* Anshika - Unpack only if DRX is enabled */
5326    CMCHKUNPK(oduPackUInt8, &param->ueDrxCfg.isDrxEnabled, mBuf);
5327    if(TRUE == param->ueDrxCfg.isDrxEnabled)
5328    {
5329       CMCHKUNPK(cmUnpkRgrUeDrxCfg, &param->ueDrxCfg, mBuf);
5330    }
5331    CMCHKUNPK(oduPackUInt8, &param->isTtiBundlEnabled, mBuf);
5332    CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, &param->ueAckNackCfg, mBuf);
5333    CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, &param->ueMesGapCfg, mBuf);
5334    CMCHKUNPK(cmUnpkRgrUeCapCfg, &param->ueCapCfg, mBuf);
5335    CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, &param->ueCodeBookRstCfg, mBuf);
5336    CMCHKUNPK(cmUnpkTknUInt8, &param->dedPreambleId, mBuf);
5337
5338 #ifdef LTE_TDD
5339    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5340    param->ackNackModeEnum = tmpEnum;
5341
5342 #endif
5343    /*rgr_c_001.main_7 - Added support for SPS*/
5344    CMCHKUNPK(cmUnpkRgrUeSpsCfg, &param->ueSpsCfg, mBuf);
5345
5346 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
5347 #ifdef TFU_UPGRADE
5348    CMCHKUNPK(cmUnpkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
5349    CMCHKUNPK(cmUnpkRgrUeSrCfg, &param->srCfg, mBuf);
5350 #endif
5351 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
5352 #ifdef LTEMAC_HDFDD
5353    CMCHKUNPK(oduPackUInt8, &param->isHdFddEnbld, mBuf);
5354 #endif
5355    CMCHKUNPK(cmUnpkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
5356    CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
5357 /* rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
5358    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
5359 #ifdef RGR_CQI_REPT
5360    CMCHKUNPK(cmUnpkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
5361 #endif
5362 #ifdef TFU_UPGRADE
5363    CMCHKUNPK(cmUnpkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
5364 #endif
5365    /* LTE_ADV_FLAG_REMOVED_START */
5366    CMCHKUNPK(cmUnpkRgrLteAdvancedUeConfig, &param->ueLteAdvCfg, mBuf);
5367    /* LTE_ADV_FLAG_REMOVED_END */
5368    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->accessStratumRls, mBuf);
5369    CMCHKUNPK(oduPackUInt8, &param->csgMmbrSta, mBuf);
5370
5371 #ifdef EMTC_ENABLE
5372  CMCHKUNPK(cmUnpkRgrEmtcUeCfg, &param->emtcUeCfg, mBuf);
5373 #endif
5374
5375 #ifdef RG_5GTF
5376  CMCHKUNPK(cmUnpkRgr5gtfUeCfg, &param->ue5gtfCfg, mBuf);
5377 #endif
5378
5379    return ROK;
5380 }
5381
5382
5383 \f
5384 /***********************************************************
5385 *
5386 *     Func : cmPkRgrLchQosCfg
5387 *
5388 *
5389 *     Desc : QCI, GBR and MBR configuration for dedicated logical channels
5390 *
5391 *
5392 *     Ret  : S16
5393 *
5394 *     Notes:
5395 *
5396 *     File  :
5397 *
5398 **********************************************************/
5399 S16 cmPkRgrLchQosCfg
5400 (
5401 RgrLchQosCfg *param,
5402 Buffer *mBuf
5403 )
5404 {
5405
5406
5407    CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
5408    CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
5409    CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
5410    return ROK;
5411 }
5412
5413
5414 \f
5415 /***********************************************************
5416 *
5417 *     Func : cmUnpkRgrLchQosCfg
5418 *
5419 *
5420 *     Desc : QCI, GBR and MBR configuration for dedicated logical channels
5421 *
5422 *
5423 *     Ret  : S16
5424 *
5425 *     Notes:
5426 *
5427 *     File  :
5428 *
5429 **********************************************************/
5430 S16 cmUnpkRgrLchQosCfg
5431 (
5432 RgrLchQosCfg *param,
5433 Buffer *mBuf
5434 )
5435 {
5436
5437
5438    CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
5439    CMCHKUNPK(oduPackUInt32, &param->gbr, mBuf);
5440    CMCHKUNPK(oduPackUInt32, &param->mbr, mBuf);
5441    return ROK;
5442 }
5443 /*rgr_c_001.main_7 - Added support for SPS*/
5444
5445 \f
5446 /***********************************************************
5447 *
5448 *     Func : cmPkRgrLchSpsCfg
5449 *
5450 *
5451 *     Desc : SPS related configuration for logical channels
5452 *
5453 *
5454 *     Ret  : S16
5455 *
5456 *     Notes:
5457 *
5458 *     File  :
5459 *
5460 **********************************************************/
5461 S16 cmPkRgrLchSpsCfg
5462 (
5463 RgrLchSpsCfg *param,
5464 Buffer *mBuf
5465 )
5466 {
5467
5468
5469    /* SPS_DEV */
5470    CMCHKPK(oduUnpackUInt8, param->isSpsEnabled, mBuf);
5471    return ROK;
5472 }
5473
5474
5475 \f
5476 /***********************************************************
5477 *
5478 *     Func : cmUnpkRgrLchSpsCfg
5479 *
5480 *
5481 *     Desc : SPS related configuration for logical channels
5482 *
5483 *
5484 *     Ret  : S16
5485 *
5486 *     Notes:
5487 *
5488 *     File  :
5489 *
5490 **********************************************************/
5491 S16 cmUnpkRgrLchSpsCfg
5492 (
5493 RgrLchSpsCfg *param,
5494 Buffer *mBuf
5495 )
5496 {
5497
5498
5499    CMCHKUNPK(oduPackUInt8, &param->isSpsEnabled, mBuf);
5500
5501    return ROK;
5502 }
5503
5504
5505 /***********************************************************
5506 *
5507 *     Func : cmPkRgrDlLchCfg
5508 *
5509 *
5510 *     Desc : Logical channel configuration info for downlink logical channels
5511 *
5512 *
5513 *     Ret  : S16
5514 *
5515 *     Notes:
5516 *
5517 *     File  :
5518 *
5519 **********************************************************/
5520 S16 cmPkRgrDlLchCfg
5521 (
5522 RgrDlLchCfg *param,
5523 Buffer *mBuf
5524 )
5525 {
5526
5527 /*rgr_c_001.main_7 - Added support for SPS*/
5528
5529    CMCHKPK(oduUnpackUInt8, param->rlcReorderTmr, mBuf);
5530    CMCHKPK(cmPkRgrLchSpsCfg, &param->dlSpsCfg, mBuf);
5531    CMCHKPK(cmPkRgrLchQosCfg, &param->dlQos, mBuf);
5532    CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
5533    return ROK;
5534 }
5535
5536
5537 \f
5538 /***********************************************************
5539 *
5540 *     Func : cmUnpkRgrDlLchCfg
5541 *
5542 *
5543 *     Desc : Logical channel configuration info for downlink logical channels
5544 *
5545 *
5546 *     Ret  : S16
5547 *
5548 *     Notes:
5549 *
5550 *     File  :
5551 *
5552 **********************************************************/
5553 S16 cmUnpkRgrDlLchCfg
5554 (
5555 RgrDlLchCfg *param,
5556 Buffer *mBuf
5557 )
5558 {
5559
5560
5561    CMCHKUNPK(oduPackUInt8, &param->dlTrchType, mBuf);
5562    CMCHKUNPK(cmUnpkRgrLchQosCfg, &param->dlQos, mBuf);
5563    /*rgr_c_001.main_7 - Added support for SPs*/
5564    CMCHKUNPK(cmUnpkRgrLchSpsCfg, &param->dlSpsCfg, mBuf);
5565    CMCHKUNPK(oduPackUInt8, &param->rlcReorderTmr, mBuf);
5566
5567    return ROK;
5568 }
5569
5570
5571 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
5572 #ifdef LTE_L2_MEAS
5573
5574 \f
5575 /***********************************************************
5576 *
5577 *     Func : cmPkRgrUlLchCfg
5578 *
5579 *
5580 *     Desc : Logical channel configuration information for uplink logical channels
5581 *
5582 *
5583 *     Ret  : S16
5584 *
5585 *     Notes:
5586 *
5587 *     File  :
5588 *
5589 **********************************************************/
5590 S16 cmPkRgrUlLchCfg
5591 (
5592 RgrUlLchCfg *param,
5593 Buffer *mBuf
5594 )
5595 {
5596
5597
5598    CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
5599    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
5600    return ROK;
5601 }
5602
5603
5604 \f
5605 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
5606 /***********************************************************
5607 *
5608 *     Func : cmUnpkRgrUlLchCfg
5609 *
5610 *
5611 *     Desc : Logical channel configuration information for uplink logical channels
5612 *
5613 *
5614 *     Ret  : S16
5615 *
5616 *     Notes:
5617 *
5618 *     File  :
5619 *
5620 **********************************************************/
5621 S16 cmUnpkRgrUlLchCfg
5622 (
5623 RgrUlLchCfg *param,
5624 Buffer *mBuf
5625 )
5626 {
5627
5628
5629    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
5630    CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
5631    return ROK;
5632 }
5633
5634
5635 #endif
5636 \f
5637 /***********************************************************
5638 *
5639 *     Func : cmPkRgrUlLcgCfg
5640 *
5641 *
5642 *     Desc : Logical channel configuration info for uplink logical channels
5643 *
5644 *
5645 *     Ret  : S16
5646 *
5647 *     Notes:
5648 *
5649 *     File  :
5650 *
5651 **********************************************************/
5652 S16 cmPkRgrUlLcgCfg
5653 (
5654 RgrUlLcgCfg *param,
5655 Buffer *mBuf
5656 )
5657 {
5658
5659 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
5660 #ifdef LTE_L2_MEAS
5661    S32 i;
5662 #endif
5663    CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
5664    CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
5665
5666 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
5667 #ifdef LTE_L2_MEAS
5668    for (i = param->numLch - 1; i >= 0; i--)
5669    {
5670       CMCHKPK(cmPkRgrUlLchCfg, &param->lchUlCfg[i], mBuf);
5671    }
5672    CMCHKPK(oduUnpackUInt8, param->numLch, mBuf);
5673 #endif
5674    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
5675    return ROK;
5676 }
5677
5678
5679 \f
5680 /***********************************************************
5681 *
5682 *     Func : cmUnpkRgrUlLcgCfg
5683 *
5684 *
5685 *     Desc : Logical channel configuration info for uplink logical channels
5686 *
5687 *
5688 *     Ret  : S16
5689 *
5690 *     Notes:
5691 *
5692 *     File  :
5693 *
5694 **********************************************************/
5695 S16 cmUnpkRgrUlLcgCfg
5696 (
5697 RgrUlLcgCfg *param,
5698 Buffer *mBuf
5699 )
5700 {
5701
5702 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
5703 #ifdef LTE_L2_MEAS
5704    S32 i;
5705 #endif
5706
5707    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
5708 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
5709 #ifdef LTE_L2_MEAS
5710    CMCHKUNPK(oduPackUInt8, &param->numLch, mBuf);
5711    for (i = 0; i< param->numLch; i++)
5712    {
5713       CMCHKUNPK(cmUnpkRgrUlLchCfg, &param->lchUlCfg[i], mBuf);
5714    }
5715
5716 #endif
5717    CMCHKUNPK(oduPackUInt32, &param->gbr, mBuf);
5718    CMCHKUNPK(oduPackUInt32, &param->mbr, mBuf);
5719    return ROK;
5720 }
5721
5722 S16 cmPkRgrUlLchQciCfg
5723 (
5724 RgrUlLchQciCfg *param,
5725 Buffer *mBuf
5726 )
5727 {
5728    CMCHKPK(oduUnpackUInt8, param->lcId, mBuf);
5729    CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
5730    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
5731    return ROK;
5732 }
5733 S16 cmUnpkRgrUlLchQciCfg
5734 (
5735 RgrUlLchQciCfg *param,
5736 Buffer *mBuf
5737 )
5738 {
5739    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
5740    CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
5741    CMCHKUNPK(oduPackUInt8, &param->lcId, mBuf);
5742    return ROK;
5743 }
5744
5745 \f
5746 /***********************************************************
5747 *
5748 *     Func : cmPkRgrLchCfg
5749 *
5750 *
5751 *     Desc : Logical channel configuration info for dedicated channels
5752 *
5753 *
5754 *     Ret  : S16
5755 *
5756 *     Notes:
5757 *
5758 *     File  :
5759 *
5760 **********************************************************/
5761 S16 cmPkRgrLchCfg
5762 (
5763 RgrLchCfg *param,
5764 Buffer *mBuf
5765 )
5766 {
5767
5768    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
5769    CMCHKPK(cmPkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
5770    CMCHKPK(cmPkRgrDlLchCfg, &param->dlInfo, mBuf);
5771    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
5772    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
5773    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
5774    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
5775    return ROK;
5776 }
5777
5778
5779 \f
5780 /***********************************************************
5781 *
5782 *     Func : cmUnpkRgrLchCfg
5783 *
5784 *
5785 *     Desc : Logical channel configuration info for dedicated channels
5786 *
5787 *
5788 *     Ret  : S16
5789 *
5790 *     Notes:
5791 *
5792 *     File  :
5793 *
5794 **********************************************************/
5795 S16 cmUnpkRgrLchCfg
5796 (
5797 RgrLchCfg *param,
5798 Buffer *mBuf
5799 )
5800 {
5801
5802
5803    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5804    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
5805    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
5806    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
5807    CMCHKUNPK(cmUnpkRgrDlLchCfg, &param->dlInfo, mBuf);
5808    CMCHKUNPK(cmUnpkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
5809    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
5810    return ROK;
5811 }
5812
5813
5814 S16 cmPkRgrLcgCfg
5815 (
5816 RgrLcgCfg *param,
5817 Buffer *mBuf
5818 )
5819 {
5820
5821
5822    CMCHKPK(cmPkRgrUlLcgCfg, &param->ulInfo, mBuf);
5823    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
5824    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
5825    return ROK;
5826 }
5827
5828
5829 S16 cmUnpkRgrLcgCfg
5830 (
5831 RgrLcgCfg *param,
5832 Buffer *mBuf
5833 )
5834 {
5835
5836
5837    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
5838    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
5839    CMCHKUNPK(cmUnpkRgrUlLcgCfg, &param->ulInfo, mBuf);
5840    return ROK;
5841 }
5842
5843
5844 \f
5845 /***********************************************************
5846 *
5847 *     Func : cmPkRgrCfg
5848 *
5849 *
5850 *     Desc : Basic Configuration structure at RRM
5851 *
5852 *
5853 *     Ret  : S16
5854 *
5855 *     Notes:
5856 *
5857 *     File  :
5858 *
5859 **********************************************************/
5860 S16 cmPkRgrCfg
5861 (
5862 RgrCfg *param,
5863 Buffer *mBuf
5864 )
5865 {
5866
5867
5868       switch(param->cfgType) {
5869          case RGR_LCG_CFG:
5870             CMCHKPK(cmPkRgrLcgCfg, &param->u.lcgCfg, mBuf);
5871             break;
5872          case RGR_LCH_CFG:
5873             CMCHKPK(cmPkRgrLchCfg, &param->u.lchCfg, mBuf);
5874             break;
5875          case RGR_UE_CFG:
5876             CMCHKPK(cmPkRgrUeCfg, &param->u.ueCfg, mBuf);
5877             break;
5878          case RGR_CELL_CFG:
5879             CMCHKPK(cmPkRgrCellCfg, &param->u.cellCfg, mBuf);
5880             break;
5881          case MAC_GNB_CFG:
5882             CMCHKPK(cmPkMacSchedGnbCfg, &param->u.schedGnbCfg, mBuf);
5883             break;
5884          default :
5885             return RFAILED;
5886       }
5887    CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
5888    return ROK;
5889 }
5890
5891
5892 \f
5893 /***********************************************************
5894 *
5895 *     Func : cmUnpkRgrCfg
5896 *
5897 *
5898 *     Desc : Basic Configuration structure at RRM
5899 *
5900 *
5901 *     Ret  : S16
5902 *
5903 *     Notes:
5904 *
5905 *     File  :
5906 *
5907 **********************************************************/
5908 S16 cmUnpkRgrCfg
5909 (
5910 RgrCfg *param,
5911 Buffer *mBuf
5912 )
5913 {
5914
5915
5916    CMCHKUNPK(oduPackUInt8, &param->cfgType, mBuf);
5917       switch(param->cfgType) {
5918          case MAC_GNB_CFG:
5919             CMCHKUNPK(cmUnpkMacSchedGnbCfg, &param->u.schedGnbCfg, mBuf);
5920             break;
5921          case RGR_CELL_CFG:
5922             CMCHKUNPK(cmUnpkRgrCellCfg, &param->u.cellCfg, mBuf);
5923             break;
5924          case RGR_UE_CFG:
5925             CMCHKUNPK(cmUnpkRgrUeCfg, &param->u.ueCfg, mBuf);
5926             break;
5927          case RGR_LCH_CFG:
5928             CMCHKUNPK(cmUnpkRgrLchCfg, &param->u.lchCfg, mBuf);
5929             break;
5930          case RGR_LCG_CFG:
5931             CMCHKUNPK(cmUnpkRgrLcgCfg, &param->u.lcgCfg, mBuf);
5932             break;
5933          default :
5934             return RFAILED;
5935       }
5936    return ROK;
5937 }
5938
5939
5940 \f
5941 /***********************************************************
5942 *
5943 *     Func : cmPkRgrActvTime
5944 *
5945 *
5946 *     Desc : Activation time information
5947 *
5948 *
5949 *     Ret  : S16
5950 *
5951 *     Notes:
5952 *
5953 *     File  :
5954 *
5955 **********************************************************/
5956 S16 cmPkRgrActvTime
5957 (
5958 RgrActvTime *param,
5959 Buffer *mBuf
5960 )
5961 {
5962
5963
5964    CMCHKPK(cmPkLteTimingInfo, &param->actvTime, mBuf);
5965    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
5966    return ROK;
5967 }
5968
5969
5970 \f
5971 /***********************************************************
5972 *
5973 *     Func : cmUnpkRgrActvTime
5974 *
5975 *
5976 *     Desc : Activation time information
5977 *
5978 *
5979 *     Ret  : S16
5980 *
5981 *     Notes:
5982 *
5983 *     File  :
5984 *
5985 **********************************************************/
5986 S16 cmUnpkRgrActvTime
5987 (
5988 RgrActvTime *param,
5989 Buffer *mBuf
5990 )
5991 {
5992
5993
5994    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
5995    CMCHKUNPK(cmUnpkLteTimingInfo, &param->actvTime, mBuf);
5996    return ROK;
5997 }
5998
5999
6000 \f
6001 /***********************************************************
6002 *
6003 *     Func : cmPkRgrCellRecfg
6004 *
6005 *
6006 *     Desc : Cell reconfiguration structure at RRM
6007 *
6008 *
6009 *     Ret  : S16
6010 *
6011 *     Notes:
6012 *
6013 *     File  :
6014 *
6015 **********************************************************/
6016 S16 cmPkRgrCellRecfg
6017 (
6018 RgrCellRecfg *param,
6019 Buffer *mBuf
6020 )
6021 {
6022
6023    CMCHKPK(cmPkRgrCellCntrlCmdCfg, &param->cntrlCmdCfg, mBuf);
6024    CMCHKPK(cmPkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
6025    CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
6026    CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
6027    /* LTE_ADV_FLAG_REMOVED_START */
6028    CMCHKPK(cmPkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
6029    /* LTE_ADV_FLAG_REMOVED_END */
6030    CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
6031    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
6032 #ifdef RGR_SI_SCH
6033    CMCHKPK(cmPkRgrSiCfg, &param->siReCfg, mBuf);
6034 #endif /* RGR_SI_SCH */
6035    CMCHKPK(cmPkRgrDlfsCfg, &param->dlfsRecfg, mBuf);
6036    CMCHKPK(cmPkRgrRachCfg, &param->rachRecfg, mBuf);
6037    CMCHKPK(cmPkRgrSrsCfg, &param->srsRecfg, mBuf);
6038    CMCHKPK(cmPkRgrPucchCfg, &param->pucchRecfg, mBuf);
6039    CMCHKPK(cmPkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
6040    CMCHKPK(cmPkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
6041    CMCHKPK(cmPkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
6042    CMCHKPK(cmPkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
6043    CMCHKPK(cmPkRgrCfiCfg, &param->cfiRecfg, mBuf);
6044    CMCHKPK(cmPkRgrDlHqCfg, &param->dlHqRecfg, mBuf);
6045    CMCHKPK(cmPkRgrActvTime, &param->recfgActvTime, mBuf);
6046    CMCHKPK(oduUnpackUInt32, param->recfgTypes, mBuf);
6047    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
6048    return ROK;
6049 }
6050
6051
6052 \f
6053 /***********************************************************
6054 *
6055 *     Func : cmUnpkRgrCellRecfg
6056 *
6057 *
6058 *     Desc : Cell reconfiguration structure at RRM
6059 *
6060 *
6061 *     Ret  : S16
6062 *
6063 *     Notes:
6064 *
6065 *     File  :
6066 *
6067 **********************************************************/
6068 S16 cmUnpkRgrCellRecfg
6069 (
6070 RgrCellRecfg *param,
6071 Buffer *mBuf
6072 )
6073 {
6074
6075
6076    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
6077    CMCHKUNPK(oduPackUInt32, &param->recfgTypes, mBuf);
6078    CMCHKUNPK(cmUnpkRgrActvTime, &param->recfgActvTime, mBuf);
6079    CMCHKUNPK(cmUnpkRgrDlHqCfg, &param->dlHqRecfg, mBuf);
6080    CMCHKUNPK(cmUnpkRgrCfiCfg, &param->cfiRecfg, mBuf);
6081    CMCHKUNPK(cmUnpkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
6082    CMCHKUNPK(cmUnpkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
6083    CMCHKUNPK(cmUnpkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
6084    CMCHKUNPK(cmUnpkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
6085    CMCHKUNPK(cmUnpkRgrPucchCfg, &param->pucchRecfg, mBuf);
6086    CMCHKUNPK(cmUnpkRgrSrsCfg, &param->srsRecfg, mBuf);
6087    CMCHKUNPK(cmUnpkRgrRachCfg, &param->rachRecfg, mBuf);
6088    CMCHKUNPK(cmUnpkRgrDlfsCfg, &param->dlfsRecfg, mBuf);
6089    /* rgr_c_001.main_4-MOD-Modified for SI Enhancement. */
6090 #ifdef RGR_SI_SCH
6091    CMCHKUNPK(cmUnpkRgrSiCfg, &param->siReCfg, mBuf);
6092 #endif /* RGR_SI_SCH */
6093    CMCHKUNPK(oduPackUInt16, &param->t300TmrVal, mBuf);
6094    /* LTE_ADV_FLAG_REMOVED_START */
6095    CMCHKUNPK(cmUnpkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
6096    /* LTE_ADV_FLAG_REMOVED_END */
6097    CMCHKUNPK(oduPackUInt8, &param->isAutoCfgModeEnb, mBuf);
6098    CMCHKUNPK(oduPackUInt8, &param->isDynCfiEnb, mBuf);
6099    CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
6100    CMCHKUNPK(cmUnpkRgrCellCntrlCmdCfg, &param->cntrlCmdCfg, mBuf);
6101
6102    return ROK;
6103 }
6104
6105
6106 \f
6107 /***********************************************************
6108 *
6109 *     Func : cmPkRgrUeRecfg
6110 *
6111 *
6112 *     Desc : UE reconfiguration info
6113 *
6114 *
6115 *     Ret  : S16
6116 *
6117 *     Notes:
6118 *
6119 *     File  :
6120 *
6121 **********************************************************/
6122 S16 cmPkRgrUeRecfg
6123 (
6124 RgrUeRecfg *param,
6125 Buffer *mBuf
6126 )
6127 {
6128
6129 #ifdef EMTC_ENABLE
6130    /* Note: As we add more members to emtcUeRecfg,
6131       create a new function for pkUnpk */
6132    CMCHKPK(oduUnpackUInt8, param->emtcUeRecfg.isHdFddEnbld, mBuf);
6133 #endif
6134    CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
6135
6136    CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
6137 #ifdef LTE_ADV
6138    CMCHKPK(oduUnpackUInt8, param->simulAckNackCQIFormat3, mBuf);
6139    CMCHKPK(cmPkRgrUeSCellAckPucchCfg, &param->sCellAckN1ResCfg,mBuf);
6140    CMCHKPK(cmPkRgrUeSecCellInfo, &param->ueSCellCfgInfo,mBuf);
6141 #endif
6142    /* LTE_ADV_FLAG_REMOVED_START */
6143    CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isUeCellEdge, mBuf);
6144    CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isAbsUe, mBuf);
6145    CMCHKPK(oduUnpackUInt32, param->ueLteAdvCfg.pres, mBuf);
6146    /* LTE_ADV_FLAG_REMOVED_END */
6147    /*ccpu00130497: Removed the duplicate packing*/
6148 #ifdef TFU_UPGRADE
6149    CMCHKPK(cmPkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
6150 #endif
6151    /* rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
6152    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
6153 #ifdef RGR_CQI_REPT
6154    CMCHKPK(cmPkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
6155 #endif
6156
6157 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
6158    CMCHKPK(cmPkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
6159
6160 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
6161 #ifdef LTEMAC_HDFDD
6162    CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
6163 #endif
6164
6165 #ifdef TFU_UPGRADE
6166    CMCHKPK(cmPkRgrUeSrCfg, &param->srCfg, mBuf);
6167    CMCHKPK(cmPkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
6168    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->cqiCfg, mBuf);
6169 #endif
6170
6171    /*rgr_c_001.main_7 - Added support for SPS*/
6172    CMCHKPK(cmPkRgrUeSpsCfg, &param->ueSpsRecfg, mBuf);
6173    CMCHKPK(cmPkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
6174
6175    /* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
6176    CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
6177
6178    CMCHKPK(cmPkRgrCodeBookRstCfg, &param->ueCodeBookRstRecfg, mBuf);
6179    CMCHKPK(cmPkRgrUeMeasGapCfg, &param->ueMeasGapRecfg, mBuf);
6180    CMCHKPK(cmPkRgrUeCapCfg, &param->ueCapRecfg, mBuf);
6181    CMCHKPK(cmPkRgrUeAckNackRepCfg, &param->ueAckNackRecfg, mBuf);
6182    CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
6183 /*rgr_c_001.main_9 ADD added changes for DRX*/
6184
6185    /* Anshika - Pack only if DRX is enabled */
6186    if(TRUE == param->ueDrxRecfg.isDrxEnabled)
6187    {
6188       CMCHKPK(cmPkRgrUeDrxCfg, &param->ueDrxRecfg, mBuf);
6189    }
6190    CMCHKPK(oduUnpackUInt8, param->ueDrxRecfg.isDrxEnabled, mBuf); /* This has to be packed even if
6191                                                  DRX is disabled */
6192    CMCHKPK(cmPkRgrUeUlPwrCfg, &param->ueUlPwrRecfg, mBuf);
6193 #ifdef RGR_V1
6194    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
6195     * retxBSR-timer */
6196    CMCHKPK(cmPkRgrUeBsrTmrCfg, &param->ueBsrTmrRecfg, mBuf);
6197 #endif
6198    CMCHKPK(cmPkRgrUeTaTmrCfg, &param->ueTaTmrRecfg, mBuf);
6199    CMCHKPK(cmPkRgrUeQosCfg, &param->ueQosRecfg, mBuf);
6200    CMCHKPK(cmPkRgrUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
6201
6202 #ifndef TFU_UPGRADE
6203    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->prdDlCqiRecfg, mBuf);
6204 #endif
6205
6206    CMCHKPK(cmPkRgrUeAprdDlCqiCfg, &param->aprdDlCqiRecfg, mBuf);
6207    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
6208    /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
6209    /* LTE_ADV_FLAG_REMOVED_START */
6210    /* KW fix for LTE_ADV */
6211    CMCHKPK(oduUnpackUInt32, param->ueRecfgTypes, mBuf);
6212    /* LTE_ADV_FLAG_REMOVED_END */
6213    CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
6214    CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
6215    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
6216    return ROK;
6217 }
6218
6219
6220 \f
6221 /***********************************************************
6222 *
6223 *     Func : cmUnpkRgrUeRecfg
6224 *
6225 *
6226 *     Desc : UE reconfiguration info
6227 *
6228 *
6229 *     Ret  : S16
6230 *
6231 *     Notes:
6232 *
6233 *     File  :
6234 *
6235 **********************************************************/
6236 S16 cmUnpkRgrUeRecfg
6237 (
6238 RgrUeRecfg *param,
6239 Buffer *mBuf
6240 )
6241 {
6242    uint32_t tmpEnum;
6243
6244
6245    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
6246    CMCHKUNPK(cmUnpkLteRnti, &param->oldCrnti, mBuf);
6247    CMCHKUNPK(cmUnpkLteRnti, &param->newCrnti, mBuf);
6248    /* LTE_ADV_FLAG_REMOVED_START */
6249    /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
6250    /* KW fix for LTE_ADV */
6251    CMCHKUNPK(oduPackUInt32, &param->ueRecfgTypes, mBuf);
6252    /* LTE_ADV_FLAG_REMOVED_END */
6253    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
6254
6255    CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, &param->aprdDlCqiRecfg, mBuf);
6256
6257 #ifndef TFU_UPGRADE
6258    CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, &param->prdDlCqiRecfg, mBuf);
6259 #endif
6260
6261    CMCHKUNPK(cmUnpkRgrUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
6262    CMCHKUNPK(cmUnpkRgrUeQosCfg, &param->ueQosRecfg, mBuf);
6263    CMCHKUNPK(cmUnpkRgrUeTaTmrCfg, &param->ueTaTmrRecfg, mBuf);
6264 #ifdef RGR_V1
6265    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
6266     * retxBSR-timer */
6267    CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, &param->ueBsrTmrRecfg, mBuf);
6268 #endif
6269    CMCHKUNPK(cmUnpkRgrUeUlPwrCfg, &param->ueUlPwrRecfg, mBuf);
6270 /*rgr_c_001.main_9 ADD added changes for DRX*/
6271
6272    /* Anshika - Unpack only if DRX is enabled */
6273    CMCHKUNPK(oduPackUInt8, &param->ueDrxRecfg.isDrxEnabled, mBuf);
6274    if(TRUE == param->ueDrxRecfg.isDrxEnabled)
6275    {
6276       CMCHKUNPK(cmUnpkRgrUeDrxCfg, &param->ueDrxRecfg, mBuf);
6277    }
6278    CMCHKUNPK(oduPackUInt8, &param->isTtiBundlEnabled, mBuf);
6279    CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, &param->ueAckNackRecfg, mBuf);
6280    CMCHKUNPK(cmUnpkRgrUeCapCfg, &param->ueCapRecfg, mBuf);
6281    CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, &param->ueMeasGapRecfg, mBuf);
6282    CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, &param->ueCodeBookRstRecfg, mBuf);
6283 /* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
6284    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
6285    param->ueCatEnum = (CmLteUeCategory) tmpEnum;
6286    CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
6287    /*rgr_c_001.main_7 - Added support for SPS*/
6288    CMCHKUNPK(cmUnpkRgrUeSpsCfg, &param->ueSpsRecfg, mBuf);
6289
6290 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
6291 #ifdef TFU_UPGRADE
6292    CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, &param->cqiCfg, mBuf);
6293    CMCHKUNPK(cmUnpkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
6294    CMCHKUNPK(cmUnpkRgrUeSrCfg, &param->srCfg, mBuf);
6295 #endif
6296
6297 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
6298 #ifdef LTEMAC_HDFDD
6299    CMCHKUNPK(oduPackUInt8, &param->isHdFddEnbld, mBuf);
6300 #endif
6301
6302    CMCHKUNPK(cmUnpkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
6303
6304 /* rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
6305    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
6306 #ifdef RGR_CQI_REPT
6307    CMCHKUNPK(cmUnpkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
6308 #endif
6309 #ifdef TFU_UPGRADE
6310    CMCHKUNPK(cmUnpkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
6311 #endif
6312
6313    /* LTE_ADV_FLAG_REMOVED_START */
6314    CMCHKUNPK(oduPackUInt32, &param->ueLteAdvCfg.pres, mBuf);
6315    CMCHKUNPK(oduPackUInt8, &param->ueLteAdvCfg.isAbsUe, mBuf);
6316    CMCHKUNPK(oduPackUInt8, &param->ueLteAdvCfg.isUeCellEdge, mBuf);
6317    /* LTE_ADV_FLAG_REMOVED_END */
6318 #ifdef LTE_ADV
6319    CMCHKUNPK(cmUnpkRgrUeSecCellInfo, &param->ueSCellCfgInfo,mBuf);
6320    CMCHKUNPK(cmUnpkRgrUeSCellAckPucchCfg, &param->sCellAckN1ResCfg,mBuf);
6321    CMCHKUNPK(oduPackUInt8, &param->simulAckNackCQIFormat3, mBuf);
6322 #endif
6323    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->accessStratumRls, mBuf);
6324
6325    CMCHKUNPK(oduPackUInt8, &param->csgMmbrSta, mBuf);
6326 #ifdef EMTC_ENABLE
6327    CMCHKPK(oduPackUInt8, &param->emtcUeRecfg.isHdFddEnbld, mBuf);
6328 #endif
6329
6330    return ROK;
6331 }
6332
6333
6334 \f
6335 /***********************************************************
6336 *
6337 *     Func : cmPkRgrLchRecfg
6338 *
6339 *
6340 *     Desc : Logical channel reconfiguration info for dedicated channels only
6341 *
6342 *
6343 *     Ret  : S16
6344 *
6345 *     Notes:
6346 *
6347 *     File  :
6348 *
6349 **********************************************************/
6350 S16 cmPkRgrLchRecfg
6351 (
6352 RgrLchRecfg *param,
6353 Buffer *mBuf
6354 )
6355 {
6356
6357 /*rgr_c_001.main_7 - Added support for SPS*/
6358    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
6359
6360    CMCHKPK(cmPkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
6361    CMCHKPK(cmPkRgrLchSpsCfg, &param->dlRecfg.dlSpsRecfg, mBuf);
6362
6363    CMCHKPK(cmPkRgrLchQosCfg, &param->dlRecfg.dlQos, mBuf);
6364    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
6365    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
6366    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
6367    return ROK;
6368 }
6369
6370
6371 \f
6372 /***********************************************************
6373 *
6374 *     Func : cmUnpkRgrLchRecfg
6375 *
6376 *
6377 *     Desc : Logical channel reconfiguration info for dedicated channels only
6378 *
6379 *
6380 *     Ret  : S16
6381 *
6382 *     Notes:
6383 *
6384 *     File  :
6385 *
6386 **********************************************************/
6387 S16 cmUnpkRgrLchRecfg
6388 (
6389 RgrLchRecfg *param,
6390 Buffer *mBuf
6391 )
6392 {
6393
6394
6395    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
6396    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
6397    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
6398    CMCHKUNPK(cmUnpkRgrLchQosCfg, &param->dlRecfg.dlQos, mBuf);
6399       /*rgr_c_001.main_7 - Added support for SPs*/
6400    CMCHKUNPK(cmUnpkRgrLchSpsCfg, &param->dlRecfg.dlSpsRecfg, mBuf);
6401
6402    CMCHKUNPK(cmUnpkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
6403    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
6404    return ROK;
6405 }
6406
6407
6408 S16 cmPkRgrLcgRecfg
6409 (
6410 RgrLcgRecfg *param,
6411 Buffer *mBuf
6412 )
6413 {
6414 #ifdef RG_UNUSED
6415    S32 i;
6416 #endif
6417
6418    CMCHKPK(oduUnpackUInt32, param->ulRecfg.mbr, mBuf);
6419    CMCHKPK(oduUnpackUInt32, param->ulRecfg.gbr, mBuf);
6420 #ifdef RG_UNUSED
6421    for (i = param->ulRecfg.numLch - 1; i >= 0; i--)
6422    {
6423       CMCHKPK(cmPkRgrUlLchCfg, &param->ulRecfg.lchUlCfg[i], mBuf);
6424    }
6425    CMCHKPK(oduUnpackUInt8, param->ulRecfg.numLch, mBuf);
6426 #endif
6427    CMCHKPK(oduUnpackUInt8, param->ulRecfg.lcgId, mBuf);
6428    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
6429    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
6430    return ROK;
6431 }
6432
6433
6434 S16 cmUnpkRgrLcgRecfg
6435 (
6436 RgrLcgRecfg *param,
6437 Buffer *mBuf
6438 )
6439 {
6440 #ifdef RG_UNUSED
6441    S32 i;
6442 #endif
6443
6444    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
6445    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
6446    CMCHKUNPK(oduPackUInt8, &param->ulRecfg.lcgId, mBuf);
6447
6448 #ifdef RG_UNUSED
6449    CMCHKUNPK(oduPackUInt8, &param->ulRecfg.numLch, mBuf);
6450    for (i = 0; i < param->ulRecfg.numLch; i++)
6451    {
6452       CMCHKUNPK(cmUnpkRgrUlLchCfg, &param->ulRecfg.lchUlCfg[i], mBuf);
6453    }
6454 #endif
6455    CMCHKUNPK(oduPackUInt32, &param->ulRecfg.gbr, mBuf);
6456    CMCHKUNPK(oduPackUInt32, &param->ulRecfg.mbr, mBuf);
6457
6458    return ROK;
6459 }
6460
6461
6462 \f
6463 /***********************************************************
6464 *
6465 *     Func : cmPkRgrRecfg
6466 *
6467 *
6468 *     Desc : Basic reconfiguration structure at RRM
6469 *
6470 *
6471 *     Ret  : S16
6472 *
6473 *     Notes:
6474 *
6475 *     File  :
6476 *
6477 **********************************************************/
6478 S16 cmPkRgrRecfg
6479 (
6480 RgrRecfg *param,
6481 Buffer *mBuf
6482 )
6483 {
6484
6485
6486       switch(param->recfgType) {
6487          case RGR_LCG_CFG:
6488             CMCHKPK(cmPkRgrLcgRecfg, &param->u.lcgRecfg, mBuf);
6489             break;
6490          case RGR_LCH_CFG:
6491             CMCHKPK(cmPkRgrLchRecfg, &param->u.lchRecfg, mBuf);
6492             break;
6493          case RGR_UE_CFG:
6494             CMCHKPK(cmPkRgrUeRecfg, &param->u.ueRecfg, mBuf);
6495             break;
6496          case RGR_CELL_CFG:
6497             CMCHKPK(cmPkRgrCellRecfg, &param->u.cellRecfg, mBuf);
6498             break;
6499          default :
6500             return RFAILED;
6501       }
6502    CMCHKPK(oduUnpackUInt8, param->recfgType, mBuf);
6503    return ROK;
6504 }
6505
6506
6507 \f
6508 /***********************************************************
6509 *
6510 *     Func : cmUnpkRgrRecfg
6511 *
6512 *
6513 *     Desc : Basic reconfiguration structure at RRM
6514 *
6515 *
6516 *     Ret  : S16
6517 *
6518 *     Notes:
6519 *
6520 *     File  :
6521 *
6522 **********************************************************/
6523 S16 cmUnpkRgrRecfg
6524 (
6525 RgrRecfg *param,
6526 Buffer *mBuf
6527 )
6528 {
6529
6530
6531    CMCHKUNPK(oduPackUInt8, &param->recfgType, mBuf);
6532       switch(param->recfgType) {
6533          case RGR_CELL_CFG:
6534             CMCHKUNPK(cmUnpkRgrCellRecfg, &param->u.cellRecfg, mBuf);
6535             break;
6536          case RGR_UE_CFG:
6537             CMCHKUNPK(cmUnpkRgrUeRecfg, &param->u.ueRecfg, mBuf);
6538             break;
6539          case RGR_LCH_CFG:
6540             CMCHKUNPK(cmUnpkRgrLchRecfg, &param->u.lchRecfg, mBuf);
6541             break;
6542          case RGR_LCG_CFG:
6543             CMCHKUNPK(cmUnpkRgrLcgRecfg, &param->u.lcgRecfg, mBuf);
6544             break;
6545          default :
6546             return RFAILED;
6547       }
6548    return ROK;
6549 }
6550
6551 #ifdef LTE_ADV
6552 /***********************************************************
6553 *
6554 *     Func : cmPkRgrUeDlSecCellRelInfo
6555 *
6556 *
6557 *     Desc : DL Secondary Cell information of the UE
6558 *
6559 *
6560 *     Ret  : S16
6561 *
6562 *     Notes:
6563 *
6564 *     File  :
6565 *
6566 **********************************************************/
6567 S16 cmPkRgrUeDlSecCellRelInfo
6568 (
6569 RgrUeDlSecCellRelInfo *param,
6570 Buffer *mBuf
6571 )
6572 {
6573    CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
6574    CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
6575    return ROK;
6576 }
6577 \f
6578 /***********************************************************
6579 *
6580 *     Func : cmPkRgrUeSecCellRelInfo
6581 *
6582 *
6583 *     Desc : Secondary Cell Delete information of the UE
6584 *
6585 *
6586 *     Ret  : S16
6587 *
6588 *     Notes:
6589 *
6590 *     File  :
6591 *
6592 **********************************************************/
6593 S16 cmPkRgrUeSecCellRelInfo
6594 (
6595 RgrUeSecCellRelInfo *param,
6596 Buffer *mBuf
6597 )
6598 {
6599    S8 idx;
6600    for(idx = param->numSCells - 1; idx >= 0; idx--)
6601    {
6602       CMCHKPK(cmPkRgrUeDlSecCellRelInfo, &param->ueSCellRelDedCfg[(uint8_t)idx],mBuf);
6603    }
6604    CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
6605
6606    return ROK;
6607 }
6608 #endif
6609
6610 \f
6611 /***********************************************************
6612 *
6613 *     Func : cmPkRgrDel
6614 *
6615 *
6616 *     Desc : Basic Delete info for MAC
6617 *
6618 *
6619 *     Ret  : S16
6620 *
6621 *     Notes:
6622 *
6623 *     File  :
6624 *
6625 **********************************************************/
6626 S16 cmPkRgrDel
6627 (
6628 RgrDel *param,
6629 Buffer *mBuf
6630 )
6631 {
6632
6633
6634       switch(param->delType) {
6635          case RGR_LCG_CFG:
6636             CMCHKPK(oduUnpackUInt8, param->u.lcgDel.lcgId, mBuf);
6637             CMCHKPK(cmPkLteRnti, param->u.lcgDel.crnti, mBuf);
6638             CMCHKPK(cmPkLteCellId, param->u.lcgDel.cellId, mBuf);
6639          break;
6640          case RGR_LCH_CFG:
6641             CMCHKPK(oduUnpackUInt8, param->u.lchDel.lcgId, mBuf);
6642             CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
6643             CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
6644             CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
6645          break;
6646          case RGR_UE_CFG:
6647             CMCHKPK(cmPkLteRnti, param->u.ueDel.crnti, mBuf);
6648             CMCHKPK(cmPkLteCellId, param->u.ueDel.cellId, mBuf);
6649          break;
6650          case RGR_CELL_CFG:
6651             CMCHKPK(cmPkLteCellId, param->u.cellDel.cellId, mBuf);
6652          break;
6653 #ifdef LTE_ADV
6654          case RGR_SCELL_UE_CFG:
6655             CMCHKPK(cmPkRgrUeSecCellRelInfo, &param->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
6656             CMCHKPK(oduUnpackUInt32, param->u.ueScellRel.ueDelTypes, mBuf);
6657             CMCHKPK(cmPkLteRnti, param->u.ueScellRel.crnti, mBuf);
6658             CMCHKPK(cmPkLteCellId, param->u.ueScellRel.cellId, mBuf);
6659          break;
6660 #endif
6661          default :
6662             return RFAILED;
6663       }
6664    CMCHKPK(oduUnpackUInt8, param->delType, mBuf);
6665    return ROK;
6666 }
6667
6668
6669 #ifdef LTE_ADV
6670 \f
6671 /***********************************************************
6672 *
6673 *     Func : cmUnpkRgrUeDlSecCellRelInfo
6674 *
6675 *
6676 *     Desc : DL Secondary Cell information of the UE
6677 *
6678 *
6679 *     Ret  : S16
6680 *
6681 *     Notes:
6682 *
6683 *     File  :
6684 *
6685 **********************************************************/
6686 S16 cmUnpkRgrUeDlSecCellRelInfo
6687 (
6688 RgrUeDlSecCellRelInfo *param,
6689 Buffer *mBuf
6690 )
6691 {
6692    CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
6693    CMCHKUNPK(oduPackUInt16, &param->sCellId, mBuf);
6694    return ROK;
6695 }
6696
6697 \f
6698 /***********************************************************
6699 *
6700 *     Func : cmUnpkRgrUeSecCellRelInfo
6701 *
6702 *
6703 *     Desc : Secondary Cell information of the UE
6704 *
6705 *
6706 *     Ret  : S16
6707 *
6708 *     Notes:
6709 *
6710 *     File  :
6711 *
6712 **********************************************************/
6713 S16 cmUnpkRgrUeSecCellRelInfo
6714 (
6715 RgrUeSecCellRelInfo *param,
6716 Buffer *mBuf
6717 )
6718 {
6719    uint8_t idx;
6720
6721    CMCHKUNPK(oduPackUInt8, &param->numSCells, mBuf);
6722
6723    for(idx = 0; idx < param->numSCells;idx++)
6724    {
6725       CMCHKUNPK(cmUnpkRgrUeDlSecCellRelInfo, &param->ueSCellRelDedCfg[idx],mBuf);
6726    }
6727    return ROK;
6728 }
6729 #endif
6730 \f
6731 /***********************************************************
6732 *
6733 *     Func : cmUnpkRgrDel
6734 *
6735 *
6736 *     Desc : Basic Delete info for MAC
6737 *
6738 *
6739 *     Ret  : S16
6740 *
6741 *     Notes:
6742 *
6743 *     File  :
6744 *
6745 **********************************************************/
6746 S16 cmUnpkRgrDel
6747 (
6748 RgrDel *param,
6749 Buffer *mBuf
6750 )
6751 {
6752
6753
6754    CMCHKUNPK(oduPackUInt8, &param->delType, mBuf);
6755       switch(param->delType) {
6756          case RGR_CELL_CFG:
6757             CMCHKUNPK(cmUnpkLteCellId, &param->u.cellDel.cellId, mBuf);
6758          break;
6759          case RGR_UE_CFG:
6760             CMCHKUNPK(cmUnpkLteCellId, &param->u.ueDel.cellId, mBuf);
6761             CMCHKUNPK(cmUnpkLteRnti, &param->u.ueDel.crnti, mBuf);
6762          break;
6763          case RGR_LCH_CFG:
6764             CMCHKUNPK(cmUnpkLteCellId, &param->u.lchDel.cellId, mBuf);
6765             CMCHKUNPK(cmUnpkLteRnti, &param->u.lchDel.crnti, mBuf);
6766             CMCHKUNPK(cmUnpkLteLcId, &param->u.lchDel.lcId, mBuf);
6767             CMCHKUNPK(oduPackUInt8, &param->u.lchDel.lcgId, mBuf);
6768          break;
6769          case RGR_LCG_CFG:
6770             CMCHKUNPK(cmUnpkLteCellId, &param->u.lcgDel.cellId, mBuf);
6771             CMCHKUNPK(cmUnpkLteRnti, &param->u.lcgDel.crnti, mBuf);
6772             CMCHKUNPK(oduPackUInt8, &param->u.lcgDel.lcgId, mBuf);
6773          break;
6774 #ifdef LTE_ADV
6775          case RGR_SCELL_UE_CFG:
6776             CMCHKUNPK(cmUnpkLteCellId, &param->u.ueScellRel.cellId, mBuf);
6777             CMCHKUNPK(cmUnpkLteRnti, &param->u.ueScellRel.crnti, mBuf);
6778             CMCHKUNPK(oduPackUInt32, &param->u.ueScellRel.ueDelTypes, mBuf);
6779             CMCHKUNPK(cmUnpkRgrUeSecCellRelInfo, &param->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
6780          break;
6781 #endif
6782          default :
6783             return RFAILED;
6784       }
6785    return ROK;
6786 }
6787 /***********************************************************
6788 *
6789 *     Func : cmPkRgrSonPrbCfg
6790 *
6791 *
6792 *     Desc : SON PRB Configuration info for MAC
6793 *
6794 *
6795 *     Ret  : S16
6796 *
6797 *     Notes:
6798 *
6799 *     File  :
6800 *
6801 **********************************************************/
6802 S16 cmPkRgrSonPrbCfg
6803 (
6804 RgrPrbCfg *param,
6805 Buffer *mBuf
6806 )
6807 {
6808    S32 count;
6809    for(count = RGR_SCH_MAX_PA_PER_PRB - 1; count >= 0; count --)
6810    {
6811       CMCHKPK(oduUnpackUInt32, param->paLevelPerPrb[count], mBuf);
6812    }
6813    for(count = param->numCellCentreUEs - 1; count >= 0; count --)
6814    {
6815       CMCHKPK(cmPkLteRnti, param->cellCentreUe[count], mBuf);
6816    }
6817    for(count = param->numCellEdgeUEs - 1; count >= 0; count --)
6818    {
6819       CMCHKPK(cmPkLteRnti, param->cellEdgeUe[count], mBuf);
6820    }
6821    CMCHKPK(oduUnpackUInt8, param->numCellCentreUEs, mBuf);
6822    CMCHKPK(oduUnpackUInt8, param->numCellEdgeUEs, mBuf);
6823    CMCHKPK(oduUnpackUInt8, param->isSonIcicEnable, mBuf);
6824    return ROK;
6825 }
6826
6827 /***********************************************************
6828 *
6829 *     Func : cmUnpkRgrSon
6830 *
6831 *
6832 *     Desc : SON configuration info for MAC
6833 *
6834 *
6835 *     Ret  : S16
6836 *
6837 *     Notes:
6838 *
6839 *     File  :
6840 *
6841 **********************************************************/
6842 S16 cmUnpkRgrSonPrbCfg
6843 (
6844 RgrPrbCfg   *param,
6845 Buffer      *mBuf
6846 )
6847 {
6848    S32   count;
6849    CMCHKUNPK(oduPackUInt8, &param->isSonIcicEnable, mBuf);
6850    CMCHKUNPK(oduPackUInt8, &param->numCellEdgeUEs, mBuf);
6851    CMCHKUNPK(oduPackUInt8, &param->numCellCentreUEs, mBuf);
6852    for (count = 0; count < param->numCellEdgeUEs; count++)
6853    {
6854       CMCHKUNPK(cmUnpkLteRnti, &param->cellEdgeUe[count], mBuf);
6855    }
6856    for (count = 0; count < param->numCellCentreUEs; count++)
6857    {
6858       CMCHKUNPK(cmUnpkLteRnti, &param->cellCentreUe[count], mBuf);
6859    }
6860    for(count = 0; count < RGR_SCH_MAX_PA_PER_PRB; count ++)
6861    {
6862       CMCHKUNPK(oduPackUInt32,(uint32_t *) &param->paLevelPerPrb[count], mBuf);
6863    }
6864    return ROK;
6865 }
6866 /***********************************************************
6867 *
6868 *     Func : cmPkRgrSonCfg
6869 *
6870 *
6871 *     Desc : SON Configuration info for MAC
6872 *
6873 *
6874 *     Ret  : S16
6875 *
6876 *     Notes:
6877 *
6878 *     File  :
6879 *
6880 **********************************************************/
6881 S16 cmPkRgrSonCfg
6882 (
6883 RgrSonCfg *param,
6884 Buffer *mBuf
6885 )
6886 {
6887
6888    switch(param->cfgType)
6889    {
6890       case RGR_SON_PRB_CFG :
6891       CMCHKPK(cmPkRgrSonPrbCfg, &param->u.prbCfg, mBuf);
6892       break;
6893       default :
6894       return RFAILED;
6895    }
6896    CMCHKPK(oduUnpackUInt32, param->cfgType, mBuf);
6897    return ROK;
6898 }
6899
6900 /***********************************************************
6901 *
6902 *     Func : cmUnpkRgrSon
6903 *
6904 *
6905 *     Desc : SON configuration info for MAC
6906 *
6907 *
6908 *     Ret  : S16
6909 *
6910 *     Notes:
6911 *
6912 *     File  :
6913 *
6914 **********************************************************/
6915 S16 cmUnpkRgrSonCfg
6916 (
6917 RgrSonCfg   *param,
6918 Buffer      *mBuf
6919 )
6920 {
6921
6922    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->cfgType, mBuf);
6923    switch(param->cfgType)
6924    {
6925       case RGR_SON_PRB_CFG :
6926       {
6927          CMCHKUNPK(cmUnpkRgrSonPrbCfg, &param->u.prbCfg, mBuf);
6928          break;
6929          default :
6930          return RFAILED;
6931       }
6932    }
6933    return ROK;
6934 }
6935
6936 \f
6937 /***********************************************************
6938 *
6939 *     Func : cmPkRgrRst
6940 *
6941 *
6942 *     Desc : UE RESET info for MAC
6943 *
6944 *
6945 *     Ret  : S16
6946 *
6947 *     Notes:
6948 *
6949 *     File  :
6950 *
6951 **********************************************************/
6952 S16 cmPkRgrRst
6953 (
6954 RgrRst *param,
6955 Buffer *mBuf
6956 )
6957 {
6958
6959
6960    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
6961    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
6962    return ROK;
6963 }
6964
6965
6966 \f
6967 /***********************************************************
6968 *
6969 *     Func : cmUnpkRgrRst
6970 *
6971 *
6972 *     Desc : UE RESET info for MAC
6973 *
6974 *
6975 *     Ret  : S16
6976 *
6977 *     Notes:
6978 *
6979 *     File  :
6980 *
6981 **********************************************************/
6982 S16 cmUnpkRgrRst
6983 (
6984 RgrRst *param,
6985 Buffer *mBuf
6986 )
6987 {
6988
6989
6990    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
6991    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
6992    return ROK;
6993 }
6994 #ifdef LTE_ADV
6995 /***********************************************************
6996 *
6997 *     Func : cmUnPkRgrSCellActDeactInfo
6998 *
6999 *
7000 *     Desc : SCell Activation information of the UE
7001 *
7002 *
7003 *     Ret  : S16
7004 *
7005 *     Notes:
7006 *
7007 *     File  :
7008 *
7009 **********************************************************/
7010 static S16 cmUnPkRgrSCellActDeactInfo
7011 (
7012 RgrSCellActDeactInfo *param,
7013 Buffer *mBuf
7014 )
7015 {
7016
7017    CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
7018    return ROK;
7019 }
7020
7021 /***********************************************************
7022 *
7023 *     Func : cmUnPkRgrSCellActDeactEvnt
7024 *
7025 *
7026 *     Desc : SCell Activation Configuration structure to SCH
7027 *
7028 *
7029 *     Ret  : S16
7030 *
7031 *     Notes:
7032 *
7033 *     File  :
7034 *
7035 **********************************************************/
7036 S16 cmUnPkRgrSCellActDeactEvnt
7037 (
7038 RgrSCellActDeactEvnt *param,
7039 Buffer *mBuf
7040 )
7041 {
7042
7043    uint8_t idx;
7044
7045    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
7046    CMCHKUNPK(oduPackUInt8, &param->numOfSCells, mBuf);
7047
7048    for(idx = 0; idx < param->numOfSCells;idx++)
7049    {
7050       CMCHKUNPK(cmUnPkRgrSCellActDeactInfo, &param->sCellActDeactInfo[idx],mBuf);
7051    }
7052
7053    return ROK;
7054 }
7055
7056
7057 /***********************************************************
7058 *
7059 *     Func : cmPkRgrSCellActInfo
7060 *
7061 *
7062 *     Desc : SCell Activation information of the UE
7063 *
7064 *
7065 *     Ret  : S16
7066 *
7067 *     Notes:
7068 *
7069 *     File  :
7070 *
7071 **********************************************************/
7072 static S16 cmPkRgrSCellActDeactInfo
7073 (
7074 RgrSCellActDeactInfo *param,
7075 Buffer *mBuf
7076 )
7077 {
7078
7079    CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
7080
7081    return ROK;
7082 }
7083
7084 /***********************************************************
7085 *
7086 *     Func : cmPkRgrSCellActDeactEvnt
7087 *
7088 *
7089 *     Desc : Basic Configuration structure at SCH
7090 *
7091 *
7092 *     Ret  : S16
7093 *
7094 *     Notes:
7095 *
7096 *     File  :
7097 *
7098 **********************************************************/
7099 S16 cmPkRgrSCellActDeactEvnt
7100 (
7101 RgrSCellActDeactEvnt *param,
7102 Buffer *mBuf
7103 )
7104 {
7105
7106
7107    S8 idx;
7108    for(idx = param->numOfSCells - 1; idx >= 0; idx--)
7109    {
7110       CMCHKPK(cmPkRgrSCellActDeactInfo, &param->sCellActDeactInfo[(uint8_t)idx], mBuf);
7111    }
7112
7113    CMCHKPK(oduUnpackUInt8, param->numOfSCells, mBuf);
7114    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
7115
7116    return ROK;
7117 }
7118
7119
7120 #endif /* LTE_ADV */
7121 \f
7122 /***********************************************************
7123 *
7124 *     Func : cmPkRgrCfgReqInfo
7125 *
7126 *
7127 *     Desc : Basic RGR configuration/reconfiguration info at RRM
7128 *
7129 *
7130 *     Ret  : S16
7131 *
7132 *     Notes:
7133 *
7134 *     File  :
7135 *
7136 **********************************************************/
7137 S16 cmPkRgrCfgReqInfo
7138 (
7139 RgrCfgReqInfo *param,
7140 Buffer *mBuf
7141 )
7142 {
7143
7144
7145       switch(param->action) {
7146          case RGR_SON_CFG:
7147             CMCHKPK(cmPkRgrSonCfg, &param->u.sonCfg, mBuf);
7148             break;
7149          case RGR_RESET:
7150             CMCHKPK(cmPkRgrRst, &param->u.rstInfo, mBuf);
7151             break;
7152          case RGR_DELETE:
7153             CMCHKPK(cmPkRgrDel, &param->u.delInfo, mBuf);
7154             break;
7155          case RGR_RECONFIG:
7156             CMCHKPK(cmPkRgrRecfg, &param->u.recfgInfo, mBuf);
7157             break;
7158          case SCH_CONFIG:
7159             CMCHKPK(cmPkRgrCfg, &param->u.cfgInfo, mBuf);
7160             break;
7161 #ifdef LTE_ADV
7162          case RGR_SCELL_ACT:
7163          case RGR_SCELL_DEACT:
7164          case RGR_SCELL_READY:
7165             CMCHKPK(cmPkRgrSCellActDeactEvnt, &param->u.sCellActDeactEvnt, mBuf);
7166             break;
7167 #endif
7168          default :
7169             return RFAILED;
7170       }
7171    CMCHKPK(oduUnpackUInt8, param->action, mBuf);
7172    return ROK;
7173 }
7174
7175
7176 \f
7177 /***********************************************************
7178 *
7179 *     Func : cmUnpkRgrCfgReqInfo
7180 *
7181 *
7182 *     Desc : Basic RGR configuration/reconfiguration info at RRM
7183 *
7184 *
7185 *     Ret  : S16
7186 *
7187 *     Notes:
7188 *
7189 *     File  :
7190 *
7191 **********************************************************/
7192 S16 cmUnpkRgrCfgReqInfo
7193 (
7194 RgrCfgReqInfo *param,
7195 Buffer *mBuf
7196 )
7197 {
7198
7199
7200    CMCHKUNPK(oduPackUInt8, &param->action, mBuf);
7201       switch(param->action) {
7202          case SCH_CONFIG:
7203             CMCHKUNPK(cmUnpkRgrCfg, &param->u.cfgInfo, mBuf);
7204             break;
7205          case RGR_RECONFIG:
7206             CMCHKUNPK(cmUnpkRgrRecfg, &param->u.recfgInfo, mBuf);
7207             break;
7208          case RGR_DELETE:
7209             CMCHKUNPK(cmUnpkRgrDel, &param->u.delInfo, mBuf);
7210             break;
7211          case RGR_RESET:
7212             CMCHKUNPK(cmUnpkRgrRst, &param->u.rstInfo, mBuf);
7213             break;
7214          case RGR_SON_CFG:
7215             CMCHKUNPK(cmUnpkRgrSonCfg, &param->u.sonCfg, mBuf);
7216             break;
7217 #ifdef LTE_ADV
7218          case RGR_SCELL_ACT:
7219          case RGR_SCELL_DEACT:
7220          case RGR_SCELL_READY:
7221             CMCHKUNPK(cmUnPkRgrSCellActDeactEvnt, &param->u.sCellActDeactEvnt, mBuf);
7222             break;
7223 #endif /* LTE_ADV */
7224          default :
7225             return RFAILED;
7226       }
7227    return ROK;
7228 }
7229 #ifdef RGR_V1
7230 /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
7231  * retxBSR-timer */
7232 /***********************************************************
7233 *
7234 *     Func : cmPkRgrUeBsrTmrCfg
7235 *
7236 *
7237 *     Desc : BSR timer configuration per UE
7238 *
7239 *
7240 *     Ret  : S16
7241 *
7242 *     Notes:
7243 *
7244 *     File  :
7245 *
7246 **********************************************************/
7247 S16 cmPkRgrUeBsrTmrCfg
7248 (
7249 RgrUeBsrTmrCfg *param,
7250 Buffer *mBuf
7251 )
7252 {
7253
7254
7255    CMCHKPK(oduUnpackUInt16, param->prdBsrTmr, mBuf);
7256    CMCHKPK(oduUnpackUInt16, param->retxBsrTmr, mBuf);
7257    CMCHKPK(oduUnpackUInt8, param->isPrdBsrTmrPres, mBuf);
7258    return ROK;
7259 }
7260
7261 /***********************************************************
7262 *
7263 *     Func : cmUnpkRgrUeBsrTmrCfg
7264 *
7265 *
7266 *     Desc : BSR timer configuration per UE
7267 *
7268 *
7269 *     Ret  : S16
7270 *
7271 *     Notes:
7272 *
7273 *     File  :
7274 *
7275 **********************************************************/
7276 S16 cmUnpkRgrUeBsrTmrCfg
7277 (
7278 RgrUeBsrTmrCfg *param,
7279 Buffer *mBuf
7280 )
7281 {
7282
7283
7284    CMCHKUNPK(oduPackUInt8, &param->isPrdBsrTmrPres, mBuf);
7285    CMCHKUNPK(oduPackUInt16, &param->retxBsrTmr, mBuf);
7286    CMCHKUNPK(oduPackUInt16, &param->prdBsrTmr, mBuf);
7287    return ROK;
7288 }
7289 #endif /* RGR_V1 */
7290
7291 /*rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
7292    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
7293 #ifdef RGR_CQI_REPT
7294 \f
7295 /***********************************************************
7296 *
7297 *     Func : cmPkRgrUeCqiReptCfg
7298 *
7299 *
7300 *     Desc : Transaction ID between MAC and RRM
7301 *
7302 *
7303 *     Ret  : S16
7304 *
7305 *     Notes:
7306 *
7307 *     File  :
7308 *
7309 **********************************************************/
7310 S16 cmPkRgrUeCqiReptCfg
7311 (
7312 RgrUeCqiReptCfg *param,
7313 Buffer *mBuf
7314 )
7315 {
7316
7317    CMCHKPK(oduUnpackUInt8, param->numColltdCqiRept, mBuf);
7318
7319    return ROK;
7320 }
7321
7322 \f
7323 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7324 /***********************************************************
7325 *
7326 *     Func : cmUnpkRgrUeCqiReptCfg
7327 *
7328 *
7329 *     Desc : Transaction ID between MAC and RRM
7330 *
7331 *
7332 *     Ret  : S16
7333 *
7334 *     Notes:
7335 *
7336 *     File  :
7337 *
7338 **********************************************************/
7339 S16 cmUnpkRgrUeCqiReptCfg
7340 (
7341 RgrUeCqiReptCfg *param,
7342 Buffer *mBuf
7343 )
7344 {
7345
7346    CMCHKUNPK(oduPackUInt8, &param->numColltdCqiRept, mBuf);
7347
7348    return ROK;
7349 }
7350
7351 \f
7352 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7353 /***********************************************************
7354 *
7355 *     Func : cmPkRgrStaInd
7356 *
7357 *
7358 *     Desc : Packing Sta Indication sent to RRM
7359 *
7360 *
7361 *     Ret  : S16
7362 *
7363 *     Notes:
7364 *
7365 *     File  :
7366 *
7367 **********************************************************/
7368 S16 cmPkRgrStaInd
7369 (
7370 Pst* pst,
7371 SuId suId,
7372 RgrStaIndInfo* staInd
7373 )
7374 {
7375    Buffer *mBuf = NULLP;
7376
7377    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
7378    {
7379 #if (ERRCLASS & ERRCLS_ADD_RES)
7380       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7381          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7382          (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
7383 #endif
7384       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
7385                sizeof(RgrStaIndInfo));
7386       return RFAILED;
7387    }
7388
7389    if (cmPkRgrStaIndInfo(staInd, mBuf) != ROK)
7390    {
7391 #if (ERRCLASS & ERRCLS_ADD_RES)
7392       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7393             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7394             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
7395 #endif
7396       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd, sizeof(RgrStaIndInfo));
7397       SPutMsg(mBuf);
7398       return RFAILED;
7399    }
7400
7401    if (SPkS16(suId, mBuf) != ROK)
7402    {
7403 #if (ERRCLASS & ERRCLS_ADD_RES)
7404       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7405          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7406          (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
7407 #endif
7408       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
7409                   sizeof(RgrStaIndInfo));
7410       SPutMsg(mBuf);
7411       return RFAILED;
7412    }
7413
7414    if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
7415                   sizeof(RgrStaIndInfo)) != ROK)
7416    {
7417 #if (ERRCLASS & ERRCLS_ADD_RES)
7418       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7419          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7420          (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
7421 #endif
7422       SPutMsg(mBuf);
7423       return RFAILED;
7424    }
7425
7426    pst->event = (Event) EVTRGRSTAIND;
7427    return (SPstTsk(pst,mBuf));
7428 }
7429
7430 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7431 /***********************************************************
7432 *
7433 *     Func : cmUnpkRgrStaInd
7434 *
7435 *
7436 *     Desc : Unpacking Sta Indication sent to RRM
7437 *
7438 *     Ret  : S16
7439 *
7440 *     Notes:
7441 *
7442 *     File  :
7443 *
7444 **********************************************************/
7445 S16 cmUnpkRgrStaInd
7446 (
7447 RgrStaInd func,
7448 Pst *pst,
7449 Buffer *mBuf
7450 )
7451 {
7452    SuId suId;
7453    RgrStaIndInfo *staInd;
7454
7455
7456    if (SUnpkS16(&suId, mBuf) != ROK)
7457    {
7458       SPutMsg(mBuf);
7459 #if (ERRCLASS & ERRCLS_ADD_RES)
7460       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7461          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7462          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
7463 #endif
7464       return RFAILED;
7465    }
7466
7467    if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&staInd,
7468                  sizeof(RgrStaIndInfo))) != ROK)
7469    {
7470 #if (ERRCLASS & ERRCLS_ADD_RES)
7471          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7472             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7473             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
7474 #endif
7475          SPutMsg(mBuf);
7476          return RFAILED;
7477    }
7478
7479    if (cmUnpkRgrStaIndInfo(staInd, mBuf) != ROK)
7480    {
7481       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)staInd,
7482              sizeof(RgrStaIndInfo));
7483       SPutMsg(mBuf);
7484 #if (ERRCLASS & ERRCLS_ADD_RES)
7485       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7486          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7487          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
7488 #endif
7489       return RFAILED;
7490    }
7491
7492    SPutMsg(mBuf);
7493    return ((*func)(pst, suId, staInd));
7494 }
7495 \f
7496 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7497 /***********************************************************
7498 *
7499 *     Func : cmPkRgrStaIndInfo
7500 *
7501 *
7502 *     Desc : Packing of StaIndInfo structure
7503 *
7504 *     Ret  : S16
7505 *
7506 *     Notes:
7507 *
7508 *     File  :
7509 *
7510 **********************************************************/
7511 S16 cmPkRgrStaIndInfo
7512 (
7513 RgrStaIndInfo *param,
7514 Buffer *mBuf
7515 )
7516 {
7517
7518
7519    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7520    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
7521    CMCHKPK(cmPkRgrUeCqiInfo, &param->ueCqiInfo, mBuf);
7522
7523    return ROK;
7524 }
7525 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7526 /***********************************************************
7527 *
7528 *     Func : cmUnpkRgrStaIndInfo
7529 *
7530 *
7531 *     Desc : Unpacking of StaIndInfo structure
7532 *
7533 *     Ret  : S16
7534 *
7535 *     Notes:
7536 *
7537 *     File  :
7538 *
7539 **********************************************************/
7540 S16 cmUnpkRgrStaIndInfo
7541 (
7542 RgrStaIndInfo *param,
7543 Buffer *mBuf
7544 )
7545 {
7546
7547
7548    CMCHKUNPK(cmUnpkRgrUeCqiInfo, &param->ueCqiInfo, mBuf);
7549    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
7550    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7551
7552    return ROK;
7553 }
7554 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7555 /***********************************************************
7556 *
7557 *     Func : cmPkRgrUeCqiInfo
7558 *
7559 *
7560 *     Desc : Packing of StaIndInfo structure
7561 *
7562 *     Ret  : S16
7563 *
7564 *     Notes:
7565 *
7566 *     File  :
7567 *
7568 **********************************************************/
7569 S16 cmPkRgrUeCqiInfo
7570 (
7571 RgrUeCqiInfo *param,
7572 Buffer *mBuf
7573 )
7574 {
7575
7576    S16 idx;
7577
7578    for (idx = param->numCqiRept - 1; idx >= 0; idx--)
7579    {
7580       CMCHKPK(cmPkRgrUeCqiRept, &param->cqiRept[idx], mBuf);
7581    }
7582    CMCHKPK(oduUnpackUInt8, param->numCqiRept, mBuf);
7583
7584    return ROK;
7585 } /* cmPkRgrUeCqiInfo */
7586
7587 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7588 /***********************************************************
7589 *
7590 *     Func : cmUnpkRgrUeCqiInfo
7591 *
7592 *
7593 *     Desc : Packing of StaIndInfo structure
7594 *
7595 *     Ret  : S16
7596 *
7597 *     Notes:
7598 *
7599 *     File  :
7600 *
7601 **********************************************************/
7602 S16 cmUnpkRgrUeCqiInfo
7603 (
7604 RgrUeCqiInfo *param,
7605 Buffer *mBuf
7606 )
7607 {
7608
7609    uint8_t  idx;
7610
7611    CMCHKUNPK(oduPackUInt8, &param->numCqiRept, mBuf);
7612    for (idx = 0; idx < param->numCqiRept; idx++)
7613    {
7614       CMCHKUNPK(cmUnpkRgrUeCqiRept, &param->cqiRept[idx], mBuf);
7615    }
7616
7617    return ROK;
7618 } /* cmUnpkRgrUeCqiInfo */
7619
7620 /***********************************************************
7621 *
7622 *     Func : cmPkRgrSubBandCqiInfo
7623 *
7624 *
7625 *     Desc : Packing ofcmPkRgrSubBandCqiInfo structure
7626 *
7627 *     Ret  : S16
7628 *
7629 *     Notes:
7630 *
7631 *     File  :
7632 *
7633 **********************************************************/
7634 S16 cmPkRgrSubBandCqiInfo
7635 (
7636 RgrSubBandCqiInfo *param,
7637 Buffer *mBuf
7638 )
7639 {
7640
7641
7642    CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
7643    CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
7644    CMCHKPK(oduUnpackUInt8, param->subBandIdx, mBuf);
7645
7646    return ROK;
7647 } /* cmPkRgrSubBandCqiInfo */
7648
7649 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7650 /***********************************************************
7651 *
7652 *     Func : cmPkRgrUeCqiRept
7653 *
7654 *
7655 *     Desc : Packing of StaIndInfo structure
7656 *
7657 *     Ret  : S16
7658 *
7659 *     Notes:
7660 *
7661 *     File  :
7662 *
7663 **********************************************************/
7664 S16 cmPkRgrUeCqiRept
7665 (
7666 RgrUeCqiRept *param,
7667 Buffer *mBuf
7668 )
7669 {
7670    S8 idx;
7671    uint8_t count;
7672
7673
7674    CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
7675    CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
7676    CMCHKPK(oduUnpackUInt8, param->cqiMode, mBuf);
7677    for (idx = param->numSubBand - 1; idx >= 0; idx--)
7678    {
7679       count = idx;
7680       CMCHKPK(cmPkRgrSubBandCqiInfo, &param->sbCqiInfo[count], mBuf);
7681    }
7682    CMCHKPK(oduUnpackUInt8, param->numSubBand, mBuf);
7683    return ROK;
7684 } /* cmPkRgrUeCqiRept */
7685
7686 /***********************************************************
7687 *
7688 *     Func :cmUnpkRgrSubBandCqiInfo
7689 *
7690 *
7691 *     Desc : Packing of cmUnpkRgrSubBandCqiInfo structure
7692 *
7693 *     Ret  : S16
7694 *
7695 *     Notes:
7696 *
7697 *     File  :
7698 *
7699 **********************************************************/
7700 S16 cmUnpkRgrSubBandCqiInfo
7701 (
7702 RgrSubBandCqiInfo *param,
7703 Buffer *mBuf
7704 )
7705 {
7706
7707
7708    CMCHKUNPK(oduPackUInt8, &param->subBandIdx, mBuf);
7709    CMCHKUNPK(oduPackUInt8, &param->cqi[1], mBuf);
7710    CMCHKUNPK(oduPackUInt8, &param->cqi[0], mBuf);
7711
7712    return ROK;
7713 } /* cmUnpkRgrSubBandCqiInfo*/
7714
7715 /*rgr_c_001.main_9 ADD added changes for CQI management*/
7716 /***********************************************************
7717 *
7718 *     Func : cmUnpkRgrUeCqiRept
7719 *
7720 *
7721 *     Desc : Packing of StaIndInfo structure
7722 *
7723 *     Ret  : S16
7724 *
7725 *     Notes:
7726 *
7727 *     File  :
7728 *
7729 **********************************************************/
7730 S16 cmUnpkRgrUeCqiRept
7731 (
7732 RgrUeCqiRept *param,
7733 Buffer *mBuf
7734 )
7735 {
7736    uint8_t idx;
7737
7738    CMCHKUNPK(oduPackUInt8, &param->numSubBand, mBuf);
7739    for (idx = 0; idx < param->numSubBand; idx++)
7740    {
7741       CMCHKUNPK(cmUnpkRgrSubBandCqiInfo, &param->sbCqiInfo[idx], mBuf);
7742    }
7743    CMCHKUNPK(oduPackUInt8, &param->cqiMode, mBuf);
7744    CMCHKUNPK(oduPackUInt8, &param->cqi[1], mBuf);
7745    CMCHKUNPK(oduPackUInt8, &param->cqi[0], mBuf);
7746
7747    return ROK;
7748 } /* cmUnpkRgrUeCqiRept */
7749 #endif /* End of ifdef RGR_CQI_REPT */
7750
7751 /* LTE_ADV_FLAG_REMOVED_START */
7752 /***********************************************************
7753 *
7754 *     Func : cmPkRgrLoadInfInd
7755 *
7756 *
7757 *     Desc : Packing LOAD INFORMATION Indication sent to RRM
7758 *
7759 *
7760 *     Ret  : S16
7761 *
7762 *     Notes:
7763 *
7764 *     File  :
7765 *
7766 **********************************************************/
7767 S16 cmPkRgrLoadInfInd
7768 (
7769 Pst* pst,
7770 SuId suId,
7771 RgrLoadInfIndInfo* loadInfInd
7772 )
7773 {
7774    Buffer *mBuf = NULLP;
7775
7776    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
7777    {
7778 #if (ERRCLASS & ERRCLS_ADD_RES)
7779       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7780             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7781             (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
7782 #endif
7783       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
7784             sizeof(RgrLoadInfIndInfo));
7785       return RFAILED;
7786    }
7787
7788    if (cmPkRgrLoadInfIndInfo(loadInfInd, mBuf) != ROK)
7789    {
7790 #if (ERRCLASS & ERRCLS_ADD_RES)
7791       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7792             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7793             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
7794 #endif
7795       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
7796             sizeof(RgrLoadInfIndInfo));
7797       SPutMsg(mBuf);
7798
7799       return RFAILED;
7800    }
7801
7802    if (SPkS16(suId, mBuf) != ROK)
7803    {
7804 #if (ERRCLASS & ERRCLS_ADD_RES)
7805       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7806             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7807             (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
7808 #endif
7809       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
7810             sizeof(RgrLoadInfIndInfo));
7811       SPutMsg(mBuf);
7812       return RFAILED;
7813    }
7814
7815    if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
7816                   sizeof(RgrLoadInfIndInfo)) != ROK)
7817    {
7818 #if (ERRCLASS & ERRCLS_ADD_RES)
7819       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7820             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7821             (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
7822 #endif
7823       SPutMsg(mBuf);
7824       return RFAILED;
7825    }
7826
7827    pst->event = (Event) EVTRGRLOADINFIND;
7828    return (SPstTsk(pst,mBuf));
7829 }
7830
7831 /***********************************************************
7832 *
7833 *     Func : cmUnpkRgrLoadInfInd
7834 *
7835 *
7836 *     Desc : Unpacking LOAD INFORMATION Indication sent to RRM
7837 *
7838 *     Ret  : S16
7839 *
7840 *     Notes:
7841 *
7842 *     File  :
7843 *
7844 **********************************************************/
7845 S16 cmUnpkRgrLoadInfInd
7846 (
7847 RgrLoadInfInd func,
7848 Pst *pst,
7849 Buffer *mBuf
7850 )
7851 {
7852    SuId suId;
7853    RgrLoadInfIndInfo *loadInfInd = NULLP; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
7854
7855
7856    if (SUnpkS16(&suId, mBuf) != ROK)
7857    {
7858       SPutMsg(mBuf);
7859 #if (ERRCLASS & ERRCLS_ADD_RES)
7860       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7861          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7862          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
7863 #endif
7864       return RFAILED;
7865    }
7866
7867    if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&loadInfInd,
7868                  sizeof(RgrLoadInfIndInfo))) != ROK)
7869    {
7870 #if (ERRCLASS & ERRCLS_ADD_RES)
7871          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7872             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7873             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
7874 #endif
7875          SPutMsg(mBuf);
7876          return RFAILED;
7877    }
7878
7879    /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
7880    if (cmUnpkRgrLoadInfIndInfo(loadInfInd, pst, mBuf) != ROK)
7881    {
7882       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)loadInfInd,
7883              sizeof(RgrLoadInfIndInfo));
7884       SPutMsg(mBuf);
7885 #if (ERRCLASS & ERRCLS_ADD_RES)
7886       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7887          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7888          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
7889 #endif
7890       return RFAILED;
7891    }
7892
7893    SPutMsg(mBuf);
7894    return ((*func)(pst, suId, loadInfInd));
7895 }
7896 \f
7897
7898 /***********************************************************
7899 *
7900 *     Func : cmPkRgrLoadInfIndInfo
7901 *
7902 *
7903 *     Desc : Packing of LoadInfIndInfo structure
7904 *
7905 *     Ret  : S16
7906 *
7907 *     Notes:
7908 *
7909 *     File  :
7910 *
7911 **********************************************************/
7912 S16 cmPkRgrLoadInfIndInfo
7913 (
7914 RgrLoadInfIndInfo *param,
7915 Buffer *mBuf
7916 )
7917 {
7918    uint8_t                     idx;
7919
7920    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7921    CMCHKPK(oduUnpackUInt16, param->bw, mBuf);
7922    if(RGR_ABS == param->type)
7923    {
7924       for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
7925       {
7926          CMCHKPK(oduUnpackUInt32, param->u.absLoadInfo[idx], mBuf);
7927       }
7928    }
7929    else
7930    {
7931       CMCHKPK(cmPkTknStrOSXL, &param->u.rntpInfo, mBuf);
7932    }
7933
7934    CMCHKPK(oduUnpackUInt32, param->type, mBuf);
7935
7936    return ROK;
7937 }
7938
7939 /***********************************************************
7940 *
7941 *     Func : cmUnpkRgrLoadInfIndInfo
7942 *
7943 *
7944 *     Desc : Unpacking of LoadInfIndInfo structure
7945 *
7946 *     Ret  : S16
7947 *
7948 *     Notes:
7949 *
7950 *     File  :
7951 *
7952 **********************************************************/
7953 S16 cmUnpkRgrLoadInfIndInfo
7954 (
7955 RgrLoadInfIndInfo *param,
7956 Pst *pst,
7957 Buffer *mBuf
7958 )
7959 {
7960    S8          idx;
7961
7962    /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
7963    TknStrOSXL  *tknStr;
7964    uint16_t         ndx;
7965
7966
7967    CMCHKUNPK(oduPackUInt32, &param->type, mBuf);
7968    if(RGR_ABS == param->type)
7969    {
7970       for(idx = RGR_ABS_PATTERN_LEN -1 ; idx >= 0; idx--)
7971       {
7972          CMCHKUNPK(oduPackUInt32, &param->u.absLoadInfo[(uint8_t)idx], mBuf);
7973       }
7974    }
7975    else
7976    {
7977
7978       /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Start */
7979       tknStr = &param->u.rntpInfo;
7980
7981       CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
7982
7983       if(tknStr->pres)
7984       {
7985          /* Length */
7986          CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
7987
7988          if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&tknStr->val,tknStr->len)) != ROK) {
7989 #if (ERRCLASS & ERRCLS_ADD_RES)
7990             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
7991                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
7992                (ErrVal)ERGR052, (ErrVal)0, "Packing failed");
7993 #endif
7994             SPutMsg(mBuf);
7995             return RFAILED;
7996          }
7997
7998          /* Value */
7999          for (ndx = 1; ndx <= tknStr->len; ndx++)
8000          {
8001             CMCHKUNPK(oduPackUInt8, &tknStr->val[tknStr->len - ndx], mBuf);
8002          }
8003       }
8004    }
8005    /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** End */
8006
8007    /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
8008    CMCHKUNPK(oduPackUInt16, &param->bw, mBuf);
8009
8010    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
8011
8012    return ROK;
8013 }
8014 /* LTE_ADV_FLAG_REMOVED_END */
8015
8016 #ifdef TFU_UPGRADE
8017 /*rgr_c_001.main_9 ADD added changes for CQI management*/
8018 /***********************************************************
8019 *
8020 *     Func : cmPkRgrUepACfg
8021 *
8022 *
8023 *     Desc : Transaction ID between MAC and RRM
8024 *
8025 *
8026 *     Ret  : S16
8027 *
8028 *     Notes:
8029 *
8030 *     File  :
8031 *
8032 **********************************************************/
8033 S16 cmPkRgrUepACfg
8034 (
8035 RgrUepACfg *param,
8036 Buffer *mBuf
8037 )
8038 {
8039
8040    if(param->pAPrsnt)
8041    {
8042       CMCHKPK(oduUnpackUInt32, param->pA, mBuf);
8043    }
8044    CMCHKPK(oduUnpackUInt8, param->pAPrsnt, mBuf);
8045
8046    return ROK;
8047 }
8048
8049 \f
8050 /*rgr_c_001.main_9 ADD added changes for CQI management*/
8051 /***********************************************************
8052 *
8053 *     Func : cmUnpkRgrUepACfg
8054 *
8055 *
8056 *     Desc : Transaction ID between MAC and RRM
8057 *
8058 *
8059 *     Ret  : S16
8060 *
8061 *     Notes:
8062 *
8063 *     File  :
8064 *
8065 **********************************************************/
8066 S16 cmUnpkRgrUepACfg
8067 (
8068 RgrUepACfg *param,
8069 Buffer *mBuf
8070 )
8071 {
8072    uint32_t tmpEnum;
8073
8074    CMCHKUNPK(oduPackUInt8, (uint8_t *)&param->pAPrsnt, mBuf);
8075    if (param->pAPrsnt)
8076    {
8077       CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
8078       param->pA = (RgrUeDlPwrCntrlPaCfg) tmpEnum;
8079    }
8080
8081    return ROK;
8082 }
8083 \f
8084 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
8085 /***********************************************************
8086 *
8087 *     Func : cmPkRgrUePdschDedCfg
8088 *
8089 *
8090 *     Desc : Transaction ID between MAC and RRM
8091 *
8092 *
8093 *     Ret  : S16
8094 *
8095 *     Notes:
8096 *
8097 *     File  :
8098 *
8099 **********************************************************/
8100 S16 cmPkRgrUePdschDedCfg
8101 (
8102 RgrUePdschDedCfg *param,
8103 Buffer *mBuf
8104 )
8105 {
8106
8107    CMCHKPK(cmPkRgrUepACfg, &param->uepACfg, mBuf);
8108
8109    return ROK;
8110 }
8111
8112 \f
8113 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
8114 /***********************************************************
8115 *
8116 *     Func : cmUnpkRgrUePdschDedCfg
8117 *
8118 *
8119 *     Desc : Transaction ID between MAC and RRM
8120 *
8121 *
8122 *     Ret  : S16
8123 *
8124 *     Notes:
8125 *
8126 *     File  :
8127 *
8128 **********************************************************/
8129 S16 cmUnpkRgrUePdschDedCfg
8130 (
8131 RgrUePdschDedCfg *param,
8132 Buffer *mBuf
8133 )
8134 {
8135
8136    CMCHKUNPK(cmUnpkRgrUepACfg, &param->uepACfg, mBuf);
8137
8138    return ROK;
8139 }
8140 #endif
8141 \f
8142
8143 #ifdef LTE_ADV
8144
8145 /***********************************************************
8146 *
8147 *     Func : cmPkRgrUeUlPwrDedSCellCfg
8148 *
8149 *
8150 *     Desc : DL Secondary Cell UL PC Info
8151 *
8152 *
8153 *     Ret  : S16
8154 *
8155 *     Notes:
8156 *
8157 *     File  :
8158 *
8159 **********************************************************/
8160 static S16 cmPkRgrUeUlPwrDedSCellCfg
8161 (
8162 RgrUeUlPwrDedSCellCfg *param,
8163 Buffer *mBuf
8164 )
8165 {
8166    CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
8167    CMCHKPK(SPkS8, param->p0UePusch, mBuf);
8168    CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
8169    CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
8170
8171    return ROK;
8172 }
8173
8174 /***********************************************************
8175 *
8176 *     Func : cmUnpkRgrUeUlPwrDedSCellCfg
8177 *
8178 *
8179 *     Desc : Uplink power configuration per UE
8180 *
8181 *
8182 *     Ret  : S16
8183 *
8184 *     Notes:
8185 *
8186 *     File  :
8187 *
8188 **********************************************************/
8189 static S16 cmUnpkRgrUeUlPwrDedSCellCfg
8190 (
8191 RgrUeUlPwrDedSCellCfg *param,
8192 Buffer *mBuf
8193 )
8194 {
8195
8196
8197    CMCHKUNPK(oduPackUInt8, &param->isAccumulated, mBuf);
8198    CMCHKUNPK(oduPackUInt8, &param->isDeltaMCSEnabled, mBuf);
8199    CMCHKUNPK(SUnpkS8, &param->p0UePusch, mBuf);
8200    CMCHKUNPK(oduPackUInt8, &param->pSRSOffset, mBuf);
8201    return ROK;
8202 }
8203
8204
8205
8206
8207 /***********************************************************
8208 *
8209 *     Func : cmPkRgrUeSecCellCfg
8210 *
8211 *
8212 *     Desc : DL Secondary Cell information of the UE
8213 *
8214 *
8215 *     Ret  : S16
8216 *
8217 *     Notes:
8218 *
8219 *     File  :
8220 *
8221 **********************************************************/
8222 static S16 cmPkRgrUeSecCellCfg
8223 (
8224 RgrUeSecCellCfg *param,
8225 Buffer *mBuf
8226 )
8227 {
8228    CMCHKPK(cmPkRgrUeUlPwrDedSCellCfg,&param->ueSCellUlDedPwrCfg, mBuf);
8229    CMCHKPK(oduUnpackUInt8, param->isUlCaEnabled, mBuf);
8230    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
8231 #ifdef TFU_UPGRADE
8232 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
8233    CMCHKPK(cmPkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
8234 #endif
8235    CMCHKPK(cmPkRgrUeDlCqiCfg,&param->ueSCellDlCqiCfg, mBuf);
8236    CMCHKPK(cmPkTknUInt32, &param->sCellDeActTmr, mBuf);
8237    CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
8238    CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
8239
8240    return ROK;
8241 }
8242
8243
8244 \f
8245 /***********************************************************
8246 *
8247 *     Func : cmPkRgrUeSecCellInfo
8248 *
8249 *
8250 *     Desc : Secondary Cell information of the UE
8251 *
8252 *
8253 *     Ret  : S16
8254 *
8255 *     Notes:
8256 *
8257 *     File  :
8258 *
8259 **********************************************************/
8260 S16 cmPkRgrUeSecCellInfo
8261 (
8262 RgrUeSecCellInfo *param,
8263 Buffer *mBuf
8264 )
8265 {
8266    S8 idx;
8267    for(idx = param->numSCells - 1; idx >= 0; idx--)
8268    {
8269       CMCHKPK(cmPkRgrUeSecCellCfg, &param->ueSCellDedCfg[(uint8_t)idx],mBuf);
8270    }
8271
8272    CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
8273
8274    CMCHKPK(oduUnpackUInt8, param->useExtBSRSizes, mBuf);
8275
8276    return ROK;
8277 }
8278
8279 \f
8280 /***********************************************************
8281 *
8282 *     Func : cmUnpkRgrUeSecCellCfg
8283 *
8284 *
8285 *     Desc : DL Secondary Cell information of the UE
8286 *
8287 *
8288 *     Ret  : S16
8289 *
8290 *     Notes:
8291 *
8292 *     File  :
8293 *
8294 **********************************************************/
8295 static S16 cmUnpkRgrUeSecCellCfg
8296 (
8297 RgrUeSecCellCfg *param,
8298 Buffer *mBuf
8299 )
8300 {
8301    CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
8302    CMCHKUNPK(oduPackUInt16, &param->sCellId, mBuf);
8303    CMCHKUNPK(cmUnpkTknUInt32, &param->sCellDeActTmr, mBuf);
8304    CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, &param->ueSCellDlCqiCfg, mBuf);
8305 #ifdef TFU_UPGRADE
8306    CMCHKUNPK(cmUnpkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
8307 #endif
8308    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
8309    CMCHKUNPK(oduPackUInt8, &param->isUlCaEnabled, mBuf);
8310    CMCHKUNPK(cmUnpkRgrUeUlPwrDedSCellCfg, &param->ueSCellUlDedPwrCfg, mBuf);
8311
8312    return ROK;
8313 }
8314
8315
8316
8317 \f
8318 /***********************************************************
8319 *
8320 *     Func : cmUnpkRgrUeSecCellInfo
8321 *
8322 *
8323 *     Desc : Secondary Cell information of the UE
8324 *
8325 *
8326 *     Ret  : S16
8327 *
8328 *     Notes:
8329 *
8330 *     File  :
8331 *
8332 **********************************************************/
8333 S16 cmUnpkRgrUeSecCellInfo
8334 (
8335 RgrUeSecCellInfo *param,
8336 Buffer *mBuf
8337 )
8338 {
8339    uint8_t idx;
8340
8341    CMCHKUNPK(oduPackUInt8, &param->useExtBSRSizes, mBuf);
8342    CMCHKUNPK(oduPackUInt8, &param->numSCells, mBuf);
8343
8344    for(idx = 0; idx < param->numSCells;idx++)
8345    {
8346       CMCHKUNPK(cmUnpkRgrUeSecCellCfg, &param->ueSCellDedCfg[idx],mBuf);
8347    }
8348
8349    return ROK;
8350 }
8351 /* Sprint 3 */
8352 /***********************************************************
8353 *
8354 *     Func : cmPkRgrUeSCellAckPucchCfg
8355 *
8356 *
8357 *     Desc : PUCCH Configuration information of the UE
8358 *
8359 *
8360 *     Ret  : S16
8361 *
8362 *     Notes:
8363 *
8364 *     File  :
8365 *
8366 **********************************************************/
8367 S16 cmPkRgrUeSCellAckPucchCfg
8368 (
8369 RgrUeSCellAckPucchCfg *param,
8370 Buffer *mBuf
8371 )
8372 {
8373    S8 idx;
8374
8375    if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
8376    {
8377       for(idx = param->u.format1Bcs.sCellAckN1ResTb2Count - 1; idx >=0 ;idx--)
8378       {
8379          CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(uint8_t)idx], mBuf);
8380       }
8381
8382       CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
8383
8384       for(idx = param->u.format1Bcs.sCellAckN1ResTb1Count - 1; idx >=0 ;idx--)
8385       {
8386          CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(uint8_t)idx], mBuf);
8387       }
8388
8389       CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
8390    }
8391    else
8392    {
8393       for(idx = param->u.format3.sCellAckN3ResAntP1Count - 1; idx >=0 ;idx--)
8394       {
8395          CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(uint8_t)idx], mBuf);
8396       }
8397
8398       CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
8399
8400       for(idx = param->u.format3.sCellAckN3ResAntP0Count- 1; idx >=0 ;idx--)
8401       {
8402          CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(uint8_t)idx], mBuf);
8403       }
8404
8405       CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
8406    }
8407    CMCHKPK(oduUnpackUInt32, param->pucchFormatType, mBuf);
8408
8409    return ROK;
8410 }
8411
8412 /***********************************************************
8413 *
8414 *     Func : cmUnpkRgrUeSCellAckPucchCfg
8415 *
8416 *
8417 *     Desc : PUCCH Configuration information of the UE
8418 *
8419 *
8420 *     Ret  : S16
8421 *
8422 *     Notes:
8423 *
8424 *     File  :
8425 *
8426 **********************************************************/
8427 S16 cmUnpkRgrUeSCellAckPucchCfg
8428 (
8429 RgrUeSCellAckPucchCfg *param,
8430 Buffer *mBuf
8431 )
8432 {
8433    uint8_t idx;
8434
8435
8436    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pucchFormatType, mBuf);
8437    //if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS)
8438    if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
8439    {
8440       CMCHKUNPK(oduPackUInt8, &param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
8441
8442       for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb1Count; idx++)
8443       {
8444          CMCHKUNPK(oduPackUInt16, &param->u.format1Bcs.sCellAckN1ResTb1[idx], mBuf);
8445       }
8446
8447       CMCHKUNPK(oduPackUInt8, &param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
8448
8449       for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb2Count; idx++)
8450       {
8451          CMCHKUNPK(oduPackUInt16, &param->u.format1Bcs.sCellAckN1ResTb2[idx], mBuf);
8452       }
8453    }
8454    else
8455    {
8456       CMCHKUNPK(oduPackUInt8, &param->u.format3.sCellAckN3ResAntP0Count, mBuf);
8457
8458       for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP0Count; idx++)
8459       {
8460          CMCHKUNPK(oduPackUInt16, &param->u.format3.sCellAckN3ResAntP0[idx], mBuf);
8461       }
8462
8463       CMCHKUNPK(oduPackUInt8, &param->u.format3.sCellAckN3ResAntP1Count, mBuf);
8464
8465       for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP1Count; idx++)
8466       {
8467          CMCHKUNPK(oduPackUInt16, &param->u.format3.sCellAckN3ResAntP1[idx], mBuf);
8468       }
8469
8470    }
8471    return ROK;
8472 }
8473
8474
8475
8476
8477 #endif
8478
8479 \f
8480 /***********************************************************
8481 *
8482 *     Func : cmPkRgrUeStaInd
8483 *
8484 *
8485 *     Desc : Packing Ue Sta Indication sent to RRM
8486 *
8487 *
8488 *     Ret  : S16
8489 *
8490 *     Notes:
8491 *
8492 *     File  :
8493 *
8494 **********************************************************/
8495 S16 cmPkRgrUeStaInd
8496 (
8497 Pst* pst,
8498 SuId suId,
8499 RgrUeStaIndInfo* ueStaInd
8500 )
8501 {
8502    Buffer *mBuf = NULLP;
8503    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
8504    {
8505 #if (ERRCLASS & ERRCLS_ADD_RES)
8506       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8507          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8508          (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
8509 #endif
8510       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
8511                sizeof(RgrUeStaIndInfo));
8512       return RFAILED;
8513    }
8514
8515    if (cmPkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
8516    {
8517 #if (ERRCLASS & ERRCLS_ADD_RES)
8518       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8519             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8520             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
8521 #endif
8522       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
8523                sizeof(RgrUeStaIndInfo));
8524       SPutMsg(mBuf);
8525       return RFAILED;
8526    }
8527
8528    if (SPkS16(suId, mBuf) != ROK)
8529    {
8530 #if (ERRCLASS & ERRCLS_ADD_RES)
8531       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8532          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8533          (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
8534 #endif
8535       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
8536                   sizeof(RgrUeStaIndInfo));
8537       SPutMsg(mBuf);
8538       return RFAILED;
8539    }
8540
8541    if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
8542                   sizeof(RgrUeStaIndInfo)) != ROK)
8543    {
8544 #if (ERRCLASS & ERRCLS_ADD_RES)
8545       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8546          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8547          (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
8548 #endif
8549       SPutMsg(mBuf);
8550       return RFAILED;
8551    }
8552
8553    pst->event = (Event) EVTRGRUESTAIND;
8554    return (SPstTsk(pst,mBuf));
8555 }
8556
8557 /*rgr_c_001.main_9 ADD added changes for CQI management*/
8558 /***********************************************************
8559 *
8560 *     Func : cmUnpkRgrUeStaInd
8561 *
8562 *
8563 *     Desc : Unpacking Sta Indication sent to RRM
8564 *
8565 *     Ret  : S16
8566 *
8567 *     Notes:
8568 *
8569 *     File  :
8570 *
8571 **********************************************************/
8572 S16 cmUnpkRgrUeStaInd
8573 (
8574 RgrUeStaInd  func,
8575 Pst *pst,
8576 Buffer *mBuf
8577 )
8578 {
8579    SuId suId;
8580    RgrUeStaIndInfo *ueStaInd;
8581
8582
8583    if (SUnpkS16(&suId, mBuf) != ROK)
8584    {
8585       SPutMsg(mBuf);
8586 #if (ERRCLASS & ERRCLS_ADD_RES)
8587       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8588          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8589          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
8590 #endif
8591       return RFAILED;
8592    }
8593
8594    if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&ueStaInd,
8595                  sizeof(RgrUeStaIndInfo))) != ROK)
8596    {
8597 #if (ERRCLASS & ERRCLS_ADD_RES)
8598          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8599             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8600             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
8601 #endif
8602          SPutMsg(mBuf);
8603          return RFAILED;
8604    }
8605
8606    if (cmUnpkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
8607    {
8608       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)ueStaInd,
8609              sizeof(RgrUeStaIndInfo));
8610       SPutMsg(mBuf);
8611 #if (ERRCLASS & ERRCLS_ADD_RES)
8612       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
8613          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
8614          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
8615 #endif
8616       return RFAILED;
8617    }
8618
8619    SPutMsg(mBuf);
8620    return ((*func)(pst, suId, ueStaInd));
8621 }
8622 \f
8623 /***********************************************************
8624 *
8625 *     Func : cmPkRgrUeStaIndInfo
8626 *
8627 *
8628 *     Desc : Packing of UeStaIndInfo structure
8629 *
8630 *     Ret  : S16
8631 *
8632 *     Notes:
8633 *
8634 *     File  :
8635 *
8636 **********************************************************/
8637 S16 cmPkRgrUeStaIndInfo
8638 (
8639 RgrUeStaIndInfo *param,
8640 Buffer *mBuf
8641 )
8642 {
8643
8644
8645    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
8646    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
8647    CMCHKPK(oduUnpackUInt8, param->status, mBuf);
8648
8649    return ROK;
8650 }
8651 /***********************************************************
8652 *
8653 *     Func : cmUnpkRgrUeStaIndInfo
8654 *
8655 *
8656 *     Desc : Unpacking of UeStaIndInfo structure
8657 *
8658 *     Ret  : S16
8659 *
8660 *     Notes:
8661 *
8662 *     File  :
8663 *
8664 **********************************************************/
8665 S16 cmUnpkRgrUeStaIndInfo
8666 (
8667 RgrUeStaIndInfo *param,
8668 Buffer *mBuf
8669 )
8670 {
8671
8672
8673    CMCHKUNPK(oduPackUInt8, &param->status, mBuf);
8674    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
8675    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
8676
8677    return ROK;
8678 }
8679
8680 \f
8681 /***********************************************************
8682 *
8683 *     Func : cmPkRgrCellCsgParamCfg
8684 *
8685 *
8686 *     Desc : CSG Parameter configuration
8687 *
8688 *
8689 *     Ret  : S16
8690 *
8691 *     Notes:
8692 *
8693 *     File  :
8694 *
8695 **********************************************************/
8696 S16 cmPkRgrCellCsgParamCfg
8697 (
8698 RgrCellCsgParamCfg *param,
8699 Buffer *mBuf
8700 )
8701 {
8702
8703
8704    CMCHKPK(oduUnpackUInt8, param->minUlResNonCsg, mBuf);
8705    CMCHKPK(oduUnpackUInt8, param->minDlResNonCsg, mBuf);
8706
8707    return ROK;
8708 }
8709
8710 /***********************************************************
8711 *
8712 *     Func : cmUnpkRgrCellCsgParamCfg
8713 *
8714 *
8715 *     Desc : Unpacking of RgrCellCsgParamCfg structure
8716 *
8717 *     Ret  : S16
8718 *
8719 *     Notes:
8720 *
8721 *     File  :
8722 *
8723 **********************************************************/
8724 S16 cmUnpkRgrCellCsgParamCfg
8725 (
8726 RgrCellCsgParamCfg *param,
8727 Buffer *mBuf
8728 )
8729 {
8730
8731
8732    CMCHKUNPK(oduPackUInt8, &param->minDlResNonCsg, mBuf);
8733    CMCHKUNPK(oduPackUInt8, &param->minUlResNonCsg, mBuf);
8734
8735    return ROK;
8736 }
8737
8738 /***********************************************************
8739 *
8740 *     Func : cmPkRgrCellCntrlCmdCfg
8741 *
8742 *
8743 *     Desc : Packing of RgrCellCntrlCmdCfg structure
8744 *
8745 *     Ret  : S16
8746 *
8747 *     Notes:
8748 *
8749 *     File  :
8750 *
8751 **********************************************************/
8752 S16 cmPkRgrCellCntrlCmdCfg
8753 (
8754 RgrCellCntrlCmdCfg *param,
8755 Buffer *mBuf
8756 )
8757 {
8758
8759    switch(param->cmdType)
8760    {
8761       case RGR_CNTRL_CMD_RACH_OVRLD:
8762          CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffVal, mBuf);
8763          CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
8764          break;
8765       case RGR_CNTRL_CMD_CPU_OVRLD:
8766          CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.cpuOvrLd.instruction, mBuf);
8767          break;
8768       default:
8769          break;
8770    }
8771    CMCHKUNPK(oduUnpackUInt32, param->cmdType, mBuf);
8772
8773    return ROK;
8774 }
8775 /***********************************************************
8776 *
8777 *     Func : cmUnpkRgrCellCntrlCmdCfg
8778 *
8779 *
8780 *     Desc : Unpacking of RgrCellCntrlCmdCfg structure
8781 *
8782 *     Ret  : S16
8783 *
8784 *     Notes:
8785 *
8786 *     File  :
8787 *
8788 **********************************************************/
8789 S16 cmUnpkRgrCellCntrlCmdCfg
8790 (
8791 RgrCellCntrlCmdCfg *param,
8792 Buffer *mBuf
8793 )
8794 {
8795    uint32_t tmpEnum;
8796
8797
8798    CMCHKUNPK(oduPackUInt32, &tmpEnum, mBuf);
8799    param->cmdType = (RgrCellCntrlCmdType) tmpEnum;
8800    switch(param->cmdType)
8801    {
8802       case RGR_CNTRL_CMD_RACH_OVRLD:
8803          CMCHKUNPK(oduPackUInt8, &param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
8804          CMCHKUNPK(oduPackUInt8, &param->cmdDesc.rachOvrLd.backOffVal, mBuf);
8805          break;
8806       case RGR_CNTRL_CMD_CPU_OVRLD:
8807          CMCHKUNPK(oduPackUInt8, &param->cmdDesc.cpuOvrLd.instruction, mBuf);
8808          break;
8809       default:
8810          break;
8811    }
8812
8813    return ROK;
8814 }
8815 #endif /* End of if defined(LCRGR) */
8816
8817 /**********************************************************************
8818          End of file
8819 **********************************************************************/