src/cm/lrg.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 LRG interface primitives.
  27
  28      File:     lrg.c
  29
  30 **********************************************************************/
  31
  32 /** @file lrg.c
  33 @brief This file contains the packing/unpacking code for the LRG interface
  34        primitives.
  35 */
  36
  37 /* header include files (.h) */
  38 #include "common_def.h"
  39 #include "lrg.h"           /* LRG Interface Defines */
  40 /* header/extern include files (.x) */
  41 #include "lrg.x"           /* LRG Interface includes */
  42
  43 #if (defined(LCLRG))
  44
  45 \f
  46 /**
  47 * @brief This API is used to send a
  48 Configuration Request from LM to MAC.
  49 *
  50 * @details
  51 *
  52 *     Function: cmPkLrgCfgReq
  53 *
  54 *  @param[in]   Pst *  pst
  55 *  @param[in]   RgMngmt *  cfg
  56 *  @return   S16
  57 *      -# ROK
  58 **/
  59 S16 cmPkLrgCfgReq
  60 (
  61 Pst * pst,
  62 RgMngmt * cfg
  63 )
  64 {
  65    Buffer *mBuf = NULLP;
  66
  67    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
  68 #if (ERRCLASS & ERRCLS_ADD_RES)
  69       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  70          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  71          (ErrVal)ELRG001, (ErrVal)0, "Packing failed");
  72 #endif
  73       return RFAILED;
  74    }
  75    if (pst->selector == ODU_SELECTOR_LC) {
  76       if (cmPkRgMngmt(pst, cfg, EVTLRGCFGREQ, mBuf) != ROK) {
  77 #if (ERRCLASS & ERRCLS_ADD_RES)
  78          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  79             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  80             (ErrVal)ELRG002, (ErrVal)0, "Packing failed");
  81 #endif
  82          SPutMsg(mBuf);
  83          return RFAILED;
  84       }
  85    }
  86    pst->event = (Event) EVTLRGCFGREQ;
  87    return (SPstTsk(pst,mBuf));
  88 }
  89
  90 \f
  91 /**
  92 * @brief This API is used to send a
  93 Configuration Request from LM to MAC.
  94 *
  95 * @details
  96 *
  97 *     Function: cmUnpkLrgCfgReq
  98 *
  99 *  @param[in]   Pst *  pst
 100 *  @param[in]   RgMngmt *  cfg
 101 *  @return   S16
 102 *      -# ROK
 103 **/
 104 S16 cmUnpkLrgCfgReq
 105 (
 106 LrgCfgReq func,
 107 Pst *pst,
 108 Buffer *mBuf
 109 )
 110 {
 111    /* lrg_c_001.main_2: Changed Pointer across Interface */
 112    RgMngmt cfg;
 113
 114
 115    if (cmUnpkRgMngmt(pst, &cfg, EVTLRGCFGREQ, mBuf) != ROK) {
 116       SPutMsg(mBuf);
 117 #if (ERRCLASS & ERRCLS_ADD_RES)
 118       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 119             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 120             (ErrVal)ELRG003, (ErrVal)0, "Packing failed");
 121 #endif
 122       return RFAILED;
 123    }
 124    SPutMsg(mBuf);
 125    return ((*func)(pst, &cfg));
 126 }
 127
 128 \f
 129 /**
 130 * @brief This API is used to send a
 131 Configuration Request from LM to SCH.
 132 *
 133 * @details
 134 *
 135 *     Function: cmPkLrgSchCfgReq
 136 *
 137 *  @param[in]   Pst *  pst
 138 *  @param[in]   RgMngmt *  cfg
 139 *  @return   S16
 140 *      -# ROK
 141 **/
 142 S16 cmPkLrgSchCfgReq
 143 (
 144 Pst * pst,
 145 RgMngmt * cfg
 146 )
 147 {
 148    Buffer *mBuf = NULLP;
 149
 150    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 151 #if (ERRCLASS & ERRCLS_ADD_RES)
 152       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 153          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 154          (ErrVal)ELRG004, (ErrVal)0, "Packing failed");
 155 #endif
 156       return RFAILED;
 157    }
 158    if (pst->selector == ODU_SELECTOR_LC) {
 159       if (cmPkRgMngmt(pst, cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
 160 #if (ERRCLASS & ERRCLS_ADD_RES)
 161          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 162             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 163             (ErrVal)ELRG005, (ErrVal)0, "Packing failed");
 164 #endif
 165          SPutMsg(mBuf);
 166          return RFAILED;
 167       }
 168    }
 169
 170    return (SPstTsk(pst,mBuf));
 171 }
 172
 173 \f
 174 /**
 175 * @brief This API is used to send a
 176 Configuration Request from LM to SCH.
 177 *
 178 * @details
 179 *
 180 *     Function: cmUnpkLrgSchCfgReq
 181 *
 182 *  @param[in]   Pst *  pst
 183 *  @param[in]   RgMngmt *  cfg
 184 *  @return   S16
 185 *      -# ROK
 186 **/
 187 S16 cmUnpkLrgSchCfgReq
 188 (
 189 LrgSchCfgReq func,
 190 Pst *pst,
 191 Buffer *mBuf
 192 )
 193 {
 194    /* lrg_c_001.main_2: Changed Pointer across Interface */
 195    RgMngmt cfg;
 196
 197
 198    if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGREQ, mBuf) != ROK) {
 199       SPutMsg(mBuf);
 200 #if (ERRCLASS & ERRCLS_ADD_RES)
 201       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 202             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 203             (ErrVal)ELRG006, (ErrVal)0, "Packing failed");
 204 #endif
 205       return RFAILED;
 206    }
 207    SPutMsg(mBuf);
 208    return ((*func)(pst, &cfg));
 209 }
 210
 211 \f
 212 /**
 213 * @brief This API is used to send a
 214 Configuration Confirm from MAC to LM.
 215 *
 216 * @details
 217 *
 218 *     Function: cmPkLrgCfgCfm
 219 *
 220 *  @param[in]   Pst *  pst
 221 *  @param[in]   RgMngmt *  cfm
 222 *  @return   S16
 223 *      -# ROK
 224 **/
 225 uint8_t cmPkLrgCfgCfm
 226 (
 227 Pst * pst,
 228 RgMngmt * cfm
 229 )
 230 {
 231    Buffer *mBuf = NULLP;
 232
 233    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 234 #if (ERRCLASS & ERRCLS_ADD_RES)
 235       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 236          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 237          (ErrVal)ELRG007, (ErrVal)0, "Packing failed");
 238 #endif
 239       return RFAILED;
 240    }
 241    if (pst->selector == ODU_SELECTOR_LC) {
 242       if (cmPkRgMngmt(pst, cfm, EVTLRGCFGCFM, mBuf) != ROK) {
 243 #if (ERRCLASS & ERRCLS_ADD_RES)
 244          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 245             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 246             (ErrVal)ELRG008, (ErrVal)0, "Packing failed");
 247 #endif
 248          SPutMsg(mBuf);
 249          return RFAILED;
 250       }
 251    }
 252
 253    pst->event = (Event) EVTLRGCFGCFM;
 254    return (SPstTsk(pst,mBuf));
 255 }
 256
 257 \f
 258 /**
 259 * @brief This API is used to send a
 260 Configuration Confirm from MAC to LM.
 261 *
 262 * @details
 263 *
 264 *     Function: cmUnpkLrgCfgCfm
 265 *
 266 *  @param[in]   Pst *  pst
 267 *  @param[in]   RgMngmt *  cfm
 268 *  @return   S16
 269 *      -# ROK
 270 **/
 271 S16 cmUnpkLrgCfgCfm
 272 (
 273 LrgCfgCfm func,
 274 Pst *pst,
 275 Buffer *mBuf
 276 )
 277 {
 278    RgMngmt cfm;
 279
 280
 281    if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCFGCFM, mBuf) != ROK) {
 282       SPutMsg(mBuf);
 283 #if (ERRCLASS & ERRCLS_ADD_RES)
 284       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 285             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 286             (ErrVal)ELRG009, (ErrVal)0, "Packing failed");
 287 #endif
 288       return RFAILED;
 289    }
 290    SPutMsg(mBuf);
 291    return ((*func)(pst, &cfm));
 292 }
 293
 294 \f
 295 /**
 296 * @brief This API is used to send a
 297 Configuration Confirm from SCH to LM.
 298 *
 299 * @details
 300 *
 301 *     Function: cmPkLrgSchCfgCfm
 302 *
 303 *  @param[in]   Pst *  pst
 304 *  @param[in]   RgMngmt *  cfg
 305 *  @return   S16
 306 *      -# ROK
 307 **/
 308 uint8_t cmPkLrgSchCfgCfm
 309 (
 310 Pst * pst,
 311 RgMngmt * cfg
 312 )
 313 {
 314    Buffer *mBuf = NULLP;
 315
 316    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 317 #if (ERRCLASS & ERRCLS_ADD_RES)
 318       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 319          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 320          (ErrVal)ELRG010, (ErrVal)0, "Packing failed");
 321 #endif
 322       return RFAILED;
 323    }
 324    if (pst->selector == ODU_SELECTOR_LC) {
 325       if (cmPkRgMngmt(pst, cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
 326 #if (ERRCLASS & ERRCLS_ADD_RES)
 327          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 328             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 329             (ErrVal)ELRG011, (ErrVal)0, "Packing failed");
 330 #endif
 331          SPutMsg(mBuf);
 332          return RFAILED;
 333       }
 334    }
 335
 336    pst->event = (Event) EVTMACSCHGENCFGCFM;
 337    return (SPstTsk(pst,mBuf));
 338 }
 339
 340 \f
 341 /**
 342 * @brief This API is used to send a
 343 Configuration Confirm from SCH to LM.
 344 *
 345 * @details
 346 *
 347 *     Function: cmUnpkLrgSchCfgCfm
 348 *
 349 *  @param[in]   Pst *  pst
 350 *  @param[in]   RgMngmt *  cfg
 351 *  @return   S16
 352 *      -# ROK
 353 **/
 354 S16 cmUnpkLrgSchCfgCfm
 355 (
 356 LrgSchCfgCfm func,
 357 Pst *pst,
 358 Buffer *mBuf
 359 )
 360 {
 361    RgMngmt cfg;
 362
 363    if (cmUnpkRgMngmt(pst, &cfg, EVTMACSCHGENCFGCFM, mBuf) != ROK) {
 364       SPutMsg(mBuf);
 365 #if (ERRCLASS & ERRCLS_ADD_RES)
 366       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 367             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 368             (ErrVal)ELRG012, (ErrVal)0, "Packing failed");
 369 #endif
 370       return RFAILED;
 371    }
 372    SPutMsg(mBuf);
 373    return ((*func)(pst, &cfg));
 374 }
 375
 376 \f
 377 /**
 378 * @brief This API is used to send a
 379 Statistics Request from LM to MAC.
 380 *
 381 * @details
 382 *
 383 *     Function: cmPkLrgStsReq
 384 *
 385 *  @param[in]   Pst *  pst
 386 *  @param[in]   RgMngmt *  sts
 387 *  @return   S16
 388 *      -# ROK
 389 **/
 390 S16 cmPkLrgStsReq
 391 (
 392 Pst * pst,
 393 RgMngmt * sts
 394 )
 395 {
 396    Buffer *mBuf = NULLP;
 397
 398    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 399 #if (ERRCLASS & ERRCLS_ADD_RES)
 400       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 401          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 402          (ErrVal)ELRG013, (ErrVal)0, "Packing failed");
 403 #endif
 404       return RFAILED;
 405    }
 406    if (pst->selector == ODU_SELECTOR_LC) {
 407       if (cmPkRgMngmt(pst, sts, EVTLRGSTSREQ, mBuf) != ROK) {
 408 #if (ERRCLASS & ERRCLS_ADD_RES)
 409          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 410             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 411             (ErrVal)ELRG014, (ErrVal)0, "Packing failed");
 412 #endif
 413          SPutMsg(mBuf);
 414          return RFAILED;
 415       }
 416    }
 417
 418    pst->event = (Event) EVTLRGSTSREQ;
 419    return (SPstTsk(pst,mBuf));
 420 }
 421
 422 \f
 423 /**
 424 * @brief This API is used to send a
 425 Statistics Request from LM to MAC.
 426 *
 427 * @details
 428 *
 429 *     Function: cmUnpkLrgStsReq
 430 *
 431 *  @param[in]   Pst *  pst
 432 *  @param[in]   RgMngmt *  sts
 433 *  @return   S16
 434 *      -# ROK
 435 **/
 436 S16 cmUnpkLrgStsReq
 437 (
 438 LrgStsReq func,
 439 Pst *pst,
 440 Buffer *mBuf
 441 )
 442 {
 443    RgMngmt sts;
 444
 445
 446    if (cmUnpkRgMngmt(pst, &sts, EVTLRGSTSREQ, mBuf) != ROK) {
 447       SPutMsg(mBuf);
 448 #if (ERRCLASS & ERRCLS_ADD_RES)
 449       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 450             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 451             (ErrVal)ELRG015, (ErrVal)0, "Packing failed");
 452 #endif
 453       return RFAILED;
 454    }
 455    SPutMsg(mBuf);
 456    return ((*func)(pst, &sts));
 457 }
 458
 459 \f
 460 /**
 461 * @brief This API is used to send a
 462 Statistics Confirm from MAC to LM.
 463 *
 464 * @details
 465 *
 466 *     Function: cmPkLrgStsCfm
 467 *
 468 *  @param[in]   Pst *  pst
 469 *  @param[in]   RgMngmt *  cfm
 470 *  @return   S16
 471 *      -# ROK
 472 **/
 473 S16 cmPkLrgStsCfm
 474 (
 475 Pst * pst,
 476 RgMngmt * cfm
 477 )
 478 {
 479    Buffer *mBuf = NULLP;
 480
 481    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 482 #if (ERRCLASS & ERRCLS_ADD_RES)
 483       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 484          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 485          (ErrVal)ELRG016, (ErrVal)0, "Packing failed");
 486 #endif
 487       return RFAILED;
 488    }
 489    if (pst->selector == ODU_SELECTOR_LC) {
 490       if (cmPkRgMngmt(pst, cfm, EVTLRGSTSCFM, mBuf) != ROK) {
 491 #if (ERRCLASS & ERRCLS_ADD_RES)
 492          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 493             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 494             (ErrVal)ELRG017, (ErrVal)0, "Packing failed");
 495 #endif
 496          SPutMsg(mBuf);
 497          return RFAILED;
 498       }
 499    }
 500
 501    pst->event = (Event) EVTLRGSTSCFM;
 502    return (SPstTsk(pst,mBuf));
 503 }
 504
 505 \f
 506 /**
 507 * @brief This API is used to send a
 508 Statistics Confirm from MAC to LM.
 509 *
 510 * @details
 511 *
 512 *     Function: cmUnpkLrgStsCfm
 513 *
 514 *  @param[in]   Pst *  pst
 515 *  @param[in]   RgMngmt *  cfm
 516 *  @return   S16
 517 *      -# ROK
 518 **/
 519 S16 cmUnpkLrgStsCfm
 520 (
 521 LrgStsCfm func,
 522 Pst *pst,
 523 Buffer *mBuf
 524 )
 525 {
 526    RgMngmt cfm;
 527
 528
 529    if (cmUnpkRgMngmt(pst, &cfm, EVTLRGSTSCFM, mBuf) != ROK) {
 530       SPutMsg(mBuf);
 531 #if (ERRCLASS & ERRCLS_ADD_RES)
 532       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 533             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 534             (ErrVal)ELRG018, (ErrVal)0, "Packing failed");
 535 #endif
 536       return RFAILED;
 537    }
 538    SPutMsg(mBuf);
 539    return ((*func)(pst, &cfm));
 540 }
 541
 542 \f
 543 /**
 544 * @brief This API is used to send a
 545 Status Request from LM to MAC.
 546 *
 547 * @details
 548 *
 549 *     Function: cmPkLrgStaReq
 550 *
 551 *  @param[in]   Pst *  pst
 552 *  @param[in]   RgMngmt *  sta
 553 *  @return   S16
 554 *      -# ROK
 555 **/
 556 S16 cmPkLrgStaReq
 557 (
 558 Pst * pst,
 559 RgMngmt * sta
 560 )
 561 {
 562    Buffer *mBuf = NULLP;
 563
 564    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 565 #if (ERRCLASS & ERRCLS_ADD_RES)
 566       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 567          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 568          (ErrVal)ELRG019, (ErrVal)0, "Packing failed");
 569 #endif
 570       return RFAILED;
 571    }
 572    if (cmPkRgMngmt(pst, sta, EVTLRGSSTAREQ, mBuf) != ROK) {
 573 #if (ERRCLASS & ERRCLS_ADD_RES)
 574       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 575             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 576             (ErrVal)ELRG020, (ErrVal)0, "Packing failed");
 577 #endif
 578       SPutMsg(mBuf);
 579       return RFAILED;
 580    }
 581
 582    pst->event = (Event) EVTLRGSSTAREQ;
 583    return (SPstTsk(pst,mBuf));
 584 }
 585
 586 \f
 587 /**
 588 * @brief This API is used to send a
 589 Status Request from LM to MAC.
 590 *
 591 * @details
 592 *
 593 *     Function: cmUnpkLrgStaReq
 594 *
 595 *  @param[in]   Pst *  pst
 596 *  @param[in]   RgMngmt *  sta
 597 *  @return   S16
 598 *      -# ROK
 599 **/
 600 S16 cmUnpkLrgStaReq
 601 (
 602 LrgStaReq func,
 603 Pst *pst,
 604 Buffer *mBuf
 605 )
 606 {
 607    RgMngmt sta;
 608
 609
 610    memset(&sta, 0, sizeof(RgMngmt));
 611    if (cmUnpkRgMngmt(pst, &sta, EVTLRGSSTAREQ, mBuf) != ROK) {
 612 #if (ERRCLASS & ERRCLS_ADD_RES)
 613       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 614             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 615             (ErrVal)ELRG021, (ErrVal)0, "Packing failed");
 616 #endif
 617       SPutMsg(mBuf);
 618       return RFAILED;
 619    }
 620    SPutMsg(mBuf);
 621    return ((*func)(pst, &sta));
 622 }
 623
 624 \f
 625 /**
 626 * @brief This API is used to send a
 627 Status Confirm from MAC to LM.
 628 *
 629 * @details
 630 *
 631 *     Function: cmPkLrgStaCfm
 632 *
 633 *  @param[in]   Pst *  pst
 634 *  @param[in]   RgMngmt *  cfm
 635 *  @return   S16
 636 *      -# ROK
 637 **/
 638 S16 cmPkLrgStaCfm
 639 (
 640 Pst * pst,
 641 RgMngmt * cfm
 642 )
 643 {
 644    Buffer *mBuf = NULLP;
 645
 646    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 647 #if (ERRCLASS & ERRCLS_ADD_RES)
 648       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 649          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 650          (ErrVal)ELRG022, (ErrVal)0, "Packing failed");
 651 #endif
 652       return RFAILED;
 653    }
 654    if (cmPkRgMngmt(pst, cfm, EVTLRGSSTACFM, mBuf) != ROK) {
 655 #if (ERRCLASS & ERRCLS_ADD_RES)
 656       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 657             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 658             (ErrVal)ELRG023, (ErrVal)0, "Packing failed");
 659 #endif
 660       SPutMsg(mBuf);
 661       return RFAILED;
 662    }
 663
 664    pst->event = (Event) EVTLRGSSTACFM;
 665    return (SPstTsk(pst,mBuf));
 666 }
 667
 668 \f
 669 /**
 670 * @brief This API is used to send a
 671 Status Confirm from MAC to LM.
 672 *
 673 * @details
 674 *
 675 *     Function: cmUnpkLrgStaCfm
 676 *
 677 *  @param[in]   Pst *  pst
 678 *  @param[in]   RgMngmt *  cfm
 679 *  @return   S16
 680 *      -# ROK
 681 **/
 682 S16 cmUnpkLrgStaCfm
 683 (
 684 LrgStaCfm func,
 685 Pst *pst,
 686 Buffer *mBuf
 687 )
 688 {
 689    RgMngmt cfm;
 690
 691
 692    memset(&cfm, 0, sizeof(RgMngmt));
 693    if (cmUnpkRgMngmt(pst, &cfm, EVTLRGSSTACFM, mBuf) != ROK) {
 694 #if (ERRCLASS & ERRCLS_ADD_RES)
 695       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 696             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 697             (ErrVal)ELRG024, (ErrVal)0, "Packing failed");
 698 #endif
 699       SPutMsg(mBuf);
 700       return RFAILED;
 701    }
 702    SPutMsg(mBuf);
 703    return ((*func)(pst, &cfm));
 704 }
 705
 706 \f
 707 /**
 708 * @brief This API is used to send a
 709 Status Indication from MAC to LM.
 710 *
 711 * @details
 712 *
 713 *     Function: cmPkLrgStaInd
 714 *
 715 *  @param[in]   Pst *  pst
 716 *  @param[in]   RgMngmt *  usta
 717 *  @return   S16
 718 *      -# ROK
 719 **/
 720 S16 cmPkLrgStaInd
 721 (
 722 Pst * pst,
 723 RgMngmt * usta
 724 )
 725 {
 726    Buffer *mBuf = NULLP;
 727
 728    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 729 #if (ERRCLASS & ERRCLS_ADD_RES)
 730       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 731          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 732          (ErrVal)ELRG025, (ErrVal)0, "Packing failed");
 733 #endif
 734       return RFAILED;
 735    }
 736    if (pst->selector == ODU_SELECTOR_LC) {
 737       if (cmPkRgMngmt(pst, usta, EVTLRGUSTAIND, mBuf) != ROK) {
 738 #if (ERRCLASS & ERRCLS_ADD_RES)
 739          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 740             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 741             (ErrVal)ELRG026, (ErrVal)0, "Packing failed");
 742 #endif
 743          SPutMsg(mBuf);
 744          return RFAILED;
 745       }
 746    }
 747
 748    pst->event = (Event) EVTLRGUSTAIND;
 749    return (SPstTsk(pst,mBuf));
 750 }
 751
 752 \f
 753 /**
 754 * @brief This API is used to send a
 755 Status Indication from MAC to LM.
 756 *
 757 * @details
 758 *
 759 *     Function: cmUnpkLrgStaInd
 760 *
 761 *  @param[in]   Pst *  pst
 762 *  @param[in]   RgMngmt *  usta
 763 *  @return   S16
 764 *      -# ROK
 765 **/
 766 S16 cmUnpkLrgStaInd
 767 (
 768 LrgStaInd func,
 769 Pst *pst,
 770 Buffer *mBuf
 771 )
 772 {
 773    RgMngmt usta;
 774
 775
 776    if (cmUnpkRgMngmt(pst, &usta, EVTLRGUSTAIND, mBuf) != ROK) {
 777       SPutMsg(mBuf);
 778 #if (ERRCLASS & ERRCLS_ADD_RES)
 779       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 780             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 781             (ErrVal)ELRG027, (ErrVal)0, "Packing failed");
 782 #endif
 783       return RFAILED;
 784    }
 785    SPutMsg(mBuf);
 786    return ((*func)(pst, &usta));
 787 }
 788
 789 \f
 790 /**
 791 * @brief This API is used to send a
 792 Status Indication from SCH to LM.
 793 *
 794 * @details
 795 *
 796 *     Function: cmPkLrgSchStaInd
 797 *
 798 *  @param[in]   Pst *  pst
 799 *  @param[in]   RgMngmt *  sta
 800 *  @return   S16
 801 *      -# ROK
 802 **/
 803 S16 cmPkLrgSchStaInd
 804 (
 805 Pst * pst,
 806 RgMngmt * sta
 807 )
 808 {
 809    Buffer *mBuf = NULLP;
 810
 811    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 812 #if (ERRCLASS & ERRCLS_ADD_RES)
 813       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 814          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 815          (ErrVal)ELRG028, (ErrVal)0, "Packing failed");
 816 #endif
 817       return RFAILED;
 818    }
 819    if (pst->selector == ODU_SELECTOR_LC) {
 820       if (cmPkRgMngmt(pst, sta, EVTLRGSCHSTAIND, mBuf) != ROK) {
 821 #if (ERRCLASS & ERRCLS_ADD_RES)
 822          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 823             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 824             (ErrVal)ELRG029, (ErrVal)0, "Packing failed");
 825 #endif
 826          SPutMsg(mBuf);
 827          return RFAILED;
 828       }
 829    }
 830
 831    pst->event = (Event) EVTLRGSCHSTAIND;
 832    return (SPstTsk(pst,mBuf));
 833 }
 834
 835 \f
 836 /**
 837 * @brief This API is used to send a
 838 Status Indication from SCH to LM.
 839 *
 840 * @details
 841 *
 842 *     Function: cmUnpkLrgSchStaInd
 843 *
 844 *  @param[in]   Pst *  pst
 845 *  @param[in]   RgMngmt *  sta
 846 *  @return   S16
 847 *      -# ROK
 848 **/
 849 S16 cmUnpkLrgSchStaInd
 850 (
 851 LrgSchStaInd func,
 852 Pst *pst,
 853 Buffer *mBuf
 854 )
 855 {
 856    RgMngmt sta;
 857
 858
 859    if (cmUnpkRgMngmt(pst, &sta, EVTLRGSCHSTAIND, mBuf) != ROK) {
 860       SPutMsg(mBuf);
 861 #if (ERRCLASS & ERRCLS_ADD_RES)
 862       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 863             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 864             (ErrVal)ELRG030, (ErrVal)0, "Packing failed");
 865 #endif
 866       return RFAILED;
 867    }
 868    SPutMsg(mBuf);
 869    return ((*func)(pst, &sta));
 870 }
 871
 872 \f
 873 /**
 874 * @brief This API is used to send a
 875 Control Request from LM to MAC.
 876 *
 877 * @details
 878 *
 879 *     Function: cmPkLrgCntrlReq
 880 *
 881 *  @param[in]   Pst *  pst
 882 *  @param[in]   RgMngmt *  cntrl
 883 *  @return   S16
 884 *      -# ROK
 885 **/
 886 S16 cmPkLrgCntrlReq
 887 (
 888 Pst * pst,
 889 RgMngmt * cntrl
 890 )
 891 {
 892    Buffer *mBuf = NULLP;
 893
 894    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 895 #if (ERRCLASS & ERRCLS_ADD_RES)
 896       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 897          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 898          (ErrVal)ELRG031, (ErrVal)0, "Packing failed");
 899 #endif
 900       return RFAILED;
 901    }
 902    if (pst->selector == ODU_SELECTOR_LC) {
 903       if (cmPkRgMngmt(pst, cntrl, EVTLRGCNTRLREQ, mBuf) != ROK) {
 904 #if (ERRCLASS & ERRCLS_ADD_RES)
 905          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 906             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 907             (ErrVal)ELRG032, (ErrVal)0, "Packing failed");
 908 #endif
 909          SPutMsg(mBuf);
 910          return RFAILED;
 911       }
 912    }
 913
 914    pst->event = (Event) EVTLRGCNTRLREQ;
 915    return (SPstTsk(pst,mBuf));
 916 }
 917
 918 \f
 919 /**
 920 * @brief This API is used to send a
 921 Control Request from LM to MAC.
 922 *
 923 * @details
 924 *
 925 *     Function: cmUnpkLrgCntrlReq
 926 *
 927 *  @param[in]   Pst *  pst
 928 *  @param[in]   RgMngmt *  cntrl
 929 *  @return   S16
 930 *      -# ROK
 931 **/
 932 S16 cmUnpkLrgCntrlReq
 933 (
 934 LrgCntrlReq func,
 935 Pst *pst,
 936 Buffer *mBuf
 937 )
 938 {
 939    RgMngmt cntrl;
 940
 941
 942    if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGCNTRLREQ, mBuf) != ROK) {
 943       SPutMsg(mBuf);
 944 #if (ERRCLASS & ERRCLS_ADD_RES)
 945       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 946             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 947             (ErrVal)ELRG033, (ErrVal)0, "Packing failed");
 948 #endif
 949       return RFAILED;
 950    }
 951    SPutMsg(mBuf);
 952    return ((*func)(pst, &cntrl));
 953 }
 954
 955 \f
 956 /**
 957 * @brief This API is used to send a
 958 Control Request from LM to SCH.
 959 *
 960 * @details
 961 *
 962 *     Function: cmPkLrgSchCntrlReq
 963 *
 964 *  @param[in]   Pst *  pst
 965 *  @param[in]   RgMngmt *  cntrl
 966 *  @return   S16
 967 *      -# ROK
 968 **/
 969 S16 cmPkLrgSchCntrlReq
 970 (
 971 Pst * pst,
 972 RgMngmt * cntrl
 973 )
 974 {
 975    Buffer *mBuf = NULLP;
 976
 977    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 978 #if (ERRCLASS & ERRCLS_ADD_RES)
 979       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 980          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 981          (ErrVal)ELRG034, (ErrVal)0, "Packing failed");
 982 #endif
 983       return RFAILED;
 984    }
 985    if (pst->selector == ODU_SELECTOR_LC) {
 986       if (cmPkRgMngmt(pst, cntrl, EVTLRGSCHCNTRLREQ, mBuf) != ROK) {
 987 #if (ERRCLASS & ERRCLS_ADD_RES)
 988          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 989             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 990             (ErrVal)ELRG035, (ErrVal)0, "Packing failed");
 991 #endif
 992          SPutMsg(mBuf);
 993          return RFAILED;
 994       }
 995    }
 996
 997    pst->event = (Event) EVTLRGSCHCNTRLREQ;
 998    return (SPstTsk(pst,mBuf));
 999 }
1000
1001 \f
1002 /**
1003 * @brief This API is used to send a
1004 Control Request from LM to SCH.
1005 *
1006 * @details
1007 *
1008 *     Function: cmUnpkLrgSchCntrlReq
1009 *
1010 *  @param[in]   Pst *  pst
1011 *  @param[in]   RgMngmt *  cntrl
1012 *  @return   S16
1013 *      -# ROK
1014 **/
1015 S16 cmUnpkLrgSchCntrlReq
1016 (
1017 LrgSchCntrlReq func,
1018 Pst *pst,
1019 Buffer *mBuf
1020 )
1021 {
1022    RgMngmt cntrl;
1023
1024
1025    if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLREQ, mBuf) != ROK) {
1026       SPutMsg(mBuf);
1027 #if (ERRCLASS & ERRCLS_ADD_RES)
1028       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1029             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1030             (ErrVal)ELRG036, (ErrVal)0, "Packing failed");
1031 #endif
1032       return RFAILED;
1033    }
1034    SPutMsg(mBuf);
1035    return ((*func)(pst, &cntrl));
1036 }
1037
1038 \f
1039 /**
1040 * @brief This API is used to send a
1041 Control Confirm from MAC to LM.
1042 *
1043 * @details
1044 *
1045 *     Function: cmPkLrgCntrlCfm
1046 *
1047 *  @param[in]   Pst *  pst
1048 *  @param[in]   RgMngmt *  cfm
1049 *  @return   S16
1050 *      -# ROK
1051 **/
1052 S16 cmPkLrgCntrlCfm
1053 (
1054 Pst * pst,
1055 RgMngmt * cfm
1056 )
1057 {
1058    Buffer *mBuf = NULLP;
1059
1060    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1061 #if (ERRCLASS & ERRCLS_ADD_RES)
1062       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1063          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1064          (ErrVal)ELRG037, (ErrVal)0, "Packing failed");
1065 #endif
1066       return RFAILED;
1067    }
1068    if (pst->selector == ODU_SELECTOR_LC) {
1069       if (cmPkRgMngmt(pst, cfm, EVTLRGCNTRLCFM, mBuf) != ROK) {
1070 #if (ERRCLASS & ERRCLS_ADD_RES)
1071          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1072             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1073             (ErrVal)ELRG038, (ErrVal)0, "Packing failed");
1074 #endif
1075          SPutMsg(mBuf);
1076          return RFAILED;
1077       }
1078    }
1079
1080    pst->event = (Event) EVTLRGCNTRLCFM;
1081    return (SPstTsk(pst,mBuf));
1082 }
1083
1084 \f
1085 /**
1086 * @brief This API is used to send a
1087 Control Confirm from MAC to LM.
1088 *
1089 * @details
1090 *
1091 *     Function: cmUnpkLrgCntrlCfm
1092 *
1093 *  @param[in]   Pst *  pst
1094 *  @param[in]   RgMngmt *  cfm
1095 *  @return   S16
1096 *      -# ROK
1097 **/
1098 S16 cmUnpkLrgCntrlCfm
1099 (
1100 LrgCntrlCfm func,
1101 Pst *pst,
1102 Buffer *mBuf
1103 )
1104 {
1105    RgMngmt cfm;
1106
1107
1108    if (cmUnpkRgMngmt(pst, &cfm, EVTLRGCNTRLCFM, mBuf) != ROK) {
1109       SPutMsg(mBuf);
1110 #if (ERRCLASS & ERRCLS_ADD_RES)
1111       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1112             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1113             (ErrVal)ELRG039, (ErrVal)0, "Packing failed");
1114 #endif
1115       return RFAILED;
1116    }
1117    SPutMsg(mBuf);
1118    return ((*func)(pst, &cfm));
1119 }
1120
1121 \f
1122 /**
1123 * @brief This API is used to send a
1124 Control Confirm from SCH to LM.
1125 *
1126 * @details
1127 *
1128 *     Function: cmPkLrgSchCntrlCfm
1129 *
1130 *  @param[in]   Pst *  pst
1131 *  @param[in]   RgMngmt *  cntrl
1132 *  @return   S16
1133 *      -# ROK
1134 **/
1135 S16 cmPkLrgSchCntrlCfm
1136 (
1137 Pst * pst,
1138 RgMngmt * cntrl
1139 )
1140 {
1141    Buffer *mBuf = NULLP;
1142
1143    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1144 #if (ERRCLASS & ERRCLS_ADD_RES)
1145       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1146          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1147          (ErrVal)ELRG040, (ErrVal)0, "Packing failed");
1148 #endif
1149       return RFAILED;
1150    }
1151    if (pst->selector == ODU_SELECTOR_LC) {
1152       if (cmPkRgMngmt(pst, cntrl, EVTLRGSCHCNTRLCFM, mBuf) != ROK) {
1153 #if (ERRCLASS & ERRCLS_ADD_RES)
1154          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1155             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1156             (ErrVal)ELRG041, (ErrVal)0, "Packing failed");
1157 #endif
1158          SPutMsg(mBuf);
1159          return RFAILED;
1160       }
1161    }
1162
1163    pst->event = (Event) EVTLRGSCHCNTRLCFM;
1164    return (SPstTsk(pst,mBuf));
1165 }
1166
1167 \f
1168 /**
1169 * @brief This API is used to send a
1170 Control Confirm from SCH to LM.
1171 *
1172 * @details
1173 *
1174 *     Function: cmUnpkLrgSchCntrlCfm
1175 *
1176 *  @param[in]   Pst *  pst
1177 *  @param[in]   RgMngmt *  cntrl
1178 *  @return   S16
1179 *      -# ROK
1180 **/
1181 S16 cmUnpkLrgSchCntrlCfm
1182 (
1183 LrgSchCntrlCfm func,
1184 Pst *pst,
1185 Buffer *mBuf
1186 )
1187 {
1188    RgMngmt cntrl;
1189
1190
1191    if (cmUnpkRgMngmt(pst, &cntrl, EVTLRGSCHCNTRLCFM, mBuf) != ROK) {
1192       SPutMsg(mBuf);
1193 #if (ERRCLASS & ERRCLS_ADD_RES)
1194       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1195             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1196             (ErrVal)ELRG042, (ErrVal)0, "Packing failed");
1197 #endif
1198       return RFAILED;
1199    }
1200    SPutMsg(mBuf);
1201    return ((*func)(pst, &cntrl));
1202 }
1203
1204 \f
1205 /**
1206 * @brief This API is used to send a
1207 Trace Indication from MAC to LM.
1208 *
1209 * @details
1210 *
1211 *     Function: cmPkLrgTrcInd
1212 *
1213 *  @param[in]   Pst *  pst
1214 *  @param[in]   RgMngmt *  trc
1215 *  @param[in]   Buffer *  trcBuf
1216 *  @return   S16
1217 *      -# ROK
1218 **/
1219 S16 cmPkLrgTrcInd
1220 (
1221 Pst * pst,
1222 RgMngmt * trc,
1223 Buffer * trcBuf
1224 )
1225 {
1226    Buffer *mBuf = NULLP;
1227
1228    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1229 #if (ERRCLASS & ERRCLS_ADD_RES)
1230       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1231          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1232          (ErrVal)ELRG043, (ErrVal)0, "Packing failed");
1233 #endif
1234       SPutMsg(trcBuf);
1235       return RFAILED;
1236    }
1237    if (pst->selector == ODU_SELECTOR_LC) {
1238       MsgLen msgLen;
1239       if (SFndLenMsg(trcBuf, &msgLen) != ROK) {
1240 #if (ERRCLASS & ERRCLS_ADD_RES)
1241          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1242             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1243             (ErrVal)ELRG044, (ErrVal)0, "Packing failed");
1244 #endif
1245          SPutMsg(trcBuf);
1246          return RFAILED;
1247       }
1248       if (SCatMsg(mBuf, trcBuf, M1M2) != ROK) {
1249 #if (ERRCLASS & ERRCLS_ADD_RES)
1250          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1251             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1252             (ErrVal)ELRG045, (ErrVal)0, "Packing failed");
1253 #endif
1254          SPutMsg(trcBuf);
1255          return RFAILED;
1256       }
1257       SPutMsg(trcBuf);
1258       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
1259    }
1260    if (cmPkRgMngmt(pst, trc, EVTLRGTRCIND, mBuf) != ROK) {
1261 #if (ERRCLASS & ERRCLS_ADD_RES)
1262       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1263             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1264             (ErrVal)ELRG046, (ErrVal)0, "Packing failed");
1265 #endif
1266       SPutMsg(trcBuf);
1267       SPutMsg(mBuf);
1268       return RFAILED;
1269    }
1270
1271    pst->event = (Event) EVTLRGTRCIND;
1272    return (SPstTsk(pst,mBuf));
1273 }
1274
1275 \f
1276 /**
1277 * @brief This API is used to send a
1278 Trace Indication from MAC to LM.
1279 *
1280 * @details
1281 *
1282 *     Function: cmUnpkLrgTrcInd
1283 *
1284 *  @param[in]   Pst *  pst
1285 *  @param[in]   RgMngmt *  trc
1286 *  @param[in]   Buffer *  trcBuf
1287 *  @return   S16
1288 *      -# ROK
1289 **/
1290 S16 cmUnpkLrgTrcInd
1291 (
1292 LrgTrcInd func,
1293 Pst *pst,
1294 Buffer *mBuf
1295 )
1296 {
1297    RgMngmt trc;
1298   /* lrg_c_001.main_3 - MODIFY -  Modified trcBuf to have it initialized to NULLP */
1299    Buffer *trcBuf = NULLP;
1300
1301
1302    if (cmUnpkRgMngmt(pst, &trc, EVTLRGTRCIND, mBuf) != ROK) {
1303       SPutMsg(mBuf);
1304 #if (ERRCLASS & ERRCLS_ADD_RES)
1305       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1306             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1307             (ErrVal)ELRG047, (ErrVal)0, "Packing failed");
1308 #endif
1309       return RFAILED;
1310    }
1311    if (pst->selector == ODU_SELECTOR_LC) {
1312       MsgLen msgLen, totalMsgLen;
1313       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
1314       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
1315          return RFAILED;
1316       if (SSegMsg(mBuf, totalMsgLen-msgLen, &trcBuf) != ROK)
1317          return RFAILED;
1318    }
1319    SPutMsg(mBuf);
1320    return ((*func)(pst, &trc, trcBuf));
1321 }
1322
1323 \f
1324 /***********************************************************
1325 *
1326 *     Func : cmPkRgGenCfg
1327 *
1328 *
1329 *     Desc :   This structure holds configuration parameters for MAC General Configuration.
1330 *
1331 *
1332 *     Ret  : S16
1333 *
1334 *     Notes:
1335 *
1336 *     File  :
1337 *
1338 **********************************************************/
1339 S16 cmPkRgGenCfg
1340 (
1341 RgGenCfg *param,
1342 Buffer *mBuf
1343 )
1344 {
1345
1346
1347 #ifdef LTE_ADV
1348    CMCHKPK(oduUnpackUInt8, param->isSCellActDeactAlgoEnable, mBuf);
1349    CMCHKPK(oduUnpackUInt8, param->forceCntrlSrbBoOnPCel, mBuf);
1350 #endif
1351    CMCHKPK(oduUnpackUInt8, param->startCellId, mBuf);
1352    CMCHKPK(oduUnpackUInt8, param->numRguSaps, mBuf);
1353    CMCHKPK(oduUnpackUInt8, param->tmrRes, mBuf);
1354    CMCHKPK(cmPkMemoryId, &param->mem, mBuf);
1355    CMCHKPK(cmPkPst, &param->lmPst, mBuf);
1356    return ROK;
1357 }
1358
1359
1360 \f
1361 /***********************************************************
1362 *
1363 *     Func : cmUnpkRgGenCfg
1364 *
1365 *
1366 *     Desc :   This structure holds configuration parameters for MAC General Configuration.
1367 *
1368 *
1369 *     Ret  : S16
1370 *
1371 *     Notes:
1372 *
1373 *     File  :
1374 *
1375 **********************************************************/
1376 S16 cmUnpkRgGenCfg
1377 (
1378 RgGenCfg *param,
1379 Buffer *mBuf
1380 )
1381 {
1382
1383
1384    CMCHKUNPK(cmUnpkPst, &param->lmPst, mBuf);
1385    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
1386    CMCHKUNPK(oduPackUInt8, &param->tmrRes, mBuf);
1387    CMCHKUNPK(oduPackUInt8, &param->numRguSaps, mBuf);
1388    CMCHKUNPK(oduPackUInt8, &param->startCellId, mBuf);
1389 #ifdef LTE_ADV
1390    CMCHKUNPK(oduPackUInt8, &param->forceCntrlSrbBoOnPCel, mBuf);
1391    CMCHKUNPK(oduPackUInt8, &param->isSCellActDeactAlgoEnable, mBuf);
1392 #endif
1393    return ROK;
1394 }
1395
1396
1397 \f
1398 /***********************************************************
1399 *
1400 *     Func : cmPkRgUpSapCfg
1401 *
1402 *
1403 *     Desc :   This structure holds configuration parameters for MAC Upper SAP Configuration.
1404 *
1405 *
1406 *     Ret  : S16
1407 *
1408 *     Notes:
1409 *
1410 *     File  :
1411 *
1412 **********************************************************/
1413 S16 cmPkRgUpSapCfg
1414 (
1415 RgUpSapCfg *param,
1416 Buffer *mBuf
1417 )
1418 {
1419
1420
1421    CMCHKPK(SPkS16, param->suId, mBuf);
1422    CMCHKPK(SPkS16, param->spId, mBuf);
1423    CMCHKPK(oduUnpackUInt8, param->route, mBuf);
1424    CMCHKPK(oduUnpackUInt8, param->inst, mBuf);
1425    CMCHKPK(oduUnpackUInt8, param->ent, mBuf);
1426    CMCHKPK(oduUnpackUInt16, param->procId, mBuf);
1427    CMCHKPK(oduUnpackUInt8, param->prior, mBuf);
1428    CMCHKPK(cmPkMemoryId, &param->mem, mBuf);
1429    CMCHKPK(oduUnpackUInt8, param->selector, mBuf);
1430    return ROK;
1431 }
1432
1433
1434 \f
1435 /***********************************************************
1436 *
1437 *     Func : cmUnpkRgUpSapCfg
1438 *
1439 *
1440 *     Desc :   This structure holds configuration parameters for MAC Upper SAP Configuration.
1441 *
1442 *
1443 *     Ret  : S16
1444 *
1445 *     Notes:
1446 *
1447 *     File  :
1448 *
1449 **********************************************************/
1450 S16 cmUnpkRgUpSapCfg
1451 (
1452 RgUpSapCfg *param,
1453 Buffer *mBuf
1454 )
1455 {
1456
1457
1458    CMCHKUNPK(oduPackUInt8, &param->selector, mBuf);
1459    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
1460    CMCHKUNPK(oduPackUInt8, &param->prior, mBuf);
1461    CMCHKUNPK(oduPackUInt16, &param->procId, mBuf);
1462    CMCHKUNPK(oduPackUInt8, &param->ent, mBuf);
1463    CMCHKUNPK(oduPackUInt8, &param->inst, mBuf);
1464    CMCHKUNPK(oduPackUInt8, &param->route, mBuf);
1465    CMCHKUNPK(SUnpkS16, &param->spId, mBuf);
1466    CMCHKUNPK(SUnpkS16, &param->suId, mBuf);
1467    return ROK;
1468 }
1469
1470
1471 \f
1472 /***********************************************************
1473 *
1474 *     Func : cmPkRgLowSapCfg
1475 *
1476 *
1477 *     Desc :   This structure holds configuration parameters for MAC Lower SAP Configuration.
1478 *
1479 *
1480 *     Ret  : S16
1481 *
1482 *     Notes:
1483 *
1484 *     File  :
1485 *
1486 **********************************************************/
1487 S16 cmPkRgLowSapCfg
1488 (
1489 RgLowSapCfg *param,
1490 Buffer *mBuf
1491 )
1492 {
1493
1494
1495    CMCHKPK(cmPkTmrCfg, &param->bndTmr, mBuf);
1496    CMCHKPK(SPkS16, param->suId, mBuf);
1497    CMCHKPK(SPkS16, param->spId, mBuf);
1498    CMCHKPK(oduUnpackUInt8, param->route, mBuf);
1499    CMCHKPK(oduUnpackUInt8, param->inst, mBuf);
1500    CMCHKPK(oduUnpackUInt8, param->ent, mBuf);
1501    CMCHKPK(oduUnpackUInt16, param->procId, mBuf);
1502    CMCHKPK(oduUnpackUInt8, param->prior, mBuf);
1503    CMCHKPK(cmPkMemoryId, &param->mem, mBuf);
1504    CMCHKPK(oduUnpackUInt8, param->selector, mBuf);
1505    return ROK;
1506 }
1507
1508
1509 \f
1510 /***********************************************************
1511 *
1512 *     Func : cmUnpkRgLowSapCfg
1513 *
1514 *
1515 *     Desc :   This structure holds configuration parameters for MAC Lower SAP Configuration.
1516 *
1517 *
1518 *     Ret  : S16
1519 *
1520 *     Notes:
1521 *
1522 *     File  :
1523 *
1524 **********************************************************/
1525 S16 cmUnpkRgLowSapCfg
1526 (
1527 RgLowSapCfg *param,
1528 Buffer *mBuf
1529 )
1530 {
1531
1532
1533    CMCHKUNPK(oduPackUInt8, &param->selector, mBuf);
1534    CMCHKUNPK(cmUnpkMemoryId, &param->mem, mBuf);
1535    CMCHKUNPK(oduPackUInt8, &param->prior, mBuf);
1536    CMCHKUNPK(oduPackUInt16, &param->procId, mBuf);
1537    CMCHKUNPK(oduPackUInt8, &param->ent, mBuf);
1538    CMCHKUNPK(oduPackUInt8, &param->inst, mBuf);
1539    CMCHKUNPK(oduPackUInt8, &param->route, mBuf);
1540    CMCHKUNPK(SUnpkS16, &param->spId, mBuf);
1541    CMCHKUNPK(SUnpkS16, &param->suId, mBuf);
1542    CMCHKUNPK(cmUnpkTmrCfg, &param->bndTmr, mBuf);
1543    return ROK;
1544 }
1545
1546 #ifdef MAC_SCH_STATS
1547
1548 \f
1549 /***********************************************************
1550 *
1551 *     Func : cmPkRgAckNack
1552 *
1553 *
1554 *     Desc :   Ack and Nack statistics
1555 *
1556 *
1557 *     Ret  : S16
1558 *
1559 *     Notes:
1560 *
1561 *     File  :
1562 *
1563 **********************************************************/
1564 S16 cmPkRgAckNack
1565 (
1566 RgAckNack *param,
1567 Buffer *mBuf
1568 )
1569 {
1570
1571
1572    CMCHKPK(oduUnpackUInt16, param->numOfAcks, mBuf);
1573    CMCHKPK(oduUnpackUInt16, param->numOfNacks, mBuf);
1574    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
1575
1576    return ROK;
1577 } /* cmPkRgAckNack */
1578
1579 \f
1580 /***********************************************************
1581 *
1582 *     Func : cmPkRgSchNackAckStats
1583 *
1584 *
1585 *     Desc :
1586 *
1587 *
1588 *     Ret  : S16
1589 *
1590 *     Notes:
1591 *
1592 *     File  :
1593 *
1594 **********************************************************/
1595 S16 cmPkRgSchNackAckStats
1596 (
1597 RgSchNackAckStats *param,
1598 Buffer *mBuf
1599 )
1600 {
1601
1602    S32 i;
1603
1604    for (i=14; i >= 0; i--) {
1605       CMCHKPK(cmPkRgAckNack, &param->ulCqiStat[i], mBuf);
1606    }
1607
1608    for (i=14; i >= 0; i--) {
1609       CMCHKPK(cmPkRgAckNack, &param->dlCqiStat[i], mBuf);
1610    }
1611
1612    return ROK;
1613 }
1614
1615 \f
1616 /***********************************************************
1617 *
1618 *     Func : cmPkRgHqNumRetx
1619 *
1620 *
1621 *     Desc :   Harq Retransmission statistics
1622 *
1623 *
1624 *     Ret  : S16
1625 *
1626 *     Notes:
1627 *
1628 *     File  :
1629 *
1630 **********************************************************/
1631 S16 cmPkRgHqNumRetx
1632 (
1633 RgSchHqNumRetx *param,
1634 Buffer *mBuf
1635 )
1636 {
1637
1638    CMCHKPK(oduUnpackUInt32, param->totalTx, mBuf);
1639    CMCHKPK(oduUnpackUInt16, param->numOfHQ_4, mBuf);
1640    CMCHKPK(oduUnpackUInt16, param->numOfHQ_3, mBuf);
1641    CMCHKPK(oduUnpackUInt16, param->numOfHQ_2, mBuf);
1642    CMCHKPK(oduUnpackUInt16, param->numOfHQ_1, mBuf);
1643    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
1644
1645    return ROK;
1646 } /* cmPkRgHqNumRetx */
1647
1648 \f
1649 /***********************************************************
1650 *
1651 *     Func : cmPkRgSchHqRetxStats
1652 *
1653 *
1654 *     Desc :
1655 *
1656 *
1657 *     Ret  : S16
1658 *
1659 *     Notes:
1660 *
1661 *     File  :
1662 *
1663 **********************************************************/
1664 S16 cmPkRgSchHqRetxStats
1665 (
1666 RgSchHqRetxStats *param,
1667 Buffer *mBuf
1668 )
1669 {
1670
1671    S32 i;
1672
1673    for (i=14; i >= 0; i--) {
1674       CMCHKPK(cmPkRgHqNumRetx, &param->ulCqiStat[i], mBuf);
1675    }
1676
1677    for (i=14; i >= 0; i--) {
1678       CMCHKPK(cmPkRgHqNumRetx, &param->dlCqiStat[i], mBuf);
1679    }
1680
1681    return ROK;
1682 } /* cmPkRgSchHqRetxStats */
1683
1684 /* unpcaking functions */
1685 \f
1686 /***********************************************************
1687 *
1688 *     Func : cmUnpkRgAckNack
1689 *
1690 *
1691 *     Desc :   Ack and Nack statistics
1692 *
1693 *
1694 *     Ret  : S16
1695 *
1696 *     Notes:
1697 *
1698 *     File  :
1699 *
1700 **********************************************************/
1701 S16 cmUnpkRgAckNack
1702 (
1703 RgAckNack *param,
1704 Buffer *mBuf
1705 )
1706 {
1707
1708
1709    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
1710    CMCHKUNPK(oduPackUInt16, &param->numOfNacks, mBuf);
1711    CMCHKUNPK(oduPackUInt16, &param->numOfAcks, mBuf);
1712
1713    return ROK;
1714 } /* cmUnkRgAckNack */
1715
1716 \f
1717 /***********************************************************
1718 *
1719 *     Func : cmUnpkRgSchNackAckStats
1720 *
1721 *
1722 *     Desc :
1723 *
1724 *
1725 *     Ret  : S16
1726 *
1727 *     Notes:
1728 *
1729 *     File  :
1730 *
1731 **********************************************************/
1732 S16 cmUnpkRgSchNackAckStats
1733 (
1734 RgSchNackAckStats *param,
1735 Buffer *mBuf
1736 )
1737 {
1738    S32 i;
1739
1740    for (i=0; i <= 14; i++) {
1741       CMCHKUNPK(cmUnpkRgAckNack, &param->dlCqiStat[i], mBuf);
1742    }
1743
1744    for (i=0; i <= 14; i++) {
1745       CMCHKUNPK(cmUnpkRgAckNack, &param->ulCqiStat[i], mBuf);
1746    }
1747
1748    return ROK;
1749 } /* cmUnpkRgSchNackAckStats */
1750
1751 \f
1752 /***********************************************************
1753 *
1754 *     Func : cmUnpkRgHqNumRetx
1755 *
1756 *
1757 *     Desc :   Harq Retransmission statistics
1758 *
1759 *
1760 *     Ret  : S16
1761 *
1762 *     Notes:
1763 *
1764 *     File  :
1765 *
1766 **********************************************************/
1767 S16 cmUnpkRgHqNumRetx
1768 (
1769 RgSchHqNumRetx *param,
1770 Buffer *mBuf
1771 )
1772 {
1773
1774    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
1775    CMCHKUNPK(oduPackUInt16, &param->numOfHQ_1, mBuf);
1776    CMCHKUNPK(oduPackUInt16, &param->numOfHQ_2, mBuf);
1777    CMCHKUNPK(oduPackUInt16, &param->numOfHQ_3, mBuf);
1778    CMCHKUNPK(oduPackUInt16, &param->numOfHQ_4, mBuf);
1779    CMCHKUNPK(oduPackUInt32, &param->totalTx, mBuf);
1780
1781    return ROK;
1782 } /* cmUnpkRgHqNumRetx */
1783
1784 \f
1785 /***********************************************************
1786 *
1787 *     Func : cmUnpkRgSchHqRetxStats
1788 *
1789 *
1790 *     Desc :
1791 *
1792 *
1793 *     Ret  : S16
1794 *
1795 *     Notes:
1796 *
1797 *     File  :
1798 *
1799 **********************************************************/
1800 S16 cmUnpkRgSchHqRetxStats
1801 (
1802 RgSchHqRetxStats *param,
1803 Buffer *mBuf
1804 )
1805 {
1806    S32 i;
1807
1808    for (i=0; i <= 14; i++) {
1809       CMCHKUNPK(cmUnpkRgHqNumRetx, &param->dlCqiStat[i], mBuf);
1810    }
1811
1812    for (i=0; i <= 14; i++) {
1813       CMCHKUNPK(cmUnpkRgHqNumRetx, &param->ulCqiStat[i], mBuf);
1814    }
1815
1816    return ROK;
1817 } /* cmUnpkRgSchHqRetxStats */
1818
1819 #endif /* MAC_SCH_STATS */
1820
1821 \f
1822 /***********************************************************
1823 *
1824 *     Func : cmPkRgGenSts
1825 *
1826 *
1827 *     Desc :   This structure holds General Statistical information of MAC.
1828 *
1829 *
1830 *     Ret  : S16
1831 *
1832 *     Notes:
1833 *
1834 *     File  :
1835 *
1836 **********************************************************/
1837 S16 cmPkRgGenSts
1838 (
1839 RgGenSts *param,
1840 Buffer *mBuf
1841 )
1842 {
1843
1844 #ifdef MAC_SCH_STATS
1845    CMCHKPK(cmPkRgSchHqRetxStats, &param->hqRetxStats, mBuf);
1846    CMCHKPK(cmPkRgSchNackAckStats, &param->nackAckStats, mBuf);
1847 #endif /* MAC_SCH_STATS */
1848    CMCHKPK(oduUnpackUInt16, param->numCellCfg, mBuf);
1849    CMCHKPK(oduUnpackUInt32, param->numUeCfg, mBuf);
1850    CMCHKPK(oduUnpackUInt32, param->numHarqFail, mBuf);
1851    return ROK;
1852 }
1853
1854
1855 \f
1856 /***********************************************************
1857 *
1858 *     Func : cmUnpkRgGenSts
1859 *
1860 *
1861 *     Desc :   This structure holds General Statistical information of MAC.
1862 *
1863 *
1864 *     Ret  : S16
1865 *
1866 *     Notes:
1867 *
1868 *     File  :
1869 *
1870 **********************************************************/
1871 S16 cmUnpkRgGenSts
1872 (
1873 RgGenSts *param,
1874 Buffer *mBuf
1875 )
1876 {
1877
1878    CMCHKUNPK(oduPackUInt32, &param->numHarqFail, mBuf);
1879    CMCHKUNPK(oduPackUInt32, &param->numUeCfg, mBuf);
1880    CMCHKUNPK(oduPackUInt16, &param->numCellCfg, mBuf);
1881 #ifdef MAC_SCH_STATS
1882    CMCHKUNPK(cmUnpkRgSchNackAckStats, &param->nackAckStats, mBuf);
1883    CMCHKUNPK(cmUnpkRgSchHqRetxStats, &param->hqRetxStats, mBuf);
1884 #endif /* MAC_SCH_STATS */
1885    return ROK;
1886 }
1887
1888
1889 \f
1890 /***********************************************************
1891 *
1892 *     Func : cmPkRgSapSts
1893 *
1894 *
1895 *     Desc :   This structure holds Statistical information of a SAP in MAC.
1896 *
1897 *
1898 *     Ret  : S16
1899 *
1900 *     Notes:
1901 *
1902 *     File  :
1903 *
1904 **********************************************************/
1905 S16 cmPkRgSapSts
1906 (
1907 RgSapSts *param,
1908 Buffer *mBuf
1909 )
1910 {
1911
1912    CMCHKPK(oduUnpackUInt32, param->numPduDrop, mBuf);
1913    CMCHKPK(oduUnpackUInt32, param->numPduTxmit, mBuf);
1914    CMCHKPK(oduUnpackUInt32, param->numPduRcvd, mBuf);
1915    return ROK;
1916 }
1917
1918
1919 \f
1920 /***********************************************************
1921 *
1922 *     Func : cmUnpkRgSapSts
1923 *
1924 *
1925 *     Desc :   This structure holds Statistical information of a SAP in MAC.
1926 *
1927 *
1928 *     Ret  : S16
1929 *
1930 *     Notes:
1931 *
1932 *     File  :
1933 *
1934 **********************************************************/
1935 S16 cmUnpkRgSapSts
1936 (
1937 RgSapSts *param,
1938 Buffer *mBuf
1939 )
1940 {
1941
1942    CMCHKUNPK(oduPackUInt32, &param->numPduRcvd, mBuf);
1943    CMCHKUNPK(oduPackUInt32, &param->numPduTxmit, mBuf);
1944    CMCHKUNPK(oduPackUInt32, &param->numPduDrop, mBuf);
1945    return ROK;
1946 }
1947
1948
1949 \f
1950 /***********************************************************
1951 *
1952 *     Func : cmPkRgSchInstCfg
1953 *
1954 *
1955 *     Desc : Scheduler Configuration
1956 *
1957 *
1958 *     Ret  : S16
1959 *
1960 *     Notes:
1961 *
1962 *     File  :
1963 *
1964 **********************************************************/
1965 S16 cmPkRgSchInstCfg
1966 (
1967 RgSchInstCfg *param,
1968 Buffer *mBuf
1969 )
1970 {
1971
1972    S32 i;
1973
1974    for (i=param->numSaps-1; i >= 0; i--) {
1975       CMCHKPK(cmPkRgLowSapCfg, &param->tfuSap[i], mBuf);
1976    }
1977    for (i=param->numSaps-1; i >= 0; i--) {
1978       CMCHKPK(cmPkRgUpSapCfg, &param->rgrSap[i], mBuf);
1979    }
1980    for (i=param->numSaps-1; i >= 0; i--) {
1981       CMCHKPK(cmPkRgUpSapCfg, &param->rgmSap[i], mBuf);
1982    }
1983    CMCHKPK(oduUnpackUInt8, param->numSaps, mBuf);
1984    CMCHKPK(cmPkRgGenCfg, &param->genCfg, mBuf);
1985    CMCHKPK(oduUnpackUInt8, param->instId, mBuf);
1986    return ROK;
1987 }
1988
1989
1990 \f
1991 /***********************************************************
1992 *
1993 *     Func : cmUnpkRgSchInstCfg
1994 *
1995 *
1996 *     Desc : Scheduler Configuration
1997 *
1998 *
1999 *     Ret  : S16
2000 *
2001 *     Notes:
2002 *
2003 *     File  :
2004 *
2005 **********************************************************/
2006 S16 cmUnpkRgSchInstCfg
2007 (
2008 RgSchInstCfg *param,
2009 Buffer *mBuf
2010 )
2011 {
2012
2013    S32 i;
2014
2015    CMCHKUNPK(oduPackUInt8, &param->instId, mBuf);
2016    CMCHKUNPK(cmUnpkRgGenCfg, &param->genCfg, mBuf);
2017    CMCHKUNPK(oduPackUInt8, &param->numSaps, mBuf);
2018    for (i=0; i<param->numSaps; i++) {
2019       CMCHKUNPK(cmUnpkRgUpSapCfg, &param->rgmSap[i], mBuf);
2020    }
2021    for (i=0; i<param->numSaps; i++) {
2022       CMCHKUNPK(cmUnpkRgUpSapCfg, &param->rgrSap[i], mBuf);
2023    }
2024    for (i=0; i<param->numSaps; i++) {
2025       CMCHKUNPK(cmUnpkRgLowSapCfg, &param->tfuSap[i], mBuf);
2026    }
2027    return ROK;
2028 }
2029
2030
2031 \f
2032 /***********************************************************
2033 *
2034 *     Func : cmPkRgCfg
2035 *
2036 *
2037 *     Desc :   This structure holds Configuration parameters for MAC.
2038 *
2039 *
2040 *     Ret  : S16
2041 *
2042 *     Notes:
2043 *
2044 *     File  :
2045 *
2046 **********************************************************/
2047 S16 cmPkRgCfg
2048 (
2049 RgCfg *param,
2050 S16 elmnt,
2051 Buffer *mBuf
2052 )
2053 {
2054
2055       switch(elmnt) {
2056          case STSCHINST:
2057             CMCHKPK(cmPkRgSchInstCfg, &param->s.schInstCfg, mBuf);
2058             break;
2059          case STTFUSAP:
2060             CMCHKPK(cmPkRgLowSapCfg, &param->s.tfuSap, mBuf);
2061             break;
2062          case STCRGSAP:
2063             CMCHKPK(cmPkRgUpSapCfg, &param->s.crgSap, mBuf);
2064             break;
2065          case STRGUSAP:
2066             CMCHKPK(cmPkRgUpSapCfg, &param->s.rguSap, mBuf);
2067             break;
2068          case STGEN:
2069             CMCHKPK(cmPkRgGenCfg, &param->s.genCfg, mBuf);
2070             break;
2071          default :
2072             return RFAILED;
2073       }
2074    return ROK;
2075 }
2076
2077
2078 \f
2079 /***********************************************************
2080 *
2081 *     Func : cmUnpkRgCfg
2082 *
2083 *
2084 *     Desc :   This structure holds Configuration parameters for MAC.
2085 *
2086 *
2087 *     Ret  : S16
2088 *
2089 *     Notes:
2090 *
2091 *     File  :
2092 *
2093 **********************************************************/
2094 S16 cmUnpkRgCfg
2095 (
2096 RgCfg *param,
2097 S16 elmnt,
2098 Buffer *mBuf
2099 )
2100 {
2101
2102       switch(elmnt) {
2103          case STGEN:
2104             CMCHKUNPK(cmUnpkRgGenCfg, &param->s.genCfg, mBuf);
2105             break;
2106          case STRGUSAP:
2107             CMCHKUNPK(cmUnpkRgUpSapCfg, &param->s.rguSap, mBuf);
2108             break;
2109          case STCRGSAP:
2110             CMCHKUNPK(cmUnpkRgUpSapCfg, &param->s.crgSap, mBuf);
2111             break;
2112          case STTFUSAP:
2113             CMCHKUNPK(cmUnpkRgLowSapCfg, &param->s.tfuSap, mBuf);
2114             break;
2115          case STSCHINST:
2116             CMCHKUNPK(cmUnpkRgSchInstCfg, &param->s.schInstCfg, mBuf);
2117             break;
2118          default :
2119             return RFAILED;
2120       }
2121    return ROK;
2122 }
2123
2124
2125 \f
2126 /***********************************************************
2127 *
2128 *     Func : cmPkRgSapSta
2129 *
2130 *
2131 *     Desc :   This structure holds a SAP's status information.
2132 *
2133 *
2134 *     Ret  : S16
2135 *
2136 *     Notes:
2137 *
2138 *     File  :
2139 *
2140 **********************************************************/
2141 S16 cmPkRgSapSta
2142 (
2143 RgSapSta *param,
2144 Buffer *mBuf
2145 )
2146 {
2147
2148    CMCHKPK(oduUnpackUInt8, param->sapState, mBuf);
2149    return ROK;
2150 }
2151
2152
2153 \f
2154 /***********************************************************
2155 *
2156 *     Func : cmUnpkRgSapSta
2157 *
2158 *
2159 *     Desc :   This structure holds a SAP's status information.
2160 *
2161 *
2162 *     Ret  : S16
2163 *
2164 *     Notes:
2165 *
2166 *     File  :
2167 *
2168 **********************************************************/
2169 S16 cmUnpkRgSapSta
2170 (
2171 RgSapSta *param,
2172 Buffer *mBuf
2173 )
2174 {
2175
2176    CMCHKUNPK(oduPackUInt8, &param->sapState, mBuf);
2177    return ROK;
2178 }
2179
2180
2181 \f
2182 /***********************************************************
2183 *
2184 *     Func : cmPkRgSts
2185 *
2186 *
2187 *     Desc :   This structure holds MAC's Statistical information.
2188 *
2189 *
2190 *     Ret  : S16
2191 *
2192 *     Notes:
2193 *
2194 *     File  :
2195 *
2196 **********************************************************/
2197 S16 cmPkRgSts
2198 (
2199 RgSts *param,
2200 S16 elmnt,
2201 Buffer *mBuf
2202 )
2203 {
2204
2205       switch(elmnt) {
2206          case STTFUSAP:
2207             CMCHKPK(cmPkRgSapSts, &param->s.tfuSts, mBuf);
2208             break;
2209          case STRGRSAP:
2210             CMCHKPK(cmPkRgSapSts, &param->s.rgrSts, mBuf);
2211             break;
2212          case STCRGSAP:
2213             CMCHKPK(cmPkRgSapSts, &param->s.crgSts, mBuf);
2214             break;
2215          case STRGUSAP:
2216             CMCHKPK(cmPkRgSapSts, &param->s.rguSts, mBuf);
2217             break;
2218          case STGEN:
2219             CMCHKPK(cmPkRgGenSts, &param->s.genSts, mBuf);
2220             break;
2221          default :
2222             break;
2223       }
2224    CMCHKPK(cmPkAction, param->action, mBuf);
2225    CMCHKPK(oduUnpackUInt8, param->sapInst, mBuf);
2226    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
2227    return ROK;
2228 }
2229
2230
2231 \f
2232 /***********************************************************
2233 *
2234 *     Func : cmUnpkRgSts
2235 *
2236 *
2237 *     Desc :   This structure holds MAC's Statistical information.
2238 *
2239 *
2240 *     Ret  : S16
2241 *
2242 *     Notes:
2243 *
2244 *     File  :
2245 *
2246 **********************************************************/
2247 S16 cmUnpkRgSts
2248 (
2249 RgSts *param,
2250 S16 elmnt,
2251 Buffer *mBuf
2252 )
2253 {
2254
2255    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
2256    CMCHKUNPK(oduPackUInt8, &param->sapInst, mBuf);
2257    CMCHKUNPK(cmUnpkAction, &param->action, mBuf);
2258       switch(elmnt) {
2259          case STGEN:
2260             CMCHKUNPK(cmUnpkRgGenSts, &param->s.genSts, mBuf);
2261             break;
2262          case STRGUSAP:
2263             CMCHKUNPK(cmUnpkRgSapSts, &param->s.rguSts, mBuf);
2264             break;
2265          case STCRGSAP:
2266             CMCHKUNPK(cmUnpkRgSapSts, &param->s.crgSts, mBuf);
2267             break;
2268          case STRGRSAP:
2269             CMCHKUNPK(cmUnpkRgSapSts, &param->s.rgrSts, mBuf);
2270             break;
2271          case STTFUSAP:
2272             CMCHKUNPK(cmUnpkRgSapSts, &param->s.tfuSts, mBuf);
2273             break;
2274          default :
2275             break;
2276       }
2277    return ROK;
2278 }
2279
2280
2281 \f
2282 /***********************************************************
2283 *
2284 *     Func : cmPkRgSsta
2285 *
2286 *
2287 *     Desc :   This structure holds MAC's Solicited Status information.
2288 *
2289 *
2290 *     Ret  : S16
2291 *
2292 *     Notes:
2293 *
2294 *     File  :
2295 *
2296 **********************************************************/
2297 S16 cmPkRgSsta
2298 (
2299 Pst *pst,
2300 RgSsta *param,
2301 S16 elmnt,
2302 #ifdef LRG_V1
2303 uint8_t eventType,
2304 #endif
2305 Buffer *mBuf
2306 )
2307 {
2308
2309       switch(elmnt) {
2310          case STTFUSAP:
2311             CMCHKPK(cmPkRgSapSta, &param->s.tfuSapSta, mBuf);
2312             break;
2313          case STRGRSAP:
2314             CMCHKPK(cmPkRgSapSta, &param->s.rgrSapSta, mBuf);
2315             break;
2316          case STCRGSAP:
2317             CMCHKPK(cmPkRgSapSta, &param->s.crgSapSta, mBuf);
2318             break;
2319          case STRGUSAP:
2320             CMCHKPK(cmPkRgSapSta, &param->s.rguSapSta, mBuf);
2321             break;
2322             /*ccpu00118255 - ADD - Check for eventType before Pack */
2323          case STGEN:
2324 #ifdef LRG_V1
2325             if (eventType == EVTLRGSSTACFM)
2326             {
2327                CMCHKPK(cmPkSystemId, &param->s.sysId, mBuf);
2328                if (param->s.sysId.ptNmb != NULLP)
2329                {
2330                   SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool,
2331                         (Data *)param->s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
2332                }
2333             }
2334 #else /*LRG_V1 not defined */
2335             if (param->s.sysId.ptNmb != NULLP)
2336             {
2337                  CMCHKPK(cmPkSystemId, &param->s.sysId, mBuf);
2338                  SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)param->s.sysId.ptNmb, LRG_MAX_PT_NUM_SIZE);
2339             }
2340
2341 #endif /*end of LRG_V1 */
2342             break;
2343          default :
2344             break;
2345       }
2346    CMCHKPK(oduUnpackUInt8, param->sapInst, mBuf);
2347    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
2348    return ROK;
2349 }
2350
2351
2352 \f
2353 /***********************************************************
2354 *
2355 *     Func : cmUnpkRgSsta
2356 *
2357 *
2358 *     Desc :   This structure holds MAC's Solicited Status information.
2359 *
2360 *
2361 *     Ret  : S16
2362 *
2363 *     Notes:
2364 *
2365 *     File  :
2366 *
2367 **********************************************************/
2368 S16 cmUnpkRgSsta
2369 (
2370 Pst    *pst,
2371 RgSsta *param,
2372 S16 elmnt,
2373 Buffer *mBuf
2374 )
2375 {
2376
2377
2378    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
2379    CMCHKUNPK(oduPackUInt8, &param->sapInst, mBuf);
2380       switch(elmnt) {
2381          case STGEN:
2382             /*ccpu00118255 - ADD - Check for eventType before Unpack */
2383             if (pst->event == EVTLRGSSTACFM)
2384             {
2385                /* After Merging */
2386                if((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&param->s.sysId.ptNmb,
2387                            LRG_MAX_PT_NUM_SIZE)) != ROK){
2388 #if (ERRCLASS & ERRCLS_ADD_RES)
2389                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
2390                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
2391                         (ErrVal)ELRG048, (ErrVal)0, "Packing failed");
2392 #endif
2393                   SPutMsg(mBuf);
2394                   return RFAILED;
2395                }
2396                /* KWORK_FIX: Moved the memset under the NULL check */
2397                if (param->s.sysId.ptNmb != NULLP)
2398                {
2399                   memset(param->s.sysId.ptNmb, 0, LRG_MAX_PT_NUM_SIZE);
2400                   CMCHKUNPK(cmUnpkSystemId, &param->s.sysId, mBuf);
2401                }
2402             }
2403             break;
2404          case STRGUSAP:
2405             CMCHKUNPK(cmUnpkRgSapSta, &param->s.rguSapSta, mBuf);
2406             break;
2407          case STCRGSAP:
2408             CMCHKUNPK(cmUnpkRgSapSta, &param->s.crgSapSta, mBuf);
2409             break;
2410          case STRGRSAP:
2411             CMCHKUNPK(cmUnpkRgSapSta, &param->s.rgrSapSta, mBuf);
2412             break;
2413          case STTFUSAP:
2414             CMCHKUNPK(cmUnpkRgSapSta, &param->s.tfuSapSta, mBuf);
2415             break;
2416          default :
2417             break;
2418       }
2419    return ROK;
2420 }
2421
2422
2423 \f
2424 /***********************************************************
2425 *
2426 *     Func : cmPkRgUstaDgn
2427 *
2428 *
2429 *     Desc :   Alarm diagnostics structure.
2430 *
2431 *
2432 *     Ret  : S16
2433 *
2434 *     Notes:
2435 *
2436 *     File  :
2437 *
2438 **********************************************************/
2439 S16 cmPkRgUstaDgn
2440 (
2441 RgUstaDgn *param,
2442 Buffer *mBuf
2443 )
2444 {
2445
2446       switch(param->type) {
2447          case LRG_USTA_DGNVAL_MEM:
2448             CMCHKPK(cmPkMemoryId, &param->u.mem, mBuf);
2449             break;
2450          default :
2451             break;
2452       }
2453    CMCHKPK(oduUnpackUInt8, param->type, mBuf);
2454    return ROK;
2455 }
2456
2457
2458 \f
2459 /***********************************************************
2460 *
2461 *     Func : cmUnpkRgUstaDgn
2462 *
2463 *
2464 *     Desc :   Alarm diagnostics structure.
2465 *
2466 *
2467 *     Ret  : S16
2468 *
2469 *     Notes:
2470 *
2471 *     File  :
2472 *
2473 **********************************************************/
2474 S16 cmUnpkRgUstaDgn
2475 (
2476 RgUstaDgn *param,
2477 Buffer *mBuf
2478 )
2479 {
2480
2481
2482    CMCHKUNPK(oduPackUInt8, &param->type, mBuf);
2483    switch(param->type)
2484    {
2485       case LRG_USTA_DGNVAL_MEM:
2486          CMCHKUNPK(cmUnpkMemoryId, &param->u.mem, mBuf);
2487          break;
2488       default :
2489          break;
2490       }
2491    return ROK;
2492 }
2493
2494
2495 \f
2496 /***********************************************************
2497 *
2498 *     Func : cmPkRgUsta
2499 *
2500 *
2501 *     Desc :   This structure holds MAC's Unsolicited Status information.
2502 *
2503 *
2504 *     Ret  : S16
2505 *
2506 *     Notes:
2507 *
2508 *     File  :
2509 *
2510 **********************************************************/
2511 S16 cmPkRgUsta
2512 (
2513 RgUsta *param,
2514 Buffer *mBuf
2515 )
2516 {
2517
2518    CMCHKPK(cmPkRgUstaDgn, &param->dgn, mBuf);
2519    CMCHKPK(cmPkCmAlarm, &param->cmAlarm, mBuf);
2520    return ROK;
2521 }
2522
2523
2524 \f
2525 /***********************************************************
2526 *
2527 *     Func : cmUnpkRgUsta
2528 *
2529 *
2530 *     Desc :   This structure holds MAC's Unsolicited Status information.
2531 *
2532 *
2533 *     Ret  : S16
2534 *
2535 *     Notes:
2536 *
2537 *     File  :
2538 *
2539 **********************************************************/
2540 S16 cmUnpkRgUsta
2541 (
2542 RgUsta *param,
2543 Buffer *mBuf
2544 )
2545 {
2546
2547    CMCHKUNPK(cmUnpkCmAlarm, &param->cmAlarm, mBuf);
2548    CMCHKUNPK(cmUnpkRgUstaDgn, &param->dgn, mBuf);
2549    return ROK;
2550 }
2551
2552
2553 \f
2554 /***********************************************************
2555 *
2556 *     Func : cmPkRgTrc
2557 *
2558 *
2559 *     Desc :   This structure holds MAC's Trace Indication information.
2560 *
2561 *
2562 *     Ret  : S16
2563 *
2564 *     Notes:
2565 *
2566 *     File  :
2567 *
2568 **********************************************************/
2569 S16 cmPkRgTrc
2570 (
2571 RgTrc *param,
2572 Buffer *mBuf
2573 )
2574 {
2575
2576    CMCHKPK(oduUnpackUInt8, param->evnt, mBuf);
2577    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
2578    return ROK;
2579 }
2580
2581
2582 \f
2583 /***********************************************************
2584 *
2585 *     Func : cmUnpkRgTrc
2586 *
2587 *
2588 *     Desc :   This structure holds MAC's Trace Indication information.
2589 *
2590 *
2591 *     Ret  : S16
2592 *
2593 *     Notes:
2594 *
2595 *     File  :
2596 *
2597 **********************************************************/
2598 S16 cmUnpkRgTrc
2599 (
2600 RgTrc *param,
2601 Buffer *mBuf
2602 )
2603 {
2604
2605    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
2606    CMCHKUNPK(oduPackUInt8, &param->evnt, mBuf);
2607    return ROK;
2608 }
2609
2610
2611 \f
2612 /***********************************************************
2613 *
2614 *     Func : cmPkRgDbgCntrl
2615 *
2616 *
2617 *     Desc :   This structure holds MAC's Debug Control information.
2618 *
2619 *
2620 *     Ret  : S16
2621 *
2622 *     Notes:
2623 *
2624 *     File  :
2625 *
2626 **********************************************************/
2627 S16 cmPkRgDbgCntrl
2628 (
2629 RgDbgCntrl *param,
2630 Buffer *mBuf
2631 )
2632 {
2633
2634    CMCHKPK(oduUnpackUInt32, param->dbgMask, mBuf);
2635    return ROK;
2636 }
2637
2638 #ifdef PHY_ERROR_LOGING
2639 /***********************************************************
2640 *
2641 *     Func : cmPkRgSchUlAllocCntrl
2642 *
2643 *
2644 *     Desc :   This structure holds MAC's Debug Control information.
2645 *
2646 *
2647 *     Ret  : S16
2648 *
2649 *     Notes:
2650 *
2651 *     File  :
2652 *
2653 **********************************************************/
2654 S16 cmPkRgSchUlAllocCntrl
2655 (
2656 RgSchUlAllocCntrl *param,
2657 Buffer *mBuf
2658 )
2659 {
2660
2661    CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
2662    CMCHKPK(oduUnpackUInt16, param->numOfRb, mBuf);
2663    CMCHKPK(oduUnpackUInt16, param->rbStart, mBuf);
2664    CMCHKPK(oduUnpackUInt8, param->testStart, mBuf);
2665    CMCHKPK(oduUnpackUInt8, param->enaLog, mBuf);
2666    CMCHKPK(oduUnpackUInt16, param->logTime, mBuf);
2667
2668    return ROK;
2669 }
2670
2671 /***********************************************************
2672 *
2673 *     Func : cmUnpkRgSchUlAllocCntrl
2674 *
2675 *
2676 *     Desc :   This structure holds MAC's Scheduler Configuration for Ul Allocation.
2677 *
2678 *
2679 *     Ret  : S16
2680 *
2681 *     Notes:
2682 *
2683 *     File  :
2684 *
2685 **********************************************************/
2686 S16 cmUnpkRgSchUlAllocCntrl
2687 (
2688 RgSchUlAllocCntrl *param,
2689 Buffer *mBuf
2690 )
2691 {
2692
2693    CMCHKUNPK(oduPackUInt16, &param->logTime, mBuf);
2694    CMCHKUNPK(oduPackUInt8, &param->enaLog, mBuf);
2695    CMCHKUNPK(oduPackUInt8, &param->testStart, mBuf);
2696    CMCHKUNPK(oduPackUInt16, &param->rbStart, mBuf);
2697    CMCHKUNPK(oduPackUInt16, &param->numOfRb, mBuf);
2698    CMCHKUNPK(oduPackUInt8, &param->mcs, mBuf);
2699
2700    return ROK;
2701 }
2702
2703
2704 #endif
2705 \f
2706 /***********************************************************
2707 *
2708 *     Func : cmUnpkRgDbgCntrl
2709 *
2710 *
2711 *     Desc :   This structure holds MAC's Debug Control information.
2712 *
2713 *
2714 *     Ret  : S16
2715 *
2716 *     Notes:
2717 *
2718 *     File  :
2719 *
2720 **********************************************************/
2721 S16 cmUnpkRgDbgCntrl
2722 (
2723 RgDbgCntrl *param,
2724 Buffer *mBuf
2725 )
2726 {
2727
2728    CMCHKUNPK(oduPackUInt32, &param->dbgMask, mBuf);
2729    return ROK;
2730 }
2731
2732
2733 \f
2734 /***********************************************************
2735 *
2736 *     Func : cmPkRgSapCntrl
2737 *
2738 *
2739 *     Desc :   This structure holds MAC's SAP Control information.
2740 *
2741 *
2742 *     Ret  : S16
2743 *
2744 *     Notes:
2745 *
2746 *     File  :
2747 *
2748 **********************************************************/
2749 S16 cmPkRgSapCntrl
2750 (
2751 RgSapCntrl *param,
2752 Buffer *mBuf
2753 )
2754 {
2755
2756    CMCHKPK(SPkS16, param->spId, mBuf);
2757    CMCHKPK(SPkS16, param->suId, mBuf);
2758    return ROK;
2759 }
2760
2761
2762 \f
2763 /***********************************************************
2764 *
2765 *     Func : cmUnpkRgSapCntrl
2766 *
2767 *
2768 *     Desc :   This structure holds MAC's SAP Control information.
2769 *
2770 *
2771 *     Ret  : S16
2772 *
2773 *     Notes:
2774 *
2775 *     File  :
2776 *
2777 **********************************************************/
2778 S16 cmUnpkRgSapCntrl
2779 (
2780 RgSapCntrl *param,
2781 Buffer *mBuf
2782 )
2783 {
2784
2785    CMCHKUNPK(SUnpkS16, &param->suId, mBuf);
2786    CMCHKUNPK(SUnpkS16, &param->spId, mBuf);
2787    return ROK;
2788 }
2789
2790
2791 \f
2792 /***********************************************************
2793 *
2794 *     Func : cmPkRgCntrl
2795 *
2796 *
2797 *     Desc :   This structure holds MAC's Control information.
2798 *
2799 *
2800 *     Ret  : S16
2801 *
2802 *     Notes:
2803 *
2804 *     File  :
2805 *
2806 **********************************************************/
2807 S16 cmPkRgCntrl
2808 (
2809 RgCntrl *param,
2810 S16 elmnt,
2811 Buffer *mBuf
2812 )
2813 {
2814
2815
2816       switch(elmnt) {
2817          case STTFUSAP:
2818          case STRGUSAP:
2819          case STRGRSAP:
2820          case STCRGSAP:
2821             switch(param->subAction) {
2822                default :
2823                   CMCHKPK(cmPkRgSapCntrl, &param->s.rgSapCntrl, mBuf);
2824                   break;
2825             }
2826          break;
2827          case STGEN:
2828             switch(param->subAction) {
2829                case SATRC:
2830                   CMCHKPK(SPkS16, param->s.trcLen, mBuf);
2831                   break;
2832                case SADBG:
2833                   CMCHKPK(cmPkRgDbgCntrl, &param->s.rgDbgCntrl, mBuf);
2834                   break;
2835                case SAUSTA:
2836                   break;
2837 #ifdef SS_DIAG
2838                case SALOG:
2839                   CMCHKPK(oduUnpackUInt32,  param->s.logMask, mBuf);
2840                   break;
2841 #endif
2842 #ifdef PHY_ERROR_LOGING
2843                case SAELMNT:
2844              CMCHKPK(cmPkRgSchUlAllocCntrl, &param->s.rgSchUlAllocCntrl, mBuf);
2845                   break;
2846 #endif
2847                default :
2848                   break;
2849             }
2850             break;
2851          default :
2852             break;
2853       }
2854    CMCHKPK(oduUnpackUInt8, param->subAction, mBuf);
2855    CMCHKPK(oduUnpackUInt8, param->action, mBuf);
2856    CMCHKPK(cmPkDateTime, &param->dt, mBuf);
2857    return ROK;
2858 }
2859
2860
2861 \f
2862 /***********************************************************
2863 *
2864 *     Func : cmUnpkRgCntrl
2865 *
2866 *
2867 *     Desc :   This structure holds MAC's Control information.
2868 *
2869 *
2870 *     Ret  : S16
2871 *
2872 *     Notes:
2873 *
2874 *     File  :
2875 *
2876 **********************************************************/
2877 S16 cmUnpkRgCntrl
2878 (
2879 RgCntrl *param,
2880 S16 elmnt,
2881 Buffer *mBuf
2882 )
2883 {
2884
2885
2886    CMCHKUNPK(cmUnpkDateTime, &param->dt, mBuf);
2887    CMCHKUNPK(oduPackUInt8, &param->action, mBuf);
2888    CMCHKUNPK(oduPackUInt8, &param->subAction, mBuf);
2889    switch(elmnt) {
2890       case STGEN:
2891          switch(param->subAction) {
2892             case SADBG:
2893                CMCHKUNPK(cmUnpkRgDbgCntrl, &param->s.rgDbgCntrl, mBuf);
2894                break;
2895             case SATRC:
2896                CMCHKUNPK(SUnpkS16, &param->s.trcLen, mBuf);
2897                break;
2898             case SAUSTA:
2899                break;
2900 #ifdef SS_DIAG
2901             case SALOG:
2902                CMCHKUNPK(oduPackUInt32, &param->s.logMask, mBuf);
2903                break;
2904 #endif
2905 #ifdef PHY_ERROR_LOGING
2906             case SAELMNT:
2907                CMCHKUNPK(cmUnpkRgSchUlAllocCntrl, &param->s.rgSchUlAllocCntrl, mBuf);
2908                break;
2909 #endif
2910             default :
2911                break;
2912          }
2913          break;
2914       case STTFUSAP:
2915       case STRGUSAP:
2916       case STRGRSAP:
2917       case STCRGSAP:
2918          switch(param->subAction) {
2919             default :
2920                CMCHKUNPK(cmUnpkRgSapCntrl, &param->s.rgSapCntrl, mBuf);
2921                break;
2922          }
2923          break;
2924       default :
2925          break;
2926       }
2927    return ROK;
2928 }
2929
2930
2931 \f
2932 /***********************************************************
2933 *
2934 *     Func : cmPkRgMngmt
2935 *
2936 *
2937 *     Desc :   This structure holds MAC's Configuration and Control Management Information.
2938 *
2939 *
2940 *     Ret  : S16
2941 *
2942 *     Notes:
2943 *
2944 *     File  :
2945 *
2946 **********************************************************/
2947 S16 cmPkRgMngmt
2948 (
2949 Pst *pst,
2950 RgMngmt *param,
2951 uint8_t eventType,
2952 Buffer *mBuf
2953 )
2954 {
2955
2956
2957       switch(eventType) {
2958          case EVTLRGCNTRLREQ:
2959          case  EVTLRGCNTRLCFM:
2960          case EVTLRGSCHCNTRLREQ:
2961          case  EVTLRGSCHCNTRLCFM:
2962             if(cmPkRgCntrl(&param->t.cntrl, param->hdr.elmId.elmnt, mBuf) != ROK)
2963                return RFAILED;
2964             break;
2965          case EVTLRGTRCIND:
2966             CMCHKPK(cmPkRgTrc, &param->t.trc, mBuf);
2967             break;
2968          case EVTLRGUSTAIND:
2969          case EVTLRGSCHSTAIND:
2970             CMCHKPK(cmPkRgUsta, &param->t.usta, mBuf);
2971             break;
2972          case EVTLRGSSTAREQ:
2973          case  EVTLRGSSTACFM:
2974             /*ccpu00118255 - ADD - eventType param */
2975 #ifdef LRG_V1
2976             if(cmPkRgSsta(pst, &param->t.ssta, param->hdr.elmId.elmnt,
2977                      eventType, mBuf) != ROK)
2978                return RFAILED;
2979 #else /* LRG_V1 is not defined */
2980             if(cmPkRgSsta(pst, &param->t.ssta, param->hdr.elmId.elmnt, mBuf) != ROK)
2981                return RFAILED;
2982 #endif /* end of LRG_V1*/
2983             break;
2984          case EVTLRGSTSREQ:
2985          case  EVTLRGSTSCFM:
2986             if(cmPkRgSts(&param->t.sts, param->hdr.elmId.elmnt, mBuf)!= ROK)
2987                return RFAILED;
2988             break;
2989          case EVTLRGCFGREQ:
2990          case  EVTLRGCFGCFM:
2991             if(cmPkRgCfg(&param->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
2992                return RFAILED;
2993             break;
2994          case EVTMACSCHGENCFGREQ:
2995          case  EVTMACSCHGENCFGCFM:
2996             if(cmPkRgCfg(&param->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
2997                return RFAILED;
2998             break;
2999          default :
3000             return RFAILED;
3001       }
3002    CMCHKPK(cmPkCmStatus, &param->cfm, mBuf);
3003    CMCHKPK(cmPkHeader, &param->hdr, mBuf);
3004    return ROK;
3005 }
3006
3007
3008 \f
3009 /***********************************************************
3010 *
3011 *     Func : cmUnpkRgMngmt
3012 *
3013 *
3014 *     Desc :   This structure holds MAC's Configuration and Control Management Information.
3015 *
3016 *
3017 *     Ret  : S16
3018 *
3019 *     Notes:
3020 *
3021 *     File  :
3022 *
3023 **********************************************************/
3024 S16 cmUnpkRgMngmt
3025 (
3026 Pst *pst,
3027 RgMngmt *param,
3028 uint8_t eventType,
3029 Buffer *mBuf
3030 )
3031 {
3032
3033
3034    CMCHKUNPK(cmUnpkHeader, &param->hdr, mBuf);
3035    CMCHKUNPK(cmUnpkCmStatus, &param->cfm, mBuf);
3036    switch(eventType) {
3037       case EVTLRGCFGREQ:
3038       case  EVTLRGCFGCFM:
3039       case EVTMACSCHGENCFGREQ:
3040       case  EVTMACSCHGENCFGCFM:
3041          if(cmUnpkRgCfg(&param->t.cfg, param->hdr.elmId.elmnt, mBuf) != ROK)
3042             return RFAILED;
3043          break;
3044       case EVTLRGSTSREQ:
3045       case  EVTLRGSTSCFM:
3046          if(cmUnpkRgSts(&param->t.sts, param->hdr.elmId.elmnt, mBuf) != ROK)
3047             return RFAILED;
3048          break;
3049       case EVTLRGSSTAREQ:
3050       case  EVTLRGSSTACFM:
3051          if(cmUnpkRgSsta(pst, &param->t.ssta, param->hdr.elmId.elmnt, mBuf) != ROK)
3052             return RFAILED;
3053          break;
3054       case EVTLRGUSTAIND:
3055       case EVTLRGSCHSTAIND:
3056          CMCHKUNPK(cmUnpkRgUsta, &param->t.usta, mBuf);
3057          break;
3058       case EVTLRGTRCIND:
3059          CMCHKUNPK(cmUnpkRgTrc, &param->t.trc, mBuf);
3060          break;
3061       case EVTLRGCNTRLREQ:
3062       case  EVTLRGCNTRLCFM:
3063       case EVTLRGSCHCNTRLREQ:
3064       case  EVTLRGSCHCNTRLCFM:
3065          if(cmUnpkRgCntrl(&param->t.cntrl, param->hdr.elmId.elmnt, mBuf) != ROK)
3066             return RFAILED;
3067          break;
3068       default :
3069          return RFAILED;
3070       }
3071    return ROK;
3072 }
3073
3074 /* lrg_c_001.main_3 - ADD -  Added the functions pertaining to LTE_L2_MEAS  */
3075 #ifdef LTE_L2_MEAS
3076 \f
3077 /**
3078 * @brief This API is used to pack
3079  LrgNmbActvUeQCI elements
3080 *
3081 * @details
3082 *
3083 *     Function: cmPkNmbActvUeQciReq
3084 *
3085 *  @param[in]   LrgNmbActvUeQCI
3086 *  @param[in]   Buffer   *mBuf
3087 *  @return   S16
3088 *      -# ROK
3089 **/
3090 static S16  cmPkNmbActvUeQciReq
3091 (
3092 LrgNmbActvUeQCI   *nmbActvUeQci,
3093 Buffer        *mBuf
3094 )
3095 {
3096    uint8_t      idx;
3097
3098
3099    for(idx = 0; idx < nmbActvUeQci->numQci; idx++)
3100    {
3101        CMCHKPK(oduUnpackUInt8, nmbActvUeQci->qci[idx], mBuf);
3102    }
3103    CMCHKPK(oduUnpackUInt8, nmbActvUeQci->numQci, mBuf);
3104    CMCHKPK(oduUnpackUInt8, nmbActvUeQci->sampPrd, mBuf);
3105    return ROK;
3106 }
3107 \f
3108 /**
3109 * @brief This API is used to pack
3110  LrgAvgPrbQci elements
3111 *
3112 * @details
3113 *
3114 *     Function: cmPkAvgPrbQciReq
3115 *
3116 *  @param[in]   LrgNmbActvUeQciReq  *avgPrbQciReq
3117 *  @param[in]   Buffer   *mBuf
3118 *  @return   S16
3119 *      -# ROK
3120 **/
3121 static S16  cmPkAvgPrbQciReq
3122 (
3123 LrgAvgPrbQCI  *avgPrbQciReq,
3124 Buffer        *mBuf
3125 )
3126 {
3127    uint8_t      idx;
3128
3129    for(idx = 0; idx < avgPrbQciReq->numQci; idx++)
3130    {
3131        CMCHKPK(oduUnpackUInt8, avgPrbQciReq->qci[idx], mBuf);
3132    }
3133    CMCHKPK(oduUnpackUInt8, avgPrbQciReq->numQci, mBuf);
3134    return ROK;
3135
3136 }
3137 \f
3138 /**
3139 * @brief This API is used to send a
3140 L2 Measurement Request from LM to MAC.
3141 *
3142 * @details
3143 *
3144 *     Function: cmPkLrgSchL2MeasReq
3145 *
3146 *  @param[in]   Pst *  pst
3147 *  @param[in]   LrgSchMeasReqInfo  *  measInfo
3148 *  @return   S16
3149 *      -# ROK
3150 **/
3151 S16 cmPkLrgSchL2MeasReq
3152 (
3153 Pst * pst,
3154 LrgSchMeasReqInfo  *measInfo
3155 )
3156 {
3157    Buffer *mBuf = NULLP;
3158
3159    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3160 #if (ERRCLASS & ERRCLS_ADD_RES)
3161       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3162          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3163          (ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
3164 #endif
3165       return RFAILED;
3166    }
3167    if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
3168    {
3169       CMCHKPK(cmPkNmbActvUeQciReq, &measInfo->nmbActvUeQciDl, mBuf);
3170    }
3171    if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
3172    {
3173       CMCHKPK(cmPkNmbActvUeQciReq, &measInfo->nmbActvUeQciUl, mBuf);
3174    }
3175    if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
3176    {
3177       CMCHKPK(cmPkAvgPrbQciReq, &measInfo->avgPrbQciDl, mBuf);
3178    }
3179    if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
3180    {
3181       CMCHKPK(cmPkAvgPrbQciReq, &measInfo->avgPrbQciUl, mBuf);
3182    }
3183
3184    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
3185    CMCHKPK(oduUnpackUInt32, measInfo->timePrd, mBuf);
3186    CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
3187    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
3188    pst->event = (Event) EVTLRGSCHL2MEASREQ;
3189    return (SPstTsk(pst,mBuf));
3190 }
3191 /**
3192 * @brief This API is used to stop a
3193 L2 Measurement Request from LM to MAC.
3194 *
3195 * @details
3196 *
3197 *     Function: cmPkLrgSchL2MeasStopReq
3198 *
3199 *  @param[in]   Pst *  pst
3200 *  @param[in]   LrgSchMeasReqInfo  *  measInfo
3201 *  @return   S16
3202 *      -# ROK
3203 **/
3204 S16 cmPkLrgSchL2MeasStopReq
3205 (
3206 Pst * pst,
3207 LrgSchMeasStopReqInfo *measInfo
3208 )
3209 {
3210    Buffer *mBuf = NULLP;
3211
3212  if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3213 #if (ERRCLASS & ERRCLS_ADD_RES)
3214       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3215          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3216          (ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
3217 #endif
3218       return RFAILED;
3219    }
3220    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
3221    /*CMCHKPK(oduUnpackUInt16, measInfo->timePrd, mBuf);*/
3222    CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
3223    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
3224    pst->event = (Event) EVTLRGSCHL2MEASSTOPREQ;
3225    return (SPstTsk(pst,mBuf));
3226 }/*cmPkLrgSchL2MeasStopReq*/
3227
3228 /**
3229 * @brief This API is used to send a
3230 L2 Measurement Request from LM to MAC.
3231 *
3232 * @details
3233 *
3234 *     Function: cmPkLrgSchL2MeasSendReq
3235 *
3236 *  @param[in]   Pst *  pst
3237 *  @param[in]   LrgSchMeasReqInfo  *  measInfo
3238 *  @return   S16
3239 *      -# ROK
3240 **/
3241 S16 cmPkLrgSchL2MeasSendReq
3242 (
3243 Pst * pst,
3244 LrgSchMeasSndReqInfo *measInfo
3245 )
3246 {
3247    Buffer *mBuf = NULLP;
3248    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3249 #if (ERRCLASS & ERRCLS_ADD_RES)
3250       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3251          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3252          (ErrVal)ELRG049, (ErrVal)0, "SGetMsg failed");
3253 #endif
3254       return RFAILED;
3255    }
3256    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
3257    CMCHKPK(oduUnpackUInt32, measInfo->timePrd, mBuf);
3258    CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
3259    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
3260    pst->event = (Event) EVTLRGSCHL2MEASSENDREQ;
3261    return (SPstTsk(pst,mBuf));
3262 }/*cmPkLrgSchL2MeasSendReq*/
3263 \f
3264 /**
3265 * @brief This API is used to unpack AvgPrbQciReq
3266 *
3267 * @details
3268 *
3269 *     Function: cmUnpkNmbActvUeQciReq
3270 *
3271 *  @param[in]   LrgNmbActvUeQCI     *param
3272 *  @param[in]   Buffer * mBuf
3273 *  @return   S16
3274 *      -# ROK
3275 **/
3276 static S16 cmUnpkNmbActvUeQciReq
3277 (
3278 LrgNmbActvUeQCI  *param,
3279 Buffer           *mBuf
3280 )
3281 {
3282    uint8_t     idx;
3283
3284    CMCHKUNPK(oduPackUInt8, &param->sampPrd, mBuf);
3285    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
3286    for(idx = param->numQci; idx > 0; idx--)
3287    {
3288       CMCHKUNPK(oduPackUInt8, &param->qci[idx - 1], mBuf);
3289    }
3290
3291    return ROK;
3292 }
3293 \f
3294 /**
3295 * @brief This API is used to unpack AvgPrbQciReq
3296 *
3297 * @details
3298 *
3299 *     Function: cmUnpkAvgPrbQciReq
3300 *
3301 *  @param[in]   LrgAvgPrbQCI     *param
3302 *  @param[in]   Buffer * mBuf
3303 *  @return   S16
3304 *      -# ROK
3305 **/
3306 static S16 cmUnpkAvgPrbQciReq
3307 (
3308 LrgAvgPrbQCI     *param,
3309 Buffer           *mBuf
3310 )
3311 {
3312    uint8_t     idx;
3313
3314
3315    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
3316    for(idx = param->numQci; idx > 0; idx--)
3317    {
3318       CMCHKUNPK(oduPackUInt8, &param->qci[idx - 1], mBuf);
3319    }
3320    return ROK;
3321
3322 }
3323 \f
3324 /**
3325 * @brief This API is used to send a
3326 Measurement  Request from LM to SCH.
3327 *
3328 * @details
3329 *
3330 *     Function: cmUnpkLrgSchL2MeasReq
3331 *
3332 *  @param[in]   LrgSchMeasReq func
3333 *  @param[in]   Pst *  pst
3334 *  @param[in]   Buffer * mBuf
3335 *  @return   S16
3336 *      -# ROK
3337 **/
3338 S16 cmUnpkLrgSchL2MeasReq
3339 (
3340 LrgSchL2MeasReq func,
3341 Pst *pst,
3342 Buffer *mBuf
3343 )
3344 {
3345    LrgSchMeasReqInfo  measInfo;
3346
3347
3348    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
3349    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
3350    CMCHKUNPK(oduPackUInt32, &measInfo.timePrd, mBuf);
3351    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
3352    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
3353    {
3354       CMCHKUNPK(cmUnpkAvgPrbQciReq, &measInfo.avgPrbQciUl, mBuf);
3355    }
3356    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
3357    {
3358       CMCHKUNPK(cmUnpkAvgPrbQciReq, &measInfo.avgPrbQciDl, mBuf);
3359    }
3360    if(measInfo.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
3361    {
3362       CMCHKUNPK(cmUnpkNmbActvUeQciReq, &measInfo.nmbActvUeQciUl, mBuf);
3363    }
3364    if(measInfo.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
3365    {
3366       CMCHKUNPK(cmUnpkNmbActvUeQciReq, &measInfo.nmbActvUeQciDl, mBuf);
3367    }
3368    SPutMsg(mBuf);
3369    return ((*func)(pst, &measInfo));
3370 }
3371
3372 /**
3373 * @brief This API is used to stop  a
3374 Measurement  Request from LM to SCH.
3375 *
3376 * @details
3377 *
3378 *     Function: cmUnpkLrgSchL2MeasStopReq
3379 *
3380 *  @param[in]   LrgSchMeasStopReq func
3381 *  @param[in]   Pst *  pst
3382 *  @param[in]   Buffer * mBuf
3383 *  @return   S16
3384 *      -# ROK
3385 **/
3386 S16 cmUnpkLrgSchL2MeasStopReq
3387 (
3388 LrgSchL2MeasStopReq func,
3389 Pst *pst,
3390 Buffer *mBuf
3391 )
3392 {
3393    LrgSchMeasStopReqInfo measInfo;
3394
3395    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
3396    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
3397    /*CMCHKUNPK(oduPackUInt16, &measInfo.timePrd, mBuf);*/
3398    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
3399    SPutMsg(mBuf);
3400    return ((*func)(pst, &measInfo));
3401 }/*cmUnpkLrgSchL2MeasStopReq*/
3402
3403 /**
3404 * @brief This API is used to send a
3405 Measurement  Request from LM to SCH.
3406 *
3407 * @details
3408 *
3409 *     Function: cmUnpkLrgSchL2MeasSendReq
3410 *
3411 *  @param[in]   LrgSchMeasSendReq func
3412 *  @param[in]   Pst *  pst
3413 *  @param[in]   Buffer * mBuf
3414 *  @return   S16
3415 *      -# ROK
3416 **/
3417 S16 cmUnpkLrgSchL2MeasSendReq
3418 (
3419 LrgSchL2MeasSendReq func,
3420 Pst *pst,
3421 Buffer *mBuf
3422 )
3423 {
3424    LrgSchMeasSndReqInfo measInfo;
3425    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
3426    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
3427    CMCHKUNPK(oduPackUInt32, &measInfo.timePrd, mBuf);
3428    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
3429    SPutMsg(mBuf);
3430    return ((*func)(pst, &measInfo));
3431 }/*cmUnpkLrgSchL2MeasSendReq*/
3432
3433 /**
3434 * @brief This API is used to stop a
3435 L2 Measurement confirm from MAC to LM
3436 *
3437 * @details
3438 *
3439 *     Function: cmPkLrgSchL2MeasStopCfm
3440 *
3441 *  @param[in]   Pst *  pst
3442 *  @param[in]   LrgSchMeasCfmInfo  *  measInfo
3443 *  @return   S16
3444 *      -# ROK
3445 **/
3446 S16 cmPkLrgSchL2MeasStopCfm
3447 (
3448 Pst * pst,
3449 LrgSchMeasCfmInfo  *measInfo
3450 )
3451 {
3452    Buffer *mBuf = NULLP;
3453
3454    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3455 #if (ERRCLASS & ERRCLS_ADD_RES)
3456       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3457          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3458          (ErrVal)ELRG050, (ErrVal)0, "SGetMsg failed");
3459 #endif
3460       return RFAILED;
3461    }
3462    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
3463    CMCHKPK(cmPkCmStatus, &measInfo->cfm, mBuf);
3464    CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
3465    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
3466    pst->event = (Event) EVTLRGSCHL2MEASSTOPCFM;
3467    return (SPstTsk(pst,mBuf));
3468 }/*cmPkLrgSchL2MeasStopCfm*/
3469 /**
3470 * @brief This API is used to Send a
3471 Measurement  Confirm from SCH to LM.
3472 *
3473 * @details
3474 *
3475 *     Function: cmUnpkLrgL2SchMeasCfm
3476 *
3477 *  @param[in]   Pst *  pst
3478 *  @param[in]   Buffer * mBuf
3479 *  @return   S16
3480 *      -# ROK
3481 **/
3482 S16 cmUnpkLrgSchL2MeasStopCfm
3483 (
3484 LrgSchL2MeasStopCfm func,
3485 Pst *pst,
3486 Buffer *mBuf
3487 )
3488 {
3489    LrgSchMeasCfmInfo  measInfo;
3490
3491
3492    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
3493    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
3494    CMCHKUNPK(cmUnpkCmStatus, &measInfo.cfm, mBuf);
3495    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
3496
3497    SPutMsg(mBuf);
3498    return ((*func)(pst, &measInfo));
3499 }/*cmUnpkLrgSchL2MeasStopCfm*/
3500 \f
3501 /**
3502 * @brief This API is used to unpack LrgNumActvUeQCICfm structure
3503 *
3504 * @details
3505 *
3506 *     Function: cmPkNumUeQciCfm
3507 *
3508 *  @param[in]   LrgNumActvUeQCICfm *  param
3509 *  @param[in]   Buffer *  mBuf
3510 *  @return   S16
3511 *      -# ROK
3512 **/
3513 static S16 cmPkNumUeQciCfm
3514 (
3515 LrgNumActvUeQCICfm  *param,
3516 Buffer              *mBuf
3517 )
3518 {
3519    uint8_t         idx;
3520
3521
3522    for(idx = 0; idx < param->numQci; idx++)
3523    {
3524 /*LRG : Review Tag*/
3525      CMCHKPK(oduUnpackUInt8, param->numActvUeQci[idx].qciValue, mBuf);
3526      CMCHKPK(oduUnpackUInt8, param->numActvUeQci[idx].numActvUeQci, mBuf);
3527 /*LRG : Review Tag*/
3528    }
3529    CMCHKPK(oduUnpackUInt8, param->numQci, mBuf);
3530    return ROK;
3531 }
3532 \f
3533 /**
3534 * @brief This API is used to unpack LrgAvgPrbQCICfm structure
3535 *
3536 * @details
3537 *
3538 *     Function: cmPkAvgPrbQciCfm
3539 *
3540 *  @param[in]   LrgAvgPrbQCICfm *  param
3541 *  @param[in]   Buffer *  mBuf
3542 *  @return   S16
3543 *      -# ROK
3544 **/
3545 static S16 cmPkAvgPrbQciCfm
3546 (
3547 LrgAvgPrbQCICfm    *param,
3548 Buffer             *mBuf
3549 )
3550 {
3551    uint8_t         idx;
3552
3553    for(idx = 0; idx < param->numQci; idx++)
3554    {
3555 /*LRG : Review Tag*/
3556       CMCHKPK(oduUnpackUInt8, param->prbPercQci[idx].qciValue, mBuf);
3557       CMCHKPK(oduUnpackUInt8, param->prbPercQci[idx].prbPercQci, mBuf);
3558 /*LRG : Review Tag*/
3559    }
3560    CMCHKPK(oduUnpackUInt8, param->numQci, mBuf);
3561    return ROK;
3562 }
3563 \f
3564 /**
3565 * @brief This API is used to unpack raPreamblesCfm structure
3566 *
3567 * @details
3568 *
3569 *     Function: cmPkRaPrmbsCfm
3570 *
3571 *  @param[in]   LrgRaPreamblesCfm *  param
3572 *  @param[in]   Buffer *  mBuf
3573 *  @return   S16
3574 *      -# ROK
3575 **/
3576 static S16 cmPkRaPrmbsCfm
3577 (
3578 LrgRaPreamblesCfm  *param,
3579 Buffer             *mBuf
3580 )
3581 {
3582
3583    CMCHKPK(oduUnpackUInt16, param->randSelPreHighRange, mBuf);
3584    CMCHKPK(oduUnpackUInt16, param->randSelPreLowRange, mBuf);
3585    CMCHKPK(oduUnpackUInt16, param->dedPreambles, mBuf);
3586    return ROK;
3587 }
3588 \f
3589 /**
3590 * @brief This API is used to unpack avgPrbCfm structure
3591 *
3592 * @details
3593 *
3594 *     Function: cmPkAvgPrbCfm
3595 *
3596 *  @param[in]   LrgAvgPrbCfm *  param
3597 *  @param[in]   Buffer *  mBuf
3598 *  @return   S16
3599 *      -# ROK
3600 **/
3601 static S16 cmPkAvgPrbCfm
3602 (
3603 LrgAvgPrbCfm  *param,
3604 Buffer        *mBuf
3605 )
3606 {
3607
3608    CMCHKPK(oduUnpackUInt8, param->prbPerc, mBuf);
3609    return ROK;
3610 }
3611 \f
3612 /**
3613 * @brief This API is used to send a
3614 L2 Measurement confirm from MAC to LM
3615 *
3616 * @details
3617 *
3618 *     Function: cmPkLrgSchL2MeasCfm
3619 *
3620 *  @param[in]   Pst *  pst
3621 *  @param[in]   LrgSchMeasCfmInfo  *  measInfo
3622 *  @return   S16
3623 *      -# ROK
3624 **/
3625 S16 cmPkLrgSchL2MeasCfm
3626 (
3627 Pst * pst,
3628 LrgSchMeasCfmInfo  *measInfo
3629 )
3630 {
3631    Buffer *mBuf = NULLP;
3632
3633
3634    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
3635 #if (ERRCLASS & ERRCLS_ADD_RES)
3636       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
3637          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
3638          (ErrVal)ELRG050, (ErrVal)0, "SGetMsg failed");
3639 #endif
3640       return RFAILED;
3641    }
3642    if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
3643    {
3644      CMCHKPK(cmPkNumUeQciCfm, &measInfo->numUeQciDlCfm, mBuf);
3645    }
3646    if(measInfo->measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
3647    {
3648      CMCHKPK(cmPkNumUeQciCfm, &measInfo->numUeQciUlCfm, mBuf);
3649    }
3650    if(measInfo->measType & LRG_L2MEAS_RA_PREAMBLE)
3651    {
3652      CMCHKPK(cmPkRaPrmbsCfm, &measInfo->raPrmbsCfm, mBuf);
3653    }
3654    if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
3655    {
3656      CMCHKPK(cmPkAvgPrbQciCfm, &measInfo->avgPrbQciDlCfm, mBuf);
3657    }
3658    if(measInfo->measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
3659    {
3660      CMCHKPK(cmPkAvgPrbQciCfm, &measInfo->avgPrbQciUlCfm, mBuf);
3661    }
3662    if(measInfo->measType & LRG_L2MEAS_AVG_PRB_DL)
3663    {
3664      CMCHKPK(cmPkAvgPrbCfm, &measInfo->avgPrbDl, mBuf);
3665    }
3666    if(measInfo->measType & LRG_L2MEAS_AVG_PRB_UL)
3667    {
3668      CMCHKPK(cmPkAvgPrbCfm, &measInfo->avgPrbUl, mBuf);
3669    }
3670    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
3671    {
3672       CMCHKPK(oduUnpackUInt32, measInfo->tbTransDlTotalCnt, mBuf);
3673    }
3674    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
3675    {
3676       CMCHKPK(oduUnpackUInt32, measInfo->tbTransDlFaulty, mBuf);
3677    }
3678    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
3679    {
3680       CMCHKPK(oduUnpackUInt32, measInfo->tbTransUlTotalCnt, mBuf);
3681    }
3682    if(measInfo->measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
3683    {
3684       CMCHKPK(oduUnpackUInt32, measInfo->tbTransUlFaulty, mBuf);
3685    }
3686    CMCHKPK(cmPkLteCellId, measInfo->cellId, mBuf);
3687    CMCHKPK(cmPkCmStatus, &measInfo->cfm, mBuf);
3688    CMCHKPK(oduUnpackUInt16, measInfo->measType, mBuf);
3689    CMCHKPK(cmPkHeader, &measInfo->hdr, mBuf);
3690    pst->event = (Event) EVTLRGSCHL2MEASCFM;
3691    return (SPstTsk(pst,mBuf));
3692 }
3693 \f
3694 /**
3695 * @brief This API is used to unpack LrgNumActvUeQCICfm
3696 *
3697 * @details
3698 *
3699 *     Function: cmUnpkNumUeQciCfm
3700 *
3701 *  @param[in]   LrgNumActvUeQCICfm *param
3702 *  @param[in]   Buffer * mBuf
3703 *  @return   Void
3704 *      -# ROK
3705 **/
3706 static S16 cmUnpkNumUeQciCfm
3707 (
3708 LrgNumActvUeQCICfm *param,
3709 Buffer          *mBuf
3710 )
3711 {
3712    uint8_t          idx;
3713
3714    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
3715    for(idx = param->numQci; idx > 0; idx--)
3716    {
3717 /*LRG : Review Tag*/
3718        CMCHKUNPK(oduPackUInt8, &param->numActvUeQci[idx - 1].numActvUeQci, mBuf);
3719        CMCHKUNPK(oduPackUInt8, &param->numActvUeQci[idx - 1].qciValue, mBuf);
3720 /*LRG : Review Tag*/
3721    }
3722    return ROK;
3723 }
3724 \f
3725 /**
3726 * @brief This API is used to unpack LrgAvgPrbQCICfm
3727 *
3728 * @details
3729 *
3730 *     Function: cmUnpkAvgPrbQciCfm
3731 *
3732 *  @param[in]   LrgAvgPrbQCICfm *param
3733 *  @param[in]   Buffer * mBuf
3734 *  @return  Void
3735 *      -# ROK
3736 **/
3737 static S16 cmUnpkAvgPrbQciCfm
3738 (
3739 LrgAvgPrbQCICfm *param,
3740 Buffer          *mBuf
3741 )
3742 {
3743    uint8_t          idx;
3744
3745
3746    CMCHKUNPK(oduPackUInt8, &param->numQci, mBuf);
3747    for(idx = param->numQci; idx > 0; idx--)
3748    {
3749 /*LRG : Review Tag*/
3750       CMCHKUNPK(oduPackUInt8, &param->prbPercQci[idx - 1].prbPercQci, mBuf);
3751       CMCHKUNPK(oduPackUInt8, &param->prbPercQci[idx - 1].qciValue, mBuf);
3752 /*LRG : Review Tag*/
3753    }
3754    return ROK;
3755 }
3756 \f
3757 /**
3758 * @brief This API is used to unpack LrgRaPreamblesCfm
3759 *
3760 * @details
3761 *
3762 *     Function: cmUnpkRaPrmbsCfm
3763 *
3764 *  @param[in]   LrgRaPreamblesCfm *param
3765 *  @param[in]   Buffer * mBuf
3766 *  @return   Void
3767 *      -# ROK
3768 **/
3769 static S16 cmUnpkRaPrmbsCfm
3770 (
3771 LrgRaPreamblesCfm *param,
3772 Buffer         *mBuf
3773 )
3774 {
3775
3776
3777    CMCHKUNPK(oduPackUInt16, &param->dedPreambles, mBuf);
3778    CMCHKUNPK(oduPackUInt16, &param->randSelPreLowRange, mBuf);
3779    CMCHKUNPK(oduPackUInt16, &param->randSelPreHighRange, mBuf);
3780    return ROK;
3781 }
3782 \f
3783 /**
3784 * @brief This API is used to unpack avgPrbCfm
3785 *
3786 * @details
3787 *
3788 *     Function: cmUnpkAvgPrbCfm
3789 *
3790 *  @param[in]   LrgAvgPrbCfm  *param
3791 *  @param[in]   Buffer * mBuf
3792 *  @return   Void
3793 *      -# ROK
3794 **/
3795 static S16 cmUnpkAvgPrbCfm
3796 (
3797 LrgAvgPrbCfm   *param,
3798 Buffer         *mBuf
3799 )
3800 {
3801
3802
3803    CMCHKUNPK(oduPackUInt8, &param->prbPerc, mBuf);
3804    return ROK;
3805 }
3806 \f
3807 /**
3808 * @brief This API is used to send a
3809 Measurement  Confirm from LM to SCH.
3810 *
3811 * @details
3812 *
3813 *     Function: cmUnpkLrgL2SchMeasCfm
3814 *
3815 *  @param[in]   Pst *  pst
3816 *  @param[in]   Buffer * mBuf
3817 *  @return   S16
3818 *      -# ROK
3819 **/
3820 S16 cmUnpkLrgSchL2MeasCfm
3821 (
3822 LrgSchL2MeasCfm func,
3823 Pst *pst,
3824 Buffer *mBuf
3825 )
3826 {
3827    LrgSchMeasCfmInfo  measInfo;
3828
3829
3830    CMCHKUNPK(cmUnpkHeader, &measInfo.hdr, mBuf);
3831    CMCHKUNPK(oduPackUInt16, &measInfo.measType, mBuf);
3832    CMCHKUNPK(cmUnpkCmStatus, &measInfo.cfm, mBuf);
3833    CMCHKUNPK(cmUnpkLteCellId, &measInfo.cellId, mBuf);
3834    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT)
3835    {
3836       CMCHKPK(oduPackUInt32, &measInfo.tbTransUlFaulty, mBuf);
3837    }
3838    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_UL_COUNT)
3839    {
3840       CMCHKPK(oduPackUInt32, &measInfo.tbTransUlTotalCnt, mBuf);
3841    }
3842    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT)
3843    {
3844       CMCHKPK(oduPackUInt32, &measInfo.tbTransDlFaulty, mBuf);
3845    }
3846    if(measInfo.measType & LRG_L2MEAS_TB_TRANS_DL_COUNT)
3847    {
3848       CMCHKPK(oduPackUInt32, &measInfo.tbTransDlTotalCnt, mBuf);
3849    }
3850    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_UL)
3851    {
3852      CMCHKUNPK(cmUnpkAvgPrbCfm, &measInfo.avgPrbUl, mBuf);
3853    }
3854    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_DL)
3855    {
3856      CMCHKUNPK(cmUnpkAvgPrbCfm, &measInfo.avgPrbDl, mBuf);
3857    }
3858    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
3859    {
3860      CMCHKUNPK(cmUnpkAvgPrbQciCfm, &measInfo.avgPrbQciUlCfm, mBuf);
3861    }
3862    if(measInfo.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_DL)
3863    {
3864      CMCHKUNPK(cmUnpkAvgPrbQciCfm, &measInfo.avgPrbQciDlCfm, mBuf);
3865    }
3866    if(measInfo.measType & LRG_L2MEAS_RA_PREAMBLE)
3867    {
3868      CMCHKUNPK(cmUnpkRaPrmbsCfm, &measInfo.raPrmbsCfm, mBuf);
3869    }
3870    if(measInfo.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL)
3871    {
3872      CMCHKUNPK(cmUnpkNumUeQciCfm, &measInfo.numUeQciUlCfm, mBuf);
3873    }
3874    if(measInfo.measType & LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL)
3875    {
3876      CMCHKUNPK(cmUnpkNumUeQciCfm, &measInfo.numUeQciDlCfm, mBuf);
3877    }
3878    SPutMsg(mBuf);
3879    return ((*func)(pst, &measInfo));
3880 }
3881 #endif
3882 #endif
3883 \f
3884
3885 /**********************************************************************
3886          End of file
3887  **********************************************************************/