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