src/cm/rgm.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 packing/unpacking of RGM interface
  27                primitives.
  28
  29      File:     rgm.c
  30
  31 **********************************************************************/
  32
  33 /** @file rgm.c
  34 @brief This file contains the packing/unpacking code for the RGM interface
  35        primitives.
  36 */
  37
  38 /* header include files (.h) */
  39 #include "common_def.h"
  40 #include "rgm.h"           /* RGM Interface defines */
  41 /* header/extern include files (.x) */
  42 #include "rgm.x"           /* RGM Interface includes */
  43
  44 #ifdef RGM_LWLC
  45
  46 \f
  47 /**
  48 * @brief Request from RRM to MAC to bind the interface saps
  49 *
  50 * @details
  51 *
  52 *     Function : cmPkLwLcRgmBndReq
  53 *
  54 *  @param[in]   Pst*  pst
  55 *  @param[in]   SuId  suId
  56 *  @param[in]   SpId  spId
  57 *  @return   S16
  58 *      -# ROK
  59 **/
  60 #ifdef ANSI
  61 PUBLIC S16 cmPkLwLcRgmBndReq
  62 (
  63 Pst* pst,
  64 SuId suId,
  65 SpId spId
  66 )
  67 #else
  68 PUBLIC S16 cmPkLwLcRgmBndReq(pst, suId, spId)
  69 Pst* pst;
  70 SuId suId;
  71 SpId spId;
  72 #endif
  73 {
  74    Buffer *mBuf = NULLP;
  75    TRC3(cmPkLwLcRgmBndReq)
  76
  77    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
  78    {
  79       RETVALUE(RFAILED);
  80    }
  81
  82    if (SPkS16(spId, mBuf) != ROK)
  83    {
  84       SPutMsg(mBuf);
  85       RETVALUE(RFAILED);
  86    }
  87
  88    if (SPkS16(suId, mBuf) != ROK)
  89    {
  90       SPutMsg(mBuf);
  91       RETVALUE(RFAILED);
  92    }
  93
  94    pst->event = (Event) EVTRGMBNDREQ;
  95    RETVALUE(SPstTsk(pst,mBuf));
  96 }
  97
  98 \f
  99 /**
 100 * @brief Request from RRM to MAC to bind the interface saps
 101 *
 102 * @details
 103 *
 104 *     Function : cmUnpkLwLcRgmBndReq
 105 *
 106 *  @param[in]   Pst*  pst
 107 *  @param[in]   SuId  suId
 108 *  @param[in]   SpId  spId
 109 *  @return   S16
 110 *      -# ROK
 111 **/
 112 #ifdef ANSI
 113 PUBLIC S16 cmUnpkLwLcRgmBndReq
 114 (
 115 RgmBndReq func,
 116 Pst *pst,
 117 Buffer *mBuf
 118 )
 119 #else
 120 PUBLIC S16 cmUnpkLwLcRgmBndReq(func, pst, mBuf)
 121 RgmBndReq func;
 122 Pst *pst;
 123 Buffer *mBuf;
 124 #endif
 125 {
 126    SuId suId;
 127    SpId spId;
 128    S16  ret;
 129
 130    TRC3(cmUnpkLwLcRgmBndReq)
 131
 132    if (SUnpkS16(&suId, mBuf) != ROK)
 133    {
 134       SPutMsg(mBuf);
 135       RETVALUE(RFAILED);
 136    }
 137
 138    if (SUnpkS16(&spId, mBuf) != ROK)
 139    {
 140       SPutMsg(mBuf);
 141       RETVALUE(RFAILED);
 142    }
 143
 144    ret = ((*func)(pst, suId, spId));
 145
 146    SPutMsg(mBuf);
 147
 148    RETVALUE(ret);
 149 }
 150
 151 /**
 152 * @brief Request from RRM to MAC to Unbind the interface saps
 153 *
 154 * @details
 155 *
 156 *     Function : cmPkLwLcRgmUbndReq
 157 *
 158 *  @param[in]   Pst*  pst
 159 *  @param[in]   SpId  spId
 160 *  @param[in]   Reason  reason
 161 *  @return   S16
 162 *      -# ROK
 163 **/
 164 #ifdef ANSI
 165 PUBLIC S16 cmPkLwLcRgmUbndReq
 166 (
 167 Pst* pst,
 168 SpId spId,
 169 Reason reason
 170 )
 171 #else
 172 PUBLIC S16 cmPkLwLcRgmUbndReq(pst, spId, reason)
 173 Pst* pst;
 174 SpId spId;
 175 Reason reason;
 176 #endif
 177 {
 178    Buffer *mBuf = NULLP;
 179    TRC3(cmPkLwLcRgmUbndReq)
 180
 181    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 182    {
 183       RETVALUE(RFAILED);
 184    }
 185    if (SPkS16(reason, mBuf) != ROK)
 186    {
 187       SPutMsg(mBuf);
 188       RETVALUE(RFAILED);
 189    }
 190    if (SPkS16(spId, mBuf) != ROK)
 191    {
 192       SPutMsg(mBuf);
 193       RETVALUE(RFAILED);
 194    }
 195
 196    pst->event = (Event) EVTRGMUBNDREQ;
 197    RETVALUE(SPstTsk(pst,mBuf));
 198 }
 199
 200 /**
 201 * @brief Confirmation from MAC to RRM for the bind/Unbind
 202  * request for the interface saps
 203 *
 204 * @details
 205 *
 206 *     Function : cmPkLwLcRgmBndCfm
 207 *
 208 *  @param[in]   Pst*  pst
 209 *  @param[in]   SuId  suId
 210 *  @param[in]   U8  status
 211 *  @return   S16
 212 *      -# ROK
 213 **/
 214 #ifdef ANSI
 215 PUBLIC S16 cmPkLwLcRgmBndCfm
 216 (
 217 Pst* pst,
 218 SuId suId,
 219 U8 status
 220 )
 221 #else
 222 PUBLIC S16 cmPkLwLcRgmBndCfm(pst, suId, status)
 223 Pst* pst;
 224 SuId suId;
 225 U8 status;
 226 #endif
 227 {
 228    Buffer *mBuf = NULLP;
 229    TRC3(cmPkLwLcRgmBndCfm)
 230
 231    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 232    {
 233       RETVALUE(RFAILED);
 234    }
 235
 236    if (SPkS16(suId, mBuf) != ROK)
 237    {
 238       SPutMsg(mBuf);
 239       RETVALUE(RFAILED);
 240    }
 241
 242    if (SPkU8(status, mBuf) != ROK)
 243    {
 244       SPutMsg(mBuf);
 245       RETVALUE(RFAILED);
 246    }
 247
 248   pst->event = (Event) EVTRGMBNDCFM;
 249    RETVALUE(SPstTsk(pst,mBuf));
 250 }
 251
 252 \f
 253 /**
 254 * @brief Confirmation from MAC to RRM for the bind/Unbind
 255  * request for the interface saps
 256 *
 257 * @details
 258 *
 259 *     Function : cmUnpkLwLcRgmBndCfm
 260 *
 261 *  @param[in]   Pst*  pst
 262 *  @param[in]   SuId  suId
 263 *  @param[in]   U8  status
 264 *  @return   S16
 265 *      -# ROK
 266 **/
 267 #ifdef ANSI
 268 PUBLIC S16 cmUnpkLwLcRgmBndCfm
 269 (
 270 RgmBndCfm func,
 271 Pst *pst,
 272 Buffer *mBuf
 273 )
 274 #else
 275 PUBLIC S16 cmUnpkLwLcRgmBndCfm(func, pst, mBuf)
 276 RgmBndCfm func;
 277 Pst *pst;
 278 Buffer *mBuf;
 279 #endif
 280 {
 281    SuId suId;
 282    U8 status;
 283
 284    TRC3(cmUnpkLwLcRgmBndCfm)
 285
 286    if (SUnpkU8(&status, mBuf) != ROK)
 287    {
 288       SPutMsg(mBuf);
 289       RETVALUE(RFAILED);
 290    }
 291
 292    if (SUnpkS16(&suId, mBuf) != ROK)
 293    {
 294       SPutMsg(mBuf);
 295       RETVALUE(RFAILED);
 296    }
 297    SPutMsg(mBuf);
 298    RETVALUE((*func)(pst, suId, status));
 299 }
 300
 301 \f
 302 /**
 303 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC
 304 *
 305 * @details
 306 *
 307 *     Function : cmPkLwLcRgmCfgPrbRprt
 308 *
 309 *  @param[in]   Pst*  pst
 310 *  @param[in]   SpId  spId
 311 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
 312 *  @return   S16
 313 *      -# ROK
 314 **/
 315 #ifdef ANSI
 316 PUBLIC S16 cmPkLwLcRgmCfgPrbRprt
 317 (
 318 Pst* pst,
 319 SpId spId,
 320 RgmPrbRprtCfg  * prbRprtCfg
 321 )
 322 #else
 323 PUBLIC S16 cmPkLwLcRgmCfgPrbRprt(pst, spId, prbRprtCfg)
 324 Pst* pst;
 325 SpId spId;
 326 RgmPrbRprtCfg  * prbRprtCfg;
 327 #endif
 328 {
 329    Buffer *mBuf = NULLP;
 330    U32 len = sizeof(RgmPrbRprtCfg);
 331    TRC3(cmPkLwLcRgmCfgPrbRprt)
 332
 333    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 334    {
 335       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
 336       RETVALUE(RFAILED);
 337    }
 338
 339     if(cmPkPtr((PTR)prbRprtCfg, mBuf) != ROK)
 340     {
 341        SPutMsg(mBuf);
 342        SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
 343        RETVALUE(RFAILED);
 344     }
 345
 346    if (SPkS16(spId, mBuf) != ROK)
 347    {
 348       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
 349       SPutMsg(mBuf);
 350       RETVALUE(RFAILED);
 351    }
 352
 353    pst->event = (Event) EVTRGMCFGPRBRPRT;
 354    RETVALUE(SPstTsk(pst,mBuf));
 355 }
 356
 357 \f
 358 /**
 359 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC
 360 *
 361 * @details
 362 *
 363 *     Function : cmUnpkLwLcRgmCfgPrbRprt
 364 *
 365 *  @param[in]   Pst*  pst
 366 *  @param[in]   SpId  spId
 367 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
 368 *  @return   S16
 369 *      -# ROK
 370 **/
 371 #ifdef ANSI
 372 PUBLIC S16 cmUnpkLwLcRgmCfgPrbRprt
 373 (
 374 RgmCfgPrbRprtFptr func,
 375 Pst *pst,
 376 Buffer *mBuf
 377 )
 378 #else
 379 PUBLIC S16 cmUnpkLwLcRgmCfgPrbRprt(func, pst, mBuf)
 380 RgmCfgPrbRprtFptr func;
 381 Pst *pst;
 382 Buffer *mBuf;
 383 #endif
 384 {
 385    S16 ret;
 386    SpId spId;
 387    RgmPrbRprtCfg *prbRprtCfg;
 388
 389    TRC3(cmUnpkLwLcRgmCfgPrbRprt)
 390
 391    if (SUnpkS16(&spId, mBuf) != ROK)
 392    {
 393       SPutMsg(mBuf);
 394       RETVALUE(RFAILED);
 395    }
 396
 397    if (cmUnpkPtr((PTR *)&prbRprtCfg, mBuf) != ROK)
 398    {
 399       SPutMsg(mBuf);
 400       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
 401       RETVALUE(RFAILED);
 402    }
 403
 404    ret =  ((*func)(pst, spId, prbRprtCfg));
 405
 406    SPutMsg(mBuf);
 407    RETVALUE(ret);
 408 }
 409
 410
 411 /**
 412 * @brief PRB Usage Report Indication  from MAC to RRM
 413 *
 414 * @details
 415 *
 416 *     Function : cmPkLwLcRgmPrbRprtInd
 417 *
 418 *  @param[in]   Pst*  pst
 419 *  @param[in]   SuId  suId
 420 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
 421 *  @return   S16
 422 *      -# ROK
 423 **/
 424 #ifdef ANSI
 425 PUBLIC S16 cmPkLwLcRgmPrbRprtInd
 426 (
 427 Pst* pst,
 428 SuId suId,
 429 RgmPrbRprtInd  * prbRprtInd
 430 )
 431 #else
 432 PUBLIC S16 cmPkLwLcRgmPrbRprtInd(pst, suId, prbRprtInd)
 433 Pst* pst;
 434 SuId suId;
 435 RgmPrbRprtInd  * prbRprtInd;
 436 #endif
 437 {
 438    Buffer *mBuf = NULLP;
 439
 440    TRC3(cmPkLwLcRgmPrbRprtInd)
 441
 442    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 443       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
 444       RETVALUE(RFAILED);
 445    }
 446
 447    if(cmPkPtr((PTR)prbRprtInd, mBuf) != ROK)
 448    {
 449       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
 450       SPutMsg(mBuf);
 451       RETVALUE(RFAILED);
 452    }
 453
 454    if (SPkS16(suId, mBuf) != ROK)
 455    {
 456       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
 457       SPutMsg(mBuf);
 458       RETVALUE(RFAILED);
 459    }
 460
 461    pst->event = (Event) EVTRGMCFGPRBRPRT;
 462    RETVALUE(SPstTsk(pst,mBuf));
 463 }
 464
 465
 466 /**
 467 * @brief PRB Usage Report Indication from MAC to RRM
 468 *
 469 * @details
 470 *
 471 *     Function : cmUnpkLwLcRgmPrbRprtInd
 472 *
 473 *  @param[in]   Pst*  pst
 474 *  @param[in]   SuId  suId
 475 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
 476 *  @return   S16
 477 *      -# ROK
 478 **/
 479 #ifdef ANSI
 480 PUBLIC S16 cmUnpkLwLcRgmPrbRprtInd
 481 (
 482 RgmPrbRprtIndFptr func,
 483 Pst *pst,
 484 Buffer *mBuf
 485 )
 486 #else
 487 PUBLIC S16 cmUnpkLwLcRgmPrbRprtInd(func, pst, mBuf)
 488 RgmPrbRprtIndFptr func;
 489 Pst *pst;
 490 Buffer *mBuf;
 491 #endif
 492 {
 493    SuId suId;
 494    RgmPrbRprtInd *prbRprtInd;
 495    S16 ret;
 496
 497    TRC3(cmUnpkLwLcRgmPrbRprtInd)
 498
 499    if (SUnpkS16(&suId, mBuf) != ROK)
 500    {
 501       SPutMsg(mBuf);
 502       RETVALUE(RFAILED);
 503    }
 504
 505    if (cmUnpkPtr((PTR *)&prbRprtInd, mBuf) != ROK)
 506    {
 507       SPutMsg(mBuf);
 508       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
 509       RETVALUE(RFAILED);
 510    }
 511
 512
 513    ret = ((*func)(pst, suId, prbRprtInd));
 514
 515    SPutMsg(mBuf);
 516
 517    RETVALUE(ret);
 518 }
 519 #endif
 520
 521
 522 /**
 523 * @brief Request from RRM to MAC to bind the interface saps
 524 *
 525 * @details
 526 *
 527 *     Function : cmPkRgmBndReq
 528 *
 529 *  @param[in]   Pst*  pst
 530 *  @param[in]   SuId  suId
 531 *  @param[in]   SpId  spId
 532 *  @return   S16
 533 *      -# ROK
 534 **/
 535 #ifdef ANSI
 536 PUBLIC S16 cmPkRgmBndReq
 537 (
 538 Pst* pst,
 539 SuId suId,
 540 SpId spId
 541 )
 542 #else
 543 PUBLIC S16 cmPkRgmBndReq(pst, suId, spId)
 544 Pst* pst;
 545 SuId suId;
 546 SpId spId;
 547 #endif
 548 {
 549    Buffer *mBuf = NULLP;
 550    TRC3(cmPkRgmBndReq)
 551
 552    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 553    {
 554       RETVALUE(RFAILED);
 555    }
 556
 557    if (SPkS16(spId, mBuf) != ROK)
 558    {
 559       SPutMsg(mBuf);
 560       RETVALUE(RFAILED);
 561    }
 562
 563    if (SPkS16(suId, mBuf) != ROK)
 564    {
 565       SPutMsg(mBuf);
 566       RETVALUE(RFAILED);
 567    }
 568
 569    pst->event = (Event) EVTRGMBNDREQ;
 570    RETVALUE(SPstTsk(pst,mBuf));
 571 }
 572
 573 \f
 574 /**
 575 * @brief Request from RRM to MAC to bind the interface saps
 576 *
 577 * @details
 578 *
 579 *     Function : cmUnpkRgmBndReq
 580 *
 581 *  @param[in]   Pst*  pst
 582 *  @param[in]   SuId  suId
 583 *  @param[in]   SpId  spId
 584 *  @return   S16
 585 *      -# ROK
 586 **/
 587 #ifdef ANSI
 588 PUBLIC S16 cmUnpkRgmBndReq
 589 (
 590 RgmBndReq func,
 591 Pst *pst,
 592 Buffer *mBuf
 593 )
 594 #else
 595 PUBLIC S16 cmUnpkRgmBndReq(func, pst, mBuf)
 596 RgmBndReq func;
 597 Pst *pst;
 598 Buffer *mBuf;
 599 #endif
 600 {
 601    SuId suId;
 602    SpId spId;
 603    S16  ret;
 604
 605    TRC3(cmUnpkRgmBndReq)
 606
 607    if (SUnpkS16(&suId, mBuf) != ROK)
 608    {
 609       SPutMsg(mBuf);
 610       RETVALUE(RFAILED);
 611    }
 612
 613    if (SUnpkS16(&spId, mBuf) != ROK)
 614    {
 615       SPutMsg(mBuf);
 616       RETVALUE(RFAILED);
 617    }
 618
 619    ret = ((*func)(pst, suId, spId));
 620
 621    SPutMsg(mBuf);
 622
 623    RETVALUE(ret);
 624 }
 625
 626 /**
 627 * @brief Request from RRM to MAC to Unbind the interface saps
 628 *
 629 * @details
 630 *
 631 *     Function : cmPkRgmUbndReq
 632 *
 633 *  @param[in]   Pst*  pst
 634 *  @param[in]   SpId  spId
 635 *  @param[in]   Reason  reason
 636 *  @return   S16
 637 *      -# ROK
 638 **/
 639 #ifdef ANSI
 640 PUBLIC S16 cmPkRgmUbndReq
 641 (
 642 Pst* pst,
 643 SpId spId,
 644 Reason reason
 645 )
 646 #else
 647 PUBLIC S16 cmPkRgmUbndReq(pst, spId, reason)
 648 Pst* pst;
 649 SpId spId;
 650 Reason reason;
 651 #endif
 652 {
 653    Buffer *mBuf = NULLP;
 654    TRC3(cmPkRgmUbndReq)
 655
 656    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 657    {
 658       RETVALUE(RFAILED);
 659    }
 660    if (SPkS16(reason, mBuf) != ROK)
 661    {
 662       SPutMsg(mBuf);
 663       RETVALUE(RFAILED);
 664    }
 665    if (SPkS16(spId, mBuf) != ROK)
 666    {
 667       SPutMsg(mBuf);
 668       RETVALUE(RFAILED);
 669    }
 670
 671    pst->event = (Event) EVTRGMUBNDREQ;
 672    RETVALUE(SPstTsk(pst,mBuf));
 673 }
 674
 675 #if 1
 676 \f
 677 /**
 678 * @brief Request from RRM to MAC to Unbind the interface saps
 679 *
 680 * @details
 681 *
 682 *     Function : cmUnpkRgmUbndReq
 683 *
 684 *  @param[in]   Pst*  pst
 685 *  @param[in]   SpId  spId
 686 *  @param[in]   Reason  reason
 687 *  @return   S16
 688 *      -# ROK
 689 **/
 690 #ifdef ANSI
 691 PUBLIC S16 cmUnpkRgmUbndReq
 692 (
 693 RgmUbndReq func,
 694 Pst *pst,
 695 Buffer *mBuf
 696 )
 697 #else
 698 PUBLIC S16 cmUnpkRgmUbndReq(func, pst, mBuf)
 699 RgmUbndReq func;
 700 Pst *pst;
 701 Buffer *mBuf;
 702 #endif
 703 {
 704    SpId spId;
 705    Reason reason;
 706
 707    TRC3(cmUnpkRgmUbndReq)
 708
 709    if (SUnpkS16(&spId, mBuf) != ROK)
 710    {
 711       SPutMsg(mBuf);
 712       RETVALUE(RFAILED);
 713    }
 714    if (SUnpkS16(&reason, mBuf) != ROK)
 715    {
 716       SPutMsg(mBuf);
 717       RETVALUE(RFAILED);
 718    }
 719    SPutMsg(mBuf);
 720    RETVALUE((*func)(pst, spId, reason));
 721 }
 722 #endif
 723
 724 /**
 725 * @brief Confirmation from MAC to RRM for the bind/Unbind
 726  * request for the interface saps
 727 *
 728 * @details
 729 *
 730 *     Function : cmPkRgmBndCfm
 731 *
 732 *  @param[in]   Pst*  pst
 733 *  @param[in]   SuId  suId
 734 *  @param[in]   U8  status
 735 *  @return   S16
 736 *      -# ROK
 737 **/
 738 #ifdef ANSI
 739 PUBLIC S16 cmPkRgmBndCfm
 740 (
 741 Pst* pst,
 742 SuId suId,
 743 U8 status
 744 )
 745 #else
 746 PUBLIC S16 cmPkRgmBndCfm(pst, suId, status)
 747 Pst* pst;
 748 SuId suId;
 749 U8 status;
 750 #endif
 751 {
 752    Buffer *mBuf = NULLP;
 753    TRC3(cmPkRgmBndCfm)
 754
 755    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 756    {
 757       RETVALUE(RFAILED);
 758    }
 759
 760    if (SPkS16(suId, mBuf) != ROK)
 761    {
 762       SPutMsg(mBuf);
 763       RETVALUE(RFAILED);
 764    }
 765
 766    if (SPkU8(status, mBuf) != ROK)
 767    {
 768       SPutMsg(mBuf);
 769       RETVALUE(RFAILED);
 770    }
 771
 772   pst->event = (Event) EVTRGMBNDCFM;
 773    RETVALUE(SPstTsk(pst,mBuf));
 774 }
 775
 776 \f
 777 /**
 778 * @brief Confirmation from MAC to RRM for the bind/Unbind
 779  * request for the interface saps
 780 *
 781 * @details
 782 *
 783 *     Function : cmUnpkRgmBndCfm
 784 *
 785 *  @param[in]   Pst*  pst
 786 *  @param[in]   SuId  suId
 787 *  @param[in]   U8  status
 788 *  @return   S16
 789 *      -# ROK
 790 **/
 791 #ifdef ANSI
 792 PUBLIC S16 cmUnpkRgmBndCfm
 793 (
 794 RgmBndCfm func,
 795 Pst *pst,
 796 Buffer *mBuf
 797 )
 798 #else
 799 PUBLIC S16 cmUnpkRgmBndCfm(func, pst, mBuf)
 800 RgmBndCfm func;
 801 Pst *pst;
 802 Buffer *mBuf;
 803 #endif
 804 {
 805    SuId suId;
 806    U8 status;
 807
 808    TRC3(cmUnpkRgmBndCfm)
 809
 810    if (SUnpkU8(&status, mBuf) != ROK)
 811    {
 812       SPutMsg(mBuf);
 813       RETVALUE(RFAILED);
 814    }
 815
 816    if (SUnpkS16(&suId, mBuf) != ROK)
 817    {
 818       SPutMsg(mBuf);
 819       RETVALUE(RFAILED);
 820    }
 821    SPutMsg(mBuf);
 822    RETVALUE((*func)(pst, suId, status));
 823 }
 824
 825 \f
 826
 827
 828 /**
 829 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC
 830 *
 831 * @details
 832 *
 833 *     Function : cmPkCfgPrbRprt
 834 *
 835 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
 836 *  @param[in]   Buffer *mBuf
 837 *  @return   S16
 838 *      -# ROK
 839 **/
 840 #ifdef ANSI
 841 PUBLIC S16 cmPkCfgPrbRprt
 842 (
 843 RgmPrbRprtCfg  * prbRprtCfg,
 844 Buffer *mBuf
 845 )
 846 #else
 847 PUBLIC S16 cmPkCfgPrbRprt(prbRprtCfg, mBuf)
 848 RgmPrbRprtCfg  * prbRprtCfg;
 849 Buffer *mBuf;
 850 #endif
 851 {
 852    TRC3(cmPkCfgPrbRprt);
 853    CMCHKPK(SPkU16, prbRprtCfg->usPrbAvgPeriodicty, mBuf);
 854    CMCHKPK(SPkU8, prbRprtCfg->bConfigType, mBuf);
 855    CMCHKPK(SPkU8, prbRprtCfg->bCellId, mBuf);
 856    RETVALUE(ROK);
 857 }
 858 /**
 859 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC
 860 *
 861 * @details
 862 *
 863 *     Function : cmUnPkCfgPrbRprt
 864 *
 865 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
 866 *  @param[in]   Buffer *mBuf
 867 *  @return   S16
 868 *      -# ROK
 869 **/
 870 #ifdef ANSI
 871 PUBLIC S16 cmUnPkCfgPrbRprt
 872 (
 873 RgmPrbRprtCfg  * prbRprtCfg,
 874 Buffer *mBuf
 875 )
 876 #else
 877 PUBLIC S16 cmUnPkCfgPrbRprt(prbRprtCfg, mBuf)
 878 RgmPrbRprtCfg  * prbRprtCfg;
 879 Buffer *mBuf;
 880 #endif
 881 {
 882    TRC3(cmUnPkCfgPrbRprt);
 883    CMCHKUNPK(SUnpkU8, &prbRprtCfg->bCellId, mBuf);
 884    CMCHKUNPK(SUnpkU8, &prbRprtCfg->bConfigType, mBuf);
 885    CMCHKUNPK(SUnpkU16, &prbRprtCfg->usPrbAvgPeriodicty, mBuf);
 886    RETVALUE(ROK);
 887 }
 888
 889
 890
 891 \f
 892 /**
 893 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC
 894 *
 895 * @details
 896 *
 897 *     Function : cmPkRgmCfgPrbRprt
 898 *
 899 *  @param[in]   Pst*  pst
 900 *  @param[in]   SpId  spId
 901 *  @param[in]   RgmPrbRprtCfg  *prbRprtCfg
 902 *  @return   S16
 903 *      -# ROK
 904 **/
 905 #ifdef ANSI
 906 PUBLIC S16 cmPkRgmCfgPrbRprt
 907 (
 908 Pst* pst,
 909 SpId spId,
 910 RgmPrbRprtCfg  * prbRprtCfg
 911 )
 912 #else
 913 PUBLIC S16 cmPkRgmCfgPrbRprt(pst, spId, prbRprtCfg)
 914 Pst* pst;
 915 SpId spId;
 916 RgmPrbRprtCfg  * prbRprtCfg;
 917 #endif
 918 {
 919    Buffer *mBuf = NULLP;
 920    U32 len = sizeof(RgmPrbRprtCfg);
 921    TRC3(cmPkRgmCfgPrbRprt)
 922
 923    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 924    {
 925       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
 926       RETVALUE(RFAILED);
 927    }
 928
 929     if(cmPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
 930     {
 931        SPutMsg(mBuf);
 932        SPutSBuf(pst->region, pst->pool, (Data*)prbRprtCfg, len);
 933        RETVALUE(RFAILED);
 934     }
 935
 936    if (SPkS16(spId, mBuf) != ROK)
 937    {
 938       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
 939       SPutMsg(mBuf);
 940       RETVALUE(RFAILED);
 941    }
 942
 943    SPutSBuf(pst->region, pst->pool, (Data *)prbRprtCfg, sizeof(RgmPrbRprtCfg));
 944
 945    pst->event = (Event) EVTRGMCFGPRBRPRT;
 946    RETVALUE(SPstTsk(pst,mBuf));
 947 }
 948
 949
 950
 951 /**
 952 * @brief Configure the PRB Report Preparation Start/Stop from RRM to MAC
 953 *
 954 * @details
 955 *
 956 *     Function : cmUnpkRgmCfgPrbRprt
 957 *
 958 *  @param[in]   Pst*  pst
 959 *  @param[in]   SpId  spId
 960 *  @param[in]   RgmPrbRprtCfg  *  prbRprtCfg
 961 *  @return   S16
 962 *      -# ROK
 963 **/
 964 #ifdef ANSI
 965 PUBLIC S16 cmUnpkRgmCfgPrbRprt
 966 (
 967 RgmCfgPrbRprtFptr func,
 968 Pst *pst,
 969 Buffer *mBuf
 970 )
 971 #else
 972 PUBLIC S16 cmUnpkRgmCfgPrbRprt(func, pst, mBuf)
 973 RgmCfgPrbRprtFptr func;
 974 Pst *pst;
 975 Buffer *mBuf;
 976 #endif
 977 {
 978    SpId spId;
 979    RgmPrbRprtCfg *prbRprtCfg;
 980
 981    TRC3(cmUnpkRgmCfgPrbRprt)
 982    if ((SGetSBuf(pst->region, pst->pool, (Data **)&prbRprtCfg, sizeof(RgmPrbRprtCfg))) != ROK)
 983       {
 984          SPutMsg(mBuf);
 985          RETVALUE(RFAILED);
 986       }
 987
 988    if (SUnpkS16(&spId, mBuf) != ROK)
 989    {
 990       SPutMsg(mBuf);
 991       RETVALUE(RFAILED);
 992    }
 993
 994    if (cmUnPkCfgPrbRprt(prbRprtCfg, mBuf) != ROK)
 995    {
 996       SPutMsg(mBuf);
 997       RETVALUE(RFAILED);
 998    }
 999
1000    SPutMsg(mBuf);
1001    RETVALUE((*func)(pst, spId, prbRprtCfg));
1002 }
1003
1004 /* RRM_SP1_START */
1005 /**
1006 * @brief Packing of PRB Usage Report for qci for sending
1007 *        to RRM from MAC
1008 *
1009 * @details
1010 *
1011 *     Function : cmPkRgmPrbQciRpt
1012 *
1013 *  @param[in]   RgmPrbRptPerQci * qciPrbRprt
1014 *  @param[out]   Buffer *mBuf
1015 *  @return   S16
1016 *      -# ROK
1017 **/
1018 #ifdef ANSI
1019 PUBLIC S16 cmPkRgmPrbQciRpt
1020 (
1021  RgmPrbRptPerQci *qciPrbRprt,
1022  Buffer *mBuf
1023  )
1024 #else
1025 PUBLIC S16 cmPkRgmPrbQciRpt(qciPrbRprt, mBuf)
1026 RgmPrbRptPerQci *qciPrbRprt;
1027 Buffer *mBuf = NULLP;
1028 #endif
1029 {
1030    CMCHKPK(SPkU8, qciPrbRprt->bQci, mBuf);
1031    CMCHKPK(SPkU8, qciPrbRprt->bAvgPrbUlUsage, mBuf);
1032    CMCHKPK(SPkU8, qciPrbRprt->bAvgPrbDlUsage, mBuf);
1033
1034    RETVALUE(ROK);
1035 }
1036
1037 /**
1038 * @brief Unpacking of PRB Usage Report for qci received from MAC
1039 *
1040 * @details
1041 *
1042 *     Function : cmUnpkRgmPrbQciRpt
1043 *
1044 *  @param[out]   RgmPrbRptPerQci * qciPrbRprt
1045 *  @param[in]   Buffer *mBuf
1046 *  @return   S16
1047 *      -# ROK
1048 **/
1049 #ifdef ANSI
1050 PUBLIC S16 cmUnpkRgmPrbQciRpt
1051 (
1052  RgmPrbRptPerQci *qciPrbRprt,
1053  Buffer *mBuf
1054  )
1055 #else
1056 PUBLIC S16 cmUnpkRgmPrbQciRpt(qciPrbRprt, mBuf)
1057 RgmPrbRptPerQci *qciPrbRprt;
1058 Buffer *mBuf = NULLP;
1059 #endif
1060 {
1061    CMCHKUNPK(SUnpkU8, &qciPrbRprt->bAvgPrbDlUsage, mBuf);
1062    CMCHKUNPK(SUnpkU8, &qciPrbRprt->bAvgPrbUlUsage, mBuf);
1063    CMCHKUNPK(SUnpkU8, &qciPrbRprt->bQci, mBuf);
1064
1065    RETVALUE(ROK);
1066 }
1067 /* RRM_SP1_END */
1068
1069 /**
1070 * @brief PRB Usage Report Indication  from MAC to RRM
1071 *
1072 * @details
1073 *
1074 *     Function : cmPkPrbRprtInd
1075 *
1076 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1077 *  @param[in]   Buffer *mBuf
1078 *  @return   S16
1079 *      -# ROK
1080 **/
1081 #ifdef ANSI
1082 PUBLIC S16 cmPkPrbRprtInd
1083 (
1084  RgmPrbRprtInd  * prbRprtInd,
1085  Buffer *mBuf
1086  )
1087 #else
1088 PUBLIC S16 cmPkPrbRprtInd(prbRprtInd, mBuf)
1089    RgmPrbRprtInd  * prbRprtInd;
1090    Buffer *mBuf = NULLP;
1091 #endif
1092 {
1093    S32 idx = 0;
1094
1095    TRC3(cmPkPrbRprtInd);
1096
1097    /* RRM_SP1_START */
1098    for(idx = RGM_MAX_QCI_REPORTS-1; idx >= 0; idx--)
1099    {
1100       CMCHKPK(cmPkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
1101    }
1102    CMCHKPK(SPkU8, prbRprtInd->bPrbUsageMask, mBuf);
1103    CMCHKPK(SPkU8, prbRprtInd->bCellId, mBuf);
1104    /* RRM_SP1_END */
1105    RETVALUE(ROK);
1106 }
1107
1108 /**
1109 * @brief PRB Usage Report Indication  from MAC to RRM
1110 *
1111 * @details
1112 *
1113 *     Function : cmUnpkPrbRprtInd
1114 *
1115 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1116 *  @param[in]   Buffer *mBuf
1117 *  @return   S16
1118 *      -# ROK
1119 **/
1120 #ifdef ANSI
1121 PUBLIC S16 cmUnpkPrbRprtInd
1122 (
1123  RgmPrbRprtInd  * prbRprtInd,
1124  Buffer *mBuf
1125  )
1126 #else
1127 PUBLIC S16 cmUnpkPrbRprtInd(prbRprtInd, mBuf)
1128    RgmPrbRprtInd  * prbRprtInd;
1129    Buffer *mBuf;
1130 #endif
1131 {
1132    U32 idx = 0;
1133
1134    TRC3(cmUnpkPrbRprtInd);
1135
1136    /* RRM_SP1_START */
1137    CMCHKUNPK(SUnpkU8, &prbRprtInd->bCellId, mBuf);
1138    CMCHKUNPK(SUnpkU8, &prbRprtInd->bPrbUsageMask, mBuf);
1139    for(idx = 0; idx < RGM_MAX_QCI_REPORTS; idx++)
1140    {
1141       CMCHKUNPK(cmUnpkRgmPrbQciRpt, &prbRprtInd->stQciPrbRpts[idx], mBuf);
1142    }
1143
1144    /* RRM_SP1_END */
1145    RETVALUE(ROK);
1146 }
1147
1148
1149
1150 /**
1151 * @brief PRB Usage Report Indication  from MAC to RRM
1152 *
1153 * @details
1154 *
1155 *     Function : cmPkRgmPrbRprtInd
1156 *
1157 *  @param[in]   Pst*  pst
1158 *  @param[in]   SuId  suId
1159 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1160 *  @return   S16
1161 *      -# ROK
1162 **/
1163 #ifdef ANSI
1164 PUBLIC S16 cmPkRgmPrbRprtInd
1165 (
1166 Pst* pst,
1167 SuId suId,
1168 RgmPrbRprtInd  * prbRprtInd
1169 )
1170 #else
1171 PUBLIC S16 cmPkRgmPrbRprtInd(pst, suId, prbRprtInd)
1172 Pst* pst;
1173 SuId suId;
1174 RgmPrbRprtInd  * prbRprtInd;
1175 #endif
1176 {
1177    Buffer *mBuf = NULLP;
1178
1179    TRC3(cmPkRgmPrbRprtInd)
1180
1181    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1182       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1183       RETVALUE(RFAILED);
1184    }
1185
1186    if(cmPkPrbRprtInd(prbRprtInd, mBuf) != ROK)
1187    {
1188       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1189       SPutMsg(mBuf);
1190       RETVALUE(RFAILED);
1191    }
1192
1193    if (SPkS16(suId, mBuf) != ROK)
1194    {
1195       SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1196       SPutMsg(mBuf);
1197       RETVALUE(RFAILED);
1198    }
1199
1200    SPutSBuf(pst->region, pst->pool, (Data *)prbRprtInd, sizeof(RgmPrbRprtInd));
1201
1202    pst->event = (Event) EVTRGMPRBRPRTIND;
1203    RETVALUE(SPstTsk(pst,mBuf));
1204 }
1205 /**
1206 * @brief PRB Usage Report Indication from MAC to RRM
1207 *
1208 * @details
1209 *
1210 *     Function : cmUnpkRgmPrbRprtInd
1211 *
1212 *  @param[in]   Pst*  pst
1213 *  @param[in]   SuId  suId
1214 *  @param[in]   RgmPrbRprtInd  *  prbRprtInd
1215 *  @return   S16
1216 *      -# ROK
1217 **/
1218 #ifdef ANSI
1219 PUBLIC S16 cmUnpkRgmPrbRprtInd
1220 (
1221 RgmPrbRprtIndFptr func,
1222 Pst *pst,
1223 Buffer *mBuf
1224 )
1225 #else
1226 PUBLIC S16 cmUnpkRgmPrbRprtInd(func, pst, mBuf)
1227 RgmPrbRprtIndFptr func;
1228 Pst *pst;
1229 Buffer *mBuf;
1230 #endif
1231 {
1232    SuId suId;
1233    RgmPrbRprtInd prbRprtInd;
1234
1235    TRC3(cmUnpkRgmPrbRprtInd)
1236
1237    if (SUnpkS16(&suId, mBuf) != ROK)
1238    {
1239       SPutMsg(mBuf);
1240       RETVALUE(RFAILED);
1241    }
1242
1243    if (cmUnpkPrbRprtInd(&prbRprtInd, mBuf) != ROK)
1244    {
1245       SPutMsg(mBuf);
1246       RETVALUE(RFAILED);
1247    }
1248
1249    SPutMsg(mBuf);
1250    RETVALUE((*func)(pst, suId, &prbRprtInd));
1251 }
1252
1253 /**
1254 * @brief Transmission Mode Change Indication  from MAC to RRM
1255 *
1256 * @details
1257 *
1258 *     Function : cmPkTransModeInd
1259 *
1260 *  @param[in]   RgmTransModeInd *transModeInd
1261 *  @param[in]   Buffer *mBuf
1262 *  @return   S16
1263 *      -# ROK
1264 **/
1265 #ifdef ANSI
1266 PUBLIC S16 cmPkTransModeInd
1267 (
1268  RgmTransModeInd *transModeInd,
1269  Buffer *mBuf
1270  )
1271 #else
1272 PUBLIC S16 cmPkTransModeInd(transModeInd, mBuf)
1273    RgmTransModeInd *transModeInd;
1274    Buffer *mBuf;
1275 #endif
1276 {
1277    TRC3(cmPkTransModeInd);
1278    CMCHKPK(SPkU32, transModeInd->eMode, mBuf);
1279    CMCHKPK(SPkU16, transModeInd->usCrnti, mBuf);
1280    CMCHKPK(SPkU8, transModeInd->bCellId, mBuf);
1281    RETVALUE(ROK);
1282 }
1283
1284 /**
1285 * @brief  Transmission Mode Change Indication from MAC to RRM
1286 *
1287 * @details
1288 *
1289 *     Function : cmUnpkTransModeInd
1290 *
1291 *  @param[in]   RgmTransModeInd *transModeInd
1292 *  @param[in]   Buffer *mBuf
1293 *  @return   S16
1294 *      -# ROK
1295 **/
1296 #ifdef ANSI
1297 PUBLIC S16 cmUnpkTransModeInd
1298 (
1299  RgmTransModeInd *transModeInd,
1300  Buffer *mBuf
1301  )
1302 #else
1303 PUBLIC S16 cmUnpkTransModeInd(transModeInd, mBuf)
1304    RgmTransModeInd *transModeInd;
1305    Buffer *mBuf;
1306 #endif
1307 {
1308    U32 tmpModeEnum;
1309    TRC3(cmUnpkTransModeInd);
1310    CMCHKUNPK(SUnpkU8, &transModeInd->bCellId, mBuf);
1311    CMCHKUNPK(SUnpkU16, &transModeInd->usCrnti, mBuf);
1312    CMCHKUNPK(SUnpkU32, (U32 *)&tmpModeEnum, mBuf);
1313    transModeInd->eMode = (RgmTxnMode)tmpModeEnum;
1314    RETVALUE(ROK);
1315 }
1316 /**
1317 * @brief Transmission Mode Change Indication  from MAC to RRM
1318 *
1319 * @details
1320 *
1321 *     Function : cmPkRgmTransModeInd
1322 *
1323 *  @param[in]   Pst*  pst
1324 *  @param[in]   SuId  suId
1325 *  @param[in]   RgmTransModeInd *transModeInd
1326 *  @return   S16
1327 *      -# ROK
1328 **/
1329 #ifdef ANSI
1330 PUBLIC S16 cmPkRgmTransModeInd
1331 (
1332 Pst* pst,
1333 SuId suId,
1334 RgmTransModeInd *transModeInd
1335 )
1336 #else
1337 PUBLIC S16 cmPkRgmTransModeInd(pst, suId, transModeInd)
1338 Pst* pst;
1339 SuId suId;
1340 RgmTransModeInd *transModeInd;
1341 #endif
1342 {
1343    Buffer *mBuf = NULLP;
1344
1345    TRC3(cmPkRgmTransModeInd)
1346
1347    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1348       SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1349       RETVALUE(RFAILED);
1350    }
1351
1352    if(cmPkTransModeInd(transModeInd, mBuf) != ROK)
1353    {
1354       SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1355       SPutMsg(mBuf);
1356       RETVALUE(RFAILED);
1357    }
1358
1359    if (SPkS16(suId, mBuf) != ROK)
1360    {
1361       SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1362       SPutMsg(mBuf);
1363       RETVALUE(RFAILED);
1364    }
1365
1366    SPutSBuf(pst->region, pst->pool, (Data *)transModeInd, sizeof(RgmTransModeInd));
1367
1368    pst->event = (Event) EVTRGMTRANSMODEIND;
1369    RETVALUE(SPstTsk(pst,mBuf));
1370 }
1371 /**
1372 * @brief Transmission Mode Change Indication  from MAC to RRM
1373 *
1374 * @details
1375 *
1376 *     Function : cmUnpkRgmTransModeInd
1377 *
1378 *  @param[in]   Pst*  pst
1379 *  @param[in]   SuId  suId
1380 *  @param[in]   RgmTransModeInd *transModeInd
1381 *  @return   S16
1382 *      -# ROK
1383 **/
1384 #ifdef ANSI
1385 PUBLIC S16 cmUnpkRgmTransModeInd
1386 (
1387 RgmTransModeIndFptr func,
1388 Pst *pst,
1389 Buffer *mBuf
1390 )
1391 #else
1392 PUBLIC S16 cmUnpkRgmTransModeInd(func, pst, mBuf)
1393 RgmTransModeIndFptr func;
1394 Pst *pst;
1395 Buffer *mBuf;
1396 #endif
1397 {
1398    SuId suId;
1399    RgmTransModeInd transModeInd;
1400
1401    TRC3(cmUnpkRgmTransModeInd)
1402
1403    if (SUnpkS16(&suId, mBuf) != ROK)
1404    {
1405       SPutMsg(mBuf);
1406       RETVALUE(RFAILED);
1407    }
1408
1409    if (cmUnpkTransModeInd(&transModeInd, mBuf) != ROK)
1410    {
1411       SPutMsg(mBuf);
1412       RETVALUE(RFAILED);
1413    }
1414
1415    SPutMsg(mBuf);
1416    RETVALUE((*func)(pst, suId, &transModeInd));
1417 }
1418 /**********************************************************************
1419
1420          End of file
1421
1422 **********************************************************************/