src/cm/kwu.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /********************************************************************20**
  20
  21         Name:    KWU Interface
  22
  23         Type:    C file
  24
  25         Desc:    This file Contains the packing and unpacking functions for
  26                  KWU Interface
  27
  28         File:    kwu.c
  29
  30 *********************************************************************21*/
  31 \f
  32 /* header include files (.h) */
  33 #include "common_def.h"
  34 #ifdef TENB_SPLIT_ARCH
  35 #include "ss_queue.h"
  36 #include "ss_task.h"
  37 #include "ss_msg.h"
  38 #endif
  39 #include "kwu.h"           /* KWU defines */
  40
  41 /* extern (.x) include files */
  42 #ifdef TENB_SPLIT_ARCH
  43 #include "ss_queue.x"
  44 #include "ss_task.x"
  45 #include "ss_msg.x"
  46 #endif
  47 #ifdef SS_RBUF
  48 #include "ss_rbuf.h"
  49 #include "ss_rbuf.x"
  50 #endif /*SS_RBUF*/
  51 #include "kwu.x"           /* KWU */
  52
  53 #ifdef LCKWU
  54 \f
  55 /****************************************************************************
  56  *                      Packing Functions
  57  ***************************************************************************/
  58 S16 cmPkKwuBndReq(Pst * pst,SuId suId,SpId spId)
  59 {
  60    S16    ret1;
  61    Buffer *mBuf;
  62
  63    mBuf = NULLP;
  64
  65    if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
  66    {
  67 #if (ERRCLASS & ERRCLS_ADD_RES)
  68       if(ret1 != ROK)
  69       {
  70          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  71                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  72                (ErrVal)EKWU001, (ErrVal)0, "SGetMsg() failed");
  73       }
  74 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
  75       return (ret1);
  76    }
  77    CMCHKPKLOG(SPkS16, spId, mBuf, EKWU002, pst);
  78    CMCHKPKLOG(SPkS16, suId, mBuf, EKWU003, pst);
  79    pst->event = (Event) KWU_EVT_BND_REQ;
  80    return (SPstTsk(pst,mBuf));
  81 }
  82
  83 \f
  84 S16 cmPkKwuBndCfm(Pst * pst,SuId suId,uint8_t status)
  85 {
  86    S16    ret1;
  87    Buffer *mBuf;
  88
  89
  90    mBuf = NULLP;
  91
  92    if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
  93    {
  94 #if (ERRCLASS & ERRCLS_ADD_RES)
  95       if(ret1 != ROK)
  96       {
  97          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
  98                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
  99                (ErrVal)EKWU004, (ErrVal)0, "SGetMsg() failed");
 100       }
 101 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 102       return (ret1);
 103    }
 104
 105    CMCHKPKLOG(oduUnpackUInt8, status, mBuf, EKWU005, pst);
 106    CMCHKPKLOG(SPkS16, suId, mBuf, EKWU006, pst);
 107    pst->event = (Event) KWU_EVT_BND_CFM;
 108    return (SPstTsk(pst,mBuf));
 109 }
 110
 111 \f
 112 S16 cmPkKwuUbndReq(Pst * pst,SuId suId,Reason reason)
 113 {
 114    S16 ret1;
 115    Buffer *mBuf;
 116
 117
 118    mBuf = NULLP;
 119
 120    if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 121    {
 122 #if (ERRCLASS & ERRCLS_ADD_RES)
 123       if(ret1 != ROK)
 124       {
 125          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 126                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 127                (ErrVal)EKWU007, (ErrVal)0, "SGetMsg() failed");
 128       }
 129 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 130       return (ret1);
 131    }
 132    CMCHKPKLOG(SPkS16, reason, mBuf, EKWU008, pst);
 133    CMCHKPKLOG(SPkS16, suId, mBuf, EKWU009, pst);
 134
 135    pst->event = (Event) KWU_EVT_UBND_REQ;
 136    return (SPstTsk(pst,mBuf));
 137 } /* cmPkKwuUbndReq */
 138
 139 uint8_t cmPkRlcDatReqInfo(RlcDatReqInfo *param,Buffer *mBuf)
 140 {
 141 #ifdef CCPU_OPT
 142    switch(param->lcType) {
 143       case CM_LTE_LCH_CCCH:
 144          CMCHKPK(cmPkLteRnti, param->tm.rnti, mBuf);
 145          break;
 146       case CM_LTE_LCH_BCCH:
 147       case  CM_LTE_LCH_PCCH:
 148          CMCHKPK(cmPkLteTimingInfo, &param->tm.tmg, mBuf);
 149 #ifdef EMTC_ENABLE
 150          CMCHKPK(oduUnpackUInt8, param->emtcDiReason,mBuf);
 151          CMCHKPK(oduUnpackUInt8, param->pnb,mBuf);
 152 #endif
 153          break;
 154       case CM_LTE_LCH_DTCH:
 155       case CM_LTE_LCH_DCCH:
 156          break;
 157       default :
 158          return RFAILED;
 159    }
 160    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
 161
 162 #endif
 163    CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
 164    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 165    return ROK;
 166 } /* cmPkRlcDatReqInfo */
 167
 168 \f
 169 uint8_t cmPkRlcDatReq(Pst * pst,RlcDatReqInfo* datReq,Buffer * mBuf)
 170 {
 171 #ifdef LCKWU
 172 #if (ERRCLASS & ERRCLS_ADD_RES)
 173 #endif
 174 #endif /* LCKWU */
 175    S16 ret1 = ROK;
 176 #ifndef SS_RBUF
 177    RlcDatReqInfo* datReqInfo;
 178 #endif
 179 #ifndef SS_RBUF
 180    switch(pst->selector)
 181    {
 182      case ODU_SELECTOR_LWLC:
 183         {
 184            if(pst->srcEnt == ENTDUAPP)
 185            {
 186              /* When the Selector is LWLC, we need to allocate memory, copy
 187               * the contents and pass the pointer of the allocated memory. The
 188               * subsequent free would be done during the Unpack function of the
 189               * primitive. */
 190             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReqInfo,
 191                         sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
 192             {
 193 #if (ERRCLASS & ERRCLS_ADD_RES)
 194                if(ret1 != ROK)
 195                {
 196                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 197                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 198                         (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
 199                }
 200 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 201                return (ret1);
 202             }
 203             memcpy(datReqInfo,datReq,sizeof(RlcDatReqInfo));
 204             CMCHKPK(oduPackPointer,(PTR)datReqInfo, mBuf);
 205            }
 206            else
 207            {
 208             CMCHKPK(oduPackPointer,(PTR)datReq, mBuf);
 209            }
 210         }
 211         break;
 212      case ODU_SELECTOR_LC:
 213         {
 214 #if (ERRCLASS & ERRCLS_ADD_RES)
 215            ret1 = cmPkRlcDatReqInfo( (datReq), mBuf);
 216            if(ret1 != ROK)
 217            {
 218               SPutMsg(mBuf);
 219               SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 220                     __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 221                     (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
 222               return ( ret1 );
 223            }
 224 #else
 225            cmPkRlcDatReqInfo( (datReq), mBuf);
 226 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 227            if(pst->srcEnt == ENTNH)
 228            {
 229               if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
 230                        sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
 231               {
 232                  SPutMsg(mBuf);
 233                  return RFAILED;
 234               }
 235            }
 236         }
 237         break;
 238      default:
 239           SPutMsg(mBuf);
 240 #if (ERRCLASS & ERRCLS_ADD_RES)
 241           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 242                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 243                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 244 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 245           return RFAILED;
 246    }
 247
 248 #ifdef L2_L3_SPLIT
 249     if(datReq->rlcId.rbType == CM_LTE_SRB)
 250     {
 251        pst->event = (Event) KWU_EVT_CPLANE_DAT_REQ;
 252     }
 253     else
 254     {
 255        pst->event = (Event) KWU_EVT_UPLANE_DAT_REQ;
 256     }
 257 #else
 258     pst->event = (Event) KWU_EVT_DAT_REQ;
 259 #endif
 260     return (SPstTsk(pst,mBuf));
 261 #else
 262    if (pst->srcEnt == ENTPJ)
 263    {
 264       Void *elem = NULLP;
 265       KwuDatReqDetl *kwuDatReqDetl = NULLP;
 266       elem = SRngGetWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
 267       if (NULLP != elem)
 268       {
 269          kwuDatReqDetl = (KwuDatReqDetl *) elem;
 270          kwuDatReqDetl->spId = spId;
 271          kwuDatReqDetl->lcType = datReq->lcType;
 272          kwuDatReqDetl->sduId = datReq->sduId;
 273          kwuDatReqDetl->rlcId = datReq->rlcId;
 274          kwuDatReqDetl->mBuf = mBuf;
 275          SRngIncrWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
 276          SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktRate++;
 277          ret1 = ROK;
 278       }
 279       else
 280       {
 281          SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktDrop++;
 282          SPutMsg(mBuf);
 283          ret1 = RFAILED;
 284       }
 285    }
 286    else
 287    {
 288       switch(pst->selector)
 289       {
 290 #ifdef LCKWU
 291          case ODU_SELECTOR_LC:
 292             {
 293                ret1 = cmPkRlcDatReqInfo( (datReq), mBuf);
 294 #if (ERRCLASS & ERRCLS_ADD_RES)
 295                if(ret1 != ROK)
 296                {
 297                   SPutMsg(mBuf);
 298                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 299                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 300                         (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
 301                   return ( ret1 );
 302                }
 303 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 304             }
 305             break;
 306          case ODU_SELECTOR_LWLC:
 307             {
 308                CMCHKPK(oduPackPointer,(PTR)datReq, mBuf);
 309             }
 310             break;
 311 #endif /* LCKWU */
 312       }
 313
 314       CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
 315       pst->event = (Event) KWU_EVT_DAT_REQ;
 316       ret1 = SPstTsk(pst,mBuf);
 317       if(pst->selector == ODU_SELECTOR_LC)
 318       {
 319          if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
 320                   sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
 321          {
 322             SPutMsg(mBuf);
 323             return RFAILED;
 324          }
 325       }
 326    }
 327    return (ret1);
 328 #endif
 329 } /* cmPkRlcDatReq */
 330
 331 \f
 332 uint8_t cmPkKwuDatIndInfo(KwuDatIndInfo *param,Buffer *mBuf)
 333 {
 334
 335    CMCHKPK(oduUnpackUInt8, param->isOutOfSeq, mBuf);
 336 #ifdef CCPU_OPT
 337    CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
 338 #endif
 339    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 340    return ROK;
 341 }
 342
 343 \f
 344 uint8_t cmPkKwuDatInd(Pst * pst,KwuDatIndInfo* datInd,Buffer * mBuf)
 345 {
 346 #ifdef LCKWU
 347     S16 ret1 = ROK;
 348 #endif /* LCKWU */
 349 #ifdef TENB_SPLIT_ARCH
 350 #ifdef SS_LOCKLESS_MEMORY
 351     SsMsgInfo   *mInfo;
 352 #endif
 353 #endif
 354     KwuDatIndInfo *datIndInfo = NULLP;
 355
 356
 357 #ifdef TENB_SPLIT_ARCH
 358     /* SSI_CHANGES: */
 359 #ifdef SS_LOCKLESS_MEMORY
 360     mInfo = (SsMsgInfo *)mBuf->b_rptr;
 361     mInfo->region = pst->region;
 362 #endif /* SS_LOCKLESS_MEMORY */
 363 #endif
 364
 365     switch(pst->selector)
 366     {
 367        case ODU_SELECTOR_LWLC:
 368           {
 369              /* When the Selector is LWLC, we need to allocate memory, copy
 370               * the contents and pass the pointer of the allocated memory. The
 371               * subsequent free would be done during the Unpack function of the
 372               * primitive. */
 373             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datIndInfo,
 374                         sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
 375             {
 376 #if (ERRCLASS & ERRCLS_ADD_RES)
 377                if(ret1 != ROK)
 378                {
 379                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 380                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 381                         (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
 382                }
 383 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 384                return (ret1);
 385             }
 386
 387             memcpy(datIndInfo, datInd,sizeof(KwuDatIndInfo));
 388             CMCHKPK(oduPackPointer,(PTR)datIndInfo, mBuf);
 389           }
 390           break;
 391        case ODU_SELECTOR_LC:
 392           {
 393 #if (ERRCLASS & ERRCLS_ADD_RES)
 394              ret1 = cmPkKwuDatIndInfo( (datInd), mBuf);
 395              if(ret1 != ROK)
 396              {
 397                 SPutMsg(mBuf);
 398                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 399                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 400                       (ErrVal)EKWU012, (ErrVal)ret1, "Packing failure");
 401                 return ( ret1 );
 402              }
 403 #else
 404              cmPkKwuDatIndInfo( (datInd), mBuf);
 405 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 406           }
 407           break;
 408        default:
 409           SPutMsg(mBuf);
 410 #if (ERRCLASS & ERRCLS_ADD_RES)
 411           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 412                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 413                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 414 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 415           return RFAILED;
 416     }
 417
 418     pst->event = (Event) KWU_EVT_DAT_IND;
 419
 420     return (SPstTsk(pst,mBuf));
 421 } /* cmPkKwuDatInd */
 422
 423 \f
 424 S16 cmPkKwuDatCfmInfo(KwuDatCfmInfo *param,Buffer *mBuf)
 425 {
 426    register uint32_t iter;
 427
 428    for(iter = 0; iter < param->numSduIds; iter++)
 429    {
 430       CMCHKPK(oduUnpackUInt32, param->sduIds[iter], mBuf);
 431    }
 432    CMCHKPK(oduUnpackUInt32, param->numSduIds, mBuf);
 433    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 434    return ROK;
 435 } /* cmPkKwuDatCfmInfo */
 436
 437 \f
 438 S16 cmPkKwuDatCfm(Pst * pst,SuId suId,KwuDatCfmInfo* datCfm)
 439 {
 440 #if (ERRCLASS & ERRCLS_ADD_RES)
 441    S16 ret1= ROK;
 442 #endif
 443    Buffer *mBuf;
 444
 445
 446    mBuf = NULLP;
 447
 448    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 449       return RFAILED;
 450    }
 451
 452    switch(pst->selector)
 453    {
 454       case ODU_SELECTOR_LWLC:
 455          {
 456             CMCHKPK(oduPackPointer,(PTR)datCfm, mBuf);
 457          }
 458          break;
 459       case ODU_SELECTOR_LC:
 460          {
 461 #if (ERRCLASS & ERRCLS_ADD_RES)
 462             ret1 = cmPkKwuDatCfmInfo( (datCfm), mBuf);
 463             if(ret1 != ROK)
 464             {
 465                SPutMsg(mBuf);
 466                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 467                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 468                      (ErrVal)EKWU014, (ErrVal)ret1, "Packing failure");
 469                return ( ret1 );
 470             }
 471 #else
 472             cmPkKwuDatCfmInfo( (datCfm), mBuf);
 473 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 474             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datCfm,
 475                      sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
 476             {
 477                SPutMsg(mBuf);
 478                return RFAILED;
 479             }
 480          }
 481          break;
 482       default:
 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)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 488 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 489           return RFAILED;
 490    }
 491
 492     CMCHKPKLOG(SPkS16, suId, mBuf, EKWU015, pst);
 493     pst->event = (Event) KWU_EVT_DAT_CFM;
 494
 495     return (SPstTsk(pst,mBuf));
 496 } /* cmPkKwuDatCfm */
 497
 498 \f
 499 S16 cmPkKwuDiscSduReq(Pst * pst,SpId spId,KwuDiscSduInfo* discSdu)
 500 {
 501 #ifdef LCKWU
 502    S16 ret1;
 503 #endif /* LCKWU */
 504    Buffer *mBuf;
 505    KwuDiscSduInfo* discSduInfo = NULLP;
 506
 507    mBuf = NULLP;
 508
 509    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 510       return RFAILED;
 511    }
 512
 513    switch(pst->selector)
 514    {
 515       case ODU_SELECTOR_LWLC:
 516          {
 517             /* When the Selector is LWLC, we need to allocate memory, copy
 518              * the contents and pass the pointer of the allocated memory. The
 519              * subsequent free would be done during the Unpack function of the
 520              * primitive. */
 521            if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSduInfo,
 522                        sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
 523            {
 524 #if (ERRCLASS & ERRCLS_ADD_RES)
 525               if(ret1 != ROK)
 526               {
 527                  SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 528                        __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 529                         (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
 530               }
 531 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 532               return (ret1);
 533            }
 534
 535            memcpy(discSduInfo, discSdu,sizeof(KwuDiscSduInfo));
 536            CMCHKPK(oduPackPointer,(PTR)discSduInfo, mBuf);
 537          }
 538          break;
 539       case ODU_SELECTOR_LC:
 540          {
 541 #if (ERRCLASS & ERRCLS_ADD_RES)
 542             ret1 = cmPkKwuDiscSduInfo( (discSdu), mBuf);
 543             if(ret1 != ROK)
 544             {
 545                SPutMsg(mBuf);
 546                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 547                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 548                      (ErrVal)EKWU016, (ErrVal)ret1, "Packing failure");
 549                return ( ret1 );
 550             }
 551 #else
 552             cmPkKwuDiscSduInfo( (discSdu), mBuf);
 553 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 554              break;
 555           }
 556     }
 557
 558     CMCHKPKLOG(SPkS16, spId, mBuf, EKWU017, pst);
 559     pst->event = (Event) KWU_EVT_DISC_SDU_REQ;
 560
 561     return (SPstTsk(pst,mBuf));
 562 } /* cmPkKwuDiscSduReq */
 563
 564 \f
 565 S16 cmPkKwuStaIndInfo(KwuStaIndInfo *param,Buffer *mBuf)
 566 {
 567    S16 i;
 568
 569
 570    for (i = (param->numSdu - 1); i >= 0; i--)
 571    {
 572       CMCHKPK(oduUnpackUInt32, param->sduId[(uint16_t)i], mBuf);
 573    }
 574    CMCHKPK(oduUnpackUInt32, param->numSdu, mBuf);
 575    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 576    return ROK;
 577 }
 578
 579 S16 cmPkKwuFlowCntrlIndInfo(KwuFlowCntrlIndInfo *param,Buffer *mBuf)
 580 {
 581
 582    CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
 583    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 584
 585    return ROK;
 586 } /* cmPkKwuFlowCntrlIndInfo */
 587
 588 S16 cmUnpkKwuFlowCntrlIndInfo(KwuFlowCntrlIndInfo *param,Buffer *mBuf)
 589 {
 590
 591    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
 592    CMCHKUNPK(oduPackUInt32, &param->pktAdmitCnt, mBuf);
 593
 594    return ROK;
 595 } /* cmUnpkKwuFlowCntrlIndInfo */
 596
 597 \f
 598 S16 cmPkKwuStaInd(Pst * pst,SuId suId,KwuStaIndInfo* staInd)
 599 {
 600 #ifdef LCKWU
 601 #if (ERRCLASS & ERRCLS_ADD_RES)
 602    S16 ret1 = ROK;
 603 #endif
 604 #endif /* LCKWU */
 605    Buffer *mBuf;
 606
 607
 608    mBuf = NULLP;
 609
 610    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 611       return RFAILED;
 612    }
 613
 614     switch(pst->selector)
 615     {
 616        case ODU_SELECTOR_LWLC:
 617           {
 618              CMCHKPK(oduPackPointer,(PTR) staInd, mBuf);
 619           }
 620           break;
 621        case ODU_SELECTOR_LC:
 622           {
 623 #if (ERRCLASS & ERRCLS_ADD_RES)
 624              ret1 = cmPkKwuStaIndInfo( (staInd), mBuf);
 625              if(ret1 != ROK)
 626              {
 627                 SPutMsg(mBuf);
 628                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 629                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 630                       (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
 631                 return ( ret1 );
 632              }
 633 #else
 634              cmPkKwuStaIndInfo( (staInd), mBuf);
 635 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 636              if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staInd,
 637                       sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
 638              {
 639                 SPutMsg(mBuf);
 640                 return RFAILED;
 641              }
 642           }
 643           break;
 644        default:
 645           SPutMsg(mBuf);
 646 #if (ERRCLASS & ERRCLS_ADD_RES)
 647           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 648                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 649                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 650 #endif
 651           return RFAILED;
 652     }
 653
 654     CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
 655     pst->event = (Event) KWU_EVT_STA_IND;
 656
 657     return (SPstTsk(pst,mBuf));
 658 } /* cmPkKwuStaInd */
 659
 660 \f
 661 S16 cmPkKwuReEstCmpInd(Pst * pst,SuId suId,CmLteRlcId rlcId)
 662 {
 663 #ifdef LCKWU
 664 #if (ERRCLASS & ERRCLS_ADD_RES)
 665    S16 ret1;
 666 #endif
 667 #endif /* LCKWU */
 668    Buffer *mBuf;
 669
 670
 671    mBuf = NULLP;
 672
 673    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 674       return RFAILED;
 675    }
 676
 677     switch(pst->selector)
 678     {
 679 #ifdef LCKWU
 680        case ODU_SELECTOR_LC:
 681           {
 682 #if (ERRCLASS & ERRCLS_ADD_RES)
 683              ret1 = cmPkLteRlcId( &rlcId, mBuf);
 684              if(ret1 != ROK)
 685              {
 686                 SPutMsg(mBuf);
 687                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 688                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 689                       (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
 690                 return ( ret1 );
 691              }
 692 #else
 693              cmPkLteRlcId( &rlcId, mBuf);
 694 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 695              break;
 696           }
 697 #endif /* LCKWU */
 698     }
 699
 700     CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
 701     pst->event = (Event) KWU_EVT_REEST_CMP_IND;
 702
 703     return (SPstTsk(pst,mBuf));
 704 } /* cmPkKwuReEstCmpInd */
 705
 706 /* kwu_c_001.main_3 added support for L2 Measurement */
 707 S16 cmPkKwuDiscSduCfm(Pst *pst,SpId spId,KwuDiscSduInfo *discCfmSdu)
 708 {
 709 #if (ERRCLASS & ERRCLS_ADD_RES)
 710    S16 ret1 = ROK;
 711 #endif
 712    Buffer *mBuf;
 713
 714
 715    mBuf = NULLP;
 716
 717    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 718       return RFAILED;
 719    }
 720
 721    switch(pst->selector)
 722    {
 723       case ODU_SELECTOR_LWLC:
 724          {
 725             CMCHKPK(oduPackPointer,(PTR)discCfmSdu, mBuf);
 726          }
 727          break;
 728       case ODU_SELECTOR_LC:
 729          {
 730 #if (ERRCLASS & ERRCLS_ADD_RES)
 731             ret1 = cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
 732             if(ret1 != ROK)
 733             {
 734                SPutMsg(mBuf);
 735                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 736                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 737                      (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
 738                return ( ret1 );
 739             }
 740 #else
 741             cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
 742 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 743             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)discCfmSdu,
 744                      sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
 745             {
 746                SPutMsg(mBuf);
 747                return RFAILED;
 748             }
 749          }
 750          break;
 751       default:
 752          SPutMsg(mBuf);
 753 #if (ERRCLASS & ERRCLS_ADD_RES)
 754          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 755                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 756                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 757 #endif
 758           return RFAILED;
 759    }
 760
 761    CMCHKPKLOG(SPkS16, spId, mBuf, ERRKWU, pst);
 762    pst->event = (Event) KWU_EVT_DISC_SDU_CFM;
 763
 764    return (SPstTsk(pst,mBuf));
 765 } /* cmPkKwuDiscSduCfm */
 766 \f
 767 S16 cmPkKwuFlowCntrlInd(Pst *pst,SuId suId,KwuFlowCntrlIndInfo *flowCntrlIndInfo)
 768 {
 769    Buffer *mBuf;
 770
 771
 772    mBuf = NULLP;
 773
 774    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
 775    {
 776       SPutStaticBuffer(pst->region,
 777                pst->pool,
 778                (Data *)flowCntrlIndInfo,
 779                sizeof(KwuFlowCntrlIndInfo),0);
 780       return RFAILED;
 781    }
 782 #ifdef LCKWU
 783    switch(pst->selector)
 784    {
 785       case ODU_SELECTOR_LC:
 786       {
 787          cmPkKwuFlowCntrlIndInfo((flowCntrlIndInfo), mBuf);
 788
 789          if (SPutStaticBuffer(pst->region,
 790                       pst->pool,
 791                       (Data *)flowCntrlIndInfo,
 792                       sizeof(KwuFlowCntrlIndInfo),0) != ROK)
 793          {
 794             SPutMsg(mBuf);
 795             return RFAILED;
 796          }
 797       }
 798       break;
 799
 800       case ODU_SELECTOR_LWLC:
 801       {
 802          CMCHKPK(oduPackPointer,(PTR) flowCntrlIndInfo, mBuf);
 803       }
 804       break;
 805    }
 806 #endif
 807
 808    CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
 809    pst->event = (Event) KWU_EVT_FLOW_CNTRL_IND;
 810
 811    return (SPstTsk(pst,mBuf));
 812 } /* cmPkKwuFlowCntrlInd */
 813
 814 #ifdef LTE_L2_MEAS
 815 S16 cmPkKwuDatAckInfo(KwuDatAckInfo *param,Buffer *mBuf)
 816 {
 817
 818    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 819    CMCHKPK(oduUnpackUInt32, param->sduId, mBuf);
 820    return ROK;
 821 }
 822
 823 S16 cmPkKwuDatAckInd(Pst * pst,SuId suId,KwuDatAckInfo* datInd)
 824 {
 825     S16 ret1;
 826
 827    Buffer *mBuf;
 828
 829
 830    mBuf = NULLP;
 831
 832    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 833       return RFAILED;
 834    }
 835
 836    ret1 = cmPkKwuDatAckInfo( (datInd), mBuf);
 837 #if (ERRCLASS & ERRCLS_ADD_RES)
 838    if(ret1 != ROK)
 839    {
 840       SPutMsg(mBuf);
 841       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 842             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 843             (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
 844       return ( ret1 );
 845    }
 846 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 847    if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
 848             sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
 849    {
 850       SPutMsg(mBuf);
 851       return RFAILED;
 852    }
 853
 854    CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
 855    pst->event = (Event) KWU_EVT_DAT_ACK_IND;
 856
 857    return (SPstTsk(pst,mBuf));
 858 } /* cmPkKwuDatAckInd */
 859 #endif /* LTE_L2_MEAS */
 860
 861 \f
 862 S16 cmUnpkKwuBndReq(KwuBndReq func,Pst *pst,Buffer *mBuf)
 863 {
 864    SuId suId = 0;
 865    SpId spId = 0;
 866
 867    CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU020, pst);
 868    CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
 869    SPutMsg(mBuf);
 870
 871    return ((*func)(pst, suId, spId));
 872 }
 873
 874 \f
 875 S16 cmUnpkKwuBndCfm(KwuBndCfm func,Pst *pst,Buffer *mBuf)
 876 {
 877    SuId suId = 0;
 878    uint8_t status = 0;
 879
 880
 881    CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
 882    CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EKWU023, pst);
 883    SPutMsg(mBuf);
 884
 885    return ((*func)(pst, suId, status));
 886 }
 887
 888 \f
 889 S16 cmUnpkKwuUbndReq(KwuUbndReq func,Pst *pst,Buffer *mBuf)
 890 {
 891    SpId spId = 0;
 892    Reason reason = 0;
 893
 894
 895    CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst);
 896    CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
 897    SPutMsg(mBuf);
 898
 899    return ((*func)(pst, spId, reason));
 900 } /* cmUnpkKwuUbndReq */
 901
 902 \f
 903 S16 cmUnpkRlcDatReqInfo(RlcDatReqInfo *param,Buffer *mBuf)
 904 {
 905
 906
 907    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
 908    CMCHKUNPK(oduPackUInt32, &param->sduId, mBuf);
 909
 910 #ifdef CCPU_OPT
 911    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
 912    switch(param->lcType) {
 913       case CM_LTE_LCH_BCCH:
 914       case  CM_LTE_LCH_PCCH:
 915 #ifdef EMTC_ENABLE
 916          CMCHKUNPK(oduPackUInt8,&param->pnb , mBuf);
 917          CMCHKUNPK(oduPackUInt8,&param->emtcDiReason , mBuf);
 918 #endif
 919          CMCHKUNPK(cmUnpkLteTimingInfo, &param->tm.tmg, mBuf);
 920
 921          break;
 922       case CM_LTE_LCH_CCCH:
 923          CMCHKUNPK(cmUnpkLteRnti, &param->tm.rnti, mBuf);
 924          break;
 925       case CM_LTE_LCH_DTCH:
 926       case CM_LTE_LCH_DCCH:
 927          break;
 928       default :
 929          return RFAILED;
 930    }
 931 #endif
 932    return ROK;
 933 }
 934
 935 \f
 936 S16 cmUnpkKwuDatReq(KwuDatReq func,Pst *pst,Buffer *mBuf)
 937 {
 938 #if(ERRCLASS & ERRCLS_DEBUG)
 939    S16 ret1 = ROK;
 940 #endif
 941    S16 retVal;
 942    RlcDatReqInfo *datReq = NULLP;
 943    RlcDatReqInfo datReqTmp;
 944
 945
 946    switch(pst->selector)
 947    {
 948       case ODU_SELECTOR_LWLC:
 949          {
 950             CMCHKUNPK(oduUnpackPointer,(PTR *) &datReq, mBuf);
 951          }
 952          break;
 953       case ODU_SELECTOR_LC:
 954          {
 955             /* Allocate the memory statically  as there is no free
 956              * in RLC */
 957             datReq = &datReqTmp;
 958             memset(datReq, 0, sizeof(RlcDatReqInfo));
 959 #if(ERRCLASS & ERRCLS_DEBUG)
 960             ret1 = cmUnpkRlcDatReqInfo( (datReq), mBuf);
 961             if(ret1 != ROK)
 962             {
 963                SPutMsg(mBuf);
 964                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
 965                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
 966                      (ErrVal)EKWU027, (ErrVal)ret1, "Unpacking failure");
 967                return ( ret1 );
 968             }
 969 #else
 970             cmUnpkRlcDatReqInfo( (datReq), mBuf);
 971 #endif /* ERRCLASS & ERRCLS_DEBUG */
 972          }
 973          break;
 974       default:
 975          SPutMsg(mBuf);
 976 #if (ERRCLASS & ERRCLS_ADD_RES)
 977          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 978                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 979                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 980 #endif
 981          return RFAILED;
 982    }
 983
 984    retVal = (*func)(pst, datReq, mBuf);
 985    /* If LWLC is configured, we need to
 986     * free the memory here. */
 987    if(pst->selector == ODU_SELECTOR_LWLC)
 988    {
 989       retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
 990             sizeof(RlcDatReqInfo),SS_SHARABLE_MEMORY);
 991    }
 992    return (retVal);
 993 } /* cmUnpkKwuDatReq */
 994
 995 \f
 996 uint8_t cmUnpkKwuDatIndInfo(KwuDatIndInfo *param,Buffer *mBuf)
 997 {
 998
 999    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1000
1001 #ifdef CCPU_OPT
1002    CMCHKUNPK(cmUnpkLteRnti, &param->tCrnti, mBuf);
1003 #endif
1004    CMCHKUNPK(oduPackUInt8, &param->isOutOfSeq, mBuf);
1005    return ROK;
1006 }
1007
1008 \f
1009 uint8_t cmUnpkKwuDatInd(KwuDatInd func,Pst *pst,Buffer *mBuf)
1010 {
1011     S16 ret1 = ROK, retVal;
1012     KwuDatIndInfo *datInd = NULLP;
1013     KwuDatIndInfo datIndTmp;
1014
1015
1016     switch(pst->selector)
1017     {
1018       case ODU_SELECTOR_LWLC:
1019          {
1020             CMCHKUNPK(oduUnpackPointer,(PTR *) &datInd, mBuf);
1021          }
1022          break;
1023       case ODU_SELECTOR_LC:
1024          {
1025             /*SGetStaticBuffer used as RRC has an equivalent free but PDCP
1026              * doesn't free any memory */
1027             if(pst->dstEnt != ENTPJ)
1028             {
1029                if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,
1030                            sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1031                {
1032 #if (ERRCLASS & ERRCLS_ADD_RES)
1033        if(ret1 != ROK)
1034        {
1035           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1036                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1037                (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
1038        }
1039 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1040                   return (ret1);
1041                }
1042             }
1043             else
1044             {
1045                datInd = &datIndTmp;
1046             }
1047
1048             ret1 = cmUnpkKwuDatIndInfo( (datInd), mBuf);
1049 #if(ERRCLASS & ERRCLS_DEBUG)
1050           if(ret1 != ROK)
1051           {
1052              SPutMsg(mBuf);
1053              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1054                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1055                   (ErrVal)EKWU029, (ErrVal)ret1, "Unpacking failure");
1056              return ( ret1 );
1057           }
1058 #endif /* ERRCLASS & ERRCLS_DEBUG */
1059          }
1060          break;
1061       default:
1062          SPutMsg(mBuf);
1063          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1064                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1065                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1066          return RFAILED;
1067     }
1068     retVal = (*func)(pst, datInd, mBuf);
1069     /* If LWLC is configured and the destination entity is PDCP, we need to
1070      * free the memory here. */
1071     if((pst->selector == ODU_SELECTOR_LWLC) && (pst->dstEnt == ENTPJ))
1072     {
1073        retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
1074                 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
1075     }
1076     return (retVal);
1077 } /* cmUnpkKwuDatInd */
1078
1079 \f
1080 S16 cmUnpkKwuDatCfmInfo(KwuDatCfmInfo *param,Buffer *mBuf)
1081 {
1082    register S32 iter;
1083
1084    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1085    CMCHKUNPK(oduPackUInt32, &param->numSduIds, mBuf);
1086
1087 #ifdef L2_L3_SPLIT /*Work Around */
1088    if (param->numSduIds >= KWU_MAX_DAT_CFM)
1089       param->numSduIds = KWU_MAX_DAT_CFM;
1090 #endif
1091    for(iter = param->numSduIds -1; iter >= 0 ; iter--)
1092    {
1093       CMCHKUNPK(oduPackUInt32, &param->sduIds[iter], mBuf);
1094    }
1095    return ROK;
1096 }
1097
1098 S16 cmUnpkKwuDatCfm(KwuDatCfm func,Pst *pst,Buffer *mBuf)
1099 {
1100    S16 ret1 = ROK;
1101    SuId          suId = 0;
1102    KwuDatCfmInfo *datCfm = NULLP;
1103
1104
1105    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1106
1107    switch(pst->selector)
1108    {
1109       case ODU_SELECTOR_LWLC:
1110          {
1111             CMCHKUNPK(oduUnpackPointer,(PTR *) &datCfm, mBuf);
1112          }
1113          break;
1114       case ODU_SELECTOR_LC:
1115          {
1116             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datCfm,\
1117                         sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY)) != ROK)
1118             {
1119 #if (ERRCLASS & ERRCLS_ADD_RES)
1120        if(ret1 != ROK)
1121        {
1122           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1123                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1124                (ErrVal)EKWU030, (ErrVal)0, "SGetMsg() failed");
1125        }
1126 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1127                return (ret1);
1128             }
1129
1130             memset(datCfm, 0, sizeof(KwuDatCfmInfo));
1131             ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf);
1132 #if(ERRCLASS & ERRCLS_DEBUG)
1133           if(ret1 != ROK)
1134           {
1135              SPutMsg(mBuf);
1136              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1137                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1138                   (ErrVal)EKWU031, (ErrVal)ret1, "Unpacking failure");
1139              return ( ret1 );
1140           }
1141 #endif /* ERRCLASS & ERRCLS_DEBUG */
1142          }
1143          break;
1144       default:
1145 #if (ERRCLASS & ERRCLS_ADD_RES)
1146           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1147                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1148                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1149 #endif
1150           SPutMsg(mBuf);
1151           return RFAILED;
1152    }
1153
1154    SPutMsg(mBuf);
1155
1156    return ((*func)(pst, suId, datCfm));
1157 } /* cmUnpkKwuDatCfm */
1158
1159 \f
1160 S16 cmUnpkKwuDiscSduReq(KwuDiscSduReq func,Pst *pst,Buffer *mBuf)
1161 {
1162    S16 ret1 = ROK;
1163    SpId          spId = 0;
1164    KwuDiscSduInfo *discSdu = NULLP;
1165
1166
1167    CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1168    switch(pst->selector)
1169    {
1170       case ODU_SELECTOR_LWLC:
1171          {
1172             CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf);
1173          }
1174          break;
1175       case ODU_SELECTOR_LC:
1176          {
1177             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1178                         sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1179             {
1180 #if (ERRCLASS & ERRCLS_ADD_RES)
1181                /*MBUF_FIXX*/
1182                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1183                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1184                      (ErrVal)EKWU032, (ErrVal)0, "SGetMsg() failed");
1185
1186 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1187                return (ret1);
1188             }
1189
1190             memset(discSdu, 0, sizeof(KwuDiscSduInfo));
1191             ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1192 #if(ERRCLASS & ERRCLS_DEBUG)
1193             if(ret1 != ROK)
1194             {
1195                SPutMsg(mBuf);
1196                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1197                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1198                      (ErrVal)EKWU033, (ErrVal)ret1, "Unpacking failure");
1199                return ( ret1 );
1200             }
1201 #endif /* ERRCLASS & ERRCLS_DEBUG */
1202             break;
1203          }
1204       default:
1205 #if (ERRCLASS & ERRCLS_ADD_RES)
1206           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1207                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1208                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1209 #endif
1210           SPutMsg(mBuf);
1211           return RFAILED;
1212    }
1213    SPutMsg(mBuf);
1214
1215    return ((*func)(pst, spId, discSdu));
1216 } /* cmUnpkKwuDiscSduReq */
1217
1218 \f
1219 S16 cmUnpkKwuStaIndInfo(KwuStaIndInfo *param,Buffer *mBuf)
1220 {
1221    uint32_t i;
1222
1223    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1224    CMCHKUNPK(oduPackUInt32, &param->numSdu, mBuf);
1225    for (i = 0; i < param->numSdu; i++)
1226    {
1227       CMCHKUNPK(oduPackUInt32, &param->sduId[i], mBuf);
1228    }
1229
1230    return ROK;
1231 } /* cmUnpkKwuStaIndInfo */
1232
1233 \f
1234 S16 cmUnpkKwuStaInd(KwuStaInd func,Pst *pst,Buffer *mBuf)
1235 {
1236    S16 ret1 = ROK;
1237    SuId          suId = 0;
1238    KwuStaIndInfo *staInd = NULLP;
1239
1240
1241    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1242
1243    switch(pst->selector)
1244    {
1245       case ODU_SELECTOR_LWLC:
1246          {
1247             CMCHKUNPK(oduUnpackPointer,(PTR *)&staInd, mBuf);
1248          }
1249          break;
1250       case ODU_SELECTOR_LC:
1251          {
1252             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&staInd,\
1253                         sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1254             {
1255 #if (ERRCLASS & ERRCLS_ADD_RES)
1256                if(ret1 != ROK)
1257                {
1258                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1259                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1260                         (ErrVal)EKWU034, (ErrVal)0, "SGetMsg() failed");
1261                }
1262 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1263                return (ret1);
1264             }
1265
1266             memset(staInd, 0, sizeof(KwuStaIndInfo));
1267
1268             ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf);
1269 #if(ERRCLASS & ERRCLS_DEBUG)
1270             if(ret1 != ROK)
1271             {
1272                SPutMsg(mBuf);
1273                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1274                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1275                      (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1276                return ( ret1 );
1277             }
1278 #endif /* ERRCLASS & ERRCLS_DEBUG */
1279          }
1280          break;
1281       default:
1282           SPutMsg(mBuf);
1283 #if(ERRCLASS & ERRCLS_DEBUG)
1284           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1285                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1286                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1287 #endif
1288           return RFAILED;
1289    }
1290    SPutMsg(mBuf);
1291
1292    return ((*func)(pst, suId, staInd));
1293 } /* cmUnpkKwuStaInd */
1294
1295 \f
1296 S16 cmUnpkKwuReEstCmpInd(KwuReEstCmpInd func,Pst *pst,Buffer *mBuf)
1297 {
1298 #if(ERRCLASS & ERRCLS_DEBUG)
1299    S16 ret1;
1300 #endif
1301    SuId          suId = 0;
1302    CmLteRlcId    rlcId;
1303
1304    memset(&rlcId, 0, sizeof(CmLteRlcId));
1305    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1306    switch(pst->selector)
1307    {
1308 #ifdef LCKWU
1309       case ODU_SELECTOR_LC:
1310          {
1311 #if(ERRCLASS & ERRCLS_DEBUG)
1312             ret1 = cmUnpkLteRlcId( &rlcId, mBuf);
1313             if(ret1 != ROK)
1314             {
1315                SPutMsg(mBuf);
1316                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1317                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1318                      (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1319                return ( ret1 );
1320             }
1321 #else
1322             cmUnpkLteRlcId( &rlcId, mBuf);
1323 #endif /* ERRCLASS & ERRCLS_DEBUG */
1324             break;
1325          }
1326 #endif /* LCKWU */
1327    }
1328    SPutMsg(mBuf);
1329
1330    return ((*func)(pst, suId, rlcId));
1331 } /* cmUnpkKwuReEstCmpInd */
1332
1333 /* kwu_c_001.main_3 added support for L2 Measurement */
1334 S16 cmUnpkKwuDiscSduCfm(KwuDiscSduCfm  func,Pst *pst,Buffer *mBuf)
1335 {
1336    S16 ret1 = ROK;
1337    SpId  spId = 0;
1338    KwuDiscSduInfo *discSdu = NULLP;
1339
1340
1341    CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1342
1343    switch(pst->selector)
1344    {
1345       case ODU_SELECTOR_LWLC:
1346          {
1347             CMCHKUNPK(oduUnpackPointer,(PTR *) &discSdu, mBuf);
1348          }
1349          break;
1350       case ODU_SELECTOR_LC:
1351          {
1352             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1353                         sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1354             {
1355 #if (ERRCLASS & ERRCLS_ADD_RES)
1356       if(ret1 != ROK)
1357       {
1358          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1359                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1360                (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1361       }
1362 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1363                return (ret1);
1364             }
1365             memset(discSdu, 0, sizeof(KwuDiscSduInfo));
1366
1367    ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1368 #if(ERRCLASS & ERRCLS_DEBUG)
1369             if(ret1 != ROK)
1370             {
1371                SPutMsg(mBuf);
1372                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1373                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1374                      (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1375             }
1376 #endif /* ERRCLASS & ERRCLS_DEBUG */
1377          }
1378          break;
1379       default:
1380           SPutMsg(mBuf);
1381 #if(ERRCLASS & ERRCLS_DEBUG)
1382           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1383                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1384                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1385 #endif
1386           return RFAILED;
1387    }
1388    SPutMsg(mBuf);
1389
1390    return ((*func)(pst, spId, discSdu));
1391 } /* cmUnpkKwuDiscSduCfm */
1392 S16 cmUnpkKwuFlowCntrlInd(KwuFlowCntrlInd func,Pst *pst,Buffer *mBuf)
1393 {
1394    SuId   suId;
1395    KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP;
1396
1397    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1398    switch(pst->selector)
1399    {
1400 #ifdef LCKWU
1401       case ODU_SELECTOR_LC:
1402       {
1403          if(SGetStaticBuffer(pst->region,
1404                      pst->pool,
1405                      (Data **)&flowCntrlInfo,
1406                      sizeof(KwuFlowCntrlIndInfo),0) != ROK)
1407          {
1408             SPutMsg(mBuf);
1409             return RFAILED;
1410          }
1411
1412          cmUnpkKwuFlowCntrlIndInfo(flowCntrlInfo, mBuf);
1413       }
1414       break;
1415
1416       case ODU_SELECTOR_LWLC:
1417       {
1418          CMCHKUNPK(oduUnpackPointer,(PTR *) &flowCntrlInfo, mBuf);
1419       }
1420       break;
1421 #endif
1422    }
1423
1424    SPutMsg(mBuf);
1425
1426    return ((*func)(pst, suId, flowCntrlInfo));
1427 } /* cmUnpkKwuFlowCntrlInd */
1428 #ifdef LTE_L2_MEAS
1429 \f
1430 S16 cmUnpkKwuDatAckInfo(KwuDatAckInfo *param,Buffer *mBuf)
1431 {
1432
1433    CMCHKUNPK(oduPackUInt32, &param->sduId, mBuf);
1434    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1435
1436    return ROK;
1437 }
1438
1439 \f
1440 S16 cmUnpkKwuDatAckInd(KwuDatAckInd func,Pst *pst,Buffer *mBuf)
1441 {
1442     S16 ret1;
1443     SuId          suId = 0;
1444     KwuDatAckInfo *datInd = NULLP;
1445
1446
1447     if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
1448                 sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
1449     {
1450 #if (ERRCLASS & ERRCLS_ADD_RES)
1451        if(ret1 != ROK)
1452        {
1453           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1454                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1455                 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1456        }
1457 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1458        return (ret1);
1459     }
1460
1461     memset(datInd, 0, sizeof(KwuDatAckInfo));
1462
1463     CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1464     ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf);
1465 #if(ERRCLASS & ERRCLS_DEBUG)
1466     if(ret1 != ROK)
1467     {
1468        SPutMsg(mBuf);
1469        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1470              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1471              (ErrVal)ERRKWU, (ErrVal)ret1, "Unpacking failure");
1472        return ( ret1 );
1473     }
1474 #endif /* ERRCLASS & ERRCLS_DEBUG */
1475
1476     return ((*func)(pst, suId, datInd));
1477 } /* cmUnpkKwuDatAckInd */
1478 #endif /* LTE_L2_MEAS */
1479 #endif /* LCKWU */
1480
1481 /**********************************************************************
1482          End of file
1483  **********************************************************************/