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