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