src/cm/crg.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18 \f
  19
  20 /************************************************************************
  21
  22      Name:     LTE-MAC layer
  23
  24      Type:     C source file
  25
  26      Desc:     C source code for pack/unpack of CRG interface primitives.
  27
  28      File:     crg.c
  29
  30 **********************************************************************/
  31
  32 /** @file crg.c
  33 @brief This file contains the packing/unpacking code for the CRG interface
  34        primitives.
  35 */
  36 /* header include files (.h) */
  37 #include "common_def.h"
  38 #include "crg.h"           /* CRG Interface defines */
  39
  40 /* header/extern include files (.x) */
  41 #include "crg.x"           /* CRG Interface includes */
  42
  43 #ifdef LCCRG
  44 \f
  45 /**
  46 * @brief Request from RRC to MAC to bind the interface saps
  47 *
  48 * @details
  49 *
  50 *     Function : cmPkCrgBndReq
  51 *
  52 *  @param[in]   Pst*  pst
  53 *  @param[in]   SuId  suId
  54 *  @param[in]   SpId  spId
  55 *  @return   S16
  56 *      -# ROK
  57 **/
  58 #ifdef ANSI
  59 PUBLIC S16 cmPkCrgBndReq
  60 (
  61 Pst* pst,
  62 SuId suId,
  63 SpId spId
  64 )
  65 #else
  66 PUBLIC S16 cmPkCrgBndReq(pst, suId, spId)
  67 Pst* pst;
  68 SuId suId;
  69 SpId spId;
  70 #endif
  71 {
  72    Buffer *mBuf = NULLP;
  73    TRC3(cmPkCrgBndReq)
  74
  75    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
  76 #if (ERRCLASS & ERRCLS_ADD_RES)
  77       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  78          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  79          (ErrVal)ECRG001, (ErrVal)0, "Packing failed");
  80 #endif
  81       RETVALUE(RFAILED);
  82    }
  83    if (SPkS16(spId, mBuf) != ROK) {
  84 #if (ERRCLASS & ERRCLS_ADD_RES)
  85       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  86          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  87          (ErrVal)ECRG002, (ErrVal)0, "Packing failed");
  88 #endif
  89       SPutMsg(mBuf);
  90       RETVALUE(RFAILED);
  91    }
  92    if (SPkS16(suId, mBuf) != ROK) {
  93 #if (ERRCLASS & ERRCLS_ADD_RES)
  94       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  95          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  96          (ErrVal)ECRG003, (ErrVal)0, "Packing failed");
  97 #endif
  98       SPutMsg(mBuf);
  99       RETVALUE(RFAILED);
 100    }
 101    pst->event = (Event) EVTCRGBNDREQ;
 102    RETVALUE(SPstTsk(pst,mBuf));
 103 }
 104
 105 \f
 106 /**
 107 * @brief Request from RRC to MAC to bind the interface saps
 108 *
 109 * @details
 110 *
 111 *     Function : cmUnpkCrgBndReq
 112 *
 113 *  @param[in]   Pst*  pst
 114 *  @param[in]   SuId  suId
 115 *  @param[in]   SpId  spId
 116 *  @return   S16
 117 *      -# ROK
 118 **/
 119 #ifdef ANSI
 120 PUBLIC S16 cmUnpkCrgBndReq
 121 (
 122 CrgBndReq func,
 123 Pst *pst,
 124 Buffer *mBuf
 125 )
 126 #else
 127 PUBLIC S16 cmUnpkCrgBndReq(func, pst, mBuf)
 128 CrgBndReq func;
 129 Pst *pst;
 130 Buffer *mBuf;
 131 #endif
 132 {
 133    SuId suId;
 134    SpId spId;
 135
 136    TRC3(cmUnpkCrgBndReq)
 137
 138    if (SUnpkS16(&suId, mBuf) != ROK) {
 139       SPutMsg(mBuf);
 140 #if (ERRCLASS & ERRCLS_ADD_RES)
 141       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 142          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 143          (ErrVal)ECRG004, (ErrVal)0, "Packing failed");
 144 #endif
 145       RETVALUE(RFAILED);
 146    }
 147    if (SUnpkS16(&spId, mBuf) != ROK) {
 148       SPutMsg(mBuf);
 149 #if (ERRCLASS & ERRCLS_ADD_RES)
 150       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 151          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 152          (ErrVal)ECRG005, (ErrVal)0, "Packing failed");
 153 #endif
 154       RETVALUE(RFAILED);
 155    }
 156    SPutMsg(mBuf);
 157    RETVALUE((*func)(pst, suId, spId));
 158 }
 159
 160 \f
 161 /**
 162 * @brief Confirmation from MAC to RRC for the bind/Unbind
 163  * request for the interface saps
 164 *
 165 * @details
 166 *
 167 *     Function : cmPkCrgBndCfm
 168 *
 169 *  @param[in]   Pst*  pst
 170 *  @param[in]   SuId  suId
 171 *  @param[in]   U8  status
 172 *  @return   S16
 173 *      -# ROK
 174 **/
 175 #ifdef ANSI
 176 PUBLIC S16 cmPkCrgBndCfm
 177 (
 178 Pst* pst,
 179 SuId suId,
 180 U8 status
 181 )
 182 #else
 183 PUBLIC S16 cmPkCrgBndCfm(pst, suId, status)
 184 Pst* pst;
 185 SuId suId;
 186 U8 status;
 187 #endif
 188 {
 189    Buffer *mBuf = NULLP;
 190    TRC3(cmPkCrgBndCfm)
 191
 192    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 193 #if (ERRCLASS & ERRCLS_ADD_RES)
 194       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 195          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 196          (ErrVal)ECRG006, (ErrVal)0, "Packing failed");
 197 #endif
 198       RETVALUE(RFAILED);
 199    }
 200    if (SPkU8(status, mBuf) != ROK) {
 201 #if (ERRCLASS & ERRCLS_ADD_RES)
 202       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 203          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 204          (ErrVal)ECRG007, (ErrVal)0, "Packing failed");
 205 #endif
 206       SPutMsg(mBuf);
 207       RETVALUE(RFAILED);
 208    }
 209    if (SPkS16(suId, mBuf) != ROK) {
 210 #if (ERRCLASS & ERRCLS_ADD_RES)
 211       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 212          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 213          (ErrVal)ECRG008, (ErrVal)0, "Packing failed");
 214 #endif
 215       SPutMsg(mBuf);
 216       RETVALUE(RFAILED);
 217    }
 218    pst->event = (Event) EVTCRGBNDCFM;
 219    RETVALUE(SPstTsk(pst,mBuf));
 220 }
 221
 222 \f
 223 /**
 224 * @brief Confirmation from MAC to RRC for the bind/Unbind
 225  * request for the interface saps
 226 *
 227 * @details
 228 *
 229 *     Function : cmUnpkCrgBndCfm
 230 *
 231 *  @param[in]   Pst*  pst
 232 *  @param[in]   SuId  suId
 233 *  @param[in]   U8  status
 234 *  @return   S16
 235 *      -# ROK
 236 **/
 237 #ifdef ANSI
 238 PUBLIC S16 cmUnpkCrgBndCfm
 239 (
 240 CrgBndCfm func,
 241 Pst *pst,
 242 Buffer *mBuf
 243 )
 244 #else
 245 PUBLIC S16 cmUnpkCrgBndCfm(func, pst, mBuf)
 246 CrgBndCfm func;
 247 Pst *pst;
 248 Buffer *mBuf;
 249 #endif
 250 {
 251    SuId suId;
 252    U8 status;
 253
 254    TRC3(cmUnpkCrgBndCfm)
 255
 256    if (SUnpkS16(&suId, mBuf) != ROK) {
 257       SPutMsg(mBuf);
 258 #if (ERRCLASS & ERRCLS_ADD_RES)
 259       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 260          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 261          (ErrVal)ECRG009, (ErrVal)0, "Packing failed");
 262 #endif
 263       RETVALUE(RFAILED);
 264    }
 265    if (SUnpkU8(&status, mBuf) != ROK) {
 266       SPutMsg(mBuf);
 267 #if (ERRCLASS & ERRCLS_ADD_RES)
 268       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 269          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 270          (ErrVal)ECRG010, (ErrVal)0, "Packing failed");
 271 #endif
 272       RETVALUE(RFAILED);
 273    }
 274    SPutMsg(mBuf);
 275    RETVALUE((*func)(pst, suId, status));
 276 }
 277
 278 \f
 279 /**
 280 * @brief Request from RRC to MAC to Unbind the interface saps
 281 *
 282 * @details
 283 *
 284 *     Function : cmPkCrgUbndReq
 285 *
 286 *  @param[in]   Pst*  pst
 287 *  @param[in]   SpId  spId
 288 *  @param[in]   Reason  reason
 289 *  @return   S16
 290 *      -# ROK
 291 **/
 292 #ifdef ANSI
 293 PUBLIC S16 cmPkCrgUbndReq
 294 (
 295 Pst* pst,
 296 SpId spId,
 297 Reason reason
 298 )
 299 #else
 300 PUBLIC S16 cmPkCrgUbndReq(pst, spId, reason)
 301 Pst* pst;
 302 SpId spId;
 303 Reason reason;
 304 #endif
 305 {
 306    Buffer *mBuf = NULLP;
 307    TRC3(cmPkCrgUbndReq)
 308
 309    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 310 #if (ERRCLASS & ERRCLS_ADD_RES)
 311       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 312          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 313          (ErrVal)ECRG011, (ErrVal)0, "Packing failed");
 314 #endif
 315       RETVALUE(RFAILED);
 316    }
 317    if (SPkS16(reason, mBuf) != ROK) {
 318 #if (ERRCLASS & ERRCLS_ADD_RES)
 319       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 320          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 321          (ErrVal)ECRG012, (ErrVal)0, "Packing failed");
 322 #endif
 323       SPutMsg(mBuf);
 324       RETVALUE(RFAILED);
 325    }
 326    if (SPkS16(spId, mBuf) != ROK) {
 327 #if (ERRCLASS & ERRCLS_ADD_RES)
 328       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 329          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 330          (ErrVal)ECRG013, (ErrVal)0, "Packing failed");
 331 #endif
 332       SPutMsg(mBuf);
 333       RETVALUE(RFAILED);
 334    }
 335    pst->event = (Event) EVTCRGUBNDREQ;
 336    RETVALUE(SPstTsk(pst,mBuf));
 337 }
 338
 339 \f
 340 /**
 341 * @brief Request from RRC to MAC to Unbind the interface saps
 342 *
 343 * @details
 344 *
 345 *     Function : cmUnpkCrgUbndReq
 346 *
 347 *  @param[in]   Pst*  pst
 348 *  @param[in]   SpId  spId
 349 *  @param[in]   Reason  reason
 350 *  @return   S16
 351 *      -# ROK
 352 **/
 353 #ifdef ANSI
 354 PUBLIC S16 cmUnpkCrgUbndReq
 355 (
 356 CrgUbndReq func,
 357 Pst *pst,
 358 Buffer *mBuf
 359 )
 360 #else
 361 PUBLIC S16 cmUnpkCrgUbndReq(func, pst, mBuf)
 362 CrgUbndReq func;
 363 Pst *pst;
 364 Buffer *mBuf;
 365 #endif
 366 {
 367    SpId spId;
 368    Reason reason;
 369
 370    TRC3(cmUnpkCrgUbndReq)
 371
 372    if (SUnpkS16(&spId, mBuf) != ROK) {
 373       SPutMsg(mBuf);
 374 #if (ERRCLASS & ERRCLS_ADD_RES)
 375       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 376          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 377          (ErrVal)ECRG014, (ErrVal)0, "Packing failed");
 378 #endif
 379       RETVALUE(RFAILED);
 380    }
 381    if (SUnpkS16(&reason, mBuf) != ROK) {
 382       SPutMsg(mBuf);
 383 #if (ERRCLASS & ERRCLS_ADD_RES)
 384       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 385          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 386          (ErrVal)ECRG015, (ErrVal)0, "Packing failed");
 387 #endif
 388       RETVALUE(RFAILED);
 389    }
 390    SPutMsg(mBuf);
 391    RETVALUE((*func)(pst, spId, reason));
 392 }
 393
 394 \f
 395 /**
 396 * @brief Configuration Request from RRC to MAC for
 397  * configuring Cell/Ue/Lc
 398 *
 399 * @details
 400 *
 401 *     Function : cmPkCrgCfgReq
 402 *
 403 *  @param[in]   Pst*  pst
 404 *  @param[in]   SpId  spId
 405 *  @param[in]   CrgCfgTransId  transId
 406 *  @param[in]   CrgCfgReqInfo  *  cfgReqInfo
 407 *  @return   S16
 408 *      -# ROK
 409 **/
 410 #ifdef ANSI
 411 PUBLIC S16 cmPkCrgCfgReq
 412 (
 413 Pst* pst,
 414 SpId spId,
 415 CrgCfgTransId transId,
 416 CrgCfgReqInfo  * cfgReqInfo
 417 )
 418 #else
 419 PUBLIC S16 cmPkCrgCfgReq(pst, spId, transId, cfgReqInfo)
 420 Pst* pst;
 421 SpId spId;
 422 CrgCfgTransId transId;
 423 CrgCfgReqInfo  * cfgReqInfo;
 424 #endif
 425 {
 426    Buffer *mBuf = NULLP;
 427    TRC3(cmPkCrgCfgReq)
 428
 429    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 430 #if (ERRCLASS & ERRCLS_ADD_RES)
 431       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 432          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 433          (ErrVal)ECRG016, (ErrVal)0, "Packing failed");
 434 #endif
 435       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
 436       RETVALUE(RFAILED);
 437    }
 438    if (cmPkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
 439 #if (ERRCLASS & ERRCLS_ADD_RES)
 440       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 441          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 442          (ErrVal)ECRG017, (ErrVal)0, "Packing failed");
 443 #endif
 444       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
 445       SPutMsg(mBuf);
 446       RETVALUE(RFAILED);
 447    }
 448 /* crg_c_001.main_5: MOD - Updating ERR code */
 449    if (cmPkCrgCfgTransId(&transId, mBuf) != ROK) {
 450 #if (ERRCLASS & ERRCLS_ADD_RES)
 451       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 452          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 453          (ErrVal)ECRG018, (ErrVal)0, "Packing failed");
 454 #endif
 455       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
 456       SPutMsg(mBuf);
 457       RETVALUE(RFAILED);
 458    }
 459    if (SPkS16(spId, mBuf) != ROK) {
 460 #if (ERRCLASS & ERRCLS_ADD_RES)
 461       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 462          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 463          (ErrVal)ECRG019, (ErrVal)0, "Packing failed");
 464 #endif
 465       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
 466       SPutMsg(mBuf);
 467       RETVALUE(RFAILED);
 468    }
 469    if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo)) != ROK) {
 470 #if (ERRCLASS & ERRCLS_ADD_RES)
 471       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 472          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 473          (ErrVal)ECRG020, (ErrVal)0, "Packing failed");
 474 #endif
 475       SPutMsg(mBuf);
 476       RETVALUE(RFAILED);
 477    }
 478    pst->event = (Event) EVTCRGCFGREQ;
 479    RETVALUE(SPstTsk(pst,mBuf));
 480 }
 481
 482 \f
 483 /**
 484 * @brief Configuration Request from RRC to MAC for
 485  * configuring Cell/Ue/Lc
 486 *
 487 * @details
 488 *
 489 *     Function : cmUnpkCrgCfgReq
 490 *
 491 *  @param[in]   Pst*  pst
 492 *  @param[in]   SpId  spId
 493 *  @param[in]   CrgCfgTransId  transId
 494 *  @param[in]   CrgCfgReqInfo  *  cfgReqInfo
 495 *  @return   S16
 496 *      -# ROK
 497 **/
 498 #ifdef ANSI
 499 PUBLIC S16 cmUnpkCrgCfgReq
 500 (
 501 CrgCfgReq func,
 502 Pst *pst,
 503 Buffer *mBuf
 504 )
 505 #else
 506 PUBLIC S16 cmUnpkCrgCfgReq(func, pst, mBuf)
 507 CrgCfgReq func;
 508 Pst *pst;
 509 Buffer *mBuf;
 510 #endif
 511 {
 512    SpId spId;
 513    CrgCfgTransId transId;
 514    CrgCfgReqInfo *cfgReqInfo;
 515
 516    TRC3(cmUnpkCrgCfgReq)
 517
 518    if (SUnpkS16(&spId, mBuf) != ROK) {
 519       SPutMsg(mBuf);
 520 #if (ERRCLASS & ERRCLS_ADD_RES)
 521       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 522          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 523          (ErrVal)ECRG021, (ErrVal)0, "Packing failed");
 524 #endif
 525       RETVALUE(RFAILED);
 526    }
 527    if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
 528       SPutMsg(mBuf);
 529 #if (ERRCLASS & ERRCLS_ADD_RES)
 530       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 531          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 532          (ErrVal)ECRG022, (ErrVal)0, "Packing failed");
 533 #endif
 534       RETVALUE(RFAILED);
 535    }
 536    if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CrgCfgReqInfo))) != ROK) {
 537 #if (ERRCLASS & ERRCLS_ADD_RES)
 538       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 539          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 540          (ErrVal)ECRG023, (ErrVal)0, "Packing failed");
 541 #endif
 542       SPutMsg(mBuf);
 543       RETVALUE(RFAILED);
 544    }
 545
 546    if (cmUnpkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
 547       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
 548       SPutMsg(mBuf);
 549 #if (ERRCLASS & ERRCLS_ADD_RES)
 550       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 551          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 552          (ErrVal)ECRG024, (ErrVal)0, "Packing failed");
 553 #endif
 554       RETVALUE(RFAILED);
 555    }
 556    SPutMsg(mBuf);
 557    RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
 558 }
 559
 560 \f
 561 /**
 562 * @brief Configuration Confirm from MAC to RRC
 563 *
 564 * @details
 565 *
 566 *     Function : cmPkCrgCfgCfm
 567 *
 568 *  @param[in]   Pst*  pst
 569 *  @param[in]   SuId  suId
 570 *  @param[in]   CrgCfgTransId  transId
 571 *  @param[in]   U8  status
 572 *  @return   S16
 573 *      -# ROK
 574 **/
 575 #ifdef ANSI
 576 PUBLIC S16 cmPkCrgCfgCfm
 577 (
 578 Pst* pst,
 579 SuId suId,
 580 CrgCfgTransId transId,
 581 U8 status
 582 )
 583 #else
 584 PUBLIC S16 cmPkCrgCfgCfm(pst, suId, transId, status)
 585 Pst* pst;
 586 SuId suId;
 587 CrgCfgTransId transId;
 588 U8 status;
 589 #endif
 590 {
 591    Buffer *mBuf = NULLP;
 592    TRC3(cmPkCrgCfgCfm)
 593
 594    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 595 #if (ERRCLASS & ERRCLS_ADD_RES)
 596       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 597          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 598          (ErrVal)ECRG025, (ErrVal)0, "Packing failed");
 599 #endif
 600       RETVALUE(RFAILED);
 601    }
 602 /* crg_c_001.main_5 - ADD - Added the packing for status. */
 603    if (SPkU8(status, mBuf) != ROK) {
 604 #if (ERRCLASS & ERRCLS_ADD_RES)
 605       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 606          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 607          (ErrVal)ECRG026, (ErrVal)0, "Packing failed");
 608 #endif
 609       SPutMsg(mBuf);
 610       RETVALUE(RFAILED);
 611    }
 612    if (cmPkCrgCfgTransId(&transId, mBuf) != ROK) {
 613 #if (ERRCLASS & ERRCLS_ADD_RES)
 614       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 615          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 616          (ErrVal)ECRG027, (ErrVal)0, "Packing failed");
 617 #endif
 618       SPutMsg(mBuf);
 619       RETVALUE(RFAILED);
 620    }
 621    if (SPkS16(suId, mBuf) != ROK) {
 622 #if (ERRCLASS & ERRCLS_ADD_RES)
 623       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 624          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 625          (ErrVal)ECRG028, (ErrVal)0, "Packing failed");
 626 #endif
 627       SPutMsg(mBuf);
 628       RETVALUE(RFAILED);
 629    }
 630    pst->event = (Event) EVTCRGCFGCFM;
 631    RETVALUE(SPstTsk(pst,mBuf));
 632 }
 633
 634 \f
 635 /**
 636 * @brief Configuration Confirm from MAC to RRC
 637 *
 638 * @details
 639 *
 640 *     Function : cmUnpkCrgCfgCfm
 641 *
 642 *  @param[in]   Pst*  pst
 643 *  @param[in]   SuId  suId
 644 *  @param[in]   CrgCfgTransId  transId
 645 *  @param[in]   U8  status
 646 *  @return   S16
 647 *      -# ROK
 648 **/
 649 #ifdef ANSI
 650 PUBLIC S16 cmUnpkCrgCfgCfm
 651 (
 652 CrgCfgCfm func,
 653 Pst *pst,
 654 Buffer *mBuf
 655 )
 656 #else
 657 PUBLIC S16 cmUnpkCrgCfgCfm(func, pst, mBuf)
 658 CrgCfgCfm func;
 659 Pst *pst;
 660 Buffer *mBuf;
 661 #endif
 662 {
 663    SuId suId;
 664    CrgCfgTransId transId;
 665    U8 status;
 666
 667    TRC3(cmUnpkCrgCfgCfm)
 668
 669    if (SUnpkS16(&suId, mBuf) != ROK) {
 670       SPutMsg(mBuf);
 671 #if (ERRCLASS & ERRCLS_ADD_RES)
 672       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 673          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 674          (ErrVal)ECRG029, (ErrVal)0, "Packing failed");
 675 #endif
 676       RETVALUE(RFAILED);
 677    }
 678    if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
 679       SPutMsg(mBuf);
 680 #if (ERRCLASS & ERRCLS_ADD_RES)
 681       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 682          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 683          (ErrVal)ECRG030, (ErrVal)0, "Packing failed");
 684 #endif
 685       RETVALUE(RFAILED);
 686    }
 687    if (SUnpkU8(&status, mBuf) != ROK) {
 688       SPutMsg(mBuf);
 689 #if (ERRCLASS & ERRCLS_ADD_RES)
 690       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 691          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 692          (ErrVal)ECRG031, (ErrVal)0, "Packing failed");
 693 #endif
 694       RETVALUE(RFAILED);
 695    }
 696    SPutMsg(mBuf);
 697    RETVALUE((*func)(pst, suId, transId, status));
 698 }
 699
 700 \f
 701 /***********************************************************
 702 *
 703 *     Func : cmPkCrgCfgTransId
 704 *
 705 *
 706 *     Desc : Transaction ID between MAC and RRC
 707 *
 708 *
 709 *     Ret  : S16
 710 *
 711 *     Notes:
 712 *
 713 *     File  :
 714 *
 715 **********************************************************/
 716 #ifdef ANSI
 717 PUBLIC S16 cmPkCrgCfgTransId
 718 (
 719 CrgCfgTransId *param,
 720 Buffer *mBuf
 721 )
 722 #else
 723 PUBLIC S16 cmPkCrgCfgTransId(param, mBuf)
 724 CrgCfgTransId *param;
 725 Buffer *mBuf;
 726 #endif
 727 {
 728
 729    S32 i;
 730    TRC3(cmPkCrgCfgTransId)
 731
 732    for (i=CRG_CFG_TRANSID_SIZE-1; i >= 0; i--) {
 733       CMCHKPK(SPkU8, param->trans[i], mBuf);
 734    }
 735    RETVALUE(ROK);
 736 }
 737
 738
 739 \f
 740 /***********************************************************
 741 *
 742 *     Func : cmUnpkCrgCfgTransId
 743 *
 744 *
 745 *     Desc : Transaction ID between MAC and RRC
 746 *
 747 *
 748 *     Ret  : S16
 749 *
 750 *     Notes:
 751 *
 752 *     File  :
 753 *
 754 **********************************************************/
 755 #ifdef ANSI
 756 PUBLIC S16 cmUnpkCrgCfgTransId
 757 (
 758 CrgCfgTransId *param,
 759 Buffer *mBuf
 760 )
 761 #else
 762 PUBLIC S16 cmUnpkCrgCfgTransId(param, mBuf)
 763 CrgCfgTransId *param;
 764 Buffer *mBuf;
 765 #endif
 766 {
 767
 768    S32 i;
 769    TRC3(cmUnpkCrgCfgTransId)
 770
 771    for (i=0; i<CRG_CFG_TRANSID_SIZE; i++) {
 772       CMCHKUNPK(SUnpkU8, &param->trans[i], mBuf);
 773    }
 774    RETVALUE(ROK);
 775 }
 776
 777
 778 \f
 779 /***********************************************************
 780 *
 781 *     Func : cmPkCrgBwCfg
 782 *
 783 *
 784 *     Desc : Bandwidth configuration per cell
 785 *
 786 *
 787 *     Ret  : S16
 788 *
 789 *     Notes:
 790 *
 791 *     File  :
 792 *
 793 **********************************************************/
 794 #ifdef ANSI
 795 PUBLIC S16 cmPkCrgBwCfg
 796 (
 797 CrgBwCfg *param,
 798 Buffer *mBuf
 799 )
 800 #else
 801 PUBLIC S16 cmPkCrgBwCfg(param, mBuf)
 802 CrgBwCfg *param;
 803 Buffer *mBuf;
 804 #endif
 805 {
 806
 807    TRC3(cmPkCrgBwCfg)
 808
 809    CMCHKPK(SPkU8, param->ulTotalBw, mBuf);
 810    CMCHKPK(SPkU8, param->dlTotalBw, mBuf);
 811    RETVALUE(ROK);
 812 }
 813
 814
 815 \f
 816 /***********************************************************
 817 *
 818 *     Func : cmUnpkCrgBwCfg
 819 *
 820 *
 821 *     Desc : Bandwidth configuration per cell
 822 *
 823 *
 824 *     Ret  : S16
 825 *
 826 *     Notes:
 827 *
 828 *     File  :
 829 *
 830 **********************************************************/
 831 #ifdef ANSI
 832 PUBLIC S16 cmUnpkCrgBwCfg
 833 (
 834 CrgBwCfg *param,
 835 Buffer *mBuf
 836 )
 837 #else
 838 PUBLIC S16 cmUnpkCrgBwCfg(param, mBuf)
 839 CrgBwCfg *param;
 840 Buffer *mBuf;
 841 #endif
 842 {
 843
 844    TRC3(cmUnpkCrgBwCfg)
 845
 846    CMCHKUNPK(SUnpkU8, &param->dlTotalBw, mBuf);
 847    CMCHKUNPK(SUnpkU8, &param->ulTotalBw, mBuf);
 848    RETVALUE(ROK);
 849 }
 850
 851
 852 \f
 853 /***********************************************************
 854 *
 855 *     Func : cmPkCrgRachCfg
 856 *
 857 *
 858 *     Desc : RACH configuration per cell
 859 *
 860 *
 861 *     Ret  : S16
 862 *
 863 *     Notes:
 864 *
 865 *     File  :
 866 *
 867 **********************************************************/
 868 #ifdef ANSI
 869 PUBLIC S16 cmPkCrgRachCfg
 870 (
 871 CrgRachCfg *param,
 872 Buffer *mBuf
 873 )
 874 #else
 875 PUBLIC S16 cmPkCrgRachCfg(param, mBuf)
 876 CrgRachCfg *param;
 877 Buffer *mBuf;
 878 #endif
 879 {
 880
 881    TRC3(cmPkCrgRachCfg)
 882
 883    CMCHKPK(SPkU8, param->maxMsg3Tx, mBuf);
 884    RETVALUE(ROK);
 885 }
 886
 887
 888 \f
 889 /***********************************************************
 890 *
 891 *     Func : cmUnpkCrgRachCfg
 892 *
 893 *
 894 *     Desc : RACH configuration per cell
 895 *
 896 *
 897 *     Ret  : S16
 898 *
 899 *     Notes:
 900 *
 901 *     File  :
 902 *
 903 **********************************************************/
 904 #ifdef ANSI
 905 PUBLIC S16 cmUnpkCrgRachCfg
 906 (
 907 CrgRachCfg *param,
 908 Buffer *mBuf
 909 )
 910 #else
 911 PUBLIC S16 cmUnpkCrgRachCfg(param, mBuf)
 912 CrgRachCfg *param;
 913 Buffer *mBuf;
 914 #endif
 915 {
 916
 917    TRC3(cmUnpkCrgRachCfg)
 918
 919    CMCHKUNPK(SUnpkU8, &param->maxMsg3Tx, mBuf);
 920    RETVALUE(ROK);
 921 }
 922
 923
 924 \f
 925 /***********************************************************
 926 *
 927 *     Func : cmPkCrgCellCfg
 928 *
 929 *
 930 *     Desc : Cell configuration
 931 *
 932 *
 933 *     Ret  : S16
 934 *
 935 *     Notes:
 936 *
 937 *     File  :
 938 *
 939 **********************************************************/
 940 #ifdef ANSI
 941 PUBLIC S16 cmPkCrgCellCfg
 942 (
 943 CrgCellCfg *param,
 944 Buffer *mBuf
 945 )
 946 #else
 947 PUBLIC S16 cmPkCrgCellCfg(param, mBuf)
 948 CrgCellCfg *param;
 949 Buffer *mBuf;
 950 #endif
 951 {
 952
 953    TRC3(cmPkCrgCellCfg)
 954
 955 #ifdef EMTC_ENABLE
 956    CMCHKPK(SPkU8, param->emtcEnable, mBuf);
 957 #endif
 958 #ifdef TENB_MULT_CELL_SUPPRT
 959    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
 960    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
 961 #endif
 962    CMCHKPK(cmPkCrgBwCfg, &param->bwCfg, mBuf);
 963    CMCHKPK(cmPkCrgRachCfg, &param->rachCfg, mBuf);
 964    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
 965    RETVALUE(ROK);
 966 }
 967
 968
 969 \f
 970 /***********************************************************
 971 *
 972 *     Func : cmUnpkCrgCellCfg
 973 *
 974 *
 975 *     Desc : Cell configuration
 976 *
 977 *
 978 *     Ret  : S16
 979 *
 980 *     Notes:
 981 *
 982 *     File  :
 983 *
 984 **********************************************************/
 985 #ifdef ANSI
 986 PUBLIC S16 cmUnpkCrgCellCfg
 987 (
 988 CrgCellCfg *param,
 989 Buffer *mBuf
 990 )
 991 #else
 992 PUBLIC S16 cmUnpkCrgCellCfg(param, mBuf)
 993 CrgCellCfg *param;
 994 Buffer *mBuf;
 995 #endif
 996 {
 997
 998    TRC3(cmUnpkCrgCellCfg)
 999
1000    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1001    CMCHKUNPK(cmUnpkCrgRachCfg, &param->rachCfg, mBuf);
1002    CMCHKUNPK(cmUnpkCrgBwCfg, &param->bwCfg, mBuf);
1003 #ifdef TENB_MULT_CELL_SUPPRT
1004    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
1005    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
1006 #endif
1007 #ifdef EMTC_ENABLE
1008    CMCHKUNPK(SUnpkU8, &param->emtcEnable, mBuf);
1009 #endif
1010    RETVALUE(ROK);
1011 }
1012
1013
1014 \f
1015 /***********************************************************
1016 *
1017 *     Func : cmPkCrgUeUlHqCfg
1018 *
1019 *
1020 *     Desc : Uplink HARQ configuration per UE
1021 *
1022 *
1023 *     Ret  : S16
1024 *
1025 *     Notes:
1026 *
1027 *     File  :
1028 *
1029 **********************************************************/
1030 #ifdef ANSI
1031 PUBLIC S16 cmPkCrgUeUlHqCfg
1032 (
1033 CrgUeUlHqCfg *param,
1034 Buffer *mBuf
1035 )
1036 #else
1037 PUBLIC S16 cmPkCrgUeUlHqCfg(param, mBuf)
1038 CrgUeUlHqCfg *param;
1039 Buffer *mBuf;
1040 #endif
1041 {
1042
1043    TRC3(cmPkCrgUeUlHqCfg)
1044
1045    CMCHKPK(SPkU8, param->maxUlHqTx, mBuf);
1046    RETVALUE(ROK);
1047 }
1048
1049 #ifdef LTE_ADV
1050 /***********************************************************
1051 *
1052 *     Func : cmPkCrgUeSCellCfg
1053 *
1054 *
1055 *     Desc : Secondary Cell information of the UE
1056 *
1057 *
1058 *     Ret  : S16
1059 *
1060 *     Notes:
1061 *
1062 *     File  :
1063 *
1064 **********************************************************/
1065 #ifdef ANSI
1066 PRIVATE S16 cmPkCrgUeSCellCfg
1067 (
1068 CrgUeSCellInfo *param,
1069 Buffer *mBuf
1070 )
1071 #else
1072 PRIVATE S16 cmPkCrgUeSCellCfg(param, mBuf)
1073 CrgUeSCellInfo *param;
1074 Buffer *mBuf;
1075 #endif
1076 {
1077    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
1078    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
1079    CMCHKPK(SPkU8, param->macInst, mBuf);
1080    CMCHKPK(SPkU16, param->sCellId, mBuf);
1081
1082    RETVALUE(ROK);
1083 }
1084 /***********************************************************
1085 *
1086 *     Func : cmUnpkCrgUeSCellCfg
1087 *
1088 *
1089 *     Desc : Secondary Cell information of the UE
1090 *
1091 *
1092 *     Ret  : S16
1093 *
1094 *     Notes:
1095 *
1096 *     File  :
1097 *
1098 **********************************************************/
1099 #ifdef ANSI
1100 PRIVATE S16 cmUnpkCrgUeSCellCfg
1101 (
1102 CrgUeSCellInfo *param,
1103 Buffer *mBuf
1104 )
1105 #else
1106 PRIVATE S16 cmUnpkCrgUeSCellCfg(param, mBuf)
1107 CrgUeSCellInfo *param;
1108 Buffer *mBuf;
1109 #endif
1110 {
1111    CMCHKUNPK(SUnpkU16, &param->sCellId, mBuf);
1112    CMCHKUNPK(SUnpkU8, &param->macInst, mBuf);
1113    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
1114    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
1115    RETVALUE(ROK);
1116 }
1117 /***********************************************************
1118 *
1119 *     Func : cmPkCrgUeSecCellInfo
1120 *
1121 *
1122 *     Desc : Secondary Cell information of the UE
1123 *
1124 *
1125 *     Ret  : S16
1126 *
1127 *     Notes:
1128 *
1129 *     File  :
1130 *
1131 **********************************************************/
1132 #ifdef ANSI
1133 PUBLIC S16 cmPkCrgUeSecCellInfo
1134 (
1135 CrgUeSecCellInfo *param,
1136 Buffer *mBuf
1137 )
1138 #else
1139 PUBLIC S16 cmPkCrgUeSecCellInfo(param, mBuf)
1140 CrgUeSecCellInfo *param;
1141 Buffer *mBuf;
1142 #endif
1143 {
1144    S8 idx;
1145    for(idx = param->numSCells - 1; idx >= 0; idx--)
1146    {
1147       CMCHKPK(cmPkCrgUeSCellCfg, &param->ueSCellCfg[(U8)idx], mBuf);
1148    }
1149
1150    CMCHKPK(SPkU8, param->numSCells, mBuf);
1151    CMCHKPK(SPkU8, param->isSCellCfgPres, mBuf);
1152
1153    RETVALUE(ROK);
1154 }
1155
1156 /***********************************************************
1157 *
1158 *     Func : cmUnpkCrgUeSecCellInfo
1159 *
1160 *
1161 *     Desc : Secondary Cell information of the UE
1162 *
1163 *
1164 *     Ret  : S16
1165 *
1166 *     Notes:
1167 *
1168 *     File  :
1169 *
1170 **********************************************************/
1171 #ifdef ANSI
1172 PUBLIC S16 cmUnpkCrgUeSecCellInfo
1173 (
1174 CrgUeSecCellInfo *param,
1175 Buffer *mBuf
1176 )
1177 #else
1178 PUBLIC S16 cmUnpkCrgUeSecCellInfo(param, mBuf)
1179 CrgUeSecCellInfo *param;
1180 Buffer *mBuf;
1181 #endif
1182 {
1183    U8 idx;
1184
1185    CMCHKUNPK(SUnpkU8, &param->isSCellCfgPres, mBuf);
1186    if(TRUE == param->isSCellCfgPres)
1187    {
1188       CMCHKUNPK(SUnpkU8, &param->numSCells, mBuf);
1189
1190       for(idx = 0; idx < param->numSCells; idx++)
1191       {
1192          CMCHKUNPK(cmUnpkCrgUeSCellCfg, &param->ueSCellCfg[idx],mBuf);
1193       }
1194    }
1195
1196    RETVALUE(ROK);
1197 }
1198
1199 #endif /* LTE_ADV */
1200
1201 \f
1202 /***********************************************************
1203 *
1204 *     Func : cmUnpkCrgUeUlHqCfg
1205 *
1206 *
1207 *     Desc : Uplink HARQ configuration per UE
1208 *
1209 *
1210 *     Ret  : S16
1211 *
1212 *     Notes:
1213 *
1214 *     File  :
1215 *
1216 **********************************************************/
1217 #ifdef ANSI
1218 PUBLIC S16 cmUnpkCrgUeUlHqCfg
1219 (
1220 CrgUeUlHqCfg *param,
1221 Buffer *mBuf
1222 )
1223 #else
1224 PUBLIC S16 cmUnpkCrgUeUlHqCfg(param, mBuf)
1225 CrgUeUlHqCfg *param;
1226 Buffer *mBuf;
1227 #endif
1228 {
1229
1230    TRC3(cmUnpkCrgUeUlHqCfg)
1231
1232    CMCHKUNPK(SUnpkU8, &param->maxUlHqTx, mBuf);
1233    RETVALUE(ROK);
1234 }
1235
1236
1237 \f
1238 /***********************************************************
1239 *
1240 *     Func : cmPkCrgUeCfg
1241 *
1242 *
1243 *     Desc : UE configuration
1244 *
1245 *
1246 *     Ret  : S16
1247 *
1248 *     Notes:
1249 *
1250 *     File  :
1251 *
1252 **********************************************************/
1253 #ifdef ANSI
1254 PUBLIC S16 cmPkCrgUeCfg
1255 (
1256 CrgUeCfg *param,
1257 Buffer *mBuf
1258 )
1259 #else
1260 PUBLIC S16 cmPkCrgUeCfg(param, mBuf)
1261 CrgUeCfg *param;
1262 Buffer *mBuf;
1263 #endif
1264 {
1265
1266    TRC3(cmPkCrgUeCfg)
1267 #ifdef TENB_MULT_CELL_SUPPRT
1268    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
1269    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
1270 #endif
1271    CMCHKPK(SPkU32, param->txMode.tm, mBuf);
1272    CMCHKPK(SPkU8, param->txMode.pres, mBuf);
1273    CMCHKPK(cmPkCrgUeUlHqCfg, &param->ueUlHqCfg, mBuf);
1274    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
1275    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1276    RETVALUE(ROK);
1277 }
1278
1279
1280 \f
1281 /***********************************************************
1282 *
1283 *     Func : cmUnpkCrgUeCfg
1284 *
1285 *
1286 *     Desc : UE configuration
1287 *
1288 *
1289 *     Ret  : S16
1290 *
1291 *     Notes:
1292 *
1293 *     File  :
1294 *
1295 **********************************************************/
1296 #ifdef ANSI
1297 PUBLIC S16 cmUnpkCrgUeCfg
1298 (
1299 CrgUeCfg *param,
1300 Buffer *mBuf
1301 )
1302 #else
1303 PUBLIC S16 cmUnpkCrgUeCfg(param, mBuf)
1304 CrgUeCfg *param;
1305 Buffer *mBuf;
1306 #endif
1307 {
1308    U32 tmpEnum;
1309
1310    TRC3(cmUnpkCrgUeCfg)
1311
1312    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1313    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
1314    CMCHKUNPK(cmUnpkCrgUeUlHqCfg, &param->ueUlHqCfg, mBuf);
1315    CMCHKUNPK(SUnpkU8, &param->txMode.pres, mBuf);
1316    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
1317    param->txMode.tm = (CrgTxMode) tmpEnum;
1318 #ifdef TENB_MULT_CELL_SUPPRT
1319    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
1320    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
1321 #endif
1322    RETVALUE(ROK);
1323 }
1324
1325
1326 \f
1327 /***********************************************************
1328 *
1329 *     Func : cmPkCrgDlLchCfg
1330 *
1331 *
1332 *     Desc : Logical channel configuration info for downlink logical channels
1333 *
1334 *
1335 *     Ret  : S16
1336 *
1337 *     Notes:
1338 *
1339 *     File  :
1340 *
1341 **********************************************************/
1342 #ifdef ANSI
1343 PUBLIC S16 cmPkCrgDlLchCfg
1344 (
1345 CrgDlLchCfg *param,
1346 Buffer *mBuf
1347 )
1348 #else
1349 PUBLIC S16 cmPkCrgDlLchCfg(param, mBuf)
1350 CrgDlLchCfg *param;
1351 Buffer *mBuf;
1352 #endif
1353 {
1354
1355    TRC3(cmPkCrgDlLchCfg)
1356
1357    CMCHKPK(SPkU8, param->dlTrchType, mBuf);
1358    RETVALUE(ROK);
1359 }
1360
1361
1362 \f
1363 /***********************************************************
1364 *
1365 *     Func : cmUnpkCrgDlLchCfg
1366 *
1367 *
1368 *     Desc : Logical channel configuration info for downlink logical channels
1369 *
1370 *
1371 *     Ret  : S16
1372 *
1373 *     Notes:
1374 *
1375 *     File  :
1376 *
1377 **********************************************************/
1378 #ifdef ANSI
1379 PUBLIC S16 cmUnpkCrgDlLchCfg
1380 (
1381 CrgDlLchCfg *param,
1382 Buffer *mBuf
1383 )
1384 #else
1385 PUBLIC S16 cmUnpkCrgDlLchCfg(param, mBuf)
1386 CrgDlLchCfg *param;
1387 Buffer *mBuf;
1388 #endif
1389 {
1390
1391    TRC3(cmUnpkCrgDlLchCfg)
1392
1393    CMCHKUNPK(SUnpkU8, &param->dlTrchType, mBuf);
1394    RETVALUE(ROK);
1395 }
1396
1397
1398 \f
1399 /***********************************************************
1400 *
1401 *     Func : cmPkCrgUlLchCfg
1402 *
1403 *
1404 *     Desc : Logical channel configuration info for uplink logical channels
1405 *
1406 *
1407 *     Ret  : S16
1408 *
1409 *     Notes:
1410 *
1411 *     File  :
1412 *
1413 **********************************************************/
1414 #ifdef ANSI
1415 PUBLIC S16 cmPkCrgUlLchCfg
1416 (
1417 CrgUlLchCfg *param,
1418 Buffer *mBuf
1419 )
1420 #else
1421 PUBLIC S16 cmPkCrgUlLchCfg(param, mBuf)
1422 CrgUlLchCfg *param;
1423 Buffer *mBuf;
1424 #endif
1425 {
1426
1427    TRC3(cmPkCrgUlLchCfg)
1428
1429    CMCHKPK(SPkU8, param->lcgId, mBuf);
1430    CMCHKPK(SPkU8, param->ulTrchType, mBuf);
1431    RETVALUE(ROK);
1432 }
1433
1434
1435 \f
1436 /***********************************************************
1437 *
1438 *     Func : cmUnpkCrgUlLchCfg
1439 *
1440 *
1441 *     Desc : Logical channel configuration info for uplink logical channels
1442 *
1443 *
1444 *     Ret  : S16
1445 *
1446 *     Notes:
1447 *
1448 *     File  :
1449 *
1450 **********************************************************/
1451 #ifdef ANSI
1452 PUBLIC S16 cmUnpkCrgUlLchCfg
1453 (
1454 CrgUlLchCfg *param,
1455 Buffer *mBuf
1456 )
1457 #else
1458 PUBLIC S16 cmUnpkCrgUlLchCfg(param, mBuf)
1459 CrgUlLchCfg *param;
1460 Buffer *mBuf;
1461 #endif
1462 {
1463
1464    TRC3(cmUnpkCrgUlLchCfg)
1465
1466    CMCHKUNPK(SUnpkU8, &param->ulTrchType, mBuf);
1467    CMCHKUNPK(SUnpkU8, &param->lcgId, mBuf);
1468    RETVALUE(ROK);
1469 }
1470
1471
1472 \f
1473 /***********************************************************
1474 *
1475 *     Func : cmPkCrgLchCfg
1476 *
1477 *
1478 *     Desc : Logical channel configuration info for common and dedicated channels
1479 *
1480 *
1481 *     Ret  : S16
1482 *
1483 *     Notes:
1484 *
1485 *     File  :
1486 *
1487 **********************************************************/
1488 #ifdef ANSI
1489 PUBLIC S16 cmPkCrgLchCfg
1490 (
1491 CrgLchCfg *param,
1492 Buffer *mBuf
1493 )
1494 #else
1495 PUBLIC S16 cmPkCrgLchCfg(param, mBuf)
1496 CrgLchCfg *param;
1497 Buffer *mBuf;
1498 #endif
1499 {
1500
1501    TRC3(cmPkCrgLchCfg)
1502 /* crg_c_001.main_5 - ADD - Added the packing for LTE_L2_MEAS. */
1503 #ifdef LTE_L2_MEAS
1504    CMCHKPK(SPkU8, param->qci, mBuf);
1505 #endif
1506    CMCHKPK(cmPkCrgUlLchCfg, &param->ulInfo, mBuf);
1507    CMCHKPK(cmPkCrgDlLchCfg, &param->dlInfo, mBuf);
1508    CMCHKPK(SPkU8, param->dir, mBuf);
1509    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
1510    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1511    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
1512    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1513    RETVALUE(ROK);
1514 }
1515
1516
1517 \f
1518 /***********************************************************
1519 *
1520 *     Func : cmUnpkCrgLchCfg
1521 *
1522 *
1523 *     Desc : Logical channel configuration info for common and dedicated channels
1524 *
1525 *
1526 *     Ret  : S16
1527 *
1528 *     Notes:
1529 *
1530 *     File  :
1531 *
1532 **********************************************************/
1533 #ifdef ANSI
1534 PUBLIC S16 cmUnpkCrgLchCfg
1535 (
1536 CrgLchCfg *param,
1537 Buffer *mBuf
1538 )
1539 #else
1540 PUBLIC S16 cmUnpkCrgLchCfg(param, mBuf)
1541 CrgLchCfg *param;
1542 Buffer *mBuf;
1543 #endif
1544 {
1545
1546    TRC3(cmUnpkCrgLchCfg)
1547
1548    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1549    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
1550    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1551    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
1552    CMCHKUNPK(SUnpkU8, &param->dir, mBuf);
1553    CMCHKUNPK(cmUnpkCrgDlLchCfg, &param->dlInfo, mBuf);
1554    CMCHKUNPK(cmUnpkCrgUlLchCfg, &param->ulInfo, mBuf);
1555 /* crg_c_001.main_5 - ADD - Added the unpacking for LTE_L2_MEAS. */
1556 #ifdef LTE_L2_MEAS
1557    CMCHKUNPK(SUnpkU8, &param->qci, mBuf);
1558 #endif
1559    RETVALUE(ROK);
1560 }
1561
1562
1563 \f
1564 /***********************************************************
1565 *
1566 *     Func : cmPkCrgCfg
1567 *
1568 *
1569 *     Desc : Basic configuration info for MAC
1570 *
1571 *
1572 *     Ret  : S16
1573 *
1574 *     Notes:
1575 *
1576 *     File  :
1577 *
1578 **********************************************************/
1579 #ifdef ANSI
1580 PUBLIC S16 cmPkCrgCfg
1581 (
1582 CrgCfg *param,
1583 Buffer *mBuf
1584 )
1585 #else
1586 PUBLIC S16 cmPkCrgCfg(param, mBuf)
1587 CrgCfg *param;
1588 Buffer *mBuf;
1589 #endif
1590 {
1591
1592    TRC3(cmPkCrgCfg)
1593
1594       switch(param->cfgType) {
1595          case CRG_LCH_CFG:
1596             CMCHKPK(cmPkCrgLchCfg, &param->u.lchCfg, mBuf);
1597             break;
1598          case CRG_UE_CFG:
1599             CMCHKPK(cmPkCrgUeCfg, &param->u.ueCfg, mBuf);
1600             break;
1601          case CRG_CELL_CFG:
1602             CMCHKPK(cmPkCrgCellCfg, &param->u.cellCfg, mBuf);
1603             break;
1604          default :
1605             RETVALUE(RFAILED);
1606       }
1607    CMCHKPK(SPkU8, param->cfgType, mBuf);
1608    RETVALUE(ROK);
1609 }
1610
1611
1612 \f
1613 /***********************************************************
1614 *
1615 *     Func : cmUnpkCrgCfg
1616 *
1617 *
1618 *     Desc : Basic configuration info for MAC
1619 *
1620 *
1621 *     Ret  : S16
1622 *
1623 *     Notes:
1624 *
1625 *     File  :
1626 *
1627 **********************************************************/
1628 #ifdef ANSI
1629 PUBLIC S16 cmUnpkCrgCfg
1630 (
1631 CrgCfg *param,
1632 Buffer *mBuf
1633 )
1634 #else
1635 PUBLIC S16 cmUnpkCrgCfg(param, mBuf)
1636 CrgCfg *param;
1637 Buffer *mBuf;
1638 #endif
1639 {
1640
1641    TRC3(cmUnpkCrgCfg)
1642
1643    CMCHKUNPK(SUnpkU8, &param->cfgType, mBuf);
1644       switch(param->cfgType) {
1645          case CRG_CELL_CFG:
1646             CMCHKUNPK(cmUnpkCrgCellCfg, &param->u.cellCfg, mBuf);
1647             break;
1648          case CRG_UE_CFG:
1649             CMCHKUNPK(cmUnpkCrgUeCfg, &param->u.ueCfg, mBuf);
1650             break;
1651          case CRG_LCH_CFG:
1652             CMCHKUNPK(cmUnpkCrgLchCfg, &param->u.lchCfg, mBuf);
1653             break;
1654          default :
1655             RETVALUE(RFAILED);
1656       }
1657    RETVALUE(ROK);
1658 }
1659
1660
1661 \f
1662 /***********************************************************
1663 *
1664 *     Func : cmPkCrgCellRecfg
1665 *
1666 *
1667 *     Desc : Cell reconfiguration info
1668 *
1669 *
1670 *     Ret  : S16
1671 *
1672 *     Notes:
1673 *
1674 *     File  :
1675 *
1676 **********************************************************/
1677 #ifdef ANSI
1678 PUBLIC S16 cmPkCrgCellRecfg
1679 (
1680 CrgCellRecfg *param,
1681 Buffer *mBuf
1682 )
1683 #else
1684 PUBLIC S16 cmPkCrgCellRecfg(param, mBuf)
1685 CrgCellRecfg *param;
1686 Buffer *mBuf;
1687 #endif
1688 {
1689
1690    TRC3(cmPkCrgCellRecfg)
1691
1692    CMCHKPK(cmPkCrgRachCfg, &param->rachRecfg, mBuf);
1693    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1694    RETVALUE(ROK);
1695 }
1696
1697
1698 \f
1699 /***********************************************************
1700 *
1701 *     Func : cmUnpkCrgCellRecfg
1702 *
1703 *
1704 *     Desc : Cell reconfiguration info
1705 *
1706 *
1707 *     Ret  : S16
1708 *
1709 *     Notes:
1710 *
1711 *     File  :
1712 *
1713 **********************************************************/
1714 #ifdef ANSI
1715 PUBLIC S16 cmUnpkCrgCellRecfg
1716 (
1717 CrgCellRecfg *param,
1718 Buffer *mBuf
1719 )
1720 #else
1721 PUBLIC S16 cmUnpkCrgCellRecfg(param, mBuf)
1722 CrgCellRecfg *param;
1723 Buffer *mBuf;
1724 #endif
1725 {
1726
1727    TRC3(cmUnpkCrgCellRecfg)
1728
1729    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1730    CMCHKUNPK(cmUnpkCrgRachCfg, &param->rachRecfg, mBuf);
1731    RETVALUE(ROK);
1732 }
1733
1734
1735 \f
1736 /***********************************************************
1737 *
1738 *     Func : cmPkCrgUeRecfg
1739 *
1740 *
1741 *     Desc : UE reconfiguration info
1742 *
1743 *
1744 *     Ret  : S16
1745 *
1746 *     Notes:
1747 *
1748 *     File  :
1749 *
1750 **********************************************************/
1751 #ifdef ANSI
1752 PUBLIC S16 cmPkCrgUeRecfg
1753 (
1754 CrgUeRecfg *param,
1755 Buffer *mBuf
1756 )
1757 #else
1758 PUBLIC S16 cmPkCrgUeRecfg(param, mBuf)
1759 CrgUeRecfg *param;
1760 Buffer *mBuf;
1761 #endif
1762 {
1763
1764    TRC3(cmPkCrgUeRecfg)
1765 #ifdef LTE_ADV
1766    if(TRUE == param->crgSCellCfg.isSCellCfgPres)
1767    {
1768       CMCHKPK(cmPkCrgUeSecCellInfo, &param->crgSCellCfg, mBuf);
1769    }
1770    else
1771    {
1772       CMCHKPK(SPkU8, param->crgSCellCfg.isSCellCfgPres, mBuf);
1773    }
1774 #endif /* LTE_ADV */
1775    CMCHKPK(SPkU32, param->txMode.tm, mBuf);
1776    CMCHKPK(SPkU8, param->txMode.pres, mBuf);
1777    CMCHKPK(cmPkCrgUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
1778    CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
1779    CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
1780    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1781    RETVALUE(ROK);
1782 }
1783
1784
1785 \f
1786 /***********************************************************
1787 *
1788 *     Func : cmUnpkCrgUeRecfg
1789 *
1790 *
1791 *     Desc : UE reconfiguration info
1792 *
1793 *
1794 *     Ret  : S16
1795 *
1796 *     Notes:
1797 *
1798 *     File  :
1799 *
1800 **********************************************************/
1801 #ifdef ANSI
1802 PUBLIC S16 cmUnpkCrgUeRecfg
1803 (
1804 CrgUeRecfg *param,
1805 Buffer *mBuf
1806 )
1807 #else
1808 PUBLIC S16 cmUnpkCrgUeRecfg(param, mBuf)
1809 CrgUeRecfg *param;
1810 Buffer *mBuf;
1811 #endif
1812 {
1813
1814    TRC3(cmUnpkCrgUeRecfg)
1815
1816    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1817    CMCHKUNPK(cmUnpkLteRnti, &param->oldCrnti, mBuf);
1818    CMCHKUNPK(cmUnpkLteRnti, &param->newCrnti, mBuf);
1819    CMCHKUNPK(cmUnpkCrgUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
1820    CMCHKUNPK(SUnpkU8, &param->txMode.pres, mBuf);
1821    CMCHKUNPK(SUnpkU32, (U32 *)&param->txMode.tm, mBuf);
1822 #ifdef LTE_ADV
1823       CMCHKUNPK(cmUnpkCrgUeSecCellInfo, &param->crgSCellCfg, mBuf);
1824 #endif /* LTE_ADV */
1825    RETVALUE(ROK);
1826 }
1827
1828
1829 \f
1830 /***********************************************************
1831 *
1832 *     Func : cmPkCrgLchRecfg
1833 *
1834 *
1835 *     Desc : Logical channel reconfiguration info for dedicated channels only
1836 *
1837 *
1838 *     Ret  : S16
1839 *
1840 *     Notes:
1841 *
1842 *     File  :
1843 *
1844 **********************************************************/
1845 #ifdef ANSI
1846 PUBLIC S16 cmPkCrgLchRecfg
1847 (
1848 CrgLchRecfg *param,
1849 Buffer *mBuf
1850 )
1851 #else
1852 PUBLIC S16 cmPkCrgLchRecfg(param, mBuf)
1853 CrgLchRecfg *param;
1854 Buffer *mBuf;
1855 #endif
1856 {
1857
1858    TRC3(cmPkCrgLchRecfg)
1859
1860       CMCHKPK(SPkU8, param->ulRecfg.lcgId, mBuf);
1861    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1862    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
1863    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1864    RETVALUE(ROK);
1865 }
1866
1867
1868 \f
1869 /***********************************************************
1870 *
1871 *     Func : cmUnpkCrgLchRecfg
1872 *
1873 *
1874 *     Desc : Logical channel reconfiguration info for dedicated channels only
1875 *
1876 *
1877 *     Ret  : S16
1878 *
1879 *     Notes:
1880 *
1881 *     File  :
1882 *
1883 **********************************************************/
1884 #ifdef ANSI
1885 PUBLIC S16 cmUnpkCrgLchRecfg
1886 (
1887 CrgLchRecfg *param,
1888 Buffer *mBuf
1889 )
1890 #else
1891 PUBLIC S16 cmUnpkCrgLchRecfg(param, mBuf)
1892 CrgLchRecfg *param;
1893 Buffer *mBuf;
1894 #endif
1895 {
1896
1897    TRC3(cmUnpkCrgLchRecfg)
1898
1899    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1900    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
1901    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1902       CMCHKUNPK(SUnpkU8, &param->ulRecfg.lcgId, mBuf);
1903    RETVALUE(ROK);
1904 }
1905
1906
1907 \f
1908 /***********************************************************
1909 *
1910 *     Func : cmPkCrgRecfg
1911 *
1912 *
1913 *     Desc : Basic reconfiguration info for MAC
1914 *
1915 *
1916 *     Ret  : S16
1917 *
1918 *     Notes:
1919 *
1920 *     File  :
1921 *
1922 **********************************************************/
1923 #ifdef ANSI
1924 PUBLIC S16 cmPkCrgRecfg
1925 (
1926 CrgRecfg *param,
1927 Buffer *mBuf
1928 )
1929 #else
1930 PUBLIC S16 cmPkCrgRecfg(param, mBuf)
1931 CrgRecfg *param;
1932 Buffer *mBuf;
1933 #endif
1934 {
1935
1936    TRC3(cmPkCrgRecfg)
1937
1938       switch(param->recfgType) {
1939          case CRG_LCH_CFG:
1940             CMCHKPK(cmPkCrgLchRecfg, &param->u.lchRecfg, mBuf);
1941             break;
1942          case CRG_UE_CFG:
1943             CMCHKPK(cmPkCrgUeRecfg, &param->u.ueRecfg, mBuf);
1944             break;
1945          case CRG_CELL_CFG:
1946             CMCHKPK(cmPkCrgCellRecfg, &param->u.cellRecfg, mBuf);
1947             break;
1948          default :
1949             RETVALUE(RFAILED);
1950       }
1951    CMCHKPK(SPkU8, param->recfgType, mBuf);
1952    RETVALUE(ROK);
1953 }
1954
1955
1956 \f
1957 /***********************************************************
1958 *
1959 *     Func : cmUnpkCrgRecfg
1960 *
1961 *
1962 *     Desc : Basic reconfiguration info for MAC
1963 *
1964 *
1965 *     Ret  : S16
1966 *
1967 *     Notes:
1968 *
1969 *     File  :
1970 *
1971 **********************************************************/
1972 #ifdef ANSI
1973 PUBLIC S16 cmUnpkCrgRecfg
1974 (
1975 CrgRecfg *param,
1976 Buffer *mBuf
1977 )
1978 #else
1979 PUBLIC S16 cmUnpkCrgRecfg(param, mBuf)
1980 CrgRecfg *param;
1981 Buffer *mBuf;
1982 #endif
1983 {
1984
1985    TRC3(cmUnpkCrgRecfg)
1986
1987    CMCHKUNPK(SUnpkU8, &param->recfgType, mBuf);
1988       switch(param->recfgType) {
1989          case CRG_CELL_CFG:
1990             CMCHKUNPK(cmUnpkCrgCellRecfg, &param->u.cellRecfg, mBuf);
1991             break;
1992          case CRG_UE_CFG:
1993             CMCHKUNPK(cmUnpkCrgUeRecfg, &param->u.ueRecfg, mBuf);
1994             break;
1995          case CRG_LCH_CFG:
1996             CMCHKUNPK(cmUnpkCrgLchRecfg, &param->u.lchRecfg, mBuf);
1997             break;
1998          default :
1999             RETVALUE(RFAILED);
2000       }
2001    RETVALUE(ROK);
2002 }
2003
2004
2005 \f
2006 /***********************************************************
2007 *
2008 *     Func : cmPkCrgDel
2009 *
2010 *
2011 *     Desc : Basic Delete info for MAC
2012 *
2013 *
2014 *     Ret  : S16
2015 *
2016 *     Notes:
2017 *
2018 *     File  :
2019 *
2020 **********************************************************/
2021 #ifdef ANSI
2022 PUBLIC S16 cmPkCrgDel
2023 (
2024 CrgDel *param,
2025 Buffer *mBuf
2026 )
2027 #else
2028 PUBLIC S16 cmPkCrgDel(param, mBuf)
2029 CrgDel *param;
2030 Buffer *mBuf;
2031 #endif
2032 {
2033
2034    TRC3(cmPkCrgDel)
2035
2036       switch(param->delType) {
2037          case CRG_LCH_CFG:
2038             CMCHKPK(SPkU8, param->u.lchDel.dir, mBuf);
2039             CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
2040             CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
2041             CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
2042          break;
2043          case CRG_UE_CFG:
2044             CMCHKPK(cmPkLteRnti, param->u.ueDel.crnti, mBuf);
2045             CMCHKPK(cmPkLteCellId, param->u.ueDel.cellId, mBuf);
2046          break;
2047          case CRG_CELL_CFG:
2048             CMCHKPK(cmPkLteCellId, param->u.cellDel.cellId, mBuf);
2049          break;
2050          default :
2051             RETVALUE(RFAILED);
2052       }
2053    CMCHKPK(SPkU8, param->delType, mBuf);
2054    RETVALUE(ROK);
2055 }
2056
2057
2058 \f
2059 /***********************************************************
2060 *
2061 *     Func : cmUnpkCrgDel
2062 *
2063 *
2064 *     Desc : Basic Delete info for MAC
2065 *
2066 *
2067 *     Ret  : S16
2068 *
2069 *     Notes:
2070 *
2071 *     File  :
2072 *
2073 **********************************************************/
2074 #ifdef ANSI
2075 PUBLIC S16 cmUnpkCrgDel
2076 (
2077 CrgDel *param,
2078 Buffer *mBuf
2079 )
2080 #else
2081 PUBLIC S16 cmUnpkCrgDel(param, mBuf)
2082 CrgDel *param;
2083 Buffer *mBuf;
2084 #endif
2085 {
2086
2087    TRC3(cmUnpkCrgDel)
2088
2089    CMCHKUNPK(SUnpkU8, &param->delType, mBuf);
2090       switch(param->delType) {
2091          case CRG_CELL_CFG:
2092             CMCHKUNPK(cmUnpkLteCellId, &param->u.cellDel.cellId, mBuf);
2093          break;
2094          case CRG_UE_CFG:
2095             CMCHKUNPK(cmUnpkLteCellId, &param->u.ueDel.cellId, mBuf);
2096             CMCHKUNPK(cmUnpkLteRnti, &param->u.ueDel.crnti, mBuf);
2097          break;
2098          case CRG_LCH_CFG:
2099             CMCHKUNPK(cmUnpkLteCellId, &param->u.lchDel.cellId, mBuf);
2100             CMCHKUNPK(cmUnpkLteRnti, &param->u.lchDel.crnti, mBuf);
2101             CMCHKUNPK(cmUnpkLteLcId, &param->u.lchDel.lcId, mBuf);
2102             CMCHKUNPK(SUnpkU8, &param->u.lchDel.dir, mBuf);
2103          break;
2104          default :
2105             RETVALUE(RFAILED);
2106       }
2107    RETVALUE(ROK);
2108 }
2109
2110
2111 \f
2112 /***********************************************************
2113 *
2114 *     Func : cmPkCrgRst
2115 *
2116 *
2117 *     Desc : UE RESET info for MAC
2118 *
2119 *
2120 *     Ret  : S16
2121 *
2122 *     Notes:
2123 *
2124 *     File  :
2125 *
2126 **********************************************************/
2127 #ifdef ANSI
2128 PUBLIC S16 cmPkCrgRst
2129 (
2130 CrgRst *param,
2131 Buffer *mBuf
2132 )
2133 #else
2134 PUBLIC S16 cmPkCrgRst(param, mBuf)
2135 CrgRst *param;
2136 Buffer *mBuf;
2137 #endif
2138 {
2139
2140    TRC3(cmPkCrgRst)
2141
2142    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
2143    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2144    RETVALUE(ROK);
2145 }
2146
2147
2148 \f
2149 /***********************************************************
2150 *
2151 *     Func : cmUnpkCrgRst
2152 *
2153 *
2154 *     Desc : UE RESET info for MAC
2155 *
2156 *
2157 *     Ret  : S16
2158 *
2159 *     Notes:
2160 *
2161 *     File  :
2162 *
2163 **********************************************************/
2164 #ifdef ANSI
2165 PUBLIC S16 cmUnpkCrgRst
2166 (
2167 CrgRst *param,
2168 Buffer *mBuf
2169 )
2170 #else
2171 PUBLIC S16 cmUnpkCrgRst(param, mBuf)
2172 CrgRst *param;
2173 Buffer *mBuf;
2174 #endif
2175 {
2176
2177    TRC3(cmUnpkCrgRst)
2178
2179    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2180    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
2181    RETVALUE(ROK);
2182 }
2183
2184
2185 \f
2186 /***********************************************************
2187 *
2188 *     Func : cmPkCrgCfgReqInfo
2189 *
2190 *
2191 *     Desc : Config/Reconfig/Delete info for MAC
2192 *
2193 *
2194 *     Ret  : S16
2195 *
2196 *     Notes:
2197 *
2198 *     File  :
2199 *
2200 **********************************************************/
2201 #ifdef ANSI
2202 PUBLIC S16 cmPkCrgCfgReqInfo
2203 (
2204 CrgCfgReqInfo *param,
2205 Buffer *mBuf
2206 )
2207 #else
2208 PUBLIC S16 cmPkCrgCfgReqInfo(param, mBuf)
2209 CrgCfgReqInfo *param;
2210 Buffer *mBuf;
2211 #endif
2212 {
2213
2214    TRC3(cmPkCrgCfgReqInfo)
2215
2216       switch(param->action) {
2217          case CRG_RESET:
2218             CMCHKPK(cmPkCrgRst, &param->u.rstInfo, mBuf);
2219             break;
2220          case CRG_DELETE:
2221             CMCHKPK(cmPkCrgDel, &param->u.delInfo, mBuf);
2222             break;
2223          case CRG_RECONFIG:
2224             CMCHKPK(cmPkCrgRecfg, &param->u.recfgInfo, mBuf);
2225             break;
2226          case CRG_CONFIG:
2227             CMCHKPK(cmPkCrgCfg, &param->u.cfgInfo, mBuf);
2228             break;
2229          default :
2230             RETVALUE(RFAILED);
2231       }
2232    CMCHKPK(SPkU8, param->action, mBuf);
2233    RETVALUE(ROK);
2234 }
2235
2236
2237 \f
2238 /***********************************************************
2239 *
2240 *     Func : cmUnpkCrgCfgReqInfo
2241 *
2242 *
2243 *     Desc : Config/Reconfig/Delete info for MAC
2244 *
2245 *
2246 *     Ret  : S16
2247 *
2248 *     Notes:
2249 *
2250 *     File  :
2251 *
2252 **********************************************************/
2253 #ifdef ANSI
2254 PUBLIC S16 cmUnpkCrgCfgReqInfo
2255 (
2256 CrgCfgReqInfo *param,
2257 Buffer *mBuf
2258 )
2259 #else
2260 PUBLIC S16 cmUnpkCrgCfgReqInfo(param, mBuf)
2261 CrgCfgReqInfo *param;
2262 Buffer *mBuf;
2263 #endif
2264 {
2265
2266    TRC3(cmUnpkCrgCfgReqInfo)
2267
2268    CMCHKUNPK(SUnpkU8, &param->action, mBuf);
2269       switch(param->action) {
2270          case CRG_CONFIG:
2271             CMCHKUNPK(cmUnpkCrgCfg, &param->u.cfgInfo, mBuf);
2272             break;
2273          case CRG_RECONFIG:
2274             CMCHKUNPK(cmUnpkCrgRecfg, &param->u.recfgInfo, mBuf);
2275             break;
2276          case CRG_DELETE:
2277             CMCHKUNPK(cmUnpkCrgDel, &param->u.delInfo, mBuf);
2278             break;
2279          case CRG_RESET:
2280             CMCHKUNPK(cmUnpkCrgRst, &param->u.rstInfo, mBuf);
2281             break;
2282          default :
2283             RETVALUE(RFAILED);
2284       }
2285    RETVALUE(ROK);
2286 }
2287 #endif
2288
2289 /**********************************************************************
2290          End of file
2291 **********************************************************************/