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