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