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 "envopt.h"        /* environment options */
  34 #include "envdep.h"        /* environment dependent */
  35 #include "envind.h"        /* environment independent */
  36
  37 #include "gen.h"           /* general */
  38 #include "ssi.h"           /* system services */
  39 #include "cm5.h"           /* common timer defines */
  40 #include "cm_tkns.h"       /* common tokens defines */
  41 #include "cm_mblk.h"       /* common memory allocation library defines */
  42 #include "cm_llist.h"      /* common link list  defines  */
  43 #include "cm_hash.h"       /* common hash list  defines */
  44 #include "cm_lte.h"        /* common LTE defines */
  45 #ifdef TENB_SPLIT_ARCH
  46 #include "ss_queue.h"
  47 #include "ss_task.h"
  48 #include "ss_msg.h"
  49 #endif
  50 #include "kwu.h"           /* KWU defines */
  51
  52 /* extern (.x) include files */
  53 #include "gen.x"           /* general */
  54 #include "ssi.x"           /* system services */
  55
  56 #include "cm5.x"           /* common timer library */
  57 #include "cm_tkns.x"       /* common tokens */
  58 #include "cm_mblk.x"       /* common memory allocation */
  59 #include "cm_llist.x"      /* common link list */
  60 #include "cm_hash.x"       /* common hash list */
  61 #include "cm_lte.x"        /* common LTE includes */
  62 #include "cm_lib.x"        /* common memory allocation library */
  63 #ifdef TENB_SPLIT_ARCH
  64 #include "ss_queue.x"
  65 #include "ss_task.x"
  66 #include "ss_msg.x"
  67 #endif
  68 #ifdef SS_RBUF
  69 #include "ss_rbuf.h"
  70 #include "ss_rbuf.x"
  71 #endif /*SS_RBUF*/
  72 #include "kwu.x"           /* KWU */
  73
  74 #ifdef LCKWU
  75 \f
  76 /****************************************************************************
  77  *                      Packing Functions
  78  ***************************************************************************/
  79 #ifdef ANSI
  80 PUBLIC S16 cmPkKwuBndReq
  81 (
  82 Pst * pst,
  83 SuId suId,
  84 SpId spId
  85 )
  86 #else
  87 PUBLIC S16 cmPkKwuBndReq(pst, suId, spId)
  88 Pst * pst;
  89 SuId suId;
  90 SpId spId;
  91 #endif
  92 {
  93    S16    ret1;
  94    Buffer *mBuf;
  95
  96    TRC3(cmPkKwuBndReq)
  97
  98    mBuf = NULLP;
  99
 100    if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 101    {
 102 #if (ERRCLASS & ERRCLS_ADD_RES)
 103       if(ret1 != ROK)
 104       {
 105          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 106                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 107                (ErrVal)EKWU001, (ErrVal)0, "SGetMsg() failed");
 108       }
 109 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 110       RETVALUE(ret1);
 111    }
 112    CMCHKPKLOG(SPkS16, spId, mBuf, EKWU002, pst);
 113    CMCHKPKLOG(SPkS16, suId, mBuf, EKWU003, pst);
 114    pst->event = (Event) KWU_EVT_BND_REQ;
 115    RETVALUE(SPstTsk(pst,mBuf));
 116 }
 117
 118 \f
 119 #ifdef ANSI
 120 PUBLIC S16 cmPkKwuBndCfm
 121 (
 122 Pst * pst,
 123 SuId suId,
 124 U8 status
 125 )
 126 #else
 127 PUBLIC S16 cmPkKwuBndCfm(pst, suId, status)
 128 Pst * pst;
 129 SuId suId;
 130 U8 status;
 131 #endif
 132 {
 133    S16    ret1;
 134    Buffer *mBuf;
 135
 136    TRC3(cmPkKwuBndCfm)
 137
 138    mBuf = NULLP;
 139
 140    if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 141    {
 142 #if (ERRCLASS & ERRCLS_ADD_RES)
 143       if(ret1 != ROK)
 144       {
 145          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 146                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 147                (ErrVal)EKWU004, (ErrVal)0, "SGetMsg() failed");
 148       }
 149 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 150       RETVALUE(ret1);
 151    }
 152
 153    CMCHKPKLOG(SPkU8, status, mBuf, EKWU005, pst);
 154    CMCHKPKLOG(SPkS16, suId, mBuf, EKWU006, pst);
 155    pst->event = (Event) KWU_EVT_BND_CFM;
 156    RETVALUE(SPstTsk(pst,mBuf));
 157 }
 158
 159 \f
 160 #ifdef ANSI
 161 PUBLIC S16 cmPkKwuUbndReq
 162 (
 163 Pst * pst,
 164 SuId suId,
 165 Reason reason
 166 )
 167 #else
 168 PUBLIC S16 cmPkKwuUbndReq(pst, suId, reason)
 169 Pst * pst;
 170 SuId suId;
 171 Reason reason;
 172 #endif
 173 {
 174    S16 ret1;
 175    Buffer *mBuf;
 176
 177    TRC3(cmPkKwuUbndReq)
 178
 179    mBuf = NULLP;
 180
 181    if((ret1 = SGetMsg(pst->region, pst->pool, &mBuf)) != ROK)
 182    {
 183 #if (ERRCLASS & ERRCLS_ADD_RES)
 184       if(ret1 != ROK)
 185       {
 186          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 187                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 188                (ErrVal)EKWU007, (ErrVal)0, "SGetMsg() failed");
 189       }
 190 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 191       RETVALUE(ret1);
 192    }
 193    CMCHKPKLOG(SPkS16, reason, mBuf, EKWU008, pst);
 194    CMCHKPKLOG(SPkS16, suId, mBuf, EKWU009, pst);
 195
 196    pst->event = (Event) KWU_EVT_UBND_REQ;
 197    RETVALUE(SPstTsk(pst,mBuf));
 198 } /* cmPkKwuUbndReq */
 199
 200 #ifdef ANSI
 201 PUBLIC S16 cmPkKwuDatReqInfo
 202 (
 203 KwuDatReqInfo *param,
 204 Buffer *mBuf
 205 )
 206 #else
 207 PUBLIC S16 cmPkKwuDatReqInfo(param, mBuf)
 208 KwuDatReqInfo *param;
 209 Buffer *mBuf;
 210 #endif
 211 {
 212
 213    TRC3(cmPkKwuDatReqInfo);
 214
 215 #ifdef CCPU_OPT
 216    switch(param->lcType) {
 217       case CM_LTE_LCH_CCCH:
 218          CMCHKPK(cmPkLteRnti, param->tm.rnti, mBuf);
 219          break;
 220       case CM_LTE_LCH_BCCH:
 221       case  CM_LTE_LCH_PCCH:
 222          CMCHKPK(cmPkLteTimingInfo, &param->tm.tmg, mBuf);
 223 #ifdef EMTC_ENABLE
 224          CMCHKPK(SPkU8, param->emtcDiReason,mBuf);
 225          CMCHKPK(SPkU8, param->pnb,mBuf);
 226 #endif
 227          break;
 228       case CM_LTE_LCH_DTCH:
 229       case CM_LTE_LCH_DCCH:
 230          break;
 231       default :
 232          RETVALUE(RFAILED);
 233    }
 234    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
 235
 236 #endif
 237    CMCHKPK(SPkU32, param->sduId, mBuf);
 238    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 239    RETVALUE(ROK);
 240 } /* cmPkKwuDatReqInfo */
 241
 242 \f
 243 #ifdef ANSI
 244 PUBLIC S16 cmPkKwuDatReq
 245 (
 246 Pst * pst,
 247 SpId spId,
 248 KwuDatReqInfo* datReq,
 249 Buffer * mBuf
 250 )
 251 #else
 252 PUBLIC S16 cmPkKwuDatReq(pst, spId, datReq, mBuf)
 253 Pst * pst;
 254 SpId spId;
 255 KwuDatReqInfo* datReq;
 256 Buffer * mBuf;
 257 #endif
 258 {
 259 #ifdef LCKWU
 260 #if (ERRCLASS & ERRCLS_ADD_RES)
 261 #endif
 262 #endif /* LCKWU */
 263    S16 ret1 = ROK;
 264 #ifndef SS_RBUF
 265    KwuDatReqInfo* datReqInfo;
 266 #endif
 267     TRC3(cmPkKwuDatReq)
 268 #ifndef SS_RBUF
 269    switch(pst->selector)
 270    {
 271      case KWU_SEL_LWLC:
 272         {
 273            if(pst->srcEnt == ENTPJ)
 274            {
 275              /* When the Selector is LWLC, we need to allocate memory, copy
 276               * the contents and pass the pointer of the allocated memory. The
 277               * subsequent free would be done during the Unpack function of the
 278               * primitive. */
 279             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReqInfo,
 280                         sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
 281             {
 282 #if (ERRCLASS & ERRCLS_ADD_RES)
 283                if(ret1 != ROK)
 284                {
 285                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 286                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 287                         (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
 288                }
 289 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 290                RETVALUE(ret1);
 291             }
 292             cmMemcpy((U8*)datReqInfo,(U8*)datReq,sizeof(KwuDatReqInfo));
 293             CMCHKPK(cmPkPtr,(PTR)datReqInfo, mBuf);
 294            }
 295            else
 296            {
 297             CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
 298            }
 299         }
 300         break;
 301      case KWU_SEL_LC:
 302         {
 303 #if (ERRCLASS & ERRCLS_ADD_RES)
 304            ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
 305            if(ret1 != ROK)
 306            {
 307               SPutMsg(mBuf);
 308               SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 309                     __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 310                     (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
 311               RETVALUE( ret1 );
 312            }
 313 #else
 314            cmPkKwuDatReqInfo( (datReq), mBuf);
 315 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 316            if(pst->srcEnt == ENTNH)
 317            {
 318               if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
 319                        sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
 320               {
 321                  SPutMsg(mBuf);
 322                  RETVALUE(RFAILED);
 323               }
 324            }
 325         }
 326         break;
 327      default:
 328           SPutMsg(mBuf);
 329 #if (ERRCLASS & ERRCLS_ADD_RES)
 330           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 331                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 332                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 333 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 334           RETVALUE(RFAILED);
 335    }
 336
 337     CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
 338 #ifdef L2_L3_SPLIT
 339     if(datReq->rlcId.rbType == CM_LTE_SRB)
 340     {
 341        pst->event = (Event) KWU_EVT_CPLANE_DAT_REQ;
 342     }
 343     else
 344     {
 345        pst->event = (Event) KWU_EVT_UPLANE_DAT_REQ;
 346     }
 347 #else
 348     pst->event = (Event) KWU_EVT_DAT_REQ;
 349 #endif
 350     RETVALUE(SPstTsk(pst,mBuf));
 351 #else
 352    if (pst->srcEnt == ENTPJ)
 353    {
 354       Void *elem = NULLP;
 355       KwuDatReqDetl *kwuDatReqDetl = NULLP;
 356       elem = SRngGetWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
 357       if (NULLP != elem)
 358       {
 359          kwuDatReqDetl = (KwuDatReqDetl *) elem;
 360          kwuDatReqDetl->spId = spId;
 361          kwuDatReqDetl->lcType = datReq->lcType;
 362          kwuDatReqDetl->sduId = datReq->sduId;
 363          kwuDatReqDetl->rlcId = datReq->rlcId;
 364          kwuDatReqDetl->mBuf = mBuf;
 365          SRngIncrWIndx(SS_RNG_BUF_DLPDCP_TO_DLRLC);
 366          SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktRate++;
 367          ret1 = ROK;
 368       }
 369       else
 370       {
 371          SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].pktDrop++;
 372          SPutMsg(mBuf);
 373          ret1 = RFAILED;
 374       }
 375    }
 376    else
 377    {
 378       switch(pst->selector)
 379       {
 380 #ifdef LCKWU
 381          case KWU_SEL_LC:
 382             {
 383                ret1 = cmPkKwuDatReqInfo( (datReq), mBuf);
 384 #if (ERRCLASS & ERRCLS_ADD_RES)
 385                if(ret1 != ROK)
 386                {
 387                   SPutMsg(mBuf);
 388                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 389                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 390                         (ErrVal)EKWU010, (ErrVal)ret1, "Packing failure");
 391                   RETVALUE( ret1 );
 392                }
 393 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 394             }
 395             break;
 396          case KWU_SEL_LWLC:
 397             {
 398                CMCHKPK(cmPkPtr,(PTR)datReq, mBuf);
 399             }
 400             break;
 401 #endif /* LCKWU */
 402       }
 403
 404       CMCHKPKLOG(SPkS16, spId, mBuf, EKWU011, pst);
 405       pst->event = (Event) KWU_EVT_DAT_REQ;
 406       ret1 = SPstTsk(pst,mBuf);
 407       if(pst->selector == KWU_SEL_LC)
 408       {
 409          if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
 410                   sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY) != ROK)
 411          {
 412             SPutMsg(mBuf);
 413             RETVALUE(RFAILED);
 414          }
 415       }
 416    }
 417    RETVALUE(ret1);
 418 #endif
 419 } /* cmPkKwuDatReq */
 420
 421 \f
 422 #ifdef ANSI
 423 PUBLIC S16 cmPkKwuDatIndInfo
 424 (
 425 KwuDatIndInfo *param,
 426 Buffer *mBuf
 427 )
 428 #else
 429 PUBLIC S16 cmPkKwuDatIndInfo(param, mBuf)
 430 KwuDatIndInfo *param;
 431 Buffer *mBuf;
 432 #endif
 433 {
 434    TRC3(cmPkKwuDatIndInfo);
 435
 436    CMCHKPK(SPkU8, param->isOutOfSeq, mBuf);
 437 #ifdef CCPU_OPT
 438    CMCHKPK(cmPkLteRnti, param->tCrnti, mBuf);
 439 #endif
 440    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 441    RETVALUE(ROK);
 442 }
 443
 444 \f
 445 #ifdef ANSI
 446 PUBLIC S16 cmPkKwuDatInd
 447 (
 448 Pst * pst,
 449 SuId suId,
 450 KwuDatIndInfo* datInd,
 451 Buffer * mBuf
 452 )
 453 #else
 454 PUBLIC S16 cmPkKwuDatInd(pst, suId, datInd, mBuf)
 455 Pst * pst;
 456 SuId suId;
 457 KwuDatIndInfo* datInd;
 458 Buffer * mBuf;
 459 #endif
 460 {
 461 #ifdef LCKWU
 462     S16 ret1 = ROK;
 463 #endif /* LCKWU */
 464 #ifdef TENB_SPLIT_ARCH
 465 #ifdef SS_LOCKLESS_MEMORY
 466     SsMsgInfo   *mInfo;
 467 #endif
 468 #endif
 469     KwuDatIndInfo *datIndInfo = NULLP;
 470
 471     TRC3(cmPkKwuDatInd)
 472
 473 #ifdef TENB_SPLIT_ARCH
 474     /* SSI_CHANGES: */
 475 #ifdef SS_LOCKLESS_MEMORY
 476     mInfo = (SsMsgInfo *)mBuf->b_rptr;
 477     mInfo->region = pst->region;
 478 #endif /* SS_LOCKLESS_MEMORY */
 479 #endif
 480
 481     switch(pst->selector)
 482     {
 483        case KWU_SEL_LWLC:
 484           {
 485              /* When the Selector is LWLC, we need to allocate memory, copy
 486               * the contents and pass the pointer of the allocated memory. The
 487               * subsequent free would be done during the Unpack function of the
 488               * primitive. */
 489             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datIndInfo,
 490                         sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
 491             {
 492 #if (ERRCLASS & ERRCLS_ADD_RES)
 493                if(ret1 != ROK)
 494                {
 495                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 496                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 497                         (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
 498                }
 499 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 500                RETVALUE(ret1);
 501             }
 502
 503             cmMemcpy((U8*)datIndInfo,(U8*)datInd,sizeof(KwuDatIndInfo));
 504             CMCHKPK(cmPkPtr,(PTR)datIndInfo, mBuf);
 505           }
 506           break;
 507        case KWU_SEL_LC:
 508           {
 509 #if (ERRCLASS & ERRCLS_ADD_RES)
 510              ret1 = cmPkKwuDatIndInfo( (datInd), mBuf);
 511              if(ret1 != ROK)
 512              {
 513                 SPutMsg(mBuf);
 514                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 515                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 516                       (ErrVal)EKWU012, (ErrVal)ret1, "Packing failure");
 517                 RETVALUE( ret1 );
 518              }
 519 #else
 520              cmPkKwuDatIndInfo( (datInd), mBuf);
 521 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 522 #if 0
 523              /*Commenting out the below block as no Memory Allocation happens
 524               * in Protocol. This code will be removed once testing is done */
 525              if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
 526                       sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY) != ROK)
 527              {
 528                 SPutMsg(mBuf);
 529                 RETVALUE(RFAILED);
 530              }
 531 #endif
 532           }
 533           break;
 534        default:
 535           SPutMsg(mBuf);
 536 #if (ERRCLASS & ERRCLS_ADD_RES)
 537           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 538                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 539                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 540 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 541           RETVALUE(RFAILED);
 542     }
 543
 544     CMCHKPKLOG(SPkS16, suId, mBuf, EKWU013, pst);
 545     pst->event = (Event) KWU_EVT_DAT_IND;
 546
 547     RETVALUE(SPstTsk(pst,mBuf));
 548 } /* cmPkKwuDatInd */
 549
 550 \f
 551 #ifdef ANSI
 552 PUBLIC S16 cmPkKwuDatCfmInfo
 553 (
 554 KwuDatCfmInfo *param,
 555 Buffer *mBuf
 556 )
 557 #else
 558 PUBLIC S16 cmPkKwuDatCfmInfo(param, mBuf)
 559 KwuDatCfmInfo *param;
 560 Buffer *mBuf;
 561 #endif
 562 {
 563    register U32 iter;
 564
 565    TRC3(cmPkKwuDatCfmInfo);
 566    for(iter = 0; iter < param->numSduIds; iter++)
 567    {
 568       CMCHKPK(SPkU32, param->sduIds[iter], mBuf);
 569    }
 570    CMCHKPK(SPkU32, param->numSduIds, mBuf);
 571    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 572    RETVALUE(ROK);
 573 } /* cmPkKwuDatCfmInfo */
 574
 575 \f
 576 #ifdef ANSI
 577 PUBLIC S16 cmPkKwuDatCfm
 578 (
 579 Pst * pst,
 580 SuId suId,
 581 KwuDatCfmInfo* datCfm
 582 )
 583 #else
 584 PUBLIC S16 cmPkKwuDatCfm(pst, suId, datCfm)
 585 Pst * pst;
 586 SuId suId;
 587 KwuDatCfmInfo* datCfm;
 588 #endif
 589 {
 590 #if (ERRCLASS & ERRCLS_ADD_RES)
 591    S16 ret1= ROK;
 592 #endif
 593    Buffer *mBuf;
 594
 595    TRC3(cmPkKwuDatCfm)
 596
 597    mBuf = NULLP;
 598
 599    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 600       RETVALUE(RFAILED);
 601    }
 602
 603    switch(pst->selector)
 604    {
 605       case KWU_SEL_LWLC:
 606          {
 607             CMCHKPK(cmPkPtr,(PTR)datCfm, mBuf);
 608          }
 609          break;
 610       case KWU_SEL_LC:
 611          {
 612 #if (ERRCLASS & ERRCLS_ADD_RES)
 613             ret1 = cmPkKwuDatCfmInfo( (datCfm), mBuf);
 614             if(ret1 != ROK)
 615             {
 616                SPutMsg(mBuf);
 617                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 618                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 619                      (ErrVal)EKWU014, (ErrVal)ret1, "Packing failure");
 620                RETVALUE( ret1 );
 621             }
 622 #else
 623             cmPkKwuDatCfmInfo( (datCfm), mBuf);
 624 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 625             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datCfm,
 626                      sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY) != ROK)
 627             {
 628                SPutMsg(mBuf);
 629                RETVALUE(RFAILED);
 630             }
 631          }
 632          break;
 633       default:
 634           SPutMsg(mBuf);
 635 #if (ERRCLASS & ERRCLS_ADD_RES)
 636           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 637                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 638                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 639 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 640           RETVALUE(RFAILED);
 641    }
 642
 643     CMCHKPKLOG(SPkS16, suId, mBuf, EKWU015, pst);
 644     pst->event = (Event) KWU_EVT_DAT_CFM;
 645
 646     RETVALUE(SPstTsk(pst,mBuf));
 647 } /* cmPkKwuDatCfm */
 648
 649 \f
 650 #ifdef ANSI
 651 PUBLIC S16 cmPkKwuDiscSduReq
 652 (
 653 Pst * pst,
 654 SpId spId,
 655 KwuDiscSduInfo* discSdu
 656 )
 657 #else
 658 PUBLIC S16 cmPkKwuDiscSduReq(pst, spId, discSdu)
 659 Pst * pst;
 660 SpId spId;
 661 KwuDiscSduInfo* discSdu;
 662 #endif
 663 {
 664 #ifdef LCKWU
 665    S16 ret1;
 666 #endif /* LCKWU */
 667    Buffer *mBuf;
 668    KwuDiscSduInfo* discSduInfo = NULLP;
 669
 670    TRC3(cmPkKwuDiscSduReq)
 671    mBuf = NULLP;
 672
 673    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 674       RETVALUE(RFAILED);
 675    }
 676
 677    switch(pst->selector)
 678    {
 679       case KWU_SEL_LWLC:
 680          {
 681             /* When the Selector is LWLC, we need to allocate memory, copy
 682              * the contents and pass the pointer of the allocated memory. The
 683              * subsequent free would be done during the Unpack function of the
 684              * primitive. */
 685            if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSduInfo,
 686                        sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
 687            {
 688 #if (ERRCLASS & ERRCLS_ADD_RES)
 689               if(ret1 != ROK)
 690               {
 691                  SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 692                        __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 693                         (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
 694               }
 695 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 696               RETVALUE(ret1);
 697            }
 698
 699            cmMemcpy((U8*)discSduInfo,(U8*)discSdu,sizeof(KwuDiscSduInfo));
 700            CMCHKPK(cmPkPtr,(PTR)discSduInfo, mBuf);
 701          }
 702          break;
 703       case KWU_SEL_LC:
 704          {
 705 #if (ERRCLASS & ERRCLS_ADD_RES)
 706             ret1 = cmPkKwuDiscSduInfo( (discSdu), mBuf);
 707             if(ret1 != ROK)
 708             {
 709                SPutMsg(mBuf);
 710                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 711                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 712                      (ErrVal)EKWU016, (ErrVal)ret1, "Packing failure");
 713                RETVALUE( ret1 );
 714             }
 715 #else
 716             cmPkKwuDiscSduInfo( (discSdu), mBuf);
 717 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 718 #if 0
 719              if (SPutSBuf(pst->region, pst->pool, (Data *)discSdu,
 720                       sizeof(KwuDiscSduInfo)) != ROK)
 721              {
 722                 SPutMsg(mBuf);
 723                 RETVALUE(RFAILED);
 724              }
 725 #endif
 726              break;
 727           }
 728     }
 729
 730     CMCHKPKLOG(SPkS16, spId, mBuf, EKWU017, pst);
 731     pst->event = (Event) KWU_EVT_DISC_SDU_REQ;
 732
 733     RETVALUE(SPstTsk(pst,mBuf));
 734 } /* cmPkKwuDiscSduReq */
 735
 736 \f
 737 #ifdef ANSI
 738 PUBLIC S16 cmPkKwuStaIndInfo
 739 (
 740 KwuStaIndInfo *param,
 741 Buffer *mBuf
 742 )
 743 #else
 744 PUBLIC S16 cmPkKwuStaIndInfo(param, mBuf)
 745 KwuStaIndInfo *param;
 746 Buffer *mBuf;
 747 #endif
 748 {
 749    S16 i;
 750
 751    TRC3(cmPkKwuStaIndInfo);
 752
 753    for (i = (param->numSdu - 1); i >= 0; i--)
 754    {
 755       CMCHKPK(SPkU32, param->sduId[(U16)i], mBuf);
 756    }
 757    CMCHKPK(SPkU32, param->numSdu, mBuf);
 758    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 759    RETVALUE(ROK);
 760 }
 761
 762 #ifdef ANSI
 763 PUBLIC S16 cmPkKwuFlowCntrlIndInfo
 764 (
 765 KwuFlowCntrlIndInfo *param,
 766 Buffer              *mBuf
 767 )
 768 #else
 769 PUBLIC S16 cmPkKwuFlowCntrlIndInfo(param, mBuf)
 770 KwuFlowCntrlIndInfo  *param;
 771 Buffer               *mBuf;
 772 #endif
 773 {
 774    TRC3(cmPkKwuFlowCntrlIndInfo);
 775
 776    CMCHKPK(SPkU32, param->pktAdmitCnt, mBuf);
 777    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
 778
 779    RETVALUE(ROK);
 780 } /* cmPkKwuFlowCntrlIndInfo */
 781
 782 #ifdef ANSI
 783 PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo
 784 (
 785 KwuFlowCntrlIndInfo *param,
 786 Buffer              *mBuf
 787 )
 788 #else
 789 PUBLIC S16 cmUnpkKwuFlowCntrlIndInfo(param, mBuf)
 790 KwuFlowCntrlIndInfo  *param;
 791 Buffer               *mBuf;
 792 #endif
 793 {
 794    TRC3(cmUnpkKwuFlowCntrlIndInfo);
 795
 796    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
 797    CMCHKUNPK(SUnpkU32, &param->pktAdmitCnt, mBuf);
 798
 799    RETVALUE(ROK);
 800 } /* cmUnpkKwuFlowCntrlIndInfo */
 801
 802 \f
 803 #ifdef ANSI
 804 PUBLIC S16 cmPkKwuStaInd
 805 (
 806 Pst * pst,
 807 SuId suId,
 808 KwuStaIndInfo* staInd
 809 )
 810 #else
 811 PUBLIC S16 cmPkKwuStaInd(pst, suId, staInd)
 812 Pst * pst;
 813 SuId suId;
 814 KwuStaIndInfo* staInd;
 815 #endif
 816 {
 817 #ifdef LCKWU
 818 #if (ERRCLASS & ERRCLS_ADD_RES)
 819    S16 ret1 = ROK;
 820 #endif
 821 #endif /* LCKWU */
 822    Buffer *mBuf;
 823
 824    TRC3(cmPkKwuStaInd)
 825
 826    mBuf = NULLP;
 827
 828    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 829       RETVALUE(RFAILED);
 830    }
 831
 832     switch(pst->selector)
 833     {
 834        case KWU_SEL_LWLC:
 835           {
 836              CMCHKPK(cmPkPtr,(PTR) staInd, mBuf);
 837           }
 838           break;
 839        case KWU_SEL_LC:
 840           {
 841 #if (ERRCLASS & ERRCLS_ADD_RES)
 842              ret1 = cmPkKwuStaIndInfo( (staInd), mBuf);
 843              if(ret1 != ROK)
 844              {
 845                 SPutMsg(mBuf);
 846                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 847                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 848                       (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
 849                 RETVALUE( ret1 );
 850              }
 851 #else
 852              cmPkKwuStaIndInfo( (staInd), mBuf);
 853 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 854              if (SPutStaticBuffer(pst->region, pst->pool, (Data *)staInd,
 855                       sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY) != ROK)
 856              {
 857                 SPutMsg(mBuf);
 858                 RETVALUE(RFAILED);
 859              }
 860           }
 861           break;
 862        default:
 863           SPutMsg(mBuf);
 864 #if (ERRCLASS & ERRCLS_ADD_RES)
 865           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 866                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 867                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
 868 #endif
 869           RETVALUE(RFAILED);
 870     }
 871
 872     CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
 873     pst->event = (Event) KWU_EVT_STA_IND;
 874
 875     RETVALUE(SPstTsk(pst,mBuf));
 876 } /* cmPkKwuStaInd */
 877
 878 \f
 879 #ifdef ANSI
 880 PUBLIC S16 cmPkKwuReEstCmpInd
 881 (
 882 Pst * pst,
 883 SuId suId,
 884 CmLteRlcId rlcId
 885 )
 886 #else
 887 PUBLIC S16 cmPkKwuReEstCmpInd(pst, suId, rlcId)
 888 Pst * pst;
 889 SuId suId;
 890 CmLteRlcId rlcId;
 891 #endif
 892 {
 893 #ifdef LCKWU
 894 #if (ERRCLASS & ERRCLS_ADD_RES)
 895    S16 ret1;
 896 #endif
 897 #endif /* LCKWU */
 898    Buffer *mBuf;
 899
 900    TRC3(cmPkKwuReEstCmpInd)
 901
 902    mBuf = NULLP;
 903
 904    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 905       RETVALUE(RFAILED);
 906    }
 907
 908     switch(pst->selector)
 909     {
 910 #ifdef LCKWU
 911        case KWU_SEL_LC:
 912           {
 913 #if (ERRCLASS & ERRCLS_ADD_RES)
 914              ret1 = cmPkLteRlcId( &rlcId, mBuf);
 915              if(ret1 != ROK)
 916              {
 917                 SPutMsg(mBuf);
 918                 SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 919                       __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 920                       (ErrVal)EKWU018, (ErrVal)ret1, "Packing failure");
 921                 RETVALUE( ret1 );
 922              }
 923 #else
 924              cmPkLteRlcId( &rlcId, mBuf);
 925 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 926              break;
 927           }
 928 #endif /* LCKWU */
 929     }
 930
 931     CMCHKPKLOG(SPkS16, suId, mBuf, EKWU019, pst);
 932     pst->event = (Event) KWU_EVT_REEST_CMP_IND;
 933
 934     RETVALUE(SPstTsk(pst,mBuf));
 935 } /* cmPkKwuReEstCmpInd */
 936
 937 /* kwu_c_001.main_3 added support for L2 Measurement */
 938 #ifdef ANSI
 939 PUBLIC S16 cmPkKwuDiscSduCfm
 940 (
 941 Pst            *pst,
 942 SpId           spId,
 943 KwuDiscSduInfo *discCfmSdu
 944 )
 945 #else
 946 PUBLIC S16 cmPkKwuDiscSduCfm(pst, spId, discCfmSdu)
 947 Pst            *pst;
 948 SpId           spId;
 949 KwuDiscSduInfo *discCfmSdu;
 950 #endif
 951 {
 952 #if (ERRCLASS & ERRCLS_ADD_RES)
 953    S16 ret1 = ROK;
 954 #endif
 955    Buffer *mBuf;
 956
 957    TRC3(cmPkKwuDiscSduCfm)
 958
 959    mBuf = NULLP;
 960
 961    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
 962       RETVALUE(RFAILED);
 963    }
 964
 965    switch(pst->selector)
 966    {
 967       case KWU_SEL_LWLC:
 968          {
 969             CMCHKPK(cmPkPtr,(PTR)discCfmSdu, mBuf);
 970          }
 971          break;
 972       case KWU_SEL_LC:
 973          {
 974 #if (ERRCLASS & ERRCLS_ADD_RES)
 975             ret1 = cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
 976             if(ret1 != ROK)
 977             {
 978                SPutMsg(mBuf);
 979                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 980                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
 981                      (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
 982                RETVALUE( ret1 );
 983             }
 984 #else
 985             cmPkKwuDiscSduInfo((discCfmSdu), mBuf);
 986 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
 987             if (SPutStaticBuffer(pst->region, pst->pool, (Data *)discCfmSdu,
 988                      sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY) != ROK)
 989             {
 990                SPutMsg(mBuf);
 991                RETVALUE(RFAILED);
 992             }
 993          }
 994          break;
 995       default:
 996          SPutMsg(mBuf);
 997 #if (ERRCLASS & ERRCLS_ADD_RES)
 998          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
 999                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1000                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1001 #endif
1002           RETVALUE(RFAILED);
1003    }
1004
1005    CMCHKPKLOG(SPkS16, spId, mBuf, ERRKWU, pst);
1006    pst->event = (Event) KWU_EVT_DISC_SDU_CFM;
1007
1008    RETVALUE(SPstTsk(pst,mBuf));
1009 } /* cmPkKwuDiscSduCfm */
1010 \f
1011 #ifdef ANSI
1012 PUBLIC S16 cmPkKwuFlowCntrlInd
1013 (
1014 Pst            *pst,
1015 SuId           suId,
1016 KwuFlowCntrlIndInfo *flowCntrlIndInfo
1017 )
1018 #else
1019 PUBLIC S16 cmPkKwuFlowCntrlInd(pst, suId, flowCntrlIndInfo)
1020 Pst            *pst;
1021 SuId           suId;
1022 KwuFlowCntrlIndInfo *flowCntrlIndInfo;
1023 #endif
1024 {
1025    Buffer *mBuf;
1026
1027    TRC3(cmPkKwuFlowCntrlInd)
1028
1029    mBuf = NULLP;
1030
1031    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
1032    {
1033       SPutStaticBuffer(pst->region,
1034                pst->pool,
1035                (Data *)flowCntrlIndInfo,
1036                sizeof(KwuFlowCntrlIndInfo),0);
1037       RETVALUE(RFAILED);
1038    }
1039 #ifdef LCKWU
1040    switch(pst->selector)
1041    {
1042       case KWU_SEL_LC:
1043       {
1044          cmPkKwuFlowCntrlIndInfo((flowCntrlIndInfo), mBuf);
1045
1046          if (SPutStaticBuffer(pst->region,
1047                       pst->pool,
1048                       (Data *)flowCntrlIndInfo,
1049                       sizeof(KwuFlowCntrlIndInfo),0) != ROK)
1050          {
1051             SPutMsg(mBuf);
1052             RETVALUE(RFAILED);
1053          }
1054       }
1055       break;
1056
1057       case KWU_SEL_LWLC:
1058       {
1059          CMCHKPK(cmPkPtr,(PTR) flowCntrlIndInfo, mBuf);
1060       }
1061       break;
1062    }
1063 #endif
1064
1065    CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
1066    pst->event = (Event) KWU_EVT_FLOW_CNTRL_IND;
1067
1068    RETVALUE(SPstTsk(pst,mBuf));
1069 } /* cmPkKwuFlowCntrlInd */
1070
1071 #ifdef LTE_L2_MEAS
1072 #ifdef ANSI
1073 PUBLIC S16 cmPkKwuDatAckInfo
1074 (
1075 KwuDatAckInfo *param,
1076 Buffer *mBuf
1077 )
1078 #else
1079 PUBLIC S16 cmPkKwuDatAckInfo(param, mBuf)
1080 KwuDatAckInfo *param;
1081 Buffer *mBuf;
1082 #endif
1083 {
1084    TRC3(cmPkKwuDatAckIndInfo);
1085
1086    CMCHKPK(cmPkLteRlcId, &param->rlcId, mBuf);
1087    CMCHKPK(SPkU32, param->sduId, mBuf);
1088    RETVALUE(ROK);
1089 }
1090
1091 #ifdef ANSI
1092 PUBLIC S16 cmPkKwuDatAckInd
1093 (
1094 Pst * pst,
1095 SuId suId,
1096 KwuDatAckInfo* datInd
1097 )
1098 #else
1099 PUBLIC S16 cmPkKwuDatAckInd(pst, suId, datInd)
1100 Pst * pst;
1101 SuId suId;
1102 KwuDatAckInfo* datInd;
1103 #endif
1104 {
1105     S16 ret1;
1106
1107    Buffer *mBuf;
1108
1109    TRC3(cmPkKwuDatAckInd);
1110
1111    mBuf = NULLP;
1112
1113    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
1114       RETVALUE(RFAILED);
1115    }
1116
1117    ret1 = cmPkKwuDatAckInfo( (datInd), mBuf);
1118 #if (ERRCLASS & ERRCLS_ADD_RES)
1119    if(ret1 != ROK)
1120    {
1121       SPutMsg(mBuf);
1122       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1123             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1124             (ErrVal)ERRKWU, (ErrVal)ret1, "Packing failure");
1125       RETVALUE( ret1 );
1126    }
1127 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1128    if (SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
1129             sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY) != ROK)
1130    {
1131       SPutMsg(mBuf);
1132       RETVALUE(RFAILED);
1133    }
1134
1135    CMCHKPKLOG(SPkS16, suId, mBuf, ERRKWU, pst);
1136    pst->event = (Event) KWU_EVT_DAT_ACK_IND;
1137
1138    RETVALUE(SPstTsk(pst,mBuf));
1139 } /* cmPkKwuDatAckInd */
1140 #endif /* LTE_L2_MEAS */
1141
1142 \f
1143 #ifdef ANSI
1144 PUBLIC S16 cmUnpkKwuBndReq
1145 (
1146 KwuBndReq func,
1147 Pst *pst,
1148 Buffer *mBuf
1149 )
1150 #else
1151 PUBLIC S16 cmUnpkKwuBndReq(func, pst, mBuf)
1152 KwuBndReq func;
1153 Pst *pst;
1154 Buffer *mBuf;
1155 #endif
1156 {
1157    SuId suId = 0;
1158    SpId spId = 0;
1159
1160    TRC3(cmUnpkKwuBndReq)
1161
1162    CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU020, pst);
1163    CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU021, pst);
1164    SPutMsg(mBuf);
1165
1166    RETVALUE((*func)(pst, suId, spId));
1167 }
1168
1169 \f
1170 #ifdef ANSI
1171 PUBLIC S16 cmUnpkKwuBndCfm
1172 (
1173 KwuBndCfm func,
1174 Pst *pst,
1175 Buffer *mBuf
1176 )
1177 #else
1178 PUBLIC S16 cmUnpkKwuBndCfm(func, pst, mBuf)
1179 KwuBndCfm func;
1180 Pst *pst;
1181 Buffer *mBuf;
1182 #endif
1183 {
1184    SuId suId = 0;
1185    U8 status = 0;
1186
1187    TRC3(cmUnpkKwuBndCfm)
1188
1189    CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
1190    CMCHKUNPKLOG(SUnpkU8, &status, mBuf, EKWU023, pst);
1191    SPutMsg(mBuf);
1192
1193    RETVALUE((*func)(pst, suId, status));
1194 }
1195
1196 \f
1197 #ifdef ANSI
1198 PUBLIC S16 cmUnpkKwuUbndReq
1199 (
1200 KwuUbndReq func,
1201 Pst *pst,
1202 Buffer *mBuf
1203 )
1204 #else
1205 PUBLIC S16 cmUnpkKwuUbndReq(func, pst, mBuf)
1206 KwuUbndReq func;
1207 Pst *pst;
1208 Buffer *mBuf;
1209 #endif
1210 {
1211    SpId spId = 0;
1212    Reason reason = 0;
1213
1214    TRC3(cmUnpkKwuUbndReq)
1215
1216    CMCHKUNPKLOG(SUnpkS16, &spId, mBuf, EKWU024, pst);
1217    CMCHKUNPKLOG(SUnpkS16, &reason, mBuf, EKWU025, pst);
1218    SPutMsg(mBuf);
1219
1220    RETVALUE((*func)(pst, spId, reason));
1221 } /* cmUnpkKwuUbndReq */
1222
1223 \f
1224 #ifdef ANSI
1225 PUBLIC S16 cmUnpkKwuDatReqInfo
1226 (
1227 KwuDatReqInfo *param,
1228 Buffer *mBuf
1229 )
1230 #else
1231 PUBLIC S16 cmUnpkKwuDatReqInfo(param, mBuf)
1232 KwuDatReqInfo *param;
1233 Buffer *mBuf;
1234 #endif
1235 {
1236
1237    TRC3(cmUnpkKwuDatReqInfo);
1238
1239    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1240    CMCHKUNPK(SUnpkU32, &param->sduId, mBuf);
1241
1242 #ifdef CCPU_OPT
1243    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
1244    switch(param->lcType) {
1245       case CM_LTE_LCH_BCCH:
1246       case  CM_LTE_LCH_PCCH:
1247 #ifdef EMTC_ENABLE
1248          CMCHKUNPK(SUnpkU8,&param->pnb , mBuf);
1249          CMCHKUNPK(SUnpkU8,&param->emtcDiReason , mBuf);
1250 #endif
1251          CMCHKUNPK(cmUnpkLteTimingInfo, &param->tm.tmg, mBuf);
1252
1253          break;
1254       case CM_LTE_LCH_CCCH:
1255          CMCHKUNPK(cmUnpkLteRnti, &param->tm.rnti, mBuf);
1256          break;
1257       case CM_LTE_LCH_DTCH:
1258       case CM_LTE_LCH_DCCH:
1259          break;
1260       default :
1261          RETVALUE(RFAILED);
1262    }
1263 #endif
1264    RETVALUE(ROK);
1265 }
1266
1267 \f
1268 #ifdef ANSI
1269 PUBLIC S16 cmUnpkKwuDatReq
1270 (
1271 KwuDatReq func,
1272 Pst *pst,
1273 Buffer *mBuf
1274 )
1275 #else
1276 PUBLIC S16 cmUnpkKwuDatReq(func, pst, mBuf)
1277 KwuDatReq func;
1278 Pst *pst;
1279 Buffer *mBuf;
1280 #endif
1281 {
1282 #if(ERRCLASS & ERRCLS_DEBUG)
1283    S16 ret1 = ROK;
1284 #endif
1285    S16 retVal;
1286    SpId          spId = 0;
1287    KwuDatReqInfo *datReq = NULLP;
1288    KwuDatReqInfo datReqTmp;
1289
1290    TRC3(cmUnpkKwuDatReq)
1291
1292
1293       CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1294
1295    switch(pst->selector)
1296    {
1297       case KWU_SEL_LWLC:
1298          {
1299             CMCHKUNPK(cmUnpkPtr,(PTR *) &datReq, mBuf);
1300          }
1301          break;
1302       case KWU_SEL_LC:
1303          {
1304 #if 0
1305         /*This will be removed once the testing is done on all platforms */
1306             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datReq,\
1307                         sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY)) != ROK)
1308             {
1309 #if (ERRCLASS & ERRCLS_ADD_RES)
1310                /*MBUF_FIXX*/
1311                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1312                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1313                      (ErrVal)EKWU026, (ErrVal)0, "SGetMsg() failed");
1314
1315 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1316                RETVALUE(ret1);
1317             }
1318
1319 #endif
1320             /* Allocate the memory statically  as there is no free
1321              * in RLC */
1322             datReq = &datReqTmp;
1323             cmMemset((U8 *)datReq, 0, sizeof(KwuDatReqInfo));
1324 #if(ERRCLASS & ERRCLS_DEBUG)
1325             ret1 = cmUnpkKwuDatReqInfo( (datReq), mBuf);
1326             if(ret1 != ROK)
1327             {
1328                SPutMsg(mBuf);
1329                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1330                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1331                      (ErrVal)EKWU027, (ErrVal)ret1, "Unpacking failure");
1332                RETVALUE( ret1 );
1333             }
1334 #else
1335             cmUnpkKwuDatReqInfo( (datReq), mBuf);
1336 #endif /* ERRCLASS & ERRCLS_DEBUG */
1337          }
1338          break;
1339       default:
1340          SPutMsg(mBuf);
1341 #if (ERRCLASS & ERRCLS_ADD_RES)
1342          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1343                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1344                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1345 #endif
1346          RETVALUE(RFAILED);
1347    }
1348
1349    retVal = (*func)(pst, spId, datReq, mBuf);
1350    /* If LWLC is configured, we need to
1351     * free the memory here. */
1352    if(pst->selector == KWU_SEL_LWLC)
1353    {
1354       retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datReq,
1355             sizeof(KwuDatReqInfo),SS_SHARABLE_MEMORY);
1356    }
1357    RETVALUE(retVal);
1358 } /* cmUnpkKwuDatReq */
1359
1360 \f
1361 #ifdef ANSI
1362 PUBLIC S16 cmUnpkKwuDatIndInfo
1363 (
1364 KwuDatIndInfo *param,
1365 Buffer *mBuf
1366 )
1367 #else
1368 PUBLIC S16 cmUnpkKwuDatIndInfo(param, mBuf)
1369 KwuDatIndInfo *param;
1370 Buffer *mBuf;
1371 #endif
1372 {
1373    TRC3(cmUnpkKwuDatIndInfo);
1374
1375    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1376
1377 #ifdef CCPU_OPT
1378    CMCHKUNPK(cmUnpkLteRnti, &param->tCrnti, mBuf);
1379 #endif
1380    CMCHKUNPK(SUnpkU8, &param->isOutOfSeq, mBuf);
1381    RETVALUE(ROK);
1382 }
1383
1384 \f
1385 #ifdef ANSI
1386 PUBLIC S16 cmUnpkKwuDatInd
1387 (
1388 KwuDatInd func,
1389 Pst *pst,
1390 Buffer *mBuf
1391 )
1392 #else
1393 PUBLIC S16 cmUnpkKwuDatInd(func, pst, mBuf)
1394 KwuDatInd func;
1395 Pst *pst;
1396 Buffer *mBuf;
1397 #endif
1398 {
1399     S16 ret1 = ROK, retVal;
1400     SuId          suId = 0;
1401     KwuDatIndInfo *datInd = NULLP;
1402     KwuDatIndInfo datIndTmp;
1403
1404     TRC3(cmUnpkKwuDatInd)
1405
1406     CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1407
1408     switch(pst->selector)
1409     {
1410       case KWU_SEL_LWLC:
1411          {
1412             CMCHKUNPK(cmUnpkPtr,(PTR *) &datInd, mBuf);
1413          }
1414          break;
1415       case KWU_SEL_LC:
1416          {
1417             /*SGetStaticBuffer used as RRC has an equivalent free but PDCP
1418              * doesn't free any memory */
1419             if(pst->dstEnt != ENTPJ)
1420             {
1421                if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,
1422                            sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1423                {
1424 #if (ERRCLASS & ERRCLS_ADD_RES)
1425        if(ret1 != ROK)
1426        {
1427           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1428                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1429                (ErrVal)EKWU028, (ErrVal)0, "SGetMsg() failed");
1430        }
1431 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1432                   RETVALUE(ret1);
1433                }
1434             }
1435             else
1436             {
1437                datInd = &datIndTmp;
1438             }
1439
1440             ret1 = cmUnpkKwuDatIndInfo( (datInd), mBuf);
1441 #if(ERRCLASS & ERRCLS_DEBUG)
1442           if(ret1 != ROK)
1443           {
1444              SPutMsg(mBuf);
1445              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1446                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1447                   (ErrVal)EKWU029, (ErrVal)ret1, "Unpacking failure");
1448              RETVALUE( ret1 );
1449           }
1450 #endif /* ERRCLASS & ERRCLS_DEBUG */
1451          }
1452          break;
1453       default:
1454          SPutMsg(mBuf);
1455          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1456                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1457                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1458          RETVALUE(RFAILED);
1459     }
1460     retVal = (*func)(pst, suId, datInd, mBuf);
1461     /* If LWLC is configured and the destination entity is PDCP, we need to
1462      * free the memory here. */
1463     if((pst->selector == KWU_SEL_LWLC) && (pst->dstEnt == ENTPJ))
1464     {
1465        retVal = SPutStaticBuffer(pst->region, pst->pool, (Data *)datInd,
1466                 sizeof(KwuDatIndInfo),SS_SHARABLE_MEMORY);
1467     }
1468     RETVALUE(retVal);
1469 } /* cmUnpkKwuDatInd */
1470
1471 \f
1472 #ifdef ANSI
1473 PUBLIC S16 cmUnpkKwuDatCfmInfo
1474 (
1475 KwuDatCfmInfo *param,
1476 Buffer *mBuf
1477 )
1478 #else
1479 PUBLIC S16 cmUnpkKwuDatCfmInfo(param, mBuf)
1480 KwuDatCfmInfo *param;
1481 Buffer *mBuf;
1482 #endif
1483 {
1484    register S32 iter;
1485    TRC3(cmUnpkKwuDatCfmInfo);
1486
1487    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1488    CMCHKUNPK(SUnpkU32, &param->numSduIds, mBuf);
1489
1490 #ifdef L2_L3_SPLIT /*Work Around */
1491    if (param->numSduIds >= KWU_MAX_DAT_CFM)
1492       param->numSduIds = KWU_MAX_DAT_CFM;
1493 #endif
1494    for(iter = param->numSduIds -1; iter >= 0 ; iter--)
1495    {
1496       CMCHKUNPK(SUnpkU32, &param->sduIds[iter], mBuf);
1497    }
1498    RETVALUE(ROK);
1499 }
1500
1501 #ifdef ANSI
1502 PUBLIC S16 cmUnpkKwuDatCfm
1503 (
1504 KwuDatCfm func,
1505 Pst *pst,
1506 Buffer *mBuf
1507 )
1508 #else
1509 PUBLIC S16 cmUnpkKwuDatCfm(func, pst, mBuf)
1510 KwuDatCfm func;
1511 Pst *pst;
1512 Buffer *mBuf;
1513 #endif
1514 {
1515    S16 ret1 = ROK;
1516    SuId          suId = 0;
1517    KwuDatCfmInfo *datCfm = NULLP;
1518
1519    TRC3(cmUnpkKwuDatCfm)
1520
1521    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1522
1523    switch(pst->selector)
1524    {
1525       case KWU_SEL_LWLC:
1526          {
1527             CMCHKUNPK(cmUnpkPtr,(PTR *) &datCfm, mBuf);
1528          }
1529          break;
1530       case KWU_SEL_LC:
1531          {
1532             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datCfm,\
1533                         sizeof(KwuDatCfmInfo),SS_SHARABLE_MEMORY)) != ROK)
1534             {
1535 #if (ERRCLASS & ERRCLS_ADD_RES)
1536        if(ret1 != ROK)
1537        {
1538           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1539                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1540                (ErrVal)EKWU030, (ErrVal)0, "SGetMsg() failed");
1541        }
1542 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1543                RETVALUE(ret1);
1544             }
1545
1546             cmMemset((U8 *)datCfm, 0, sizeof(KwuDatCfmInfo));
1547             ret1 = cmUnpkKwuDatCfmInfo( (datCfm), mBuf);
1548 #if(ERRCLASS & ERRCLS_DEBUG)
1549           if(ret1 != ROK)
1550           {
1551              SPutMsg(mBuf);
1552              SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1553                    __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1554                   (ErrVal)EKWU031, (ErrVal)ret1, "Unpacking failure");
1555              RETVALUE( ret1 );
1556           }
1557 #endif /* ERRCLASS & ERRCLS_DEBUG */
1558          }
1559          break;
1560       default:
1561 #if (ERRCLASS & ERRCLS_ADD_RES)
1562           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1563                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1564                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1565 #endif
1566           SPutMsg(mBuf);
1567           RETVALUE(RFAILED);
1568    }
1569
1570    SPutMsg(mBuf);
1571
1572    RETVALUE((*func)(pst, suId, datCfm));
1573 } /* cmUnpkKwuDatCfm */
1574
1575 \f
1576 #ifdef ANSI
1577 PUBLIC S16 cmUnpkKwuDiscSduReq
1578 (
1579 KwuDiscSduReq func,
1580 Pst *pst,
1581 Buffer *mBuf
1582 )
1583 #else
1584 PUBLIC S16 cmUnpkKwuDiscSduReq(func, pst, mBuf)
1585 KwuDiscSduReq func;
1586 Pst *pst;
1587 Buffer *mBuf;
1588 #endif
1589 {
1590    S16 ret1 = ROK;
1591    SpId          spId = 0;
1592    KwuDiscSduInfo *discSdu = NULLP;
1593
1594
1595    CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1596    switch(pst->selector)
1597    {
1598       case KWU_SEL_LWLC:
1599          {
1600             CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
1601          }
1602          break;
1603       case KWU_SEL_LC:
1604          {
1605             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1606                         sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1607             {
1608 #if (ERRCLASS & ERRCLS_ADD_RES)
1609                /*MBUF_FIXX*/
1610                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1611                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1612                      (ErrVal)EKWU032, (ErrVal)0, "SGetMsg() failed");
1613
1614 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1615                RETVALUE(ret1);
1616             }
1617
1618             cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
1619             ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1620 #if(ERRCLASS & ERRCLS_DEBUG)
1621             if(ret1 != ROK)
1622             {
1623                SPutMsg(mBuf);
1624                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1625                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1626                      (ErrVal)EKWU033, (ErrVal)ret1, "Unpacking failure");
1627                RETVALUE( ret1 );
1628             }
1629 #endif /* ERRCLASS & ERRCLS_DEBUG */
1630             break;
1631          }
1632       default:
1633 #if (ERRCLASS & ERRCLS_ADD_RES)
1634           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1635                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1636                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1637 #endif
1638           SPutMsg(mBuf);
1639           RETVALUE(RFAILED);
1640    }
1641    SPutMsg(mBuf);
1642
1643    RETVALUE((*func)(pst, spId, discSdu));
1644 } /* cmUnpkKwuDiscSduReq */
1645
1646 \f
1647 #ifdef ANSI
1648 PUBLIC S16 cmUnpkKwuStaIndInfo
1649 (
1650 KwuStaIndInfo *param,
1651 Buffer *mBuf
1652 )
1653 #else
1654 PUBLIC S16 cmUnpkKwuStaIndInfo(param, mBuf)
1655 KwuStaIndInfo *param;
1656 Buffer *mBuf;
1657 #endif
1658 {
1659    U32 i;
1660
1661    TRC3(cmUnpkKwuStaIndInfo);
1662
1663    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1664    CMCHKUNPK(SUnpkU32, &param->numSdu, mBuf);
1665    for (i = 0; i < param->numSdu; i++)
1666    {
1667       CMCHKUNPK(SUnpkU32, &param->sduId[i], mBuf);
1668    }
1669
1670    RETVALUE(ROK);
1671 } /* cmUnpkKwuStaIndInfo */
1672
1673 \f
1674 #ifdef ANSI
1675 PUBLIC S16 cmUnpkKwuStaInd
1676 (
1677 KwuStaInd func,
1678 Pst *pst,
1679 Buffer *mBuf
1680 )
1681 #else
1682 PUBLIC S16 cmUnpkKwuStaInd(func, pst, mBuf)
1683 KwuStaInd func;
1684 Pst *pst;
1685 Buffer *mBuf;
1686 #endif
1687 {
1688    S16 ret1 = ROK;
1689    SuId          suId = 0;
1690    KwuStaIndInfo *staInd = NULLP;
1691
1692    TRC3(cmUnpkKwuStaInd)
1693
1694    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1695
1696    switch(pst->selector)
1697    {
1698       case KWU_SEL_LWLC:
1699          {
1700             CMCHKUNPK(cmUnpkPtr,(PTR *)&staInd, mBuf);
1701          }
1702          break;
1703       case KWU_SEL_LC:
1704          {
1705             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&staInd,\
1706                         sizeof(KwuStaIndInfo),SS_SHARABLE_MEMORY)) != ROK)
1707             {
1708 #if (ERRCLASS & ERRCLS_ADD_RES)
1709                if(ret1 != ROK)
1710                {
1711                   SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1712                         __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1713                         (ErrVal)EKWU034, (ErrVal)0, "SGetMsg() failed");
1714                }
1715 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1716                RETVALUE(ret1);
1717             }
1718
1719             cmMemset((U8 *)staInd, 0, sizeof(KwuStaIndInfo));
1720
1721             ret1 = cmUnpkKwuStaIndInfo( (staInd), mBuf);
1722 #if(ERRCLASS & ERRCLS_DEBUG)
1723             if(ret1 != ROK)
1724             {
1725                SPutMsg(mBuf);
1726                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1727                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1728                      (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1729                RETVALUE( ret1 );
1730             }
1731 #endif /* ERRCLASS & ERRCLS_DEBUG */
1732          }
1733          break;
1734       default:
1735           SPutMsg(mBuf);
1736 #if(ERRCLASS & ERRCLS_DEBUG)
1737           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1738                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1739                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1740 #endif
1741           RETVALUE(RFAILED);
1742    }
1743    SPutMsg(mBuf);
1744
1745    RETVALUE((*func)(pst, suId, staInd));
1746 } /* cmUnpkKwuStaInd */
1747
1748 \f
1749 #ifdef ANSI
1750 PUBLIC S16 cmUnpkKwuReEstCmpInd
1751 (
1752 KwuReEstCmpInd func,
1753 Pst *pst,
1754 Buffer *mBuf
1755 )
1756 #else
1757 PUBLIC S16 cmUnpkKwuReEstCmpInd(func, pst, mBuf)
1758 KwuReEstCmpInd func;
1759 Pst *pst;
1760 Buffer *mBuf;
1761 #endif
1762 {
1763 #if(ERRCLASS & ERRCLS_DEBUG)
1764    S16 ret1;
1765 #endif
1766    SuId          suId = 0;
1767    CmLteRlcId    rlcId;
1768
1769    TRC3(cmUnpkKwuReEstCmpInd)
1770
1771    cmMemset((U8 *)&rlcId, 0, sizeof(CmLteRlcId));
1772
1773    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1774    switch(pst->selector)
1775    {
1776 #ifdef LCKWU
1777       case KWU_SEL_LC:
1778          {
1779 #if(ERRCLASS & ERRCLS_DEBUG)
1780             ret1 = cmUnpkLteRlcId( &rlcId, mBuf);
1781             if(ret1 != ROK)
1782             {
1783                SPutMsg(mBuf);
1784                SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1785                      __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1786                      (ErrVal)EKWU035, (ErrVal)ret1, "Unpacking failure");
1787                RETVALUE( ret1 );
1788             }
1789 #else
1790             cmUnpkLteRlcId( &rlcId, mBuf);
1791 #endif /* ERRCLASS & ERRCLS_DEBUG */
1792             break;
1793          }
1794 #endif /* LCKWU */
1795    }
1796    SPutMsg(mBuf);
1797
1798    RETVALUE((*func)(pst, suId, rlcId));
1799 } /* cmUnpkKwuReEstCmpInd */
1800
1801 /* kwu_c_001.main_3 added support for L2 Measurement */
1802 #ifdef ANSI
1803 PUBLIC S16 cmUnpkKwuDiscSduCfm
1804 (
1805 KwuDiscSduCfm  func,
1806 Pst            *pst,
1807 Buffer         *mBuf
1808 )
1809 #else
1810 PUBLIC S16 cmUnpkKwuDiscSduCfm(func, pst, mBuf)
1811 KwuDiscSduCfm  func;
1812 Pst            *pst;
1813 Buffer         *mBuf;
1814 #endif
1815 {
1816    S16 ret1 = ROK;
1817    SpId          spId = 0;
1818    KwuDiscSduInfo *discSdu = NULLP;
1819
1820    TRC3(cmUnpkKwuDiscSduCfm);
1821
1822    CMCHKUNPK(SUnpkS16, &(spId), mBuf);
1823
1824    switch(pst->selector)
1825    {
1826       case KWU_SEL_LWLC:
1827          {
1828             CMCHKUNPK(cmUnpkPtr,(PTR *) &discSdu, mBuf);
1829          }
1830          break;
1831       case KWU_SEL_LC:
1832          {
1833             if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&discSdu,\
1834                         sizeof(KwuDiscSduInfo),SS_SHARABLE_MEMORY)) != ROK)
1835             {
1836 #if (ERRCLASS & ERRCLS_ADD_RES)
1837       if(ret1 != ROK)
1838       {
1839          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1840                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1841                (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1842       }
1843 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1844                RETVALUE(ret1);
1845             }
1846             cmMemset((U8 *)discSdu, 0, sizeof(KwuDiscSduInfo));
1847
1848    ret1 = cmUnpkKwuDiscSduInfo( (discSdu), mBuf);
1849 #if(ERRCLASS & ERRCLS_DEBUG)
1850             if(ret1 != ROK)
1851             {
1852                SPutMsg(mBuf);
1853                SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1854                      __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1855                      (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1856             }
1857 #endif /* ERRCLASS & ERRCLS_DEBUG */
1858          }
1859          break;
1860       default:
1861           SPutMsg(mBuf);
1862 #if(ERRCLASS & ERRCLS_DEBUG)
1863           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1864                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1865                (ErrVal)ERRKWU, (ErrVal)ret1, "pst->selector is invalid\n");
1866 #endif
1867           RETVALUE(RFAILED);
1868    }
1869    SPutMsg(mBuf);
1870
1871    RETVALUE((*func)(pst, spId, discSdu));
1872 } /* cmUnpkKwuDiscSduCfm */
1873 #ifdef ANSI
1874 PUBLIC S16 cmUnpkKwuFlowCntrlInd
1875 (
1876 KwuFlowCntrlInd  func,
1877 Pst            *pst,
1878 Buffer         *mBuf
1879 )
1880 #else
1881 PUBLIC S16 cmUnpkKwuFlowCntrlInd(func, pst, mBuf)
1882 KwuFlowCntrlInd  func;
1883 Pst            *pst;
1884 Buffer         *mBuf;
1885 #endif
1886 {
1887    SuId   suId;
1888    KwuFlowCntrlIndInfo *flowCntrlInfo = NULLP;
1889
1890    TRC3(cmUnpkKwuFlowCntrlInd);
1891
1892    CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1893    switch(pst->selector)
1894    {
1895 #ifdef LCKWU
1896       case KWU_SEL_LC:
1897       {
1898          if(SGetStaticBuffer(pst->region,
1899                      pst->pool,
1900                      (Data **)&flowCntrlInfo,
1901                      sizeof(KwuFlowCntrlIndInfo),0) != ROK)
1902          {
1903             SPutMsg(mBuf);
1904             RETVALUE(RFAILED);
1905          }
1906
1907          cmUnpkKwuFlowCntrlIndInfo(flowCntrlInfo, mBuf);
1908       }
1909       break;
1910
1911       case KWU_SEL_LWLC:
1912       {
1913          CMCHKUNPK(cmUnpkPtr,(PTR *) &flowCntrlInfo, mBuf);
1914       }
1915       break;
1916 #endif
1917    }
1918
1919    SPutMsg(mBuf);
1920
1921    RETVALUE((*func)(pst, suId, flowCntrlInfo));
1922 } /* cmUnpkKwuFlowCntrlInd */
1923 #ifdef LTE_L2_MEAS
1924 \f
1925 #ifdef ANSI
1926 PUBLIC S16 cmUnpkKwuDatAckInfo
1927 (
1928 KwuDatAckInfo *param,
1929 Buffer *mBuf
1930 )
1931 #else
1932 PUBLIC S16 cmUnpkKwuDatAckInfo(param, mBuf)
1933 KwuDatAckInfo *param;
1934 Buffer *mBuf;
1935 #endif
1936 {
1937    TRC3(cmUnpkKwuDatAckInfo);
1938
1939    CMCHKUNPK(SUnpkU32, &param->sduId, mBuf);
1940    CMCHKUNPK(cmUnpkLteRlcId, &param->rlcId, mBuf);
1941
1942    RETVALUE(ROK);
1943 }
1944
1945 \f
1946 #ifdef ANSI
1947 PUBLIC S16 cmUnpkKwuDatAckInd
1948 (
1949 KwuDatAckInd func,
1950 Pst *pst,
1951 Buffer *mBuf
1952 )
1953 #else
1954 PUBLIC S16 cmUnpkKwuDatAckInd(func, pst, mBuf)
1955 KwuDatAckInd func;
1956 Pst *pst;
1957 Buffer *mBuf;
1958 #endif
1959 {
1960     S16 ret1;
1961     SuId          suId = 0;
1962     KwuDatAckInfo *datInd = NULLP;
1963
1964     TRC3(cmUnpkKwuDatAckInd);
1965
1966     if((ret1 = SGetStaticBuffer(pst->region, pst->pool, (Data **)&datInd,\
1967                 sizeof(KwuDatAckInfo),SS_SHARABLE_MEMORY)) != ROK)
1968     {
1969 #if (ERRCLASS & ERRCLS_ADD_RES)
1970        if(ret1 != ROK)
1971        {
1972           SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
1973                 __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
1974                 (ErrVal)ERRKWU, (ErrVal)0, "SGetMsg() failed");
1975        }
1976 #endif /*  ERRCLASS & ERRCLS_ADD_RES  */
1977        RETVALUE(ret1);
1978     }
1979
1980     cmMemset((U8 *)datInd, 0, sizeof(KwuDatAckInfo));
1981
1982     CMCHKUNPK(SUnpkS16, &(suId), mBuf);
1983     ret1 = cmUnpkKwuDatAckInfo( (datInd), mBuf);
1984 #if(ERRCLASS & ERRCLS_DEBUG)
1985     if(ret1 != ROK)
1986     {
1987        SPutMsg(mBuf);
1988        SLogError(pst->dstEnt, pst->dstInst, pst->dstProcId,
1989              __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG,
1990              (ErrVal)ERRKWU, (ErrVal)ret1, "Unpacking failure");
1991        RETVALUE( ret1 );
1992     }
1993 #endif /* ERRCLASS & ERRCLS_DEBUG */
1994
1995     RETVALUE((*func)(pst, suId, datInd));
1996 } /* cmUnpkKwuDatAckInd */
1997 #endif /* LTE_L2_MEAS */
1998 #endif /* LCKWU */
1999
2000 /**********************************************************************
2001          End of file
2002  **********************************************************************/