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