src/cm/rgu.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
  19 /************************************************************************
  20
  21      Name:     LTE-MAC layer
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for packing/unpacking of RGU interface
  26                primitives.
  27
  28      File:     rgu.c
  29
  30 **********************************************************************/
  31
  32 /** @file rgu.c
  33 @brief This file contains the packing/unpacking code for the RGU interface
  34        primitives.
  35 */
  36
  37 /* header include files (.h) */
  38 #include "envopt.h"        /* environment options */
  39 #include "envdep.h"        /* environment dependent */
  40 #include "envind.h"        /* environment independent */
  41 #include "gen.h"           /* general */
  42 #include "ssi.h"           /* system services */
  43 #include "cm_tkns.h"       /* Common Token Defines */
  44 #include "cm_llist.h"      /* Common Link List Defines */
  45 #include "cm_hash.h"       /* Common Hash List Defines */
  46 #include "cm_lte.h"        /* Common LTE Defines */
  47 #include "rgu.h"           /* RGU Interface defines */
  48
  49 /* header/extern include files (.x) */
  50 #include "gen.x"           /* general */
  51 #include "ssi.x"           /* system services */
  52 #include "cm_tkns.x"       /* Common Token Definitions */
  53 #include "cm_llist.x"      /* Common Link List Definitions */
  54 #include "cm_lib.x"        /* Common Library Definitions */
  55 #include "cm_hash.x"       /* Common Hash List Definitions */
  56 #include "cm_lte.x"        /* Common LTE Defines */
  57 #include "rgu.x"           /* RGU Interface includes */
  58
  59 #ifdef SS_RBUF
  60 #include "ss_rbuf.h"
  61 #include "ss_rbuf.x"
  62 #endif
  63
  64 #ifdef LCRGU
  65
  66 \f
  67 /**
  68 * @brief Request from RLC to MAC to bind the interface saps
  69 *
  70 * @details
  71 *
  72 *     Function : cmPkRguBndReq
  73 *
  74 *  @param[in]   Pst*  pst
  75 *  @param[in]   SuId  suId
  76 *  @param[in]   SpId  spId
  77 *  @return   S16
  78 *      -# ROK
  79 **/
  80 #ifdef ANSI
  81 PUBLIC S16 cmPkRguBndReq
  82 (
  83 Pst* pst,
  84 SuId suId,
  85 SpId spId
  86 )
  87 #else
  88 PUBLIC S16 cmPkRguBndReq(pst, suId, spId)
  89 Pst* pst;
  90 SuId suId;
  91 SpId spId;
  92 #endif
  93 {
  94    Buffer *mBuf = NULLP;
  95    TRC3(cmPkRguBndReq)
  96
  97    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
  98 #if (ERRCLASS & ERRCLS_ADD_RES)
  99       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 100           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 101           (ErrVal)ERGU001, (ErrVal)0, "Packing failed");
 102 #endif
 103       RETVALUE(RFAILED);
 104    }
 105    if (SPkS16(spId, mBuf) != ROK) {
 106 #if (ERRCLASS & ERRCLS_ADD_RES)
 107       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 108           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 109           (ErrVal)ERGU002, (ErrVal)0, "Packing failed");
 110 #endif
 111       SPutMsg(mBuf);
 112       RETVALUE(RFAILED);
 113    }
 114    if (SPkS16(suId, mBuf) != ROK) {
 115 #if (ERRCLASS & ERRCLS_ADD_RES)
 116       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 117           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 118           (ErrVal)ERGU003, (ErrVal)0, "Packing failed");
 119 #endif
 120       SPutMsg(mBuf);
 121       RETVALUE(RFAILED);
 122    }
 123    pst->event = (Event) EVTRGUBNDREQ;
 124    RETVALUE(SPstTsk(pst,mBuf));
 125 }
 126
 127 \f
 128 /**
 129 * @brief Request from RLC to MAC to bind the interface saps
 130 *
 131 * @details
 132 *
 133 *     Function : cmUnpkRguBndReq
 134 *
 135 *  @param[in]   Pst*  pst
 136 *  @param[in]   SuId  suId
 137 *  @param[in]   SpId  spId
 138 *  @return   S16
 139 *      -# ROK
 140 **/
 141 #ifdef ANSI
 142 PUBLIC S16 cmUnpkRguBndReq
 143 (
 144 RguBndReq func,
 145 Pst *pst,
 146 Buffer *mBuf
 147 )
 148 #else
 149 PUBLIC S16 cmUnpkRguBndReq(func, pst, mBuf)
 150 RguBndReq func;
 151 Pst *pst;
 152 Buffer *mBuf;
 153 #endif
 154 {
 155    SuId suId;
 156    SpId spId;
 157
 158    TRC3(cmUnpkRguBndReq)
 159
 160    if (SUnpkS16(&suId, mBuf) != ROK) {
 161 #if (ERRCLASS & ERRCLS_ADD_RES)
 162       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 163           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 164           (ErrVal)ERGU004, (ErrVal)0, "UnPacking failed");
 165 #endif
 166       SPutMsg(mBuf);
 167       RETVALUE(RFAILED);
 168    }
 169    if (SUnpkS16(&spId, mBuf) != ROK) {
 170 #if (ERRCLASS & ERRCLS_ADD_RES)
 171       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 172           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 173           (ErrVal)ERGU005, (ErrVal)0, "UnPacking failed");
 174 #endif
 175       SPutMsg(mBuf);
 176       RETVALUE(RFAILED);
 177    }
 178    SPutMsg(mBuf);
 179    RETVALUE((*func)(pst, suId, spId));
 180 }
 181
 182 \f
 183 /**
 184 * @brief Request from RLC to MAC to Unbind the interface saps
 185 *
 186 * @details
 187 *
 188 *     Function : cmPkRguUbndReq
 189 *
 190 *  @param[in]   Pst*  pst
 191 *  @param[in]   SpId  spId
 192 *  @param[in]   Reason  reason
 193 *  @return   S16
 194 *      -# ROK
 195 **/
 196 #ifdef ANSI
 197 PUBLIC S16 cmPkRguUbndReq
 198 (
 199 Pst* pst,
 200 SpId spId,
 201 Reason reason
 202 )
 203 #else
 204 PUBLIC S16 cmPkRguUbndReq(pst, spId, reason)
 205 Pst* pst;
 206 SpId spId;
 207 Reason reason;
 208 #endif
 209 {
 210    Buffer *mBuf = NULLP;
 211    TRC3(cmPkRguUbndReq)
 212
 213    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 214 #if (ERRCLASS & ERRCLS_ADD_RES)
 215       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 216           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 217           (ErrVal)ERGU006, (ErrVal)0, "Packing failed");
 218 #endif
 219       RETVALUE(RFAILED);
 220    }
 221    if (SPkS16(reason, mBuf) != ROK) {
 222 #if (ERRCLASS & ERRCLS_ADD_RES)
 223       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 224           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 225           (ErrVal)ERGU007, (ErrVal)0, "Packing failed");
 226 #endif
 227       SPutMsg(mBuf);
 228       RETVALUE(RFAILED);
 229    }
 230    if (SPkS16(spId, mBuf) != ROK) {
 231 #if (ERRCLASS & ERRCLS_ADD_RES)
 232       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 233           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 234           (ErrVal)ERGU008, (ErrVal)0, "Packing failed");
 235 #endif
 236       SPutMsg(mBuf);
 237       RETVALUE(RFAILED);
 238    }
 239    pst->event = (Event) EVTRGUUBNDREQ;
 240    RETVALUE(SPstTsk(pst,mBuf));
 241 }
 242
 243 \f
 244 /**
 245 * @brief Request from RLC to MAC to Unbind the interface saps
 246 *
 247 * @details
 248 *
 249 *     Function : cmUnpkRguUbndReq
 250 *
 251 *  @param[in]   Pst*  pst
 252 *  @param[in]   SpId  spId
 253 *  @param[in]   Reason  reason
 254 *  @return   S16
 255 *      -# ROK
 256 **/
 257 #ifdef ANSI
 258 PUBLIC S16 cmUnpkRguUbndReq
 259 (
 260 RguUbndReq func,
 261 Pst *pst,
 262 Buffer *mBuf
 263 )
 264 #else
 265 PUBLIC S16 cmUnpkRguUbndReq(func, pst, mBuf)
 266 RguUbndReq func;
 267 Pst *pst;
 268 Buffer *mBuf;
 269 #endif
 270 {
 271    SpId spId;
 272    Reason reason;
 273
 274    TRC3(cmUnpkRguUbndReq)
 275
 276    if (SUnpkS16(&spId, mBuf) != ROK) {
 277 #if (ERRCLASS & ERRCLS_ADD_RES)
 278       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 279           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 280           (ErrVal)ERGU009, (ErrVal)0, "UnPacking failed");
 281 #endif
 282       SPutMsg(mBuf);
 283       RETVALUE(RFAILED);
 284    }
 285    if (SUnpkS16(&reason, mBuf) != ROK) {
 286 #if (ERRCLASS & ERRCLS_ADD_RES)
 287       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 288           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 289           (ErrVal)ERGU010, (ErrVal)0, "UnPacking failed");
 290 #endif
 291       SPutMsg(mBuf);
 292       RETVALUE(RFAILED);
 293    }
 294    SPutMsg(mBuf);
 295    RETVALUE((*func)(pst, spId, reason));
 296 }
 297
 298 \f
 299 /**
 300 * @brief Confirmation from MAC to RLC for the bind/Unbind
 301  * request for the interface saps
 302 *
 303 * @details
 304 *
 305 *     Function : cmPkRguBndCfm
 306 *
 307 *  @param[in]   Pst*  pst
 308 *  @param[in]   SuId  suId
 309 *  @param[in]   U8  status
 310 *  @return   S16
 311 *      -# ROK
 312 **/
 313 #ifdef ANSI
 314 PUBLIC S16 cmPkRguBndCfm
 315 (
 316 Pst* pst,
 317 SuId suId,
 318 U8 status
 319 )
 320 #else
 321 PUBLIC S16 cmPkRguBndCfm(pst, suId, status)
 322 Pst* pst;
 323 SuId suId;
 324 U8 status;
 325 #endif
 326 {
 327    Buffer *mBuf = NULLP;
 328    TRC3(cmPkRguBndCfm)
 329
 330    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 331 #if (ERRCLASS & ERRCLS_ADD_RES)
 332       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 333           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 334           (ErrVal)ERGU011, (ErrVal)0, "Packing failed");
 335 #endif
 336       RETVALUE(RFAILED);
 337    }
 338    if (SPkU8(status, mBuf) != ROK) {
 339 #if (ERRCLASS & ERRCLS_ADD_RES)
 340       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 341           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 342           (ErrVal)ERGU012, (ErrVal)0, "Packing failed");
 343 #endif
 344       SPutMsg(mBuf);
 345       RETVALUE(RFAILED);
 346    }
 347    if (SPkS16(suId, mBuf) != ROK) {
 348 #if (ERRCLASS & ERRCLS_ADD_RES)
 349       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 350           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 351           (ErrVal)ERGU013, (ErrVal)0, "Packing failed");
 352 #endif
 353       SPutMsg(mBuf);
 354       RETVALUE(RFAILED);
 355    }
 356    pst->event = (Event) EVTRGUBNDCFM;
 357    RETVALUE(SPstTsk(pst,mBuf));
 358 }
 359
 360 \f
 361 /**
 362 * @brief Confirmation from MAC to RLC for the bind/Unbind
 363  * request for the interface saps
 364 *
 365 * @details
 366 *
 367 *     Function : cmUnpkRguBndCfm
 368 *
 369 *  @param[in]   Pst*  pst
 370 *  @param[in]   SuId  suId
 371 *  @param[in]   U8  status
 372 *  @return   S16
 373 *      -# ROK
 374 **/
 375 #ifdef ANSI
 376 PUBLIC S16 cmUnpkRguBndCfm
 377 (
 378 RguBndCfm func,
 379 Pst *pst,
 380 Buffer *mBuf
 381 )
 382 #else
 383 PUBLIC S16 cmUnpkRguBndCfm(func, pst, mBuf)
 384 RguBndCfm func;
 385 Pst *pst;
 386 Buffer *mBuf;
 387 #endif
 388 {
 389    SuId suId;
 390    U8 status;
 391
 392    TRC3(cmUnpkRguBndCfm)
 393
 394    if (SUnpkS16(&suId, mBuf) != ROK) {
 395 #if (ERRCLASS & ERRCLS_ADD_RES)
 396       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 397           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 398           (ErrVal)ERGU014, (ErrVal)0, "UnPacking failed");
 399 #endif
 400       SPutMsg(mBuf);
 401       RETVALUE(RFAILED);
 402    }
 403    if (SUnpkU8(&status, mBuf) != ROK) {
 404 #if (ERRCLASS & ERRCLS_ADD_RES)
 405       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 406           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 407           (ErrVal)ERGU015, (ErrVal)0, "UnPacking failed");
 408 #endif
 409       SPutMsg(mBuf);
 410       RETVALUE(RFAILED);
 411    }
 412    SPutMsg(mBuf);
 413    RETVALUE((*func)(pst, suId, status));
 414 }
 415
 416 \f
 417 /**
 418 * @brief Request from RLC to MAC for forwarding SDUs on
 419  * dedicated channel for transmission
 420 *
 421 * @details
 422 *
 423 *     Function : packDlData
 424 *
 425 *  @param[in]   Pst*  pst
 426 *  @param[in]   SpId  spId
 427 *  @param[in]   RguDDatReqInfo  *  datReq
 428 *  @return   S16
 429 *      -# ROK
 430 **/
 431 #ifdef ANSI
 432 PUBLIC S16 packDlData
 433 (
 434 Pst* pst,
 435 SpId spId,
 436 RlcMacData  *dlData
 437 )
 438 #else
 439 PUBLIC S16 packDlData(pst, spId, dlData)
 440 Pst* pst;
 441 SpId spId;
 442 RlcMacData  dlData;
 443 #endif
 444 {
 445    Buffer *mBuf = NULLP;
 446    TRC3(packDlData)
 447
 448    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 449 #if (ERRCLASS & ERRCLS_ADD_RES)
 450       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 451           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 452           (ErrVal)ERGU022, (ErrVal)0, "Packing failed");
 453 #endif
 454       SPutSBuf(pst->region, pst->pool, (Data *)dlData, sizeof(RlcMacData));
 455       RETVALUE(RFAILED);
 456    }
 457
 458    if (pst->selector == RGU_SEL_LWLC)
 459    {
 460       CMCHKPK(cmPkPtr,(PTR) dlData, mBuf);
 461    }
 462    else
 463    {
 464       /*rgu_c_001.main_5 - ADD - L2M Support */
 465 #ifdef LTE_L2_MEAS
 466       if (packRlcMacDataInfo(pst, dlData, mBuf) != ROK)
 467 #else
 468       if (packRlcMacDataInfo(dlData, mBuf) != ROK)
 469 #endif
 470       {
 471 #if (ERRCLASS & ERRCLS_ADD_RES)
 472          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 473           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 474           (ErrVal)ERGU023, (ErrVal)0, "Packing failed");
 475 #endif
 476          SPutSBuf(pst->region, pst->pool, (Data *)dlData,
 477                                        sizeof(RlcMacData));
 478          SPutMsg(mBuf);
 479          RETVALUE(RFAILED);
 480       }
 481
 482       if (SPutSBuf(pst->region, pst->pool,
 483                    (Data *)dlData, sizeof(RlcMacData)) != ROK) {
 484 #if (ERRCLASS & ERRCLS_ADD_RES)
 485          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 486               __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 487              (ErrVal)ERGU025, (ErrVal)0, "Packing failed");
 488 #endif
 489          SPutMsg(mBuf);
 490          RETVALUE(RFAILED);
 491       }
 492       dlData = NULLP;
 493    }
 494    if (SPkS16(spId, mBuf) != ROK) {
 495 #if (ERRCLASS & ERRCLS_ADD_RES)
 496       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 497           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 498           (ErrVal)ERGU024, (ErrVal)0, "Packing failed");
 499 #endif
 500       if (dlData != NULLP);
 501       {
 502          SPutSBuf(pst->region, pst->pool,
 503                   (Data *)dlData, sizeof(RlcMacData));
 504       }
 505       SPutMsg(mBuf);
 506       RETVALUE(RFAILED);
 507    }
 508    pst->event = (Event) EVTRLCDLDAT;
 509    RETVALUE(SPstTsk(pst,mBuf));
 510 }
 511
 512 \f
 513 /**
 514 * @brief Request from RLC to MAC for forwarding SDUs on
 515  * dedicated channel for transmission
 516 *
 517 * @details
 518 *
 519 *     Function : unpackDlData
 520 *
 521 *  @param[in]   Pst*  pst
 522 *  @param[in]   SpId  spId
 523 *  @param[in]   RguDDatReqInfo  *  datReq
 524 *  @return   S16
 525 *      -# ROK
 526 **/
 527 #ifdef ANSI
 528 PUBLIC S16 unpackDlData
 529 (
 530 RguDDatReq func,
 531 Pst *pst,
 532 Buffer *mBuf
 533 )
 534 #else
 535 PUBLIC S16 unpackDlData(func, pst, mBuf)
 536 RguDDatReq func;
 537 Pst *pst;
 538 Buffer *mBuf;
 539 #endif
 540 {
 541    SpId spId;
 542 //   RguDDatReqInfo *datReq;
 543    RlcMacData *dlData;
 544
 545    TRC3(unpackDlData)
 546
 547    if (SUnpkS16(&spId, mBuf) != ROK) {
 548       SPutMsg(mBuf);
 549       RETVALUE(RFAILED);
 550    }
 551
 552    if (pst->selector == RGU_SEL_LWLC)
 553    {
 554       CMCHKUNPK(cmUnpkPtr,(PTR *) &dlData, mBuf);
 555    }
 556    else
 557    {
 558       if ((SGetSBuf(pst->region, pst->pool,
 559                      (Data **)&dlData, sizeof(RlcMacData))) != ROK) {
 560 #if (ERRCLASS & ERRCLS_ADD_RES)
 561          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 562              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 563              (ErrVal)ERGU026, (ErrVal)0, "UnPacking failed");
 564 #endif
 565          SPutMsg(mBuf);
 566          RETVALUE(RFAILED);
 567       }
 568       cmMemset((U8*)dlData, (U8)0, sizeof(RlcMacData));
 569   /*rgu_c_001.main_5 - ADD - L2M Support */
 570 #ifdef LTE_L2_MEAS
 571       if (unpackRlcMacDataInfo(pst,dlData, mBuf) != ROK)
 572 #else
 573       if (unpackRlcMacDataInfo(dlData, mBuf) != ROK)
 574 #endif
 575       {
 576 #if (ERRCLASS & ERRCLS_ADD_RES)
 577          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 578              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 579              (ErrVal)ERGU027, (ErrVal)0, "UnPacking failed");
 580 #endif
 581          SPutMsg(mBuf);
 582          SPutSBuf(pst->region, pst->pool, (Data *)dlData,
 583                                      sizeof(RlcMacData));
 584          RETVALUE(RFAILED);
 585       }
 586    }
 587    SPutMsg(mBuf);
 588
 589    /* TODO : change function call to send RlcMacData as below: */
 590    RETVALUE((*func)(pst, spId, dlData));
 591
 592    //RETVALUE((*func)(pst, spId, datReq));
 593 }
 594
 595 \f
 596 /**
 597 * @brief Data Indication from MAC to RLC to
 598  * forward the data received for dedicated channels
 599 *
 600 * @details
 601 *
 602 *     Function : packRcvdUlData
 603 *
 604 *  @param[in]   Pst*  pst
 605 *  @param[in]   SuId  suId
 606 *  @param[in]   RlcMacData *ulData
 607 *  @return   S16
 608 *      -# ROK
 609 **/
 610 #ifdef ANSI
 611 PUBLIC S16 packRcvdUlData
 612 (
 613 Pst* pst,
 614 SuId suId,
 615 RlcMacData  *ulData
 616 )
 617 #else
 618 PUBLIC S16 packRcvdUlData(pst, suId, ulData)
 619 Pst* pst;
 620 SuId suId;
 621 RlcMacData  *ulData;
 622 #endif
 623 {
 624    Buffer *mBuf = NULLP;
 625    TRC3(packRcvdUlData)
 626
 627    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 628 #if (ERRCLASS & ERRCLS_ADD_RES)
 629       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 630           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 631           (ErrVal)ERGU035, (ErrVal)0, "Packing failed");
 632 #endif
 633       SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
 634       RETVALUE(RFAILED);
 635    }
 636
 637    if (pst->selector == RGU_SEL_LWLC)
 638    {
 639       CMCHKPK(cmPkPtr,(PTR)ulData, mBuf);
 640    }
 641    else
 642    {
 643       if (packRlcMacDataInfo(ulData, mBuf) != ROK) {
 644 #if (ERRCLASS & ERRCLS_ADD_RES)
 645             SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 646                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 647                 (ErrVal)ERGU036, (ErrVal)0, "Packing failed");
 648 #endif
 649          SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
 650          SPutMsg(mBuf);
 651          RETVALUE(RFAILED);
 652       }
 653
 654       if (SPutStaticBuffer(pst->region, pst->pool,
 655                       (Data *)ulData, sizeof(RlcMacData),0) != ROK) {
 656 #if (ERRCLASS & ERRCLS_ADD_RES)
 657          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 658              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 659              (ErrVal)ERGU038, (ErrVal)0, "Packing failed");
 660 #endif
 661          SPutMsg(mBuf);
 662          RETVALUE(RFAILED);
 663       }
 664       ulData = NULLP;
 665    }
 666    if (SPkS16(suId, mBuf) != ROK) {
 667 #if (ERRCLASS & ERRCLS_ADD_RES)
 668       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 669           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 670           (ErrVal)ERGU037, (ErrVal)0, "Packing failed");
 671 #endif
 672       SPutStaticBuffer(pst->region, pst->pool, (Data *)ulData, sizeof(RlcMacData),0);
 673       SPutMsg(mBuf);
 674       RETVALUE(RFAILED);
 675    }
 676
 677    pst->event = (Event) EVTRLCULDAT;
 678    RETVALUE(SPstTsk(pst,mBuf));
 679 }
 680
 681 \f
 682 /**
 683 * @brief Data Indication from MAC to RLC to
 684  * forward the data received for dedicated channels
 685 *
 686 * @details
 687 *
 688 *     Function : unpackRcvdUlData
 689 *
 690 *  @param[in]   Pst*  pst
 691 *  @param[in]   SuId  suId
 692 *  @param[in]   RlcMacData  *ulData
 693 *  @return   S16
 694 *      -# ROK
 695 **/
 696 #ifdef ANSI
 697 PUBLIC S16 unpackRcvdUlData
 698 (
 699 RguDDatInd func,
 700 Pst *pst,
 701 Buffer *mBuf
 702 )
 703 #else
 704 PUBLIC S16 unpackRcvdUlData(func, pst, mBuf)
 705 RguDDatInd func;
 706 Pst *pst;
 707 Buffer *mBuf;
 708 #endif
 709 {
 710    SuId suId;
 711    RlcMacData *ulData;
 712
 713    TRC3(unpackRcvdUlData)
 714
 715    if (SUnpkS16(&suId, mBuf) != ROK) {
 716 #if (ERRCLASS & ERRCLS_ADD_RES)
 717       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 718           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 719           (ErrVal)ERGU039, (ErrVal)0, "UnPacking failed");
 720 #endif
 721       SPutMsg(mBuf);
 722       RETVALUE(RFAILED);
 723    }
 724
 725    if (pst->selector == RGU_SEL_LWLC)
 726    {
 727       CMCHKUNPK(cmUnpkPtr,(PTR *) &ulData, mBuf);
 728    }
 729    else
 730    {
 731        if ((SGetStaticBuffer(pst->region, pst->pool,
 732                     (Data **)&ulData, sizeof(RlcMacData),0)) != ROK) {
 733 #if (ERRCLASS & ERRCLS_ADD_RES)
 734          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 735              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 736              (ErrVal)ERGU040, (ErrVal)0, "UnPacking failed");
 737 #endif
 738          SPutMsg(mBuf);
 739          RETVALUE(RFAILED);
 740       }
 741       if (unpackRlcMacDataInfo(ulData, mBuf) != ROK) {
 742 #if (ERRCLASS & ERRCLS_ADD_RES)
 743          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 744              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 745              (ErrVal)ERGU041, (ErrVal)0, "UnPacking failed");
 746 #endif
 747          SPutMsg(mBuf);
 748          SPutStaticBuffer(pst->region, pst->pool,
 749                     (Data *)ulData, sizeof(RlcMacData),0);
 750          RETVALUE(RFAILED);
 751       }
 752    }
 753    SPutMsg(mBuf);
 754    RETVALUE((*func)(pst, suId, ulData));
 755 }
 756
 757
 758 /*rgu_c_001.main_5 - ADD - L2M & R9 Support */
 759 #ifdef LTE_L2_MEAS
 760
 761 /***********************************************************
 762 *
 763 *     Func :cmPkRguL2MUlThrpMeasReqInfo
 764 *
 765 *
 766 * Status Response from RLC to MAC on UL dedicated logical channel for Uplink
 767 * Scheduled throughput measurement
 768 *
 769 *
 770 *     Ret  : S16
 771 *
 772 *     Notes:
 773 *
 774 *     File  :
 775 *
 776 **********************************************************/
 777 #ifdef ANSI
 778 PUBLIC S16 cmPkRguL2MUlThrpMeasReqInfo
 779 (
 780 RguL2MUlThrpMeasReqInfo* param,
 781 Buffer *mBuf
 782 )
 783 #else
 784 PUBLIC S16 cmPkRguL2MUlThrpMeasReqInfo(param, mBuf)
 785 RguL2MUlThrpMeasReqInfo* param;
 786 Buffer *mBuf;
 787 #endif
 788 {
 789    S32 loop;
 790    TRC3(cmPkRguL2MUlThrpMeasReqInfo);
 791
 792    CMCHKPK(SPkU8, param->enbMeas, mBuf);
 793    for (loop=param->numLcId-1; loop >= 0; loop--)
 794    {
 795       CMCHKPK(SPkU8, param->lcId[loop], mBuf);
 796    }
 797    CMCHKPK(cmPkLteLcId, param->numLcId, mBuf);
 798    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
 799    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 800    RETVALUE(ROK);
 801 }
 802
 803
 804 \f
 805 /***********************************************************
 806 *
 807 *     Func :cmUnpkRguL2MUlThrpMeasReqInfo
 808 *
 809 *
 810 * Status Response from RLC to MAC on UL dedicated logical channel for Uplink
 811 * Scheduled throughput measurement
 812 *
 813 *
 814 *     Ret  : S16
 815 *
 816 *     Notes:
 817 *
 818 *     File  :
 819 *
 820 **********************************************************/
 821 #ifdef ANSI
 822 PUBLIC S16 cmUnpkRguL2MUlThrpMeasReqInfo
 823 (
 824 RguL2MUlThrpMeasReqInfo *param,
 825 Buffer *mBuf
 826 )
 827 #else
 828 PUBLIC S16 cmUnpkRguL2MUlThrpMeasReqInfo(param, mBuf)
 829 RguL2MUlThrpMeasReqInfo *param;
 830 Buffer *mBuf;
 831 #endif
 832 {
 833    U8 loop;
 834    TRC3(cmUnpkRguL2MUlThrpMeasReqInfo);
 835
 836    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
 837    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
 838    CMCHKUNPK(cmUnpkLteLcId, &param->numLcId, mBuf);
 839    for (loop=0; loop<param->numLcId; loop++)
 840    {
 841       CMCHKUNPK(SUnpkU8, &param->lcId[loop], mBuf);
 842    }
 843    CMCHKUNPK(SUnpkU8, &param->enbMeas, mBuf);
 844    RETVALUE(ROK);
 845 }
 846
 847 /**
 848 * @brief Primitive invoked from RLC to MAC to
 849 * inform the On/Off status for Scheduled UL throughput
 850 * measurment for dedicated channels
 851 *
 852 * @details
 853 *
 854 *     Function :cmPkRguL2MUlThrpMeasReq
 855 *
 856 *  @param[in]   Pst*  pst
 857 *  @param[in]   SpId  spId
 858 *  @param[in]   RguL2MUlThrpMeasReqInfo*  measReq
 859 *  @return   S16
 860 *      -# ROK
 861 **/
 862 #ifdef ANSI
 863 PUBLIC S16 cmPkRguL2MUlThrpMeasReq
 864 (
 865 Pst* pst,
 866 SpId spId,
 867 RguL2MUlThrpMeasReqInfo* measReq
 868 )
 869 #else
 870 PUBLIC S16 cmPkRguL2MUlThrpMeasReq(pst, spId, measReq)
 871 Pst* pst;
 872 SpId spId;
 873 RguL2MUlThrpMeasReqInfo* measReq;
 874 #endif
 875 {
 876    Buffer *mBuf = NULLP;
 877    TRC3(cmPkRguL2MUlThrpMeasReq)
 878
 879    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 880 #if (ERRCLASS & ERRCLS_ADD_RES)
 881       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 882           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 883           (ErrVal)ERGU049, (ErrVal)0, "Packing failed");
 884 #endif
 885       SPutSBuf(pst->region, pst->pool, (Data *)measReq, sizeof(RguL2MUlThrpMeasReqInfo));
 886       RETVALUE(RFAILED);
 887    }
 888    if (pst->selector == RGU_SEL_LWLC)
 889    {
 890       CMCHKPK(cmPkPtr,(PTR) measReq, mBuf);
 891    }
 892    else
 893    {
 894       if (cmPkRguL2MUlThrpMeasReqInfo(measReq, 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)ERGU050, (ErrVal)0, "Packing failed");
 899 #endif
 900          SPutSBuf(pst->region, pst->pool, (Data *)measReq,
 901                                     sizeof(RguL2MUlThrpMeasReqInfo));
 902          SPutMsg(mBuf);
 903          RETVALUE(RFAILED);
 904       }
 905       if (SPutSBuf(pst->region, pst->pool, (Data *)measReq,
 906                            sizeof(RguL2MUlThrpMeasReqInfo)) != ROK) {
 907 #if (ERRCLASS & ERRCLS_ADD_RES)
 908          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 909             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 910              (ErrVal)ERGU052, (ErrVal)0, "Packing failed");
 911 #endif
 912          SPutMsg(mBuf);
 913          RETVALUE(RFAILED);
 914       }
 915       measReq = NULLP;
 916    }
 917
 918    if (SPkS16(spId, mBuf) != ROK) {
 919 #if (ERRCLASS & ERRCLS_ADD_RES)
 920       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 921           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 922           (ErrVal)ERGU051, (ErrVal)0, "Packing failed");
 923 #endif
 924       if (measReq != NULLP)
 925       {
 926          SPutSBuf(pst->region, pst->pool, (Data *)measReq,
 927                              sizeof(RguL2MUlThrpMeasReqInfo));
 928       }
 929       SPutMsg(mBuf);
 930       RETVALUE(RFAILED);
 931    }
 932
 933    pst->event = (Event) EVTRGUL2MULTHRPMEASREQ;
 934    RETVALUE(SPstTsk(pst,mBuf));
 935 }
 936
 937 \f
 938 /**
 939 * @brief Primitive invoked from RLC to MAC to
 940 * inform the On/Off status for Scheduled UL throughput
 941 * measurment for dedicated channels
 942 *
 943 * @details
 944 *
 945 *     Function :cmUnpkRguL2MUlThrpMeasReq
 946 *
 947 *  @param[in]   Pst*  pst
 948 *  @param[in]   SpId  spId
 949 *  @param[in]   RguL2MUlThrpMeasReqInfo  * measReq
 950 *  @return   S16
 951 *      -# ROK
 952 **/
 953 #ifdef ANSI
 954 PUBLIC S16 cmUnpkRguL2MUlThrpMeasReq
 955 (
 956 RguL2MUlThrpMeasReq func,
 957 Pst *pst,
 958 Buffer *mBuf
 959 )
 960 #else
 961 PUBLIC S16 cmUnpkRguL2MUlThrpMeasReq(func, pst, mBuf)
 962 RguL2MUlThrpMeasReq func;
 963 Pst *pst;
 964 Buffer *mBuf;
 965 #endif
 966 {
 967    SpId spId;
 968    RguL2MUlThrpMeasReqInfo* measReq;
 969
 970    TRC3(cmUnpkRguL2MUlThrpMeasReq)
 971
 972    if (SUnpkS16(&spId, mBuf) != ROK) {
 973 #if (ERRCLASS & ERRCLS_ADD_RES)
 974       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 975           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 976           (ErrVal)ERGU053, (ErrVal)0, "UnPacking failed");
 977 #endif
 978       SPutMsg(mBuf);
 979       RETVALUE(RFAILED);
 980    }
 981    if (pst->selector == RGU_SEL_LWLC)
 982    {
 983       CMCHKUNPK(cmUnpkPtr,(PTR *) &measReq, mBuf);
 984    }
 985    else
 986    {
 987       if ((SGetSBuf(pst->region, pst->pool, (Data **)&measReq,
 988                               sizeof(RguL2MUlThrpMeasReqInfo))) != ROK) {
 989 #if (ERRCLASS & ERRCLS_ADD_RES)
 990          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 991              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 992              (ErrVal)ERGU054, (ErrVal)0, "UnPacking failed");
 993 #endif
 994          SPutMsg(mBuf);
 995          RETVALUE(RFAILED);
 996       }
 997       if (cmUnpkRguL2MUlThrpMeasReqInfo(measReq, mBuf) != ROK) {
 998 #if (ERRCLASS & ERRCLS_ADD_RES)
 999          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1000              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1001              (ErrVal)ERGU055, (ErrVal)0, "UnPacking failed");
1002 #endif
1003          SPutMsg(mBuf);
1004          SPutSBuf(pst->region, pst->pool, (Data *)measReq,
1005                                 sizeof(RguL2MUlThrpMeasReqInfo));
1006          RETVALUE(RFAILED);
1007       }
1008    }
1009    SPutMsg(mBuf);
1010    RETVALUE((*func)(pst, spId, measReq));
1011 }
1012
1013 #endif
1014
1015
1016
1017 \f
1018 /**
1019 * @brief Primitive invoked from RLC to MAC to
1020  * inform the BO report for dedicated channels
1021 *
1022 * @details
1023 *
1024 *     Function : packBOStatus,
1025 *
1026 *  @param[in]   Pst*  pst
1027 *  @param[in]   SpId  spId
1028 *  @param[in]   RlcMacBOStatus  *  staRsp
1029 *  @return   S16
1030 *      -# ROK
1031 **/
1032 #ifdef ANSI
1033 PUBLIC S16 packBOStatus
1034 (
1035 Pst* pst,
1036 SpId spId,
1037 RlcMacBOStatus  *boStatus
1038 )
1039 #else
1040 PUBLIC S16 packBOStatus(pst, spId, staRsp)
1041 Pst* pst;
1042 SpId spId;
1043 RlcMacBOStatus  *boStatus;
1044 #endif
1045 {
1046    RlcMacBOStatus  *boStaInfo = NULL;
1047    Buffer *mBuf = NULLP;
1048
1049    if(SGetSBuf(pst->region, pst->pool, (Data **)&boStaInfo, sizeof(RlcMacBOStatus)) != ROK)
1050    {
1051 #if (ERRCLASS & ERRCLS_ADD_RES)
1052       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1053             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1054             (ErrVal)ERGU056, (ErrVal)0, "Packing failed");
1055 #endif
1056       RETVALUE(RFAILED);
1057    }
1058 #ifdef ERRCLS_KW
1059    /* boStaInfo cant be NULL here */
1060    if (boStaInfo == NULLP)
1061    {
1062       RETVALUE(RFAILED);
1063    }
1064 #endif
1065    cmMemcpy((U8 *)boStaInfo, (U8 *)boStatus, sizeof(RlcMacBOStatus));
1066    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1067 #if (ERRCLASS & ERRCLS_ADD_RES)
1068       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1069           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1070           (ErrVal)ERGU056, (ErrVal)0, "Packing failed");
1071 #endif
1072          SPutSBuf(pst->region, pst->pool, (Data *)boStaInfo, sizeof(RlcMacBOStatus));
1073
1074       RETVALUE(RFAILED);
1075    }
1076    if (pst->selector == RGU_SEL_LWLC)
1077    {
1078       CMCHKPK(cmPkPtr,(PTR) boStaInfo, mBuf);
1079    }
1080    else
1081    {
1082       if (packBOStatusInfo(boStatus, mBuf) != ROK) {
1083 #if (ERRCLASS & ERRCLS_ADD_RES)
1084         SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1085             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1086             (ErrVal)ERGU057, (ErrVal)0, "Packing failed");
1087 #endif
1088         SPutMsg(mBuf);
1089         RETVALUE(RFAILED);
1090      }
1091    }
1092    if (SPkS16(spId, mBuf) != ROK) {
1093 #if (ERRCLASS & ERRCLS_ADD_RES)
1094       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1095           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1096           (ErrVal)ERGU058, (ErrVal)0, "Packing failed");
1097 #endif
1098       if (boStaInfo != NULLP)
1099       {
1100          SPutSBuf(pst->region, pst->pool, (Data *)boStaInfo, sizeof(RlcMacBOStatus));
1101       }
1102       SPutMsg(mBuf);
1103       RETVALUE(RFAILED);
1104    }
1105
1106    pst->event = (Event)EVTRLCBOSTA;
1107    RETVALUE(SPstTsk(pst,mBuf));
1108    SPutMsg(mBuf);
1109 }
1110
1111 \f
1112 /**
1113 * @brief Primitive invoked from RLC to MAC to
1114 * inform the BO report for dedicated channels
1115 *
1116 * @details
1117 *
1118 *     Function : unpackBOStatus
1119 *
1120 *  @param[in]   Pst*  pst
1121 *  @param[in]   SpId  spId
1122 *  @param[in]   RlcMacBOStatus *  staRsp
1123 *  @return   S16
1124 *      -# ROK
1125 **/
1126 #ifdef ANSI
1127 PUBLIC S16 unpackBOStatus
1128 (
1129 RguDStaRsp func,
1130 Pst *pst,
1131 Buffer *mBuf
1132 )
1133 #else
1134 PUBLIC S16 unpackBOStatus(func, pst, mBuf)
1135 RguDStaRsp func;
1136 Pst *pst;
1137 Buffer *mBuf;
1138 #endif
1139 {
1140    SpId spId;
1141    RlcMacBOStatus *boSta;
1142
1143    TRC3(unpackBOStatus)
1144
1145    if (SUnpkS16(&spId, mBuf) != ROK) {
1146 #if (ERRCLASS & ERRCLS_ADD_RES)
1147       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1148           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1149           (ErrVal)ERGU060, (ErrVal)0, "UnPacking failed");
1150 #endif
1151       SPutMsg(mBuf);
1152       RETVALUE(RFAILED);
1153    }
1154
1155    if (pst->selector == RGU_SEL_LWLC)
1156    {
1157       CMCHKUNPK(cmUnpkPtr,(PTR *) &boSta, mBuf);
1158    }
1159    else
1160    {
1161       if ((SGetSBuf(pst->region, pst->pool, (Data **)&boSta,
1162                                  sizeof(RlcMacBOStatus))) != ROK) {
1163 #if (ERRCLASS & ERRCLS_ADD_RES)
1164          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1165              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1166              (ErrVal)ERGU061, (ErrVal)0, "UnPacking failed");
1167 #endif
1168          SPutMsg(mBuf);
1169          RETVALUE(RFAILED);
1170       }
1171       if (unpackBOStatusInfo(boSta, mBuf) != ROK) {
1172 #if (ERRCLASS & ERRCLS_ADD_RES)
1173          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1174              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1175              (ErrVal)ERGU062, (ErrVal)0, "UnPacking failed");
1176 #endif
1177          SPutMsg(mBuf);
1178          SPutSBuf(pst->region, pst->pool, (Data *)boSta, sizeof(RlcMacBOStatus));
1179          RETVALUE(RFAILED);
1180       }
1181    }
1182    SPutMsg(mBuf);
1183   // (*func)(pst, spId, boSta);
1184    SPutSBuf(pst->region, pst->pool, (Data *)boSta, sizeof(RlcMacBOStatus));
1185    RETVALUE(ROK);
1186 }
1187
1188
1189    /*rgu_c_001.main_5 - ADD - L2M Support */
1190 #ifdef LTE_L2_MEAS
1191 \f
1192 /**
1193 * @brief Harq Status Indication from MAC to RLC
1194 *
1195 * @details
1196 *
1197 *     Function : cmPkRguHqStaInd
1198 *
1199 *  @param[in]   Pst*  pst
1200 *  @param[in]   SuId  suId
1201 *  @param[in]   RguHarqStatusInd  *harqStatusInd
1202 *  @return   S16
1203 *      -# ROK
1204 **/
1205 #ifdef ANSI
1206 PUBLIC S16 cmPkRguHqStaInd
1207 (
1208 Pst* pst,
1209 SuId suId,
1210 RguHarqStatusInd  *harqStatusInd
1211 )
1212 #else
1213 PUBLIC S16 cmPkRguHqStaInd(pst, suId, harqStatusInd)
1214 Pst* pst;
1215 SuId suId;
1216 RguHarqStatusInd  *harqStatusInd;
1217 #endif
1218 {
1219
1220    Buffer   *mBuf;
1221    U8       idx;
1222    RguHarqStatusInd *harqStaInd = NULL;
1223
1224    TRC3(cmPkRguHqStaInd)
1225 #ifdef XEON_SPECIFIC_CHANGES
1226    if (SGetSBuf(pst->region, pst->pool, (Data **)&harqStaInd, sizeof(RguHarqStatusInd)) != ROK)
1227 #else
1228    if ((SGetStaticBuffer(pst->region, pst->pool,
1229                (Data **)&harqStaInd, sizeof(RguHarqStatusInd),0)) != ROK)
1230 #endif
1231    {
1232 #if (ERRCLASS & ERRCLS_ADD_RES)
1233       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1234             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1235             (ErrVal)ERGU070, (ErrVal)0, "Packing failed");
1236 #endif
1237       RETVALUE(RFAILED);
1238    }
1239
1240    cmMemcpy((U8 *)harqStaInd, (U8 *)harqStatusInd, sizeof(RguHarqStatusInd));
1241
1242    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1243 #if (ERRCLASS & ERRCLS_ADD_RES)
1244       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1245             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1246             (ErrVal)ERGU070, (ErrVal)0, "Packing failed");
1247 #endif
1248 #ifdef XEON_SPECIFIC_CHANGES
1249       SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd));
1250 #else
1251       SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
1252 #endif
1253       RETVALUE(RFAILED);
1254    }
1255
1256    if (pst->selector == RGU_SEL_LWLC)
1257    {
1258       CMCHKPK(cmPkPtr,(PTR) harqStaInd, mBuf);
1259    }
1260    else
1261    {
1262       for(idx = 0; idx < harqStaInd->numTbs; idx++)
1263       {
1264          CMCHKPK(SPkU16, harqStaInd->status[idx], mBuf);
1265       }
1266       for(idx = 0; idx < harqStaInd->numTbs; idx++)
1267       {
1268          CMCHKPK(SPkU32, harqStaInd->tbId[idx], mBuf);
1269       }
1270       CMCHKPK(SPkU8, harqStaInd->numTbs, mBuf);
1271       CMCHKPK(cmPkLteRnti, harqStaInd->ueId, mBuf);
1272       CMCHKPK(cmPkLteCellId, harqStaInd->cellId, mBuf);
1273    }
1274    if (SPkS16(suId, mBuf) != ROK) {
1275 #if (ERRCLASS & ERRCLS_ADD_RES)
1276       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1277           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1278           (ErrVal)ERGU071, (ErrVal)0, "Packing failed");
1279 #endif
1280 #ifdef XEON_SPECIFIC_CHANGES
1281       SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd,
1282               sizeof(RguHarqStatusInd));
1283 #else
1284       SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
1285 #endif
1286       SPutMsg(mBuf);
1287       RETVALUE(RFAILED);
1288    }
1289 #ifdef XEON_SPECIFIC_CHANGES
1290    if (SPutSBuf(pst->region, pst->pool, (Data *)harqStaInd,
1291             sizeof(RguHarqStatusInd)) != ROK) {
1292 #else
1293    if (pst->selector != RGU_SEL_LWLC)
1294    {
1295       if(SPutStaticBuffer(pst->region, pst->pool, (Data *)harqStaInd,
1296                sizeof(RguHarqStatusInd), 0) != ROK)
1297       {
1298 #endif
1299 #if (ERRCLASS & ERRCLS_ADD_RES)
1300          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1301                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1302                (ErrVal)ERGU072, (ErrVal)0, "Packing failed");
1303 #endif
1304          SPutMsg(mBuf);
1305          RETVALUE(RFAILED);
1306       }
1307 #ifndef XEON_SPECIFIC_CHANGES
1308    }
1309 #endif
1310
1311    pst->event = (Event) EVTRGUHQSTAIND;
1312    RETVALUE(SPstTsk(pst,mBuf));
1313 }
1314 \f
1315
1316 /**
1317 * @brief Harq Status Indication from MAC to RLC
1318 *
1319 * @details
1320 *
1321 *     Function : cmUnpkRguHqStaInd
1322 *
1323 *  @param[in]  RguHqStaInd   func
1324 *  @param[in]  Pst           *pst
1325 *  @param[in]  Buffer        *mBuf
1326 *  @return   S16
1327 *      -# ROK
1328 **/
1329 #ifdef ANSI
1330 PUBLIC S16 cmUnpkRguHqStaInd
1331 (
1332 RguHqStaInd  func,
1333 Pst *pst,
1334 Buffer *mBuf
1335 )
1336 #else
1337 PUBLIC S16 cmUnpkRguHqStaInd(func, pst, mBuf)
1338 RguHqStaInd   func;
1339 Pst *pst;
1340 Buffer *mBuf;
1341 #endif
1342 {
1343    RguHarqStatusInd    *hqStaInd;
1344    SuId                suId;
1345    U8                  idx;
1346
1347    TRC3(cmUnpkRguHqStaInd)
1348
1349    if (SUnpkS16(&suId, mBuf) != ROK) {
1350 #if (ERRCLASS & ERRCLS_ADD_RES)
1351       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1352           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1353           (ErrVal)ERGU073, (ErrVal)0, "UnPacking failed");
1354 #endif
1355       SPutMsg(mBuf);
1356       RETVALUE(RFAILED);
1357    }
1358 #ifdef XEON_SPECIFIC_CHANGES
1359    if ((SGetSBuf(pst->region, pst->pool, (Data **)&hqStaInd,
1360         sizeof(RguHarqStatusInd))) != ROK) {
1361 #else
1362    if (pst->selector == RGU_SEL_LWLC)
1363    {
1364       CMCHKUNPK(cmUnpkPtr,(PTR *) &hqStaInd, mBuf);
1365    }
1366    else
1367    {
1368       if ((SGetStaticBuffer(pst->region, pst->pool,
1369                   (Data **)&hqStaInd, sizeof(RguHarqStatusInd),0)) != ROK)
1370       {
1371 #endif
1372 #if (ERRCLASS & ERRCLS_ADD_RES)
1373          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1374                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1375                (ErrVal)ERGU074, (ErrVal)0, "UnPacking failed");
1376 #endif
1377          SPutMsg(mBuf);
1378          RETVALUE(RFAILED);
1379       }
1380       CMCHKUNPK(cmUnpkLteCellId, &hqStaInd->cellId, mBuf);
1381       CMCHKUNPK(cmUnpkLteRnti, &hqStaInd->ueId, mBuf);
1382       CMCHKUNPK(SUnpkU8, &hqStaInd->numTbs, mBuf);
1383       for(idx = hqStaInd->numTbs; idx > 0; idx--)
1384       {
1385          CMCHKUNPK(SUnpkU32, &hqStaInd->tbId[idx - 1], mBuf);
1386       }
1387       for(idx = hqStaInd->numTbs; idx > 0; idx--)
1388       {
1389          CMCHKUNPK(SUnpkU16, &hqStaInd->status[idx - 1], mBuf);
1390       }
1391 #ifndef XEON_SPECIFIC_CHANGES
1392    }
1393 #endif
1394    SPutMsg(mBuf);
1395    (*func)(pst, suId, hqStaInd);
1396 #ifdef XEON_SPECIFIC_CHANGES
1397    SPutSBuf(pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd));
1398 #else
1399    SPutStaticBuffer(pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd), 0);
1400 #endif
1401    RETVALUE(ROK);
1402 }
1403 #endif /* LTE_L2_MEAS */
1404
1405 \f
1406 /**
1407 * @brief Status Indication from MAC to RLC
1408  * as a response to the staRsp primitive from RLC.
1409  * Informs RLC of the totalBufferSize and Timing Info
1410  * for the transmission on dedicated channels.
1411 *
1412 * @details
1413 *
1414 *     Function : packSchedRep
1415 *
1416 *  @param[in]   Pst*  pst
1417 *  @param[in]   SuId  suId
1418 *  @param[in]   RlcMacSchedRep*  schRep
1419 *  @return   S16
1420 *      -# ROK
1421 **/
1422 #ifdef ANSI
1423 PUBLIC S16 packSchedRep
1424 (
1425 Pst* pst,
1426 SuId suId,
1427 RlcMacSchedRep  * schRep
1428 )
1429 #else
1430 PUBLIC S16 packSchedRep(pst, suId, staInd)
1431 Pst* pst;
1432 SuId suId;
1433 RlcMacSchedRep  * schRep;
1434 #endif
1435 {
1436    Buffer *mBuf = NULLP;
1437    TRC3(packSchedRep)
1438
1439    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1440 #if (ERRCLASS & ERRCLS_ADD_RES)
1441       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1442           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1443           (ErrVal)ERGU076, (ErrVal)0, "Packing failed");
1444 #endif
1445       SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRep));
1446       RETVALUE(RFAILED);
1447    }
1448    if (pst->selector == RGU_SEL_LWLC)
1449    {
1450       CMCHKPK(cmPkPtr,(PTR) schRep, mBuf);
1451    }
1452    else
1453    {
1454       if (packSchedRepInfo(schRep, mBuf) != ROK) {
1455 #if (ERRCLASS & ERRCLS_ADD_RES)
1456            SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1457                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1458                (ErrVal)ERGU077, (ErrVal)0, "Packing failed");
1459 #endif
1460         SPutSBuf(pst->region, pst->pool, (Data *)schRep,
1461                                          sizeof(RlcMacSchedRep));
1462          SPutMsg(mBuf);
1463          RETVALUE(RFAILED);
1464       }
1465       if (SPutSBuf(pst->region, pst->pool, (Data *)schRep,
1466                                   sizeof(RlcMacSchedRep)) != ROK) {
1467 #if (ERRCLASS & ERRCLS_ADD_RES)
1468          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1469              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1470              (ErrVal)ERGU079, (ErrVal)0, "Packing failed");
1471 #endif
1472          SPutMsg(mBuf);
1473          RETVALUE(RFAILED);
1474       }
1475       schRep= NULLP;
1476    }
1477    if (SPkS16(suId, mBuf) != ROK) {
1478 #if (ERRCLASS & ERRCLS_ADD_RES)
1479       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1480           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1481           (ErrVal)ERGU078, (ErrVal)0, "Packing failed");
1482 #endif
1483       if (schRep != NULLP)
1484       {
1485          SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRep));
1486       }
1487       SPutMsg(mBuf);
1488       RETVALUE(RFAILED);
1489    }
1490
1491    pst->event = (Event) EVTSCHREP;
1492    RETVALUE(SPstTsk(pst,mBuf));
1493 }
1494
1495 \f
1496 /**
1497 * @brief Status Indication from MAC to RLC
1498  * as a response to the staRsp primitive from RLC.
1499  * Informs RLC of the totalBufferSize and Timing Info
1500  * for the transmission on dedicated channels.
1501 *
1502 * @details
1503 *
1504 *     Function : unpackSchedRep
1505 *
1506 *  @param[in]   Pst*  pst
1507 *  @param[in]   SuId  suId
1508 *  @param[in]   RguDStaIndInfo  *  staInd
1509 *  @return   S16
1510 *      -# ROK
1511 **/
1512 #ifdef ANSI
1513 PUBLIC S16 unpackSchedRep
1514 (
1515 RguDStaInd func,
1516 Pst *pst,
1517 Buffer *mBuf
1518 )
1519 #else
1520 PUBLIC S16 unpackSchedRep(func, pst, mBuf)
1521 RguDStaInd func;
1522 Pst *pst;
1523 Buffer *mBuf;
1524 #endif
1525 {
1526    SuId suId;
1527 //   RguDStaIndInfo *staInd;
1528    RlcMacSchedRep *schRep;
1529
1530    TRC3(unpackSchedRep)
1531
1532    if (SUnpkS16(&suId, mBuf) != ROK) {
1533 #if (ERRCLASS & ERRCLS_ADD_RES)
1534       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1535           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1536           (ErrVal)ERGU080, (ErrVal)0, "UnPacking failed");
1537 #endif
1538       SPutMsg(mBuf);
1539       RETVALUE(RFAILED);
1540    }
1541    if (pst->selector == RGU_SEL_LWLC)
1542    {
1543       CMCHKUNPK(cmUnpkPtr,(PTR *) &schRep, mBuf);
1544    }
1545    else
1546    {
1547       if ((SGetSBuf(pst->region, pst->pool, (Data **)&schRep, sizeof(RlcMacSchedRep))) != ROK) {
1548 #if (ERRCLASS & ERRCLS_ADD_RES)
1549          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1550          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1551          (ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
1552 #endif
1553          SPutMsg(mBuf);
1554          RETVALUE(RFAILED);
1555       }
1556       if (unpackSchedRepInfo(schRep, mBuf) != ROK) {
1557 #if (ERRCLASS & ERRCLS_ADD_RES)
1558          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1559              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1560              (ErrVal)ERGU082, (ErrVal)0, "UnPacking failed");
1561 #endif
1562          SPutMsg(mBuf);
1563          SPutSBuf(pst->region, pst->pool, (Data *)schRep, sizeof(RlcMacSchedRep));
1564          RETVALUE(RFAILED);
1565       }
1566    }
1567    SPutMsg(mBuf);
1568    RETVALUE((*func)(pst, suId, schRep));
1569 }
1570
1571 #ifdef ANSI
1572 PUBLIC S16 cmPkRguLcFlowCntrlInfo
1573 (
1574 RguLcFlowCntrlInfo *param,
1575 Buffer             *mBuf
1576 )
1577 #else
1578 PUBLIC S16 cmPkRguLcFlowCntrlInfo (param,mBuf)
1579 RguLcFlowCntrlInfo *param;
1580 Buffer             *mBuf;
1581 #endif
1582 {
1583   TRC3(cmPkRguLcFlowCntrlInfo);
1584   CMCHKPK(SPkU32, param->maxBo4FlowCtrl, mBuf);
1585   CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
1586   CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1587
1588   RETVALUE(ROK);
1589 }
1590
1591 #ifdef ANSI
1592 PUBLIC S16 cmPkRguUeFlowCntrlInfo
1593 (
1594 RguUeFlowCntrlInfo *param,
1595 Buffer             *mBuf
1596 )
1597 #else
1598 PUBLIC S16 cmPkRguUeFlowCntrlInfo (param,mBuf)
1599 RguUeFlowCntrlInfo *param;
1600 Buffer             *mBuf;
1601 #endif
1602 {
1603   U32 idx;
1604
1605   TRC3(cmPkRguUeFlowCntrlInfo);
1606
1607   for(idx=(param->numLcs - 1); idx >= 0; idx--)
1608   {
1609     cmPkRguLcFlowCntrlInfo(&param->lcInfo[idx],mBuf);
1610   }
1611   CMCHKPK(SPkU32, param->numLcs, mBuf);
1612   CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
1613   RETVALUE(ROK);
1614 }
1615
1616 #ifdef ANSI
1617 PUBLIC S16 cmPkRguFlowCntrlInfo
1618 (
1619 RguFlowCntrlInd *param,
1620 Buffer          *mBuf
1621 )
1622 #else
1623 PUBLIC S16 cmPkRguFlowCntrlInfo(flowCntrlInd, mBuf)
1624 RguFlowCntrlInd *param;
1625 Buffer          *mBuf;
1626 #endif
1627 {
1628   U32 idx;
1629
1630   TRC3(cmPkRguFlowCntrlInfo);
1631
1632   for (idx=(param->numUes - 1); idx >= 0; idx--)
1633   {
1634     cmPkRguUeFlowCntrlInfo(&param->ueFlowCntrlInfo[idx],mBuf);
1635   }
1636   CMCHKPK(SPkU32, param->numUes, mBuf);
1637   CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1638   RETVALUE(ROK);
1639 }
1640 \f
1641 /**
1642 * @brief Flow Cntrl Indication from MAC to RLC
1643  * Informs RLC of the LCs on which flow control
1644  * to be performed.
1645 *
1646 * @details
1647 *
1648 *     Function : cmPkRguFlowCntrlInd
1649 *
1650 *  @param[in]   Pst*  pst
1651 *  @param[in]   SuId  suId
1652 *  @param[in]   RguFlowCntrlInd *staInd
1653 *  @return   S16
1654 *      -# ROK
1655 **/
1656 #ifdef ANSI
1657 PUBLIC S16 cmPkRguFlowCntrlInd
1658 (
1659 Pst* pst,
1660 SuId suId,
1661 RguFlowCntrlInd  *flowCntrlInd
1662 )
1663 #else
1664 PUBLIC S16 cmPkRguFlowCntrlInd(pst, suId, flowCntrlInd)
1665 Pst* pst;
1666 SuId suId;
1667 RguFlowCntrlInd   *flowCntrlInd;
1668 #endif
1669 {
1670    Buffer *mBuf = NULLP;
1671
1672    TRC3(cmPkRguFlowCntrlInd);
1673    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1674 #if (ERRCLASS & ERRCLS_ADD_RES)
1675       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1676           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1677           (ErrVal)ERGU076, (ErrVal)0, "Packing failed");
1678 #endif
1679       RETVALUE(RFAILED);
1680    }
1681    if (pst->selector == RGU_SEL_LWLC)
1682    {
1683       CMCHKPK(cmPkPtr,(PTR) flowCntrlInd, mBuf);
1684    }
1685    else
1686    {
1687       if (cmPkRguFlowCntrlInfo(flowCntrlInd, mBuf) != ROK) {
1688 #if (ERRCLASS & ERRCLS_ADD_RES)
1689            SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1690                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1691                (ErrVal)ERGU077, (ErrVal)0, "Packing failed");
1692 #endif
1693          SPutMsg(mBuf);
1694          RETVALUE(RFAILED);
1695       }
1696    }
1697    if (SPkS16(suId, mBuf) != ROK) {
1698 #if (ERRCLASS & ERRCLS_ADD_RES)
1699       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1700           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1701           (ErrVal)ERGU078, (ErrVal)0, "Packing failed");
1702 #endif
1703       SPutMsg(mBuf);
1704       RETVALUE(RFAILED);
1705    }
1706
1707    pst->event = (Event) EVTRGUFLOWCNTRLIND;
1708    RETVALUE(SPstTsk(pst,mBuf));
1709 }
1710
1711 #ifdef ANSI
1712 PUBLIC S16 cmUnpkRguLcFlowCntrlInfo
1713 (
1714 RguLcFlowCntrlInfo *param,
1715 Buffer           *mBuf
1716 )
1717 #else
1718 PUBLIC S16 cmUnpkRguLcFlowCntrlInfo (param,mBuf)
1719 RguLcFlowCntrlInfo *param;
1720 Buffer           *mBuf;
1721 #endif
1722 {
1723   TRC3(cmUnpkRguLcFlowCntrlInfo);
1724
1725   CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1726   CMCHKUNPK(SUnpkU32, &param->pktAdmitCnt, mBuf);
1727   CMCHKUNPK(SUnpkU32, &param->maxBo4FlowCtrl, mBuf);
1728
1729   RETVALUE(ROK);
1730 }
1731 #ifdef ANSI
1732 PUBLIC S16 cmUnpkRguUeFlowCntrlInfo
1733 (
1734 RguUeFlowCntrlInfo *param,
1735 Buffer           *mBuf
1736 )
1737 #else
1738 PUBLIC S16 cmUnpkRguUeFlowCntrlInfo (param,mBuf)
1739 RguUeFlowCntrlInfo *param;
1740 Buffer           *mBuf;
1741 #endif
1742 {
1743   U32 idx;
1744   TRC3(cmUnpkRguUeFlowCntrlInfo);
1745   CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
1746   CMCHKUNPK(SUnpkU32, &param->numLcs, mBuf);
1747   for(idx=0; idx < param->numLcs; idx++)
1748   {
1749     cmUnpkRguLcFlowCntrlInfo(&param->lcInfo[idx],mBuf);
1750   }
1751   RETVALUE(ROK);
1752 }
1753
1754 #ifdef ANSI
1755 PUBLIC S16 cmUnpkRguFlowCntrlInfo
1756 (
1757 RguFlowCntrlInd *param,
1758 Buffer           *mBuf
1759 )
1760 #else
1761 PUBLIC S16 cmUnpkRguFlowCntrlInfo(flowCntrlInfo, mBuf)
1762 RguFlowCntrlInd *param;
1763 Buffer           *mBuf;
1764 #endif
1765 {
1766   U32 idx;
1767
1768   TRC3(cmUnpkRguFlowCntrlInfo);
1769
1770   CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1771   CMCHKUNPK(SUnpkU32, &param->numUes, mBuf);
1772   for (idx=0; idx < param->numUes; idx++)
1773   {
1774     cmUnpkRguUeFlowCntrlInfo(&param->ueFlowCntrlInfo[idx],mBuf);
1775   }
1776   RETVALUE(ROK);
1777 }
1778
1779 /**
1780 * @brief Flow control indication from MAC to RLC
1781 * Informs RLC of the LCs on which flow control to
1782 * be started
1783 *
1784 * @details
1785 *
1786 *     Function : cmUnpkRguFlowCntrlInd
1787 *
1788 *  @param[in]   RguFlowCntrlInd func
1789 *  @param[in]   Pst    *pst
1790 *  @param[in]   Buffer *mBuf
1791 *  @return   S16
1792 *      -# ROK
1793 **/
1794 #ifdef ANSI
1795 PUBLIC S16 cmUnpkRguFlowCntrlInd
1796 (
1797 RguFlowCntrlIndInfo func,
1798 Pst *pst,
1799 Buffer *mBuf
1800 )
1801 #else
1802 PUBLIC S16 cmUnpkRguFlowCntrlInd(func, pst, mBuf)
1803 RguFlowCntrlIndInfo func;
1804 Pst *pst;
1805 Buffer *mBuf;
1806 #endif
1807 {
1808    SuId suId;
1809    RguFlowCntrlInd *flowCntrlInd;
1810
1811    TRC3(cmUnpkRguFlowCntrlInd)
1812
1813    if (SUnpkS16(&suId, mBuf) != ROK) {
1814 #if (ERRCLASS & ERRCLS_ADD_RES)
1815       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1816           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1817           (ErrVal)ERGU080, (ErrVal)0, "UnPacking failed");
1818 #endif
1819       SPutMsg(mBuf);
1820       RETVALUE(RFAILED);
1821    }
1822    if (pst->selector == RGU_SEL_LWLC)
1823    {
1824       CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInd, mBuf);
1825    }
1826    else
1827    {
1828       if ((SGetSBuf(pst->region, pst->pool, (Data **)&flowCntrlInd, sizeof(RguFlowCntrlInd))) != ROK) {
1829 #if (ERRCLASS & ERRCLS_ADD_RES)
1830          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1831          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1832          (ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
1833 #endif
1834          SPutMsg(mBuf);
1835          RETVALUE(RFAILED);
1836       }
1837       if (cmUnpkRguFlowCntrlInfo(flowCntrlInd, mBuf) != ROK) {
1838 #if (ERRCLASS & ERRCLS_ADD_RES)
1839          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1840              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1841              (ErrVal)ERGU082, (ErrVal)0, "UnPacking failed");
1842 #endif
1843          SPutMsg(mBuf);
1844          SPutSBuf(pst->region, pst->pool, (Data *)flowCntrlInd, sizeof(RguFlowCntrlInd));
1845          RETVALUE(RFAILED);
1846       }
1847    }
1848    SPutMsg(mBuf);
1849    RETVALUE((*func)(pst, suId, flowCntrlInd));
1850 }
1851
1852 /***********************************************************
1853 *
1854 *     Func : cmPkRguPduInfo
1855 *
1856 *
1857 *     Desc : RguPduInfo
1858  * PDU information given on a logical channel
1859 *
1860 *
1861 *     Ret  : S16
1862 *
1863 *     Notes:
1864 *
1865 *     File  :
1866 *
1867 **********************************************************/
1868 #ifdef ANSI
1869 PUBLIC S16 cmPkRguPduInfo
1870 (
1871 RguPduInfo *param,
1872 Buffer *mBuf
1873 )
1874 #else
1875 PUBLIC S16 cmPkRguPduInfo(param, mBuf)
1876 RguPduInfo *param;
1877 Buffer *mBuf;
1878 #endif
1879 {
1880    S32 i;
1881
1882    TRC3(cmPkRguPduInfo);
1883
1884    for (i=param->numPdu-1; i >= 0; i--) {
1885      /* rgu_c_001.main_3: ccpu00111328: S16 is renamed as MsgLen */
1886       MsgLen msgLen = 0;
1887       if (SFndLenMsg(param->mBuf[i], &msgLen) != ROK)
1888          RETVALUE(RFAILED);
1889       if (SCatMsg(mBuf, param->mBuf[i], M1M2) != ROK)
1890          RETVALUE(RFAILED);
1891       SPutMsg(param->mBuf[i]);
1892       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
1893    }
1894    CMCHKPK(SPkU8, param->numPdu, mBuf);
1895    RETVALUE(ROK);
1896 }
1897
1898
1899 \f
1900 /***********************************************************
1901 *
1902 *     Func : cmUnpkRguPduInfo
1903 *
1904 *
1905 *     Desc : RguPduInfo
1906  * PDU information given on a logical channel
1907 *
1908 *
1909 *     Ret  : S16
1910 *
1911 *     Notes:
1912 *
1913 *     File  :
1914 *
1915 **********************************************************/
1916 #ifdef ANSI
1917 PUBLIC S16 cmUnpkRguPduInfo
1918 (
1919 RguPduInfo *param,
1920 Buffer *mBuf
1921 )
1922 #else
1923 PUBLIC S16 cmUnpkRguPduInfo(param, mBuf)
1924 RguPduInfo *param;
1925 Buffer *mBuf;
1926 #endif
1927 {
1928    S32 i;
1929
1930    TRC3(cmUnpkRguPduInfo);
1931
1932    CMCHKUNPK(SUnpkU8, &param->numPdu, mBuf);
1933    for (i=0; i<param->numPdu; i++) {
1934       MsgLen msgLen, totalMsgLen;
1935       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
1936       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
1937          RETVALUE(RFAILED);
1938       if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->mBuf[i]) != ROK)
1939          RETVALUE(RFAILED);
1940    }
1941    RETVALUE(ROK);
1942 }
1943
1944
1945 \f
1946 /***********************************************************
1947 *
1948 *     Func : cmPkRguDBoReport
1949 *
1950 *
1951 *     Desc : RguDBoReport
1952  * Buffer Occupancy Report for dedicated logical channel
1953 *
1954 *
1955 *     Ret  : S16
1956 *
1957 *     Notes:
1958 *
1959 *     File  :
1960 *
1961 **********************************************************/
1962 #ifdef ANSI
1963 PUBLIC S16 cmPkRguDBoReport
1964 (
1965 RguDBoReport *param,
1966 Buffer *mBuf
1967 )
1968 #else
1969 PUBLIC S16 cmPkRguDBoReport(param, mBuf)
1970 RguDBoReport *param;
1971 Buffer *mBuf;
1972 #endif
1973 {
1974
1975    TRC3(cmPkRguDBoReport);
1976
1977    CMCHKPK(SPkU32, param->oldestSduArrTime, mBuf);
1978    CMCHKPK(SPkU32, param->staPduBo, mBuf);
1979 #ifdef CCPU_OPT
1980    CMCHKPK(SPkU8, param->staPduPrsnt, mBuf);
1981    CMCHKPK(SPkU16, param->estRlcHdrSz, mBuf);
1982 #endif
1983    CMCHKPK(SPkS32, param->bo, mBuf);
1984    RETVALUE(ROK);
1985 }
1986
1987
1988 \f
1989 /***********************************************************
1990 *
1991 *     Func : cmUnpkRguDBoReport
1992 *
1993 *
1994 *     Desc : RguDBoReport
1995  * Buffer Occupancy Report for dedicated logical channel
1996 *
1997 *
1998 *     Ret  : S16
1999 *
2000 *     Notes:
2001 *
2002 *     File  :
2003 *
2004 **********************************************************/
2005 #ifdef ANSI
2006 PUBLIC S16 cmUnpkRguDBoReport
2007 (
2008 RguDBoReport *param,
2009 Buffer *mBuf
2010 )
2011 #else
2012 PUBLIC S16 cmUnpkRguDBoReport(param, mBuf)
2013 RguDBoReport *param;
2014 Buffer *mBuf;
2015 #endif
2016 {
2017
2018    TRC3(cmUnpkRguDBoReport);
2019
2020    CMCHKUNPK(SUnpkS32, &param->bo, mBuf);
2021 #ifdef CCPU_OPT
2022    CMCHKUNPK(SUnpkU16, &param->estRlcHdrSz, mBuf);
2023    CMCHKUNPK(SUnpkU8, &param->staPduPrsnt, mBuf);
2024 #endif
2025
2026    CMCHKUNPK(SUnpkU32, &param->staPduBo, mBuf);
2027    CMCHKUNPK(SUnpkU32, &param->oldestSduArrTime, mBuf);
2028    RETVALUE(ROK);
2029 }
2030
2031 \f
2032 /***********************************************************
2033 *
2034 *     Func : cmPkRguCDatReqInfo
2035 *
2036 *
2037 *     Desc : RguCDatReqInfo
2038  * DatReq from RLC to MAC for Common Channels(BCCH, PCCH and CCCH)
2039 *
2040 *
2041 *     Ret  : S16
2042 *
2043 *     Notes:
2044 *
2045 *     File  :
2046 *
2047 **********************************************************/
2048 #ifdef ANSI
2049 PUBLIC S16 cmPkRguCDatReqInfo
2050 (
2051 RguCDatReqInfo *param,
2052 Buffer *mBuf
2053 )
2054 #else
2055 PUBLIC S16 cmPkRguCDatReqInfo(param, mBuf)
2056 RguCDatReqInfo *param;
2057 Buffer *mBuf;
2058 #endif
2059 {
2060    MsgLen msgLen;
2061
2062    TRC3(cmPkRguCDatReqInfo);
2063
2064    if (param->pdu != NULLP)
2065    {
2066       if (SFndLenMsg(param->pdu, &msgLen) != ROK)
2067          RETVALUE(RFAILED);
2068       if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
2069          RETVALUE(RFAILED);
2070       SPutMsg(param->pdu);
2071       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
2072    }
2073    switch(param->lcType) {
2074       case CM_LTE_LCH_CCCH:
2075          CMCHKPK(cmPkLteRnti, param->u.rnti, mBuf);
2076          break;
2077       case CM_LTE_LCH_BCCH:
2078       case CM_LTE_LCH_PCCH:
2079          CMCHKPK(cmPkLteTimingInfo, &param->u.timeToTx, mBuf);
2080 #ifdef EMTC_ENABLE
2081         CMCHKPK(SPkU8,param->pnb,mBuf);
2082 #endif
2083          break;
2084       default :
2085          RETVALUE(RFAILED);
2086    }
2087    CMCHKPK(SPkU32, param->transId, mBuf);
2088    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
2089    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2090    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2091    RETVALUE(ROK);
2092 }
2093
2094
2095 \f
2096 /***********************************************************
2097 *
2098 *     Func : cmUnpkRguCDatReqInfo
2099 *
2100 *
2101 *     Desc : RguCDatReqInfo
2102  * DatReq from RLC to MAC for Common Channels(BCCH, PCCH and CCCH)
2103 *
2104 *
2105 *     Ret  : S16
2106 *
2107 *     Notes:
2108 *
2109 *     File  :
2110 *
2111 **********************************************************/
2112 #ifdef ANSI
2113 PUBLIC S16 cmUnpkRguCDatReqInfo
2114 (
2115 RguCDatReqInfo *param,
2116 Buffer *mBuf
2117 )
2118 #else
2119 PUBLIC S16 cmUnpkRguCDatReqInfo(param, mBuf)
2120 RguCDatReqInfo *param;
2121 Buffer *mBuf;
2122 #endif
2123 {
2124    MsgLen msgLen, totalMsgLen;
2125
2126    TRC3(cmUnpkRguCDatReqInfo);
2127
2128    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2129    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
2130    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
2131    CMCHKUNPK(SUnpkU32, &param->transId, mBuf);
2132    switch(param->lcType) {
2133       case CM_LTE_LCH_BCCH:
2134       case CM_LTE_LCH_PCCH:
2135 #ifdef EMTC_ENABLE
2136          CMCHKUNPK(SUnpkU8,&param->pnb, mBuf);
2137 #endif
2138          CMCHKUNPK(cmUnpkLteTimingInfo, &param->u.timeToTx, mBuf);
2139          break;
2140       case CM_LTE_LCH_CCCH:
2141          CMCHKUNPK(cmUnpkLteRnti, &param->u.rnti, mBuf);
2142          break;
2143       default :
2144          RETVALUE(RFAILED);
2145    }
2146    SFndLenMsg(mBuf, &msgLen);
2147    if (msgLen > 0)
2148    {
2149       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
2150       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
2151          RETVALUE(RFAILED);
2152       if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
2153          RETVALUE(RFAILED);
2154    }
2155    RETVALUE(ROK);
2156 }
2157
2158
2159 \f
2160 /***********************************************************
2161 *
2162 *     Func : cmPkRguLchDatReq
2163 *
2164 *
2165 *     Desc : RguLchDatReq
2166  * DatReq Information of a logical channel
2167 *
2168 *
2169 *     Ret  : S16
2170 *
2171 *     Notes:
2172 *
2173 *     File  :
2174 *
2175 **********************************************************/
2176 #ifdef ANSI
2177 PUBLIC S16 cmPkRguLchDatReq
2178 (
2179 RguLchDatReq *param,
2180 Buffer *mBuf
2181 )
2182 #else
2183 PUBLIC S16 cmPkRguLchDatReq(param, mBuf)
2184 RguLchDatReq *param;
2185 Buffer *mBuf;
2186 #endif
2187 {
2188
2189    TRC3(cmPkRguLchDatReq);
2190
2191 #ifdef L2_OPTMZ
2192    CMCHKPK(SPkU8, param->freeBuff, mBuf);
2193 #endif
2194    CMCHKPK(SPkU8, param->setMaxUlPrio, mBuf);
2195    CMCHKPK(cmPkRguPduInfo, &param->pdu, mBuf);
2196    CMCHKPK(cmPkRguDBoReport, &param->boReport, mBuf);
2197    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2198    RETVALUE(ROK);
2199 }
2200
2201
2202 \f
2203 /***********************************************************
2204 *
2205 *     Func : cmUnpkRguLchDatReq
2206 *
2207 *
2208 *     Desc : RguLchDatReq
2209  * DatReq Information of a logical channel
2210 *
2211 *
2212 *     Ret  : S16
2213 *
2214 *     Notes:
2215 *
2216 *     File  :
2217 *
2218 **********************************************************/
2219 #ifdef ANSI
2220 PUBLIC S16 cmUnpkRguLchDatReq
2221 (
2222 RguLchDatReq *param,
2223 Buffer *mBuf
2224 )
2225 #else
2226 PUBLIC S16 cmUnpkRguLchDatReq(param, mBuf)
2227 RguLchDatReq *param;
2228 Buffer *mBuf;
2229 #endif
2230 {
2231
2232    TRC3(cmUnpkRguLchDatReq);
2233
2234    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
2235    CMCHKUNPK(cmUnpkRguDBoReport, &param->boReport, mBuf);
2236    CMCHKUNPK(cmUnpkRguPduInfo, &param->pdu, mBuf);
2237    CMCHKUNPK(SUnpkU8, &param->setMaxUlPrio, mBuf);
2238 #ifdef L2_OPTMZ
2239    CMCHKUNPK(SUnpkU8, &param->freeBuff, mBuf);
2240 #endif
2241    RETVALUE(ROK);
2242 }
2243
2244 \f
2245 /***********************************************************
2246 *
2247 *     Func : cmPkRguDatReqTb
2248 *
2249 *
2250 *     Desc : RguDatReqTb
2251 * DatReq from RLC to MAC for dedicated channels of a UE
2252 *
2253 *
2254 *     Ret  : S16
2255 *
2256 *     Notes:
2257 *
2258 *     File  :
2259 *
2260 **********************************************************/
2261 #ifdef ANSI
2262 PUBLIC S16 cmPkRguDatReqTb
2263 (
2264 RguDatReqTb *param,
2265 Buffer *mBuf
2266 )
2267 #else
2268 PUBLIC S16 cmPkRguDatReqTb(param, mBuf)
2269 RguDatReqTb *param;
2270 Buffer *mBuf;
2271 #endif
2272 {
2273    S32 i;
2274
2275    TRC3(cmPkRguDatReqTb);
2276    /*rgu_c_001.main_5 - ADD - L2M Support */
2277 #ifdef LTE_L2_MEAS
2278    CMCHKPK(SPkU32, param->tbId, mBuf);
2279 #endif
2280    for (i=param->nmbLch-1; i >= 0; i--) {
2281       CMCHKPK(cmPkRguLchDatReq, &param->lchData[i], mBuf);
2282    }
2283    CMCHKPK(SPkU8, param->nmbLch, mBuf);
2284    RETVALUE(ROK);
2285 }
2286
2287
2288 \f
2289 /***********************************************************
2290 *
2291 *     Func : cmUnpkRguDatReqTb
2292 *
2293 *
2294 *     Desc : RguDatReqTb
2295  * DatReq from RLC to MAC for dedicated channels of a UE
2296 *
2297 *
2298 *     Ret  : S16
2299 *
2300 *     Notes:
2301 *
2302 *     File  :
2303 *
2304 **********************************************************/
2305 #ifdef LTE_L2_MEAS
2306 #ifdef ANSI
2307 PUBLIC S16 cmUnpkRguDatReqTb
2308 (
2309 Pst         *pst,
2310 RguDatReqTb *param,
2311 Buffer *mBuf
2312 )
2313 #else
2314 PUBLIC S16 cmUnpkRguDatReqTb(pst, param, mBuf)
2315 Pst         *pst;
2316 RguDatReqTb *param;
2317 Buffer *mBuf;
2318 #endif
2319 #else
2320 #ifdef ANSI
2321 PUBLIC S16 cmUnpkRguDatReqTb
2322 (
2323 RguDatReqTb *param,
2324 Buffer *mBuf
2325 )
2326 #else
2327 PUBLIC S16 cmUnpkRguDatReqTb(param, mBuf)
2328 RguDatReqTb *param;
2329 Buffer *mBuf;
2330 #endif
2331 #endif
2332 {
2333    S32 i;
2334
2335    TRC3(cmUnpkRguDatReqTb);
2336
2337    CMCHKUNPK(SUnpkU8, &param->nmbLch, mBuf);
2338    for (i=0; i<param->nmbLch; i++) {
2339       CMCHKUNPK(cmUnpkRguLchDatReq, &param->lchData[i], mBuf);
2340    }
2341    /*rgu_c_001.main_5 - ADD - L2M Support */
2342 #ifdef LTE_L2_MEAS
2343    CMCHKUNPK(SUnpkU32, &param->tbId, mBuf);
2344 #endif
2345    RETVALUE(ROK);
2346 }
2347
2348 \f
2349 /***********************************************************
2350 *
2351 *     Func : cmPkRguDDatReqInfo
2352 *
2353 *
2354 *     Desc : RguDDatReqInfo
2355  * DatReq from RLC to MAC for dedicated channels of a UE
2356 *
2357 *
2358 *     Ret  : S16
2359 *
2360 *     Notes:
2361 *
2362 *     File  :
2363 *
2364 **********************************************************/
2365    /*rgu_c_001.main_5 - ADD - L2M Support */
2366 #ifdef LTE_L2_MEAS
2367 #ifdef ANSI
2368 PUBLIC S16 cmPkRguDDatReqInfo
2369 (
2370 Pst            *pst,
2371 RguDDatReqInfo *param,
2372 Buffer *mBuf
2373 )
2374 #else
2375 PUBLIC S16 cmPkRguDDatReqInfo(pst, param, mBuf)
2376 Pst            *pst;
2377 RguDDatReqInfo *param;
2378 Buffer *mBuf;
2379 #endif
2380 #else
2381 #ifdef ANSI
2382 PUBLIC S16 cmPkRguDDatReqInfo
2383 (
2384 RguDDatReqInfo *param,
2385 Buffer *mBuf
2386 )
2387 #else
2388 PUBLIC S16 cmPkRguDDatReqInfo(param, mBuf)
2389 RguDDatReqInfo *param;
2390 Buffer *mBuf;
2391 #endif
2392 #endif
2393 {
2394    S32 i;
2395    S32 idx;
2396
2397    TRC3(cmPkRguDDatReqInfo);
2398
2399    for(idx = (param->nmbOfUeGrantPerTti-1); idx >= 0; idx--)
2400    {
2401       RguDDatReqPerUe *datReq = &param->datReq[idx];
2402       for (i=RGU_MAX_TB-1; i >= 0; i--)
2403       {
2404          CMCHKPK(cmPkRguDatReqTb, &datReq->datReqTb[i], mBuf);
2405       }
2406       CMCHKPK(SPkU8, datReq->nmbOfTbs, mBuf);
2407       CMCHKPK(SPkU32, datReq->transId, mBuf);
2408       CMCHKPK(cmPkLteRnti, datReq->rnti, mBuf);
2409    }
2410    CMCHKPK(SPkU8, param->nmbOfUeGrantPerTti, mBuf);
2411    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2412    RETVALUE(ROK);
2413 }
2414
2415
2416 \f
2417 /***********************************************************
2418 *
2419 *     Func : cmUnpkRguDDatReqInfo
2420 *
2421 *
2422 *     Desc : RguDDatReqInfo
2423  * DatReq from RLC to MAC for dedicated channels of a UE
2424 *
2425 *
2426 *     Ret  : S16
2427 *
2428 *     Notes:
2429 *
2430 *     File  :
2431 *
2432 **********************************************************/
2433 #ifdef LTE_L2_MEAS
2434 #ifdef ANSI
2435 PUBLIC S16 cmUnpkRguDDatReqInfo
2436 (
2437 Pst            *pst,
2438 RguDDatReqInfo *param,
2439 Buffer *mBuf
2440 )
2441 #else
2442 PUBLIC S16 cmUnpkRguDDatReqInfo(pst, param, mBuf)
2443 Pst            *pst;
2444 RguDDatReqInfo *param;
2445 Buffer *mBuf;
2446 #endif
2447 #else
2448 #ifdef ANSI
2449 PUBLIC S16 cmUnpkRguDDatReqInfo
2450 (
2451 RguDDatReqInfo *param,
2452 Buffer *mBuf
2453 )
2454 #else
2455 PUBLIC S16 cmUnpkRguDDatReqInfo(param, mBuf)
2456 RguDDatReqInfo *param;
2457 Buffer *mBuf;
2458 #endif
2459 #endif
2460 {
2461    S32 i;
2462   /* After Merging from 2.1 to 2.2 */
2463    /*rgu_c_001.main_5 - ADD - L2M Support */
2464 #ifdef LTE_L2_MEAS
2465    S16 retVal;
2466 #endif
2467    S32 idx;
2468
2469    TRC3(cmUnpkRguDDatReqInfo);
2470
2471   /* After Merging from 2.1 to 2.2 */
2472    /*rgu_c_001.main_5 - ADD - L2M Support */
2473 #ifdef LTE_L2_MEAS
2474    retVal = ROK;
2475 #endif
2476    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2477    CMCHKUNPK(SUnpkU8, &param->nmbOfUeGrantPerTti, mBuf);
2478    for(idx = 0; idx < param->nmbOfUeGrantPerTti; idx++)
2479    {
2480       RguDDatReqPerUe *datReq = &param->datReq[idx];
2481       CMCHKUNPK(cmUnpkLteRnti, &datReq->rnti, mBuf);
2482       CMCHKUNPK(SUnpkU32, &datReq->transId, mBuf);
2483       CMCHKUNPK(SUnpkU8, &datReq->nmbOfTbs, mBuf);
2484       /* rgu_c_001.main_4 - Changes for MIMO feature addition */
2485       for (i=0; i<RGU_MAX_TB; i++)
2486       {
2487          /*rgu_c_001.main_5 - ADD - L2M Support */
2488 #ifdef LTE_L2_MEAS
2489          /* After Merging from 2.1 to 2.2 */
2490          retVal = cmUnpkRguDatReqTb(pst, &datReq->datReqTb[i], mBuf);
2491          if(retVal != ROK)
2492          {
2493             RETVALUE(RFAILED);
2494          }
2495 #else
2496          CMCHKUNPK(cmUnpkRguDatReqTb, &datReq->datReqTb[i], mBuf);
2497 #endif
2498       }
2499    }
2500    RETVALUE(ROK);
2501 }
2502
2503
2504 \f
2505 /***********************************************************
2506 *
2507 *     Func : cmPkRguCDatIndInfo
2508 *
2509 *
2510 *     Desc : RguCDatIndInfo
2511  * DatInd from MAC to RLC on CCCH
2512 *
2513 *
2514 *     Ret  : S16
2515 *
2516 *     Notes:
2517 *
2518 *     File  :
2519 *
2520 **********************************************************/
2521 #ifdef ANSI
2522 PUBLIC S16 cmPkRguCDatIndInfo
2523 (
2524 RguCDatIndInfo *param,
2525 Buffer *mBuf
2526 )
2527 #else
2528 PUBLIC S16 cmPkRguCDatIndInfo(param, mBuf)
2529 RguCDatIndInfo *param;
2530 Buffer *mBuf;
2531 #endif
2532 {
2533    MsgLen msgLen;
2534
2535    TRC3(cmPkRguCDatIndInfo);
2536
2537    if (SFndLenMsg(param->pdu, &msgLen) != ROK)
2538       RETVALUE(RFAILED);
2539    if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
2540       RETVALUE(RFAILED);
2541    SPutMsg(param->pdu);
2542    CMCHKPK(cmPkMsgLen, msgLen, mBuf);
2543    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2544    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
2545    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2546    RETVALUE(ROK);
2547 }
2548
2549
2550 \f
2551 /***********************************************************
2552 *
2553 *     Func : cmUnpkRguCDatIndInfo
2554 *
2555 *
2556 *     Desc : RguCDatIndInfo
2557  * DatInd from MAC to RLC on CCCH
2558 *
2559 *
2560 *     Ret  : S16
2561 *
2562 *     Notes:
2563 *
2564 *     File  :
2565 *
2566 **********************************************************/
2567 #ifdef ANSI
2568 PUBLIC S16 cmUnpkRguCDatIndInfo
2569 (
2570 RguCDatIndInfo *param,
2571 Buffer *mBuf
2572 )
2573 #else
2574 PUBLIC S16 cmUnpkRguCDatIndInfo(param, mBuf)
2575 RguCDatIndInfo *param;
2576 Buffer *mBuf;
2577 #endif
2578 {
2579    MsgLen msgLen, totalMsgLen;
2580
2581    TRC3(cmUnpkRguCDatIndInfo);
2582
2583    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2584    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
2585    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
2586    CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
2587    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
2588       RETVALUE(RFAILED);
2589    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
2590       RETVALUE(RFAILED);
2591    RETVALUE(ROK);
2592 }
2593
2594
2595 \f
2596 /***********************************************************
2597 *
2598 *     Func : cmPkRguLchDatInd
2599 *
2600 *
2601 *     Desc : RguLchDatInd
2602  * DatInd Information for a logical channel
2603 *
2604 *
2605 *     Ret  : S16
2606 *
2607 *     Notes:
2608 *
2609 *     File  :
2610 *
2611 **********************************************************/
2612 #ifdef ANSI
2613 PUBLIC S16 cmPkRguLchDatInd
2614 (
2615 RguLchDatInd *param,
2616 Buffer *mBuf
2617 )
2618 #else
2619 PUBLIC S16 cmPkRguLchDatInd(param, mBuf)
2620 RguLchDatInd *param;
2621 Buffer *mBuf;
2622 #endif
2623 {
2624    TRC3(cmPkRguLchDatInd);
2625
2626       CMCHKPK(cmPkRguPduInfo, &param->pdu, mBuf);
2627    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2628    RETVALUE(ROK);
2629 }
2630
2631
2632 \f
2633 /***********************************************************
2634 *
2635 *     Func : cmUnpkRguLchDatInd
2636 *
2637 *
2638 *     Desc : RguLchDatInd
2639  * DatInd Information for a logical channel
2640 *
2641 *
2642 *     Ret  : S16
2643 *
2644 *     Notes:
2645 *
2646 *     File  :
2647 *
2648 **********************************************************/
2649 #ifdef ANSI
2650 PUBLIC S16 cmUnpkRguLchDatInd
2651 (
2652 RguLchDatInd *param,
2653 Buffer *mBuf
2654 )
2655 #else
2656 PUBLIC S16 cmUnpkRguLchDatInd(param, mBuf)
2657 RguLchDatInd *param;
2658 Buffer *mBuf;
2659 #endif
2660 {
2661    TRC3(cmUnpkRguLchDatInd);
2662
2663    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
2664    CMCHKUNPK(cmUnpkRguPduInfo, &param->pdu, mBuf);
2665    RETVALUE(ROK);
2666 }
2667
2668
2669 \f
2670 /***********************************************************
2671 *
2672 *     Func : packRlcMacDataInfo
2673 *
2674 *
2675 *     Desc : RlcMacData
2676  * Data Indication from MAC to RLC for dedicated channels of a UE
2677 *
2678 *
2679 *     Ret  : S16
2680 *
2681 *     Notes:
2682 *
2683 *     File  :
2684 *
2685 **********************************************************/
2686 #ifdef ANSI
2687 PUBLIC S16 packRlcMacDataInfo
2688 (
2689 RlcMacData *param,
2690 Buffer *mBuf
2691 )
2692 #else
2693 PUBLIC S16 packRlcMacDataInfo(param, mBuf)
2694 RlcMacData *param;
2695 Buffer *mBuf;
2696 #endif
2697 {
2698    S32 i;
2699    MsgLen msgLen;
2700
2701    TRC3(packRlcMacDataInfo);
2702
2703    for (i=param->nmbPdu-1; i >= 0; i--)
2704    {
2705       msgLen = 0;
2706       if (SFndLenMsg(param->pduInfo[i].pduBuf, &msgLen) != ROK)
2707          RETVALUE(RFAILED);
2708       if (SCatMsg(mBuf, param->pduInfo[i].pduBuf, M1M2) != ROK)
2709           RETVALUE(RFAILED);
2710       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
2711       CMCHKPK(cmPkLteLcId, param->pduInfo[i].lcId, mBuf);
2712       CMCHKPK(cmPkBool, param->pduInfo[i].commCh, mBuf);
2713    }
2714    CMCHKPK(SPkU8, param->nmbPdu, mBuf);
2715    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
2716    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2717    CMCHKPK(cmPkLteTimingInfo, &param->timeToTx, mBuf);
2718    RETVALUE(ROK);
2719 }
2720
2721
2722 \f
2723 /***********************************************************
2724 *
2725 *     Func : unpackRlcMacDataInfo
2726 *
2727 *
2728 *     Desc : RlcMacData
2729  * Data Indication from MAC to RLC for dedicated channels of a UE
2730 *
2731 *
2732 *     Ret  : S16
2733 *
2734 *     Notes:
2735 *
2736 *     File  :
2737 *
2738 **********************************************************/
2739 #ifdef ANSI
2740 PUBLIC S16 unpackRlcMacDataInfo
2741 (
2742 RlcMacData *param,
2743 Buffer *mBuf
2744 )
2745 #else
2746 PUBLIC S16 unpackRlcMacDataInfo(param, mBuf)
2747 RlcMacData *param;
2748 Buffer *mBuf;
2749 #endif
2750 {
2751    S32 i;
2752
2753    TRC3(unpackRlcMacDataInfo);
2754
2755    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timeToTx, mBuf);
2756    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2757    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
2758    CMCHKUNPK(SUnpkU8, &param->nmbPdu, mBuf);
2759    for (i=0; i<param->nmbPdu; i++)
2760    {
2761       MsgLen totalMsgLen;
2762
2763       CMCHKUNPK(cmUnpkBool, &param->pduInfo[i].commCh, mBuf);
2764       CMCHKUNPK(cmUnpkLteLcId, &param->pduInfo[i].lcId, mBuf);
2765       CMCHKUNPK(cmUnpkMsgLen, &param->pduInfo[i].pduLen, mBuf);
2766       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
2767          RETVALUE(RFAILED);
2768       if (SSegMsg(mBuf, totalMsgLen-param->pduInfo[i].pduLen, &param->pduInfo[i].pduBuf) != ROK)
2769          RETVALUE(RFAILED);
2770    }
2771    RETVALUE(ROK);
2772 }
2773
2774 \f
2775 /***********************************************************
2776 *
2777 *     Func : cmPkRguCStaRspInfo
2778 *
2779 *
2780 *     Desc : RguCStaRspInfo
2781  * Status Response from RLC to MAC  for common logical channel
2782 *
2783 *
2784 *     Ret  : S16
2785 *
2786 *     Notes:
2787 *
2788 *     File  :
2789 *
2790 **********************************************************/
2791 #ifdef ANSI
2792 PUBLIC S16 cmPkRguCStaRspInfo
2793 (
2794 RguCStaRspInfo *param,
2795 Buffer *mBuf
2796 )
2797 #else
2798 PUBLIC S16 cmPkRguCStaRspInfo(param, mBuf)
2799 RguCStaRspInfo *param;
2800 Buffer *mBuf;
2801 #endif
2802 {
2803
2804    TRC3(cmPkRguCStaRspInfo);
2805
2806    switch(param->lcType) {
2807       case CM_LTE_LCH_CCCH:
2808          CMCHKPK(cmPkLteRnti, param->u.rnti, mBuf);
2809          break;
2810       case CM_LTE_LCH_BCCH:
2811       case CM_LTE_LCH_PCCH:
2812          CMCHKPK(cmPkLteTimingInfo, &param->u.timeToTx, mBuf);
2813 #ifdef EMTC_ENABLE
2814          CMCHKPK(SPkU8,param->pnb,mBuf);
2815          CMCHKPK(SPkU8,param->emtcDiReason,mBuf);
2816 #endif
2817          break;
2818       default :
2819          RETVALUE(RFAILED);
2820    }
2821    CMCHKPK(SPkS32, param->bo, mBuf);
2822    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
2823    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2824    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2825    RETVALUE(ROK);
2826 }
2827
2828
2829 \f
2830 /***********************************************************
2831 *
2832 *     Func : cmUnpkRguCStaRspInfo
2833 *
2834 *
2835 *     Desc : RguCStaRspInfo
2836  * Status Response from RLC to MAC  for common logical channel
2837 *
2838 *
2839 *     Ret  : S16
2840 *
2841 *     Notes:
2842 *
2843 *     File  :
2844 *
2845 **********************************************************/
2846 #ifdef ANSI
2847 PUBLIC S16 cmUnpkRguCStaRspInfo
2848 (
2849 RguCStaRspInfo *param,
2850 Buffer *mBuf
2851 )
2852 #else
2853 PUBLIC S16 cmUnpkRguCStaRspInfo(param, mBuf)
2854 RguCStaRspInfo *param;
2855 Buffer *mBuf;
2856 #endif
2857 {
2858
2859    TRC3(cmUnpkRguCStaRspInfo);
2860
2861    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2862    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
2863    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
2864    CMCHKUNPK(SUnpkS32, &param->bo, mBuf);
2865    switch(param->lcType) {
2866       case CM_LTE_LCH_BCCH:
2867       case CM_LTE_LCH_PCCH:
2868 #ifdef EMTC_ENABLE
2869          CMCHKUNPK(SUnpkU8,&param->emtcDiReason , mBuf);
2870          CMCHKUNPK(SUnpkU8,&param->pnb , mBuf);
2871 #endif
2872          CMCHKUNPK(cmUnpkLteTimingInfo, &param->u.timeToTx, mBuf);
2873          break;
2874       case CM_LTE_LCH_CCCH:
2875          CMCHKUNPK(cmUnpkLteRnti, &param->u.rnti, mBuf);
2876          break;
2877       default :
2878          RETVALUE(RFAILED);
2879    }
2880    RETVALUE(ROK);
2881 }
2882
2883
2884 \f
2885 /***********************************************************
2886 *
2887 *     Func : packBOStatusInfo
2888 *
2889 *
2890 *     Desc : RlcMacBOStatus
2891  * Status Response from RLC to MAC  for dedicated logical channel
2892 *
2893 *
2894 *     Ret  : S16
2895 *
2896 *     Notes:
2897 *
2898 *     File  :
2899 *
2900 **********************************************************/
2901 #ifdef ANSI
2902 PUBLIC S16 packBOStatusInfo
2903 (
2904 RlcMacBOStatus *param,
2905 Buffer *mBuf
2906 )
2907 #else
2908 PUBLIC S16 packBOStatusInfo(param, mBuf)
2909 RlcMacBOStatus *param;
2910 Buffer *mBuf;
2911 #endif
2912 {
2913
2914    TRC3(packBOStatusInfo);
2915
2916    CMCHKPK(SPkS32, param->bo, mBuf);
2917    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2918    CMCHKPK(cmPkBool, param->commCh, mBuf);
2919    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
2920    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2921    RETVALUE(ROK);
2922 } /* End of packBOStatusInfo */
2923
2924
2925 \f
2926 /***********************************************************
2927 *
2928 *     Func : unpackBOStatusInfo
2929 *
2930 *
2931 *     Desc : RlcMacBOStatus
2932  * Status Response from RLC to MAC  for dedicated logical channel
2933 *
2934 *
2935 *     Ret  : S16
2936 *
2937 *     Notes:
2938 *
2939 *     File  :
2940 *
2941 **********************************************************/
2942 #ifdef ANSI
2943 PUBLIC S16 unpackBOStatusInfo
2944 (
2945 RlcMacBOStatus *param,
2946 Buffer *mBuf
2947 )
2948 #else
2949 PUBLIC S16 unpackBOStatusInfo(param, mBuf)
2950 RlcMacBOStatus *param;
2951 Buffer *mBuf;
2952 #endif
2953 {
2954
2955    TRC3(unpackBOStatusInfo);
2956
2957    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2958    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
2959    CMCHKUNPK(cmUnpkBool, &param->commCh, mBuf);
2960    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
2961    CMCHKUNPK(SUnpkS32, &param->bo, mBuf);
2962    RETVALUE(ROK);
2963 } /* End of unpackBOStatusInfo */
2964
2965 \f
2966 /***********************************************************
2967 *
2968 *     Func : cmPkRguLchStaInd
2969 *
2970 *
2971 *     Desc : RguLchStaInd
2972  * StaInd info for each logical channel of a UE
2973 *
2974 *
2975 *     Ret  : S16
2976 *
2977 *     Notes:
2978 *
2979 *     File  :
2980 *
2981 **********************************************************/
2982 #ifdef ANSI
2983 PUBLIC S16 cmPkRguLchStaInd
2984 (
2985 RguLchStaInd *param,
2986 Buffer *mBuf
2987 )
2988 #else
2989 PUBLIC S16 cmPkRguLchStaInd(param, mBuf)
2990 RguLchStaInd *param;
2991 Buffer *mBuf;
2992 #endif
2993 {
2994
2995    TRC3(cmPkRguLchStaInd);
2996
2997    CMCHKPK(SPkS16, param->totBufSize, mBuf);
2998    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
2999    RETVALUE(ROK);
3000 }
3001
3002
3003 \f
3004 /***********************************************************
3005 *
3006 *     Func : cmUnpkRguLchStaInd
3007 *
3008 *
3009 *     Desc : RguLchStaInd
3010  * StaInd info for each logical channel of a UE
3011 *
3012 *
3013 *     Ret  : S16
3014 *
3015 *     Notes:
3016 *
3017 *     File  :
3018 *
3019 **********************************************************/
3020 #ifdef ANSI
3021 PUBLIC S16 cmUnpkRguLchStaInd
3022 (
3023 RguLchStaInd *param,
3024 Buffer *mBuf
3025 )
3026 #else
3027 PUBLIC S16 cmUnpkRguLchStaInd(param, mBuf)
3028 RguLchStaInd *param;
3029 Buffer *mBuf;
3030 #endif
3031 {
3032
3033    TRC3(cmUnpkRguLchStaInd);
3034
3035    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
3036    CMCHKUNPK(SUnpkS16, &param->totBufSize, mBuf);
3037    RETVALUE(ROK);
3038 }
3039
3040 \f
3041 /***********************************************************
3042 *
3043 *     Func : cmPkRguStaIndTb
3044 *
3045 *
3046 *     Desc : RguStaIndTb
3047 * StaInd from RLC to MAC for dedicated channels of a UE
3048 *
3049 *
3050 *     Ret  : S16
3051 *
3052 *     Notes:
3053 *
3054 *     File  :
3055 *
3056 **********************************************************/
3057 #ifdef ANSI
3058 PUBLIC S16 cmPkRguStaIndTb
3059 (
3060 RguStaIndTb *param,
3061 Buffer *mBuf
3062 )
3063 #else
3064 PUBLIC S16 cmPkRguStaIndTb(param, mBuf)
3065 RguStaIndTb *param;
3066 Buffer *mBuf;
3067 #endif
3068 {
3069    S32 i;
3070
3071    TRC3(cmPkRguStaIndTb);
3072
3073 #ifdef LTE_L2_MEAS
3074    CMCHKPK(SPkU16, param->status, mBuf);
3075    CMCHKPK(SPkU32, param->tbId, mBuf);
3076 #endif
3077    for (i=param->nmbLch-1; i >= 0; i--) {
3078       CMCHKPK(cmPkRguLchStaInd, &param->lchStaInd[i], mBuf);
3079    }
3080    CMCHKPK(SPkU8, param->nmbLch, mBuf);
3081    RETVALUE(ROK);
3082 }
3083
3084
3085 \f
3086 /***********************************************************
3087 *
3088 *     Func : cmUnpkRguStaIndTb
3089 *
3090 *
3091 *     Desc : RguStaIndTb
3092 * StaInd from RLC to MAC for dedicated channels of a UE
3093 *
3094 *
3095 *     Ret  : S16
3096 *
3097 *     Notes:
3098 *
3099 *     File  :
3100 *
3101 **********************************************************/
3102 #ifdef ANSI
3103 PUBLIC S16 cmUnpkRguStaIndTb
3104 (
3105 RguStaIndTb *param,
3106 Buffer *mBuf
3107 )
3108 #else
3109 PUBLIC S16 cmUnpkRguStaIndTb(param, mBuf)
3110 RguStaIndTb *param;
3111 Buffer *mBuf;
3112 #endif
3113 {
3114    S32 i;
3115
3116    TRC3(cmUnpkRguStaIndTb);
3117
3118    CMCHKUNPK(SUnpkU8, &param->nmbLch, mBuf);
3119    for (i=0; i<param->nmbLch; i++) {
3120       CMCHKUNPK(cmUnpkRguLchStaInd, &param->lchStaInd[i], mBuf);
3121    }
3122 #ifdef LTE_L2_MEAS
3123    CMCHKUNPK(SUnpkU32, &param->tbId, mBuf);
3124    CMCHKUNPK(SUnpkU16, &param->status, mBuf);
3125 #endif
3126    RETVALUE(ROK);
3127 }
3128
3129 \f
3130 /***********************************************************
3131 *
3132 *     Func : packSchedRepInfo
3133 *
3134 *
3135 *     Desc : RlcMacSchedRep
3136  * StaInd from MAC to RLC for dedicated logical channels of a UE
3137 *
3138 *
3139 *     Ret  : S16
3140 *
3141 *     Notes:
3142 *
3143 *     File  :
3144 *
3145 **********************************************************/
3146 #ifdef ANSI
3147 PUBLIC S16 packSchedRepInfo
3148 (
3149 RlcMacSchedRep *param,
3150 Buffer *mBuf
3151 )
3152 #else
3153 PUBLIC S16 packSchedRepInfo(param, mBuf)
3154 RlcMacSchedRep *param;
3155 Buffer *mBuf;
3156 #endif
3157 {
3158    S32 idx;
3159
3160    TRC3(packSchedRepInfo);
3161
3162    for(idx = (param->nmbLch-1); idx >= 0; idx--)
3163    {
3164       CMCHKPK(cmPkRguLchStaInd, &param->lchSta[idx].lchStaInd, mBuf);
3165       CMCHKPK(cmPkBool, param->lchSta[idx].commCh, mBuf);
3166    }
3167    CMCHKPK(SPkU8, param->nmbLch, mBuf);
3168    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
3169    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
3170    CMCHKPK(cmPkLteTimingInfo, &param->timeToTx, mBuf);
3171
3172    RETVALUE(ROK);
3173 } /* End of packSchedRepInfo */
3174
3175
3176 \f
3177 /***********************************************************
3178 *
3179 *     Func : unpackSchedRepInfo
3180 *
3181 *
3182 *     Desc : RlcMacSchedRep
3183  * StaInd from MAC to RLC for dedicated logical channels of a UE
3184 *
3185 *
3186 *     Ret  : S16
3187 *
3188 *     Notes:
3189 *
3190 *     File  :
3191 *
3192 **********************************************************/
3193 #ifdef ANSI
3194 PUBLIC S16 unpackSchedRepInfo
3195 (
3196 RlcMacSchedRep *param,
3197 Buffer *mBuf
3198 )
3199 #else
3200 PUBLIC S16 unpackSchedRepInfo(param, mBuf)
3201 RlcMacSchedRep *param;
3202 Buffer *mBuf;
3203 #endif
3204 {
3205    S32 idx;
3206
3207    TRC3(unpackSchedRepInfo);
3208
3209    CMCHKUNPK(cmUnpkLteTimingInfo, &param->timeToTx, mBuf);
3210    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
3211    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
3212    CMCHKUNPK(SUnpkU8, &param->nmbLch, mBuf);
3213    for(idx = 0; idx < param->nmbLch; idx++)
3214    {
3215       CMCHKUNPK(cmUnpkBool, &param->lchSta[idx].commCh, mBuf);
3216       CMCHKUNPK(cmUnpkRguLchStaInd, &param->lchSta[idx].lchStaInd, mBuf);
3217    }
3218
3219    RETVALUE(ROK);
3220 } /* End of unpackSchedRepInfo */
3221
3222 #endif
3223
3224 /**********************************************************************
3225          End of file
3226 **********************************************************************/