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 : cmPkRgrBndReq
  48 *
  49 *
  50 *     Desc : Request from RRM to MAC to bind the interface saps
  51 *
  52 *
  53 *     Ret  : S16
  54 *
  55 *     Notes:
  56 *
  57 *     File  :
  58 *
  59 **********************************************************/
  60 #ifdef ANSI
  61 S16 cmPkRgrBndReq
  62 (
  63 Pst* pst,
  64 SuId suId,
  65 SpId spId
  66 )
  67 #else
  68 S16 cmPkRgrBndReq(pst, suId, spId)
  69 Pst* pst;
  70 SuId suId;
  71 SpId spId;
  72 #endif
  73 {
  74    Buffer *mBuf = NULLP;
  75
  76    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
  77 #if (ERRCLASS & ERRCLS_ADD_RES)
  78       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  79          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  80          (ErrVal)ERGR001, (ErrVal)0, "Packing failed");
  81 #endif
  82       return RFAILED;
  83    }
  84    if (SPkS16(spId, mBuf) != ROK) {
  85 #if (ERRCLASS & ERRCLS_ADD_RES)
  86       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  87          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  88          (ErrVal)ERGR002, (ErrVal)0, "Packing failed");
  89 #endif
  90       SPutMsg(mBuf);
  91       return RFAILED;
  92    }
  93    if (SPkS16(suId, mBuf) != ROK) {
  94 #if (ERRCLASS & ERRCLS_ADD_RES)
  95       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  96          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  97          (ErrVal)ERGR003, (ErrVal)0, "Packing failed");
  98 #endif
  99       SPutMsg(mBuf);
 100       return RFAILED;
 101    }
 102    pst->event = (Event) EVTRGRBNDREQ;
 103    return (SPstTsk(pst,mBuf));
 104 }
 105
 106 \f
 107 /***********************************************************
 108 *
 109 *     Func : cmUnpkRgrBndReq
 110 *
 111 *
 112 *     Desc : Request from RRM to MAC to bind the interface saps
 113 *
 114 *
 115 *     Ret  : S16
 116 *
 117 *     Notes:
 118 *
 119 *     File  :
 120 *
 121 **********************************************************/
 122 #ifdef ANSI
 123 S16 cmUnpkRgrBndReq
 124 (
 125 RgrBndReq func,
 126 Pst *pst,
 127 Buffer *mBuf
 128 )
 129 #else
 130 S16 cmUnpkRgrBndReq(func, pst, mBuf)
 131 RgrBndReq func;
 132 Pst *pst;
 133 Buffer *mBuf;
 134 #endif
 135 {
 136    SuId suId;
 137    SpId spId;
 138
 139
 140    if (SUnpkS16(&suId, mBuf) != ROK) {
 141       SPutMsg(mBuf);
 142 #if (ERRCLASS & ERRCLS_ADD_RES)
 143       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 144          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 145          (ErrVal)ERGR004, (ErrVal)0, "Packing failed");
 146 #endif
 147       return RFAILED;
 148    }
 149    if (SUnpkS16(&spId, mBuf) != ROK) {
 150       SPutMsg(mBuf);
 151 #if (ERRCLASS & ERRCLS_ADD_RES)
 152       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 153          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 154          (ErrVal)ERGR005, (ErrVal)0, "Packing failed");
 155 #endif
 156       return RFAILED;
 157    }
 158    SPutMsg(mBuf);
 159    return ((*func)(pst, suId, spId));
 160 }
 161
 162 \f
 163 /***********************************************************
 164 *
 165 *     Func : cmPkRgrBndCfm
 166 *
 167 *
 168 *     Desc : Confirmation from MAC to RRM for the bind/Unbind
 169  * request for the interface saps
 170 *
 171 *
 172 *     Ret  : S16
 173 *
 174 *     Notes:
 175 *
 176 *     File  :
 177 *
 178 **********************************************************/
 179 #ifdef ANSI
 180 S16 cmPkRgrBndCfm
 181 (
 182 Pst* pst,
 183 SuId suId,
 184 uint8_t status
 185 )
 186 #else
 187 S16 cmPkRgrBndCfm(pst, suId, status)
 188 Pst* pst;
 189 SuId suId;
 190 uint8_t status;
 191 #endif
 192 {
 193    Buffer *mBuf = NULLP;
 194
 195    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 196 #if (ERRCLASS & ERRCLS_ADD_RES)
 197       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 198          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 199          (ErrVal)ERGR006, (ErrVal)0, "Packing failed");
 200 #endif
 201       return RFAILED;
 202    }
 203    if (oduUnpackUInt8(status, mBuf) != ROK) {
 204 #if (ERRCLASS & ERRCLS_ADD_RES)
 205       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 206          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 207          (ErrVal)ERGR007, (ErrVal)0, "Packing failed");
 208 #endif
 209       SPutMsg(mBuf);
 210       return RFAILED;
 211    }
 212    if (SPkS16(suId, mBuf) != ROK) {
 213 #if (ERRCLASS & ERRCLS_ADD_RES)
 214       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 215          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 216          (ErrVal)ERGR008, (ErrVal)0, "Packing failed");
 217 #endif
 218       SPutMsg(mBuf);
 219       return RFAILED;
 220    }
 221    pst->event = (Event) EVTRGRBNDCFM;
 222    return (SPstTsk(pst,mBuf));
 223 }
 224
 225 \f
 226 /***********************************************************
 227 *
 228 *     Func : cmUnpkRgrBndCfm
 229 *
 230 *
 231 *     Desc : Confirmation from MAC to RRM for the bind/Unbind
 232  * request for the interface saps
 233 *
 234 *
 235 *     Ret  : S16
 236 *
 237 *     Notes:
 238 *
 239 *     File  :
 240 *
 241 **********************************************************/
 242 #ifdef ANSI
 243 S16 cmUnpkRgrBndCfm
 244 (
 245 RgrBndCfm func,
 246 Pst *pst,
 247 Buffer *mBuf
 248 )
 249 #else
 250 S16 cmUnpkRgrBndCfm(func, pst, mBuf)
 251 RgrBndCfm func;
 252 Pst *pst;
 253 Buffer *mBuf;
 254 #endif
 255 {
 256    SuId suId;
 257    uint8_t status;
 258
 259
 260    if (SUnpkS16(&suId, mBuf) != ROK) {
 261       SPutMsg(mBuf);
 262 #if (ERRCLASS & ERRCLS_ADD_RES)
 263       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 264          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 265          (ErrVal)ERGR009, (ErrVal)0, "Packing failed");
 266 #endif
 267       return RFAILED;
 268    }
 269    if (oduPackUInt8(&status, mBuf) != ROK) {
 270       SPutMsg(mBuf);
 271 #if (ERRCLASS & ERRCLS_ADD_RES)
 272       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 273          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 274          (ErrVal)ERGR010, (ErrVal)0, "Packing failed");
 275 #endif
 276       return RFAILED;
 277    }
 278    SPutMsg(mBuf);
 279    return ((*func)(pst, suId, status));
 280 }
 281
 282 \f
 283 /***********************************************************
 284 *
 285 *     Func : cmPkRgrUbndReq
 286 *
 287 *
 288 *     Desc : Request from RRM to MAC to Unbind the interface saps
 289 *
 290 *
 291 *     Ret  : S16
 292 *
 293 *     Notes:
 294 *
 295 *     File  :
 296 *
 297 **********************************************************/
 298 #ifdef ANSI
 299 S16 cmPkRgrUbndReq
 300 (
 301 Pst* pst,
 302 SpId spId,
 303 Reason reason
 304 )
 305 #else
 306 S16 cmPkRgrUbndReq(pst, spId, reason)
 307 Pst* pst;
 308 SpId spId;
 309 Reason reason;
 310 #endif
 311 {
 312    Buffer *mBuf = NULLP;
 313
 314    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 315 #if (ERRCLASS & ERRCLS_ADD_RES)
 316       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 317          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 318          (ErrVal)ERGR011, (ErrVal)0, "Packing failed");
 319 #endif
 320       return RFAILED;
 321    }
 322    if (SPkS16(reason, mBuf) != ROK) {
 323 #if (ERRCLASS & ERRCLS_ADD_RES)
 324       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 325          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 326          (ErrVal)ERGR012, (ErrVal)0, "Packing failed");
 327 #endif
 328       SPutMsg(mBuf);
 329       return RFAILED;
 330    }
 331    if (SPkS16(spId, mBuf) != ROK) {
 332 #if (ERRCLASS & ERRCLS_ADD_RES)
 333       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 334          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 335          (ErrVal)ERGR013, (ErrVal)0, "Packing failed");
 336 #endif
 337       SPutMsg(mBuf);
 338       return RFAILED;
 339    }
 340    pst->event = (Event) EVTRGRUBNDREQ;
 341    return (SPstTsk(pst,mBuf));
 342 }
 343
 344 \f
 345 /***********************************************************
 346 *
 347 *     Func : cmUnpkRgrUbndReq
 348 *
 349 *
 350 *     Desc : Request from RRM to MAC to Unbind the interface saps
 351 *
 352 *
 353 *     Ret  : S16
 354 *
 355 *     Notes:
 356 *
 357 *     File  :
 358 *
 359 **********************************************************/
 360 #ifdef ANSI
 361 S16 cmUnpkRgrUbndReq
 362 (
 363 RgrUbndReq func,
 364 Pst *pst,
 365 Buffer *mBuf
 366 )
 367 #else
 368 S16 cmUnpkRgrUbndReq(func, pst, mBuf)
 369 RgrUbndReq func;
 370 Pst *pst;
 371 Buffer *mBuf;
 372 #endif
 373 {
 374    SpId spId;
 375    Reason reason;
 376
 377
 378    if (SUnpkS16(&spId, mBuf) != ROK) {
 379       SPutMsg(mBuf);
 380 #if (ERRCLASS & ERRCLS_ADD_RES)
 381       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 382          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 383          (ErrVal)ERGR014, (ErrVal)0, "Packing failed");
 384 #endif
 385       return RFAILED;
 386    }
 387    if (SUnpkS16(&reason, mBuf) != ROK) {
 388       SPutMsg(mBuf);
 389 #if (ERRCLASS & ERRCLS_ADD_RES)
 390       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 391          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 392          (ErrVal)ERGR015, (ErrVal)0, "Packing failed");
 393 #endif
 394       return RFAILED;
 395    }
 396    SPutMsg(mBuf);
 397    return ((*func)(pst, spId, reason));
 398 }
 399
 400 \f
 401 /***********************************************************
 402 *
 403 *     Func : cmUnpkRgrCfgReq
 404 *
 405 *
 406 *     Desc : Configuration Request from RRM to MAC for
 407  * configuring Cell/Ue/Lc
 408 *
 409 *
 410 *     Ret  : S16
 411 *
 412 *     Notes:
 413 *
 414 *     File  :
 415 *
 416 **********************************************************/
 417 #ifdef ANSI
 418 S16 cmUnpkRgrCfgReq
 419 (
 420 RgrCfgReq func,
 421 Pst *pst,
 422 Buffer *mBuf
 423 )
 424 #else
 425 S16 cmUnpkRgrCfgReq(func, pst, mBuf)
 426 RgrCfgReq func;
 427 Pst *pst;
 428 Buffer *mBuf;
 429 #endif
 430 {
 431    RgrCfgTransId transId;
 432    RgrCfgReqInfo *cfgReqInfo;
 433
 434 #if 0
 435    if (SUnpkS16(&spId, mBuf) != ROK) {
 436       SPutMsg(mBuf);
 437 #if (ERRCLASS & ERRCLS_ADD_RES)
 438       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 439          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 440          (ErrVal)ERGR021, (ErrVal)0, "Packing failed");
 441 #endif
 442       return RFAILED;
 443    }
 444 #endif
 445
 446    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
 447       SPutMsg(mBuf);
 448 #if (ERRCLASS & ERRCLS_ADD_RES)
 449       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 450          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 451          (ErrVal)ERGR022, (ErrVal)0, "Packing failed");
 452 #endif
 453       return RFAILED;
 454    }
 455    if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,sizeof(RgrCfgReqInfo))) != ROK) {
 456 #if (ERRCLASS & ERRCLS_ADD_RES)
 457       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 458             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 459             (ErrVal)ERGR023, (ErrVal)0, "Packing failed");
 460 #endif
 461       SPutMsg(mBuf);
 462       return RFAILED;
 463    }
 464    memset(cfgReqInfo, 0, sizeof(RgrCfgReqInfo));
 465    if (pst->selector == ODU_SELECTOR_LC)
 466       if (cmUnpkRgrCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
 467          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(RgrCfgReqInfo));
 468          SPutMsg(mBuf);
 469 #if (ERRCLASS & ERRCLS_ADD_RES)
 470          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 471                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 472                (ErrVal)ERGR024, (ErrVal)0, "Packing failed");
 473 #endif
 474          return RFAILED;
 475       }
 476    SPutMsg(mBuf);
 477    return ((*func)(pst, transId, cfgReqInfo));
 478 }
 479
 480 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
 481 \f
 482 /***********************************************************
 483 *
 484 *     Func : cmPkRgrTtiIndInfo
 485 *
 486 *
 487 *     Desc : Packs the TTI indication information.
 488 *
 489 *
 490 *     Ret  : S16
 491 *
 492 *     Notes:
 493 *
 494 *     File  :
 495 *
 496 **********************************************************/
 497 #ifdef ANSI
 498 S16 cmPkRgrTtiIndInfo
 499 (
 500 RgrTtiIndInfo *param,
 501 Buffer        *mBuf
 502 )
 503 #else
 504 S16 cmPkRgrTtiIndInfo(param, mBuf)
 505 RgrTtiIndInfo *param;
 506 Buffer        *mBuf;
 507 #endif
 508 {
 509    CMCHKPK(oduUnpackUInt16, param->sfn, mBuf);
 510    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 511    return ROK;
 512 }
 513 \f
 514 /***********************************************************
 515 *
 516 *     Func : cmUnpkRgrTtiIndInfo
 517 *
 518 *
 519 *     Desc : Unpacking for RgrTtiIndInfo
 520 *
 521 *     Ret  : S16
 522 *
 523 *     Notes:
 524 *
 525 *     File  :
 526 *
 527 **********************************************************/
 528 #ifdef ANSI
 529 S16 cmUnpkRgrTtiIndInfo
 530 (
 531 RgrTtiIndInfo *param,
 532 Buffer *mBuf
 533 )
 534 #else
 535 S16 cmUnpkRgrTtiIndInfo(param, mBuf)
 536 RgrTtiIndInfo *param;
 537 Buffer *mBuf;
 538 #endif
 539 {
 540
 541    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 542    CMCHKUNPK(oduPackUInt16, &param->sfn, mBuf);
 543    return ROK;
 544 }
 545
 546 \f
 547 /***********************************************************
 548 *
 549 *     Func : cmPkRgrTtiInd
 550 *
 551 *
 552 *     Desc : TTI indication  from MAC to RRM
 553 *
 554 *
 555 *     Ret  : S16
 556 *
 557 *     Notes:
 558 *
 559 *     File  :
 560 *
 561 **********************************************************/
 562 #ifdef ANSI
 563 S16 cmPkRgrTtiInd
 564 (
 565 Pst* pst,
 566 SuId suId,
 567 RgrTtiIndInfo *ttiInd
 568 )
 569 #else
 570 S16 cmPkRgrTtiInd(pst, suId, ttiInd)
 571 Pst* pst;
 572 SuId suId;
 573 RgrTtiIndInfo *ttiInd;
 574 #endif
 575 {
 576    Buffer *mBuf = NULLP;
 577
 578    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 579 #if (ERRCLASS & ERRCLS_ADD_RES)
 580       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 581          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 582          (ErrVal)ERGR025, (ErrVal)0, "Packing failed");
 583 #endif
 584       return RFAILED;
 585    }
 586    if (cmPkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
 587 #if (ERRCLASS & ERRCLS_ADD_RES)
 588       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 589          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 590          (ErrVal)ERGR026, (ErrVal)0, "Packing failed");
 591 #endif
 592       SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
 593       SPutMsg(mBuf);
 594       return RFAILED;
 595    }
 596    if (SPkS16(suId, mBuf) != ROK) {
 597 #if (ERRCLASS & ERRCLS_ADD_RES)
 598       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 599          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 600          (ErrVal)ERGR027, (ErrVal)0, "Packing failed");
 601 #endif
 602       SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
 603       SPutMsg(mBuf);
 604       return RFAILED;
 605    }
 606    SPutSBuf(pst->region, pst->pool, (Data *)ttiInd, sizeof(RgrTtiIndInfo));
 607    pst->event = (Event) EVTRGRTTIIND;
 608    return (SPstTsk(pst,mBuf));
 609 }
 610
 611 \f
 612 /***********************************************************
 613 *
 614 *     Func : cmUnpkRgrTtiInd
 615 *
 616 *
 617 *     Desc : TTI indication from MAC to RRM
 618 *
 619 *
 620 *     Ret  : S16
 621 *
 622 *     Notes:
 623 *
 624 *     File  :
 625 *
 626 **********************************************************/
 627 #ifdef ANSI
 628 S16 cmUnpkRgrTtiInd
 629 (
 630 RgrTtiInd func,
 631 Pst *pst,
 632 Buffer *mBuf
 633 )
 634 #else
 635 S16 cmUnpkRgrTtiInd(func, pst, mBuf)
 636 RgrTtiInd func;
 637 Pst *pst;
 638 Buffer *mBuf;
 639 #endif
 640 {
 641    SuId suId;
 642    RgrTtiIndInfo *ttiInd;
 643
 644
 645    if (SUnpkS16(&suId, mBuf) != ROK) {
 646       SPutMsg(mBuf);
 647 #if (ERRCLASS & ERRCLS_ADD_RES)
 648       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 649          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 650          (ErrVal)ERGR028, (ErrVal)0, "Packing failed");
 651 #endif
 652       return RFAILED;
 653    }
 654    if ((SGetSBuf(pst->region, pst->pool, (Data **)&ttiInd, sizeof(RgrTtiIndInfo))) != ROK)
 655    {
 656 #if (ERRCLASS & ERRCLS_ADD_RES)
 657       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 658           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 659           (ErrVal)ERGR029, (ErrVal)0, "UnPacking failed");
 660 #endif
 661       SPutMsg(mBuf);
 662       return RFAILED;
 663    }
 664
 665    if (cmUnpkRgrTtiIndInfo(ttiInd, mBuf) != ROK) {
 666       /*ccpu00114888- Memory Leak issue- Start*/
 667       SPutSBuf(pst->region, pst->pool, (Data *)ttiInd,
 668             sizeof(RgrTtiIndInfo));
 669       /*ccpu00114888- Memory Leak issue- End*/
 670       SPutMsg(mBuf);
 671 #if (ERRCLASS & ERRCLS_ADD_RES)
 672       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 673          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 674          (ErrVal)ERGR030, (ErrVal)0, "Packing failed");
 675 #endif
 676       return RFAILED;
 677    }
 678    SPutMsg(mBuf);
 679    return ((*func)(pst, suId, ttiInd));
 680 }
 681
 682 \f
 683 /***********************************************************
 684 *
 685 *     Func : cmPkRgrCfgCfm
 686 *
 687 *
 688 *     Desc : Configuration Confirm from MAC to RRM
 689 *
 690 *
 691 *     Ret  : S16
 692 *
 693 *     Notes:
 694 *
 695 *     File  :
 696 *
 697 **********************************************************/
 698 #ifdef ANSI
 699 S16 cmPkRgrCfgCfm
 700 (
 701 Pst* pst,
 702 RgrCfgTransId transId,
 703 uint8_t status
 704 )
 705 #else
 706 S16 cmPkRgrCfgCfm(pst, transId, status)
 707 Pst* pst;
 708 RgrCfgTransId transId;
 709 uint8_t status;
 710 #endif
 711 {
 712    Buffer *mBuf = NULLP;
 713
 714    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 715 #if (ERRCLASS & ERRCLS_ADD_RES)
 716       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 717          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 718          (ErrVal)ERGR031, (ErrVal)0, "Packing failed");
 719 #endif
 720       return RFAILED;
 721    }
 722    if (oduUnpackUInt8(status, mBuf) != ROK) {
 723 #if (ERRCLASS & ERRCLS_ADD_RES)
 724       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 725          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 726          (ErrVal)ERGR032, (ErrVal)0, "Packing failed");
 727 #endif
 728       SPutMsg(mBuf);
 729       return RFAILED;
 730    }
 731    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
 732 #if (ERRCLASS & ERRCLS_ADD_RES)
 733       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 734          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 735          (ErrVal)ERGR033, (ErrVal)0, "Packing failed");
 736 #endif
 737       SPutMsg(mBuf);
 738       return RFAILED;
 739    }
 740    pst->event = (Event) EVTMACSCHCFGCFM;
 741    return (SPstTsk(pst,mBuf));
 742 }
 743
 744 \f
 745 /***********************************************************
 746 *
 747 *     Func : cmUnpkRgrCfgCfm
 748 *
 749 *
 750 *     Desc : Configuration Confirm from MAC to RRM
 751 *
 752 *
 753 *     Ret  : S16
 754 *
 755 *     Notes:
 756 *
 757 *     File  :
 758 *
 759 **********************************************************/
 760 #ifdef ANSI
 761 S16 cmUnpkRgrCfgCfm
 762 (
 763 RgrCfgCfm func,
 764 Pst *pst,
 765 Buffer *mBuf
 766 )
 767 #else
 768 S16 cmUnpkRgrCfgCfm(func, pst, mBuf)
 769 RgrCfgCfm func;
 770 Pst *pst;
 771 Buffer *mBuf;
 772 #endif
 773 {
 774    RgrCfgTransId transId;
 775    uint8_t status;
 776
 777
 778    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
 779       SPutMsg(mBuf);
 780 #if (ERRCLASS & ERRCLS_ADD_RES)
 781       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 782          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 783          (ErrVal)ERGR036, (ErrVal)0, "Packing failed");
 784 #endif
 785       return RFAILED;
 786    }
 787    if (oduPackUInt8(&status, mBuf) != ROK) {
 788       SPutMsg(mBuf);
 789 #if (ERRCLASS & ERRCLS_ADD_RES)
 790       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 791          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 792          (ErrVal)ERGR037, (ErrVal)0, "Packing failed");
 793 #endif
 794       return RFAILED;
 795    }
 796    SPutMsg(mBuf);
 797    return ((*func)(pst, transId, status));
 798 }
 799
 800 /* rgr_c_001.main_4: ADD-Added for SI Enhancement. */
 801 #ifdef RGR_SI_SCH
 802 /***********************************************************
 803 *
 804 *     Func : cmPkRgrSiCfgCfm
 805 *
 806 *
 807 *     Desc : SI Configuration Confirm from MAC to RRM
 808 *
 809 *
 810 *     Ret  : S16
 811 *
 812 *     Notes:
 813 *
 814 *     File  :
 815 *
 816 **********************************************************/
 817 #ifdef ANSI
 818 S16 cmPkRgrSiCfgCfm
 819 (
 820 Pst* pst,
 821 SuId suId,
 822 RgrCfgTransId transId,
 823 uint8_t status
 824 )
 825 #else
 826 S16 cmPkRgrSiCfgCfm(pst, suId, transId, status)
 827 Pst* pst;
 828 SuId suId;
 829 RgrCfgTransId transId;
 830 uint8_t status;
 831 #endif
 832 {
 833    Buffer *mBuf = NULLP;
 834
 835
 836    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 837 #if (ERRCLASS & ERRCLS_ADD_RES)
 838       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 839          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 840          (ErrVal)ERGR038, (ErrVal)0, "Packing failed");
 841 #endif
 842       return RFAILED;
 843    }
 844    if (oduUnpackUInt8(status, mBuf) != ROK) {
 845 #if (ERRCLASS & ERRCLS_ADD_RES)
 846       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 847          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 848          (ErrVal)ERGR039, (ErrVal)0, "Packing failed");
 849 #endif
 850       SPutMsg(mBuf);
 851       return RFAILED;
 852    }
 853    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
 854 #if (ERRCLASS & ERRCLS_ADD_RES)
 855       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 856          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 857          (ErrVal)ERGR040, (ErrVal)0, "Packing failed");
 858 #endif
 859       SPutMsg(mBuf);
 860       return RFAILED;
 861    }
 862    if (SPkS16(suId, mBuf) != ROK) {
 863 #if (ERRCLASS & ERRCLS_ADD_RES)
 864       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 865          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 866          (ErrVal)ERGR041, (ErrVal)0, "Packing failed");
 867 #endif
 868       SPutMsg(mBuf);
 869       return RFAILED;
 870    }
 871
 872    pst->event = (Event) EVTRGRSICFGCFM;
 873    return (SPstTsk(pst,mBuf));
 874 }
 875
 876 \f
 877 /***********************************************************
 878 *
 879 *     Func : cmUnpkRgrSiCfgCfm
 880 *
 881 *
 882 *     Desc : Configuration Confirm from MAC to RRM
 883 *
 884 *
 885 *     Ret  : S16
 886 *
 887 *     Notes:
 888 *
 889 *     File  :
 890 *
 891 **********************************************************/
 892 #ifdef ANSI
 893 S16 cmUnpkRgrSiCfgCfm
 894 (
 895 RgrSiCfgCfm func,
 896 Pst *pst,
 897 Buffer *mBuf
 898 )
 899 #else
 900 S16 cmUnpkRgrSiCfgCfm(func, pst, mBuf)
 901 RgrSiCfgCfm func;
 902 Pst *pst;
 903 Buffer *mBuf;
 904 #endif
 905 {
 906    SuId suId;
 907    RgrCfgTransId transId;
 908    uint8_t status;
 909
 910
 911    if (SUnpkS16(&suId, mBuf) != ROK) {
 912       SPutMsg(mBuf);
 913 #if (ERRCLASS & ERRCLS_ADD_RES)
 914       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 915          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 916          (ErrVal)ERGR042, (ErrVal)0, "Packing failed");
 917 #endif
 918       return RFAILED;
 919    }
 920    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
 921       SPutMsg(mBuf);
 922 #if (ERRCLASS & ERRCLS_ADD_RES)
 923       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 924          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 925          (ErrVal)ERGR043, (ErrVal)0, "Packing failed");
 926 #endif
 927       return RFAILED;
 928    }
 929    if (oduPackUInt8(&status, mBuf) != ROK) {
 930       SPutMsg(mBuf);
 931 #if (ERRCLASS & ERRCLS_ADD_RES)
 932       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 933          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 934          (ErrVal)ERGR044, (ErrVal)0, "Packing failed");
 935 #endif
 936       return RFAILED;
 937    }
 938    SPutMsg(mBuf);
 939    return ((*func)(pst, suId, transId, status));
 940 }
 941 #endif/*RGR_SI_SCH*/
 942
 943 \f
 944 /***********************************************************
 945 *
 946 *     Func : cmPkRgrCfgTransId
 947 *
 948 *
 949 *     Desc : Transaction ID between MAC and RRM
 950 *
 951 *
 952 *     Ret  : S16
 953 *
 954 *     Notes:
 955 *
 956 *     File  :
 957 *
 958 **********************************************************/
 959 #ifdef ANSI
 960 S16 cmPkRgrCfgTransId
 961 (
 962 RgrCfgTransId *param,
 963 Buffer *mBuf
 964 )
 965 #else
 966 S16 cmPkRgrCfgTransId(param, mBuf)
 967 RgrCfgTransId *param;
 968 Buffer *mBuf;
 969 #endif
 970 {
 971
 972    S32 i;
 973
 974    for (i=RGR_CFG_TRANSID_SIZE-1; i >= 0; i--) {
 975       CMCHKPK(oduUnpackUInt8, param->trans[i], mBuf);
 976    }
 977    return ROK;
 978 }
 979
 980
 981 \f
 982 /***********************************************************
 983 *
 984 *     Func : cmUnpkRgrCfgTransId
 985 *
 986 *
 987 *     Desc : Transaction ID between MAC and RRM
 988 *
 989 *
 990 *     Ret  : S16
 991 *
 992 *     Notes:
 993 *
 994 *     File  :
 995 *
 996 **********************************************************/
 997 #ifdef ANSI
 998 S16 cmUnpkRgrCfgTransId
 999 (
1000 RgrCfgTransId *param,
1001 Buffer *mBuf
1002 )
1003 #else
1004 S16 cmUnpkRgrCfgTransId(param, mBuf)
1005 RgrCfgTransId *param;
1006 Buffer *mBuf;
1007 #endif
1008 {
1009
1010    S32 i;
1011
1012    for (i=0; i<RGR_CFG_TRANSID_SIZE; i++) {
1013       CMCHKUNPK(oduPackUInt8, &param->trans[i], mBuf);
1014    }
1015    return ROK;
1016 }
1017
1018
1019 \f
1020 /***********************************************************
1021 *
1022 *     Func : cmPkRgrDlHqCfg
1023 *
1024 *
1025 *     Desc :  Downlink HARQ configuration per Cell
1026 *
1027 *
1028 *     Ret  : S16
1029 *
1030 *     Notes:
1031 *
1032 *     File  :
1033 *
1034 **********************************************************/
1035 #ifdef ANSI
1036 S16 cmPkRgrDlHqCfg
1037 (
1038 RgrDlHqCfg *param,
1039 Buffer *mBuf
1040 )
1041 #else
1042 S16 cmPkRgrDlHqCfg(param, mBuf)
1043 RgrDlHqCfg *param;
1044 Buffer *mBuf;
1045 #endif
1046 {
1047
1048
1049    CMCHKPK(oduUnpackUInt8, param->maxMsg4HqTx, mBuf);
1050    CMCHKPK(oduUnpackUInt8, param->maxDlHqTx, mBuf);
1051    return ROK;
1052 }
1053
1054
1055 \f
1056 /***********************************************************
1057 *
1058 *     Func : cmUnpkRgrDlHqCfg
1059 *
1060 *
1061 *     Desc :  Downlink HARQ configuration per Cell
1062 *
1063 *
1064 *     Ret  : S16
1065 *
1066 *     Notes:
1067 *
1068 *     File  :
1069 *
1070 **********************************************************/
1071 #ifdef ANSI
1072 S16 cmUnpkRgrDlHqCfg
1073 (
1074 RgrDlHqCfg *param,
1075 Buffer *mBuf
1076 )
1077 #else
1078 S16 cmUnpkRgrDlHqCfg(param, mBuf)
1079 RgrDlHqCfg *param;
1080 Buffer *mBuf;
1081 #endif
1082 {
1083
1084
1085    CMCHKUNPK(oduPackUInt8, &param->maxDlHqTx, mBuf);
1086    CMCHKUNPK(oduPackUInt8, &param->maxMsg4HqTx, mBuf);
1087    return ROK;
1088 }
1089
1090
1091 \f
1092 /***********************************************************
1093 *
1094 *     Func : cmPkRgrRntiCfg
1095 *
1096 *
1097 *     Desc : Range of RNTIs managed by MAC
1098 *
1099 *
1100 *     Ret  : S16
1101 *
1102 *     Notes:
1103 *
1104 *     File  :
1105 *
1106 **********************************************************/
1107 #ifdef ANSI
1108 S16 cmPkRgrRntiCfg
1109 (
1110 RgrRntiCfg *param,
1111 Buffer *mBuf
1112 )
1113 #else
1114 S16 cmPkRgrRntiCfg(param, mBuf)
1115 RgrRntiCfg *param;
1116 Buffer *mBuf;
1117 #endif
1118 {
1119
1120
1121    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
1122    CMCHKPK(cmPkLteRnti, param->startRnti, mBuf);
1123    return ROK;
1124 }
1125
1126
1127 \f
1128 /***********************************************************
1129 *
1130 *     Func : cmUnpkRgrRntiCfg
1131 *
1132 *
1133 *     Desc : Range of RNTIs managed by MAC
1134 *
1135 *
1136 *     Ret  : S16
1137 *
1138 *     Notes:
1139 *
1140 *     File  :
1141 *
1142 **********************************************************/
1143 #ifdef ANSI
1144 S16 cmUnpkRgrRntiCfg
1145 (
1146 RgrRntiCfg *param,
1147 Buffer *mBuf
1148 )
1149 #else
1150 S16 cmUnpkRgrRntiCfg(param, mBuf)
1151 RgrRntiCfg *param;
1152 Buffer *mBuf;
1153 #endif
1154 {
1155
1156
1157    CMCHKUNPK(cmUnpkLteRnti, &param->startRnti, mBuf);
1158    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
1159    return ROK;
1160 }
1161
1162 #ifdef EMTC_ENABLE
1163 /***********************************************************
1164 *
1165 *     Func : cmPkRgrEmtcRntiCfg
1166 *
1167 *
1168 *     Desc : Range of Emtc RNTIs managed by MAC
1169 *
1170 *
1171 *     Ret  : S16
1172 *
1173 *     Notes:
1174 *
1175 *     File  :
1176 *
1177 **********************************************************/
1178 #ifdef ANSI
1179 S16 cmPkRgrEmtcRntiCfg
1180 (
1181 RgrEmtcRntiCfg *param,
1182 Buffer *mBuf
1183 )
1184 #else
1185 S16 cmPkRgrEmtcRntiCfg(param, mBuf)
1186 RgrEmtcRntiCfg *param;
1187 Buffer *mBuf;
1188 #endif
1189 {
1190
1191
1192    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
1193    CMCHKPK(cmPkLteRnti, param->rntiCeModeBRange, mBuf);
1194    CMCHKPK(cmPkLteRnti, param->rntiCeModeBStart, mBuf);
1195    CMCHKPK(cmPkLteRnti, param->rntiCeModeARange, mBuf);
1196    CMCHKPK(cmPkLteRnti, param->rntiCeModeAStart, mBuf);
1197    return ROK;
1198 }
1199
1200
1201 \f
1202 /***********************************************************
1203 *
1204 *     Func : cmUnpkRgrEmtcRntiCfg
1205 *
1206 *
1207 *     Desc : Range of Emtc RNTIs managed by MAC
1208 *
1209 *
1210 *     Ret  : S16
1211 *
1212 *     Notes:
1213 *
1214 *     File  :
1215 *
1216 **********************************************************/
1217 #ifdef ANSI
1218 S16 cmUnpkRgrEmtcRntiCfg
1219 (
1220 RgrEmtcRntiCfg *param,
1221 Buffer *mBuf
1222 )
1223 #else
1224 S16 cmUnpkRgrEmtcRntiCfg(param, mBuf)
1225 RgrEmtcRntiCfg *param;
1226 Buffer *mBuf;
1227 #endif
1228 {
1229
1230
1231    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeAStart, mBuf);
1232    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeARange, mBuf);
1233    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeBStart, mBuf);
1234    CMCHKUNPK(cmUnpkLteRnti, &param->rntiCeModeBRange, mBuf);
1235    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
1236
1237    return ROK;
1238 }
1239 #endif
1240
1241 \f
1242 /***********************************************************
1243 *
1244 *     Func : cmPkRgrDlCmnCodeRateCfg
1245 *
1246 *
1247 *     Desc : Downlink common channel code rate configuration per cell
1248 *
1249 *
1250 *     Ret  : S16
1251 *
1252 *     Notes:
1253 *
1254 *     File  :
1255 *
1256 **********************************************************/
1257 #ifdef ANSI
1258 S16 cmPkRgrDlCmnCodeRateCfg
1259 (
1260 RgrDlCmnCodeRateCfg *param,
1261 Buffer *mBuf
1262 )
1263 #else
1264 S16 cmPkRgrDlCmnCodeRateCfg(param, mBuf)
1265 RgrDlCmnCodeRateCfg *param;
1266 Buffer *mBuf;
1267 #endif
1268 {
1269
1270    CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
1271    CMCHKPK(oduUnpackUInt16, param->pdcchCodeRate, mBuf);
1272    CMCHKPK(oduUnpackUInt16, param->bcchPchRaCodeRate, mBuf);
1273    return ROK;
1274 }
1275
1276
1277 \f
1278 /***********************************************************
1279 *
1280 *     Func : cmUnpkRgrDlCmnCodeRateCfg
1281 *
1282 *
1283 *     Desc : Downlink common channel code rate configuration per cell
1284 *
1285 *
1286 *     Ret  : S16
1287 *
1288 *     Notes:
1289 *
1290 *     File  :
1291 *
1292 **********************************************************/
1293 #ifdef ANSI
1294 S16 cmUnpkRgrDlCmnCodeRateCfg
1295 (
1296 RgrDlCmnCodeRateCfg *param,
1297 Buffer *mBuf
1298 )
1299 #else
1300 S16 cmUnpkRgrDlCmnCodeRateCfg(param, mBuf)
1301 RgrDlCmnCodeRateCfg *param;
1302 Buffer *mBuf;
1303 #endif
1304 {
1305
1306    CMCHKUNPK(oduPackUInt16, &param->bcchPchRaCodeRate, mBuf);
1307    CMCHKUNPK(oduPackUInt16, &param->pdcchCodeRate, mBuf);
1308    CMCHKUNPK(oduPackUInt8, &param->ccchCqi, mBuf);
1309    return ROK;
1310 }
1311
1312
1313 \f
1314 /***********************************************************
1315 *
1316 *     Func : cmPkRgrCfiCfg
1317 *
1318 *
1319 *     Desc : Control Format Indicator (CFI) configuration per cell
1320 *
1321 *
1322 *     Ret  : S16
1323 *
1324 *     Notes:
1325 *
1326 *     File  :
1327 *
1328 **********************************************************/
1329 #ifdef ANSI
1330 S16 cmPkRgrCfiCfg
1331 (
1332 RgrCfiCfg *param,
1333 Buffer *mBuf
1334 )
1335 #else
1336 S16 cmPkRgrCfiCfg(param, mBuf)
1337 RgrCfiCfg *param;
1338 Buffer *mBuf;
1339 #endif
1340 {
1341
1342    CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
1343    return ROK;
1344 }
1345
1346
1347 \f
1348 /***********************************************************
1349 *
1350 *     Func : cmUnpkRgrCfiCfg
1351 *
1352 *
1353 *     Desc : Control Format Indicator (CFI) configuration per cell
1354 *
1355 *
1356 *     Ret  : S16
1357 *
1358 *     Notes:
1359 *
1360 *     File  :
1361 *
1362 **********************************************************/
1363 #ifdef ANSI
1364 S16 cmUnpkRgrCfiCfg
1365 (
1366 RgrCfiCfg *param,
1367 Buffer *mBuf
1368 )
1369 #else
1370 S16 cmUnpkRgrCfiCfg(param, mBuf)
1371 RgrCfiCfg *param;
1372 Buffer *mBuf;
1373 #endif
1374 {
1375
1376    CMCHKUNPK(oduPackUInt8, &param->cfi, mBuf);
1377    return ROK;
1378 }
1379
1380
1381 \f
1382 /***********************************************************
1383 *
1384 *     Func : cmPkRgrPuschSubBandCfg
1385 *
1386 *
1387 *     Desc : PUSCH sub-band configuration per cell
1388 *
1389 *
1390 *     Ret  : S16
1391 *
1392 *     Notes:
1393 *
1394 *     File  :
1395 *
1396 **********************************************************/
1397 #ifdef ANSI
1398 S16 cmPkRgrPuschSubBandCfg
1399 (
1400 RgrPuschSubBandCfg *param,
1401 Buffer *mBuf
1402 )
1403 #else
1404 S16 cmPkRgrPuschSubBandCfg(param, mBuf)
1405 RgrPuschSubBandCfg *param;
1406 Buffer *mBuf;
1407 #endif
1408 {
1409
1410    S32 i;
1411
1412    for (i=param->numSubbands-1; i >= 0; i--) {
1413       CMCHKPK(oduUnpackUInt8, param->dmrs[i], mBuf);
1414    }
1415    CMCHKPK(oduUnpackUInt8, param->size, mBuf);
1416    CMCHKPK(oduUnpackUInt8, param->numSubbands, mBuf);
1417    CMCHKPK(oduUnpackUInt8, param->subbandStart, mBuf);
1418    return ROK;
1419 }
1420
1421
1422 \f
1423 /***********************************************************
1424 *
1425 *     Func : cmUnpkRgrPuschSubBandCfg
1426 *
1427 *
1428 *     Desc : PUSCH sub-band configuration per cell
1429 *
1430 *
1431 *     Ret  : S16
1432 *
1433 *     Notes:
1434 *
1435 *     File  :
1436 *
1437 **********************************************************/
1438 #ifdef ANSI
1439 S16 cmUnpkRgrPuschSubBandCfg
1440 (
1441 RgrPuschSubBandCfg *param,
1442 Buffer *mBuf
1443 )
1444 #else
1445 S16 cmUnpkRgrPuschSubBandCfg(param, mBuf)
1446 RgrPuschSubBandCfg *param;
1447 Buffer *mBuf;
1448 #endif
1449 {
1450
1451    S32 i;
1452
1453    CMCHKUNPK(oduPackUInt8, &param->subbandStart, mBuf);
1454    CMCHKUNPK(oduPackUInt8, &param->numSubbands, mBuf);
1455    CMCHKUNPK(oduPackUInt8, &param->size, mBuf);
1456    for (i=0; i<param->numSubbands; i++) {
1457       CMCHKUNPK(oduPackUInt8, &param->dmrs[i], mBuf);
1458    }
1459    return ROK;
1460 }
1461
1462
1463 \f
1464 /***********************************************************
1465 *
1466 *     Func : cmPkRgrUlCmnCodeRateCfg
1467 *
1468 *
1469 *     Desc : Uplink common channel code rate configuration per cell
1470 *
1471 *
1472 *     Ret  : S16
1473 *
1474 *     Notes:
1475 *
1476 *     File  :
1477 *
1478 **********************************************************/
1479 #ifdef ANSI
1480 S16 cmPkRgrUlCmnCodeRateCfg
1481 (
1482 RgrUlCmnCodeRateCfg *param,
1483 Buffer *mBuf
1484 )
1485 #else
1486 S16 cmPkRgrUlCmnCodeRateCfg(param, mBuf)
1487 RgrUlCmnCodeRateCfg *param;
1488 Buffer *mBuf;
1489 #endif
1490 {
1491
1492    CMCHKPK(oduUnpackUInt8, param->ccchCqi, mBuf);
1493    return ROK;
1494 }
1495
1496
1497 \f
1498 /***********************************************************
1499 *
1500 *     Func : cmUnpkRgrUlCmnCodeRateCfg
1501 *
1502 *
1503 *     Desc : Uplink common channel code rate configuration per cell
1504 *
1505 *
1506 *     Ret  : S16
1507 *
1508 *     Notes:
1509 *
1510 *     File  :
1511 *
1512 **********************************************************/
1513 #ifdef ANSI
1514 S16 cmUnpkRgrUlCmnCodeRateCfg
1515 (
1516 RgrUlCmnCodeRateCfg *param,
1517 Buffer *mBuf
1518 )
1519 #else
1520 S16 cmUnpkRgrUlCmnCodeRateCfg(param, mBuf)
1521 RgrUlCmnCodeRateCfg *param;
1522 Buffer *mBuf;
1523 #endif
1524 {
1525
1526    CMCHKUNPK(oduPackUInt8, &param->ccchCqi, mBuf);
1527    return ROK;
1528 }
1529
1530
1531 \f
1532 /***********************************************************
1533 *
1534 *     Func : cmPkRgrUlTrgCqiCfg
1535 *
1536 *
1537 *     Desc : Target Uplink CQI to achieve through group power control configured per cell
1538 *
1539 *
1540 *     Ret  : S16
1541 *
1542 *     Notes:
1543 *
1544 *     File  :
1545 *
1546 **********************************************************/
1547 #ifdef ANSI
1548 S16 cmPkRgrUlTrgCqiCfg
1549 (
1550 RgrUlTrgCqiCfg *param,
1551 Buffer *mBuf
1552 )
1553 #else
1554 S16 cmPkRgrUlTrgCqiCfg(param, mBuf)
1555 RgrUlTrgCqiCfg *param;
1556 Buffer *mBuf;
1557 #endif
1558 {
1559
1560    CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
1561    return ROK;
1562 }
1563
1564
1565 \f
1566 /***********************************************************
1567 *
1568 *     Func : cmUnpkRgrUlTrgCqiCfg
1569 *
1570 *
1571 *     Desc : Target Uplink CQI to achieve through group power control configured per cell
1572 *
1573 *
1574 *     Ret  : S16
1575 *
1576 *     Notes:
1577 *
1578 *     File  :
1579 *
1580 **********************************************************/
1581 #ifdef ANSI
1582 S16 cmUnpkRgrUlTrgCqiCfg
1583 (
1584 RgrUlTrgCqiCfg *param,
1585 Buffer *mBuf
1586 )
1587 #else
1588 S16 cmUnpkRgrUlTrgCqiCfg(param, mBuf)
1589 RgrUlTrgCqiCfg *param;
1590 Buffer *mBuf;
1591 #endif
1592 {
1593
1594    CMCHKUNPK(oduPackUInt8, &param->trgCqi, mBuf);
1595    return ROK;
1596 }
1597
1598
1599 \f
1600 /***********************************************************
1601 *
1602 *     Func : cmPkRgrBwCfg
1603 *
1604 *
1605 *     Desc : Bandwidth configuration per cell
1606 *
1607 *
1608 *     Ret  : S16
1609 *
1610 *     Notes:
1611 *
1612 *     File  :
1613 *
1614 **********************************************************/
1615 #ifdef ANSI
1616 S16 cmPkRgrBwCfg
1617 (
1618 RgrBwCfg *param,
1619 Buffer *mBuf
1620 )
1621 #else
1622 S16 cmPkRgrBwCfg(param, mBuf)
1623 RgrBwCfg *param;
1624 Buffer *mBuf;
1625 #endif
1626 {
1627
1628    CMCHKPK(oduUnpackUInt8, param->ulTotalBw, mBuf);
1629    CMCHKPK(oduUnpackUInt8, param->dlTotalBw, mBuf);
1630    return ROK;
1631 }
1632
1633
1634 #ifdef EMTC_ENABLE
1635 /* EMTC related pack changes start*/
1636
1637 #ifdef ANSI
1638 S16 cmPkRgrEmtcSiCfg
1639 (
1640 RgrEmtcSiCfg *param,
1641 Buffer *mBuf
1642 )
1643 #else
1644 S16 cmPkRgrEmtcSiCfg(param, mBuf)
1645 RgrEmtcSiCfg *param;
1646 Buffer *mBuf;
1647 #endif
1648 {
1649
1650    S32 i;
1651
1652    CMCHKPK(oduUnpackUInt8, param->siHoppingEnable, mBuf);
1653    CMCHKPK(oduUnpackUInt32, param->modPrd, mBuf);
1654    CMCHKPK(oduUnpackUInt8, param->siWinSizeBr, mBuf);
1655    CMCHKPK(oduUnpackUInt8, param->sib1Repetition, mBuf);
1656    CMCHKPK(oduUnpackUInt8, param->siRepetition, mBuf);
1657
1658    CMCHKPK(oduUnpackUInt16, param->startSymbolLc, mBuf);
1659    //CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
1660    /*Changes by SIMRAN*/
1661     if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
1662     {
1663       CMCHKPK(oduUnpackUInt16, param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
1664     }
1665     else
1666    {
1667       //CMCHKPK(SPkU64,param->fddDLOrTddSfBitmapLC.u.ptn40, mBuf);
1668       for (i=0; i<2; i++) {
1669          CMCHKPK(oduUnpackUInt32, param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
1670       }
1671
1672    }
1673    CMCHKPK(oduUnpackUInt8, param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
1674    //CMCHKPK(oduUnpackUInt16, param->fddDlOrTddSfBitmapBR, mBuf);
1675
1676      for (i= (param->numSi-1); i >= 0; i--) {
1677                  CMCHKPK(oduUnpackUInt8, param->schdInfo[i].emtcSiNarrowBand, mBuf);
1678                  CMCHKPK(oduUnpackUInt16, param->schdInfo[i].emtcSiTbs, mBuf);
1679      }
1680
1681      for (i= (param->numSi-1); i >= 0; i--) {
1682           CMCHKPK(oduUnpackUInt32, param->siPeriodicity[i], mBuf);
1683         }
1684
1685      CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
1686
1687  return ROK;
1688 }
1689
1690
1691
1692
1693 #ifdef ANSI
1694 S16 cmPkRgrEmtcRachCfg
1695 (
1696 RgrEmtcRachCfg *param,
1697 Buffer *mBuf
1698 )
1699 #else
1700 S16 cmPkRgrEmtcRachCfg(param, mBuf)
1701 RgrEmtcRachCfg *param;
1702 Buffer *mBuf;
1703 #endif
1704 {
1705
1706    S32 i;
1707
1708    CMCHKPK(oduUnpackUInt8, param->emtcCeLvlSupported, mBuf);
1709
1710    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
1711           CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcRarHopping, mBuf);
1712           CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcWinSize, mBuf);
1713           CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].raEmtcContResTmr, mBuf);
1714           CMCHKPK(oduUnpackUInt16, param->ceLevelInfo[i].emtcPreambleTransMax, mBuf);
1715           CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.firstPreamble, mBuf);
1716           CMCHKPK(oduUnpackUInt8, param->ceLevelInfo[i].emtcPreambleMap.lastPreamble, mBuf);
1717         }
1718
1719  return ROK;
1720 }
1721
1722
1723 #ifdef ANSI
1724 S16 cmPkRgrEmtcPdschCfg
1725 (
1726 RgrEmtcPdschCfg*param,
1727 Buffer *mBuf
1728 )
1729 #else
1730 S16 cmPkRgrEmtcPdschCfg(param, mBuf)
1731 RgrEmtcPdschCfg *param;
1732 Buffer *mBuf;
1733 #endif
1734 {
1735
1736    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
1737    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
1738
1739  return ROK;
1740 }
1741
1742 #ifdef ANSI
1743 S16 cmPkRgrEmtcPuschCfg
1744 (
1745 RgrEmtcPuschCfg*param,
1746 Buffer *mBuf
1747 )
1748 #else
1749 S16 cmPkRgrEmtcPuschCfg(param, mBuf)
1750 RgrEmtcPuschCfg *param;
1751 Buffer *mBuf;
1752 #endif
1753 {
1754    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeA, mBuf);
1755    CMCHKPK(oduUnpackUInt16, param->emtcMaxRepCeModeB, mBuf);
1756    CMCHKPK(oduUnpackUInt8,  param->emtcHoppingOffset, mBuf);
1757    return ROK;
1758 }
1759
1760
1761
1762 #ifdef ANSI
1763 S16 cmPkRgrEmtcPucchCfg
1764 (
1765 RgrEmtcPucchCfg *param,
1766 Buffer *mBuf
1767 )
1768 #else
1769 S16 cmPkRgrEmtcPucchCfg(param, mBuf)
1770 RgrEmtcPucchCfg *param;
1771 Buffer *mBuf;
1772 #endif
1773 {
1774
1775    S32 i;
1776
1777    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
1778           CMCHKPK(oduUnpackUInt16, param->emtcN1pucchAnInfoLst[i], mBuf);
1779         }
1780
1781         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
1782         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
1783         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
1784         CMCHKPK(oduUnpackUInt8, param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
1785
1786  return ROK;
1787 }
1788
1789
1790 #ifdef ANSI
1791 S16 cmPkRgrEmtcPrachCeParamCfg
1792 (
1793 RgrEmtcPrachCEParamLst *param,
1794 Buffer *mBuf
1795 )
1796 #else
1797 S16 cmPkRgrEmtcPrachCeParamCfg(param, mBuf)
1798 RgrEmtcPrachCEParamLst *param;
1799 Buffer *mBuf;
1800 #endif
1801 {
1802    CMCHKPK(oduUnpackUInt8, param->emtcPrachCfgIdx, mBuf);
1803    CMCHKPK(oduUnpackUInt8, param->emtcPrachFreqOffset, mBuf);
1804    CMCHKPK(oduUnpackUInt16,  param->emtcPrachStartSubFrame, mBuf);
1805    CMCHKPK(oduUnpackUInt8, param->emtcMaxPremAttemptCE, mBuf);
1806    CMCHKPK(oduUnpackUInt8, param->emtcNumRepPerPreambleAtt, mBuf);
1807    CMCHKPK(oduUnpackUInt8,  param->emtcNumMpdcchNBtoMonitor, mBuf);
1808    CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNBtoMonitor[0], mBuf);
1809    CMCHKPK(oduUnpackUInt8,  param->emtcMpdcchNBtoMonitor[1], mBuf);
1810    CMCHKPK(oduUnpackUInt16, param->emtcMpdcchNumRep, mBuf);
1811    CMCHKPK(oduUnpackUInt8,  param->emtcPrachHoppingCfg, mBuf);
1812    return ROK;
1813 }
1814
1815
1816
1817 #ifdef ANSI
1818 S16 cmPkRgrEmtcPrachCfg
1819 (
1820 RgrEmtcPrachCfg *param,
1821 Buffer *mBuf
1822 )
1823 #else
1824 S16 cmPkRgrEmtcPrachCfg(param, mBuf)
1825 RgrEmtcPrachCfg *param;
1826 Buffer *mBuf;
1827 #endif
1828 {
1829
1830    S32 i;
1831         CMCHKPK(oduUnpackUInt8, param->emtcMpdcchStartSFCssRaFdd, mBuf);
1832         CMCHKPK(oduUnpackUInt8, param->emtcPrachHopingOffset, mBuf);
1833         CMCHKPK(oduUnpackUInt8, param->emtcInitialCElevel, mBuf);
1834    for (i=RGR_MAX_CE_LEVEL-1; i >= 0; i--) {
1835         CMCHKPK(cmPkRgrEmtcPrachCeParamCfg, &param->emtcPrachCEparmLst[i], mBuf);
1836         }
1837
1838  return ROK;
1839 }
1840
1841
1842
1843
1844 #ifdef ANSI
1845 S16 cmPkRgrEmtcCfg
1846 (
1847 RgrEmtcCellCfg *param,
1848 Buffer *mBuf
1849 )
1850 #else
1851 S16 cmPkRgrEmtcCfg(param, mBuf)
1852 RgrEmtcCellCfg *param;
1853 Buffer *mBuf;
1854 #endif
1855 {
1856    CMCHKPK(oduUnpackUInt16, param->pci, mBuf);
1857    CMCHKPK(oduUnpackUInt32, param->emtcT300Tmr, mBuf);
1858    CMCHKPK(oduUnpackUInt32, param->emtcT301Tmr, mBuf);
1859    CMCHKPK(cmPkRgrEmtcSiCfg, &param->emtcSiCfg, mBuf);
1860    CMCHKPK(cmPkRgrEmtcRachCfg, &param->emtcRachCfg, mBuf);
1861    CMCHKPK(cmPkRgrEmtcPdschCfg, &param->emtcPdschCfg, mBuf);
1862    CMCHKPK(cmPkRgrEmtcPuschCfg, &param->emtcPuschCfg, mBuf);
1863    CMCHKPK(cmPkRgrEmtcPrachCfg, &param->emtcPrachCfg, mBuf);
1864    CMCHKPK(cmPkRgrEmtcPucchCfg, &param->emtcPucchCfg, mBuf);
1865    CMCHKPK(cmPkRgrEmtcRntiCfg, &param->emtcMacRnti, mBuf);
1866    CMCHKPK(oduUnpackUInt8, param->emtcPdschNbIdx, mBuf);
1867    CMCHKPK(oduUnpackUInt8, param->emtcMpdcchNbIdx, mBuf);
1868    CMCHKPK(oduUnpackUInt8, param->emtcPuschNbIdx, mBuf);
1869
1870    return ROK;
1871 }
1872
1873 /* EMTC related pack changes end*/
1874
1875 /* EMTC related unpack changes start*/
1876
1877 #ifdef ANSI
1878 S16 cmUnpkRgrEmtcSiCfg
1879 (
1880 RgrEmtcSiCfg *param,
1881 Buffer *mBuf
1882 )
1883 #else
1884 S16 cmUnpkRgrEmtcSiCfg(param, mBuf)
1885 RgrEmtcSiCfg *param;
1886 Buffer *mBuf;
1887 #endif
1888 {
1889
1890      S32 i;
1891      uint32_t tmpEnum;
1892      CMCHKUNPK(oduPackUInt8, &param->numSi, mBuf);
1893
1894      for (i=0; i < param->numSi ; i++)
1895      {
1896          CMCHKUNPK(oduPackUInt32,(uint32_t*)&tmpEnum,mBuf);
1897          param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
1898      }
1899
1900      for (i=0; i < param->numSi ; i++)
1901      {
1902          CMCHKUNPK(oduPackUInt16, &param->schdInfo[i].emtcSiTbs, mBuf);
1903          CMCHKUNPK(oduPackUInt8, &param->schdInfo[i].emtcSiNarrowBand, mBuf);
1904      }
1905      //CMCHKUNPK(oduPackUInt16, &param->fddDlOrTddSfBitmapBR, mBuf);
1906      CMCHKUNPK(oduPackUInt8, &param->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
1907      /*Changes by SIMRAN*/
1908        if(!(param->fddDLOrTddSfBitmapLC.sfnPtnChoice))
1909        {
1910         CMCHKUNPK(oduPackUInt16, &param->fddDLOrTddSfBitmapLC.u.ptn10, mBuf);
1911        }
1912        else
1913        {
1914           for (i=1; i>=0; i--) {
1915             CMCHKUNPK(oduPackUInt32, &param->fddDLOrTddSfBitmapLC.u.ptn40[i], mBuf);
1916             }
1917      }
1918
1919      CMCHKUNPK(oduPackUInt16, &param->startSymbolLc, mBuf);
1920      CMCHKUNPK(oduPackUInt8, &param->siRepetition, mBuf);
1921      CMCHKUNPK(oduPackUInt8, &param->sib1Repetition, mBuf);
1922      CMCHKUNPK(oduPackUInt8, &param->siWinSizeBr, mBuf);
1923      CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
1924      param->modPrd = (RgrModPeriodicity) tmpEnum;
1925      CMCHKUNPK(oduPackUInt8, &param->siHoppingEnable, mBuf);
1926
1927           return ROK;
1928 }
1929
1930
1931
1932
1933 #ifdef ANSI
1934 S16 cmUnpkRgrEmtcRachCfg
1935 (
1936 RgrEmtcRachCfg *param,
1937 Buffer *mBuf
1938 )
1939 #else
1940 S16 cmUnpkRgrEmtcRachCfg(param, mBuf)
1941 RgrEmtcRachCfg *param;
1942 Buffer *mBuf;
1943 #endif
1944 {
1945
1946    S32 i;
1947    for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
1948           CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.lastPreamble), mBuf);
1949           CMCHKUNPK(oduPackUInt8, &(param->ceLevelInfo[i].emtcPreambleMap.firstPreamble), mBuf);
1950           CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].emtcPreambleTransMax), mBuf);
1951           CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcContResTmr), mBuf);
1952           CMCHKUNPK(oduPackUInt16, &(param->ceLevelInfo[i].raEmtcWinSize), mBuf);
1953           CMCHKUNPK(oduPackUInt8,&(param->ceLevelInfo[i].emtcRarHopping), mBuf);
1954         }
1955     CMCHKUNPK(oduPackUInt8, &param->emtcCeLvlSupported, mBuf);
1956  return ROK;
1957 }
1958
1959
1960 #ifdef ANSI
1961 S16 cmUnpkRgrEmtcPdschCfg
1962 (
1963 RgrEmtcPdschCfg*param,
1964 Buffer *mBuf
1965 )
1966 #else
1967 S16 cmUnpkRgrEmtcPdschCfg(param, mBuf)
1968 RgrEmtcPdschCfg *param;
1969 Buffer *mBuf;
1970 #endif
1971 {
1972
1973    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeB, mBuf);
1974    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeA, mBuf);
1975  return ROK;
1976 }
1977
1978 #ifdef ANSI
1979 S16 cmUnpkRgrEmtcPuschCfg
1980 (
1981 RgrEmtcPuschCfg*param,
1982 Buffer *mBuf
1983 )
1984 #else
1985 S16 cmUnpkRgrEmtcPuschCfg(param, mBuf)
1986 RgrEmtcPuschCfg *param;
1987 Buffer *mBuf;
1988 #endif
1989 {
1990    CMCHKUNPK(oduPackUInt8,  &param->emtcHoppingOffset, mBuf);
1991    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeB, mBuf);
1992    CMCHKUNPK(oduPackUInt16, &param->emtcMaxRepCeModeA, mBuf);
1993    return ROK;
1994 }
1995
1996
1997
1998 #ifdef ANSI
1999 S16 cmUnpkRgrEmtcPucchCfg
2000 (
2001 RgrEmtcPucchCfg *param,
2002 Buffer *mBuf
2003 )
2004 #else
2005 S16 cmUnpkRgrEmtcPucchCfg(param, mBuf)
2006 RgrEmtcPucchCfg *param;
2007 Buffer *mBuf;
2008 #endif
2009 {
2010
2011    S32 i;
2012
2013
2014         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl3, mBuf);
2015         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl2, mBuf);
2016         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl1, mBuf);
2017         CMCHKUNPK(oduPackUInt8, &param->emtcPucchNumRepCEMsg4Lvl0, mBuf);
2018
2019    for (i=0; i <  RGR_MAX_CE_LEVEL ; i++) {
2020           CMCHKUNPK(oduPackUInt16, &param->emtcN1pucchAnInfoLst[i], mBuf);
2021         }
2022  return ROK;
2023 }
2024
2025
2026 #ifdef ANSI
2027 S16 cmUnpkRgrEmtcPrachCeParamCfg
2028 (
2029 RgrEmtcPrachCEParamLst *param,
2030 Buffer *mBuf
2031 )
2032 #else
2033 S16 cmUnpkRgrEmtcPrachCeParamCfg(param, mBuf)
2034 RgrEmtcPrachCEParamLst *param;
2035 Buffer *mBuf;
2036 #endif
2037 {
2038    CMCHKUNPK(oduPackUInt8,  &param->emtcPrachHoppingCfg, mBuf);
2039    CMCHKUNPK(oduPackUInt16, &param->emtcMpdcchNumRep, mBuf);
2040    CMCHKUNPK(oduPackUInt8,  &param->emtcMpdcchNBtoMonitor[1], mBuf);
2041    CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchNBtoMonitor[0], mBuf);
2042    CMCHKUNPK(oduPackUInt8,  &param->emtcNumMpdcchNBtoMonitor, mBuf);
2043    CMCHKUNPK(oduPackUInt8, &param->emtcNumRepPerPreambleAtt, mBuf);
2044    CMCHKUNPK(oduPackUInt8, &param->emtcMaxPremAttemptCE, mBuf);
2045    CMCHKUNPK(oduPackUInt16,  &param->emtcPrachStartSubFrame, mBuf);
2046    CMCHKUNPK(oduPackUInt8, &param->emtcPrachFreqOffset, mBuf);
2047    CMCHKUNPK(oduPackUInt8, &param->emtcPrachCfgIdx, mBuf);
2048    return ROK;
2049 }
2050
2051
2052
2053 #ifdef ANSI
2054 S16 cmUnpkRgrEmtcPrachCfg
2055 (
2056 RgrEmtcPrachCfg *param,
2057 Buffer *mBuf
2058 )
2059 #else
2060 S16 cmUnpkRgrEmtcPrachCfg(param, mBuf)
2061 RgrEmtcPrachCfg *param;
2062 Buffer *mBuf;
2063 #endif
2064 {
2065
2066    S32 i;
2067    for (i=0; i < RGR_MAX_CE_LEVEL; i++) {
2068         CMCHKUNPK(cmUnpkRgrEmtcPrachCeParamCfg, &param->emtcPrachCEparmLst[i], mBuf);
2069         }
2070         CMCHKUNPK(oduPackUInt8, &param->emtcInitialCElevel, mBuf);
2071         CMCHKUNPK(oduPackUInt8, &param->emtcPrachHopingOffset, mBuf);
2072         CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchStartSFCssRaFdd, mBuf);
2073
2074  return ROK;
2075 }
2076
2077 #ifdef ANSI
2078 S16 cmUnpkRgrEmtcCfg
2079 (
2080 RgrEmtcCellCfg *param,
2081 Buffer *mBuf
2082 )
2083 #else
2084 S16 cmUnpkRgrEmtcCfg(param, mBuf)
2085 RgrEmtcCellCfg *param;
2086 Buffer *mBuf;
2087 #endif
2088 {
2089
2090    CMCHKUNPK(oduPackUInt8, &param->emtcPuschNbIdx, mBuf);
2091    CMCHKUNPK(oduPackUInt8, &param->emtcMpdcchNbIdx, mBuf);
2092    CMCHKUNPK(oduPackUInt8, &param->emtcPdschNbIdx, mBuf);
2093    CMCHKUNPK(cmUnpkRgrEmtcRntiCfg, &param->emtcMacRnti, mBuf);
2094    CMCHKUNPK(cmUnpkRgrEmtcPucchCfg, &param->emtcPucchCfg, mBuf);
2095    CMCHKUNPK(cmUnpkRgrEmtcPrachCfg, &param->emtcPrachCfg, mBuf);
2096    CMCHKUNPK(cmUnpkRgrEmtcPuschCfg, &param->emtcPuschCfg, mBuf);
2097    CMCHKUNPK(cmUnpkRgrEmtcPdschCfg, &param->emtcPdschCfg, mBuf);
2098    CMCHKUNPK(cmUnpkRgrEmtcRachCfg, &param->emtcRachCfg, mBuf);
2099    CMCHKUNPK(cmUnpkRgrEmtcSiCfg, &param->emtcSiCfg, mBuf);
2100    CMCHKUNPK(oduPackUInt32,&param->emtcT301Tmr, mBuf);
2101    CMCHKUNPK(oduPackUInt32, &param->emtcT300Tmr, mBuf);
2102    CMCHKUNPK(oduPackUInt16, &param->pci, mBuf);
2103
2104
2105
2106
2107
2108    return ROK;
2109 }
2110
2111 /* EMTC related unpack changes end*/
2112
2113
2114 #endif
2115
2116 \f
2117 /***********************************************************
2118 *
2119 *     Func : cmUnpkRgrBwCfg
2120 *
2121 *
2122 *     Desc : Bandwidth configuration per cell
2123 *
2124 *
2125 *     Ret  : S16
2126 *
2127 *     Notes:
2128 *
2129 *     File  :
2130 *
2131 **********************************************************/
2132 #ifdef ANSI
2133 S16 cmUnpkRgrBwCfg
2134 (
2135 RgrBwCfg *param,
2136 Buffer *mBuf
2137 )
2138 #else
2139 S16 cmUnpkRgrBwCfg(param, mBuf)
2140 RgrBwCfg *param;
2141 Buffer *mBuf;
2142 #endif
2143 {
2144
2145    CMCHKUNPK(oduPackUInt8, &param->dlTotalBw, mBuf);
2146    CMCHKUNPK(oduPackUInt8, &param->ulTotalBw, mBuf);
2147    return ROK;
2148 }
2149
2150
2151 \f
2152 /***********************************************************
2153 *
2154 *     Func : cmPkRgrPhichCfg
2155 *
2156 *
2157 *     Desc : PHICH configuration per cell
2158 *
2159 *
2160 *     Ret  : S16
2161 *
2162 *     Notes:
2163 *
2164 *     File  :
2165 *
2166 **********************************************************/
2167 #ifdef ANSI
2168 S16 cmPkRgrPhichCfg
2169 (
2170 RgrPhichCfg *param,
2171 Buffer *mBuf
2172 )
2173 #else
2174 S16 cmPkRgrPhichCfg(param, mBuf)
2175 RgrPhichCfg *param;
2176 Buffer *mBuf;
2177 #endif
2178 {
2179
2180    CMCHKPK(oduUnpackUInt8, param->isDurExtend, mBuf);
2181    CMCHKPK(oduUnpackUInt32, param->ngEnum, mBuf);
2182    return ROK;
2183 }
2184
2185
2186 \f
2187 /***********************************************************
2188 *
2189 *     Func : cmUnpkRgrPhichCfg
2190 *
2191 *
2192 *     Desc : PHICH configuration per cell
2193 *
2194 *
2195 *     Ret  : S16
2196 *
2197 *     Notes:
2198 *
2199 *     File  :
2200 *
2201 **********************************************************/
2202 #ifdef ANSI
2203 S16 cmUnpkRgrPhichCfg
2204 (
2205 RgrPhichCfg *param,
2206 Buffer *mBuf
2207 )
2208 #else
2209 S16 cmUnpkRgrPhichCfg(param, mBuf)
2210 RgrPhichCfg *param;
2211 Buffer *mBuf;
2212 #endif
2213 {
2214    uint32_t tmpEnum;
2215
2216
2217    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2218    param->ngEnum = (RgrPhichNg) tmpEnum;
2219    CMCHKUNPK(oduPackUInt8, &param->isDurExtend, mBuf);
2220    return ROK;
2221 }
2222
2223
2224 \f
2225 /***********************************************************
2226 *
2227 *     Func : cmPkRgrPucchCfg
2228 *
2229 *
2230 *     Desc : PUCCH configuration per cell
2231 *
2232 *
2233 *     Ret  : S16
2234 *
2235 *     Notes:
2236 *
2237 *     File  :
2238 *
2239 **********************************************************/
2240 #ifdef ANSI
2241 S16 cmPkRgrPucchCfg
2242 (
2243 RgrPucchCfg *param,
2244 Buffer *mBuf
2245 )
2246 #else
2247 S16 cmPkRgrPucchCfg(param, mBuf)
2248 RgrPucchCfg *param;
2249 Buffer *mBuf;
2250 #endif
2251 {
2252
2253    CMCHKPK(oduUnpackUInt8, param->maxPucchRb, mBuf);
2254    CMCHKPK(oduUnpackUInt8, param->cyclicShift, mBuf);
2255    CMCHKPK(oduUnpackUInt8, param->deltaShift, mBuf);
2256    CMCHKPK(oduUnpackUInt16, param->n1PucchAn, mBuf);
2257    CMCHKPK(oduUnpackUInt8, param->resourceSize, mBuf);
2258
2259    return ROK;
2260 }
2261
2262
2263 \f
2264 /***********************************************************
2265 *
2266 *     Func : cmUnpkRgrPucchCfg
2267 *
2268 *
2269 *     Desc : PUCCH configuration per cell
2270 *
2271 *
2272 *     Ret  : S16
2273 *
2274 *     Notes:
2275 *
2276 *     File  :
2277 *
2278 **********************************************************/
2279 #ifdef ANSI
2280 S16 cmUnpkRgrPucchCfg
2281 (
2282 RgrPucchCfg *param,
2283 Buffer *mBuf
2284 )
2285 #else
2286 S16 cmUnpkRgrPucchCfg(param, mBuf)
2287 RgrPucchCfg *param;
2288 Buffer *mBuf;
2289 #endif
2290 {
2291
2292
2293    CMCHKUNPK(oduPackUInt8, &param->resourceSize, mBuf);
2294    CMCHKUNPK(oduPackUInt16, &param->n1PucchAn, mBuf);
2295    CMCHKUNPK(oduPackUInt8, &param->deltaShift, mBuf);
2296    CMCHKUNPK(oduPackUInt8, &param->cyclicShift, mBuf);
2297    CMCHKUNPK(oduPackUInt8, &param->maxPucchRb, mBuf);
2298
2299    return ROK;
2300 }
2301
2302
2303 \f
2304 /***********************************************************
2305 *
2306 *     Func : cmPkRgrSrsCfg
2307 *
2308 *
2309 *     Desc : SRS configuration per cell
2310 *
2311 *
2312 *     Ret  : S16
2313 *
2314 *     Notes:
2315 *
2316 *     File  :
2317 *
2318 **********************************************************/
2319 #ifdef ANSI
2320 S16 cmPkRgrSrsCfg
2321 (
2322 RgrSrsCfg *param,
2323 Buffer *mBuf
2324 )
2325 #else
2326 S16 cmPkRgrSrsCfg(param, mBuf)
2327 RgrSrsCfg *param;
2328 Buffer *mBuf;
2329 #endif
2330 {
2331
2332
2333    CMCHKPK(oduUnpackUInt8, param->srsSubFrameCfg, mBuf);
2334    CMCHKPK(oduUnpackUInt32, param->srsBwEnum, mBuf);
2335    CMCHKPK(oduUnpackUInt32, param->srsCfgPrdEnum, mBuf);
2336    CMCHKPK(oduUnpackUInt8, param->isSrsCfgSetup, mBuf);
2337    return ROK;
2338 }
2339
2340
2341 \f
2342 /***********************************************************
2343 *
2344 *     Func : cmUnpkRgrSrsCfg
2345 *
2346 *
2347 *     Desc : SRS configuration per cell
2348 *
2349 *
2350 *     Ret  : S16
2351 *
2352 *     Notes:
2353 *
2354 *     File  :
2355 *
2356 **********************************************************/
2357 #ifdef ANSI
2358 S16 cmUnpkRgrSrsCfg
2359 (
2360 RgrSrsCfg *param,
2361 Buffer *mBuf
2362 )
2363 #else
2364 S16 cmUnpkRgrSrsCfg(param, mBuf)
2365 RgrSrsCfg *param;
2366 Buffer *mBuf;
2367 #endif
2368 {
2369    uint32_t tmpEnum;
2370
2371
2372    CMCHKUNPK(oduPackUInt8, &param->isSrsCfgSetup, mBuf);
2373    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2374    param->srsCfgPrdEnum = (RgrSrsCfgPrd) tmpEnum;
2375    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2376    param->srsBwEnum = (RgrSrsBwCfg) tmpEnum;
2377    CMCHKUNPK(oduPackUInt8, &param->srsSubFrameCfg, mBuf);
2378    return ROK;
2379 }
2380
2381
2382 \f
2383 /***********************************************************
2384 *
2385 *     Func : cmPkRgrRachCfg
2386 *
2387 *
2388 *     Desc : RACH configuration per cell
2389 *
2390 *
2391 *     Ret  : S16
2392 *
2393 *     Notes:
2394 *
2395 *     File  :
2396 *
2397 **********************************************************/
2398 #ifdef ANSI
2399 S16 cmPkRgrRachCfg
2400 (
2401 RgrRachCfg *param,
2402 Buffer *mBuf
2403 )
2404 #else
2405 S16 cmPkRgrRachCfg(param, mBuf)
2406 RgrRachCfg *param;
2407 Buffer *mBuf;
2408 #endif
2409 {
2410
2411    S32 i;
2412
2413    CMCHKPK(oduUnpackUInt8, param->prachResource, mBuf);
2414    CMCHKPK(oduUnpackUInt16, param->msgSizeGrpA, mBuf);
2415    CMCHKPK(oduUnpackUInt8, param->sizeRaPreambleGrpA, mBuf);
2416    CMCHKPK(oduUnpackUInt8, param->numRaPreamble, mBuf);
2417    CMCHKPK(oduUnpackUInt8, param->maxMsg3Tx, mBuf);
2418       for (i=param->raOccasion.size-1; i >= 0; i--) {
2419          CMCHKPK(oduUnpackUInt8, param->raOccasion.subFrameNum[i], mBuf);
2420       }
2421       CMCHKPK(oduUnpackUInt32, param->raOccasion.sfnEnum, mBuf);
2422       CMCHKPK(oduUnpackUInt8, param->raOccasion.size, mBuf);
2423    CMCHKPK(oduUnpackUInt8, param->raWinSize, mBuf);
2424    CMCHKPK(oduUnpackUInt8, param->preambleFormat, mBuf);
2425 #ifdef RGR_V1
2426    /* rgr_c_001.main_5: cccpu00112372: Added contention resolution
2427     * timer configuration */
2428    CMCHKPK(oduUnpackUInt8, param->contResTmr, mBuf);
2429 #endif
2430    return ROK;
2431 }
2432
2433
2434 \f
2435 /***********************************************************
2436 *
2437 *     Func : cmUnpkRgrRachCfg
2438 *
2439 *
2440 *     Desc : RACH configuration per cell
2441 *
2442 *
2443 *     Ret  : S16
2444 *
2445 *     Notes:
2446 *
2447 *     File  :
2448 *
2449 **********************************************************/
2450 #ifdef ANSI
2451 S16 cmUnpkRgrRachCfg
2452 (
2453 RgrRachCfg *param,
2454 Buffer *mBuf
2455 )
2456 #else
2457 S16 cmUnpkRgrRachCfg(param, mBuf)
2458 RgrRachCfg *param;
2459 Buffer *mBuf;
2460 #endif
2461 {
2462    uint32_t tmpEnum;
2463
2464    S32 i;
2465 #ifdef RGR_V1
2466    /* rgr_c_001.main_5: cccpu00112372: Added contention resolution
2467     * timer configuration */
2468    CMCHKUNPK(oduPackUInt8, &param->contResTmr, mBuf);
2469 #endif
2470    CMCHKUNPK(oduPackUInt8, &param->preambleFormat, mBuf);
2471    CMCHKUNPK(oduPackUInt8, &param->raWinSize, mBuf);
2472       CMCHKUNPK(oduPackUInt8, &param->raOccasion.size, mBuf);
2473    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2474    param->raOccasion.sfnEnum = (RgrRaSfn) tmpEnum;
2475       for (i=0; i<param->raOccasion.size; i++) {
2476          CMCHKUNPK(oduPackUInt8, &param->raOccasion.subFrameNum[i], mBuf);
2477       }
2478    CMCHKUNPK(oduPackUInt8, &param->maxMsg3Tx, mBuf);
2479    CMCHKUNPK(oduPackUInt8, &param->numRaPreamble, mBuf);
2480    CMCHKUNPK(oduPackUInt8, &param->sizeRaPreambleGrpA, mBuf);
2481    CMCHKUNPK(oduPackUInt16, &param->msgSizeGrpA, mBuf);
2482    CMCHKUNPK(oduPackUInt8, &param->prachResource, mBuf);
2483    return ROK;
2484 }
2485
2486
2487 \f
2488 /***********************************************************
2489 *
2490 *     Func : cmPkRgrSiCfg
2491 *
2492 *
2493 *     Desc : SI Configuration per cell
2494 *
2495 *
2496 *     Ret  : S16
2497 *
2498 *     Notes:
2499 *
2500 *     File  :
2501 *
2502 **********************************************************/
2503 #ifdef ANSI
2504 S16 cmPkRgrSiCfg
2505 (
2506 RgrSiCfg *param,
2507 Buffer *mBuf
2508 )
2509 #else
2510 S16 cmPkRgrSiCfg(param, mBuf)
2511 RgrSiCfg *param;
2512 Buffer *mBuf;
2513 #endif
2514 {
2515    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
2516 #ifdef RGR_SI_SCH
2517    S16 idx;
2518 #endif/*RGR_SI_SCH*/
2519
2520
2521 #ifdef RGR_SI_SCH
2522    if(param->numSi > sizeof(param->siPeriodicity)/
2523                        sizeof(param->siPeriodicity[0]))
2524       param->numSi = sizeof(param->siPeriodicity)/
2525                        sizeof(param->siPeriodicity[0]);
2526
2527    for (idx=param->numSi-1; idx >= 0; idx--) {
2528    /* Enum to be packed/unpacked as uint32_t instead of S32 */
2529       CMCHKPK(oduUnpackUInt32, param->siPeriodicity[idx], mBuf);
2530    }
2531    CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
2532    /*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
2533    CMCHKPK(oduUnpackUInt32, (uint32_t)param->modPrd, mBuf);
2534 #endif/*RGR_SI_SCH*/
2535    CMCHKPK(oduUnpackUInt8, param->retxCnt, mBuf);
2536    CMCHKPK(oduUnpackUInt8, param->siWinSize, mBuf);
2537    return ROK;
2538 }
2539
2540
2541 \f
2542 /***********************************************************
2543 *
2544 *     Func : cmUnpkRgrSiCfg
2545 *
2546 *
2547 *     Desc : SI Configuration per cell
2548 *
2549 *
2550 *     Ret  : S16
2551 *
2552 *     Notes:
2553 *
2554 *     File  :
2555 *
2556 **********************************************************/
2557 #ifdef ANSI
2558 S16 cmUnpkRgrSiCfg
2559 (
2560 RgrSiCfg *param,
2561 Buffer *mBuf
2562 )
2563 #else
2564 S16 cmUnpkRgrSiCfg(param, mBuf)
2565 RgrSiCfg *param;
2566 Buffer *mBuf;
2567 #endif
2568 {
2569    uint32_t tmpEnum;
2570    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
2571 #ifdef RGR_SI_SCH
2572    S16 idx;
2573 #endif/*RGR_SI_SCH*/
2574
2575
2576    CMCHKUNPK(oduPackUInt8, &param->siWinSize, mBuf);
2577    CMCHKUNPK(oduPackUInt8, &param->retxCnt, mBuf);
2578 #ifdef RGR_SI_SCH
2579    /*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
2580    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2581    param->modPrd = (RgrModPeriodicity) tmpEnum;
2582    CMCHKUNPK(oduPackUInt8, &param->numSi, mBuf);
2583
2584    if(param->numSi > sizeof(param->siPeriodicity)/
2585                        sizeof(param->siPeriodicity[0]))
2586       param->numSi = sizeof(param->siPeriodicity)/
2587                        sizeof(param->siPeriodicity[0]);
2588
2589    /* Enum to be packed/unpacked as uint32_t instead of S32 */
2590    for (idx=0; idx < param->numSi; idx++) {
2591       CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2592       param->siPeriodicity[idx] = (RgrSiPeriodicity) tmpEnum;
2593    }
2594 #endif/*RGR_SI_SCH*/
2595
2596    return ROK;
2597 }
2598
2599
2600 \f
2601 /***********************************************************
2602 *
2603 *     Func : cmPkRgrTpcRntiCfg
2604 *
2605 *
2606 *     Desc : TPC RNTI Range
2607 *
2608 *
2609 *     Ret  : S16
2610 *
2611 *     Notes:
2612 *
2613 *     File  :
2614 *
2615 **********************************************************/
2616 #ifdef ANSI
2617 S16 cmPkRgrTpcRntiCfg
2618 (
2619 RgrTpcRntiCfg *param,
2620 Buffer *mBuf
2621 )
2622 #else
2623 S16 cmPkRgrTpcRntiCfg(param, mBuf)
2624 RgrTpcRntiCfg *param;
2625 Buffer *mBuf;
2626 #endif
2627 {
2628
2629
2630    CMCHKPK(oduUnpackUInt16, param->size, mBuf);
2631    CMCHKPK(cmPkLteRnti, param->startTpcRnti, mBuf);
2632    return ROK;
2633 }
2634
2635
2636 \f
2637 /***********************************************************
2638 *
2639 *     Func : cmUnpkRgrTpcRntiCfg
2640 *
2641 *
2642 *     Desc : TPC RNTI Range
2643 *
2644 *
2645 *     Ret  : S16
2646 *
2647 *     Notes:
2648 *
2649 *     File  :
2650 *
2651 **********************************************************/
2652 #ifdef ANSI
2653 S16 cmUnpkRgrTpcRntiCfg
2654 (
2655 RgrTpcRntiCfg *param,
2656 Buffer *mBuf
2657 )
2658 #else
2659 S16 cmUnpkRgrTpcRntiCfg(param, mBuf)
2660 RgrTpcRntiCfg *param;
2661 Buffer *mBuf;
2662 #endif
2663 {
2664
2665
2666    CMCHKUNPK(cmUnpkLteRnti, &param->startTpcRnti, mBuf);
2667    CMCHKUNPK(oduPackUInt16, &param->size, mBuf);
2668    return ROK;
2669 }
2670
2671
2672 \f
2673 /***********************************************************
2674 *
2675 *     Func : cmPkRgrUlPwrCfg
2676 *
2677 *
2678 *     Desc : Cell specific power configuration
2679 *
2680 *
2681 *     Ret  : S16
2682 *
2683 *     Notes:
2684 *
2685 *     File  :
2686 *
2687 **********************************************************/
2688 #ifdef ANSI
2689 S16 cmPkRgrUlPwrCfg
2690 (
2691 RgrUlPwrCfg *param,
2692 Buffer *mBuf
2693 )
2694 #else
2695 S16 cmPkRgrUlPwrCfg(param, mBuf)
2696 RgrUlPwrCfg *param;
2697 Buffer *mBuf;
2698 #endif
2699 {
2700
2701
2702    CMCHKPK(cmPkRgrTpcRntiCfg, &param->puschPwrFmt3a, mBuf);
2703    CMCHKPK(cmPkRgrTpcRntiCfg, &param->puschPwrFmt3, mBuf);
2704    CMCHKPK(cmPkRgrTpcRntiCfg, &param->pucchPwrFmt3a, mBuf);
2705    CMCHKPK(cmPkRgrTpcRntiCfg, &param->pucchPwrFmt3, mBuf);
2706    CMCHKPK(SPkS8, param->deltaPreambleMsg3, mBuf);
2707    CMCHKPK(SPkS8, param->p0NominalPucch, mBuf);
2708    CMCHKPK(oduUnpackUInt32, param->alpha, mBuf);
2709    CMCHKPK(SPkS8, param->p0NominalPusch, mBuf);
2710    return ROK;
2711 }
2712
2713
2714 \f
2715 /***********************************************************
2716 *
2717 *     Func : cmUnpkRgrUlPwrCfg
2718 *
2719 *
2720 *     Desc : Cell specific power configuration
2721 *
2722 *
2723 *     Ret  : S16
2724 *
2725 *     Notes:
2726 *
2727 *     File  :
2728 *
2729 **********************************************************/
2730 #ifdef ANSI
2731 S16 cmUnpkRgrUlPwrCfg
2732 (
2733 RgrUlPwrCfg *param,
2734 Buffer *mBuf
2735 )
2736 #else
2737 S16 cmUnpkRgrUlPwrCfg(param, mBuf)
2738 RgrUlPwrCfg *param;
2739 Buffer *mBuf;
2740 #endif
2741 {
2742    uint32_t tmpEnum;
2743
2744
2745    CMCHKUNPK(SUnpkS8, &param->p0NominalPusch, mBuf);
2746    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
2747    param->alpha = (RgrPwrAlpha) tmpEnum;
2748    CMCHKUNPK(SUnpkS8, &param->p0NominalPucch, mBuf);
2749    CMCHKUNPK(SUnpkS8, &param->deltaPreambleMsg3, mBuf);
2750    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->pucchPwrFmt3, mBuf);
2751    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->pucchPwrFmt3a, mBuf);
2752    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->puschPwrFmt3, mBuf);
2753    CMCHKUNPK(cmUnpkRgrTpcRntiCfg, &param->puschPwrFmt3a, mBuf);
2754    return ROK;
2755 }
2756
2757
2758 \f
2759 /***********************************************************
2760 *
2761 *     Func : cmPkRgrPuschCfg
2762 *
2763 *
2764 *     Desc : brief cell specific hopping configuration
2765 *
2766 *
2767 *     Ret  : S16
2768 *
2769 *     Notes:
2770 *
2771 *     File  :
2772 *
2773 **********************************************************/
2774 #ifdef ANSI
2775 S16 cmPkRgrPuschCfg
2776 (
2777 RgrPuschCfg *param,
2778 Buffer *mBuf
2779 )
2780 #else
2781 S16 cmPkRgrPuschCfg(param, mBuf)
2782 RgrPuschCfg *param;
2783 Buffer *mBuf;
2784 #endif
2785 {
2786
2787
2788    CMCHKPK(oduUnpackUInt8, param->hopOffst, mBuf);
2789    CMCHKPK(oduUnpackUInt8, param->isIntraHop, mBuf);
2790    CMCHKPK(oduUnpackUInt8, param->numSubBands, mBuf);
2791    return ROK;
2792 }
2793
2794
2795 \f
2796 /***********************************************************
2797 *
2798 *     Func : cmUnpkRgrPuschCfg
2799 *
2800 *
2801 *     Desc : brief cell specific hopping configuration
2802 *
2803 *
2804 *     Ret  : S16
2805 *
2806 *     Notes:
2807 *
2808 *     File  :
2809 *
2810 **********************************************************/
2811 #ifdef ANSI
2812 S16 cmUnpkRgrPuschCfg
2813 (
2814 RgrPuschCfg *param,
2815 Buffer *mBuf
2816 )
2817 #else
2818 S16 cmUnpkRgrPuschCfg(param, mBuf)
2819 RgrPuschCfg *param;
2820 Buffer *mBuf;
2821 #endif
2822 {
2823
2824
2825    CMCHKUNPK(oduPackUInt8, &param->numSubBands, mBuf);
2826    CMCHKUNPK(oduPackUInt8, &param->isIntraHop, mBuf);
2827    CMCHKUNPK(oduPackUInt8, &param->hopOffst, mBuf);
2828    return ROK;
2829 }
2830
2831
2832 \f
2833 /***********************************************************
2834 *
2835 *     Func : cmPkRgrCodeBookRstCfg
2836 *
2837 *
2838 *     Desc : Number of bits in code book for different transmission modes
2839 *
2840 *
2841 *     Ret  : S16
2842 *
2843 *     Notes:
2844 *
2845 *     File  :
2846 *
2847 **********************************************************/
2848 #ifdef ANSI
2849 S16 cmPkRgrCodeBookRstCfg
2850 (
2851 RgrCodeBookRstCfg *param,
2852 Buffer *mBuf
2853 )
2854 #else
2855 S16 cmPkRgrCodeBookRstCfg(param, mBuf)
2856 RgrCodeBookRstCfg *param;
2857 Buffer *mBuf;
2858 #endif
2859 {
2860
2861    S32 i;
2862
2863    for (i=1-1; i >= 0; i--) {
2864       CMCHKPK(oduUnpackUInt32, param->pmiBitMap[i], mBuf);
2865    }
2866    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
2867    return ROK;
2868 }
2869
2870
2871 \f
2872 /***********************************************************
2873 *
2874 *     Func : cmUnpkRgrCodeBookRstCfg
2875 *
2876 *
2877 *     Desc : Number of bits in code book for different transmission modes
2878 *
2879 *
2880 *     Ret  : S16
2881 *
2882 *     Notes:
2883 *
2884 *     File  :
2885 *
2886 **********************************************************/
2887 #ifdef ANSI
2888 S16 cmUnpkRgrCodeBookRstCfg
2889 (
2890 RgrCodeBookRstCfg *param,
2891 Buffer *mBuf
2892 )
2893 #else
2894 S16 cmUnpkRgrCodeBookRstCfg(param, mBuf)
2895 RgrCodeBookRstCfg *param;
2896 Buffer *mBuf;
2897 #endif
2898 {
2899
2900    S32 i;
2901
2902    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
2903    for (i=0; i<1; i++) {
2904       CMCHKUNPK(oduPackUInt32, &param->pmiBitMap[i], mBuf);
2905    }
2906    return ROK;
2907 }
2908
2909
2910 \f
2911 /***********************************************************
2912 *
2913 *     Func : cmPkRgrPreambleSetCfg
2914 *
2915 *
2916 *     Desc : Range of PDCCH Order Preamble Set managed by MAC
2917 *
2918 *
2919 *     Ret  : S16
2920 *
2921 *     Notes:
2922 *
2923 *     File  :
2924 *
2925 **********************************************************/
2926 #ifdef ANSI
2927 S16 cmPkRgrPreambleSetCfg
2928 (
2929 RgrPreambleSetCfg *param,
2930 Buffer *mBuf
2931 )
2932 #else
2933 S16 cmPkRgrPreambleSetCfg(param, mBuf)
2934 RgrPreambleSetCfg *param;
2935 Buffer *mBuf;
2936 #endif
2937 {
2938
2939
2940    CMCHKPK(oduUnpackUInt8, param->size, mBuf);
2941    CMCHKPK(oduUnpackUInt8, param->start, mBuf);
2942    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
2943    return ROK;
2944 }
2945
2946
2947 \f
2948 /***********************************************************
2949 *
2950 *     Func : cmUnpkRgrPreambleSetCfg
2951 *
2952 *
2953 *     Desc : Range of PDCCH Order Preamble Set managed by MAC
2954 *
2955 *
2956 *     Ret  : S16
2957 *
2958 *     Notes:
2959 *
2960 *     File  :
2961 *
2962 **********************************************************/
2963 #ifdef ANSI
2964 S16 cmUnpkRgrPreambleSetCfg
2965 (
2966 RgrPreambleSetCfg *param,
2967 Buffer *mBuf
2968 )
2969 #else
2970 S16 cmUnpkRgrPreambleSetCfg(param, mBuf)
2971 RgrPreambleSetCfg *param;
2972 Buffer *mBuf;
2973 #endif
2974 {
2975
2976
2977    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
2978    CMCHKUNPK(oduPackUInt8, &param->start, mBuf);
2979    CMCHKUNPK(oduPackUInt8, &param->size, mBuf);
2980    return ROK;
2981 }
2982
2983
2984 \f
2985 /***********************************************************
2986 *
2987 *     Func : cmPkRgrCmnLchCfg
2988 *
2989 *
2990 *     Desc : Logical channel configuration info for common channels
2991 *
2992 *
2993 *     Ret  : S16
2994 *
2995 *     Notes:
2996 *
2997 *     File  :
2998 *
2999 **********************************************************/
3000 #ifdef ANSI
3001 S16 cmPkRgrCmnLchCfg
3002 (
3003 RgrCmnLchCfg *param,
3004 Buffer *mBuf
3005 )
3006 #else
3007 S16 cmPkRgrCmnLchCfg(param, mBuf)
3008 RgrCmnLchCfg *param;
3009 Buffer *mBuf;
3010 #endif
3011 {
3012
3013
3014    CMCHKPK(oduUnpackUInt8, param->ulTrchType, mBuf);
3015    CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
3016    CMCHKPK(oduUnpackUInt8, param->dir, mBuf);
3017    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
3018    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
3019    return ROK;
3020 }
3021
3022
3023 \f
3024 /***********************************************************
3025 *
3026 *     Func : cmUnpkRgrCmnLchCfg
3027 *
3028 *
3029 *     Desc : Logical channel configuration info for common channels
3030 *
3031 *
3032 *     Ret  : S16
3033 *
3034 *     Notes:
3035 *
3036 *     File  :
3037 *
3038 **********************************************************/
3039 #ifdef ANSI
3040 S16 cmUnpkRgrCmnLchCfg
3041 (
3042 RgrCmnLchCfg *param,
3043 Buffer *mBuf
3044 )
3045 #else
3046 S16 cmUnpkRgrCmnLchCfg(param, mBuf)
3047 RgrCmnLchCfg *param;
3048 Buffer *mBuf;
3049 #endif
3050 {
3051
3052
3053    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
3054    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
3055    CMCHKUNPK(oduPackUInt8, &param->dir, mBuf);
3056    CMCHKUNPK(oduPackUInt8, &param->dlTrchType, mBuf);
3057    CMCHKUNPK(oduPackUInt8, &param->ulTrchType, mBuf);
3058    return ROK;
3059 }
3060
3061
3062 \f
3063 /***********************************************************
3064 *
3065 *     Func : cmPkRgrDlfsCfg
3066 *
3067 *
3068 *     Desc : RGR configuration for DLFS scheduler
3069 *
3070 *
3071 *     Ret  : S16
3072 *
3073 *     Notes:
3074 *
3075 *     File  :
3076 *
3077 **********************************************************/
3078 #ifdef ANSI
3079 S16 cmPkRgrDlfsCfg
3080 (
3081 RgrDlfsCfg *param,
3082 Buffer *mBuf
3083 )
3084 #else
3085 S16 cmPkRgrDlfsCfg(param, mBuf)
3086 RgrDlfsCfg *param;
3087 Buffer *mBuf;
3088 #endif
3089 {
3090
3091
3092    CMCHKPK(oduUnpackUInt8, param->thresholdCqi, mBuf);
3093    CMCHKPK(oduUnpackUInt8, param->isDlFreqSel, mBuf);
3094    return ROK;
3095 }
3096
3097
3098 \f
3099 /***********************************************************
3100 *
3101 *     Func : cmUnpkRgrDlfsCfg
3102 *
3103 *
3104 *     Desc : RGR configuration for DLFS scheduler
3105 *
3106 *
3107 *     Ret  : S16
3108 *
3109 *     Notes:
3110 *
3111 *     File  :
3112 *
3113 **********************************************************/
3114 #ifdef ANSI
3115 S16 cmUnpkRgrDlfsCfg
3116 (
3117 RgrDlfsCfg *param,
3118 Buffer *mBuf
3119 )
3120 #else
3121 S16 cmUnpkRgrDlfsCfg(param, mBuf)
3122 RgrDlfsCfg *param;
3123 Buffer *mBuf;
3124 #endif
3125 {
3126
3127
3128    CMCHKUNPK(oduPackUInt8, &param->isDlFreqSel, mBuf);
3129    CMCHKUNPK(oduPackUInt8, &param->thresholdCqi, mBuf);
3130    return ROK;
3131 }
3132
3133
3134 #ifdef LTE_TDD
3135
3136 #ifdef LTE_TDD
3137
3138 \f
3139 /***********************************************************
3140 *
3141 *     Func : cmPkRgrTddPrachInfo
3142 *
3143 *
3144 *     Desc : PRACH resource information for TDD
3145 *
3146 *
3147 *     Ret  : S16
3148 *
3149 *     Notes:
3150 *
3151 *     File  :
3152 *
3153 **********************************************************/
3154 #ifdef ANSI
3155 S16 cmPkRgrTddPrachInfo
3156 (
3157 RgrTddPrachInfo *param,
3158 Buffer *mBuf
3159 )
3160 #else
3161 S16 cmPkRgrTddPrachInfo(param, mBuf)
3162 RgrTddPrachInfo *param;
3163 Buffer *mBuf;
3164 #endif
3165 {
3166
3167
3168    CMCHKPK(oduUnpackUInt8, param->ulStartSfIdx, mBuf);
3169    CMCHKPK(oduUnpackUInt8, param->halfFrm, mBuf);
3170    CMCHKPK(oduUnpackUInt32, param->sfn, mBuf);
3171    CMCHKPK(oduUnpackUInt8, param->freqIdx, mBuf);
3172    return ROK;
3173 }
3174
3175
3176 \f
3177 /***********************************************************
3178 *
3179 *     Func : cmUnpkRgrTddPrachInfo
3180 *
3181 *
3182 *     Desc : PRACH resource information for TDD
3183 *
3184 *
3185 *     Ret  : S16
3186 *
3187 *     Notes:
3188 *
3189 *     File  :
3190 *
3191 **********************************************************/
3192 #ifdef ANSI
3193 S16 cmUnpkRgrTddPrachInfo
3194 (
3195 RgrTddPrachInfo *param,
3196 Buffer *mBuf
3197 )
3198 #else
3199 S16 cmUnpkRgrTddPrachInfo(param, mBuf)
3200 RgrTddPrachInfo *param;
3201 Buffer *mBuf;
3202 #endif
3203 {
3204    uint32_t tmpEnum;
3205
3206
3207    CMCHKUNPK(oduPackUInt8, &param->freqIdx, mBuf);
3208    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
3209    param->sfn = tmpEnum;
3210    CMCHKUNPK(oduPackUInt8, &param->halfFrm, mBuf);
3211    CMCHKUNPK(oduPackUInt8, &param->ulStartSfIdx, mBuf);
3212    return ROK;
3213 }
3214
3215
3216 \f
3217 /***********************************************************
3218 *
3219 *     Func : cmPkRgrTddPrachRscInfo
3220 *
3221 *
3222 *     Desc : Set of PRACH Information for TDD
3223 *
3224 *
3225 *     Ret  : S16
3226 *
3227 *     Notes:
3228 *
3229 *     File  :
3230 *
3231 **********************************************************/
3232 #ifdef ANSI
3233 S16 cmPkRgrTddPrachRscInfo
3234 (
3235 RgrTddPrachRscInfo *param,
3236 Buffer *mBuf
3237 )
3238 #else
3239 S16 cmPkRgrTddPrachRscInfo(param, mBuf)
3240 RgrTddPrachRscInfo *param;
3241 Buffer *mBuf;
3242 #endif
3243 {
3244
3245    S32 i;
3246
3247    for (i=param->numRsc-1; i >= 0; i--) {
3248       CMCHKPK(cmPkRgrTddPrachInfo, &param->prachInfo[i], mBuf);
3249    }
3250    CMCHKPK(oduUnpackUInt8, param->numRsc, mBuf);
3251    return ROK;
3252 }
3253
3254
3255 \f
3256 /***********************************************************
3257 *
3258 *     Func : cmUnpkRgrTddPrachRscInfo
3259 *
3260 *
3261 *     Desc : Set of PRACH Information for TDD
3262 *
3263 *
3264 *     Ret  : S16
3265 *
3266 *     Notes:
3267 *
3268 *     File  :
3269 *
3270 **********************************************************/
3271 #ifdef ANSI
3272 S16 cmUnpkRgrTddPrachRscInfo
3273 (
3274 RgrTddPrachRscInfo *param,
3275 Buffer *mBuf
3276 )
3277 #else
3278 S16 cmUnpkRgrTddPrachRscInfo(param, mBuf)
3279 RgrTddPrachRscInfo *param;
3280 Buffer *mBuf;
3281 #endif
3282 {
3283
3284    S32 i;
3285
3286    CMCHKUNPK(oduPackUInt8, &param->numRsc, mBuf);
3287    for (i=0; i<param->numRsc; i++) {
3288       CMCHKUNPK(cmUnpkRgrTddPrachInfo, &param->prachInfo[i], mBuf);
3289    }
3290    return ROK;
3291 }
3292
3293
3294 #endif
3295
3296 #endif
3297
3298 \f
3299 /***********************************************************
3300 *
3301 *     Func : cmPkRgrEnbPfs
3302 *
3303 *
3304 *     Desc : PFS Configuration
3305 *
3306 *
3307 *     Ret  : S16
3308 *
3309 *     Notes:
3310 *
3311 *     File  :
3312 *
3313 **********************************************************/
3314 #ifdef ANSI
3315 S16 cmPkRgrEnbPfs
3316 (
3317 RgrEnbPfs  *param,
3318 Buffer    *mBuf
3319 )
3320 #else
3321 S16 cmPkRgrEnbPfs(param, mBuf)
3322 RgrEnbPfs  *param;
3323 Buffer    *mBuf;
3324 #endif
3325 {
3326    S32 idx;
3327    for(idx = RGR_MAX_NUM_QCI-1; idx >= 0; idx--)
3328    {
3329       CMCHKPK(oduUnpackUInt32, param->qciWgt[idx], mBuf);
3330    }
3331    CMCHKPK(oduUnpackUInt8, param->fairCoeffi, mBuf);
3332    CMCHKPK(oduUnpackUInt8, param->tptCoeffi, mBuf);
3333
3334    return ROK;
3335 }
3336
3337
3338 \f
3339 /***********************************************************
3340 *
3341 *     Func : cmUnpkRgrEnbPfs
3342 *
3343 *
3344 *     Desc : PFS Configuration
3345 *
3346 *
3347 *     Ret  : S16
3348 *
3349 *     Notes:
3350 *
3351 *     File  :
3352 *
3353 **********************************************************/
3354 #ifdef ANSI
3355 S16 cmUnpkRgrEnbPfs
3356 (
3357 RgrEnbPfs *param,
3358 Buffer   *mBuf
3359 )
3360 #else
3361 S16 cmUnpkRgrEnbPfs(param, mBuf)
3362 RgrEnbPfs *param;
3363 Buffer *mBuf;
3364 #endif
3365 {
3366    S32 idx;
3367
3368    CMCHKUNPK(oduPackUInt8, &param->tptCoeffi, mBuf);
3369    CMCHKUNPK(oduPackUInt8, &param->fairCoeffi, mBuf);
3370    for(idx = 0; idx < RGR_MAX_NUM_QCI; idx++)
3371    {
3372       CMCHKUNPK(oduPackUInt32, &param->qciWgt[idx], mBuf);
3373    }
3374    return ROK;
3375 }
3376
3377 /*rgr_c_001.main_7 - Added support for SPS*/
3378 \f
3379 /***********************************************************
3380 *
3381 *     Func : cmPkRgrSpsCellCfg
3382 *
3383 *
3384 *     Desc : DL SPS configuration parameters per UE
3385 TODO: Check if this is to be added to re-configuration as well
3386 *
3387 *
3388 *     Ret  : S16
3389 *
3390 *     Notes:
3391 *
3392 *     File  :
3393 *
3394 **********************************************************/
3395 #ifdef ANSI
3396 S16 cmPkRgrSpsCellCfg
3397 (
3398 RgrSpsCellCfg *param,
3399 Buffer *mBuf
3400 )
3401 #else
3402 S16 cmPkRgrSpsCellCfg(param, mBuf)
3403 RgrSpsCellCfg *param;
3404 Buffer *mBuf;
3405 #endif
3406 {
3407
3408    CMCHKPK(oduUnpackUInt16, param->maxSpsUePerUlSf, mBuf);
3409    CMCHKPK(oduUnpackUInt16, param->maxSpsUePerDlSf, mBuf);
3410    CMCHKPK(oduUnpackUInt8, param->maxSpsDlBw, mBuf);
3411
3412    return ROK;
3413 }
3414
3415
3416 \f
3417 /***********************************************************
3418 *
3419 *     Func : cmUnpkRgrSpsDlCellCfg
3420 *
3421 *
3422 *     Desc : DL SPS configuration parameters per UE
3423 TODO: Check if this is to be added to re-configuration as well
3424 *
3425 *
3426 *     Ret  : S16
3427 *
3428 *     Notes:
3429 *
3430 *     File  :
3431 *
3432 **********************************************************/
3433 #ifdef ANSI
3434 S16 cmUnpkRgrSpsDlCellCfg
3435 (
3436 RgrSpsCellCfg *param,
3437 Buffer *mBuf
3438 )
3439 #else
3440 S16 cmUnpkRgrSpsDlCellCfg(param, mBuf)
3441 RgrSpsCellCfg *param;
3442 Buffer *mBuf;
3443 #endif
3444 {
3445
3446
3447    CMCHKUNPK(oduPackUInt8, &param->maxSpsDlBw, mBuf);
3448    CMCHKUNPK(oduPackUInt16, &param->maxSpsUePerDlSf, mBuf);
3449    CMCHKUNPK(oduPackUInt16, &param->maxSpsUePerUlSf, mBuf);
3450
3451    return ROK;
3452 }
3453
3454 #ifdef RG_5GTF
3455 S16 cmPkRgr5gtfCellCfg
3456 (
3457 Rgr5gtfCellCfg   *param,
3458 Buffer           *mBuf
3459 )
3460 {
3461    S8 idx = 0;
3462    for (idx = MAX_5GTF_SUBFRAME_INFO - 1; idx >= 0 ;--idx)
3463    {
3464
3465       CMCHKPK(oduUnpackUInt32, param->dynConfig[(uint8_t)idx], mBuf);
3466    }
3467    CMCHKPK(oduUnpackUInt8, param->uePerGrp, mBuf);
3468    CMCHKPK(oduUnpackUInt8, param->ueGrpPerTti, mBuf);
3469    CMCHKPK(oduUnpackUInt8, param->numUes, mBuf);
3470    CMCHKPK(oduUnpackUInt8, param->numOfCC, mBuf);
3471    CMCHKPK(oduUnpackUInt8, param->bwPerCC, mBuf);
3472    CMCHKPK(oduUnpackUInt8, param->cfi, mBuf);
3473    return ROK;
3474 }
3475
3476 S16 cmUnPkRgr5gtfCellCfg
3477 (
3478 Rgr5gtfCellCfg   *param,
3479 Buffer           *mBuf
3480 )
3481 {
3482    S8 idx = 0;
3483
3484    CMCHKUNPK(oduPackUInt8, &param->cfi, mBuf);
3485    CMCHKUNPK(oduPackUInt8, &param->bwPerCC, mBuf);
3486    CMCHKUNPK(oduPackUInt8, &param->numOfCC, mBuf);
3487    CMCHKUNPK(oduPackUInt8, &param->numUes, mBuf);
3488    CMCHKUNPK(oduPackUInt8, &param->ueGrpPerTti, mBuf);
3489    CMCHKUNPK(oduPackUInt8, &param->uePerGrp, mBuf);
3490    for (idx = 0; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
3491    {
3492
3493       CMCHKUNPK(oduPackUInt32, &param->dynConfig[(uint8_t)idx], mBuf);
3494    }
3495    return ROK;
3496 }
3497 #endif
3498
3499
3500 /*LAA : functions to pack and unpack LAA params*/
3501 /***********************************************************
3502 *
3503 *     Func : cmPkRgrLteUCellCfg
3504 *
3505 *
3506 *     Desc : LAA configuration for the Cell
3507 *
3508 *
3509 *     Ret  : S16
3510 *
3511 *     Notes:
3512 *
3513 *     File  :
3514 *
3515 **********************************************************/
3516 #ifdef ANSI
3517 static S16 cmPkRgrLteUCellCfg
3518 (
3519 RgrLteUCfg *param,
3520 Buffer *mBuf
3521 )
3522 #else
3523 static S16 cmPkRgrLteUCellCfg(param, mBuf)
3524 RgrLteUCfg *param;
3525 Buffer *mBuf;
3526 #endif
3527 {
3528
3529    CMCHKPK(oduUnpackUInt8, param->isLaaCell, mBuf);
3530
3531    return ROK;
3532 }
3533
3534 /***********************************************************
3535 *
3536 *     Func : cmUnpkRgrLteUCellCfg
3537 *
3538 *
3539 *     Desc : LAA configuration for the cell
3540 *
3541 *
3542 *     Ret  : S16
3543 *
3544 *     Notes:
3545 *
3546 *     File  :
3547 *
3548 **********************************************************/
3549 #ifdef ANSI
3550 static S16 cmUnpkRgrLteUCellCfg
3551 (
3552 RgrLteUCfg *param,
3553 Buffer *mBuf
3554 )
3555 #else
3556 static S16 cmUnpkRgrLteUCellCfg(param, mBuf)
3557 RgrLteUCfg *param;
3558 Buffer *mBuf;
3559 #endif
3560 {
3561
3562
3563    CMCHKUNPK(oduPackUInt8, &param->isLaaCell, mBuf);
3564
3565    return ROK;
3566 }
3567
3568 /* LTE_ADV_FLAG_REMOVED_START */
3569 /***********************************************************
3570  *
3571  *     Func : cmPkRgrLteAdvancedUeConfig
3572  *
3573  *
3574  *     Desc : PAcks LteAdvancedUeConfig
3575  *
3576  *
3577  *     Ret  : S16
3578  *
3579  *     Notes:
3580  *
3581  *     File  :
3582  *
3583  **********************************************************/
3584 #ifdef ANSI
3585 S16 cmPkRgrLteAdvancedUeConfig
3586 (
3587  RgrLteAdvancedUeConfig *param,
3588  Buffer *mBuf
3589  )
3590 #else
3591 S16 cmPkRgrLteAdvancedUeConfig(param, mBuf)
3592    RgrLteAdvancedUeConfig *param;
3593    Buffer *mBuf;
3594 #endif
3595 {
3596
3597    CMCHKPK(oduUnpackUInt8, param->isUeCellEdge, mBuf);
3598    CMCHKPK(oduUnpackUInt8, param->isAbsUe, mBuf);
3599    CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
3600    return ROK;
3601 }
3602
3603 /***********************************************************
3604  *
3605  *     Func : cmUnpkRgrLteAdvancedUeConfig
3606  *
3607  *
3608  *     Desc : unpacks LteAdvancedUeConfig
3609  *
3610  *
3611  *     Ret  : S16
3612  *
3613  *     Notes:
3614  *
3615  *     File  :
3616  *
3617  **********************************************************/
3618 #ifdef ANSI
3619 S16 cmUnpkRgrLteAdvancedUeConfig
3620 (
3621  RgrLteAdvancedUeConfig *param,
3622  Buffer *mBuf
3623  )
3624 #else
3625 S16 cmUnpkRgrLteAdvancedUeConfig(param, mBuf)
3626    RgrLteAdvancedUeConfig *param;
3627    Buffer *mBuf;
3628 #endif
3629 {
3630
3631    CMCHKUNPK(oduPackUInt32, &param->pres, mBuf);
3632    CMCHKUNPK(oduPackUInt8, &param->isAbsUe, mBuf);
3633    CMCHKUNPK(oduPackUInt8, &param->isUeCellEdge, mBuf);
3634    return ROK;
3635 }
3636
3637 /***********************************************************
3638  *
3639  *     Func : cmPkRgrAbsConfig
3640  *
3641  *
3642  *     Desc : Packs RgrAbsConfig
3643  *
3644  *
3645  *     Ret  : S16
3646  *
3647  *     Notes:
3648  *
3649  *     File  :
3650  *
3651  **********************************************************/
3652 #ifdef ANSI
3653 S16 cmPkRgrAbsConfig
3654 (
3655  RgrAbsConfig *param,
3656  Buffer *mBuf
3657  )
3658 #else
3659 S16 cmPkRgrAbsConfig(param, mBuf)
3660    RgrAbsConfig *param;
3661    Buffer *mBuf;
3662 #endif
3663 {
3664    S8   indx = 0;
3665
3666    CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
3667    for (indx = RGR_ABS_PATTERN_LEN-1; indx >= 0; indx--)
3668    {
3669       CMCHKPK(oduUnpackUInt8, param->absPattern[(uint8_t)indx], mBuf);
3670    }
3671
3672    CMCHKPK(oduUnpackUInt32, param->absPatternType, mBuf);
3673    CMCHKPK(oduUnpackUInt32, param->absLoadPeriodicity, mBuf);
3674
3675    return ROK;
3676
3677 }
3678 /***********************************************************
3679  *
3680  *     Func : cmPkRgrSfrConfig
3681  *
3682  *
3683  *     Desc : Packs RgrSfrConfig
3684  *
3685  *
3686  *     Ret  : S16
3687  *
3688  *     Notes:
3689  *
3690  *     File  :
3691  *
3692  **********************************************************/
3693 #ifdef ANSI
3694 S16 cmPkRgrSfrConfig
3695 (
3696  RgrSfrConfig *param,
3697  Buffer *mBuf
3698  )
3699 #else
3700 S16 cmPkRgrSfrConfig(param, mBuf)
3701    RgrSfrConfig *param;
3702    Buffer *mBuf;
3703 #endif
3704 {
3705
3706    CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
3707 #ifdef TFU_UPGRADE
3708    CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pHigh, mBuf);
3709    CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pLow, mBuf);
3710 #endif
3711    CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.endRb, mBuf);
3712    CMCHKPK(oduUnpackUInt8, param->cellEdgeRbRange.startRb, mBuf);
3713
3714    return ROK;
3715
3716 }
3717
3718
3719 /***********************************************************
3720  *
3721  *     Func : cmPkRgrDsfrConfig
3722  *
3723  *
3724  *     Desc : Packs RgrDsfrConfig
3725  *
3726  *
3727  *     Ret  : S16
3728  *
3729  *     Notes:  AIRSPAN_LTE_ADV_DSFR
3730  *
3731  *     File  :
3732  *
3733  **********************************************************/
3734 #ifdef ANSI
3735 S16 cmPkRgrDsfrConfig
3736 (
3737  RgrDsfrConfig *param,
3738  Buffer *mBuf
3739  )
3740 #else
3741 S16 cmPkRgrDsfrConfig(param, mBuf)
3742    RgrDsfrConfig *param;
3743    Buffer *mBuf;
3744 #endif
3745 {
3746
3747    CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
3748
3749    return ROK;
3750
3751 }
3752
3753
3754 /***********************************************************
3755  *
3756  *     Func : cmUnpkRgrDsfrConfig
3757  *
3758  *
3759  *     Desc : UnPacks RgrDsfrConfig
3760  *
3761  *
3762  *     Ret  : S16
3763  *
3764  *     Notes:  AIRSPAN_LTE_ADV_DSFR
3765  *
3766  *     File  :
3767  *
3768  **********************************************************/
3769 #ifdef ANSI
3770 S16 cmUnpkRgrDsfrConfig
3771 (
3772  RgrDsfrConfig *param,
3773  Buffer *mBuf
3774  )
3775 #else
3776 S16 cmUnpkRgrDsfrConfig(param, mBuf)
3777    RgrDsfrConfig *param;
3778    Buffer *mBuf;
3779 #endif
3780 {
3781
3782    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->status, mBuf);
3783    return ROK;
3784
3785 }
3786
3787
3788 /***********************************************************
3789  *
3790  *     Func : cmPkRgrCellLteAdvancedFeatureCfg
3791  *
3792  *
3793  *     Desc : Cell LteAdvancedFeatureCfg
3794  *
3795  *
3796  *     Ret  : S16
3797  *
3798  *     Notes:
3799  *
3800  *     File  :
3801  *
3802  **********************************************************/
3803 #ifdef ANSI
3804 S16 cmPkRgrCellLteAdvancedFeatureCfg
3805 (
3806  RgrLteAdvancedCellConfig *param,
3807  Buffer *mBuf
3808  )
3809 #else
3810 S16 cmPkRgrCellLteAdvancedFeatureCfg(param, mBuf)
3811    RgrLteAdvancedCellConfig *param;
3812    Buffer *mBuf;
3813 #endif
3814 {
3815
3816    CMCHKPK(oduUnpackUInt32, param->pres, mBuf);
3817    CMCHKPK(cmPkRgrDsfrConfig, &param->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
3818    CMCHKPK(cmPkRgrSfrConfig,  &param->sfrCfg, mBuf);
3819    CMCHKPK(cmPkRgrAbsConfig,  &param->absCfg, mBuf);
3820
3821    return ROK;
3822
3823 }
3824
3825
3826 /***********************************************************
3827  *
3828  *     Func : cmUnpkRgrAbsConfig
3829  *
3830  *
3831  *     Desc : Unpacks AbsConfig
3832  *
3833  *
3834  *     Ret  : S16
3835  *
3836  *     Notes:
3837  *
3838  *     File  :
3839  *
3840  **********************************************************/
3841 #ifdef ANSI
3842 S16 cmUnpkRgrAbsConfig
3843 (
3844  RgrAbsConfig *param,
3845  Buffer *mBuf
3846  )
3847 #else
3848 S16 cmUnpkRgrAbsConfig(param, mBuf)
3849    RgrAbsConfig *param;
3850    Buffer *mBuf;
3851 #endif
3852 {
3853
3854    S8 indx = 0;
3855
3856    CMCHKUNPK(oduPackUInt32, &param->absLoadPeriodicity, mBuf);
3857    CMCHKUNPK(oduPackUInt32, &param->absPatternType, mBuf);
3858    for (indx = 0; indx <RGR_ABS_PATTERN_LEN; indx++)
3859    {
3860       CMCHKUNPK(oduPackUInt8, &param->absPattern[(uint8_t)indx], mBuf);
3861    }
3862    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->status, mBuf);
3863
3864    return ROK;
3865
3866 }
3867
3868 /***********************************************************
3869  *
3870  *     Func : cmUnpkRgrSfrConfig
3871  *
3872  *
3873  *     Desc : Unpacks SfrConfig
3874  *
3875  *
3876  *     Ret  : S16
3877  *
3878  *     Notes:
3879  *
3880  *     File  :
3881  *
3882  **********************************************************/
3883 #ifdef ANSI
3884 S16 cmUnpkRgrSfrConfig
3885 (
3886  RgrSfrConfig *param,
3887  Buffer *mBuf
3888  )
3889 #else
3890 S16 cmUnpkRgrSfrConfig(param, mBuf)
3891    RgrSfrConfig *param;
3892    Buffer *mBuf;
3893 #endif
3894 {
3895
3896
3897    CMCHKUNPK(oduPackUInt8, &param->cellEdgeRbRange.startRb, mBuf);
3898    CMCHKUNPK(oduPackUInt8, &param->cellEdgeRbRange.endRb, mBuf);
3899 #ifdef TFU_UPGRADE
3900    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pwrThreshold.pLow, mBuf);
3901    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pwrThreshold.pHigh, mBuf);
3902 #endif
3903    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->status, mBuf);
3904
3905    return ROK;
3906 }
3907
3908 /***********************************************************
3909  *
3910  *     Func : cmUnpkRgrCellLteAdvancedFeatureCfg
3911  *
3912  *
3913  *     Desc : unpacks LteAdvancedFeatureCfg per cell
3914  *
3915  *
3916  *     Ret  : S16
3917  *
3918  *     Notes:
3919  *
3920  *     File  :
3921  *
3922  **********************************************************/
3923 #ifdef ANSI
3924 S16 cmUnpkRgrCellLteAdvancedFeatureCfg
3925 (
3926  RgrLteAdvancedCellConfig *param,
3927  Buffer *mBuf
3928  )
3929 #else
3930 S16 cmUnpkRgrCellLteAdvancedFeatureCfg(param, mBuf)
3931    RgrLteAdvancedCellConfig *param;
3932    Buffer *mBuf;
3933 #endif
3934 {
3935
3936    CMCHKUNPK(cmUnpkRgrAbsConfig, &param->absCfg, mBuf);
3937    CMCHKUNPK(cmUnpkRgrSfrConfig, &param->sfrCfg, mBuf);
3938    CMCHKUNPK(cmUnpkRgrDsfrConfig, &param->dsfrCfg, mBuf); /*AIRSPAN_LTE_ADV_DSFR*/
3939    CMCHKUNPK(oduPackUInt32, &param->pres, mBuf);
3940
3941    return ROK;
3942 }
3943
3944 /* LTE_ADV_FLAG_REMOVED_END */
3945
3946 /***********************************************************
3947 *
3948 *     Func : cmPkMacSchedGnbCfg
3949 *
3950 *     Desc : SCH GNB Configurations
3951 *
3952 *     Ret  : S16
3953 *
3954 *     Notes:
3955 *
3956 *     File  :
3957 *
3958 **********************************************************/
3959 #ifdef ANSI
3960 S16 cmPkMacSchedGnbCfg
3961 (
3962 MacSchedGnbCfg *param,
3963 Buffer         *mBuf
3964 )
3965 #else
3966 S16 cmPkMacSchedGnbCfg(param, mBuf)
3967 RgrSchedEnbCfg *param;
3968 Buffer         *mBuf;
3969 #endif
3970 {
3971
3972    CMCHKPK(oduUnpackUInt8, param->maxDlUePerTti, mBuf);
3973    CMCHKPK(oduUnpackUInt8, param->maxUlUePerTti, mBuf);
3974    CMCHKPK(oduUnpackUInt8, param->numCells, mBuf);
3975    CMCHKPK(oduUnpackUInt8, param->dlSchdType, mBuf);
3976    CMCHKPK(oduUnpackUInt8, param->ulSchdType, mBuf);
3977    CMCHKPK(oduUnpackUInt8, param->numTxAntPorts, mBuf);
3978    return ROK;
3979 } /* cmPkRgrSchedEnbCfg */
3980
3981 /***********************************************************
3982 *
3983 *     Func : cmUnpkMacSchedGnbCfg
3984 *
3985 *
3986 *     Desc : SCH Gnodeb Configuration to SCH
3987 *
3988 *
3989 *     Ret  : S16
3990 *
3991 *     Notes:
3992 *
3993 *     File  :
3994 *
3995 **********************************************************/
3996 #ifdef ANSI
3997 S16 cmUnpkMacSchedGnbCfg
3998 (
3999 MacSchedGnbCfg *param,
4000 Buffer         *mBuf
4001 )
4002 #else
4003 S16 cmUnpkMacSchedGnbCfg(param, mBuf)
4004 MacSchedGnbCfg *param;
4005 Buffer         *mBuf;
4006 #endif
4007 {
4008
4009
4010    CMCHKUNPK(oduPackUInt8, &param->numTxAntPorts, mBuf);
4011    CMCHKUNPK(oduPackUInt8, &param->ulSchdType, mBuf);
4012    CMCHKUNPK(oduPackUInt8, &param->dlSchdType, mBuf);
4013    CMCHKUNPK(oduPackUInt8, &param->numCells, mBuf);
4014    CMCHKUNPK(oduPackUInt8, &param->maxUlUePerTti, mBuf);
4015    CMCHKUNPK(oduPackUInt8, &param->maxDlUePerTti, mBuf);
4016    return ROK;
4017 } /* cmUnpkMacSchedGnbCfg */
4018
4019 \f
4020 /***********************************************************
4021 *
4022 *     Func : cmPkRgrCellCfg
4023 *
4024 *
4025 *     Desc : Cell Configuration at RRM
4026 *
4027 *
4028 *     Ret  : S16
4029 *
4030 *     Notes:
4031 *
4032 *     File  :
4033 *
4034 **********************************************************/
4035 #ifdef ANSI
4036 S16 cmPkRgrCellCfg
4037 (
4038 RgrCellCfg *param,
4039 Buffer *mBuf
4040 )
4041 #else
4042 S16 cmPkRgrCellCfg(param, mBuf)
4043 RgrCellCfg *param;
4044 Buffer *mBuf;
4045 #endif
4046 {
4047
4048    S32 i;
4049
4050 #ifdef EMTC_ENABLE
4051 /* EMTC related changes start*/
4052
4053
4054 /* EMTC related changes ends*/
4055 #endif
4056
4057 #ifdef RG_5GTF
4058    CMCHKPK(cmPkRgr5gtfCellCfg, &param->Cell5gtfCfg, mBuf);
4059 #endif
4060 #ifdef LTE_ADV
4061    CMCHKPK(oduUnpackUInt8, param->isPucchFormat3Sptd, mBuf);
4062 #endif
4063 /*LAA: Pack LAA params*/
4064    CMCHKPK(cmPkRgrLteUCellCfg, &param->lteUCfg, mBuf);
4065    CMCHKPK(oduUnpackUInt32, param->msg4pAVal, mBuf);
4066    CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
4067    CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
4068    CMCHKPK(oduUnpackUInt16, param->phichTxPwrOffset, mBuf);
4069    CMCHKPK(oduUnpackUInt16, param->rarTxPwrOffset, mBuf);
4070    CMCHKPK(oduUnpackUInt16, param->pcchTxPwrOffset, mBuf);
4071    CMCHKPK(oduUnpackUInt16, param->bcchTxPwrOffset, mBuf);
4072
4073    CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
4074 /*rgr_c_001.main_7 - Added support for SPS*/
4075    CMCHKPK(cmPkRgrSpsCellCfg, &param->spsCfg, mBuf);
4076
4077 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
4078    CMCHKPK(oduUnpackUInt8, param->rrmTtiIndPrd, mBuf);
4079 #ifdef LTE_TDD
4080    CMCHKPK(cmPkRgrTddPrachRscInfo, &param->prachRscInfo, mBuf);
4081    CMCHKPK(oduUnpackUInt8, param->spclSfCfgIdx, mBuf);
4082    CMCHKPK(oduUnpackUInt8, param->ulDlCfgIdx, mBuf);
4083
4084 #endif
4085    CMCHKPK(cmPkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
4086    for (i=param->numCmnLcs-1; i >= 0; i--) {
4087       CMCHKPK(cmPkRgrCmnLchCfg, &param->cmnLcCfg[i], mBuf);
4088    }
4089    CMCHKPK(oduUnpackUInt8, param->numCmnLcs, mBuf);
4090    CMCHKPK(cmPkRgrPreambleSetCfg, &param->macPreambleSet, mBuf);
4091    CMCHKPK(cmPkRgrPuschCfg, &param->puschCfg, mBuf);
4092    CMCHKPK(cmPkRgrUlPwrCfg, &param->pwrCfg, mBuf);
4093    CMCHKPK(cmPkRgrSiCfg, &param->siCfg, mBuf);
4094    CMCHKPK(cmPkRgrRachCfg, &param->rachCfg, mBuf);
4095    CMCHKPK(cmPkRgrSrsCfg, &param->srsCfg, mBuf);
4096    CMCHKPK(cmPkRgrPucchCfg, &param->pucchCfg, mBuf);
4097    CMCHKPK(cmPkRgrPhichCfg, &param->phichCfg, mBuf);
4098    /* LTE_ADV_FLAG_REMOVED_START */
4099    CMCHKPK(cmPkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
4100    /* LTE_ADV_FLAG_REMOVED_END */
4101    CMCHKPK(cmPkRgrBwCfg, &param->bwCfg, mBuf);
4102    CMCHKPK(cmPkRgrDlfsCfg, &param->dlfsCfg, mBuf);
4103    CMCHKPK(cmPkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
4104    CMCHKPK(cmPkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
4105    CMCHKPK(cmPkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
4106    CMCHKPK(cmPkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
4107    CMCHKPK(cmPkRgrCfiCfg, &param->cfiCfg, mBuf);
4108    CMCHKPK(cmPkRgrRntiCfg, &param->macRnti, mBuf);
4109    CMCHKPK(cmPkRgrDlHqCfg, &param->dlHqCfg, mBuf);
4110    CMCHKPK(oduUnpackUInt8, param->dlfsSchdType, mBuf);
4111
4112    CMCHKPK(SPkS8, param->pMax, mBuf);
4113    CMCHKPK(oduUnpackUInt8, param->cellModSchm, mBuf);
4114    CMCHKPK(oduUnpackUInt8, param->isCpDlExtend, mBuf);
4115    CMCHKPK(oduUnpackUInt8, param->isCpUlExtend, mBuf);
4116    CMCHKPK(oduUnpackUInt8, param->maxUlUeNewTxPerTti, mBuf);
4117    CMCHKPK(oduUnpackUInt8, param->maxDlUeNewTxPerTti, mBuf);
4118    CMCHKPK(oduUnpackUInt8, param->maxDlRetxBw, mBuf);
4119    CMCHKPK(oduUnpackUInt8, param->maxDlBwPerUe, mBuf);
4120    CMCHKPK(oduUnpackUInt8, param->maxUlBwPerUe, mBuf);
4121    CMCHKPK(oduUnpackUInt8, param->maxCcchPerDlSf, mBuf);
4122    CMCHKPK(oduUnpackUInt8, param->maxUePerDlSf, mBuf);
4123    CMCHKPK(oduUnpackUInt8, param->maxUePerUlSf, mBuf);
4124 #ifdef RGR_V1
4125    /* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
4126       of  MSG3s */
4127    CMCHKPK(oduUnpackUInt8, param->maxMsg3PerUlSf, mBuf);
4128 #endif
4129    CMCHKPK(oduUnpackUInt8, param->macInst, mBuf);
4130    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
4131
4132 #ifdef EMTC_ENABLE
4133 /* EMTC related changes start*/
4134    CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
4135    CMCHKPK(cmPkRgrEmtcCfg, &param->emtcCellCfg, mBuf);
4136 /* EMTC related changes ends*/
4137 #endif
4138
4139    return ROK;
4140 }
4141
4142
4143 \f
4144 /***********************************************************
4145 *
4146 *     Func : cmUnpkRgrCellCfg
4147 *
4148 *
4149 *     Desc : Cell Configuration at RRM
4150 *
4151 *
4152 *     Ret  : S16
4153 *
4154 *     Notes:
4155 *
4156 *     File  :
4157 *
4158 **********************************************************/
4159 #ifdef ANSI
4160 S16 cmUnpkRgrCellCfg
4161 (
4162 RgrCellCfg *param,
4163 Buffer *mBuf
4164 )
4165 #else
4166 S16 cmUnpkRgrCellCfg(param, mBuf)
4167 RgrCellCfg *param;
4168 Buffer *mBuf;
4169 #endif
4170 {
4171
4172    S32 i;
4173
4174 #ifdef EMTC_ENABLE
4175 /* EMTC related changes start*/
4176    CMCHKUNPK(cmUnpkRgrEmtcCfg, &param->emtcCellCfg, mBuf);
4177    CMCHKUNPK(oduPackUInt8, &param->emtcEnable, mBuf);
4178 /* EMTC related changes ends*/
4179 #endif
4180
4181    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
4182    CMCHKUNPK(oduPackUInt8, &param->macInst, mBuf);
4183 #ifdef RGR_V1
4184    /* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
4185       of  MSG3s */
4186    CMCHKUNPK(oduPackUInt8, &param->maxMsg3PerUlSf, mBuf);
4187 #endif
4188    CMCHKUNPK(oduPackUInt8, &param->maxUePerUlSf, mBuf);
4189    CMCHKUNPK(oduPackUInt8, &param->maxUePerDlSf, mBuf);
4190    CMCHKUNPK(oduPackUInt8, &param->maxCcchPerDlSf, mBuf);
4191    CMCHKUNPK(oduPackUInt8, &param->maxUlBwPerUe, mBuf);
4192    CMCHKUNPK(oduPackUInt8, &param->maxDlBwPerUe, mBuf);
4193    CMCHKUNPK(oduPackUInt8, &param->maxDlRetxBw, mBuf);
4194    CMCHKUNPK(oduPackUInt8, &param->maxDlUeNewTxPerTti, mBuf);
4195    CMCHKUNPK(oduPackUInt8, &param->maxUlUeNewTxPerTti, mBuf);
4196    CMCHKUNPK(oduPackUInt8, &param->isCpUlExtend, mBuf);
4197    CMCHKUNPK(oduPackUInt8, &param->isCpDlExtend, mBuf);
4198    CMCHKUNPK(oduPackUInt8, &param->cellModSchm, mBuf);
4199    CMCHKUNPK(SUnpkS8, &param->pMax, mBuf);
4200    CMCHKUNPK(oduPackUInt8, &param->dlfsSchdType, mBuf);
4201    CMCHKUNPK(cmUnpkRgrDlHqCfg, &param->dlHqCfg, mBuf);
4202    CMCHKUNPK(cmUnpkRgrRntiCfg, &param->macRnti, mBuf);
4203    CMCHKUNPK(cmUnpkRgrCfiCfg, &param->cfiCfg, mBuf);
4204    CMCHKUNPK(cmUnpkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
4205    CMCHKUNPK(cmUnpkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
4206    CMCHKUNPK(cmUnpkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
4207    CMCHKUNPK(cmUnpkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
4208    CMCHKUNPK(cmUnpkRgrDlfsCfg, &param->dlfsCfg, mBuf);
4209    CMCHKUNPK(cmUnpkRgrBwCfg, &param->bwCfg, mBuf);
4210    /* LTE_ADV_FLAG_REMOVED_START */
4211    CMCHKUNPK(cmUnpkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
4212    /* LTE_ADV_FLAG_REMOVED_END */
4213    CMCHKUNPK(cmUnpkRgrPhichCfg, &param->phichCfg, mBuf);
4214    CMCHKUNPK(cmUnpkRgrPucchCfg, &param->pucchCfg, mBuf);
4215    CMCHKUNPK(cmUnpkRgrSrsCfg, &param->srsCfg, mBuf);
4216    CMCHKUNPK(cmUnpkRgrRachCfg, &param->rachCfg, mBuf);
4217    CMCHKUNPK(cmUnpkRgrSiCfg, &param->siCfg, mBuf);
4218    CMCHKUNPK(cmUnpkRgrUlPwrCfg, &param->pwrCfg, mBuf);
4219    CMCHKUNPK(cmUnpkRgrPuschCfg, &param->puschCfg, mBuf);
4220    CMCHKUNPK(cmUnpkRgrPreambleSetCfg, &param->macPreambleSet, mBuf);
4221    CMCHKUNPK(oduPackUInt8, &param->numCmnLcs, mBuf);
4222    for (i=0; i<param->numCmnLcs; i++) {
4223       CMCHKUNPK(cmUnpkRgrCmnLchCfg, &param->cmnLcCfg[i], mBuf);
4224    }
4225    CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
4226
4227 #ifdef LTE_TDD
4228    CMCHKUNPK(oduPackUInt8, &param->ulDlCfgIdx, mBuf);
4229    CMCHKUNPK(oduPackUInt8, &param->spclSfCfgIdx, mBuf);
4230    CMCHKUNPK(cmUnpkRgrTddPrachRscInfo, &param->prachRscInfo, mBuf);
4231
4232 #endif
4233 /* rgr_c_001.main_3: Added TTI indication from MAC to RGR user */
4234    CMCHKUNPK(oduPackUInt8, &param->rrmTtiIndPrd, mBuf);
4235    /*rgr_c_001.main_7 - Added support for SPS*/
4236    CMCHKUNPK(cmUnpkRgrSpsDlCellCfg, &param->spsCfg, mBuf);
4237
4238    CMCHKUNPK(oduPackUInt16, &param->t300TmrVal, mBuf);
4239    CMCHKPK(oduPackUInt16, &param->bcchTxPwrOffset, mBuf);
4240    CMCHKPK(oduPackUInt16, &param->pcchTxPwrOffset, mBuf);
4241    CMCHKPK(oduPackUInt16, &param->rarTxPwrOffset, mBuf);
4242    CMCHKPK(oduPackUInt16, &param->phichTxPwrOffset, mBuf);
4243    CMCHKUNPK(oduPackUInt8, &param->isDynCfiEnb, mBuf);
4244    CMCHKUNPK(oduPackUInt8, &param->isAutoCfgModeEnb, mBuf);
4245    CMCHKPK(oduPackUInt32, (uint32_t*)&param->msg4pAVal, mBuf);
4246    /*LAA: Unpack LAA Cell params*/
4247    CMCHKUNPK(cmUnpkRgrLteUCellCfg, &param->lteUCfg, mBuf);
4248    #ifdef LTE_ADV
4249    CMCHKUNPK(oduPackUInt8, &param->isPucchFormat3Sptd, mBuf);
4250 #endif
4251 #ifdef RG_5GTF
4252    CMCHKUNPK(cmUnPkRgr5gtfCellCfg, &param->Cell5gtfCfg, mBuf);
4253 #endif
4254    return ROK;
4255 }
4256
4257
4258 \f
4259 /***********************************************************
4260 *
4261 *     Func : cmPkRgrUeAprdDlCqiCfg
4262 *
4263 *
4264 *     Desc : Downlink Aperiodic CQI reporting related configuration per UE
4265 *
4266 *
4267 *     Ret  : S16
4268 *
4269 *     Notes:
4270 *
4271 *     File  :
4272 *
4273 **********************************************************/
4274 #ifdef ANSI
4275 S16 cmPkRgrUeAprdDlCqiCfg
4276 (
4277 RgrUeAprdDlCqiCfg *param,
4278 Buffer *mBuf
4279 )
4280 #else
4281 S16 cmPkRgrUeAprdDlCqiCfg(param, mBuf)
4282 RgrUeAprdDlCqiCfg *param;
4283 Buffer *mBuf;
4284 #endif
4285 {
4286
4287    /*Pack Aperiodic Trigger List only for Pcell */
4288 #ifdef LTE_ADV
4289    CMCHKPK(oduUnpackUInt8, param->triggerSet2, mBuf);
4290    CMCHKPK(oduUnpackUInt8, param->triggerSet1, mBuf);
4291 #endif
4292
4293    CMCHKPK(oduUnpackUInt32, param->aprdModeEnum, mBuf);
4294    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
4295    return ROK;
4296 }
4297
4298
4299 \f
4300 /***********************************************************
4301 *
4302 *     Func : cmUnpkRgrUeAprdDlCqiCfg
4303 *
4304 *
4305 *     Desc : Downlink Aperiodic CQI reporting related configuration per UE
4306 *
4307 *
4308 *     Ret  : S16
4309 *
4310 *     Notes:
4311 *
4312 *     File  :
4313 *
4314 **********************************************************/
4315 #ifdef ANSI
4316 S16 cmUnpkRgrUeAprdDlCqiCfg
4317 (
4318 RgrUeAprdDlCqiCfg *param,
4319 Buffer *mBuf
4320 )
4321 #else
4322 S16 cmUnpkRgrUeAprdDlCqiCfg(param, mBuf)
4323 RgrUeAprdDlCqiCfg *param;
4324 Buffer *mBuf;
4325 #endif
4326 {
4327    uint32_t tmpEnum;
4328
4329
4330    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4331    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4332    param->aprdModeEnum = (RgrAprdCqiMode) tmpEnum;
4333
4334 #ifdef LTE_ADV
4335    CMCHKUNPK(oduPackUInt8, &param->triggerSet1, mBuf);
4336    CMCHKUNPK(oduPackUInt8, &param->triggerSet2, mBuf);
4337 #endif
4338
4339    return ROK;
4340 }
4341
4342
4343 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
4344 #ifndef TFU_UPGRADE
4345
4346 \f
4347 /***********************************************************
4348 *
4349 *     Func : cmPkRgrUePrdDlCqiCfg
4350 *
4351 *
4352 *     Desc : Downlink Periodic CQI reporting related configuration per UE
4353 *
4354 *
4355 *     Ret  : S16
4356 *
4357 *     Notes:
4358 *
4359 *     File  :
4360 *
4361 **********************************************************/
4362 #ifdef ANSI
4363 S16 cmPkRgrUePrdDlCqiCfg
4364 (
4365 RgrUePrdDlCqiCfg *param,
4366 Buffer *mBuf
4367 )
4368 #else
4369 S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
4370 RgrUePrdDlCqiCfg *param;
4371 Buffer *mBuf;
4372 #endif
4373 {
4374
4375
4376    CMCHKPK(oduUnpackUInt16, param->cqiPmiCfgIdx, mBuf);
4377    CMCHKPK(oduUnpackUInt8, param->k, mBuf);
4378    CMCHKPK(SPkS8, param->cqiOffst, mBuf);
4379    CMCHKPK(oduUnpackUInt8, param->subframeOffst, mBuf);
4380    CMCHKPK(oduUnpackUInt32, param->prdicityEnum, mBuf);
4381    CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
4382    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
4383    return ROK;
4384 }
4385
4386
4387 \f
4388 /***********************************************************
4389 *
4390 *     Func : cmUnpkRgrUePrdDlCqiCfg
4391 *
4392 *
4393 *     Desc : Downlink Periodic CQI reporting related configuration per UE
4394 *
4395 *
4396 *     Ret  : S16
4397 *
4398 *     Notes:
4399 *
4400 *     File  :
4401 *
4402 **********************************************************/
4403 #ifdef ANSI
4404 S16 cmUnpkRgrUePrdDlCqiCfg
4405 (
4406 RgrUePrdDlCqiCfg *param,
4407 Buffer *mBuf
4408 )
4409 #else
4410 S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
4411 RgrUePrdDlCqiCfg *param;
4412 Buffer *mBuf;
4413 #endif
4414 {
4415    uint32_t tmpEnum;
4416
4417
4418    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
4419    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4420    param->prdModeEnum = tmpEnum;
4421    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4422    param->prdicityEnum = tmpEnum;
4423    CMCHKUNPK(oduPackUInt8, &param->subframeOffst, mBuf);
4424    CMCHKUNPK(SUnpkS8, &param->cqiOffst, mBuf);
4425    CMCHKUNPK(oduPackUInt8, &param->k, mBuf);
4426    CMCHKUNPK(oduPackUInt16, &param->cqiPmiCfgIdx, mBuf);
4427    return ROK;
4428 }
4429
4430
4431 #endif
4432
4433 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
4434 #ifdef TFU_UPGRADE
4435 /***********************************************************
4436 *
4437 *     Func : cmPkRgrUeDlPCqiSetup
4438 *
4439 *
4440 *     Desc : Periodic CQI Setup configuration parameters information
4441 *
4442 *
4443 *     Ret  : S16
4444 *
4445 *     Notes:
4446 *
4447 *     File  :
4448 *
4449 **********************************************************/
4450 #ifdef ANSI
4451 S16 cmPkRgrUeDlPCqiSetup
4452 (
4453 RgrUeDlPCqiSetup *param,
4454 Buffer *mBuf
4455 )
4456 #else
4457 S16 cmPkRgrUeDlPCqiSetup(param, mBuf)
4458 RgrUeDlPCqiSetup *param;
4459 Buffer *mBuf;
4460 #endif
4461 {
4462
4463
4464    CMCHKPK(oduUnpackUInt32, param->prdModeEnum, mBuf);
4465    CMCHKPK(oduUnpackUInt8, param->sANCQI, mBuf);
4466    /*rgr_c_001.main_9 DEL removed unwanted comments*/
4467    CMCHKPK(oduUnpackUInt16, param->riCfgIdx, mBuf);
4468    CMCHKPK(oduUnpackUInt8, param->riEna, mBuf);
4469    CMCHKPK(oduUnpackUInt8, param->k, mBuf);
4470    CMCHKPK(oduUnpackUInt8, param->cqiRepType, mBuf);
4471    CMCHKPK(oduUnpackUInt16, param->cqiPCfgIdx, mBuf);
4472    CMCHKPK(oduUnpackUInt16, param->cqiPResIdx, mBuf);
4473    return ROK;
4474 }
4475
4476
4477 \f
4478 /***********************************************************
4479 *
4480 *     Func : cmUnpkRgrUeDlPCqiSetup
4481 *
4482 *
4483 *     Desc : Periodic CQI Setup configuration parameters information
4484 *
4485 *
4486 *     Ret  : S16
4487 *
4488 *     Notes:
4489 *
4490 *     File  :
4491 *
4492 **********************************************************/
4493 #ifdef ANSI
4494 S16 cmUnpkRgrUeDlPCqiSetup
4495 (
4496 RgrUeDlPCqiSetup *param,
4497 Buffer *mBuf
4498 )
4499 #else
4500 S16 cmUnpkRgrUeDlPCqiSetup(param, mBuf)
4501 RgrUeDlPCqiSetup *param;
4502 Buffer *mBuf;
4503 #endif
4504 {
4505    uint32_t tmpEnum;
4506
4507
4508    CMCHKUNPK(oduPackUInt16, &param->cqiPResIdx, mBuf);
4509    CMCHKUNPK(oduPackUInt16, &param->cqiPCfgIdx, mBuf);
4510    CMCHKUNPK(oduPackUInt8, &param->cqiRepType, mBuf);
4511    CMCHKUNPK(oduPackUInt8, &param->k, mBuf);
4512    CMCHKUNPK(oduPackUInt8, &param->riEna, mBuf);
4513    /*rgr_c_001.main_9 DEL removed unwanted comments*/
4514    CMCHKUNPK(oduPackUInt16, &param->riCfgIdx, mBuf);
4515    CMCHKUNPK(oduPackUInt8, &param->sANCQI, mBuf);
4516    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4517    param->prdModeEnum = (RgrPrdCqiMode) tmpEnum;
4518    return ROK;
4519 }
4520
4521
4522 \f
4523 /***********************************************************
4524 *
4525 *     Func : cmPkRgrUePrdDlCqiCfg
4526 *
4527 *
4528 *     Desc : Periodic CQI/PMI/RI configuration parameters information
4529 *
4530 *
4531 *     Ret  : S16
4532 *
4533 *     Notes:
4534 *
4535 *     File  :
4536 *
4537 **********************************************************/
4538 #ifdef ANSI
4539 S16 cmPkRgrUePrdDlCqiCfg
4540 (
4541 RgrUePrdDlCqiCfg *param,
4542 Buffer *mBuf
4543 )
4544 #else
4545 S16 cmPkRgrUePrdDlCqiCfg(param, mBuf)
4546 RgrUePrdDlCqiCfg *param;
4547 Buffer *mBuf;
4548 #endif
4549 {
4550
4551
4552    CMCHKPK(cmPkRgrUeDlPCqiSetup, &param->cqiSetup, mBuf);
4553    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
4554    return ROK;
4555 }
4556
4557
4558 \f
4559 /***********************************************************
4560 *
4561 *     Func : cmUnpkRgrUePrdDlCqiCfg
4562 *
4563 *
4564 *     Desc : Periodic CQI/PMI/RI configuration parameters information
4565 *
4566 *
4567 *     Ret  : S16
4568 *
4569 *     Notes:
4570 *
4571 *     File  :
4572 *
4573 **********************************************************/
4574 #ifdef ANSI
4575 S16 cmUnpkRgrUePrdDlCqiCfg
4576 (
4577 RgrUePrdDlCqiCfg *param,
4578 Buffer *mBuf
4579 )
4580 #else
4581 S16 cmUnpkRgrUePrdDlCqiCfg(param, mBuf)
4582 RgrUePrdDlCqiCfg *param;
4583 Buffer *mBuf;
4584 #endif
4585 {
4586
4587
4588    CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
4589    CMCHKUNPK(cmUnpkRgrUeDlPCqiSetup, &param->cqiSetup, mBuf);
4590    return ROK;
4591 }
4592
4593
4594 \f
4595 /***********************************************************
4596 *
4597 *     Func : cmPkRgrUeUlSrsSetupCfg
4598 *
4599 *
4600 *     Desc : SRS configuration setup parameters information.
4601    Reference 36.313 SoundingRS-UL-Config
4602 *
4603 *
4604 *     Ret  : S16
4605 *
4606 *     Notes:
4607 *
4608 *     File  :
4609 *
4610 **********************************************************/
4611 #ifdef ANSI
4612 S16 cmPkRgrUeUlSrsSetupCfg
4613 (
4614 RgrUeUlSrsSetupCfg *param,
4615 Buffer *mBuf
4616 )
4617 #else
4618 S16 cmPkRgrUeUlSrsSetupCfg(param, mBuf)
4619 RgrUeUlSrsSetupCfg *param;
4620 Buffer *mBuf;
4621 #endif
4622 {
4623
4624
4625    CMCHKPK(oduUnpackUInt8, param->fDomPosi, mBuf);
4626    CMCHKPK(oduUnpackUInt8, param->txComb, mBuf);
4627    CMCHKPK(oduUnpackUInt8, param->sANSrs, mBuf);
4628    CMCHKPK(oduUnpackUInt8, param->duration, mBuf);
4629    CMCHKPK(oduUnpackUInt32, param->cycShift, mBuf);
4630    CMCHKPK(oduUnpackUInt32, param->srsHopBw, mBuf);
4631    CMCHKPK(oduUnpackUInt32, param->srsBw, mBuf);
4632    /*rgr_c_001.main_9 DEL removed unwanted comments*/
4633    CMCHKPK(oduUnpackUInt16, param->srsCfgIdx, mBuf);
4634    return ROK;
4635 }
4636
4637
4638 \f
4639 /***********************************************************
4640 *
4641 *     Func : cmUnpkRgrUeUlSrsSetupCfg
4642 *
4643 *
4644 *     Desc : SRS configuration setup parameters information.
4645    Reference 36.313 SoundingRS-UL-Config
4646 *
4647 *
4648 *     Ret  : S16
4649 *
4650 *     Notes:
4651 *
4652 *     File  :
4653 *
4654 **********************************************************/
4655 #ifdef ANSI
4656 S16 cmUnpkRgrUeUlSrsSetupCfg
4657 (
4658 RgrUeUlSrsSetupCfg *param,
4659 Buffer *mBuf
4660 )
4661 #else
4662 S16 cmUnpkRgrUeUlSrsSetupCfg(param, mBuf)
4663 RgrUeUlSrsSetupCfg *param;
4664 Buffer *mBuf;
4665 #endif
4666 {
4667    uint32_t tmpEnum;
4668
4669
4670    /*rgr_c_001.main_9 DEL removed unwanted comments*/
4671    CMCHKUNPK(oduPackUInt16, &param->srsCfgIdx, mBuf);
4672    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4673    param->srsBw = (RgrUlSrsBwInfo) tmpEnum;
4674    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4675    param->srsHopBw = (RgrUlSrsHoBwInfo) tmpEnum;
4676    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
4677    param->cycShift = (RgrUlSrsCycShiftInfo) tmpEnum;
4678    CMCHKUNPK(oduPackUInt8, &param->duration, mBuf);
4679    CMCHKUNPK(oduPackUInt8, &param->sANSrs, mBuf);
4680    CMCHKUNPK(oduPackUInt8, &param->txComb, mBuf);
4681    CMCHKUNPK(oduPackUInt8, &param->fDomPosi, mBuf);
4682    return ROK;
4683 }
4684
4685
4686 \f
4687 /***********************************************************
4688 *
4689 *     Func : cmPkRgrUeSrSetupCfg
4690 *
4691 *
4692 *     Desc : SR Setup configuration parameters information
4693 *
4694 *
4695 *     Ret  : S16
4696 *
4697 *     Notes:
4698 *
4699 *     File  :
4700 *
4701 **********************************************************/
4702 #ifdef ANSI
4703 S16 cmPkRgrUeSrSetupCfg
4704 (
4705 RgrUeSrSetupCfg *param,
4706 Buffer *mBuf
4707 )
4708 #else
4709 S16 cmPkRgrUeSrSetupCfg(param, mBuf)
4710 RgrUeSrSetupCfg *param;
4711 Buffer *mBuf;
4712 #endif
4713 {
4714
4715
4716    /* ccpu00131601:DEL - dTMax Packing removed since this param will not
4717     * be required by Scheduler*/
4718    CMCHKPK(oduUnpackUInt8, param->srCfgIdx, mBuf);
4719    CMCHKPK(oduUnpackUInt16, param->srResIdx, mBuf);
4720    return ROK;
4721 }
4722
4723
4724 \f
4725 /***********************************************************
4726 *
4727 *     Func : cmUnpkRgrUeSrSetupCfg
4728 *
4729 *
4730 *     Desc : SR Setup configuration parameters information
4731 *
4732 *
4733 *     Ret  : S16
4734 *
4735 *     Notes:
4736 *
4737 *     File  :
4738 *
4739 **********************************************************/
4740 #ifdef ANSI
4741 S16 cmUnpkRgrUeSrSetupCfg
4742 (
4743 RgrUeSrSetupCfg *param,
4744 Buffer *mBuf
4745 )
4746 #else
4747 S16 cmUnpkRgrUeSrSetupCfg(param, mBuf)
4748 RgrUeSrSetupCfg *param;
4749 Buffer *mBuf;
4750 #endif
4751 {
4752
4753    CMCHKUNPK(oduPackUInt16, &param->srResIdx, mBuf);
4754    CMCHKUNPK(oduPackUInt8, &param->srCfgIdx, mBuf);
4755    /* ccpu00131601:DEL - dTMax UnPacking removed since this param will not
4756     * be required by Scheduler*/
4757    return ROK;
4758 }
4759
4760
4761 \f
4762 /***********************************************************
4763 *
4764 *     Func : cmPkRgrUeSrCfg
4765 *
4766 *
4767 *     Desc : SR configuration parameters information
4768 *
4769 *
4770 *     Ret  : S16
4771 *
4772 *     Notes:
4773 *
4774 *     File  :
4775 *
4776 **********************************************************/
4777 #ifdef ANSI
4778 S16 cmPkRgrUeSrCfg
4779 (
4780 RgrUeSrCfg *param,
4781 Buffer *mBuf
4782 )
4783 #else
4784 S16 cmPkRgrUeSrCfg(param, mBuf)
4785 RgrUeSrCfg *param;
4786 Buffer *mBuf;
4787 #endif
4788 {
4789
4790
4791    CMCHKPK(cmPkRgrUeSrSetupCfg, &param->srSetup, mBuf);
4792    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
4793    return ROK;
4794 }
4795
4796
4797 \f
4798 /***********************************************************
4799 *
4800 *     Func : cmUnpkRgrUeSrCfg
4801 *
4802 *
4803 *     Desc : SR configuration parameters information
4804 *
4805 *
4806 *     Ret  : S16
4807 *
4808 *     Notes:
4809 *
4810 *     File  :
4811 *
4812 **********************************************************/
4813 #ifdef ANSI
4814 S16 cmUnpkRgrUeSrCfg
4815 (
4816 RgrUeSrCfg *param,
4817 Buffer *mBuf
4818 )
4819 #else
4820 S16 cmUnpkRgrUeSrCfg(param, mBuf)
4821 RgrUeSrCfg *param;
4822 Buffer *mBuf;
4823 #endif
4824 {
4825
4826
4827    CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
4828    CMCHKUNPK(cmUnpkRgrUeSrSetupCfg, &param->srSetup, mBuf);
4829    return ROK;
4830 }
4831
4832
4833 \f
4834 /***********************************************************
4835 *
4836 *     Func : cmPkRgrUeUlSrsCfg
4837 *
4838 *
4839 *     Desc : SRS configuration parameters information.
4840   Reference 36.313 SoundingRS-UL-Config
4841 *
4842 *
4843 *     Ret  : S16
4844 *
4845 *     Notes:
4846 *
4847 *     File  :
4848 *
4849 **********************************************************/
4850 #ifdef ANSI
4851 S16 cmPkRgrUeUlSrsCfg
4852 (
4853 RgrUeUlSrsCfg *param,
4854 Buffer *mBuf
4855 )
4856 #else
4857 S16 cmPkRgrUeUlSrsCfg(param, mBuf)
4858 RgrUeUlSrsCfg *param;
4859 Buffer *mBuf;
4860 #endif
4861 {
4862
4863
4864    /*rgr_c_001.main_9 DEL removed unwanted comments*/
4865    CMCHKPK(cmPkRgrUeUlSrsSetupCfg, &param->srsSetup, mBuf);
4866    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
4867    return ROK;
4868 }
4869
4870
4871 \f
4872 /***********************************************************
4873 *
4874 *     Func : cmUnpkRgrUeUlSrsCfg
4875 *
4876 *
4877 *     Desc : SRS configuration parameters information.
4878   Reference 36.313 SoundingRS-UL-Config
4879 *
4880 *
4881 *     Ret  : S16
4882 *
4883 *     Notes:
4884 *
4885 *     File  :
4886 *
4887 **********************************************************/
4888 #ifdef ANSI
4889 S16 cmUnpkRgrUeUlSrsCfg
4890 (
4891 RgrUeUlSrsCfg *param,
4892 Buffer *mBuf
4893 )
4894 #else
4895 S16 cmUnpkRgrUeUlSrsCfg(param, mBuf)
4896 RgrUeUlSrsCfg *param;
4897 Buffer *mBuf;
4898 #endif
4899 {
4900
4901
4902    CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
4903    /*rgr_c_001.main_9 DEL removed unwanted comments*/
4904    CMCHKUNPK(cmUnpkRgrUeUlSrsSetupCfg, &param->srsSetup, mBuf);
4905    return ROK;
4906 }
4907
4908
4909 #endif /*TFU_UPGRADE */
4910
4911 \f
4912 /***********************************************************
4913 *
4914 *     Func : cmPkRgrUeDlCqiCfg
4915 *
4916 *
4917 *     Desc : Downlink CQI reporting related configuration per UE
4918 *
4919 *
4920 *     Ret  : S16
4921 *
4922 *     Notes:
4923 *
4924 *     File  :
4925 *
4926 **********************************************************/
4927 #ifdef ANSI
4928 S16 cmPkRgrUeDlCqiCfg
4929 (
4930 RgrUeDlCqiCfg *param,
4931 Buffer *mBuf
4932 )
4933 #else
4934 S16 cmPkRgrUeDlCqiCfg(param, mBuf)
4935 RgrUeDlCqiCfg *param;
4936 Buffer *mBuf;
4937 #endif
4938 {
4939
4940
4941
4942 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
4943 #ifdef TFU_UPGRADE
4944    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
4945 #endif
4946
4947 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
4948 #ifndef TFU_UPGRADE
4949    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
4950 #endif
4951    CMCHKPK(cmPkRgrUeAprdDlCqiCfg, &param->aprdCqiCfg, mBuf);
4952    return ROK;
4953 }
4954
4955
4956 \f
4957 /***********************************************************
4958 *
4959 *     Func : cmUnpkRgrUeDlCqiCfg
4960 *
4961 *
4962 *     Desc : Downlink CQI reporting related configuration per UE
4963 *
4964 *
4965 *     Ret  : S16
4966 *
4967 *     Notes:
4968 *
4969 *     File  :
4970 *
4971 **********************************************************/
4972 #ifdef ANSI
4973 S16 cmUnpkRgrUeDlCqiCfg
4974 (
4975 RgrUeDlCqiCfg *param,
4976 Buffer *mBuf
4977 )
4978 #else
4979 S16 cmUnpkRgrUeDlCqiCfg(param, mBuf)
4980 RgrUeDlCqiCfg *param;
4981 Buffer *mBuf;
4982 #endif
4983 {
4984
4985
4986    CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, &param->aprdCqiCfg, mBuf);
4987    CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, &param->prdCqiCfg, mBuf);
4988    return ROK;
4989 }
4990
4991
4992 \f
4993 /***********************************************************
4994 *
4995 *     Func : cmPkRgrUeMeasGapCfg
4996 *
4997 *
4998 *     Desc : Measurement gap configuration for UE
4999 *
5000 *
5001 *     Ret  : S16
5002 *
5003 *     Notes:
5004 *
5005 *     File  :
5006 *
5007 **********************************************************/
5008 #ifdef ANSI
5009 S16 cmPkRgrUeMeasGapCfg
5010 (
5011 RgrUeMeasGapCfg *param,
5012 Buffer *mBuf
5013 )
5014 #else
5015 S16 cmPkRgrUeMeasGapCfg(param, mBuf)
5016 RgrUeMeasGapCfg *param;
5017 Buffer *mBuf;
5018 #endif
5019 {
5020
5021
5022    CMCHKPK(oduUnpackUInt8, param->gapOffst, mBuf);
5023    CMCHKPK(oduUnpackUInt8, param->gapPrd, mBuf);
5024    CMCHKPK(oduUnpackUInt8, param->isMesGapEnabled, mBuf);
5025    return ROK;
5026 }
5027
5028
5029 \f
5030 /***********************************************************
5031 *
5032 *     Func : cmUnpkRgrUeMeasGapCfg
5033 *
5034 *
5035 *     Desc : Measurement gap configuration for UE
5036 *
5037 *
5038 *     Ret  : S16
5039 *
5040 *     Notes:
5041 *
5042 *     File  :
5043 *
5044 **********************************************************/
5045 #ifdef ANSI
5046 S16 cmUnpkRgrUeMeasGapCfg
5047 (
5048 RgrUeMeasGapCfg *param,
5049 Buffer *mBuf
5050 )
5051 #else
5052 S16 cmUnpkRgrUeMeasGapCfg(param, mBuf)
5053 RgrUeMeasGapCfg *param;
5054 Buffer *mBuf;
5055 #endif
5056 {
5057
5058
5059    CMCHKUNPK(oduPackUInt8, &param->isMesGapEnabled, mBuf);
5060    CMCHKUNPK(oduPackUInt8, &param->gapPrd, mBuf);
5061    CMCHKUNPK(oduPackUInt8, &param->gapOffst, mBuf);
5062    return ROK;
5063 }
5064
5065 /*rgr_c_001.main_9 ADD DRX functionality under flag*/
5066 \f
5067 /***********************************************************
5068 *
5069 *     Func : cmPkRgrDrxLongCycleOffst
5070 *
5071 *
5072 *     Desc : DRX Long Cycle Offset
5073 *
5074 *
5075 *     Ret  : S16
5076 *
5077 *     Notes:
5078 *
5079 *     File  :
5080 *
5081 **********************************************************/
5082 #ifdef ANSI
5083 S16 cmPkRgrDrxLongCycleOffst
5084 (
5085 RgrDrxLongCycleOffst *param,
5086 Buffer *mBuf
5087 )
5088 #else
5089 S16 cmPkRgrDrxLongCycleOffst(param, mBuf)
5090 RgrDrxLongCycleOffst *param;
5091 Buffer *mBuf;
5092 #endif
5093 {
5094
5095
5096    CMCHKPK(oduUnpackUInt16, param->drxStartOffst, mBuf);
5097    CMCHKPK(oduUnpackUInt16, param->longDrxCycle, mBuf);
5098    return ROK;
5099 }
5100
5101
5102 \f
5103 /***********************************************************
5104 *
5105 *     Func : cmUnpkRgrDrxLongCycleOffst
5106 *
5107 *
5108 *     Desc : DRX Long Cycle Offset
5109 *
5110 *
5111 *     Ret  : S16
5112 *
5113 *     Notes:
5114 *
5115 *     File  :
5116 *
5117 **********************************************************/
5118 #ifdef ANSI
5119 S16 cmUnpkRgrDrxLongCycleOffst
5120 (
5121 RgrDrxLongCycleOffst *param,
5122 Buffer *mBuf
5123 )
5124 #else
5125 S16 cmUnpkRgrDrxLongCycleOffst(param, mBuf)
5126 RgrDrxLongCycleOffst *param;
5127 Buffer *mBuf;
5128 #endif
5129 {
5130
5131
5132    CMCHKUNPK(oduPackUInt16, &param->longDrxCycle, mBuf);
5133    CMCHKUNPK(oduPackUInt16, &param->drxStartOffst, mBuf);
5134    return ROK;
5135 }
5136
5137
5138 \f
5139 /***********************************************************
5140 *
5141 *     Func : cmPkRgrDrxShortDrx
5142 *
5143 *
5144 *     Desc : DRX Short Cycle Offset
5145 *
5146 *
5147 *     Ret  : S16
5148 *
5149 *     Notes:
5150 *
5151 *     File  :
5152 *
5153 **********************************************************/
5154 #ifdef ANSI
5155 S16 cmPkRgrDrxShortDrx
5156 (
5157 RgrDrxShortDrx *param,
5158 Buffer *mBuf
5159 )
5160 #else
5161 S16 cmPkRgrDrxShortDrx(param, mBuf)
5162 RgrDrxShortDrx *param;
5163 Buffer *mBuf;
5164 #endif
5165 {
5166
5167
5168    CMCHKPK(oduUnpackUInt8, param->drxShortCycleTmr, mBuf);
5169    CMCHKPK(oduUnpackUInt16, param->shortDrxCycle, mBuf);
5170    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
5171    return ROK;
5172 }
5173
5174
5175 \f
5176 /***********************************************************
5177 *
5178 *     Func : cmUnpkRgrDrxShortDrx
5179 *
5180 *
5181 *     Desc : DRX Short Cycle Offset
5182 *
5183 *
5184 *     Ret  : S16
5185 *
5186 *     Notes:
5187 *
5188 *     File  :
5189 *
5190 **********************************************************/
5191 #ifdef ANSI
5192 S16 cmUnpkRgrDrxShortDrx
5193 (
5194 RgrDrxShortDrx *param,
5195 Buffer *mBuf
5196 )
5197 #else
5198 S16 cmUnpkRgrDrxShortDrx(param, mBuf)
5199 RgrDrxShortDrx *param;
5200 Buffer *mBuf;
5201 #endif
5202 {
5203
5204
5205    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
5206    CMCHKUNPK(oduPackUInt16, &param->shortDrxCycle, mBuf);
5207    CMCHKUNPK(oduPackUInt8, &param->drxShortCycleTmr, mBuf);
5208    return ROK;
5209 }
5210 \f
5211 /***********************************************************
5212 *
5213 *     Func : cmPkRgrUeDrxCfg
5214 *
5215 *
5216 *     Desc : DRX configuration for UE
5217 *
5218 *
5219 *     Ret  : S16
5220 *
5221 *     Notes:
5222 *
5223 *     File  :
5224 *
5225 **********************************************************/
5226 #ifdef ANSI
5227 S16 cmPkRgrUeDrxCfg
5228 (
5229 RgrUeDrxCfg *param,
5230 Buffer *mBuf
5231 )
5232 #else
5233 S16 cmPkRgrUeDrxCfg(param, mBuf)
5234 RgrUeDrxCfg *param;
5235 Buffer *mBuf;
5236 #endif
5237 {
5238
5239
5240    CMCHKPK(cmPkRgrDrxShortDrx, &param->drxShortDrx, mBuf);
5241    CMCHKPK(cmPkRgrDrxLongCycleOffst, &param->drxLongCycleOffst, mBuf);
5242    CMCHKPK(oduUnpackUInt16, param->drxRetxTmr, mBuf);
5243 #ifdef EMTC_ENABLE
5244    CMCHKPK(oduUnpackUInt8,  param->drxRetxTmrR13Pres, mBuf);
5245    CMCHKPK(oduUnpackUInt8,  param->drxOnDurTmrR13Pres, mBuf);
5246    CMCHKPK(oduUnpackUInt16, param->emtcDrxUlRetxTmr, mBuf);
5247    CMCHKPK(oduUnpackUInt8,  param->isEmtcUe, mBuf);
5248 #endif
5249    CMCHKPK(oduUnpackUInt16, param->drxInactvTmr, mBuf);
5250    CMCHKPK(oduUnpackUInt16, param->drxOnDurTmr, mBuf);
5251 /*rgr_c_001.main_9 ADD added changes for R9*/
5252 #ifdef LTEMAC_R9
5253    CMCHKPK(cmPkTknS32, &param->cqiMask, mBuf);
5254 #endif
5255    return ROK;
5256 }
5257
5258
5259 \f
5260 /***********************************************************
5261 *
5262 *     Func : cmUnpkRgrUeDrxCfg
5263 *
5264 *
5265 *     Desc : DRX configuration for UE
5266 *
5267 *
5268 *     Ret  : S16
5269 *
5270 *     Notes:
5271 *
5272 *     File  :
5273 *
5274 **********************************************************/
5275 #ifdef ANSI
5276 S16 cmUnpkRgrUeDrxCfg
5277 (
5278 RgrUeDrxCfg *param,
5279 Buffer *mBuf
5280 )
5281 #else
5282 S16 cmUnpkRgrUeDrxCfg(param, mBuf)
5283 RgrUeDrxCfg *param;
5284 Buffer *mBuf;
5285 #endif
5286 {
5287
5288
5289 /*rgr_c_001.main_9 ADD added changes for R9*/
5290 #ifdef LTEMAC_R9
5291    CMCHKUNPK(cmUnpkTknS32, &param->cqiMask, mBuf);
5292 #endif
5293    CMCHKUNPK(oduPackUInt16, &param->drxOnDurTmr, mBuf);
5294    CMCHKUNPK(oduPackUInt16, &param->drxInactvTmr, mBuf);
5295 #ifdef EMTC_ENABLE
5296    CMCHKUNPK(oduPackUInt8, &param->isEmtcUe, mBuf);
5297    CMCHKUNPK(oduPackUInt16,&param->emtcDrxUlRetxTmr, mBuf);
5298    CMCHKUNPK(oduPackUInt8, &param->drxOnDurTmrR13Pres, mBuf);
5299    CMCHKUNPK(oduPackUInt8, &param->drxRetxTmrR13Pres, mBuf);
5300 #endif
5301    CMCHKUNPK(oduPackUInt16, &param->drxRetxTmr, mBuf);
5302    CMCHKUNPK(cmUnpkRgrDrxLongCycleOffst, &param->drxLongCycleOffst, mBuf);
5303    CMCHKUNPK(cmUnpkRgrDrxShortDrx, &param->drxShortDrx, mBuf);
5304    return ROK;
5305 }
5306
5307 /*rgr_c_001.main_9 ADD added DRX changes under DRX*/
5308 \f
5309 /***********************************************************
5310 *
5311 *     Func : cmPkRgrUeCapCfg
5312 *
5313 *
5314 *     Desc : RgrUeCapCfg
5315 *
5316 *
5317 *     Ret  : S16
5318 *
5319 *     Notes:
5320 *
5321 *     File  :
5322 *
5323 **********************************************************/
5324 #ifdef ANSI
5325 S16 cmPkRgrUeCapCfg
5326 (
5327 RgrUeCapCfg *param,
5328 Buffer *mBuf
5329 )
5330 #else
5331 S16 cmPkRgrUeCapCfg(param, mBuf)
5332 RgrUeCapCfg *param;
5333 Buffer *mBuf;
5334 #endif
5335 {
5336
5337
5338    CMCHKPK(oduUnpackUInt8, param->txAntSel, mBuf);
5339    CMCHKPK(oduUnpackUInt8, param->simCqiAckNack, mBuf);
5340    CMCHKPK(oduUnpackUInt8, param->resAloocType1, mBuf);
5341    CMCHKPK(oduUnpackUInt8, param->intraSfFeqHop, mBuf);
5342    CMCHKPK(oduUnpackUInt8, param->pwrClass, mBuf);
5343    return ROK;
5344 }
5345
5346
5347 \f
5348 /***********************************************************
5349 *
5350 *     Func : cmUnpkRgrUeCapCfg
5351 *
5352 *
5353 *     Desc : RgrUeCapCfg
5354 *
5355 *
5356 *     Ret  : S16
5357 *
5358 *     Notes:
5359 *
5360 *     File  :
5361 *
5362 **********************************************************/
5363 #ifdef ANSI
5364 S16 cmUnpkRgrUeCapCfg
5365 (
5366 RgrUeCapCfg *param,
5367 Buffer *mBuf
5368 )
5369 #else
5370 S16 cmUnpkRgrUeCapCfg(param, mBuf)
5371 RgrUeCapCfg *param;
5372 Buffer *mBuf;
5373 #endif
5374 {
5375
5376
5377    CMCHKUNPK(oduPackUInt8, &param->pwrClass, mBuf);
5378    CMCHKUNPK(oduPackUInt8, &param->intraSfFeqHop, mBuf);
5379    CMCHKUNPK(oduPackUInt8, &param->resAloocType1, mBuf);
5380    CMCHKUNPK(oduPackUInt8, &param->simCqiAckNack, mBuf);
5381    CMCHKUNPK(oduPackUInt8, &param->txAntSel, mBuf);
5382
5383    return ROK;
5384 }
5385
5386 \f
5387 /***********************************************************
5388 *
5389 *     Func : cmPkRgrUeAckNackRepCfg
5390 *
5391 *
5392 *     Desc : rgrUeAckNackRepCfg
5393 *
5394 *
5395 *     Ret  : S16
5396 *
5397 *     Notes:
5398 *
5399 *     File  :
5400 *
5401 **********************************************************/
5402 #ifdef ANSI
5403 S16 cmPkRgrUeAckNackRepCfg
5404 (
5405 RgrUeAckNackRepCfg *param,
5406 Buffer *mBuf
5407 )
5408 #else
5409 S16 cmPkRgrUeAckNackRepCfg(param, mBuf)
5410 RgrUeAckNackRepCfg *param;
5411 Buffer *mBuf;
5412 #endif
5413 {
5414
5415
5416    CMCHKPK(oduUnpackUInt32, param->ackNackRepFactor, mBuf);
5417    CMCHKPK(oduUnpackUInt16, param->pucchAckNackRep, mBuf);
5418    CMCHKPK(oduUnpackUInt8, param->isAckNackEnabled, mBuf);
5419    return ROK;
5420 }
5421
5422
5423 \f
5424 /***********************************************************
5425 *
5426 *     Func : cmUnpkRgrUeAckNackRepCfg
5427 *
5428 *
5429 *     Desc : rgrUeAckNackRepCfg
5430 *
5431 *
5432 *     Ret  : S16
5433 *
5434 *     Notes:
5435 *
5436 *     File  :
5437 *
5438 **********************************************************/
5439 #ifdef ANSI
5440 S16 cmUnpkRgrUeAckNackRepCfg
5441 (
5442 RgrUeAckNackRepCfg *param,
5443 Buffer *mBuf
5444 )
5445 #else
5446 S16 cmUnpkRgrUeAckNackRepCfg(param, mBuf)
5447 RgrUeAckNackRepCfg *param;
5448 Buffer *mBuf;
5449 #endif
5450 {
5451    uint32_t tmpEnum;
5452
5453
5454    CMCHKUNPK(oduPackUInt8, &param->isAckNackEnabled, mBuf);
5455    CMCHKUNPK(oduPackUInt16, &param->pucchAckNackRep, mBuf);
5456    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5457    param->ackNackRepFactor = (RgrAckNackRepFactor) tmpEnum;
5458    return ROK;
5459 }
5460
5461
5462 \f
5463 /***********************************************************
5464 *
5465 *     Func : cmPkRgrUeTxModeCfg
5466 *
5467 *
5468 *     Desc : Transmission mode configuration per UE
5469 *
5470 *
5471 *     Ret  : S16
5472 *
5473 *     Notes:
5474 *
5475 *     File  :
5476 *
5477 **********************************************************/
5478 #ifdef ANSI
5479 S16 cmPkRgrUeTxModeCfg
5480 (
5481 RgrUeTxModeCfg *param,
5482 Buffer *mBuf
5483 )
5484 #else
5485 S16 cmPkRgrUeTxModeCfg(param, mBuf)
5486 RgrUeTxModeCfg *param;
5487 Buffer *mBuf;
5488 #endif
5489 {
5490
5491
5492    CMCHKPK(oduUnpackUInt32, param->txModeEnum, mBuf);
5493    CMCHKPK(oduUnpackUInt32, param->tmTrnstnState, mBuf);
5494    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
5495
5496    return ROK;
5497 }
5498
5499
5500 \f
5501 /***********************************************************
5502 *
5503 *     Func : cmUnpkRgrUeTxModeCfg
5504 *
5505 *
5506 *     Desc : Transmission mode configuration per UE
5507 *
5508 *
5509 *     Ret  : S16
5510 *
5511 *     Notes:
5512 *
5513 *     File  :
5514 *
5515 **********************************************************/
5516 #ifdef ANSI
5517 S16 cmUnpkRgrUeTxModeCfg
5518 (
5519 RgrUeTxModeCfg *param,
5520 Buffer *mBuf
5521 )
5522 #else
5523 S16 cmUnpkRgrUeTxModeCfg(param, mBuf)
5524 RgrUeTxModeCfg *param;
5525 Buffer *mBuf;
5526 #endif
5527 {
5528    uint32_t tmpEnum;
5529
5530
5531    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
5532    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5533    param->tmTrnstnState = (RgrTxModeTrnstn) tmpEnum;
5534
5535    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5536    param->txModeEnum = (RgrTxMode) tmpEnum;
5537    return ROK;
5538 }
5539
5540
5541 \f
5542 /***********************************************************
5543 *
5544 *     Func : cmPkRgrUeUlHqCfg
5545 *
5546 *
5547 *     Desc : Uplink HARQ configuration per UE
5548 *
5549 *
5550 *     Ret  : S16
5551 *
5552 *     Notes:
5553 *
5554 *     File  :
5555 *
5556 **********************************************************/
5557 #ifdef ANSI
5558 S16 cmPkRgrUeUlHqCfg
5559 (
5560 RgrUeUlHqCfg *param,
5561 Buffer *mBuf
5562 )
5563 #else
5564 S16 cmPkRgrUeUlHqCfg(param, mBuf)
5565 RgrUeUlHqCfg *param;
5566 Buffer *mBuf;
5567 #endif
5568 {
5569
5570
5571    CMCHKPK(oduUnpackUInt8, param->deltaHqOffst, mBuf);
5572    CMCHKPK(oduUnpackUInt8, param->maxUlHqTx, mBuf);
5573    return ROK;
5574 }
5575
5576
5577 \f
5578 /***********************************************************
5579 *
5580 *     Func : cmUnpkRgrUeUlHqCfg
5581 *
5582 *
5583 *     Desc : Uplink HARQ configuration per UE
5584 *
5585 *
5586 *     Ret  : S16
5587 *
5588 *     Notes:
5589 *
5590 *     File  :
5591 *
5592 **********************************************************/
5593 #ifdef ANSI
5594 S16 cmUnpkRgrUeUlHqCfg
5595 (
5596 RgrUeUlHqCfg *param,
5597 Buffer *mBuf
5598 )
5599 #else
5600 S16 cmUnpkRgrUeUlHqCfg(param, mBuf)
5601 RgrUeUlHqCfg *param;
5602 Buffer *mBuf;
5603 #endif
5604 {
5605
5606
5607    CMCHKUNPK(oduPackUInt8, &param->maxUlHqTx, mBuf);
5608    CMCHKUNPK(oduPackUInt8, &param->deltaHqOffst, mBuf);
5609    return ROK;
5610 }
5611
5612
5613 \f
5614 /***********************************************************
5615 *
5616 *     Func : cmPkRgrUeGrpPwrCfg
5617 *
5618 *
5619 *     Desc : Group power configuration per UE for PUCCH and PUSCH group power control
5620 *
5621 *
5622 *     Ret  : S16
5623 *
5624 *     Notes:
5625 *
5626 *     File  :
5627 *
5628 **********************************************************/
5629 #ifdef ANSI
5630 S16 cmPkRgrUeGrpPwrCfg
5631 (
5632 RgrUeGrpPwrCfg *param,
5633 Buffer *mBuf
5634 )
5635 #else
5636 S16 cmPkRgrUeGrpPwrCfg(param, mBuf)
5637 RgrUeGrpPwrCfg *param;
5638 Buffer *mBuf;
5639 #endif
5640 {
5641
5642
5643    CMCHKPK(oduUnpackUInt8, param->idx, mBuf);
5644    CMCHKPK(cmPkLteRnti, param->tpcRnti, mBuf);
5645    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
5646    return ROK;
5647 }
5648
5649
5650 \f
5651 /***********************************************************
5652 *
5653 *     Func : cmUnpkRgrUeGrpPwrCfg
5654 *
5655 *
5656 *     Desc : Group power configuration per UE for PUCCH and PUSCH group power control
5657 *
5658 *
5659 *     Ret  : S16
5660 *
5661 *     Notes:
5662 *
5663 *     File  :
5664 *
5665 **********************************************************/
5666 #ifdef ANSI
5667 S16 cmUnpkRgrUeGrpPwrCfg
5668 (
5669 RgrUeGrpPwrCfg *param,
5670 Buffer *mBuf
5671 )
5672 #else
5673 S16 cmUnpkRgrUeGrpPwrCfg(param, mBuf)
5674 RgrUeGrpPwrCfg *param;
5675 Buffer *mBuf;
5676 #endif
5677 {
5678
5679
5680    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
5681    CMCHKUNPK(cmUnpkLteRnti, &param->tpcRnti, mBuf);
5682    CMCHKUNPK(oduPackUInt8, &param->idx, mBuf);
5683    return ROK;
5684 }
5685
5686 /*rgr_c_001.main_7 - Added support for SPS*/
5687
5688 \f
5689 /***********************************************************
5690 *
5691 *     Func : cmPkRgrUeSpsDlCfg
5692 *
5693 *
5694 *     Desc : DL SPS configuration parameters per UE
5695 *
5696 *
5697 *     Ret  : S16
5698 *
5699 *     Notes:
5700 *
5701 *     File  :
5702 *
5703 **********************************************************/
5704 #ifdef ANSI
5705 S16 cmPkRgrUeSpsDlCfg
5706 (
5707 RgrUeSpsDlCfg *param,
5708 Buffer *mBuf
5709 )
5710 #else
5711 S16 cmPkRgrUeSpsDlCfg(param, mBuf)
5712 RgrUeSpsDlCfg *param;
5713 Buffer *mBuf;
5714 #endif
5715 {
5716
5717    S32 i;
5718    CMCHKPK(oduUnpackUInt16, param->explicitRelCnt, mBuf);
5719    CMCHKPK(oduUnpackUInt32, param->dlSpsPrdctyEnum, mBuf);
5720    for (i=param->numPucchVal-1; i >= 0; i--) {
5721       CMCHKPK(oduUnpackUInt32, param->n1PucchVal[i], mBuf);
5722    }
5723    CMCHKPK(oduUnpackUInt8, param->numPucchVal, mBuf);
5724    CMCHKPK(oduUnpackUInt8, param->numSpsHqProc, mBuf);
5725    CMCHKPK(oduUnpackUInt8, param->isDlSpsEnabled, mBuf);
5726    return ROK;
5727 }
5728
5729
5730 \f
5731 /***********************************************************
5732 *
5733 *     Func : cmUnpkRgrUeSpsDlCfg
5734 *
5735 *
5736 *     Desc : DL SPS configuration parameters per UE
5737 *
5738 *
5739 *     Ret  : S16
5740 *
5741 *     Notes:
5742 *
5743 *     File  :
5744 *
5745 **********************************************************/
5746 #ifdef ANSI
5747 S16 cmUnpkRgrUeSpsDlCfg
5748 (
5749 RgrUeSpsDlCfg *param,
5750 Buffer *mBuf
5751 )
5752 #else
5753 S16 cmUnpkRgrUeSpsDlCfg(param, mBuf)
5754 RgrUeSpsDlCfg *param;
5755 Buffer *mBuf;
5756 #endif
5757 {
5758    uint32_t tmpEnum;
5759
5760    S32 i;
5761
5762    CMCHKUNPK(oduPackUInt8, &param->isDlSpsEnabled, mBuf);
5763    CMCHKUNPK(oduPackUInt8, &param->numSpsHqProc, mBuf);
5764    CMCHKUNPK(oduPackUInt8, &param->numPucchVal, mBuf);
5765    for (i=0; i<param->numPucchVal; i++) {
5766       CMCHKUNPK(oduPackUInt32, &param->n1PucchVal[i], mBuf);
5767    }
5768    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5769    param->dlSpsPrdctyEnum = tmpEnum;
5770    CMCHKUNPK(oduPackUInt16, &param->explicitRelCnt, mBuf);
5771    return ROK;
5772 }
5773
5774
5775 \f
5776 /***********************************************************
5777 *
5778 *     Func : cmPkRgrUeSpsUlCfg
5779 *
5780 *
5781 *     Desc : UL SPS configuration parameters per UE
5782 *
5783 *
5784 *     Ret  : S16
5785 *
5786 *     Notes:
5787 *
5788 *     File  :
5789 *
5790 **********************************************************/
5791 #ifdef ANSI
5792 S16 cmPkRgrUeSpsUlCfg
5793 (
5794 RgrUeSpsUlCfg *param,
5795 Buffer *mBuf
5796 )
5797 #else
5798 S16 cmPkRgrUeSpsUlCfg(param, mBuf)
5799 RgrUeSpsUlCfg *param;
5800 Buffer *mBuf;
5801 #endif
5802 {
5803
5804    S32 i;
5805
5806    CMCHKPK(oduUnpackUInt8, param->isLcSRMaskEnab, mBuf);
5807    for (i=param->lcCnt-1; i >= 0; i--) {
5808       /* SPS Changes starts */
5809       CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].isSpsEnabled, mBuf);
5810       CMCHKPK(oduUnpackUInt8, param->spsLcInfo[i].lcId, mBuf);
5811       /* SPS Changes ends */
5812    }
5813    CMCHKPK(oduUnpackUInt8, param->lcCnt, mBuf);
5814    CMCHKPK(oduUnpackUInt32, param->ulSpsPrdctyEnum, mBuf);
5815       CMCHKPK(SPkS8, param->pwrCfg.p0UePuschVal, mBuf);
5816       CMCHKPK(SPkS8, param->pwrCfg.p0NominalPuschVal, mBuf);
5817    CMCHKPK(oduUnpackUInt8, param->pwrCfgPres, mBuf);
5818
5819 #ifdef LTE_TDD
5820    CMCHKPK(oduUnpackUInt8, param->twoIntervalCfg, mBuf);
5821
5822 #endif
5823    CMCHKPK(oduUnpackUInt32, param->implicitRelCnt, mBuf);
5824    CMCHKPK(oduUnpackUInt8, param->isUlSpsEnabled, mBuf);
5825    return ROK;
5826 }
5827
5828
5829 \f
5830 /***********************************************************
5831 *
5832 *     Func : cmUnpkRgrUeSpsUlCfg
5833 *
5834 *
5835 *     Desc : UL SPS configuration parameters per UE
5836 *
5837 *
5838 *     Ret  : S16
5839 *
5840 *     Notes:
5841 *
5842 *     File  :
5843 *
5844 **********************************************************/
5845 #ifdef ANSI
5846 S16 cmUnpkRgrUeSpsUlCfg
5847 (
5848 RgrUeSpsUlCfg *param,
5849 Buffer *mBuf
5850 )
5851 #else
5852 S16 cmUnpkRgrUeSpsUlCfg(param, mBuf)
5853 RgrUeSpsUlCfg *param;
5854 Buffer *mBuf;
5855 #endif
5856 {
5857    uint32_t tmpEnum;
5858
5859    S32 i;
5860
5861    CMCHKUNPK(oduPackUInt8, &param->isUlSpsEnabled, mBuf);
5862    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5863    param->implicitRelCnt = tmpEnum;
5864
5865 #ifdef LTE_TDD
5866    CMCHKUNPK(oduPackUInt8, &param->twoIntervalCfg, mBuf);
5867
5868 #endif
5869    CMCHKUNPK(oduPackUInt8, &param->pwrCfgPres, mBuf);
5870       CMCHKUNPK(SUnpkS8, &param->pwrCfg.p0NominalPuschVal, mBuf);
5871       CMCHKUNPK(SUnpkS8, &param->pwrCfg.p0UePuschVal, mBuf);
5872    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
5873    param->ulSpsPrdctyEnum = tmpEnum;
5874    CMCHKUNPK(oduPackUInt8, &param->lcCnt, mBuf);
5875    for (i=0; i<param->lcCnt; i++) {
5876       CMCHKUNPK(oduPackUInt8, &param->spsLcInfo[i].lcId, mBuf);
5877       CMCHKUNPK(oduPackUInt8, &param->spsLcInfo[i].isSpsEnabled, mBuf);
5878    }
5879    CMCHKUNPK(oduPackUInt8, &param->isLcSRMaskEnab, mBuf);
5880    return ROK;
5881 }
5882
5883
5884 \f
5885 /***********************************************************
5886 *
5887 *     Func : cmPkRgrUeSpsCfg
5888 *
5889 *
5890 *     Desc : SPS configuration parameters per UE
5891 *
5892 *
5893 *     Ret  : S16
5894 *
5895 *     Notes:
5896 *
5897 *     File  :
5898 *
5899 **********************************************************/
5900 #ifdef ANSI
5901 S16 cmPkRgrUeSpsCfg
5902 (
5903 RgrUeSpsCfg *param,
5904 Buffer *mBuf
5905 )
5906 #else
5907 S16 cmPkRgrUeSpsCfg(param, mBuf)
5908 RgrUeSpsCfg *param;
5909 Buffer *mBuf;
5910 #endif
5911 {
5912
5913
5914    CMCHKPK(cmPkRgrUeSpsUlCfg, &param->ulSpsCfg, mBuf);
5915    CMCHKPK(cmPkRgrUeSpsDlCfg, &param->dlSpsCfg, mBuf);
5916    CMCHKPK(cmPkLteRnti, param->spsRnti, mBuf);
5917    return ROK;
5918 }
5919
5920
5921 \f
5922 /***********************************************************
5923 *
5924 *     Func : cmUnpkRgrUeSpsCfg
5925 *
5926 *
5927 *     Desc : SPS configuration parameters per UE
5928 *
5929 *
5930 *     Ret  : S16
5931 *
5932 *     Notes:
5933 *
5934 *     File  :
5935 *
5936 **********************************************************/
5937 #ifdef ANSI
5938 S16 cmUnpkRgrUeSpsCfg
5939 (
5940 RgrUeSpsCfg *param,
5941 Buffer *mBuf
5942 )
5943 #else
5944 S16 cmUnpkRgrUeSpsCfg(param, mBuf)
5945 RgrUeSpsCfg *param;
5946 Buffer *mBuf;
5947 #endif
5948 {
5949
5950
5951    CMCHKUNPK(cmUnpkLteRnti, &param->spsRnti, mBuf);
5952    CMCHKUNPK(cmUnpkRgrUeSpsDlCfg, &param->dlSpsCfg, mBuf);
5953    CMCHKUNPK(cmUnpkRgrUeSpsUlCfg, &param->ulSpsCfg, mBuf);
5954    return ROK;
5955 }
5956
5957
5958 /***********************************************************
5959 *
5960 *     Func : cmPkRgrUeUlPwrCfg
5961 *
5962 *
5963 *     Desc : Uplink power configuration per UE
5964 *
5965 *
5966 *     Ret  : S16
5967 *
5968 *     Notes:
5969 *
5970 *     File  :
5971 *
5972 **********************************************************/
5973 #ifdef ANSI
5974 S16 cmPkRgrUeUlPwrCfg
5975 (
5976 RgrUeUlPwrCfg *param,
5977 Buffer *mBuf
5978 )
5979 #else
5980 S16 cmPkRgrUeUlPwrCfg(param, mBuf)
5981 RgrUeUlPwrCfg *param;
5982 Buffer *mBuf;
5983 #endif
5984 {
5985
5986
5987    CMCHKPK(oduUnpackUInt8, param->trgCqi, mBuf);
5988    CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
5989    CMCHKPK(SPkS8, param->p0UePucch, mBuf);
5990    CMCHKPK(SPkS8, param->p0UePusch, mBuf);
5991    CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
5992    CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
5993    CMCHKPK(cmPkRgrUeGrpPwrCfg, &param->uePucchPwr, mBuf);
5994    CMCHKPK(cmPkRgrUeGrpPwrCfg, &param->uePuschPwr, mBuf);
5995    return ROK;
5996 }
5997
5998
5999 \f
6000 /***********************************************************
6001 *
6002 *     Func : cmUnpkRgrUeUlPwrCfg
6003 *
6004 *
6005 *     Desc : Uplink power configuration per UE
6006 *
6007 *
6008 *     Ret  : S16
6009 *
6010 *     Notes:
6011 *
6012 *     File  :
6013 *
6014 **********************************************************/
6015 #ifdef ANSI
6016 S16 cmUnpkRgrUeUlPwrCfg
6017 (
6018 RgrUeUlPwrCfg *param,
6019 Buffer *mBuf
6020 )
6021 #else
6022 S16 cmUnpkRgrUeUlPwrCfg(param, mBuf)
6023 RgrUeUlPwrCfg *param;
6024 Buffer *mBuf;
6025 #endif
6026 {
6027
6028
6029    CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, &param->uePuschPwr, mBuf);
6030    CMCHKUNPK(cmUnpkRgrUeGrpPwrCfg, &param->uePucchPwr, mBuf);
6031    CMCHKUNPK(oduPackUInt8, &param->isAccumulated, mBuf);
6032    CMCHKUNPK(oduPackUInt8, &param->isDeltaMCSEnabled, mBuf);
6033    CMCHKUNPK(SUnpkS8, &param->p0UePusch, mBuf);
6034    CMCHKUNPK(SUnpkS8, &param->p0UePucch, mBuf);
6035    CMCHKUNPK(oduPackUInt8, &param->pSRSOffset, mBuf);
6036    CMCHKUNPK(oduPackUInt8, &param->trgCqi, mBuf);
6037    return ROK;
6038 }
6039
6040
6041 \f
6042 /***********************************************************
6043 *
6044 *     Func : cmPkRgrUeQosCfg
6045 *
6046 *
6047 *     Desc : Downlink/Uplink QoS configuration per UE
6048 *
6049 *
6050 *     Ret  : S16
6051 *
6052 *     Notes:
6053 *
6054 *     File  :
6055 *
6056 **********************************************************/
6057 #ifdef ANSI
6058 S16 cmPkRgrUeQosCfg
6059 (
6060 RgrUeQosCfg *param,
6061 Buffer *mBuf
6062 )
6063 #else
6064 S16 cmPkRgrUeQosCfg(param, mBuf)
6065 RgrUeQosCfg *param;
6066 Buffer *mBuf;
6067 #endif
6068 {
6069
6070
6071    CMCHKPK(oduUnpackUInt32, param->ueBr, mBuf);
6072    CMCHKPK(oduUnpackUInt32, param->dlAmbr, mBuf);
6073    CMCHKPK(oduUnpackUInt8, param->ambrPres, mBuf);
6074    return ROK;
6075 }
6076
6077
6078 \f
6079 /***********************************************************
6080 *
6081 *     Func : cmUnpkRgrUeQosCfg
6082 *
6083 *
6084 *     Desc : Downlink/Uplink QoS configuration per UE
6085 *
6086 *
6087 *     Ret  : S16
6088 *
6089 *     Notes:
6090 *
6091 *     File  :
6092 *
6093 **********************************************************/
6094 #ifdef ANSI
6095 S16 cmUnpkRgrUeQosCfg
6096 (
6097 RgrUeQosCfg *param,
6098 Buffer *mBuf
6099 )
6100 #else
6101 S16 cmUnpkRgrUeQosCfg(param, mBuf)
6102 RgrUeQosCfg *param;
6103 Buffer *mBuf;
6104 #endif
6105 {
6106
6107
6108    CMCHKUNPK(oduPackUInt8, &param->ambrPres, mBuf);
6109    CMCHKUNPK(oduPackUInt32, &param->dlAmbr, mBuf);
6110    CMCHKUNPK(oduPackUInt32, &param->ueBr, mBuf);
6111    return ROK;
6112 }
6113
6114 /***********************************************************
6115 *
6116 *     Func : cmPkRgrUePuschDedCfg
6117 *
6118 *
6119 *     Desc : PUSCH Config Dedication for UE
6120 *
6121 *
6122 *     Ret  : S16
6123 *
6124 *     Notes:
6125 *
6126 *     File  :
6127 *
6128 **********************************************************/
6129 #ifdef ANSI
6130 S16 cmPkRgrUePuschDedCfg
6131 (
6132 RgrUePuschDedCfg *param,
6133 Buffer *mBuf
6134 )
6135 #else
6136 S16 cmPkRgrUePuschDedCfg(param, mBuf)
6137 RgrUePuschDedCfg *param;
6138 Buffer *mBuf;
6139 #endif
6140 {
6141
6142
6143    CMCHKPK(oduUnpackUInt8, param->bCQIIdx, mBuf);
6144    CMCHKPK(oduUnpackUInt8, param->bRIIdx, mBuf);
6145    CMCHKPK(oduUnpackUInt8, param->bACKIdx, mBuf);
6146    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
6147    return ROK;
6148 }
6149
6150
6151 /***********************************************************
6152 *
6153 *     Func : cmUnpkRgrUePuschDedCfg
6154 *
6155 *
6156 *     Desc : PUSCH Config Dedication for UE
6157 *
6158 *
6159 *
6160 *     Ret  : S16
6161 *
6162 *     Notes:
6163 *
6164 *     File  :
6165 *
6166 **********************************************************/
6167 #ifdef ANSI
6168 S16 cmUnpkRgrUePuschDedCfg
6169 (
6170 RgrUePuschDedCfg *param,
6171 Buffer *mBuf
6172 )
6173 #else
6174 S16 cmUnpkRgrUePuschDedCfg(param, mBuf)
6175 RgrUePuschDedCfg *param;
6176 Buffer *mBuf;
6177 #endif
6178 {
6179
6180
6181    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
6182    CMCHKUNPK(oduPackUInt8, &param->bACKIdx, mBuf);
6183    CMCHKUNPK(oduPackUInt8, &param->bRIIdx, mBuf);
6184    CMCHKUNPK(oduPackUInt8, &param->bCQIIdx, mBuf);
6185    return ROK;
6186 }
6187
6188 /***********************************************************
6189 *
6190 *     Func : cmPkRgrUeTxAntSelCfg
6191 *
6192 *
6193 *     Desc : UE Transmit Antenna selection related configuration
6194 *
6195 *
6196 *     Ret  : S16
6197 *
6198 *     Notes:
6199 *
6200 *     File  :
6201 *
6202 **********************************************************/
6203 #ifdef ANSI
6204 S16 cmPkRgrUeTxAntSelCfg
6205 (
6206 RgrUeTxAntSelCfg *param,
6207 Buffer *mBuf
6208 )
6209 #else
6210 S16 cmPkRgrUeTxAntSelCfg(param, mBuf)
6211 RgrUeTxAntSelCfg *param;
6212 Buffer *mBuf;
6213 #endif
6214 {
6215
6216
6217    CMCHKPK(oduUnpackUInt32, param->selType, mBuf);
6218    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
6219    return ROK;
6220 }
6221
6222
6223 \f
6224 /***********************************************************
6225 *
6226 *     Func : cmUnpkRgrUeTxAntSelCfg
6227 *
6228 *
6229 *     Desc : UE Transmit Antenna selection related configuration
6230 *
6231 *
6232 *     Ret  : S16
6233 *
6234 *     Notes:
6235 *
6236 *     File  :
6237 *
6238 **********************************************************/
6239 #ifdef ANSI
6240 S16 cmUnpkRgrUeTxAntSelCfg
6241 (
6242 RgrUeTxAntSelCfg *param,
6243 Buffer *mBuf
6244 )
6245 #else
6246 S16 cmUnpkRgrUeTxAntSelCfg(param, mBuf)
6247 RgrUeTxAntSelCfg *param;
6248 Buffer *mBuf;
6249 #endif
6250 {
6251    uint32_t tmpEnum;
6252
6253
6254    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
6255    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
6256    param->selType = (RgrUeTxAntSelType) tmpEnum;
6257    return ROK;
6258 }
6259
6260
6261 /***********************************************************
6262 *
6263 *     Func : cmPkRgrUeTaTmrCfg
6264 *
6265 *
6266 *     Desc : Time Alignment timer configuration per UE
6267 *
6268 *
6269 *     Ret  : S16
6270 *
6271 *     Notes:
6272 *
6273 *     File  :
6274 *
6275 **********************************************************/
6276 #ifdef ANSI
6277 S16 cmPkRgrUeTaTmrCfg
6278 (
6279 RgrUeTaTmrCfg *param,
6280 Buffer *mBuf
6281 )
6282 #else
6283 S16 cmPkRgrUeTaTmrCfg(param, mBuf)
6284 RgrUeTaTmrCfg *param;
6285 Buffer *mBuf;
6286 #endif
6287 {
6288
6289
6290    CMCHKPK(oduUnpackUInt16, param->taTmr, mBuf);
6291    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
6292    return ROK;
6293 }
6294
6295
6296 \f
6297 /***********************************************************
6298 *
6299 *     Func : cmUnpkRgrUeTaTmrCfg
6300 *
6301 *
6302 *     Desc : Time Alignment timer configuration per UE
6303 *
6304 *
6305 *     Ret  : S16
6306 *
6307 *     Notes:
6308 *
6309 *     File  :
6310 *
6311 **********************************************************/
6312 #ifdef ANSI
6313 S16 cmUnpkRgrUeTaTmrCfg
6314 (
6315 RgrUeTaTmrCfg *param,
6316 Buffer *mBuf
6317 )
6318 #else
6319 S16 cmUnpkRgrUeTaTmrCfg(param, mBuf)
6320 RgrUeTaTmrCfg *param;
6321 Buffer *mBuf;
6322 #endif
6323 {
6324
6325
6326    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
6327    CMCHKUNPK(oduPackUInt16, &param->taTmr, mBuf);
6328    return ROK;
6329 }
6330
6331
6332 #ifdef EMTC_ENABLE
6333 #ifdef ANSI
6334 S16 cmUnpkRgrEmtcUeCfg
6335 (
6336 RgrUeEmtcCfg *param,
6337 Buffer *mBuf
6338 )
6339 #else
6340 S16 cmUnpkRgrEmtcUeCfg(param, mBuf)
6341 RgrUeEmtcCfg *param;
6342 Buffer *mBuf;
6343 #endif
6344 {
6345    S32 indx=0;
6346    S32 idx=0;
6347    RgrEpdcchConfigRel11 *emtcEpdcchCfg = &(param->emtcEpdcchCfg);
6348    RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
6349    RgrEpdcchAddModLst *epdcchAddModLst;
6350
6351    CMCHKUNPK(oduPackUInt8,&param->pdschReptLevModeA,mBuf);
6352    /*UnPacking PUCCH Rep */
6353    CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat2),mBuf);
6354    CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->modeANumPucchRepFormat1),mBuf);
6355    CMCHKUNPK(oduPackUInt8,&(emtcPucchRepCfg->isPucchRepPres),mBuf);
6356
6357
6358
6359    for(indx = 0; indx < RGR_MAX_EPDCCH_SET; indx++)
6360    {
6361       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
6362       CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->extaddgrp2.mpddchNB),mBuf);
6363       CMCHKUNPK(oduPackUInt16,&(epdcchAddModLst->extaddgrp2.mpdcchNumRep),mBuf);
6364       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD),mBuf);
6365       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
6366       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
6367       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
6368       CMCHKUNPK(cmUnpkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
6369       CMCHKUNPK(cmUnpkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
6370       CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
6371       CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
6372       for(idx = 0; idx < 5; idx++)
6373       {
6374          CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.rbAssignment[idx]),mBuf);
6375       }
6376
6377       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->resBlkAssignment.numPRBpairs),mBuf);
6378       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->transmissionType),mBuf);
6379       CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->setConfigId),mBuf);
6380
6381    }
6382    CMCHKUNPK(cmUnpkTknUInt32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
6383    for(indx = 0; indx < 5; indx++)
6384    {
6385       CMCHKUNPK(oduPackUInt8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
6386    }
6387    CMCHKUNPK(oduPackUInt8, &(emtcEpdcchCfg->sfPtn.pres), mBuf);
6388    CMCHKUNPK(oduPackUInt8, &(param->pres), mBuf);
6389    CMCHKUNPK(oduPackUInt8, &(param->isHdFddEnbld), mBuf);
6390
6391 #ifdef EMTC_DEBUG_CONSOLE_PRINTS
6392    printf("\n EMTC RGR UE unpack\n");
6393    printf("\nemtcEpdcchCfg->sfPtn.pres %d ",emtcEpdcchCfg->sfPtn.pres);
6394
6395    for(indx = 0; indx < 5; indx++)
6396    {
6397       printf("\nemtcEpdcchCfg->sfPtn.measSfPatFDD[%d] %d ",indx,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]);
6398    }
6399    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.pres);
6400    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.val);
6401
6402    for(indx = 0 ; indx < RGR_MAX_EPDCCH_SET; indx++)
6403    {
6404       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
6405       printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.pres);
6406       printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.val);
6407       printf("\nepdcchAddModLst->setConfigId %d ", epdcchAddModLst->setConfigId);
6408       printf("\nepdcchAddModLst->transmissionType %d ",epdcchAddModLst->transmissionType);
6409       printf("\nepdcchAddModLst->resBlkAssignment.numPRBpairs %d ",epdcchAddModLst->resBlkAssignment.numPRBpairs);
6410       for(idx = 0; idx < 5 ; idx++)
6411       {
6412          printf("\nepdcchAddModLst->resBlkAssignment.rbAssignment[idx] %d ",epdcchAddModLst->resBlkAssignment.rbAssignment[idx]);
6413       }
6414       printf("\nepdcchAddModLst->dmrsScrambSeq %d ",epdcchAddModLst->dmrsScrambSeq);
6415       printf("\nepdcchAddModLst->pucchResStartoffset %d ",epdcchAddModLst->pucchResStartoffset);
6416       printf("\nepdcchAddModLst->pdschRemapQLcfgId.pres %d ",epdcchAddModLst->pdschRemapQLcfgId.pres);
6417       printf("\nepdcchAddModLst->pdschRemapQLcfgId.val %d ", epdcchAddModLst->pdschRemapQLcfgId.val);
6418       printf("\nepdcchAddModLst->mpdcchNumPRBpair.pres %d ",  epdcchAddModLst->mpdcchNumPRBpair.pres);
6419       printf("\nepdcchAddModLst->mpdcchNumPRBpair.val %d ",  epdcchAddModLst->mpdcchNumPRBpair.val);
6420       printf("\nepdcchAddModLst->extaddgrp2.pres %d ",       epdcchAddModLst->extaddgrp2.pres);
6421       printf("\nepdcchAddModLst->extaddgrp2.csiNumRep %d ",   epdcchAddModLst->extaddgrp2.csiNumRep);
6422       printf("\nepdcchAddModLst->extaddgrp2.mpddchPdschHop %d ", epdcchAddModLst->extaddgrp2.mpddchPdschHop);
6423       printf("\nepdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD %d ",epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD);
6424       printf("\nepdcchAddModLst->extaddgrp2.mpdcchNumRep %d ", epdcchAddModLst->extaddgrp2.mpdcchNumRep);
6425       printf("\nepdcchAddModLst->extaddgrp2.mpddchNB %d ",  epdcchAddModLst->extaddgrp2.mpddchNB);
6426    }
6427
6428 #endif
6429
6430    return ROK;
6431 }
6432
6433
6434
6435 S16 cmPkRgrEmtcUeCfg
6436 (
6437  RgrUeEmtcCfg *param,
6438  Buffer *mBuf
6439  )
6440 {
6441    S32 indx=0;
6442    S32 idx=0;
6443    RgrEpdcchConfigRel11 *emtcEpdcchCfg = &(param->emtcEpdcchCfg);
6444    RgrPucchRepCfgRel13 *emtcPucchRepCfg = &(param->emtcPucchRepCfg);
6445    RgrEpdcchAddModLst *epdcchAddModLst;
6446
6447    CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
6448    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
6449    CMCHKPK(oduUnpackUInt8, emtcEpdcchCfg->sfPtn.pres, mBuf);
6450    for(indx = 4; indx >=0; indx--)
6451    {
6452       CMCHKPK(oduUnpackUInt8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
6453    }
6454    CMCHKPK(cmPkTknUInt32,&emtcEpdcchCfg->startSymbolr11,mBuf);
6455    for(indx = RGR_MAX_EPDCCH_SET-1 ; indx >= 0; indx--)
6456    {
6457       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
6458
6459       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->setConfigId,mBuf);
6460       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->transmissionType,mBuf);
6461       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.numPRBpairs,mBuf);
6462       for(idx = 4; idx >= 0; idx--)
6463       {
6464          CMCHKPK(oduUnpackUInt8,epdcchAddModLst->resBlkAssignment.rbAssignment[idx],mBuf);
6465       }
6466       CMCHKPK(oduUnpackUInt32,epdcchAddModLst->dmrsScrambSeq,mBuf);
6467       CMCHKPK(oduUnpackUInt32,epdcchAddModLst->pucchResStartoffset,mBuf);
6468       CMCHKPK(cmPkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
6469       CMCHKPK(cmPkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
6470       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.pres,mBuf);
6471       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
6472       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,mBuf);
6473       CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD,mBuf);
6474       CMCHKPK(oduUnpackUInt16,epdcchAddModLst->extaddgrp2.mpdcchNumRep,mBuf);
6475       CMCHKPK(oduUnpackUInt32,epdcchAddModLst->extaddgrp2.mpddchNB,mBuf);
6476    }
6477
6478 /*Packing PUCCH Rep */
6479    CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->isPucchRepPres, mBuf);
6480    CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat1,mBuf);
6481    CMCHKPK(oduUnpackUInt8,emtcPucchRepCfg->modeANumPucchRepFormat2,mBuf);
6482    CMCHKPK(oduUnpackUInt8,param->pdschReptLevModeA,mBuf);
6483
6484 #ifdef EMTC_DEBUG_CONSOLE_PRINTS
6485    printf("\n EMTC RGR UE pack\n");
6486    printf("\nemtcEpdcchCfg->sfPtn.pres %d ",emtcEpdcchCfg->sfPtn.pres);
6487
6488    for(indx = 0; indx < 5; indx++)
6489    {
6490       printf("\nemtcEpdcchCfg->sfPtn.measSfPatFDD[%d] %d ",indx,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]);
6491    }
6492    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.pres);
6493    printf("\nemtcEpdcchCfg->startSymbolr11 %d ",emtcEpdcchCfg->startSymbolr11.val);
6494
6495    for(indx = 0 ; indx < RGR_MAX_EPDCCH_SET; indx++)
6496    {
6497       epdcchAddModLst =  &(emtcEpdcchCfg->epdcchAddModLst[indx]);
6498      /* printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.pres);
6499       printf("\nemtcEpdcchCfg->epdcchRelLst[indx].setCfgId %d %d ", indx,emtcEpdcchCfg->epdcchRelLst[indx].setCfgId.val);*/
6500       printf("\nepdcchAddModLst->setConfigId %d ", epdcchAddModLst->setConfigId);
6501       printf("\nepdcchAddModLst->transmissionType %d ",epdcchAddModLst->transmissionType);
6502       printf("\nepdcchAddModLst->resBlkAssignment.numPRBpairs %d ",epdcchAddModLst->resBlkAssignment.numPRBpairs);
6503       for(idx = 0; idx < 5 ; idx++)
6504       {
6505          printf("\nepdcchAddModLst->resBlkAssignment.rbAssignment[idx] %d ",epdcchAddModLst->resBlkAssignment.rbAssignment[idx]);
6506       }
6507       printf("\nepdcchAddModLst->dmrsScrambSeq %d ",epdcchAddModLst->dmrsScrambSeq);
6508       printf("\nepdcchAddModLst->pucchResStartoffset %d ",epdcchAddModLst->pucchResStartoffset);
6509       printf("\nepdcchAddModLst->pdschRemapQLcfgId.pres %d ",epdcchAddModLst->pdschRemapQLcfgId.pres);
6510       printf("\nepdcchAddModLst->pdschRemapQLcfgId.val %d ", epdcchAddModLst->pdschRemapQLcfgId.val);
6511       printf("\nepdcchAddModLst->mpdcchNumPRBpair.pres %d ",  epdcchAddModLst->mpdcchNumPRBpair.pres);
6512       printf("\nepdcchAddModLst->mpdcchNumPRBpair.val %d ",  epdcchAddModLst->mpdcchNumPRBpair.val);
6513       printf("\nepdcchAddModLst->extaddgrp2.pres %d ",       epdcchAddModLst->extaddgrp2.pres);
6514       printf("\nepdcchAddModLst->extaddgrp2.csiNumRep %d ",   epdcchAddModLst->extaddgrp2.csiNumRep);
6515       printf("\nepdcchAddModLst->extaddgrp2.mpddchPdschHop %d ", epdcchAddModLst->extaddgrp2.mpddchPdschHop);
6516       printf("\nepdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD %d ",epdcchAddModLst->extaddgrp2.mpdcchStartUESSFDD);
6517       printf("\nepdcchAddModLst->extaddgrp2.mpdcchNumRep %d ", epdcchAddModLst->extaddgrp2.mpdcchNumRep);
6518       printf("\nepdcchAddModLst->extaddgrp2.mpddchNB %d ",  epdcchAddModLst->extaddgrp2.mpddchNB);
6519    }
6520
6521 #endif
6522
6523
6524
6525    return ROK;
6526 }
6527 #endif
6528
6529 #ifdef RG_5GTF
6530 S16 cmUnpkRgr5gtfUeCfg
6531 (
6532  RgrUe5gtfCfg *param,
6533  Buffer       *mBuf
6534 )
6535 {
6536    CMCHKUNPK(oduPackUInt8, &param->grpId, mBuf);
6537    CMCHKUNPK(oduPackUInt8, &param->BeamId, mBuf);
6538    CMCHKUNPK(oduPackUInt8, &param->numCC, mBuf);
6539    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
6540    CMCHKUNPK(oduPackUInt8, &param->maxPrb, mBuf);
6541    return ROK;
6542 }
6543
6544 S16 cmPkRgr5gtfUeCfg
6545 (
6546  RgrUe5gtfCfg *param,
6547  Buffer       *mBuf
6548 )
6549 {
6550    CMCHKPK(oduUnpackUInt8, param->maxPrb, mBuf);
6551    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
6552    CMCHKPK(oduUnpackUInt8, param->numCC, mBuf);
6553    CMCHKPK(oduUnpackUInt8, param->BeamId, mBuf);
6554    CMCHKPK(oduUnpackUInt8, param->grpId, mBuf);
6555    return ROK;
6556 }
6557 #endif
6558
6559 \f
6560 /***********************************************************
6561 *
6562 *     Func : cmPkRgrUeCfg
6563 *
6564 *
6565 *     Desc : UE configuration
6566 *
6567 *
6568 *     Ret  : S16
6569 *
6570 *     Notes:
6571 *
6572 *     File  :
6573 *
6574 **********************************************************/
6575 #ifdef ANSI
6576 S16 cmPkRgrUeCfg
6577 (
6578 RgrUeCfg *param,
6579 Buffer *mBuf
6580 )
6581 #else
6582 S16 cmPkRgrUeCfg(param, mBuf)
6583 RgrUeCfg *param;
6584 Buffer *mBuf;
6585 #endif
6586 {
6587
6588 #ifdef RG_5GTF
6589    CMCHKPK(cmPkRgr5gtfUeCfg, &param->ue5gtfCfg, mBuf);
6590 #endif
6591 #ifdef EMTC_ENABLE
6592  CMCHKPK(cmPkRgrEmtcUeCfg, &param->emtcUeCfg, mBuf);
6593 #endif
6594    CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
6595
6596    CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
6597    /* LTE_ADV_FLAG_REMOVED_START */
6598    CMCHKPK(cmPkRgrLteAdvancedUeConfig, &param->ueLteAdvCfg, mBuf);
6599    /* LTE_ADV_FLAG_REMOVED_END */
6600 #ifdef TFU_UPGRADE
6601 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
6602    CMCHKPK(cmPkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
6603 #endif
6604    /*rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
6605    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
6606 #ifdef RGR_CQI_REPT
6607    CMCHKPK(cmPkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
6608 #endif
6609    CMCHKPK(cmPkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
6610
6611 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
6612    CMCHKPK(cmPkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
6613
6614 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
6615 #ifdef LTEMAC_HDFDD
6616    CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
6617 #endif
6618
6619 #ifdef TFU_UPGRADE
6620    CMCHKPK(cmPkRgrUeSrCfg, &param->srCfg, mBuf);
6621    CMCHKPK(cmPkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
6622 #endif
6623
6624
6625
6626    CMCHKPK(cmPkRgrUeSpsCfg, &param->ueSpsCfg, mBuf);
6627
6628 #ifdef LTE_TDD
6629    CMCHKPK(oduUnpackUInt32, param->ackNackModeEnum, mBuf);
6630
6631 #endif
6632    CMCHKPK(cmPkTknUInt8, &param->dedPreambleId, mBuf);
6633    CMCHKPK(cmPkRgrCodeBookRstCfg, &param->ueCodeBookRstCfg, mBuf);
6634    CMCHKPK(cmPkRgrUeCapCfg, &param->ueCapCfg, mBuf);
6635    CMCHKPK(cmPkRgrUeMeasGapCfg, &param->ueMesGapCfg, mBuf);
6636    CMCHKPK(cmPkRgrUeAckNackRepCfg, &param->ueAckNackCfg, mBuf);
6637    CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
6638 /*rgr_c_001.main_9 ADD added changes for DRX*/
6639
6640    /* Anshika - Pack only if DRX is enabled */
6641    if(TRUE == param->ueDrxCfg.isDrxEnabled)
6642    {
6643     CMCHKPK(cmPkRgrUeDrxCfg, &param->ueDrxCfg, mBuf);
6644    }
6645    CMCHKPK(oduUnpackUInt8, param->ueDrxCfg.isDrxEnabled, mBuf); /* This has to be packed even if
6646                                                  DRX is disabled */
6647    CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
6648 #ifdef RGR_V1
6649    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
6650     * retxBSR-timer */
6651    CMCHKPK(cmPkRgrUeBsrTmrCfg, &param->ueBsrTmrCfg, mBuf);
6652 #endif
6653    CMCHKPK(cmPkRgrUeTaTmrCfg, &param->ueTaTmrCfg, mBuf);
6654    CMCHKPK(cmPkRgrUeQosCfg, &param->ueQosCfg, mBuf);
6655    CMCHKPK(cmPkRgrUeUlPwrCfg, &param->ueUlPwrCfg, mBuf);
6656    CMCHKPK(cmPkRgrUeUlHqCfg, &param->ueUlHqCfg, mBuf);
6657    CMCHKPK(cmPkRgrUeDlCqiCfg, &param->ueDlCqiCfg, mBuf);
6658    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
6659    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
6660    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
6661    return ROK;
6662 }
6663
6664
6665 \f
6666 /***********************************************************
6667 *
6668 *     Func : cmUnpkRgrUeCfg
6669 *
6670 *
6671 *     Desc : UE configuration
6672 *
6673 *
6674 *     Ret  : S16
6675 *
6676 *     Notes:
6677 *
6678 *     File  :
6679 *
6680 **********************************************************/
6681 #ifdef ANSI
6682 S16 cmUnpkRgrUeCfg
6683 (
6684 RgrUeCfg *param,
6685 Buffer *mBuf
6686 )
6687 #else
6688 S16 cmUnpkRgrUeCfg(param, mBuf)
6689 RgrUeCfg *param;
6690 Buffer *mBuf;
6691 #endif
6692 {
6693    uint32_t tmpEnum;
6694
6695
6696    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
6697    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
6698    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
6699    CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, &param->ueDlCqiCfg, mBuf);
6700    CMCHKUNPK(cmUnpkRgrUeUlHqCfg, &param->ueUlHqCfg, mBuf);
6701    CMCHKUNPK(cmUnpkRgrUeUlPwrCfg, &param->ueUlPwrCfg, mBuf);
6702    CMCHKUNPK(cmUnpkRgrUeQosCfg, &param->ueQosCfg, mBuf);
6703    CMCHKUNPK(cmUnpkRgrUeTaTmrCfg, &param->ueTaTmrCfg, mBuf);
6704 #ifdef RGR_V1
6705    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
6706     * retxBSR-timer */
6707    CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, &param->ueBsrTmrCfg, mBuf);
6708 #endif
6709    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
6710    param->ueCatEnum = (CmLteUeCategory) tmpEnum;
6711 /*rgr_c_001.main_9 ADD added changes for DRX*/
6712
6713    /* Anshika - Unpack only if DRX is enabled */
6714    CMCHKUNPK(oduPackUInt8, &param->ueDrxCfg.isDrxEnabled, mBuf);
6715    if(TRUE == param->ueDrxCfg.isDrxEnabled)
6716    {
6717       CMCHKUNPK(cmUnpkRgrUeDrxCfg, &param->ueDrxCfg, mBuf);
6718    }
6719    CMCHKUNPK(oduPackUInt8, &param->isTtiBundlEnabled, mBuf);
6720    CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, &param->ueAckNackCfg, mBuf);
6721    CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, &param->ueMesGapCfg, mBuf);
6722    CMCHKUNPK(cmUnpkRgrUeCapCfg, &param->ueCapCfg, mBuf);
6723    CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, &param->ueCodeBookRstCfg, mBuf);
6724    CMCHKUNPK(cmUnpkTknUInt8, &param->dedPreambleId, mBuf);
6725
6726 #ifdef LTE_TDD
6727    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
6728    param->ackNackModeEnum = tmpEnum;
6729
6730 #endif
6731    /*rgr_c_001.main_7 - Added support for SPS*/
6732    CMCHKUNPK(cmUnpkRgrUeSpsCfg, &param->ueSpsCfg, mBuf);
6733
6734 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
6735 #ifdef TFU_UPGRADE
6736    CMCHKUNPK(cmUnpkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
6737    CMCHKUNPK(cmUnpkRgrUeSrCfg, &param->srCfg, mBuf);
6738 #endif
6739 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
6740 #ifdef LTEMAC_HDFDD
6741    CMCHKUNPK(oduPackUInt8, &param->isHdFddEnbld, mBuf);
6742 #endif
6743    CMCHKUNPK(cmUnpkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
6744    CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
6745 /* rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
6746    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
6747 #ifdef RGR_CQI_REPT
6748    CMCHKUNPK(cmUnpkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
6749 #endif
6750 #ifdef TFU_UPGRADE
6751    CMCHKUNPK(cmUnpkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
6752 #endif
6753    /* LTE_ADV_FLAG_REMOVED_START */
6754    CMCHKUNPK(cmUnpkRgrLteAdvancedUeConfig, &param->ueLteAdvCfg, mBuf);
6755    /* LTE_ADV_FLAG_REMOVED_END */
6756    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->accessStratumRls, mBuf);
6757    CMCHKUNPK(oduPackUInt8, &param->csgMmbrSta, mBuf);
6758
6759 #ifdef EMTC_ENABLE
6760  CMCHKUNPK(cmUnpkRgrEmtcUeCfg, &param->emtcUeCfg, mBuf);
6761 #endif
6762
6763 #ifdef RG_5GTF
6764  CMCHKUNPK(cmUnpkRgr5gtfUeCfg, &param->ue5gtfCfg, mBuf);
6765 #endif
6766
6767    return ROK;
6768 }
6769
6770
6771 \f
6772 /***********************************************************
6773 *
6774 *     Func : cmPkRgrLchQosCfg
6775 *
6776 *
6777 *     Desc : QCI, GBR and MBR configuration for dedicated logical channels
6778 *
6779 *
6780 *     Ret  : S16
6781 *
6782 *     Notes:
6783 *
6784 *     File  :
6785 *
6786 **********************************************************/
6787 #ifdef ANSI
6788 S16 cmPkRgrLchQosCfg
6789 (
6790 RgrLchQosCfg *param,
6791 Buffer *mBuf
6792 )
6793 #else
6794 S16 cmPkRgrLchQosCfg(param, mBuf)
6795 RgrLchQosCfg *param;
6796 Buffer *mBuf;
6797 #endif
6798 {
6799
6800
6801    CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
6802    CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
6803    CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
6804    return ROK;
6805 }
6806
6807
6808 \f
6809 /***********************************************************
6810 *
6811 *     Func : cmUnpkRgrLchQosCfg
6812 *
6813 *
6814 *     Desc : QCI, GBR and MBR configuration for dedicated logical channels
6815 *
6816 *
6817 *     Ret  : S16
6818 *
6819 *     Notes:
6820 *
6821 *     File  :
6822 *
6823 **********************************************************/
6824 #ifdef ANSI
6825 S16 cmUnpkRgrLchQosCfg
6826 (
6827 RgrLchQosCfg *param,
6828 Buffer *mBuf
6829 )
6830 #else
6831 S16 cmUnpkRgrLchQosCfg(param, mBuf)
6832 RgrLchQosCfg *param;
6833 Buffer *mBuf;
6834 #endif
6835 {
6836
6837
6838    CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
6839    CMCHKUNPK(oduPackUInt32, &param->gbr, mBuf);
6840    CMCHKUNPK(oduPackUInt32, &param->mbr, mBuf);
6841    return ROK;
6842 }
6843 /*rgr_c_001.main_7 - Added support for SPS*/
6844
6845 \f
6846 /***********************************************************
6847 *
6848 *     Func : cmPkRgrLchSpsCfg
6849 *
6850 *
6851 *     Desc : SPS related configuration for logical channels
6852 *
6853 *
6854 *     Ret  : S16
6855 *
6856 *     Notes:
6857 *
6858 *     File  :
6859 *
6860 **********************************************************/
6861 #ifdef ANSI
6862 S16 cmPkRgrLchSpsCfg
6863 (
6864 RgrLchSpsCfg *param,
6865 Buffer *mBuf
6866 )
6867 #else
6868 S16 cmPkRgrLchSpsCfg(param, mBuf)
6869 RgrLchSpsCfg *param;
6870 Buffer *mBuf;
6871 #endif
6872 {
6873
6874
6875    /* SPS_DEV */
6876    CMCHKPK(oduUnpackUInt8, param->isSpsEnabled, mBuf);
6877    return ROK;
6878 }
6879
6880
6881 \f
6882 /***********************************************************
6883 *
6884 *     Func : cmUnpkRgrLchSpsCfg
6885 *
6886 *
6887 *     Desc : SPS related configuration for logical channels
6888 *
6889 *
6890 *     Ret  : S16
6891 *
6892 *     Notes:
6893 *
6894 *     File  :
6895 *
6896 **********************************************************/
6897 #ifdef ANSI
6898 S16 cmUnpkRgrLchSpsCfg
6899 (
6900 RgrLchSpsCfg *param,
6901 Buffer *mBuf
6902 )
6903 #else
6904 S16 cmUnpkRgrLchSpsCfg(param, mBuf)
6905 RgrLchSpsCfg *param;
6906 Buffer *mBuf;
6907 #endif
6908 {
6909
6910
6911    CMCHKUNPK(oduPackUInt8, &param->isSpsEnabled, mBuf);
6912
6913    return ROK;
6914 }
6915
6916
6917 /***********************************************************
6918 *
6919 *     Func : cmPkRgrDlLchCfg
6920 *
6921 *
6922 *     Desc : Logical channel configuration info for downlink logical channels
6923 *
6924 *
6925 *     Ret  : S16
6926 *
6927 *     Notes:
6928 *
6929 *     File  :
6930 *
6931 **********************************************************/
6932 #ifdef ANSI
6933 S16 cmPkRgrDlLchCfg
6934 (
6935 RgrDlLchCfg *param,
6936 Buffer *mBuf
6937 )
6938 #else
6939 S16 cmPkRgrDlLchCfg(param, mBuf)
6940 RgrDlLchCfg *param;
6941 Buffer *mBuf;
6942 #endif
6943 {
6944
6945 /*rgr_c_001.main_7 - Added support for SPS*/
6946
6947    CMCHKPK(oduUnpackUInt8, param->rlcReorderTmr, mBuf);
6948    CMCHKPK(cmPkRgrLchSpsCfg, &param->dlSpsCfg, mBuf);
6949    CMCHKPK(cmPkRgrLchQosCfg, &param->dlQos, mBuf);
6950    CMCHKPK(oduUnpackUInt8, param->dlTrchType, mBuf);
6951    return ROK;
6952 }
6953
6954
6955 \f
6956 /***********************************************************
6957 *
6958 *     Func : cmUnpkRgrDlLchCfg
6959 *
6960 *
6961 *     Desc : Logical channel configuration info for downlink logical channels
6962 *
6963 *
6964 *     Ret  : S16
6965 *
6966 *     Notes:
6967 *
6968 *     File  :
6969 *
6970 **********************************************************/
6971 #ifdef ANSI
6972 S16 cmUnpkRgrDlLchCfg
6973 (
6974 RgrDlLchCfg *param,
6975 Buffer *mBuf
6976 )
6977 #else
6978 S16 cmUnpkRgrDlLchCfg(param, mBuf)
6979 RgrDlLchCfg *param;
6980 Buffer *mBuf;
6981 #endif
6982 {
6983
6984
6985    CMCHKUNPK(oduPackUInt8, &param->dlTrchType, mBuf);
6986    CMCHKUNPK(cmUnpkRgrLchQosCfg, &param->dlQos, mBuf);
6987    /*rgr_c_001.main_7 - Added support for SPs*/
6988    CMCHKUNPK(cmUnpkRgrLchSpsCfg, &param->dlSpsCfg, mBuf);
6989    CMCHKUNPK(oduPackUInt8, &param->rlcReorderTmr, mBuf);
6990
6991    return ROK;
6992 }
6993
6994
6995 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
6996 #ifdef LTE_L2_MEAS
6997
6998 \f
6999 /***********************************************************
7000 *
7001 *     Func : cmPkRgrUlLchCfg
7002 *
7003 *
7004 *     Desc : Logical channel configuration information for uplink logical channels
7005 *
7006 *
7007 *     Ret  : S16
7008 *
7009 *     Notes:
7010 *
7011 *     File  :
7012 *
7013 **********************************************************/
7014 #ifdef ANSI
7015 S16 cmPkRgrUlLchCfg
7016 (
7017 RgrUlLchCfg *param,
7018 Buffer *mBuf
7019 )
7020 #else
7021 S16 cmPkRgrUlLchCfg(param, mBuf)
7022 RgrUlLchCfg *param;
7023 Buffer *mBuf;
7024 #endif
7025 {
7026
7027
7028    CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
7029    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
7030    return ROK;
7031 }
7032
7033
7034 \f
7035 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
7036 /***********************************************************
7037 *
7038 *     Func : cmUnpkRgrUlLchCfg
7039 *
7040 *
7041 *     Desc : Logical channel configuration information for uplink logical channels
7042 *
7043 *
7044 *     Ret  : S16
7045 *
7046 *     Notes:
7047 *
7048 *     File  :
7049 *
7050 **********************************************************/
7051 #ifdef ANSI
7052 S16 cmUnpkRgrUlLchCfg
7053 (
7054 RgrUlLchCfg *param,
7055 Buffer *mBuf
7056 )
7057 #else
7058 S16 cmUnpkRgrUlLchCfg(param, mBuf)
7059 RgrUlLchCfg *param;
7060 Buffer *mBuf;
7061 #endif
7062 {
7063
7064
7065    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
7066    CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
7067    return ROK;
7068 }
7069
7070
7071 #endif
7072 \f
7073 /***********************************************************
7074 *
7075 *     Func : cmPkRgrUlLcgCfg
7076 *
7077 *
7078 *     Desc : Logical channel configuration info for uplink logical channels
7079 *
7080 *
7081 *     Ret  : S16
7082 *
7083 *     Notes:
7084 *
7085 *     File  :
7086 *
7087 **********************************************************/
7088 #ifdef ANSI
7089 S16 cmPkRgrUlLcgCfg
7090 (
7091 RgrUlLcgCfg *param,
7092 Buffer *mBuf
7093 )
7094 #else
7095 S16 cmPkRgrUlLcgCfg(param, mBuf)
7096 RgrUlLcgCfg *param;
7097 Buffer *mBuf;
7098 #endif
7099 {
7100
7101 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
7102 #ifdef LTE_L2_MEAS
7103    S32 i;
7104 #endif
7105    CMCHKPK(oduUnpackUInt32, param->mbr, mBuf);
7106    CMCHKPK(oduUnpackUInt32, param->gbr, mBuf);
7107
7108 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
7109 #ifdef LTE_L2_MEAS
7110    for (i = param->numLch - 1; i >= 0; i--)
7111    {
7112       CMCHKPK(cmPkRgrUlLchCfg, &param->lchUlCfg[i], mBuf);
7113    }
7114    CMCHKPK(oduUnpackUInt8, param->numLch, mBuf);
7115 #endif
7116    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
7117    return ROK;
7118 }
7119
7120
7121 \f
7122 /***********************************************************
7123 *
7124 *     Func : cmUnpkRgrUlLcgCfg
7125 *
7126 *
7127 *     Desc : Logical channel configuration info for uplink logical channels
7128 *
7129 *
7130 *     Ret  : S16
7131 *
7132 *     Notes:
7133 *
7134 *     File  :
7135 *
7136 **********************************************************/
7137 #ifdef ANSI
7138 S16 cmUnpkRgrUlLcgCfg
7139 (
7140 RgrUlLcgCfg *param,
7141 Buffer *mBuf
7142 )
7143 #else
7144 S16 cmUnpkRgrUlLcgCfg(param, mBuf)
7145 RgrUlLcgCfg *param;
7146 Buffer *mBuf;
7147 #endif
7148 {
7149
7150 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
7151 #ifdef LTE_L2_MEAS
7152    S32 i;
7153 #endif
7154
7155    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
7156 /*rgr_c_001.main_9 ADD added changes for L2 measurements*/
7157 #ifdef LTE_L2_MEAS
7158    CMCHKUNPK(oduPackUInt8, &param->numLch, mBuf);
7159    for (i = 0; i< param->numLch; i++)
7160    {
7161       CMCHKUNPK(cmUnpkRgrUlLchCfg, &param->lchUlCfg[i], mBuf);
7162    }
7163
7164 #endif
7165    CMCHKUNPK(oduPackUInt32, &param->gbr, mBuf);
7166    CMCHKUNPK(oduPackUInt32, &param->mbr, mBuf);
7167    return ROK;
7168 }
7169
7170 #ifdef ANSI
7171 S16 cmPkRgrUlLchQciCfg
7172 (
7173 RgrUlLchQciCfg *param,
7174 Buffer *mBuf
7175 )
7176 #else
7177 S16 cmPkRgrUlLchQciCfg (param, mBuf)
7178 RgrUlLchQciCfg *param;
7179 Buffer *mBuf;
7180 #endif
7181 {
7182    CMCHKPK(oduUnpackUInt8, param->lcId, mBuf);
7183    CMCHKPK(oduUnpackUInt8, param->qci, mBuf);
7184    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
7185    return ROK;
7186 }
7187 #ifdef ANSI
7188 S16 cmUnpkRgrUlLchQciCfg
7189 (
7190 RgrUlLchQciCfg *param,
7191 Buffer *mBuf
7192 )
7193 #else
7194 S16 cmUnpkRgrUlLchQciCfg (param, mBuf)
7195 RgrUlLchQciCfg *param;
7196 Buffer *mBuf;
7197 #endif
7198 {
7199    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
7200    CMCHKUNPK(oduPackUInt8, &param->qci, mBuf);
7201    CMCHKUNPK(oduPackUInt8, &param->lcId, mBuf);
7202    return ROK;
7203 }
7204
7205 \f
7206 /***********************************************************
7207 *
7208 *     Func : cmPkRgrLchCfg
7209 *
7210 *
7211 *     Desc : Logical channel configuration info for dedicated channels
7212 *
7213 *
7214 *     Ret  : S16
7215 *
7216 *     Notes:
7217 *
7218 *     File  :
7219 *
7220 **********************************************************/
7221 #ifdef ANSI
7222 S16 cmPkRgrLchCfg
7223 (
7224 RgrLchCfg *param,
7225 Buffer *mBuf
7226 )
7227 #else
7228 S16 cmPkRgrLchCfg(param, mBuf)
7229 RgrLchCfg *param;
7230 Buffer *mBuf;
7231 #endif
7232 {
7233
7234    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
7235    CMCHKPK(cmPkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
7236    CMCHKPK(cmPkRgrDlLchCfg, &param->dlInfo, mBuf);
7237    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
7238    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
7239    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
7240    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7241    return ROK;
7242 }
7243
7244
7245 \f
7246 /***********************************************************
7247 *
7248 *     Func : cmUnpkRgrLchCfg
7249 *
7250 *
7251 *     Desc : Logical channel configuration info for dedicated channels
7252 *
7253 *
7254 *     Ret  : S16
7255 *
7256 *     Notes:
7257 *
7258 *     File  :
7259 *
7260 **********************************************************/
7261 #ifdef ANSI
7262 S16 cmUnpkRgrLchCfg
7263 (
7264 RgrLchCfg *param,
7265 Buffer *mBuf
7266 )
7267 #else
7268 S16 cmUnpkRgrLchCfg(param, mBuf)
7269 RgrLchCfg *param;
7270 Buffer *mBuf;
7271 #endif
7272 {
7273
7274
7275    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7276    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
7277    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
7278    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
7279    CMCHKUNPK(cmUnpkRgrDlLchCfg, &param->dlInfo, mBuf);
7280    CMCHKUNPK(cmUnpkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
7281    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
7282    return ROK;
7283 }
7284
7285
7286 #ifdef ANSI
7287 S16 cmPkRgrLcgCfg
7288 (
7289 RgrLcgCfg *param,
7290 Buffer *mBuf
7291 )
7292 #else
7293 S16 cmPkRgrLcgCfg(param, mBuf)
7294 RgrLcgCfg *param;
7295 Buffer *mBuf;
7296 #endif
7297 {
7298
7299
7300    CMCHKPK(cmPkRgrUlLcgCfg, &param->ulInfo, mBuf);
7301    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
7302    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7303    return ROK;
7304 }
7305
7306
7307 #ifdef ANSI
7308 S16 cmUnpkRgrLcgCfg
7309 (
7310 RgrLcgCfg *param,
7311 Buffer *mBuf
7312 )
7313 #else
7314 S16 cmUnpkRgrLcgCfg(param, mBuf)
7315 RgrLcgCfg *param;
7316 Buffer *mBuf;
7317 #endif
7318 {
7319
7320
7321    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7322    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
7323    CMCHKUNPK(cmUnpkRgrUlLcgCfg, &param->ulInfo, mBuf);
7324    return ROK;
7325 }
7326
7327
7328 \f
7329 /***********************************************************
7330 *
7331 *     Func : cmPkRgrCfg
7332 *
7333 *
7334 *     Desc : Basic Configuration structure at RRM
7335 *
7336 *
7337 *     Ret  : S16
7338 *
7339 *     Notes:
7340 *
7341 *     File  :
7342 *
7343 **********************************************************/
7344 #ifdef ANSI
7345 S16 cmPkRgrCfg
7346 (
7347 RgrCfg *param,
7348 Buffer *mBuf
7349 )
7350 #else
7351 S16 cmPkRgrCfg(param, mBuf)
7352 RgrCfg *param;
7353 Buffer *mBuf;
7354 #endif
7355 {
7356
7357
7358       switch(param->cfgType) {
7359          case RGR_LCG_CFG:
7360             CMCHKPK(cmPkRgrLcgCfg, &param->u.lcgCfg, mBuf);
7361             break;
7362          case RGR_LCH_CFG:
7363             CMCHKPK(cmPkRgrLchCfg, &param->u.lchCfg, mBuf);
7364             break;
7365          case RGR_UE_CFG:
7366             CMCHKPK(cmPkRgrUeCfg, &param->u.ueCfg, mBuf);
7367             break;
7368          case RGR_CELL_CFG:
7369             CMCHKPK(cmPkRgrCellCfg, &param->u.cellCfg, mBuf);
7370             break;
7371          case MAC_GNB_CFG:
7372             CMCHKPK(cmPkMacSchedGnbCfg, &param->u.schedGnbCfg, mBuf);
7373             break;
7374          default :
7375             return RFAILED;
7376       }
7377    CMCHKPK(oduUnpackUInt8, param->cfgType, mBuf);
7378    return ROK;
7379 }
7380
7381
7382 \f
7383 /***********************************************************
7384 *
7385 *     Func : cmUnpkRgrCfg
7386 *
7387 *
7388 *     Desc : Basic Configuration structure at RRM
7389 *
7390 *
7391 *     Ret  : S16
7392 *
7393 *     Notes:
7394 *
7395 *     File  :
7396 *
7397 **********************************************************/
7398 #ifdef ANSI
7399 S16 cmUnpkRgrCfg
7400 (
7401 RgrCfg *param,
7402 Buffer *mBuf
7403 )
7404 #else
7405 S16 cmUnpkRgrCfg(param, mBuf)
7406 RgrCfg *param;
7407 Buffer *mBuf;
7408 #endif
7409 {
7410
7411
7412    CMCHKUNPK(oduPackUInt8, &param->cfgType, mBuf);
7413       switch(param->cfgType) {
7414          case MAC_GNB_CFG:
7415             CMCHKUNPK(cmUnpkMacSchedGnbCfg, &param->u.schedGnbCfg, mBuf);
7416             break;
7417          case RGR_CELL_CFG:
7418             CMCHKUNPK(cmUnpkRgrCellCfg, &param->u.cellCfg, mBuf);
7419             break;
7420          case RGR_UE_CFG:
7421             CMCHKUNPK(cmUnpkRgrUeCfg, &param->u.ueCfg, mBuf);
7422             break;
7423          case RGR_LCH_CFG:
7424             CMCHKUNPK(cmUnpkRgrLchCfg, &param->u.lchCfg, mBuf);
7425             break;
7426          case RGR_LCG_CFG:
7427             CMCHKUNPK(cmUnpkRgrLcgCfg, &param->u.lcgCfg, mBuf);
7428             break;
7429          default :
7430             return RFAILED;
7431       }
7432    return ROK;
7433 }
7434
7435
7436 \f
7437 /***********************************************************
7438 *
7439 *     Func : cmPkRgrActvTime
7440 *
7441 *
7442 *     Desc : Activation time information
7443 *
7444 *
7445 *     Ret  : S16
7446 *
7447 *     Notes:
7448 *
7449 *     File  :
7450 *
7451 **********************************************************/
7452 #ifdef ANSI
7453 S16 cmPkRgrActvTime
7454 (
7455 RgrActvTime *param,
7456 Buffer *mBuf
7457 )
7458 #else
7459 S16 cmPkRgrActvTime(param, mBuf)
7460 RgrActvTime *param;
7461 Buffer *mBuf;
7462 #endif
7463 {
7464
7465
7466    CMCHKPK(cmPkLteTimingInfo, &param->actvTime, mBuf);
7467    CMCHKPK(oduUnpackUInt8, param->pres, mBuf);
7468    return ROK;
7469 }
7470
7471
7472 \f
7473 /***********************************************************
7474 *
7475 *     Func : cmUnpkRgrActvTime
7476 *
7477 *
7478 *     Desc : Activation time information
7479 *
7480 *
7481 *     Ret  : S16
7482 *
7483 *     Notes:
7484 *
7485 *     File  :
7486 *
7487 **********************************************************/
7488 #ifdef ANSI
7489 S16 cmUnpkRgrActvTime
7490 (
7491 RgrActvTime *param,
7492 Buffer *mBuf
7493 )
7494 #else
7495 S16 cmUnpkRgrActvTime(param, mBuf)
7496 RgrActvTime *param;
7497 Buffer *mBuf;
7498 #endif
7499 {
7500
7501
7502    CMCHKUNPK(oduPackUInt8, &param->pres, mBuf);
7503    CMCHKUNPK(cmUnpkLteTimingInfo, &param->actvTime, mBuf);
7504    return ROK;
7505 }
7506
7507
7508 \f
7509 /***********************************************************
7510 *
7511 *     Func : cmPkRgrCellRecfg
7512 *
7513 *
7514 *     Desc : Cell reconfiguration structure at RRM
7515 *
7516 *
7517 *     Ret  : S16
7518 *
7519 *     Notes:
7520 *
7521 *     File  :
7522 *
7523 **********************************************************/
7524 #ifdef ANSI
7525 S16 cmPkRgrCellRecfg
7526 (
7527 RgrCellRecfg *param,
7528 Buffer *mBuf
7529 )
7530 #else
7531 S16 cmPkRgrCellRecfg(param, mBuf)
7532 RgrCellRecfg *param;
7533 Buffer *mBuf;
7534 #endif
7535 {
7536
7537    CMCHKPK(cmPkRgrCellCntrlCmdCfg, &param->cntrlCmdCfg, mBuf);
7538    CMCHKPK(cmPkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
7539    CMCHKPK(oduUnpackUInt8, param->isDynCfiEnb, mBuf);
7540    CMCHKPK(oduUnpackUInt8, param->isAutoCfgModeEnb, mBuf);
7541    /* LTE_ADV_FLAG_REMOVED_START */
7542    CMCHKPK(cmPkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
7543    /* LTE_ADV_FLAG_REMOVED_END */
7544    CMCHKPK(oduUnpackUInt16, param->t300TmrVal, mBuf);
7545    /* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
7546 #ifdef RGR_SI_SCH
7547    CMCHKPK(cmPkRgrSiCfg, &param->siReCfg, mBuf);
7548 #endif /* RGR_SI_SCH */
7549    CMCHKPK(cmPkRgrDlfsCfg, &param->dlfsRecfg, mBuf);
7550    CMCHKPK(cmPkRgrRachCfg, &param->rachRecfg, mBuf);
7551    CMCHKPK(cmPkRgrSrsCfg, &param->srsRecfg, mBuf);
7552    CMCHKPK(cmPkRgrPucchCfg, &param->pucchRecfg, mBuf);
7553    CMCHKPK(cmPkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
7554    CMCHKPK(cmPkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
7555    CMCHKPK(cmPkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
7556    CMCHKPK(cmPkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
7557    CMCHKPK(cmPkRgrCfiCfg, &param->cfiRecfg, mBuf);
7558    CMCHKPK(cmPkRgrDlHqCfg, &param->dlHqRecfg, mBuf);
7559    CMCHKPK(cmPkRgrActvTime, &param->recfgActvTime, mBuf);
7560    CMCHKPK(oduUnpackUInt32, param->recfgTypes, mBuf);
7561    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7562    return ROK;
7563 }
7564
7565
7566 \f
7567 /***********************************************************
7568 *
7569 *     Func : cmUnpkRgrCellRecfg
7570 *
7571 *
7572 *     Desc : Cell reconfiguration structure at RRM
7573 *
7574 *
7575 *     Ret  : S16
7576 *
7577 *     Notes:
7578 *
7579 *     File  :
7580 *
7581 **********************************************************/
7582 #ifdef ANSI
7583 S16 cmUnpkRgrCellRecfg
7584 (
7585 RgrCellRecfg *param,
7586 Buffer *mBuf
7587 )
7588 #else
7589 S16 cmUnpkRgrCellRecfg(param, mBuf)
7590 RgrCellRecfg *param;
7591 Buffer *mBuf;
7592 #endif
7593 {
7594
7595
7596    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7597    CMCHKUNPK(oduPackUInt32, &param->recfgTypes, mBuf);
7598    CMCHKUNPK(cmUnpkRgrActvTime, &param->recfgActvTime, mBuf);
7599    CMCHKUNPK(cmUnpkRgrDlHqCfg, &param->dlHqRecfg, mBuf);
7600    CMCHKUNPK(cmUnpkRgrCfiCfg, &param->cfiRecfg, mBuf);
7601    CMCHKUNPK(cmUnpkRgrUlTrgCqiCfg, &param->trgUlCqi, mBuf);
7602    CMCHKUNPK(cmUnpkRgrDlCmnCodeRateCfg, &param->dlCmnCodeRate, mBuf);
7603    CMCHKUNPK(cmUnpkRgrPuschSubBandCfg, &param->puschSubBand, mBuf);
7604    CMCHKUNPK(cmUnpkRgrUlCmnCodeRateCfg, &param->ulCmnCodeRate, mBuf);
7605    CMCHKUNPK(cmUnpkRgrPucchCfg, &param->pucchRecfg, mBuf);
7606    CMCHKUNPK(cmUnpkRgrSrsCfg, &param->srsRecfg, mBuf);
7607    CMCHKUNPK(cmUnpkRgrRachCfg, &param->rachRecfg, mBuf);
7608    CMCHKUNPK(cmUnpkRgrDlfsCfg, &param->dlfsRecfg, mBuf);
7609    /* rgr_c_001.main_4-MOD-Modified for SI Enhancement. */
7610 #ifdef RGR_SI_SCH
7611    CMCHKUNPK(cmUnpkRgrSiCfg, &param->siReCfg, mBuf);
7612 #endif /* RGR_SI_SCH */
7613    CMCHKUNPK(oduPackUInt16, &param->t300TmrVal, mBuf);
7614    /* LTE_ADV_FLAG_REMOVED_START */
7615    CMCHKUNPK(cmUnpkRgrCellLteAdvancedFeatureCfg, &param->rgrLteAdvCfg, mBuf);
7616    /* LTE_ADV_FLAG_REMOVED_END */
7617    CMCHKUNPK(oduPackUInt8, &param->isAutoCfgModeEnb, mBuf);
7618    CMCHKUNPK(oduPackUInt8, &param->isDynCfiEnb, mBuf);
7619    CMCHKUNPK(cmUnpkRgrCellCsgParamCfg, &param->csgParamCfg, mBuf);
7620    CMCHKUNPK(cmUnpkRgrCellCntrlCmdCfg, &param->cntrlCmdCfg, mBuf);
7621
7622    return ROK;
7623 }
7624
7625
7626 \f
7627 /***********************************************************
7628 *
7629 *     Func : cmPkRgrUeRecfg
7630 *
7631 *
7632 *     Desc : UE reconfiguration info
7633 *
7634 *
7635 *     Ret  : S16
7636 *
7637 *     Notes:
7638 *
7639 *     File  :
7640 *
7641 **********************************************************/
7642 #ifdef ANSI
7643 S16 cmPkRgrUeRecfg
7644 (
7645 RgrUeRecfg *param,
7646 Buffer *mBuf
7647 )
7648 #else
7649 S16 cmPkRgrUeRecfg(param, mBuf)
7650 RgrUeRecfg *param;
7651 Buffer *mBuf;
7652 #endif
7653 {
7654
7655 #ifdef EMTC_ENABLE
7656    /* Note: As we add more members to emtcUeRecfg,
7657       create a new function for pkUnpk */
7658    CMCHKPK(oduUnpackUInt8, param->emtcUeRecfg.isHdFddEnbld, mBuf);
7659 #endif
7660    CMCHKPK(oduUnpackUInt8, param->csgMmbrSta, mBuf);
7661
7662    CMCHKPK(oduUnpackUInt32, param->accessStratumRls, mBuf);
7663 #ifdef LTE_ADV
7664    CMCHKPK(oduUnpackUInt8, param->simulAckNackCQIFormat3, mBuf);
7665    CMCHKPK(cmPkRgrUeSCellAckPucchCfg, &param->sCellAckN1ResCfg,mBuf);
7666    CMCHKPK(cmPkRgrUeSecCellInfo, &param->ueSCellCfgInfo,mBuf);
7667 #endif
7668    /* LTE_ADV_FLAG_REMOVED_START */
7669    CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isUeCellEdge, mBuf);
7670    CMCHKPK(oduUnpackUInt8, param->ueLteAdvCfg.isAbsUe, mBuf);
7671    CMCHKPK(oduUnpackUInt32, param->ueLteAdvCfg.pres, mBuf);
7672    /* LTE_ADV_FLAG_REMOVED_END */
7673    /*ccpu00130497: Removed the duplicate packing*/
7674 #ifdef TFU_UPGRADE
7675    CMCHKPK(cmPkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
7676 #endif
7677    /* rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
7678    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
7679 #ifdef RGR_CQI_REPT
7680    CMCHKPK(cmPkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
7681 #endif
7682
7683 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
7684    CMCHKPK(cmPkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
7685
7686 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
7687 #ifdef LTEMAC_HDFDD
7688    CMCHKPK(oduUnpackUInt8, param->isHdFddEnbld, mBuf);
7689 #endif
7690
7691 #ifdef TFU_UPGRADE
7692    CMCHKPK(cmPkRgrUeSrCfg, &param->srCfg, mBuf);
7693    CMCHKPK(cmPkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
7694    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->cqiCfg, mBuf);
7695 #endif
7696
7697    /*rgr_c_001.main_7 - Added support for SPS*/
7698    CMCHKPK(cmPkRgrUeSpsCfg, &param->ueSpsRecfg, mBuf);
7699    CMCHKPK(cmPkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
7700
7701    /* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
7702    CMCHKPK(oduUnpackUInt32, param->ueCatEnum, mBuf);
7703
7704    CMCHKPK(cmPkRgrCodeBookRstCfg, &param->ueCodeBookRstRecfg, mBuf);
7705    CMCHKPK(cmPkRgrUeMeasGapCfg, &param->ueMeasGapRecfg, mBuf);
7706    CMCHKPK(cmPkRgrUeCapCfg, &param->ueCapRecfg, mBuf);
7707    CMCHKPK(cmPkRgrUeAckNackRepCfg, &param->ueAckNackRecfg, mBuf);
7708    CMCHKPK(oduUnpackUInt8, param->isTtiBundlEnabled, mBuf);
7709 /*rgr_c_001.main_9 ADD added changes for DRX*/
7710
7711    /* Anshika - Pack only if DRX is enabled */
7712    if(TRUE == param->ueDrxRecfg.isDrxEnabled)
7713    {
7714       CMCHKPK(cmPkRgrUeDrxCfg, &param->ueDrxRecfg, mBuf);
7715    }
7716    CMCHKPK(oduUnpackUInt8, param->ueDrxRecfg.isDrxEnabled, mBuf); /* This has to be packed even if
7717                                                  DRX is disabled */
7718    CMCHKPK(cmPkRgrUeUlPwrCfg, &param->ueUlPwrRecfg, mBuf);
7719 #ifdef RGR_V1
7720    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
7721     * retxBSR-timer */
7722    CMCHKPK(cmPkRgrUeBsrTmrCfg, &param->ueBsrTmrRecfg, mBuf);
7723 #endif
7724    CMCHKPK(cmPkRgrUeTaTmrCfg, &param->ueTaTmrRecfg, mBuf);
7725    CMCHKPK(cmPkRgrUeQosCfg, &param->ueQosRecfg, mBuf);
7726    CMCHKPK(cmPkRgrUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
7727
7728 #ifndef TFU_UPGRADE
7729    CMCHKPK(cmPkRgrUePrdDlCqiCfg, &param->prdDlCqiRecfg, mBuf);
7730 #endif
7731
7732    CMCHKPK(cmPkRgrUeAprdDlCqiCfg, &param->aprdDlCqiRecfg, mBuf);
7733    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
7734    /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
7735    /* LTE_ADV_FLAG_REMOVED_START */
7736    /* KW fix for LTE_ADV */
7737    CMCHKPK(oduUnpackUInt32, param->ueRecfgTypes, mBuf);
7738    /* LTE_ADV_FLAG_REMOVED_END */
7739    CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
7740    CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
7741    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7742    return ROK;
7743 }
7744
7745
7746 \f
7747 /***********************************************************
7748 *
7749 *     Func : cmUnpkRgrUeRecfg
7750 *
7751 *
7752 *     Desc : UE reconfiguration info
7753 *
7754 *
7755 *     Ret  : S16
7756 *
7757 *     Notes:
7758 *
7759 *     File  :
7760 *
7761 **********************************************************/
7762 #ifdef ANSI
7763 S16 cmUnpkRgrUeRecfg
7764 (
7765 RgrUeRecfg *param,
7766 Buffer *mBuf
7767 )
7768 #else
7769 S16 cmUnpkRgrUeRecfg(param, mBuf)
7770 RgrUeRecfg *param;
7771 Buffer *mBuf;
7772 #endif
7773 {
7774    uint32_t tmpEnum;
7775
7776
7777    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7778    CMCHKUNPK(cmUnpkLteRnti, &param->oldCrnti, mBuf);
7779    CMCHKUNPK(cmUnpkLteRnti, &param->newCrnti, mBuf);
7780    /* LTE_ADV_FLAG_REMOVED_START */
7781    /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
7782    /* KW fix for LTE_ADV */
7783    CMCHKUNPK(oduPackUInt32, &param->ueRecfgTypes, mBuf);
7784    /* LTE_ADV_FLAG_REMOVED_END */
7785    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
7786
7787    CMCHKUNPK(cmUnpkRgrUeAprdDlCqiCfg, &param->aprdDlCqiRecfg, mBuf);
7788
7789 #ifndef TFU_UPGRADE
7790    CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, &param->prdDlCqiRecfg, mBuf);
7791 #endif
7792
7793    CMCHKUNPK(cmUnpkRgrUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
7794    CMCHKUNPK(cmUnpkRgrUeQosCfg, &param->ueQosRecfg, mBuf);
7795    CMCHKUNPK(cmUnpkRgrUeTaTmrCfg, &param->ueTaTmrRecfg, mBuf);
7796 #ifdef RGR_V1
7797    /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
7798     * retxBSR-timer */
7799    CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, &param->ueBsrTmrRecfg, mBuf);
7800 #endif
7801    CMCHKUNPK(cmUnpkRgrUeUlPwrCfg, &param->ueUlPwrRecfg, mBuf);
7802 /*rgr_c_001.main_9 ADD added changes for DRX*/
7803
7804    /* Anshika - Unpack only if DRX is enabled */
7805    CMCHKUNPK(oduPackUInt8, &param->ueDrxRecfg.isDrxEnabled, mBuf);
7806    if(TRUE == param->ueDrxRecfg.isDrxEnabled)
7807    {
7808       CMCHKUNPK(cmUnpkRgrUeDrxCfg, &param->ueDrxRecfg, mBuf);
7809    }
7810    CMCHKUNPK(oduPackUInt8, &param->isTtiBundlEnabled, mBuf);
7811    CMCHKUNPK(cmUnpkRgrUeAckNackRepCfg, &param->ueAckNackRecfg, mBuf);
7812    CMCHKUNPK(cmUnpkRgrUeCapCfg, &param->ueCapRecfg, mBuf);
7813    CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, &param->ueMeasGapRecfg, mBuf);
7814    CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, &param->ueCodeBookRstRecfg, mBuf);
7815 /* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
7816    CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
7817    param->ueCatEnum = (CmLteUeCategory) tmpEnum;
7818    CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, &param->ulTxAntSel, mBuf);
7819    /*rgr_c_001.main_7 - Added support for SPS*/
7820    CMCHKUNPK(cmUnpkRgrUeSpsCfg, &param->ueSpsRecfg, mBuf);
7821
7822 /* rgr_c_001.main_8. Added changes of TFU_UPGRADE */
7823 #ifdef TFU_UPGRADE
7824    CMCHKUNPK(cmUnpkRgrUePrdDlCqiCfg, &param->cqiCfg, mBuf);
7825    CMCHKUNPK(cmUnpkRgrUeUlSrsCfg, &param->srsCfg, mBuf);
7826    CMCHKUNPK(cmUnpkRgrUeSrCfg, &param->srCfg, mBuf);
7827 #endif
7828
7829 /*rgr_c_001.main_9 ADD added changes for HDFDD*/
7830 #ifdef LTEMAC_HDFDD
7831    CMCHKUNPK(oduPackUInt8, &param->isHdFddEnbld, mBuf);
7832 #endif
7833
7834    CMCHKUNPK(cmUnpkRgrUePuschDedCfg, &param->puschDedCfg, mBuf);
7835
7836 /* rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
7837    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
7838 #ifdef RGR_CQI_REPT
7839    CMCHKUNPK(cmUnpkRgrUeCqiReptCfg, &param->ueCqiReptCfg, mBuf);
7840 #endif
7841 #ifdef TFU_UPGRADE
7842    CMCHKUNPK(cmUnpkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
7843 #endif
7844
7845    /* LTE_ADV_FLAG_REMOVED_START */
7846    CMCHKUNPK(oduPackUInt32, &param->ueLteAdvCfg.pres, mBuf);
7847    CMCHKUNPK(oduPackUInt8, &param->ueLteAdvCfg.isAbsUe, mBuf);
7848    CMCHKUNPK(oduPackUInt8, &param->ueLteAdvCfg.isUeCellEdge, mBuf);
7849    /* LTE_ADV_FLAG_REMOVED_END */
7850 #ifdef LTE_ADV
7851    CMCHKUNPK(cmUnpkRgrUeSecCellInfo, &param->ueSCellCfgInfo,mBuf);
7852    CMCHKUNPK(cmUnpkRgrUeSCellAckPucchCfg, &param->sCellAckN1ResCfg,mBuf);
7853    CMCHKUNPK(oduPackUInt8, &param->simulAckNackCQIFormat3, mBuf);
7854 #endif
7855    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->accessStratumRls, mBuf);
7856
7857    CMCHKUNPK(oduPackUInt8, &param->csgMmbrSta, mBuf);
7858 #ifdef EMTC_ENABLE
7859    CMCHKPK(oduPackUInt8, &param->emtcUeRecfg.isHdFddEnbld, mBuf);
7860 #endif
7861
7862    return ROK;
7863 }
7864
7865
7866 \f
7867 /***********************************************************
7868 *
7869 *     Func : cmPkRgrLchRecfg
7870 *
7871 *
7872 *     Desc : Logical channel reconfiguration info for dedicated channels only
7873 *
7874 *
7875 *     Ret  : S16
7876 *
7877 *     Notes:
7878 *
7879 *     File  :
7880 *
7881 **********************************************************/
7882 #ifdef ANSI
7883 S16 cmPkRgrLchRecfg
7884 (
7885 RgrLchRecfg *param,
7886 Buffer *mBuf
7887 )
7888 #else
7889 S16 cmPkRgrLchRecfg(param, mBuf)
7890 RgrLchRecfg *param;
7891 Buffer *mBuf;
7892 #endif
7893 {
7894
7895 /*rgr_c_001.main_7 - Added support for SPS*/
7896    CMCHKPK(oduUnpackUInt8, param->lcgId, mBuf);
7897
7898    CMCHKPK(cmPkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
7899    CMCHKPK(cmPkRgrLchSpsCfg, &param->dlRecfg.dlSpsRecfg, mBuf);
7900
7901    CMCHKPK(cmPkRgrLchQosCfg, &param->dlRecfg.dlQos, mBuf);
7902    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
7903    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
7904    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7905    return ROK;
7906 }
7907
7908
7909 \f
7910 /***********************************************************
7911 *
7912 *     Func : cmUnpkRgrLchRecfg
7913 *
7914 *
7915 *     Desc : Logical channel reconfiguration info for dedicated channels only
7916 *
7917 *
7918 *     Ret  : S16
7919 *
7920 *     Notes:
7921 *
7922 *     File  :
7923 *
7924 **********************************************************/
7925 #ifdef ANSI
7926 S16 cmUnpkRgrLchRecfg
7927 (
7928 RgrLchRecfg *param,
7929 Buffer *mBuf
7930 )
7931 #else
7932 S16 cmUnpkRgrLchRecfg(param, mBuf)
7933 RgrLchRecfg *param;
7934 Buffer *mBuf;
7935 #endif
7936 {
7937
7938
7939    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
7940    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
7941    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
7942    CMCHKUNPK(cmUnpkRgrLchQosCfg, &param->dlRecfg.dlQos, mBuf);
7943       /*rgr_c_001.main_7 - Added support for SPs*/
7944    CMCHKUNPK(cmUnpkRgrLchSpsCfg, &param->dlRecfg.dlSpsRecfg, mBuf);
7945
7946    CMCHKUNPK(cmUnpkRgrUlLchQciCfg, &param->ulLchQciInfo, mBuf);
7947    CMCHKUNPK(oduPackUInt8, &param->lcgId, mBuf);
7948    return ROK;
7949 }
7950
7951
7952 #ifdef ANSI
7953 S16 cmPkRgrLcgRecfg
7954 (
7955 RgrLcgRecfg *param,
7956 Buffer *mBuf
7957 )
7958 #else
7959 S16 cmPkRgrLcgRecfg(param, mBuf)
7960 RgrLcgRecfg *param;
7961 Buffer *mBuf;
7962 #endif
7963 {
7964 #ifdef RG_UNUSED
7965    S32 i;
7966 #endif
7967
7968    CMCHKPK(oduUnpackUInt32, param->ulRecfg.mbr, mBuf);
7969    CMCHKPK(oduUnpackUInt32, param->ulRecfg.gbr, mBuf);
7970 #ifdef RG_UNUSED
7971    for (i = param->ulRecfg.numLch - 1; i >= 0; i--)
7972    {
7973       CMCHKPK(cmPkRgrUlLchCfg, &param->ulRecfg.lchUlCfg[i], mBuf);
7974    }
7975    CMCHKPK(oduUnpackUInt8, param->ulRecfg.numLch, mBuf);
7976 #endif
7977    CMCHKPK(oduUnpackUInt8, param->ulRecfg.lcgId, mBuf);
7978    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
7979    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
7980    return ROK;
7981 }
7982
7983
7984 #ifdef ANSI
7985 S16 cmUnpkRgrLcgRecfg
7986 (
7987 RgrLcgRecfg *param,
7988 Buffer *mBuf
7989 )
7990 #else
7991 S16 cmUnpkRgrLcgRecfg(param, mBuf)
7992 RgrLcgRecfg *param;
7993 Buffer *mBuf;
7994 #endif
7995 {
7996 #ifdef RG_UNUSED
7997    S32 i;
7998 #endif
7999
8000    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
8001    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
8002    CMCHKUNPK(oduPackUInt8, &param->ulRecfg.lcgId, mBuf);
8003
8004 #ifdef RG_UNUSED
8005    CMCHKUNPK(oduPackUInt8, &param->ulRecfg.numLch, mBuf);
8006    for (i = 0; i < param->ulRecfg.numLch; i++)
8007    {
8008       CMCHKUNPK(cmUnpkRgrUlLchCfg, &param->ulRecfg.lchUlCfg[i], mBuf);
8009    }
8010 #endif
8011    CMCHKUNPK(oduPackUInt32, &param->ulRecfg.gbr, mBuf);
8012    CMCHKUNPK(oduPackUInt32, &param->ulRecfg.mbr, mBuf);
8013
8014    return ROK;
8015 }
8016
8017
8018 \f
8019 /***********************************************************
8020 *
8021 *     Func : cmPkRgrRecfg
8022 *
8023 *
8024 *     Desc : Basic reconfiguration structure at RRM
8025 *
8026 *
8027 *     Ret  : S16
8028 *
8029 *     Notes:
8030 *
8031 *     File  :
8032 *
8033 **********************************************************/
8034 #ifdef ANSI
8035 S16 cmPkRgrRecfg
8036 (
8037 RgrRecfg *param,
8038 Buffer *mBuf
8039 )
8040 #else
8041 S16 cmPkRgrRecfg(param, mBuf)
8042 RgrRecfg *param;
8043 Buffer *mBuf;
8044 #endif
8045 {
8046
8047
8048       switch(param->recfgType) {
8049          case RGR_LCG_CFG:
8050             CMCHKPK(cmPkRgrLcgRecfg, &param->u.lcgRecfg, mBuf);
8051             break;
8052          case RGR_LCH_CFG:
8053             CMCHKPK(cmPkRgrLchRecfg, &param->u.lchRecfg, mBuf);
8054             break;
8055          case RGR_UE_CFG:
8056             CMCHKPK(cmPkRgrUeRecfg, &param->u.ueRecfg, mBuf);
8057             break;
8058          case RGR_CELL_CFG:
8059             CMCHKPK(cmPkRgrCellRecfg, &param->u.cellRecfg, mBuf);
8060             break;
8061          default :
8062             return RFAILED;
8063       }
8064    CMCHKPK(oduUnpackUInt8, param->recfgType, mBuf);
8065    return ROK;
8066 }
8067
8068
8069 \f
8070 /***********************************************************
8071 *
8072 *     Func : cmUnpkRgrRecfg
8073 *
8074 *
8075 *     Desc : Basic reconfiguration structure at RRM
8076 *
8077 *
8078 *     Ret  : S16
8079 *
8080 *     Notes:
8081 *
8082 *     File  :
8083 *
8084 **********************************************************/
8085 #ifdef ANSI
8086 S16 cmUnpkRgrRecfg
8087 (
8088 RgrRecfg *param,
8089 Buffer *mBuf
8090 )
8091 #else
8092 S16 cmUnpkRgrRecfg(param, mBuf)
8093 RgrRecfg *param;
8094 Buffer *mBuf;
8095 #endif
8096 {
8097
8098
8099    CMCHKUNPK(oduPackUInt8, &param->recfgType, mBuf);
8100       switch(param->recfgType) {
8101          case RGR_CELL_CFG:
8102             CMCHKUNPK(cmUnpkRgrCellRecfg, &param->u.cellRecfg, mBuf);
8103             break;
8104          case RGR_UE_CFG:
8105             CMCHKUNPK(cmUnpkRgrUeRecfg, &param->u.ueRecfg, mBuf);
8106             break;
8107          case RGR_LCH_CFG:
8108             CMCHKUNPK(cmUnpkRgrLchRecfg, &param->u.lchRecfg, mBuf);
8109             break;
8110          case RGR_LCG_CFG:
8111             CMCHKUNPK(cmUnpkRgrLcgRecfg, &param->u.lcgRecfg, mBuf);
8112             break;
8113          default :
8114             return RFAILED;
8115       }
8116    return ROK;
8117 }
8118
8119 #ifdef LTE_ADV
8120 /***********************************************************
8121 *
8122 *     Func : cmPkRgrUeDlSecCellRelInfo
8123 *
8124 *
8125 *     Desc : DL Secondary Cell information of the UE
8126 *
8127 *
8128 *     Ret  : S16
8129 *
8130 *     Notes:
8131 *
8132 *     File  :
8133 *
8134 **********************************************************/
8135 #ifdef ANSI
8136 S16 cmPkRgrUeDlSecCellRelInfo
8137 (
8138 RgrUeDlSecCellRelInfo *param,
8139 Buffer *mBuf
8140 )
8141 #else
8142 static S16 cmPkRgrUeDlSecCellRelInfo(param, mBuf)
8143 RgrUeDlSecCellRelInfo *param;
8144 Buffer *mBuf;
8145 #endif
8146 {
8147    CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
8148    CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
8149    return ROK;
8150 }
8151 \f
8152 /***********************************************************
8153 *
8154 *     Func : cmPkRgrUeSecCellRelInfo
8155 *
8156 *
8157 *     Desc : Secondary Cell Delete information of the UE
8158 *
8159 *
8160 *     Ret  : S16
8161 *
8162 *     Notes:
8163 *
8164 *     File  :
8165 *
8166 **********************************************************/
8167 #ifdef ANSI
8168 S16 cmPkRgrUeSecCellRelInfo
8169 (
8170 RgrUeSecCellRelInfo *param,
8171 Buffer *mBuf
8172 )
8173 #else
8174 S16 cmPkRgrUeSecCellRelInfo(param, mBuf)
8175 RgrUeSecCellRelInfo *param;
8176 Buffer *mBuf;
8177 #endif
8178 {
8179    S8 idx;
8180    for(idx = param->numSCells - 1; idx >= 0; idx--)
8181    {
8182       CMCHKPK(cmPkRgrUeDlSecCellRelInfo, &param->ueSCellRelDedCfg[(uint8_t)idx],mBuf);
8183    }
8184    CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
8185
8186    return ROK;
8187 }
8188 #endif
8189
8190 \f
8191 /***********************************************************
8192 *
8193 *     Func : cmPkRgrDel
8194 *
8195 *
8196 *     Desc : Basic Delete info for MAC
8197 *
8198 *
8199 *     Ret  : S16
8200 *
8201 *     Notes:
8202 *
8203 *     File  :
8204 *
8205 **********************************************************/
8206 #ifdef ANSI
8207 S16 cmPkRgrDel
8208 (
8209 RgrDel *param,
8210 Buffer *mBuf
8211 )
8212 #else
8213 S16 cmPkRgrDel(param, mBuf)
8214 RgrDel *param;
8215 Buffer *mBuf;
8216 #endif
8217 {
8218
8219
8220       switch(param->delType) {
8221          case RGR_LCG_CFG:
8222             CMCHKPK(oduUnpackUInt8, param->u.lcgDel.lcgId, mBuf);
8223             CMCHKPK(cmPkLteRnti, param->u.lcgDel.crnti, mBuf);
8224             CMCHKPK(cmPkLteCellId, param->u.lcgDel.cellId, mBuf);
8225          break;
8226          case RGR_LCH_CFG:
8227             CMCHKPK(oduUnpackUInt8, param->u.lchDel.lcgId, mBuf);
8228             CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
8229             CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
8230             CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
8231          break;
8232          case RGR_UE_CFG:
8233             CMCHKPK(cmPkLteRnti, param->u.ueDel.crnti, mBuf);
8234             CMCHKPK(cmPkLteCellId, param->u.ueDel.cellId, mBuf);
8235          break;
8236          case RGR_CELL_CFG:
8237             CMCHKPK(cmPkLteCellId, param->u.cellDel.cellId, mBuf);
8238          break;
8239 #ifdef LTE_ADV
8240          case RGR_SCELL_UE_CFG:
8241             CMCHKPK(cmPkRgrUeSecCellRelInfo, &param->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
8242             CMCHKPK(oduUnpackUInt32, param->u.ueScellRel.ueDelTypes, mBuf);
8243             CMCHKPK(cmPkLteRnti, param->u.ueScellRel.crnti, mBuf);
8244             CMCHKPK(cmPkLteCellId, param->u.ueScellRel.cellId, mBuf);
8245          break;
8246 #endif
8247          default :
8248             return RFAILED;
8249       }
8250    CMCHKPK(oduUnpackUInt8, param->delType, mBuf);
8251    return ROK;
8252 }
8253
8254
8255 #ifdef LTE_ADV
8256 \f
8257 /***********************************************************
8258 *
8259 *     Func : cmUnpkRgrUeDlSecCellRelInfo
8260 *
8261 *
8262 *     Desc : DL Secondary Cell information of the UE
8263 *
8264 *
8265 *     Ret  : S16
8266 *
8267 *     Notes:
8268 *
8269 *     File  :
8270 *
8271 **********************************************************/
8272 #ifdef ANSI
8273 S16 cmUnpkRgrUeDlSecCellRelInfo
8274 (
8275 RgrUeDlSecCellRelInfo *param,
8276 Buffer *mBuf
8277 )
8278 #else
8279 static S16 cmUnpkRgrUeDlSecCellRelInfo(param, mBuf)
8280 RgrUeDlSecCellRelInfo *param;
8281 Buffer *mBuf;
8282 #endif
8283 {
8284    CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
8285    CMCHKUNPK(oduPackUInt16, &param->sCellId, mBuf);
8286    return ROK;
8287 }
8288
8289 \f
8290 /***********************************************************
8291 *
8292 *     Func : cmUnpkRgrUeSecCellRelInfo
8293 *
8294 *
8295 *     Desc : Secondary Cell information of the UE
8296 *
8297 *
8298 *     Ret  : S16
8299 *
8300 *     Notes:
8301 *
8302 *     File  :
8303 *
8304 **********************************************************/
8305 #ifdef ANSI
8306 S16 cmUnpkRgrUeSecCellRelInfo
8307 (
8308 RgrUeSecCellRelInfo *param,
8309 Buffer *mBuf
8310 )
8311 #else
8312 S16 cmUnpkRgrUeSecCellRelInfo(param, mBuf)
8313 RgrUeSecCellRelInfo *param;
8314 Buffer *mBuf;
8315 #endif
8316 {
8317    uint8_t idx;
8318
8319    CMCHKUNPK(oduPackUInt8, &param->numSCells, mBuf);
8320
8321    for(idx = 0; idx < param->numSCells;idx++)
8322    {
8323       CMCHKUNPK(cmUnpkRgrUeDlSecCellRelInfo, &param->ueSCellRelDedCfg[idx],mBuf);
8324    }
8325    return ROK;
8326 }
8327 #endif
8328 \f
8329 /***********************************************************
8330 *
8331 *     Func : cmUnpkRgrDel
8332 *
8333 *
8334 *     Desc : Basic Delete info for MAC
8335 *
8336 *
8337 *     Ret  : S16
8338 *
8339 *     Notes:
8340 *
8341 *     File  :
8342 *
8343 **********************************************************/
8344 #ifdef ANSI
8345 S16 cmUnpkRgrDel
8346 (
8347 RgrDel *param,
8348 Buffer *mBuf
8349 )
8350 #else
8351 S16 cmUnpkRgrDel(param, mBuf)
8352 RgrDel *param;
8353 Buffer *mBuf;
8354 #endif
8355 {
8356
8357
8358    CMCHKUNPK(oduPackUInt8, &param->delType, mBuf);
8359       switch(param->delType) {
8360          case RGR_CELL_CFG:
8361             CMCHKUNPK(cmUnpkLteCellId, &param->u.cellDel.cellId, mBuf);
8362          break;
8363          case RGR_UE_CFG:
8364             CMCHKUNPK(cmUnpkLteCellId, &param->u.ueDel.cellId, mBuf);
8365             CMCHKUNPK(cmUnpkLteRnti, &param->u.ueDel.crnti, mBuf);
8366          break;
8367          case RGR_LCH_CFG:
8368             CMCHKUNPK(cmUnpkLteCellId, &param->u.lchDel.cellId, mBuf);
8369             CMCHKUNPK(cmUnpkLteRnti, &param->u.lchDel.crnti, mBuf);
8370             CMCHKUNPK(cmUnpkLteLcId, &param->u.lchDel.lcId, mBuf);
8371             CMCHKUNPK(oduPackUInt8, &param->u.lchDel.lcgId, mBuf);
8372          break;
8373          case RGR_LCG_CFG:
8374             CMCHKUNPK(cmUnpkLteCellId, &param->u.lcgDel.cellId, mBuf);
8375             CMCHKUNPK(cmUnpkLteRnti, &param->u.lcgDel.crnti, mBuf);
8376             CMCHKUNPK(oduPackUInt8, &param->u.lcgDel.lcgId, mBuf);
8377          break;
8378 #ifdef LTE_ADV
8379          case RGR_SCELL_UE_CFG:
8380             CMCHKUNPK(cmUnpkLteCellId, &param->u.ueScellRel.cellId, mBuf);
8381             CMCHKUNPK(cmUnpkLteRnti, &param->u.ueScellRel.crnti, mBuf);
8382             CMCHKUNPK(oduPackUInt32, &param->u.ueScellRel.ueDelTypes, mBuf);
8383             CMCHKUNPK(cmUnpkRgrUeSecCellRelInfo, &param->u.ueScellRel.ueSCellRelCfgInfo, mBuf);
8384          break;
8385 #endif
8386          default :
8387             return RFAILED;
8388       }
8389    return ROK;
8390 }
8391 /***********************************************************
8392 *
8393 *     Func : cmPkRgrSonPrbCfg
8394 *
8395 *
8396 *     Desc : SON PRB Configuration info for MAC
8397 *
8398 *
8399 *     Ret  : S16
8400 *
8401 *     Notes:
8402 *
8403 *     File  :
8404 *
8405 **********************************************************/
8406 #ifdef ANSI
8407 S16 cmPkRgrSonPrbCfg
8408 (
8409 RgrPrbCfg *param,
8410 Buffer *mBuf
8411 )
8412 #else
8413 S16 cmPkRgrSonPrbCfg(param, mBuf)
8414 RgrPrbCfg *param;
8415 Buffer *mBuf;
8416 #endif
8417 {
8418    S32 count;
8419    for(count = RGR_SCH_MAX_PA_PER_PRB - 1; count >= 0; count --)
8420    {
8421       CMCHKPK(oduUnpackUInt32, param->paLevelPerPrb[count], mBuf);
8422    }
8423    for(count = param->numCellCentreUEs - 1; count >= 0; count --)
8424    {
8425       CMCHKPK(cmPkLteRnti, param->cellCentreUe[count], mBuf);
8426    }
8427    for(count = param->numCellEdgeUEs - 1; count >= 0; count --)
8428    {
8429       CMCHKPK(cmPkLteRnti, param->cellEdgeUe[count], mBuf);
8430    }
8431    CMCHKPK(oduUnpackUInt8, param->numCellCentreUEs, mBuf);
8432    CMCHKPK(oduUnpackUInt8, param->numCellEdgeUEs, mBuf);
8433    CMCHKPK(oduUnpackUInt8, param->isSonIcicEnable, mBuf);
8434    return ROK;
8435 }
8436
8437 /***********************************************************
8438 *
8439 *     Func : cmUnpkRgrSon
8440 *
8441 *
8442 *     Desc : SON configuration info for MAC
8443 *
8444 *
8445 *     Ret  : S16
8446 *
8447 *     Notes:
8448 *
8449 *     File  :
8450 *
8451 **********************************************************/
8452 #ifdef ANSI
8453 S16 cmUnpkRgrSonPrbCfg
8454 (
8455 RgrPrbCfg   *param,
8456 Buffer      *mBuf
8457 )
8458 #else
8459 S16 cmUnpkRgrSonPrbCfg(param, mBuf)
8460 RgrPrbCfg   *param;
8461 Buffer      *mBuf;
8462 #endif
8463 {
8464    S32   count;
8465    CMCHKUNPK(oduPackUInt8, &param->isSonIcicEnable, mBuf);
8466    CMCHKUNPK(oduPackUInt8, &param->numCellEdgeUEs, mBuf);
8467    CMCHKUNPK(oduPackUInt8, &param->numCellCentreUEs, mBuf);
8468    for (count = 0; count < param->numCellEdgeUEs; count++)
8469    {
8470       CMCHKUNPK(cmUnpkLteRnti, &param->cellEdgeUe[count], mBuf);
8471    }
8472    for (count = 0; count < param->numCellCentreUEs; count++)
8473    {
8474       CMCHKUNPK(cmUnpkLteRnti, &param->cellCentreUe[count], mBuf);
8475    }
8476    for(count = 0; count < RGR_SCH_MAX_PA_PER_PRB; count ++)
8477    {
8478       CMCHKUNPK(oduPackUInt32,(uint32_t *) &param->paLevelPerPrb[count], mBuf);
8479    }
8480    return ROK;
8481 }
8482 /***********************************************************
8483 *
8484 *     Func : cmPkRgrSonCfg
8485 *
8486 *
8487 *     Desc : SON Configuration info for MAC
8488 *
8489 *
8490 *     Ret  : S16
8491 *
8492 *     Notes:
8493 *
8494 *     File  :
8495 *
8496 **********************************************************/
8497 #ifdef ANSI
8498 S16 cmPkRgrSonCfg
8499 (
8500 RgrSonCfg *param,
8501 Buffer *mBuf
8502 )
8503 #else
8504 S16 cmPkRgrSonCfg(param, mBuf)
8505 RgrSonCfg *param;
8506 Buffer *mBuf;
8507 #endif
8508 {
8509
8510    switch(param->cfgType)
8511    {
8512       case RGR_SON_PRB_CFG :
8513       CMCHKPK(cmPkRgrSonPrbCfg, &param->u.prbCfg, mBuf);
8514       break;
8515       default :
8516       return RFAILED;
8517    }
8518    CMCHKPK(oduUnpackUInt32, param->cfgType, mBuf);
8519    return ROK;
8520 }
8521
8522 /***********************************************************
8523 *
8524 *     Func : cmUnpkRgrSon
8525 *
8526 *
8527 *     Desc : SON configuration info for MAC
8528 *
8529 *
8530 *     Ret  : S16
8531 *
8532 *     Notes:
8533 *
8534 *     File  :
8535 *
8536 **********************************************************/
8537 #ifdef ANSI
8538 S16 cmUnpkRgrSonCfg
8539 (
8540 RgrSonCfg   *param,
8541 Buffer      *mBuf
8542 )
8543 #else
8544 S16 cmUnpkRgrSonCfg(param, mBuf)
8545 RgrSonCfg   *param;
8546 Buffer      *mBuf;
8547 #endif
8548 {
8549
8550    CMCHKUNPK(oduPackUInt32, (uint32_t *)&param->cfgType, mBuf);
8551    switch(param->cfgType)
8552    {
8553       case RGR_SON_PRB_CFG :
8554       {
8555          CMCHKUNPK(cmUnpkRgrSonPrbCfg, &param->u.prbCfg, mBuf);
8556          break;
8557          default :
8558          return RFAILED;
8559       }
8560    }
8561    return ROK;
8562 }
8563
8564 \f
8565 /***********************************************************
8566 *
8567 *     Func : cmPkRgrRst
8568 *
8569 *
8570 *     Desc : UE RESET info for MAC
8571 *
8572 *
8573 *     Ret  : S16
8574 *
8575 *     Notes:
8576 *
8577 *     File  :
8578 *
8579 **********************************************************/
8580 #ifdef ANSI
8581 S16 cmPkRgrRst
8582 (
8583 RgrRst *param,
8584 Buffer *mBuf
8585 )
8586 #else
8587 S16 cmPkRgrRst(param, mBuf)
8588 RgrRst *param;
8589 Buffer *mBuf;
8590 #endif
8591 {
8592
8593
8594    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
8595    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
8596    return ROK;
8597 }
8598
8599
8600 \f
8601 /***********************************************************
8602 *
8603 *     Func : cmUnpkRgrRst
8604 *
8605 *
8606 *     Desc : UE RESET info for MAC
8607 *
8608 *
8609 *     Ret  : S16
8610 *
8611 *     Notes:
8612 *
8613 *     File  :
8614 *
8615 **********************************************************/
8616 #ifdef ANSI
8617 S16 cmUnpkRgrRst
8618 (
8619 RgrRst *param,
8620 Buffer *mBuf
8621 )
8622 #else
8623 S16 cmUnpkRgrRst(param, mBuf)
8624 RgrRst *param;
8625 Buffer *mBuf;
8626 #endif
8627 {
8628
8629
8630    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
8631    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
8632    return ROK;
8633 }
8634 #ifdef LTE_ADV
8635 /***********************************************************
8636 *
8637 *     Func : cmUnPkRgrSCellActDeactInfo
8638 *
8639 *
8640 *     Desc : SCell Activation information of the UE
8641 *
8642 *
8643 *     Ret  : S16
8644 *
8645 *     Notes:
8646 *
8647 *     File  :
8648 *
8649 **********************************************************/
8650 #ifdef ANSI
8651 static S16 cmUnPkRgrSCellActDeactInfo
8652 (
8653 RgrSCellActDeactInfo *param,
8654 Buffer *mBuf
8655 )
8656 #else
8657 static S16 cmUnPkRgrSCellActInfo(param, mBuf)
8658 RgrSCellActDeactInfo *param;
8659 Buffer *mBuf;
8660 #endif
8661 {
8662
8663    CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
8664    return ROK;
8665 }
8666
8667 /***********************************************************
8668 *
8669 *     Func : cmUnPkRgrSCellActDeactEvnt
8670 *
8671 *
8672 *     Desc : SCell Activation Configuration structure to SCH
8673 *
8674 *
8675 *     Ret  : S16
8676 *
8677 *     Notes:
8678 *
8679 *     File  :
8680 *
8681 **********************************************************/
8682 #ifdef ANSI
8683 S16 cmUnPkRgrSCellActDeactEvnt
8684 (
8685 RgrSCellActDeactEvnt *param,
8686 Buffer *mBuf
8687 )
8688 #else
8689 S16 cmUnPkRgrSCellActDeactEvnt(param, mBuf)
8690 RgrSCellActDeactEvnt *param;
8691 Buffer *mBuf;
8692 #endif
8693 {
8694
8695    uint8_t idx;
8696
8697    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
8698    CMCHKUNPK(oduPackUInt8, &param->numOfSCells, mBuf);
8699
8700    for(idx = 0; idx < param->numOfSCells;idx++)
8701    {
8702       CMCHKUNPK(cmUnPkRgrSCellActDeactInfo, &param->sCellActDeactInfo[idx],mBuf);
8703    }
8704
8705    return ROK;
8706 }
8707
8708
8709 /***********************************************************
8710 *
8711 *     Func : cmPkRgrSCellActInfo
8712 *
8713 *
8714 *     Desc : SCell Activation information of the UE
8715 *
8716 *
8717 *     Ret  : S16
8718 *
8719 *     Notes:
8720 *
8721 *     File  :
8722 *
8723 **********************************************************/
8724 #ifdef ANSI
8725 static S16 cmPkRgrSCellActDeactInfo
8726 (
8727 RgrSCellActDeactInfo *param,
8728 Buffer *mBuf
8729 )
8730 #else
8731 static S16 cmPkRgrSCellActDeactInfo(param, mBuf)
8732 RgrSCellActDeactInfo *param;
8733 Buffer *mBuf;
8734 #endif
8735 {
8736
8737    CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
8738
8739    return ROK;
8740 }
8741
8742 /***********************************************************
8743 *
8744 *     Func : cmPkRgrSCellActDeactEvnt
8745 *
8746 *
8747 *     Desc : Basic Configuration structure at SCH
8748 *
8749 *
8750 *     Ret  : S16
8751 *
8752 *     Notes:
8753 *
8754 *     File  :
8755 *
8756 **********************************************************/
8757 #ifdef ANSI
8758 S16 cmPkRgrSCellActDeactEvnt
8759 (
8760 RgrSCellActDeactEvnt *param,
8761 Buffer *mBuf
8762 )
8763 #else
8764 S16 cmPkRgrSCellActDeactEvnt(param, mBuf)
8765 RgrSCellActDeactEvnt *param;
8766 Buffer *mBuf;
8767 #endif
8768 {
8769
8770
8771    S8 idx;
8772    for(idx = param->numOfSCells - 1; idx >= 0; idx--)
8773    {
8774       CMCHKPK(cmPkRgrSCellActDeactInfo, &param->sCellActDeactInfo[(uint8_t)idx], mBuf);
8775    }
8776
8777    CMCHKPK(oduUnpackUInt8, param->numOfSCells, mBuf);
8778    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
8779
8780    return ROK;
8781 }
8782
8783
8784 #endif /* LTE_ADV */
8785 \f
8786 /***********************************************************
8787 *
8788 *     Func : cmPkRgrCfgReqInfo
8789 *
8790 *
8791 *     Desc : Basic RGR configuration/reconfiguration info at RRM
8792 *
8793 *
8794 *     Ret  : S16
8795 *
8796 *     Notes:
8797 *
8798 *     File  :
8799 *
8800 **********************************************************/
8801 #ifdef ANSI
8802 S16 cmPkRgrCfgReqInfo
8803 (
8804 RgrCfgReqInfo *param,
8805 Buffer *mBuf
8806 )
8807 #else
8808 S16 cmPkRgrCfgReqInfo(param, mBuf)
8809 RgrCfgReqInfo *param;
8810 Buffer *mBuf;
8811 #endif
8812 {
8813
8814
8815       switch(param->action) {
8816          case RGR_SON_CFG:
8817             CMCHKPK(cmPkRgrSonCfg, &param->u.sonCfg, mBuf);
8818             break;
8819          case RGR_RESET:
8820             CMCHKPK(cmPkRgrRst, &param->u.rstInfo, mBuf);
8821             break;
8822          case RGR_DELETE:
8823             CMCHKPK(cmPkRgrDel, &param->u.delInfo, mBuf);
8824             break;
8825          case RGR_RECONFIG:
8826             CMCHKPK(cmPkRgrRecfg, &param->u.recfgInfo, mBuf);
8827             break;
8828          case SCH_CONFIG:
8829             CMCHKPK(cmPkRgrCfg, &param->u.cfgInfo, mBuf);
8830             break;
8831 #ifdef LTE_ADV
8832          case RGR_SCELL_ACT:
8833          case RGR_SCELL_DEACT:
8834          case RGR_SCELL_READY:
8835             CMCHKPK(cmPkRgrSCellActDeactEvnt, &param->u.sCellActDeactEvnt, mBuf);
8836             break;
8837 #endif
8838          default :
8839             return RFAILED;
8840       }
8841    CMCHKPK(oduUnpackUInt8, param->action, mBuf);
8842    return ROK;
8843 }
8844
8845
8846 \f
8847 /***********************************************************
8848 *
8849 *     Func : cmUnpkRgrCfgReqInfo
8850 *
8851 *
8852 *     Desc : Basic RGR configuration/reconfiguration info at RRM
8853 *
8854 *
8855 *     Ret  : S16
8856 *
8857 *     Notes:
8858 *
8859 *     File  :
8860 *
8861 **********************************************************/
8862 #ifdef ANSI
8863 S16 cmUnpkRgrCfgReqInfo
8864 (
8865 RgrCfgReqInfo *param,
8866 Buffer *mBuf
8867 )
8868 #else
8869 S16 cmUnpkRgrCfgReqInfo(param, mBuf)
8870 RgrCfgReqInfo *param;
8871 Buffer *mBuf;
8872 #endif
8873 {
8874
8875
8876    CMCHKUNPK(oduPackUInt8, &param->action, mBuf);
8877       switch(param->action) {
8878          case SCH_CONFIG:
8879             CMCHKUNPK(cmUnpkRgrCfg, &param->u.cfgInfo, mBuf);
8880             break;
8881          case RGR_RECONFIG:
8882             CMCHKUNPK(cmUnpkRgrRecfg, &param->u.recfgInfo, mBuf);
8883             break;
8884          case RGR_DELETE:
8885             CMCHKUNPK(cmUnpkRgrDel, &param->u.delInfo, mBuf);
8886             break;
8887          case RGR_RESET:
8888             CMCHKUNPK(cmUnpkRgrRst, &param->u.rstInfo, mBuf);
8889             break;
8890          case RGR_SON_CFG:
8891             CMCHKUNPK(cmUnpkRgrSonCfg, &param->u.sonCfg, mBuf);
8892             break;
8893 #ifdef LTE_ADV
8894          case RGR_SCELL_ACT:
8895          case RGR_SCELL_DEACT:
8896          case RGR_SCELL_READY:
8897             CMCHKUNPK(cmUnPkRgrSCellActDeactEvnt, &param->u.sCellActDeactEvnt, mBuf);
8898             break;
8899 #endif /* LTE_ADV */
8900          default :
8901             return RFAILED;
8902       }
8903    return ROK;
8904 }
8905 #ifdef RGR_V1
8906 /* rgr_c_001.main_5: ccpu00112398: Added periodicBSR-timer and
8907  * retxBSR-timer */
8908 /***********************************************************
8909 *
8910 *     Func : cmPkRgrUeBsrTmrCfg
8911 *
8912 *
8913 *     Desc : BSR timer configuration per UE
8914 *
8915 *
8916 *     Ret  : S16
8917 *
8918 *     Notes:
8919 *
8920 *     File  :
8921 *
8922 **********************************************************/
8923 #ifdef ANSI
8924 S16 cmPkRgrUeBsrTmrCfg
8925 (
8926 RgrUeBsrTmrCfg *param,
8927 Buffer *mBuf
8928 )
8929 #else
8930 S16 cmPkRgrUeBsrTmrCfg(param, mBuf)
8931 RgrUeBsrTmrCfg *param;
8932 Buffer *mBuf;
8933 #endif
8934 {
8935
8936
8937    CMCHKPK(oduUnpackUInt16, param->prdBsrTmr, mBuf);
8938    CMCHKPK(oduUnpackUInt16, param->retxBsrTmr, mBuf);
8939    CMCHKPK(oduUnpackUInt8, param->isPrdBsrTmrPres, mBuf);
8940    return ROK;
8941 }
8942
8943 /***********************************************************
8944 *
8945 *     Func : cmUnpkRgrUeBsrTmrCfg
8946 *
8947 *
8948 *     Desc : BSR timer configuration per UE
8949 *
8950 *
8951 *     Ret  : S16
8952 *
8953 *     Notes:
8954 *
8955 *     File  :
8956 *
8957 **********************************************************/
8958 #ifdef ANSI
8959 S16 cmUnpkRgrUeBsrTmrCfg
8960 (
8961 RgrUeBsrTmrCfg *param,
8962 Buffer *mBuf
8963 )
8964 #else
8965 S16 cmUnpkRgrUeBsrTmrCfg(param, mBuf)
8966 RgrUeBsrTmrCfg *param;
8967 Buffer *mBuf;
8968 #endif
8969 {
8970
8971
8972    CMCHKUNPK(oduPackUInt8, &param->isPrdBsrTmrPres, mBuf);
8973    CMCHKUNPK(oduPackUInt16, &param->retxBsrTmr, mBuf);
8974    CMCHKUNPK(oduPackUInt16, &param->prdBsrTmr, mBuf);
8975    return ROK;
8976 }
8977 #endif /* RGR_V1 */
8978 /* rgr_c_001.main_4-ADD-Added for SI Enhancement. */
8979 #ifdef RGR_SI_SCH
8980 /***********************************************************
8981 *
8982 *     Func : cmPkRgrSiCfgReq
8983 *
8984 *
8985 *     Desc : SI Configuration Request from RRM to MAC for
8986 *            configuring SI
8987 *
8988 *
8989 *     Ret  : S16
8990 *
8991 *     Notes:
8992 *
8993 *     File  :
8994 *
8995 **********************************************************/
8996 #ifdef ANSI
8997 S16 cmPkRgrSiCfgReq
8998 (
8999 Pst* pst,
9000 SpId spId,
9001 RgrCfgTransId transId,
9002 RgrSiCfgReqInfo * cfgReqInfo
9003 )
9004 #else
9005 S16 cmPkRgrSiCfgReq(pst, spId, transId, cfgReqInfo)
9006 Pst* pst;
9007 SpId spId;
9008 RgrCfgTransId transId;
9009 RgrSiCfgReqInfo * cfgReqInfo;
9010 #endif
9011 {
9012    Buffer *mBuf = NULLP;
9013
9014
9015    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
9016    {
9017 #if (ERRCLASS & ERRCLS_ADD_RES)
9018       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9019          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9020          (ErrVal)ERGR045, (ErrVal)0, "Packing failed");
9021 #endif
9022       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
9023                  sizeof(RgrSiCfgReqInfo));
9024       return RFAILED;
9025    }
9026    if (cmPkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
9027 #if (ERRCLASS & ERRCLS_ADD_RES)
9028       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9029             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9030             (ErrVal)ERGR046, (ErrVal)0, "Packing failed");
9031 #endif
9032       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
9033                 sizeof(RgrSiCfgReqInfo));
9034       SPutMsg(mBuf);
9035       return RFAILED;
9036    }
9037    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
9038 #if (ERRCLASS & ERRCLS_ADD_RES)
9039       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9040          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9041          (ErrVal)ERGR047, (ErrVal)0, "Packing failed");
9042 #endif
9043       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
9044                sizeof(RgrSiCfgReqInfo));
9045       SPutMsg(mBuf);
9046       return RFAILED;
9047    }
9048    if (SPkS16(spId, mBuf) != ROK) {
9049 #if (ERRCLASS & ERRCLS_ADD_RES)
9050       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9051          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9052          (ErrVal)ERGR048, (ErrVal)0, "Packing failed");
9053 #endif
9054       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
9055                sizeof(RgrSiCfgReqInfo));
9056       SPutMsg(mBuf);
9057       return RFAILED;
9058    }
9059    if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
9060                sizeof(RgrSiCfgReqInfo)) != ROK) {
9061 #if (ERRCLASS & ERRCLS_ADD_RES)
9062       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9063             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9064             (ErrVal)ERGR049, (ErrVal)0, "Packing failed");
9065 #endif
9066       SPutMsg(mBuf);
9067       return RFAILED;
9068    }
9069
9070    pst->event = (Event) EVTRGRSICFGREQ;
9071    return (SPstTsk(pst,mBuf));
9072 }
9073 \f
9074 /***********************************************************
9075 *
9076 *     Func : cmUnpkRgrSiCfgReq
9077 *
9078 *
9079 *     Desc : SI Configuration Request from RRM to MAC for
9080 *     configuring SI
9081 *
9082 *
9083 *     Ret  : S16
9084 *
9085 *     Notes:
9086 *
9087 *     File  :
9088 *
9089 **********************************************************/
9090 #ifdef ANSI
9091 S16 cmUnpkRgrSiCfgReq
9092 (
9093 RgrSiCfgReq func,
9094 Pst *pst,
9095 Buffer *mBuf
9096 )
9097 #else
9098 S16 cmUnpkRgrSiCfgReq(func, pst, mBuf)
9099 RgrSiCfgReq func;
9100 Pst *pst;
9101 Buffer *mBuf;
9102 #endif
9103 {
9104    SpId spId;
9105    RgrCfgTransId transId;
9106    RgrSiCfgReqInfo *cfgReqInfo;
9107
9108
9109    if (SUnpkS16(&spId, mBuf) != ROK) {
9110       SPutMsg(mBuf);
9111 #if (ERRCLASS & ERRCLS_ADD_RES)
9112       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9113          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9114          (ErrVal)ERGR050, (ErrVal)0, "Packing failed");
9115 #endif
9116       return RFAILED;
9117    }
9118    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
9119       SPutMsg(mBuf);
9120 #if (ERRCLASS & ERRCLS_ADD_RES)
9121       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9122          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9123          (ErrVal)ERGR051, (ErrVal)0, "Packing failed");
9124 #endif
9125       return RFAILED;
9126    }
9127    if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo,
9128             sizeof(RgrSiCfgReqInfo))) != ROK) {
9129 #if (ERRCLASS & ERRCLS_ADD_RES)
9130       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9131             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9132             (ErrVal)ERGR052, (ErrVal)0, "Packing failed");
9133 #endif
9134       SPutMsg(mBuf);
9135       return RFAILED;
9136    }
9137    memset(cfgReqInfo, 0, sizeof(RgrSiCfgReqInfo));
9138    if (pst->selector == ODU_SELECTOR_LC)
9139       if (cmUnpkRgrSiCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
9140          SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo,
9141                           sizeof(RgrSiCfgReqInfo));
9142          SPutMsg(mBuf);
9143 #if (ERRCLASS & ERRCLS_ADD_RES)
9144          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9145                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9146                (ErrVal)ERGR053, (ErrVal)0, "Packing failed");
9147 #endif
9148          return RFAILED;
9149       }
9150    SPutMsg(mBuf);
9151
9152    return ((*func)(pst, spId, transId, cfgReqInfo));
9153 }
9154
9155 /***********************************************************
9156 *
9157 *     Func : cmPkRgrSiCfgReqInfo
9158 *
9159 *
9160 *     Desc : Basic SI configuration/reconfiguration info at RRM
9161 *
9162 *
9163 *     Ret  : S16
9164 *
9165 *     Notes:
9166 *
9167 *     File  :
9168 *
9169 **********************************************************/
9170 #ifdef ANSI
9171 S16 cmPkRgrSiCfgReqInfo
9172 (
9173 RgrSiCfgReqInfo *param,
9174 Buffer *mBuf
9175 )
9176 #else
9177 S16 cmPkRgrSiCfgReqInfo(param, mBuf)
9178 RgrSiCfgReqInfo *param;
9179 Buffer *mBuf;
9180 #endif
9181 {
9182   /* ccpu00111328: S16 is renamed as MsgLen */
9183    MsgLen msgLen;
9184
9185
9186    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
9187    CMCHKPK(SPkS32, param->cfgType, mBuf);
9188    CMCHKPK(oduUnpackUInt8, param->siId, mBuf);
9189
9190    if(NULLP != param->pdu)
9191    {
9192       if (SFndLenMsg(param->pdu, &msgLen) != ROK)
9193          return RFAILED;
9194       if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
9195          return RFAILED;
9196       SPutMsg(param->pdu);
9197       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
9198    }
9199    /*ccpu00140789*/
9200    else
9201    {
9202       CMCHKPK(cmPkMsgLen, 0, mBuf);
9203    }
9204
9205    return ROK;
9206 }
9207 \f
9208 /***********************************************************
9209 *
9210 *     Func : cmUnpkRgrSiCfgReqInfo
9211 *
9212 *
9213 *     Desc : Basic SI configuration/reconfiguration info at RRM
9214 *
9215 *
9216 *     Ret  : S16
9217 *
9218 *     Notes:
9219 *
9220 *     File  :
9221 *
9222 **********************************************************/
9223 #ifdef ANSI
9224 S16 cmUnpkRgrSiCfgReqInfo
9225 (
9226 RgrSiCfgReqInfo *param,
9227 Buffer *mBuf
9228 )
9229 #else
9230 S16 cmUnpkRgrSiCfgReqInfo(param, mBuf)
9231 RgrSiCfgReqInfo *param;
9232 Buffer *mBuf;
9233 #endif
9234 {
9235    MsgLen  msgLen, totalMsgLen;
9236    /*Merge from Mohit Changes*/
9237    S32    cfgType;
9238
9239
9240    SFndLenMsg(mBuf, &msgLen);
9241    if(msgLen > 0)
9242    {
9243       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
9244       /*ccpu00140789*/
9245       if(msgLen > 0)
9246       {
9247          if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
9248             return RFAILED;
9249          if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
9250             return RFAILED;
9251       }
9252       else
9253       {
9254          param->pdu = NULLP;
9255       }
9256    }
9257
9258    CMCHKUNPK(oduPackUInt8, &param->siId, mBuf);
9259    /*CMCHKUNPK(SUnpkS32, (S32 *)&param->cfgType, mBuf);*/
9260    /*Merge from Mohit Changes*/
9261    CMCHKUNPK(SUnpkS32,(S32 *)&cfgType, mBuf);
9262    param->cfgType = (RgrSiCfgType) cfgType;
9263    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
9264
9265    return ROK;
9266 }
9267
9268
9269 \f
9270 /***********************************************************
9271 *
9272 *     Func : cmPkRgrWarningSiCfgReq
9273 *
9274 *
9275 *     Desc : SI Configuration Request from RRM to MAC for
9276 *            configuring warning SI
9277 *
9278 *
9279 *     Ret  : S16
9280 *
9281 *     Notes:
9282 *
9283 *     File  :
9284 *
9285 **********************************************************/
9286 #ifdef ANSI
9287 S16 cmPkRgrWarningSiCfgReq
9288 (
9289 Pst* pst,
9290 SpId spId,
9291 RgrCfgTransId transId,
9292 RgrWarningSiCfgReqInfo * warningSiCfgReqInfo
9293 )
9294 #else
9295 S16 cmPkRgrWarningSiCfgReq(pst, spId, transId, warningSiCfgReqInfo)
9296 Pst* pst;
9297 SpId spId;
9298 RgrCfgTransId transId;
9299 RgrWarningSiCfgReqInfo * warningSiCfgReqInfo;
9300 #endif
9301 {
9302    Buffer *mBuf = NULLP;
9303
9304
9305    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
9306    {
9307 #if (ERRCLASS & ERRCLS_ADD_RES)
9308       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9309          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9310          (ErrVal)ERGR061, (ErrVal)0, "Packing failed");
9311 #endif
9312       SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
9313                  sizeof(RgrWarningSiCfgReqInfo));
9314       return RFAILED;
9315    }
9316
9317    if (cmPkRgrWarningSiCfgReqInfo(pst, warningSiCfgReqInfo, mBuf) != ROK)
9318    {
9319 #if (ERRCLASS & ERRCLS_ADD_RES)
9320       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9321             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9322             (ErrVal)ERGR062, (ErrVal)0, "Packing failed");
9323 #endif
9324       SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
9325                 sizeof(RgrWarningSiCfgReqInfo));
9326       SPutMsg(mBuf);
9327       return RFAILED;
9328    }
9329
9330    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK)
9331    {
9332 #if (ERRCLASS & ERRCLS_ADD_RES)
9333       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9334          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9335          (ErrVal)ERGR063, (ErrVal)0, "Packing failed");
9336 #endif
9337       SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
9338                sizeof(RgrWarningSiCfgReqInfo));
9339       SPutMsg(mBuf);
9340       return RFAILED;
9341    }
9342
9343    if (SPkS16(spId, mBuf) != ROK)
9344    {
9345 #if (ERRCLASS & ERRCLS_ADD_RES)
9346       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9347          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9348          (ErrVal)ERGR064, (ErrVal)0, "Packing failed");
9349 #endif
9350       SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
9351                sizeof(RgrWarningSiCfgReqInfo));
9352       SPutMsg(mBuf);
9353       return RFAILED;
9354    }
9355
9356    /* if the application wants to retain this structure, the below
9357     * code should be removed */
9358    if (SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
9359                sizeof(RgrWarningSiCfgReqInfo)) != ROK)
9360    {
9361 #if (ERRCLASS & ERRCLS_ADD_RES)
9362       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9363             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9364             (ErrVal)ERGR065, (ErrVal)0, "Packing failed");
9365 #endif
9366       SPutMsg(mBuf);
9367       return RFAILED;
9368    }
9369
9370    pst->event = (Event) EVTRGRWARNINGSICFGREQ;
9371    return (SPstTsk(pst,mBuf));
9372 }/*cmPkRgrWarningSiCfgReq*/
9373
9374 \f
9375 /***********************************************************
9376 *
9377 *     Func : cmUnpkRgrWarningSiCfgReq
9378 *
9379 *
9380 *     Desc : SI Configuration Request from RRM to MAC for
9381 *            configuring warning SI
9382 *
9383 *
9384 *     Ret  : S16
9385 *
9386 *     Notes:
9387 *
9388 *     File  :
9389 *
9390 **********************************************************/
9391 #ifdef ANSI
9392 S16 cmUnpkRgrWarningSiCfgReq
9393 (
9394 RgrWarningSiCfgReq func,
9395 Pst *pst,
9396 Buffer *mBuf
9397 )
9398 #else
9399 S16 cmUnpkRgrWarningSiCfgReq(func, pst, mBuf)
9400 RgrWarningSiCfgReq func;
9401 Pst *pst;
9402 Buffer *mBuf;
9403 #endif
9404 {
9405    SpId spId;
9406    RgrCfgTransId transId;
9407    RgrWarningSiCfgReqInfo *warningSiCfgReqInfo;
9408
9409
9410    if (SUnpkS16(&spId, mBuf) != ROK)
9411    {
9412       SPutMsg(mBuf);
9413 #if (ERRCLASS & ERRCLS_ADD_RES)
9414       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9415          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9416          (ErrVal)ERGR066, (ErrVal)0, "Packing failed");
9417 #endif
9418       return RFAILED;
9419    }
9420
9421    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK)
9422    {
9423       SPutMsg(mBuf);
9424 #if (ERRCLASS & ERRCLS_ADD_RES)
9425       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9426          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9427          (ErrVal)ERGR067, (ErrVal)0, "Packing failed");
9428 #endif
9429       return RFAILED;
9430    }
9431
9432    if ((SGetSBuf(pst->region, pst->pool, (Data **)&warningSiCfgReqInfo,
9433             sizeof(RgrWarningSiCfgReqInfo))) != ROK)
9434    {
9435 #if (ERRCLASS & ERRCLS_ADD_RES)
9436       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9437             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9438             (ErrVal)ERGR068, (ErrVal)0, "Packing failed");
9439 #endif
9440       SPutMsg(mBuf);
9441       return RFAILED;
9442    }
9443
9444
9445    if (pst->selector == ODU_SELECTOR_LC)
9446    {
9447       if (cmUnpkRgrWarningSiCfgReqInfo(pst, warningSiCfgReqInfo, mBuf) != ROK)
9448       {
9449          SPutSBuf(pst->region, pst->pool, (Data *)warningSiCfgReqInfo,
9450                           sizeof(RgrWarningSiCfgReqInfo));
9451          SPutMsg(mBuf);
9452 #if (ERRCLASS & ERRCLS_ADD_RES)
9453          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9454                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9455                (ErrVal)ERGR069, (ErrVal)0, "Packing failed");
9456 #endif
9457          return RFAILED;
9458       }
9459    }
9460    SPutMsg(mBuf);
9461
9462    return ((*func)(pst, spId, transId, warningSiCfgReqInfo));
9463 } /* cmUnpkRgrWarningSiCfgReq */
9464
9465 \f
9466 /***********************************************************
9467 *
9468 *     Func : cmPkRgrWarningSiCfgReqInfo
9469 *
9470 *
9471 *     Desc : Basic warning SI configuration/reconfiguration
9472 *            info at RRM
9473 *
9474 *
9475 *     Ret  : S16
9476 *
9477 *     Notes:
9478 *
9479 *     File  :
9480 *
9481 **********************************************************/
9482 #ifdef ANSI
9483 S16 cmPkRgrWarningSiCfgReqInfo
9484 (
9485 Pst *pst,
9486 RgrWarningSiCfgReqInfo *param,
9487 Buffer *mBuf
9488 )
9489 #else
9490 S16 cmPkRgrWarningSiCfgReqInfo(pst, param, mBuf)
9491 Pst *pst;
9492 RgrWarningSiCfgReqInfo *param;
9493 Buffer *mBuf;
9494 #endif
9495 {
9496    MsgLen   msgLen;
9497    uint32_t      count;
9498    CmLList  *node, *prevNode;
9499    RgrSegmentInfo   *pdu;
9500
9501
9502    CMCHKPK(oduUnpackUInt8, param->emtcEnable, mBuf);
9503
9504    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
9505    CMCHKPK(oduUnpackUInt8, param->siId, mBuf);
9506
9507    count = param->siPduLst.count;
9508    node = param->siPduLst.last;
9509    while (node)
9510    {
9511       pdu = (RgrSegmentInfo *)node->node;
9512       prevNode= node->prev;
9513       if(NULLP != pdu)
9514       {
9515          if (SFndLenMsg(pdu->pdu, &msgLen) != ROK)
9516             return RFAILED;
9517          if (SCatMsg(mBuf, pdu->pdu, M1M2) != ROK)
9518             return RFAILED;
9519          /* The PDU is not Released. This has to be done by
9520           * the caller of the packing function  */
9521          CMCHKPK(cmPkMsgLen, msgLen, mBuf);
9522          SPutMsg(pdu->pdu);
9523       }
9524       cmLListDelFrm(&param->siPduLst, node);
9525       SPutSBuf(pst->region, pst->pool, (Data *)node, sizeof(RgrSegmentInfo));
9526       node= prevNode;
9527    }
9528    CMCHKPK(oduUnpackUInt32, count, mBuf);
9529    return ROK;
9530 }
9531
9532 \f
9533 /***********************************************************
9534 *
9535 *     Func : cmUnpkRgrWarningSiCfgReqInfo
9536 *
9537 *
9538 *     Desc : Unpack warning SI configuration info at SCH
9539 *
9540 *
9541 *     Ret  : S16
9542 *
9543 *     Notes:
9544 *
9545 *     File  :
9546 *
9547 **********************************************************/
9548 #ifdef ANSI
9549 S16 cmUnpkRgrWarningSiCfgReqInfo
9550 (
9551 Pst *pst,
9552 RgrWarningSiCfgReqInfo *param,
9553 Buffer *mBuf
9554 )
9555 #else
9556 S16 cmUnpkRgrWarningSiCfgReqInfo(pst, param, mBuf)
9557 Pst *pst;
9558 RgrWarningSiCfgReqInfo *param;
9559 Buffer *mBuf;
9560 #endif
9561 {
9562    MsgLen   msgLen, totalMsgLen;
9563    uint32_t      count, loopCnt;
9564    Buffer   *pdu;
9565    CmLList  *node;
9566
9567
9568    cmLListInit(&param->siPduLst);
9569    CMCHKUNPK(oduPackUInt32, &count, mBuf);
9570    for (loopCnt=0; loopCnt<count; loopCnt++)
9571    {
9572       if(SFndLenMsg(mBuf, &msgLen) != ROK)
9573       {
9574          return RFAILED;
9575       }
9576
9577       if(msgLen > 0)
9578       {
9579          CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
9580          if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
9581          {
9582             return RFAILED;
9583          }
9584          if (SSegMsg(mBuf, totalMsgLen-msgLen, &pdu) != ROK)
9585          {
9586             return RFAILED;
9587          }
9588       }
9589       else
9590       {
9591          return RFAILED;
9592       }
9593       if ((SGetSBuf(pst->region, pst->pool, (Data **)&node,
9594                   sizeof(CmLList))) != ROK)
9595          return RFAILED;
9596       node->node = (PTR)pdu;
9597       cmLListAdd2Tail(&param->siPduLst, node);
9598    }
9599
9600    CMCHKUNPK(oduPackUInt8, &param->siId, mBuf);
9601    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
9602    CMCHKPK(oduPackUInt8, &param->emtcEnable, mBuf);
9603
9604    return ROK;
9605 }
9606
9607 \f
9608 /***********************************************************
9609 *
9610 *    Func : cmPkRgrWarningSiStopReq
9611 *
9612 *    Desc : To stop the broadcast for SIB10, SIB11 and SIB12.
9613 *
9614 *     Ret  : S16
9615 *
9616 *     Notes:
9617 *
9618 *     File  :
9619 **********************************************************/
9620 #ifdef ANSI
9621 S16 cmPkRgrWarningSiStopReq
9622 (
9623 Pst           *pst,
9624 SpId          spId,
9625 RgrCfgTransId transId,
9626 uint8_t            siId
9627 )
9628 #else
9629 S16 cmPkRgrWarningSiStopReq(pst,spId, transId, siId)
9630 Pst           *pst;
9631 SpId          spId;
9632 RgrCfgTransId transId;
9633 uint8_t            siId;
9634 #endif
9635 {
9636    Buffer *mBuf = NULLP;
9637
9638
9639    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
9640    {
9641 #if (ERRCLASS & ERRCLS_ADD_RES)
9642       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9643             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9644             (ErrVal)ERGR070, (ErrVal)0, "Packing failed");
9645 #endif
9646       return RFAILED;
9647    }
9648
9649    CMCHKPK(oduUnpackUInt8, siId, mBuf);
9650
9651
9652    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK)
9653    {
9654 #if (ERRCLASS & ERRCLS_ADD_RES)
9655       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9656          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9657          (ErrVal)ERGR082, (ErrVal)0, "Packing failed");
9658 #endif
9659       SPutMsg(mBuf);
9660       return RFAILED;
9661    }
9662
9663
9664    if (SPkS16(spId, mBuf) != ROK)
9665    {
9666 #if (ERRCLASS & ERRCLS_ADD_RES)
9667       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9668             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9669             (ErrVal)ERGR071, (ErrVal)0, "Packing failed");
9670 #endif
9671       SPutMsg(mBuf);
9672       return RFAILED;
9673    }
9674
9675    pst->event = (Event) EVTRGRWARNINGSISTOPREQ;
9676    return (SPstTsk(pst,mBuf));
9677 }/*cmPkRgrWarningSiStopReq */
9678
9679 \f
9680 /***********************************************************
9681 *
9682 *    Func : cmUnpkRgrWarningSiStopReq
9683 *
9684 *    Desc : To stop the broadcast for SIB10, SIB11 and SIB12.
9685 *
9686 *     Ret  : S16
9687 *
9688 *     Notes:
9689 *
9690 *     File  :
9691 **********************************************************/
9692 #ifdef ANSI
9693 S16 cmUnpkRgrWarningSiStopReq
9694 (
9695 RgrWarningSiStopReq func,
9696 Pst *pst,
9697 Buffer *mBuf
9698 )
9699 #else
9700 S16 cmUnpkRgrWarningSiStopReq(param, mBuf)
9701 RgrWarningSiStopReq func;
9702 Pst *pst;
9703 Buffer *mBuf;
9704 #endif
9705 {
9706    SpId          spId;
9707    uint8_t            siId;
9708    RgrCfgTransId transId;
9709
9710
9711   if (SUnpkS16(&spId, mBuf) != ROK)
9712   {
9713      SPutMsg(mBuf);
9714 #if (ERRCLASS & ERRCLS_ADD_RES)
9715      SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9716            __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9717            (ErrVal)ERGR072, (ErrVal)0, "Packing failed");
9718 #endif
9719      return RFAILED;
9720   }
9721
9722     if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK)
9723    {
9724       SPutMsg(mBuf);
9725 #if (ERRCLASS & ERRCLS_ADD_RES)
9726       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9727          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9728          (ErrVal)ERGR083, (ErrVal)0, "Packing failed");
9729 #endif
9730       return RFAILED;
9731    }
9732
9733    CMCHKUNPK(oduPackUInt8, &siId, mBuf);
9734
9735    SPutMsg(mBuf);
9736
9737    return ((*func)(pst, spId, transId, siId));
9738 } /*cmUnpkRgrWarningSiStopReq */
9739
9740 \f
9741 /***********************************************************
9742 *
9743 *     Func : cmPkRgrWarningSiCfgCfm
9744 *
9745 *
9746 *     Desc : Warning SI Configuration Confirm from MAC to RRM
9747 *
9748 *
9749 *     Ret  : S16
9750 *
9751 *     Notes:
9752 *
9753 *     File  :
9754 *
9755 **********************************************************/
9756 #ifdef ANSI
9757 S16 cmPkRgrWarningSiCfgCfm
9758 (
9759 Pst*          pst,
9760 SuId          suId,
9761 RgrCfgTransId transId,
9762 uint8_t            siId,
9763 uint8_t            status
9764 )
9765 #else
9766 S16 cmPkRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
9767 Pst*          pst;
9768 SuId          suId;
9769 RgrCfgTransId transId;
9770 uint8_t            siId;
9771 uint8_t            status;
9772 #endif
9773 {
9774    Buffer *mBuf = NULLP;
9775
9776
9777    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
9778    {
9779 #if (ERRCLASS & ERRCLS_ADD_RES)
9780       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9781          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9782          (ErrVal)ERGR073, (ErrVal)0, "Packing failed");
9783 #endif
9784       return RFAILED;
9785    }
9786
9787    if (oduUnpackUInt8(status, mBuf) != ROK)
9788    {
9789 #if (ERRCLASS & ERRCLS_ADD_RES)
9790       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9791          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9792          (ErrVal)ERGR074, (ErrVal)0, "Packing failed");
9793 #endif
9794       SPutMsg(mBuf);
9795       return RFAILED;
9796    }
9797
9798    if (oduUnpackUInt8(siId, mBuf) != ROK)
9799    {
9800 #if (ERRCLASS & ERRCLS_ADD_RES)
9801       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9802          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9803          (ErrVal)ERGR075, (ErrVal)0, "Packing failed");
9804 #endif
9805       SPutMsg(mBuf);
9806       return RFAILED;
9807    }
9808
9809    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK)
9810    {
9811 #if (ERRCLASS & ERRCLS_ADD_RES)
9812       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9813          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9814          (ErrVal)ERGR076, (ErrVal)0, "Packing failed");
9815 #endif
9816       SPutMsg(mBuf);
9817       return RFAILED;
9818    }
9819
9820    if (SPkS16(suId, mBuf) != ROK)
9821    {
9822 #if (ERRCLASS & ERRCLS_ADD_RES)
9823       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9824          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9825          (ErrVal)ERGR077, (ErrVal)0, "Packing failed");
9826 #endif
9827       SPutMsg(mBuf);
9828       return RFAILED;
9829    }
9830
9831    pst->event = (Event) EVTRGRWARNINGSICFGCFM;
9832    return (SPstTsk(pst,mBuf));
9833 } /* cmPkRgrWarningSiCfgCfm */
9834
9835 \f
9836 /***********************************************************
9837 *
9838 *     Func : cmUnpkRgrwarningSiCfgCfm
9839 *
9840 *
9841 *     Desc : Warning SI Configuration Confirm from MAC to RRM
9842 *
9843 *
9844 *     Ret  : S16
9845 *
9846 *     Notes:
9847 *
9848 *     File  :
9849 *
9850 **********************************************************/
9851 #ifdef ANSI
9852 S16 cmUnpkRgrWarningSiCfgCfm
9853 (
9854 RgrWarningSiCfgCfm func,
9855 Pst *pst,
9856 Buffer *mBuf
9857 )
9858 #else
9859 S16 cmUnpkRgrWarningSiCfgCfm(func, pst, mBuf)
9860 RgrWarningSiCfgCfm func;
9861 Pst *pst;
9862 Buffer *mBuf;
9863 #endif
9864 {
9865    SuId          suId;
9866    uint8_t            siId;
9867    RgrCfgTransId transId;
9868    uint8_t            status;
9869
9870
9871    if (SUnpkS16(&suId, mBuf) != ROK)
9872    {
9873       SPutMsg(mBuf);
9874 #if (ERRCLASS & ERRCLS_ADD_RES)
9875       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9876             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9877             (ErrVal)ERGR078, (ErrVal)0, "Packing failed");
9878 #endif
9879       return RFAILED;
9880    }
9881
9882    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK)
9883    {
9884       SPutMsg(mBuf);
9885 #if (ERRCLASS & ERRCLS_ADD_RES)
9886       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9887             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9888             (ErrVal)ERGR079, (ErrVal)0, "Packing failed");
9889 #endif
9890       return RFAILED;
9891    }
9892
9893    if (oduPackUInt8(&siId, mBuf) != ROK)
9894    {
9895       SPutMsg(mBuf);
9896 #if (ERRCLASS & ERRCLS_ADD_RES)
9897       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9898             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9899             (ErrVal)ERGR080, (ErrVal)0, "Packing failed");
9900 #endif
9901       return RFAILED;
9902    }
9903
9904    if (oduPackUInt8(&status, mBuf) != ROK)
9905    {
9906       SPutMsg(mBuf);
9907 #if (ERRCLASS & ERRCLS_ADD_RES)
9908       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9909             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9910             (ErrVal)ERGR081, (ErrVal)0, "Packing failed");
9911 #endif
9912       return RFAILED;
9913    }
9914    SPutMsg(mBuf);
9915    return ((*func)(pst, suId, transId, siId, status));
9916 }/* cmUnpkRgrwarningSiCfgCfm */
9917 #endif/*RGR_SI_SCH*/
9918
9919 /* LTE_ADV_FLAG_REMOVED_START */
9920 /***********************************************************
9921 *
9922 *     Func : cmPkRgrLoadInfReq
9923 *
9924 *
9925 *     Desc : LOAD INF Configuration Request from RRM to MAC for
9926 *            configuring RNTP, ABS etc
9927 *
9928 *
9929 *     Ret  : S16
9930 *
9931 *     Notes:
9932 *
9933 *     File  :
9934 *
9935 **********************************************************/
9936 #ifdef ANSI
9937 S16 cmPkRgrLoadInfReq
9938 (
9939 Pst* pst,
9940 SpId spId,
9941 RgrCfgTransId transId,
9942 RgrLoadInfReqInfo * loadInfReq
9943 )
9944 #else
9945 S16 cmPkRgrLoadInfReq(pst, spId, transId, loadInfReq)
9946 Pst* pst;
9947 SpId spId;
9948 RgrCfgTransId transId;
9949 RgrLoadInfReqInfo * loadInfReq;
9950 #endif
9951 {
9952    Buffer *mBuf = NULLP;
9953
9954
9955    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
9956    {
9957 #if (ERRCLASS & ERRCLS_ADD_RES)
9958       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9959          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9960          (ErrVal)ERGR045, (ErrVal)0, "Packing failed");
9961 #endif
9962       SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
9963                  sizeof(RgrLoadInfReqInfo));
9964       return RFAILED;
9965    }
9966    if (cmPkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
9967 #if (ERRCLASS & ERRCLS_ADD_RES)
9968       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9969             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9970             (ErrVal)ERGR046, (ErrVal)0, "Packing failed");
9971 #endif
9972       SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
9973                 sizeof(RgrLoadInfReqInfo));
9974       SPutMsg(mBuf);
9975       return RFAILED;
9976    }
9977    if (cmPkRgrCfgTransId(&transId, mBuf) != ROK) {
9978 #if (ERRCLASS & ERRCLS_ADD_RES)
9979       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9980          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9981          (ErrVal)ERGR047, (ErrVal)0, "Packing failed");
9982 #endif
9983       SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
9984                sizeof(RgrLoadInfReqInfo));
9985       SPutMsg(mBuf);
9986       return RFAILED;
9987    }
9988    if (SPkS16(spId, mBuf) != ROK) {
9989 #if (ERRCLASS & ERRCLS_ADD_RES)
9990       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
9991          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
9992          (ErrVal)ERGR048, (ErrVal)0, "Packing failed");
9993 #endif
9994       SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
9995                sizeof(RgrLoadInfReqInfo));
9996       SPutMsg(mBuf);
9997       return RFAILED;
9998    }
9999    if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
10000                sizeof(RgrLoadInfReqInfo)) != ROK) {
10001 #if (ERRCLASS & ERRCLS_ADD_RES)
10002       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10003             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10004             (ErrVal)ERGR049, (ErrVal)0, "Packing failed");
10005 #endif
10006       SPutMsg(mBuf);
10007       return RFAILED;
10008    }
10009
10010    pst->event = (Event) EVTRGRLOADINFREQ;
10011    return (SPstTsk(pst,mBuf));
10012 }
10013 \f
10014 /***********************************************************
10015 *
10016 *     Func : cmUnpkRgrLoadInfReq
10017 *
10018 *
10019 *     Desc : LOAD INF Configuration Request from RRM to MAC for
10020 *     configuring RNTP, ABS etc
10021 *
10022 *
10023 *     Ret  : S16
10024 *
10025 *     Notes:
10026 *
10027 *     File  :
10028 *
10029 **********************************************************/
10030 #ifdef ANSI
10031 S16 cmUnpkRgrLoadInfReq
10032 (
10033 RgrLoadInfReq func,
10034 Pst *pst,
10035 Buffer *mBuf
10036 )
10037 #else
10038 S16 cmUnpkRgrLoadInfReq(func, pst, mBuf)
10039 RgrLoadInfReq func;
10040 Pst *pst;
10041 Buffer *mBuf;
10042 #endif
10043 {
10044    SpId spId;
10045    RgrCfgTransId transId;
10046    RgrLoadInfReqInfo *loadInfReq;
10047
10048
10049    if (SUnpkS16(&spId, mBuf) != ROK) {
10050       SPutMsg(mBuf);
10051 #if (ERRCLASS & ERRCLS_ADD_RES)
10052       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10053          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10054          (ErrVal)ERGR050, (ErrVal)0, "Packing failed");
10055 #endif
10056       return RFAILED;
10057    }
10058
10059    if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
10060       SPutMsg(mBuf);
10061 #if (ERRCLASS & ERRCLS_ADD_RES)
10062       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10063          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10064          (ErrVal)ERGR051, (ErrVal)0, "Packing failed");
10065 #endif
10066       return RFAILED;
10067    }
10068
10069    if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfReq,
10070             sizeof(RgrLoadInfReqInfo))) != ROK) {
10071 #if (ERRCLASS & ERRCLS_ADD_RES)
10072       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10073             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10074             (ErrVal)ERGR052, (ErrVal)0, "Packing failed");
10075 #endif
10076       SPutMsg(mBuf);
10077       return RFAILED;
10078    }
10079
10080    memset(loadInfReq, 0, sizeof(RgrLoadInfReqInfo));
10081
10082    if (pst->selector == ODU_SELECTOR_LC)
10083       if (cmUnpkRgrLoadInfReqInfo(loadInfReq, mBuf) != ROK) {
10084          SPutSBuf(pst->region, pst->pool, (Data *)loadInfReq,
10085                           sizeof(RgrLoadInfReqInfo));
10086          SPutMsg(mBuf);
10087 #if (ERRCLASS & ERRCLS_ADD_RES)
10088          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10089                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10090                (ErrVal)ERGR053, (ErrVal)0, "Packing failed");
10091 #endif
10092          return RFAILED;
10093       }
10094    SPutMsg(mBuf);
10095
10096    return ((*func)(pst, spId, transId, loadInfReq));
10097 }
10098
10099 /***********************************************************
10100 *
10101 *     Func : cmPkRgrLoadInfReqInfo
10102 *
10103 *
10104 *     Desc : Basic LOAD INF configuration/reconfiguration info at RRM
10105 *
10106 *
10107 *     Ret  : S16
10108 *
10109 *     Notes:
10110 *
10111 *     File  :
10112 *
10113 **********************************************************/
10114 #ifdef ANSI
10115 S16 cmPkRgrLoadInfReqInfo
10116 (
10117 RgrLoadInfReqInfo *param,
10118 Buffer *mBuf
10119 )
10120 #else
10121 S16 cmPkRgrLoadInfReqInfo(param, mBuf)
10122 RgrLoadInfReqInfo *param;
10123 Buffer *mBuf;
10124 #endif
10125 {
10126
10127    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
10128    CMCHKPK(oduUnpackUInt8, param->rgrCcPHighStartRb, mBuf);
10129    CMCHKPK(oduUnpackUInt8, param->rgrCcPHighEndRb, mBuf);
10130
10131    return ROK;
10132 }
10133 \f
10134 /***********************************************************
10135 *
10136 *     Func : cmUnpkRgrLoadInfReqInfo
10137 *
10138 *
10139 *     Desc : Basic LOAD INF configuration/reconfiguration info at RRM
10140 *
10141 *
10142 *     Ret  : S16
10143 *
10144 *     Notes:
10145 *
10146 *     File  :
10147 *
10148 **********************************************************/
10149 #ifdef ANSI
10150 S16 cmUnpkRgrLoadInfReqInfo
10151 (
10152 RgrLoadInfReqInfo *param,
10153 Buffer *mBuf
10154 )
10155 #else
10156 S16 cmUnpkRgrLoadInfReqInfo(param, mBuf)
10157 RgrLoadInfReqInfo *param;
10158 Buffer *mBuf;
10159 #endif
10160 {
10161
10162    CMCHKUNPK(oduPackUInt8, &param->rgrCcPHighEndRb, mBuf);
10163    CMCHKUNPK(oduPackUInt8, &param->rgrCcPHighStartRb, mBuf);
10164    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
10165
10166    return ROK;
10167 }
10168 /* LTE_ADV_FLAG_REMOVED_END */
10169
10170 /*rgr_c_001.main_9 ccpu00117452 - MOD - Changed macro name from
10171    RGR_RRM_DLPWR_CNTRL to RGR_CQI_REPT */
10172 #ifdef RGR_CQI_REPT
10173 \f
10174 /***********************************************************
10175 *
10176 *     Func : cmPkRgrUeCqiReptCfg
10177 *
10178 *
10179 *     Desc : Transaction ID between MAC and RRM
10180 *
10181 *
10182 *     Ret  : S16
10183 *
10184 *     Notes:
10185 *
10186 *     File  :
10187 *
10188 **********************************************************/
10189 #ifdef ANSI
10190 S16 cmPkRgrUeCqiReptCfg
10191 (
10192 RgrUeCqiReptCfg *param,
10193 Buffer *mBuf
10194 )
10195 #else
10196 S16 cmPkRgrUeCqiReptCfg(param, mBuf)
10197 RgrUeCqiReptCfg *param;
10198 Buffer *mBuf;
10199 #endif
10200 {
10201
10202    CMCHKPK(oduUnpackUInt8, param->numColltdCqiRept, mBuf);
10203
10204    return ROK;
10205 }
10206
10207 \f
10208 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10209 /***********************************************************
10210 *
10211 *     Func : cmUnpkRgrUeCqiReptCfg
10212 *
10213 *
10214 *     Desc : Transaction ID between MAC and RRM
10215 *
10216 *
10217 *     Ret  : S16
10218 *
10219 *     Notes:
10220 *
10221 *     File  :
10222 *
10223 **********************************************************/
10224 #ifdef ANSI
10225 S16 cmUnpkRgrUeCqiReptCfg
10226 (
10227 RgrUeCqiReptCfg *param,
10228 Buffer *mBuf
10229 )
10230 #else
10231 S16 cmUnpkRgrUeCqiReptCfg(param, mBuf)
10232 RgrUeCqiReptCfg *param;
10233 Buffer *mBuf;
10234 #endif
10235 {
10236
10237    CMCHKUNPK(oduPackUInt8, &param->numColltdCqiRept, mBuf);
10238
10239    return ROK;
10240 }
10241
10242 \f
10243 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10244 /***********************************************************
10245 *
10246 *     Func : cmPkRgrStaInd
10247 *
10248 *
10249 *     Desc : Packing Sta Indication sent to RRM
10250 *
10251 *
10252 *     Ret  : S16
10253 *
10254 *     Notes:
10255 *
10256 *     File  :
10257 *
10258 **********************************************************/
10259 #ifdef ANSI
10260 S16 cmPkRgrStaInd
10261 (
10262 Pst* pst,
10263 SuId suId,
10264 RgrStaIndInfo* staInd
10265 )
10266 #else
10267 S16 cmPkRgrStaInd(pst, suId, staInd)
10268 Pst* pst;
10269 SuId suId;
10270 RgrStaIndInfo* staInd;
10271 #endif
10272 {
10273    Buffer *mBuf = NULLP;
10274
10275    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
10276    {
10277 #if (ERRCLASS & ERRCLS_ADD_RES)
10278       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10279          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10280          (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
10281 #endif
10282       SPutSBuf(pst->region, pst->pool, (Data *)staInd,
10283                sizeof(RgrStaIndInfo));
10284       return RFAILED;
10285    }
10286
10287    if (cmPkRgrStaIndInfo(staInd, mBuf) != ROK)
10288    {
10289 #if (ERRCLASS & ERRCLS_ADD_RES)
10290       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10291             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10292             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
10293 #endif
10294       SPutSBuf(pst->region, pst->pool, (Data *)staInd, sizeof(RgrStaIndInfo));
10295       SPutMsg(mBuf);
10296       return RFAILED;
10297    }
10298
10299    if (SPkS16(suId, mBuf) != ROK)
10300    {
10301 #if (ERRCLASS & ERRCLS_ADD_RES)
10302       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10303          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10304          (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
10305 #endif
10306       SPutSBuf(pst->region, pst->pool, (Data *)staInd,
10307                   sizeof(RgrStaIndInfo));
10308       SPutMsg(mBuf);
10309       return RFAILED;
10310    }
10311
10312    if (SPutSBuf(pst->region, pst->pool, (Data *)staInd,
10313                   sizeof(RgrStaIndInfo)) != ROK)
10314    {
10315 #if (ERRCLASS & ERRCLS_ADD_RES)
10316       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10317          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10318          (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
10319 #endif
10320       SPutMsg(mBuf);
10321       return RFAILED;
10322    }
10323
10324    pst->event = (Event) EVTRGRSTAIND;
10325    return (SPstTsk(pst,mBuf));
10326 }
10327
10328 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10329 /***********************************************************
10330 *
10331 *     Func : cmUnpkRgrStaInd
10332 *
10333 *
10334 *     Desc : Unpacking Sta Indication sent to RRM
10335 *
10336 *     Ret  : S16
10337 *
10338 *     Notes:
10339 *
10340 *     File  :
10341 *
10342 **********************************************************/
10343 #ifdef ANSI
10344 S16 cmUnpkRgrStaInd
10345 (
10346 RgrStaInd func,
10347 Pst *pst,
10348 Buffer *mBuf
10349 )
10350 #else
10351 S16 cmUnpkRgrStaInd(func, pst, mBuf)
10352 RgrStaInd func;
10353 Pst *pst;
10354 Buffer *mBuf;
10355 #endif
10356 {
10357    SuId suId;
10358    RgrStaIndInfo *staInd;
10359
10360
10361    if (SUnpkS16(&suId, mBuf) != ROK)
10362    {
10363       SPutMsg(mBuf);
10364 #if (ERRCLASS & ERRCLS_ADD_RES)
10365       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10366          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10367          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
10368 #endif
10369       return RFAILED;
10370    }
10371
10372    if ((SGetSBuf(pst->region, pst->pool, (Data **)&staInd,
10373                  sizeof(RgrStaIndInfo))) != ROK)
10374    {
10375 #if (ERRCLASS & ERRCLS_ADD_RES)
10376          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10377             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10378             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
10379 #endif
10380          SPutMsg(mBuf);
10381          return RFAILED;
10382    }
10383
10384    if (cmUnpkRgrStaIndInfo(staInd, mBuf) != ROK)
10385    {
10386       SPutSBuf(pst->region, pst->pool, (Data *)staInd,
10387              sizeof(RgrStaIndInfo));
10388       SPutMsg(mBuf);
10389 #if (ERRCLASS & ERRCLS_ADD_RES)
10390       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10391          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10392          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
10393 #endif
10394       return RFAILED;
10395    }
10396
10397    SPutMsg(mBuf);
10398    return ((*func)(pst, suId, staInd));
10399 }
10400 \f
10401 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10402 /***********************************************************
10403 *
10404 *     Func : cmPkRgrStaIndInfo
10405 *
10406 *
10407 *     Desc : Packing of StaIndInfo structure
10408 *
10409 *     Ret  : S16
10410 *
10411 *     Notes:
10412 *
10413 *     File  :
10414 *
10415 **********************************************************/
10416 #ifdef ANSI
10417 S16 cmPkRgrStaIndInfo
10418 (
10419 RgrStaIndInfo *param,
10420 Buffer *mBuf
10421 )
10422 #else
10423 S16 cmPkRgrStaIndInfo(param, mBuf)
10424 RgrStaIndInfo *param;
10425 Buffer *mBuf;
10426 #endif
10427 {
10428
10429
10430    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
10431    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
10432    CMCHKPK(cmPkRgrUeCqiInfo, &param->ueCqiInfo, mBuf);
10433
10434    return ROK;
10435 }
10436 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10437 /***********************************************************
10438 *
10439 *     Func : cmUnpkRgrStaIndInfo
10440 *
10441 *
10442 *     Desc : Unpacking of StaIndInfo structure
10443 *
10444 *     Ret  : S16
10445 *
10446 *     Notes:
10447 *
10448 *     File  :
10449 *
10450 **********************************************************/
10451 #ifdef ANSI
10452 S16 cmUnpkRgrStaIndInfo
10453 (
10454 RgrStaIndInfo *param,
10455 Buffer *mBuf
10456 )
10457 #else
10458 S16 cmUnpkRgrStaIndInfo(param, mBuf)
10459 RgrStaIndInfo *param;
10460 Buffer *mBuf;
10461 #endif
10462 {
10463
10464
10465    CMCHKUNPK(cmUnpkRgrUeCqiInfo, &param->ueCqiInfo, mBuf);
10466    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
10467    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
10468
10469    return ROK;
10470 }
10471 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10472 /***********************************************************
10473 *
10474 *     Func : cmPkRgrUeCqiInfo
10475 *
10476 *
10477 *     Desc : Packing of StaIndInfo structure
10478 *
10479 *     Ret  : S16
10480 *
10481 *     Notes:
10482 *
10483 *     File  :
10484 *
10485 **********************************************************/
10486 #ifdef ANSI
10487 S16 cmPkRgrUeCqiInfo
10488 (
10489 RgrUeCqiInfo *param,
10490 Buffer *mBuf
10491 )
10492 #else
10493 S16 cmPkRgrUeCqiInfo(param, mBuf)
10494 RgrUeCqiInfo *param;
10495 Buffer *mBuf;
10496 #endif
10497 {
10498
10499    S16 idx;
10500
10501    for (idx = param->numCqiRept - 1; idx >= 0; idx--)
10502    {
10503       CMCHKPK(cmPkRgrUeCqiRept, &param->cqiRept[idx], mBuf);
10504    }
10505    CMCHKPK(oduUnpackUInt8, param->numCqiRept, mBuf);
10506
10507    return ROK;
10508 } /* cmPkRgrUeCqiInfo */
10509
10510 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10511 /***********************************************************
10512 *
10513 *     Func : cmUnpkRgrUeCqiInfo
10514 *
10515 *
10516 *     Desc : Packing of StaIndInfo structure
10517 *
10518 *     Ret  : S16
10519 *
10520 *     Notes:
10521 *
10522 *     File  :
10523 *
10524 **********************************************************/
10525 #ifdef ANSI
10526 S16 cmUnpkRgrUeCqiInfo
10527 (
10528 RgrUeCqiInfo *param,
10529 Buffer *mBuf
10530 )
10531 #else
10532 S16 cmUnpkRgrUeCqiInfo(param, mBuf)
10533 RgrUeCqiInfo *param;
10534 Buffer *mBuf;
10535 #endif
10536 {
10537
10538    uint8_t  idx;
10539
10540    CMCHKUNPK(oduPackUInt8, &param->numCqiRept, mBuf);
10541    for (idx = 0; idx < param->numCqiRept; idx++)
10542    {
10543       CMCHKUNPK(cmUnpkRgrUeCqiRept, &param->cqiRept[idx], mBuf);
10544    }
10545
10546    return ROK;
10547 } /* cmUnpkRgrUeCqiInfo */
10548
10549 /***********************************************************
10550 *
10551 *     Func : cmPkRgrSubBandCqiInfo
10552 *
10553 *
10554 *     Desc : Packing ofcmPkRgrSubBandCqiInfo structure
10555 *
10556 *     Ret  : S16
10557 *
10558 *     Notes:
10559 *
10560 *     File  :
10561 *
10562 **********************************************************/
10563 #ifdef ANSI
10564 S16 cmPkRgrSubBandCqiInfo
10565 (
10566 RgrSubBandCqiInfo *param,
10567 Buffer *mBuf
10568 )
10569 #else
10570 S16 cmPkRgrSubBandCqiInfo(param, mBuf)
10571 RgrSubBandCqiInfo *param;
10572 Buffer *mBuf;
10573 #endif
10574 {
10575
10576
10577    CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
10578    CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
10579    CMCHKPK(oduUnpackUInt8, param->subBandIdx, mBuf);
10580
10581    return ROK;
10582 } /* cmPkRgrSubBandCqiInfo */
10583
10584 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10585 /***********************************************************
10586 *
10587 *     Func : cmPkRgrUeCqiRept
10588 *
10589 *
10590 *     Desc : Packing of StaIndInfo structure
10591 *
10592 *     Ret  : S16
10593 *
10594 *     Notes:
10595 *
10596 *     File  :
10597 *
10598 **********************************************************/
10599 #ifdef ANSI
10600 S16 cmPkRgrUeCqiRept
10601 (
10602 RgrUeCqiRept *param,
10603 Buffer *mBuf
10604 )
10605 #else
10606 S16 cmPkRgrUeCqiRept(param, mBuf)
10607 RgrUeCqiRept *param;
10608 Buffer *mBuf;
10609 #endif
10610 {
10611    S8 idx;
10612    uint8_t count;
10613
10614
10615    CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
10616    CMCHKPK(oduUnpackUInt8, param->cqi[1], mBuf);
10617    CMCHKPK(oduUnpackUInt8, param->cqiMode, mBuf);
10618    for (idx = param->numSubBand - 1; idx >= 0; idx--)
10619    {
10620       count = idx;
10621       CMCHKPK(cmPkRgrSubBandCqiInfo, &param->sbCqiInfo[count], mBuf);
10622    }
10623    CMCHKPK(oduUnpackUInt8, param->numSubBand, mBuf);
10624    return ROK;
10625 } /* cmPkRgrUeCqiRept */
10626
10627 /***********************************************************
10628 *
10629 *     Func :cmUnpkRgrSubBandCqiInfo
10630 *
10631 *
10632 *     Desc : Packing of cmUnpkRgrSubBandCqiInfo structure
10633 *
10634 *     Ret  : S16
10635 *
10636 *     Notes:
10637 *
10638 *     File  :
10639 *
10640 **********************************************************/
10641 #ifdef ANSI
10642 S16 cmUnpkRgrSubBandCqiInfo
10643 (
10644 RgrSubBandCqiInfo *param,
10645 Buffer *mBuf
10646 )
10647 #else
10648 S16 cmUnpkRgrSubBandCqiInfo(param, mBuf)
10649 RgrSubBandCqiInfo *param;
10650 Buffer *mBuf;
10651 #endif
10652 {
10653
10654
10655    CMCHKUNPK(oduPackUInt8, &param->subBandIdx, mBuf);
10656    CMCHKUNPK(oduPackUInt8, &param->cqi[1], mBuf);
10657    CMCHKUNPK(oduPackUInt8, &param->cqi[0], mBuf);
10658
10659    return ROK;
10660 } /* cmUnpkRgrSubBandCqiInfo*/
10661
10662 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10663 /***********************************************************
10664 *
10665 *     Func : cmUnpkRgrUeCqiRept
10666 *
10667 *
10668 *     Desc : Packing of StaIndInfo structure
10669 *
10670 *     Ret  : S16
10671 *
10672 *     Notes:
10673 *
10674 *     File  :
10675 *
10676 **********************************************************/
10677 #ifdef ANSI
10678 S16 cmUnpkRgrUeCqiRept
10679 (
10680 RgrUeCqiRept *param,
10681 Buffer *mBuf
10682 )
10683 #else
10684 S16 cmUnpkRgrUeCqiRept(param, mBuf)
10685 RgrUeCqiRept *param;
10686 Buffer *mBuf;
10687 #endif
10688 {
10689    uint8_t idx;
10690
10691    CMCHKUNPK(oduPackUInt8, &param->numSubBand, mBuf);
10692    for (idx = 0; idx < param->numSubBand; idx++)
10693    {
10694       CMCHKUNPK(cmUnpkRgrSubBandCqiInfo, &param->sbCqiInfo[idx], mBuf);
10695    }
10696    CMCHKUNPK(oduPackUInt8, &param->cqiMode, mBuf);
10697    CMCHKUNPK(oduPackUInt8, &param->cqi[1], mBuf);
10698    CMCHKUNPK(oduPackUInt8, &param->cqi[0], mBuf);
10699
10700    return ROK;
10701 } /* cmUnpkRgrUeCqiRept */
10702 #endif /* End of ifdef RGR_CQI_REPT */
10703
10704 /* LTE_ADV_FLAG_REMOVED_START */
10705 /***********************************************************
10706 *
10707 *     Func : cmPkRgrLoadInfInd
10708 *
10709 *
10710 *     Desc : Packing LOAD INFORMATION Indication sent to RRM
10711 *
10712 *
10713 *     Ret  : S16
10714 *
10715 *     Notes:
10716 *
10717 *     File  :
10718 *
10719 **********************************************************/
10720 #ifdef ANSI
10721 S16 cmPkRgrLoadInfInd
10722 (
10723 Pst* pst,
10724 SuId suId,
10725 RgrLoadInfIndInfo* loadInfInd
10726 )
10727 #else
10728 S16 cmPkRgrLoadInfInd(pst, suId, loadInfInd)
10729 Pst* pst;
10730 SuId suId;
10731 RgrLoadInfIndInfo* loadInfInd;
10732 #endif
10733 {
10734    Buffer *mBuf = NULLP;
10735
10736    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
10737    {
10738 #if (ERRCLASS & ERRCLS_ADD_RES)
10739       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10740             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10741             (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
10742 #endif
10743       SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
10744             sizeof(RgrLoadInfIndInfo));
10745       return RFAILED;
10746    }
10747
10748    if (cmPkRgrLoadInfIndInfo(loadInfInd, mBuf) != ROK)
10749    {
10750 #if (ERRCLASS & ERRCLS_ADD_RES)
10751       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10752             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10753             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
10754 #endif
10755       SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
10756             sizeof(RgrLoadInfIndInfo));
10757       SPutMsg(mBuf);
10758
10759       return RFAILED;
10760    }
10761
10762    if (SPkS16(suId, mBuf) != ROK)
10763    {
10764 #if (ERRCLASS & ERRCLS_ADD_RES)
10765       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10766             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10767             (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
10768 #endif
10769       SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
10770             sizeof(RgrLoadInfIndInfo));
10771       SPutMsg(mBuf);
10772       return RFAILED;
10773    }
10774
10775    if (SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
10776                   sizeof(RgrLoadInfIndInfo)) != ROK)
10777    {
10778 #if (ERRCLASS & ERRCLS_ADD_RES)
10779       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10780             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10781             (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
10782 #endif
10783       SPutMsg(mBuf);
10784       return RFAILED;
10785    }
10786
10787    pst->event = (Event) EVTRGRLOADINFIND;
10788    return (SPstTsk(pst,mBuf));
10789 }
10790
10791 /***********************************************************
10792 *
10793 *     Func : cmUnpkRgrLoadInfInd
10794 *
10795 *
10796 *     Desc : Unpacking LOAD INFORMATION Indication sent to RRM
10797 *
10798 *     Ret  : S16
10799 *
10800 *     Notes:
10801 *
10802 *     File  :
10803 *
10804 **********************************************************/
10805 #ifdef ANSI
10806 S16 cmUnpkRgrLoadInfInd
10807 (
10808 RgrLoadInfInd func,
10809 Pst *pst,
10810 Buffer *mBuf
10811 )
10812 #else
10813 S16 cmUnpkRgrLoadInfInd(func, pst, mBuf)
10814 RgrLoadInfInd func;
10815 Pst *pst;
10816 Buffer *mBuf;
10817 #endif
10818 {
10819    SuId suId;
10820    RgrLoadInfIndInfo *loadInfInd = NULLP; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
10821
10822
10823    if (SUnpkS16(&suId, mBuf) != ROK)
10824    {
10825       SPutMsg(mBuf);
10826 #if (ERRCLASS & ERRCLS_ADD_RES)
10827       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10828          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10829          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
10830 #endif
10831       return RFAILED;
10832    }
10833
10834    if ((SGetSBuf(pst->region, pst->pool, (Data **)&loadInfInd,
10835                  sizeof(RgrLoadInfIndInfo))) != ROK)
10836    {
10837 #if (ERRCLASS & ERRCLS_ADD_RES)
10838          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10839             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10840             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
10841 #endif
10842          SPutMsg(mBuf);
10843          return RFAILED;
10844    }
10845
10846    /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
10847    if (cmUnpkRgrLoadInfIndInfo(loadInfInd, pst, mBuf) != ROK)
10848    {
10849       SPutSBuf(pst->region, pst->pool, (Data *)loadInfInd,
10850              sizeof(RgrLoadInfIndInfo));
10851       SPutMsg(mBuf);
10852 #if (ERRCLASS & ERRCLS_ADD_RES)
10853       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10854          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10855          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
10856 #endif
10857       return RFAILED;
10858    }
10859
10860    SPutMsg(mBuf);
10861    return ((*func)(pst, suId, loadInfInd));
10862 }
10863 \f
10864
10865 /***********************************************************
10866 *
10867 *     Func : cmPkRgrLoadInfIndInfo
10868 *
10869 *
10870 *     Desc : Packing of LoadInfIndInfo structure
10871 *
10872 *     Ret  : S16
10873 *
10874 *     Notes:
10875 *
10876 *     File  :
10877 *
10878 **********************************************************/
10879 #ifdef ANSI
10880 S16 cmPkRgrLoadInfIndInfo
10881 (
10882 RgrLoadInfIndInfo *param,
10883 Buffer *mBuf
10884 )
10885 #else
10886 S16 cmPkRgrLoadInfIndInfo(param, mBuf)
10887 RgrLoadInfIndInfo *param;
10888 Buffer *mBuf;
10889 #endif
10890 {
10891    uint8_t                     idx;
10892
10893    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
10894    CMCHKPK(oduUnpackUInt16, param->bw, mBuf);
10895    if(RGR_ABS == param->type)
10896    {
10897       for(idx = 0; idx < RGR_ABS_PATTERN_LEN; idx++)
10898       {
10899          CMCHKPK(oduUnpackUInt32, param->u.absLoadInfo[idx], mBuf);
10900       }
10901    }
10902    else
10903    {
10904       CMCHKPK(cmPkTknStrOSXL, &param->u.rntpInfo, mBuf);
10905    }
10906
10907    CMCHKPK(oduUnpackUInt32, param->type, mBuf);
10908
10909    return ROK;
10910 }
10911
10912 /***********************************************************
10913 *
10914 *     Func : cmUnpkRgrLoadInfIndInfo
10915 *
10916 *
10917 *     Desc : Unpacking of LoadInfIndInfo structure
10918 *
10919 *     Ret  : S16
10920 *
10921 *     Notes:
10922 *
10923 *     File  :
10924 *
10925 **********************************************************/
10926 #ifdef ANSI
10927 S16 cmUnpkRgrLoadInfIndInfo
10928 (
10929 RgrLoadInfIndInfo *param,
10930 Pst *pst,
10931 Buffer *mBuf
10932 )
10933 #else
10934 S16 cmUnpkRgrLoadInfIndInfo(param, pst, mBuf)
10935 RgrLoadInfIndInfo *param;
10936 Pst *pst;
10937 Buffer *mBuf;
10938 #endif
10939 {
10940    S8          idx;
10941
10942    /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
10943    TknStrOSXL  *tknStr;
10944    uint16_t         ndx;
10945
10946
10947    CMCHKUNPK(oduPackUInt32, &param->type, mBuf);
10948    if(RGR_ABS == param->type)
10949    {
10950       for(idx = RGR_ABS_PATTERN_LEN -1 ; idx >= 0; idx--)
10951       {
10952          CMCHKUNPK(oduPackUInt32, &param->u.absLoadInfo[(uint8_t)idx], mBuf);
10953       }
10954    }
10955    else
10956    {
10957
10958       /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** Start */
10959       tknStr = &param->u.rntpInfo;
10960
10961       CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
10962
10963       if(tknStr->pres)
10964       {
10965          /* Length */
10966          CMCHKUNPK(oduPackUInt16, &tknStr->len, mBuf);
10967
10968          if ((SGetSBuf(pst->region, pst->pool, (Data **)&tknStr->val,tknStr->len)) != ROK) {
10969 #if (ERRCLASS & ERRCLS_ADD_RES)
10970             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
10971                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
10972                (ErrVal)ERGR052, (ErrVal)0, "Packing failed");
10973 #endif
10974             SPutMsg(mBuf);
10975             return RFAILED;
10976          }
10977
10978          /* Value */
10979          for (ndx = 1; ndx <= tknStr->len; ndx++)
10980          {
10981             CMCHKUNPK(oduPackUInt8, &tknStr->val[tknStr->len - ndx], mBuf);
10982          }
10983       }
10984    }
10985    /* dsfr_pal_fixes ** 21-March-2013 ** SKS ** End */
10986
10987    /* dsfr_pal_fixes ** 22-March-2013 ** SKS */
10988    CMCHKUNPK(oduPackUInt16, &param->bw, mBuf);
10989
10990    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
10991
10992    return ROK;
10993 }
10994 /* LTE_ADV_FLAG_REMOVED_END */
10995
10996 #ifdef TFU_UPGRADE
10997 /*rgr_c_001.main_9 ADD added changes for CQI management*/
10998 /***********************************************************
10999 *
11000 *     Func : cmPkRgrUepACfg
11001 *
11002 *
11003 *     Desc : Transaction ID between MAC and RRM
11004 *
11005 *
11006 *     Ret  : S16
11007 *
11008 *     Notes:
11009 *
11010 *     File  :
11011 *
11012 **********************************************************/
11013 #ifdef ANSI
11014 S16 cmPkRgrUepACfg
11015 (
11016 RgrUepACfg *param,
11017 Buffer *mBuf
11018 )
11019 #else
11020 S16 cmPkRgrUepACfg(param, mBuf)
11021 RgrUepACfg *param;
11022 Buffer *mBuf;
11023 #endif
11024 {
11025
11026    if(param->pAPrsnt)
11027    {
11028       CMCHKPK(oduUnpackUInt32, param->pA, mBuf);
11029    }
11030    CMCHKPK(oduUnpackUInt8, param->pAPrsnt, mBuf);
11031
11032    return ROK;
11033 }
11034
11035 \f
11036 /*rgr_c_001.main_9 ADD added changes for CQI management*/
11037 /***********************************************************
11038 *
11039 *     Func : cmUnpkRgrUepACfg
11040 *
11041 *
11042 *     Desc : Transaction ID between MAC and RRM
11043 *
11044 *
11045 *     Ret  : S16
11046 *
11047 *     Notes:
11048 *
11049 *     File  :
11050 *
11051 **********************************************************/
11052 #ifdef ANSI
11053 S16 cmUnpkRgrUepACfg
11054 (
11055 RgrUepACfg *param,
11056 Buffer *mBuf
11057 )
11058 #else
11059 S16 cmUnpkRgrUepACfg(param, mBuf)
11060 RgrUepACfg *param;
11061 Buffer *mBuf;
11062 #endif
11063 {
11064    uint32_t tmpEnum;
11065
11066    CMCHKUNPK(oduPackUInt8, (uint8_t *)&param->pAPrsnt, mBuf);
11067    if (param->pAPrsnt)
11068    {
11069       CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
11070       param->pA = (RgrUeDlPwrCntrlPaCfg) tmpEnum;
11071    }
11072
11073    return ROK;
11074 }
11075 \f
11076 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
11077 /***********************************************************
11078 *
11079 *     Func : cmPkRgrUePdschDedCfg
11080 *
11081 *
11082 *     Desc : Transaction ID between MAC and RRM
11083 *
11084 *
11085 *     Ret  : S16
11086 *
11087 *     Notes:
11088 *
11089 *     File  :
11090 *
11091 **********************************************************/
11092 #ifdef ANSI
11093 S16 cmPkRgrUePdschDedCfg
11094 (
11095 RgrUePdschDedCfg *param,
11096 Buffer *mBuf
11097 )
11098 #else
11099 S16 cmPkRgrUePdschDedCfg(param, mBuf)
11100 RgrUePdschDedCfg *param;
11101 Buffer *mBuf;
11102 #endif
11103 {
11104
11105    CMCHKPK(cmPkRgrUepACfg, &param->uepACfg, mBuf);
11106
11107    return ROK;
11108 }
11109
11110 \f
11111 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
11112 /***********************************************************
11113 *
11114 *     Func : cmUnpkRgrUePdschDedCfg
11115 *
11116 *
11117 *     Desc : Transaction ID between MAC and RRM
11118 *
11119 *
11120 *     Ret  : S16
11121 *
11122 *     Notes:
11123 *
11124 *     File  :
11125 *
11126 **********************************************************/
11127 #ifdef ANSI
11128 S16 cmUnpkRgrUePdschDedCfg
11129 (
11130 RgrUePdschDedCfg *param,
11131 Buffer *mBuf
11132 )
11133 #else
11134 S16 cmUnpkRgrUePdschDedCfg(param, mBuf)
11135 RgrUePdschDedCfg *param;
11136 Buffer *mBuf;
11137 #endif
11138 {
11139
11140    CMCHKUNPK(cmUnpkRgrUepACfg, &param->uepACfg, mBuf);
11141
11142    return ROK;
11143 }
11144 #endif
11145 \f
11146
11147 #ifdef LTE_ADV
11148
11149 /***********************************************************
11150 *
11151 *     Func : cmPkRgrUeUlPwrDedSCellCfg
11152 *
11153 *
11154 *     Desc : DL Secondary Cell UL PC Info
11155 *
11156 *
11157 *     Ret  : S16
11158 *
11159 *     Notes:
11160 *
11161 *     File  :
11162 *
11163 **********************************************************/
11164 #ifdef ANSI
11165 static S16 cmPkRgrUeUlPwrDedSCellCfg
11166 (
11167 RgrUeUlPwrDedSCellCfg *param,
11168 Buffer *mBuf
11169 )
11170 #else
11171 static S16 cmPkRgrUeUlPwrDedSCellCfg(param, mBuf)
11172 RgrUeUlPwrDedSCellCfg *param;
11173 Buffer *mBuf;
11174 #endif
11175 {
11176    CMCHKPK(oduUnpackUInt8, param->pSRSOffset, mBuf);
11177    CMCHKPK(SPkS8, param->p0UePusch, mBuf);
11178    CMCHKPK(oduUnpackUInt8, param->isDeltaMCSEnabled, mBuf);
11179    CMCHKPK(oduUnpackUInt8, param->isAccumulated, mBuf);
11180
11181    return ROK;
11182 }
11183
11184 /***********************************************************
11185 *
11186 *     Func : cmUnpkRgrUeUlPwrDedSCellCfg
11187 *
11188 *
11189 *     Desc : Uplink power configuration per UE
11190 *
11191 *
11192 *     Ret  : S16
11193 *
11194 *     Notes:
11195 *
11196 *     File  :
11197 *
11198 **********************************************************/
11199 #ifdef ANSI
11200 static S16 cmUnpkRgrUeUlPwrDedSCellCfg
11201 (
11202 RgrUeUlPwrDedSCellCfg *param,
11203 Buffer *mBuf
11204 )
11205 #else
11206 static S16 cmUnpkRgrUeUlPwrDedSCellCfg(param, mBuf)
11207 RgrUeUlPwrDedSCellCfg *param;
11208 Buffer *mBuf;
11209 #endif
11210 {
11211
11212
11213    CMCHKUNPK(oduPackUInt8, &param->isAccumulated, mBuf);
11214    CMCHKUNPK(oduPackUInt8, &param->isDeltaMCSEnabled, mBuf);
11215    CMCHKUNPK(SUnpkS8, &param->p0UePusch, mBuf);
11216    CMCHKUNPK(oduPackUInt8, &param->pSRSOffset, mBuf);
11217    return ROK;
11218 }
11219
11220
11221
11222
11223 /***********************************************************
11224 *
11225 *     Func : cmPkRgrUeSecCellCfg
11226 *
11227 *
11228 *     Desc : DL Secondary Cell information of the UE
11229 *
11230 *
11231 *     Ret  : S16
11232 *
11233 *     Notes:
11234 *
11235 *     File  :
11236 *
11237 **********************************************************/
11238 #ifdef ANSI
11239 static S16 cmPkRgrUeSecCellCfg
11240 (
11241 RgrUeSecCellCfg *param,
11242 Buffer *mBuf
11243 )
11244 #else
11245 static S16 cmPkRgrUeSecCellCfg(param, mBuf)
11246 RgrUeSecCellCfg *param;
11247 Buffer *mBuf;
11248 #endif
11249 {
11250    CMCHKPK(cmPkRgrUeUlPwrDedSCellCfg,&param->ueSCellUlDedPwrCfg, mBuf);
11251    CMCHKPK(oduUnpackUInt8, param->isUlCaEnabled, mBuf);
11252    CMCHKPK(cmPkRgrUeTxModeCfg, &param->txMode, mBuf);
11253 #ifdef TFU_UPGRADE
11254 /*rgr_c_001.main_9 ADD PDSCH ded cfg*/
11255    CMCHKPK(cmPkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
11256 #endif
11257    CMCHKPK(cmPkRgrUeDlCqiCfg,&param->ueSCellDlCqiCfg, mBuf);
11258    CMCHKPK(cmPkTknUInt32, &param->sCellDeActTmr, mBuf);
11259    CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
11260    CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
11261
11262    return ROK;
11263 }
11264
11265
11266 \f
11267 /***********************************************************
11268 *
11269 *     Func : cmPkRgrUeSecCellInfo
11270 *
11271 *
11272 *     Desc : Secondary Cell information of the UE
11273 *
11274 *
11275 *     Ret  : S16
11276 *
11277 *     Notes:
11278 *
11279 *     File  :
11280 *
11281 **********************************************************/
11282 #ifdef ANSI
11283 S16 cmPkRgrUeSecCellInfo
11284 (
11285 RgrUeSecCellInfo *param,
11286 Buffer *mBuf
11287 )
11288 #else
11289 S16 cmPkRgrUeSecCellInfo(param, mBuf)
11290 RgrUeSecCellInfo *param;
11291 Buffer *mBuf;
11292 #endif
11293 {
11294    S8 idx;
11295    for(idx = param->numSCells - 1; idx >= 0; idx--)
11296    {
11297       CMCHKPK(cmPkRgrUeSecCellCfg, &param->ueSCellDedCfg[(uint8_t)idx],mBuf);
11298    }
11299
11300    CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
11301
11302    CMCHKPK(oduUnpackUInt8, param->useExtBSRSizes, mBuf);
11303
11304    return ROK;
11305 }
11306
11307 \f
11308 /***********************************************************
11309 *
11310 *     Func : cmUnpkRgrUeSecCellCfg
11311 *
11312 *
11313 *     Desc : DL Secondary Cell information of the UE
11314 *
11315 *
11316 *     Ret  : S16
11317 *
11318 *     Notes:
11319 *
11320 *     File  :
11321 *
11322 **********************************************************/
11323 #ifdef ANSI
11324 static S16 cmUnpkRgrUeSecCellCfg
11325 (
11326 RgrUeSecCellCfg *param,
11327 Buffer *mBuf
11328 )
11329 #else
11330 static S16 cmUnpkRgrUeSecCellCfg(param, mBuf)
11331 RgrUeSecCellCfg *param;
11332 Buffer *mBuf;
11333 #endif
11334 {
11335    CMCHKUNPK(oduPackUInt8, &param->sCellIdx, mBuf);
11336    CMCHKUNPK(oduPackUInt16, &param->sCellId, mBuf);
11337    CMCHKUNPK(cmUnpkTknUInt32, &param->sCellDeActTmr, mBuf);
11338    CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, &param->ueSCellDlCqiCfg, mBuf);
11339 #ifdef TFU_UPGRADE
11340    CMCHKUNPK(cmUnpkRgrUePdschDedCfg, &param->uePdschDedCfg, mBuf);
11341 #endif
11342    CMCHKUNPK(cmUnpkRgrUeTxModeCfg, &param->txMode, mBuf);
11343    CMCHKUNPK(oduPackUInt8, &param->isUlCaEnabled, mBuf);
11344    CMCHKUNPK(cmUnpkRgrUeUlPwrDedSCellCfg, &param->ueSCellUlDedPwrCfg, mBuf);
11345
11346    return ROK;
11347 }
11348
11349
11350
11351 \f
11352 /***********************************************************
11353 *
11354 *     Func : cmUnpkRgrUeSecCellInfo
11355 *
11356 *
11357 *     Desc : Secondary Cell information of the UE
11358 *
11359 *
11360 *     Ret  : S16
11361 *
11362 *     Notes:
11363 *
11364 *     File  :
11365 *
11366 **********************************************************/
11367 #ifdef ANSI
11368 S16 cmUnpkRgrUeSecCellInfo
11369 (
11370 RgrUeSecCellInfo *param,
11371 Buffer *mBuf
11372 )
11373 #else
11374 S16 cmUnpkRgrUeSecCellInfo(param, mBuf)
11375 RgrUeSecCellInfo *param;
11376 Buffer *mBuf;
11377 #endif
11378 {
11379    uint8_t idx;
11380
11381    CMCHKUNPK(oduPackUInt8, &param->useExtBSRSizes, mBuf);
11382    CMCHKUNPK(oduPackUInt8, &param->numSCells, mBuf);
11383
11384    for(idx = 0; idx < param->numSCells;idx++)
11385    {
11386       CMCHKUNPK(cmUnpkRgrUeSecCellCfg, &param->ueSCellDedCfg[idx],mBuf);
11387    }
11388
11389    return ROK;
11390 }
11391 /* Sprint 3 */
11392 /***********************************************************
11393 *
11394 *     Func : cmPkRgrUeSCellAckPucchCfg
11395 *
11396 *
11397 *     Desc : PUCCH Configuration information of the UE
11398 *
11399 *
11400 *     Ret  : S16
11401 *
11402 *     Notes:
11403 *
11404 *     File  :
11405 *
11406 **********************************************************/
11407 #ifdef ANSI
11408 S16 cmPkRgrUeSCellAckPucchCfg
11409 (
11410 RgrUeSCellAckPucchCfg *param,
11411 Buffer *mBuf
11412 )
11413 #else
11414 S16 cmPkRgrUeSCellAckPucchCfg(param, mBuf)
11415 RgrUeSCellAckPucchCfg *param;
11416 Buffer *mBuf;
11417 #endif
11418 {
11419    S8 idx;
11420
11421    if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
11422    {
11423       for(idx = param->u.format1Bcs.sCellAckN1ResTb2Count - 1; idx >=0 ;idx--)
11424       {
11425          CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(uint8_t)idx], mBuf);
11426       }
11427
11428       CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
11429
11430       for(idx = param->u.format1Bcs.sCellAckN1ResTb1Count - 1; idx >=0 ;idx--)
11431       {
11432          CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(uint8_t)idx], mBuf);
11433       }
11434
11435       CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
11436    }
11437    else
11438    {
11439       for(idx = param->u.format3.sCellAckN3ResAntP1Count - 1; idx >=0 ;idx--)
11440       {
11441          CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(uint8_t)idx], mBuf);
11442       }
11443
11444       CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
11445
11446       for(idx = param->u.format3.sCellAckN3ResAntP0Count- 1; idx >=0 ;idx--)
11447       {
11448          CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(uint8_t)idx], mBuf);
11449       }
11450
11451       CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
11452    }
11453    CMCHKPK(oduUnpackUInt32, param->pucchFormatType, mBuf);
11454
11455    return ROK;
11456 }
11457
11458 /***********************************************************
11459 *
11460 *     Func : cmUnpkRgrUeSCellAckPucchCfg
11461 *
11462 *
11463 *     Desc : PUCCH Configuration information of the UE
11464 *
11465 *
11466 *     Ret  : S16
11467 *
11468 *     Notes:
11469 *
11470 *     File  :
11471 *
11472 **********************************************************/
11473 #ifdef ANSI
11474 S16 cmUnpkRgrUeSCellAckPucchCfg
11475 (
11476 RgrUeSCellAckPucchCfg *param,
11477 Buffer *mBuf
11478 )
11479 #else
11480 S16 cmUnpkRgrUeSCellAckPucchCfg(param, mBuf)
11481 RgrUeSCellAckPucchCfg *param;
11482 Buffer *mBuf;
11483 #endif
11484 {
11485    uint8_t idx;
11486
11487
11488    CMCHKUNPK(oduPackUInt32, (uint32_t*)&param->pucchFormatType, mBuf);
11489    //if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS)
11490    if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
11491    {
11492       CMCHKUNPK(oduPackUInt8, &param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
11493
11494       for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb1Count; idx++)
11495       {
11496          CMCHKUNPK(oduPackUInt16, &param->u.format1Bcs.sCellAckN1ResTb1[idx], mBuf);
11497       }
11498
11499       CMCHKUNPK(oduPackUInt8, &param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
11500
11501       for(idx = 0; idx < param->u.format1Bcs.sCellAckN1ResTb2Count; idx++)
11502       {
11503          CMCHKUNPK(oduPackUInt16, &param->u.format1Bcs.sCellAckN1ResTb2[idx], mBuf);
11504       }
11505    }
11506    else
11507    {
11508       CMCHKUNPK(oduPackUInt8, &param->u.format3.sCellAckN3ResAntP0Count, mBuf);
11509
11510       for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP0Count; idx++)
11511       {
11512          CMCHKUNPK(oduPackUInt16, &param->u.format3.sCellAckN3ResAntP0[idx], mBuf);
11513       }
11514
11515       CMCHKUNPK(oduPackUInt8, &param->u.format3.sCellAckN3ResAntP1Count, mBuf);
11516
11517       for(idx = 0; idx < param->u.format3.sCellAckN3ResAntP1Count; idx++)
11518       {
11519          CMCHKUNPK(oduPackUInt16, &param->u.format3.sCellAckN3ResAntP1[idx], mBuf);
11520       }
11521
11522    }
11523    return ROK;
11524 }
11525
11526
11527
11528
11529 #endif
11530
11531 \f
11532 /***********************************************************
11533 *
11534 *     Func : cmPkRgrUeStaInd
11535 *
11536 *
11537 *     Desc : Packing Ue Sta Indication sent to RRM
11538 *
11539 *
11540 *     Ret  : S16
11541 *
11542 *     Notes:
11543 *
11544 *     File  :
11545 *
11546 **********************************************************/
11547 #ifdef ANSI
11548 S16 cmPkRgrUeStaInd
11549 (
11550 Pst* pst,
11551 SuId suId,
11552 RgrUeStaIndInfo* ueStaInd
11553 )
11554 #else
11555 S16 cmPkRgrUeStaInd(pst, suId, ueStaInd)
11556 Pst* pst;
11557 SuId suId;
11558 RgrUeStaIndInfo* ueStaInd;
11559 #endif
11560 {
11561    Buffer *mBuf = NULLP;
11562    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
11563    {
11564 #if (ERRCLASS & ERRCLS_ADD_RES)
11565       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
11566          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
11567          (ErrVal)ERGR054, (ErrVal)0, "Packing failed");
11568 #endif
11569       SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
11570                sizeof(RgrUeStaIndInfo));
11571       return RFAILED;
11572    }
11573
11574    if (cmPkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
11575    {
11576 #if (ERRCLASS & ERRCLS_ADD_RES)
11577       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
11578             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
11579             (ErrVal)ERGR055, (ErrVal)0, "Packing failed");
11580 #endif
11581       SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
11582                sizeof(RgrUeStaIndInfo));
11583       SPutMsg(mBuf);
11584       return RFAILED;
11585    }
11586
11587    if (SPkS16(suId, mBuf) != ROK)
11588    {
11589 #if (ERRCLASS & ERRCLS_ADD_RES)
11590       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
11591          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
11592          (ErrVal)ERGR056, (ErrVal)0, "Packing failed");
11593 #endif
11594       SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
11595                   sizeof(RgrUeStaIndInfo));
11596       SPutMsg(mBuf);
11597       return RFAILED;
11598    }
11599
11600    if (SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
11601                   sizeof(RgrUeStaIndInfo)) != ROK)
11602    {
11603 #if (ERRCLASS & ERRCLS_ADD_RES)
11604       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
11605          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
11606          (ErrVal)ERGR057, (ErrVal)0, "Packing failed");
11607 #endif
11608       SPutMsg(mBuf);
11609       return RFAILED;
11610    }
11611
11612    pst->event = (Event) EVTRGRUESTAIND;
11613    return (SPstTsk(pst,mBuf));
11614 }
11615
11616 /*rgr_c_001.main_9 ADD added changes for CQI management*/
11617 /***********************************************************
11618 *
11619 *     Func : cmUnpkRgrUeStaInd
11620 *
11621 *
11622 *     Desc : Unpacking Sta Indication sent to RRM
11623 *
11624 *     Ret  : S16
11625 *
11626 *     Notes:
11627 *
11628 *     File  :
11629 *
11630 **********************************************************/
11631 #ifdef ANSI
11632 S16 cmUnpkRgrUeStaInd
11633 (
11634 RgrUeStaInd  func,
11635 Pst *pst,
11636 Buffer *mBuf
11637 )
11638 #else
11639 S16 cmUnpkRgrUeStaInd(func, pst, mBuf)
11640 RgrUeStaInd func;
11641 Pst *pst;
11642 Buffer *mBuf;
11643 #endif
11644 {
11645    SuId suId;
11646    RgrUeStaIndInfo *ueStaInd;
11647
11648
11649    if (SUnpkS16(&suId, mBuf) != ROK)
11650    {
11651       SPutMsg(mBuf);
11652 #if (ERRCLASS & ERRCLS_ADD_RES)
11653       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
11654          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
11655          (ErrVal)ERGR058, (ErrVal)0, "Packing failed");
11656 #endif
11657       return RFAILED;
11658    }
11659
11660    if ((SGetSBuf(pst->region, pst->pool, (Data **)&ueStaInd,
11661                  sizeof(RgrUeStaIndInfo))) != ROK)
11662    {
11663 #if (ERRCLASS & ERRCLS_ADD_RES)
11664          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
11665             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
11666             (ErrVal)ERGR059, (ErrVal)0, "Packing failed");
11667 #endif
11668          SPutMsg(mBuf);
11669          return RFAILED;
11670    }
11671
11672    if (cmUnpkRgrUeStaIndInfo(ueStaInd, mBuf) != ROK)
11673    {
11674       SPutSBuf(pst->region, pst->pool, (Data *)ueStaInd,
11675              sizeof(RgrUeStaIndInfo));
11676       SPutMsg(mBuf);
11677 #if (ERRCLASS & ERRCLS_ADD_RES)
11678       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
11679          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
11680          (ErrVal)ERGR060, (ErrVal)0, "Packing failed");
11681 #endif
11682       return RFAILED;
11683    }
11684
11685    SPutMsg(mBuf);
11686    return ((*func)(pst, suId, ueStaInd));
11687 }
11688 \f
11689 /***********************************************************
11690 *
11691 *     Func : cmPkRgrUeStaIndInfo
11692 *
11693 *
11694 *     Desc : Packing of UeStaIndInfo structure
11695 *
11696 *     Ret  : S16
11697 *
11698 *     Notes:
11699 *
11700 *     File  :
11701 *
11702 **********************************************************/
11703 #ifdef ANSI
11704 S16 cmPkRgrUeStaIndInfo
11705 (
11706 RgrUeStaIndInfo *param,
11707 Buffer *mBuf
11708 )
11709 #else
11710 S16 cmPkRgrUeStaIndInfo(param, mBuf)
11711 RgrUeStaIndInfo *param;
11712 Buffer *mBuf;
11713 #endif
11714 {
11715
11716
11717    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
11718    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
11719    CMCHKPK(oduUnpackUInt8, param->status, mBuf);
11720
11721    return ROK;
11722 }
11723 /***********************************************************
11724 *
11725 *     Func : cmUnpkRgrUeStaIndInfo
11726 *
11727 *
11728 *     Desc : Unpacking of UeStaIndInfo structure
11729 *
11730 *     Ret  : S16
11731 *
11732 *     Notes:
11733 *
11734 *     File  :
11735 *
11736 **********************************************************/
11737 #ifdef ANSI
11738 S16 cmUnpkRgrUeStaIndInfo
11739 (
11740 RgrUeStaIndInfo *param,
11741 Buffer *mBuf
11742 )
11743 #else
11744 S16 cmUnpkRgrUeStaIndInfo(param, mBuf)
11745 RgrUeStaIndInfo *param;
11746 Buffer *mBuf;
11747 #endif
11748 {
11749
11750
11751    CMCHKUNPK(oduPackUInt8, &param->status, mBuf);
11752    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
11753    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
11754
11755    return ROK;
11756 }
11757
11758 \f
11759 /***********************************************************
11760 *
11761 *     Func : cmPkRgrCellCsgParamCfg
11762 *
11763 *
11764 *     Desc : CSG Parameter configuration
11765 *
11766 *
11767 *     Ret  : S16
11768 *
11769 *     Notes:
11770 *
11771 *     File  :
11772 *
11773 **********************************************************/
11774 #ifdef ANSI
11775 S16 cmPkRgrCellCsgParamCfg
11776 (
11777 RgrCellCsgParamCfg *param,
11778 Buffer *mBuf
11779 )
11780 #else
11781 S16 cmPkRgrCellCsgParamCfg(param, mBuf)
11782 RgrCellCsgParamCfg *param;
11783 Buffer *mBuf;
11784 #endif
11785 {
11786
11787
11788    CMCHKPK(oduUnpackUInt8, param->minUlResNonCsg, mBuf);
11789    CMCHKPK(oduUnpackUInt8, param->minDlResNonCsg, mBuf);
11790
11791    return ROK;
11792 }
11793
11794 /***********************************************************
11795 *
11796 *     Func : cmUnpkRgrCellCsgParamCfg
11797 *
11798 *
11799 *     Desc : Unpacking of RgrCellCsgParamCfg structure
11800 *
11801 *     Ret  : S16
11802 *
11803 *     Notes:
11804 *
11805 *     File  :
11806 *
11807 **********************************************************/
11808 #ifdef ANSI
11809 S16 cmUnpkRgrCellCsgParamCfg
11810 (
11811 RgrCellCsgParamCfg *param,
11812 Buffer *mBuf
11813 )
11814 #else
11815 S16 cmUnpkRgrCellCsgParamCfg(param, mBuf)
11816 RgrCellCsgParamCfg *param;
11817 Buffer *mBuf;
11818 #endif
11819 {
11820
11821
11822    CMCHKUNPK(oduPackUInt8, &param->minDlResNonCsg, mBuf);
11823    CMCHKUNPK(oduPackUInt8, &param->minUlResNonCsg, mBuf);
11824
11825    return ROK;
11826 }
11827
11828 /***********************************************************
11829 *
11830 *     Func : cmPkRgrCellCntrlCmdCfg
11831 *
11832 *
11833 *     Desc : Packing of RgrCellCntrlCmdCfg structure
11834 *
11835 *     Ret  : S16
11836 *
11837 *     Notes:
11838 *
11839 *     File  :
11840 *
11841 **********************************************************/
11842 #ifdef ANSI
11843 S16 cmPkRgrCellCntrlCmdCfg
11844 (
11845 RgrCellCntrlCmdCfg *param,
11846 Buffer *mBuf
11847 )
11848 #else
11849 S16 cmPkRgrCellCntrlCmdCfg(param, mBuf)
11850 RgrCellCntrlCmdCfg *param;
11851 Buffer *mBuf;
11852 #endif
11853 {
11854
11855    switch(param->cmdType)
11856    {
11857       case RGR_CNTRL_CMD_RACH_OVRLD:
11858          CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffVal, mBuf);
11859          CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
11860          break;
11861       case RGR_CNTRL_CMD_CPU_OVRLD:
11862          CMCHKUNPK(oduUnpackUInt8, param->cmdDesc.cpuOvrLd.instruction, mBuf);
11863          break;
11864       default:
11865          break;
11866    }
11867    CMCHKUNPK(oduUnpackUInt32, param->cmdType, mBuf);
11868
11869    return ROK;
11870 }
11871 /***********************************************************
11872 *
11873 *     Func : cmUnpkRgrCellCntrlCmdCfg
11874 *
11875 *
11876 *     Desc : Unpacking of RgrCellCntrlCmdCfg structure
11877 *
11878 *     Ret  : S16
11879 *
11880 *     Notes:
11881 *
11882 *     File  :
11883 *
11884 **********************************************************/
11885 #ifdef ANSI
11886 S16 cmUnpkRgrCellCntrlCmdCfg
11887 (
11888 RgrCellCntrlCmdCfg *param,
11889 Buffer *mBuf
11890 )
11891 #else
11892 S16 cmUnpkRgrCellCntrlCmdCfg(param, mBuf)
11893 RgrCellCntrlCmdCfg *param;
11894 Buffer *mBuf;
11895 #endif
11896 {
11897    uint32_t tmpEnum;
11898
11899
11900    CMCHKUNPK(oduPackUInt32, &tmpEnum, mBuf);
11901    param->cmdType = (RgrCellCntrlCmdType) tmpEnum;
11902    switch(param->cmdType)
11903    {
11904       case RGR_CNTRL_CMD_RACH_OVRLD:
11905          CMCHKUNPK(oduPackUInt8, &param->cmdDesc.rachOvrLd.backOffEnb, mBuf);
11906          CMCHKUNPK(oduPackUInt8, &param->cmdDesc.rachOvrLd.backOffVal, mBuf);
11907          break;
11908       case RGR_CNTRL_CMD_CPU_OVRLD:
11909          CMCHKUNPK(oduPackUInt8, &param->cmdDesc.cpuOvrLd.instruction, mBuf);
11910          break;
11911       default:
11912          break;
11913    }
11914
11915    return ROK;
11916 }
11917 #endif /* End of if defined(LCRGR) */
11918
11919 /**********************************************************************
11920          End of file
11921 **********************************************************************/