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