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