src/5gnrrlc/kw_lmm.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:    LTE - RLC - Layer Manager file
  22
  23         Type:    C source file
  24
  25         Desc:    It contains the following common  functions for processing
  26                  the all the external interfaces.
  27                     -- KwMiLkwCfgReq
  28                     -- KwMiLkwCfgCfm
  29                     -- KwMiLkwCntrlReq
  30                     -- KwMiLkwCntrlCfm
  31                     -- KwMiLkwStaReq
  32                     -- KwMiLkwStaCfm
  33                     -- KwMiLkwStaInd
  34                     -- KwMiLkwStsReq
  35                     -- KwMiLkwStsCfm
  36                     -- KwMiLkwTrcInd
  37
  38         File:     kw_lmm.c
  39
  40 *********************************************************************21*/
  41 static const char* RLOG_MODULE_NAME="LMM";
  42 static int RLOG_MODULE_ID=2048;
  43 static int RLOG_FILE_ID=197;
  44 /** @file kw_lmm.c
  45 @brief RLC Layer Manager Module
  46 **/
  47
  48 \f
  49 /* header (.h) include files */
  50 #include "envopt.h"        /* environment options */
  51 #include "envdep.h"        /* environment dependent */
  52 #include "envind.h"        /* environment independent */
  53
  54 #include "gen.h"           /* general */
  55 #include "ssi.h"           /* system services */
  56 #include "cm5.h"           /* common timer defines */
  57 #include "cm_tkns.h"       /* common tokens defines */
  58 #include "cm_mblk.h"       /* common memory allocation library defines */
  59 #include "cm_llist.h"      /* common link list  defines  */
  60 #include "cm_hash.h"       /* common hash list  defines */
  61 #include "cm_lte.h"        /* common LTE defines */
  62 #include "lkw.h"           /* LKW defines */
  63 #include "ckw.h"           /* CKW defines */
  64 #include "kwu.h"           /* KWU defines */
  65 #include "rgu.h"           /* RGU defines */
  66 #include "kw_err.h"        /* Err defines */
  67 #include "kw_env.h"        /* RLC environment options */
  68
  69 #include "kw.h"            /* RLC defines */
  70 #include "kw_dl.h"
  71 #include "kw_ul.h"
  72 #include "kw_udx.h"
  73
  74 /* extern (.x) include files */
  75 #include "gen.x"           /* general */
  76 #include "ssi.x"           /* system services */
  77
  78 #include "cm5.x"           /* common timer library */
  79 #include "cm_tkns.x"       /* common tokens */
  80 #include "cm_mblk.x"       /* common memory allocation */
  81 #include "cm_llist.x"      /* common link list */
  82 #include "cm_hash.x"       /* common hash list */
  83 #include "cm_lte.x"        /* common LTE includes */
  84 #include "cm_lib.x"        /* common memory allocation library */
  85 #include "lkw.x"           /* LKW */
  86 #include "ckw.x"           /* CKW */
  87 #include "kwu.x"           /* KWU */
  88 #include "rgu.x"           /* RGU */
  89
  90 #include "kw.x"
  91 #include "kw_udx.x"
  92 #include "kw_dl.x"
  93 #include "kw_ul.x"
  94
  95 #define KW_MODULE KW_DBGMASK_LMM
  96
  97 RLCStats gRlcStats;
  98 \f
  99 /*********************************************************************
 100  *             Forward Declaration of LKW Porting Functions
 101  ********************************************************************/
 102 PUBLIC KwCb *kwCb[KW_MAX_RLC_INSTANCES];
 103 EXTERN S16 kwActvTmr ARGS ((Ent ent, Inst inst));
 104
 105 PRIVATE Void kwLmmSendCfm ARGS ((KwCb *gCb,Pst *pst,KwMngmt *cfm,U8 type,
 106                                  Header *hdr));
 107 PRIVATE S16 kwLmmGenCfg ARGS ((KwCb *gCb, KwGenCfg *cfg));
 108 PRIVATE S16 kwLmmCfgKwuSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
 109 PRIVATE S16 kwLmmCfgUdxSap ARGS ((KwCb *gCb,KwSapCfg *cfg));
 110 PRIVATE S16 kwLmmCfgCkwSap ARGS ((KwCb *gCb,KwSapCfg   *cfg));
 111 PRIVATE S16 kwLmmCfgRguSap ARGS ((KwCb *gCb,KwSapCfg   *cfg));
 112 PRIVATE S16 kwLmmGenCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
 113 PRIVATE S16 kwLmmUdxSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
 114 PRIVATE S16 kwLmmLSapCntrl ARGS ((KwCb *gCb,KwMngmt *cntrl));
 115 PRIVATE S16 kwLmmGetKwuSapSta ARGS ((KwCb *gCb,KwKwuSapSta *sta));
 116 PRIVATE S16 kwLmmGetRguSapSta ARGS ((KwCb *gCb,KwRguSapSta *sta));
 117 PRIVATE S16 kwLmmGetCkwCntSapSta ARGS ((KwCb *gCb,KwCkwCntSapSta *sta));
 118 PRIVATE S16 kwLmmGetGenSts ARGS ((KwCb *gCb,KwGenSts *sts,Action action));
 119 PRIVATE S16 kwLmmGetSapSts ARGS ((KwCb *gCb,KwMngmt *sts,Elmnt elmnt,Action
 120                                   action));
 121
 122 \f
 123 /*********************************************************************
 124  *             Primitives for RGU interface
 125  ********************************************************************/
 126 /**
 127  * @brief
 128  *    Stores the general RLC configuration.
 129  * @details
 130  *    It calculates the memory requirement of the Saps
 131  *    It also initializes the control blocks, the hash lists and registers
 132  *    the timers. In case of error it rolls back and reports error in the
 133  *    confirm.If the general configuration is already done it is treated as
 134  *    reconfiguration, but right now reconfiguration is not supported.
 135  *
 136  * @param[in]  gCb   RLC Instance Control Block
 137  * @param[in]  cfm   RLC LM general config structure
 138  *
 139  * @return  S16
 140  *    LCM_REASON_NOT_APPL  (SUCCESS)
 141  *    LCM_REASON_MEM_NOAVAIL
 142  *    LCM_REASON_REGTMR_FAIL
 143  *    LCM_REASON_INVALID_PAR_VAL
 144  *    LCM_REASON_HASHING_FAILED
 145  */
 146 #ifdef ANSI
 147 PRIVATE S16 kwLmmGenCfg
 148 (
 149 KwCb       *gCb,
 150 KwGenCfg   *cfg
 151 )
 152 #else
 153 PRIVATE S16 kwLmmGenCfg(gCB,cfg)
 154 KwCb       *gCb;
 155 KwGenCfg   *cfg;
 156 #endif
 157 {
 158    Size     kwSapSize;
 159    Size     kwUdxSapSize;
 160    S16      ret;
 161    CmTqCp   *kwTqCp;
 162    Size     rguSapSize;
 163
 164    TRC2(kwLmmGenCfg)
 165
 166    if(cfg->maxUe > KW_MAX_UE)
 167    {
 168 #if (ERRCLASS & ERRCLS_INT_PAR)
 169       RLOG2(L_ERROR, "Invalid maxUe : Max [%lu] Received [%lu]",
 170             KW_MAX_UE,
 171             cfg->maxUe);
 172 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 173       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
 174    }
 175
 176    if(cfg->maxKwuSaps > KW_MAX_KWUSAPS)
 177    {
 178 #if (ERRCLASS & ERRCLS_INT_PAR)
 179       RLOG2(L_ERROR, "Invalid maxKwuSaps : Max [%lu] Received [%lu]",
 180             KW_MAX_KWUSAPS,
 181             cfg->maxKwuSaps);
 182 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 183       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
 184    }
 185
 186    if(cfg->maxUdxSaps > KW_MAX_UDXSAPS)
 187    {
 188 #if (ERRCLASS & ERRCLS_INT_PAR)
 189       RLOG2(L_ERROR, "Invalid maxUduSaps : Max [%lu] Received [%lu]",
 190             KW_MAX_UDXSAPS,
 191             cfg->maxUdxSaps);
 192 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 193       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
 194    }
 195
 196    if((cfg->maxRguSaps == 0) || (cfg->maxRguSaps > KW_MAX_RGUSAPS))
 197    {
 198
 199
 200       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
 201    }
 202    if(gCb->init.cfgDone == TRUE)
 203    {
 204       /* reconfiguration not supported */
 205       RETVALUE(LCM_REASON_RECONFIG_FAIL);
 206    }
 207
 208    gCb->genCfg = *cfg;
 209
 210    /* Timer Queue Control point initialization */
 211    kwTqCp         = &(gCb->kwTqCp);
 212    kwTqCp->tmrLen = KW_TMR_LEN;
 213    kwTqCp->nxtEnt = 0;
 214
 215    if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
 216    {
 217       KW_ALLOC(gCb,gCb->u.dlCb, sizeof (KwDlCb));
 218       if (gCb->u.dlCb == NULLP)
 219       {
 220          RLOG0(L_FATAL,"Memory Allocation failed");
 221          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 222
 223       }
 224       /* allocate memory to the KWU sap's */
 225       kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
 226                    (Size)sizeof(KwKwuSapCb));
 227
 228       KW_ALLOC(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
 229
 230 #if (ERRCLASS & ERRCLS_INT_PAR)
 231       if(gCb->u.dlCb->kwuDlSap == NULLP)
 232       {
 233          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
 234          RLOG0(L_FATAL,"Memory Allocation failed");
 235          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 236       }
 237 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 238
 239       gCb->u.dlCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
 240
 241       kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
 242                    (Size)sizeof(KwUdxDlSapCb));
 243
 244       KW_ALLOC(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
 245 #if (ERRCLASS & ERRCLS_INT_PAR)
 246       if(gCb->u.dlCb->udxDlSap == NULLP)
 247       {
 248          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
 249          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
 250          RLOG0(L_FATAL,"Memory Allocation failed");
 251          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 252       }
 253 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 254
 255       rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
 256                    (Size)sizeof(KwRguSapCb));
 257       KW_ALLOC(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
 258 #if (ERRCLASS & ERRCLS_INT_PAR)
 259       if(gCb->u.dlCb->rguDlSap == NULLP)
 260       {
 261          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
 262          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
 263          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
 264
 265          KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
 266                    "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
 267          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 268       }
 269 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 270
 271
 272       /* Initialize the Ue and Cell hash list */
 273       ret = kwDbmDlInit(gCb);
 274       if (ret != ROK)
 275       {
 276          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
 277          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
 278          KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
 279          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
 280          RLOG0(L_FATAL,"RLC DL Initialization failed");
 281          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 282       }
 283       /* Register the timer */
 284 /*Pradeep: changing the SRegTmrMt() to SRegTmr()*/
 285       if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
 286               kwActvTmr) != ROK)
 287       {
 288          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
 289          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
 290          KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
 291          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
 292
 293          RETVALUE(LCM_REASON_REGTMR_FAIL);
 294       }
 295
 296       /* initializations for background processing of freeing memory */
 297       kwUtlInitToBeFreed(gCb, &(gCb->u.dlCb->toBeFreed));
 298       kwUtlInitializeSelfPst(gCb);
 299
 300       if(SGetMsg(gCb->init.region,
 301                  gCb->init.pool,
 302                  &(gCb->u.dlCb->selfPstMBuf)) != ROK)
 303       {
 304          KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwSapSize);
 305          KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
 306          KW_FREE(gCb,gCb->u.dlCb->rguDlSap, rguSapSize);
 307          KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
 308
 309          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 310
 311       }
 312 #ifdef LTE_L2_MEAS
 313       kwUtlL2MeasDlInit(gCb);
 314 #endif
 315    }
 316    else if(gCb->genCfg.rlcMode == LKW_RLC_MODE_UL)
 317    {
 318       KW_ALLOC(gCb,gCb->u.ulCb, sizeof (KwUlCb));
 319       if (gCb->u.ulCb == NULLP)
 320       {
 321          RLOG0(L_FATAL,"Memory Allocation failed");
 322          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 323
 324       }
 325       /* allocate memory to the KWU sap's */
 326       kwSapSize = (Size)((Size) gCb->genCfg.maxKwuSaps *
 327                    (Size)sizeof(KwKwuSapCb));
 328
 329       KW_ALLOC(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
 330
 331 #if (ERRCLASS & ERRCLS_INT_PAR)
 332       if(gCb->u.ulCb->kwuUlSap == NULLP)
 333       {
 334          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
 335          RLOG0(L_FATAL,"Memory Allocation failed");
 336          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 337       }
 338 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 339
 340       gCb->u.ulCb->numKwuSaps = gCb->genCfg.maxKwuSaps;
 341
 342       /* allocate memory to the KWU sap's */
 343       kwUdxSapSize = (Size)((Size) gCb->genCfg.maxUdxSaps *
 344                    (Size)sizeof(KwUdxUlSapCb));
 345
 346       KW_ALLOC(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
 347
 348 #if (ERRCLASS & ERRCLS_INT_PAR)
 349       if(gCb->u.ulCb->kwuUlSap == NULLP)
 350       {
 351          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
 352          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
 353          RLOG0(L_FATAL,"Memory Allocation failed");
 354          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 355       }
 356 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 357
 358       rguSapSize = (Size)((Size) gCb->genCfg.maxRguSaps *
 359                    (Size)sizeof(KwRguSapCb));
 360       KW_ALLOC(gCb,gCb->u.ulCb->rguUlSap, rguSapSize);
 361 #if (ERRCLASS & ERRCLS_INT_PAR)
 362       if(gCb->u.ulCb->rguUlSap == NULLP)
 363       {
 364          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
 365          KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
 366          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
 367
 368          KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW043, (ErrVal) cfg->maxUe,
 369                    "kwLmmGenCfg: SgetSBuf Failed for rguSap...!");
 370          RETVALUE(LCM_REASON_MEM_NOAVAIL);
 371       }
 372 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 373
 374       /* Initialize the Ue and Cell hash list */
 375       ret = kwDbmUlInit(gCb);
 376       if (ret != ROK)
 377       {
 378          KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
 379          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
 380          KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
 381          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
 382          RLOG0(L_FATAL,"RLC DL Initialization failed");
 383       }
 384
 385       /* Register the timer */
 386
 387       if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
 388               kwActvTmr) != ROK)
 389       {
 390          KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
 391          KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
 392          KW_FREE(gCb,gCb->u.ulCb->rguUlSap, kwSapSize);
 393          KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
 394
 395          RETVALUE(LCM_REASON_REGTMR_FAIL);
 396       }
 397 #ifdef LTE_L2_MEAS
 398       kwUtlL2MeasUlInit(gCb);
 399 #endif
 400    }
 401    else
 402    {
 403 #if (ERRCLASS & ERRCLS_INT_PAR)
 404       RLOG0(L_ERROR, "Received Invalid RLC Mode");
 405 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 406
 407       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
 408    }
 409    /* Timer Initialization  */
 410    gCb->kwTqCp.tmrLen = KW_TMR_LEN;
 411
 412    cmMemset((U8*)gCb->kwTq, NULLP, sizeof(CmTqType) * KW_TMR_LEN);
 413
 414    KW_MEM_CPY(&(gCb->init.lmPst), &cfg->lmPst, sizeof(Pst));
 415
 416    gCb->init.lmPst.srcProcId = gCb->init.procId;
 417    gCb->init.lmPst.srcEnt = gCb->init.ent;
 418    gCb->init.lmPst.srcInst = gCb->init.inst;
 419    gCb->init.lmPst.event = EVTNONE;
 420
 421    /* kw002.201 For multi core and multi region,no need to reinitiailize the
 422     * region again . This would be done with kwActvInit from SSI */
 423 #if !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION)
 424    gCb->init.region = cfg->lmPst.region;
 425 #endif /* !defined(SS_MULTICORE_SUPPORT) && !defined(SS_M_PROTO_REGION) */
 426    gCb->init.pool   = cfg->lmPst.pool;
 427
 428    gCb->init.cfgDone = TRUE;
 429
 430    RETVALUE(LCM_REASON_NOT_APPL);
 431 }
 432
 433 /**
 434  * @brief
 435  *     Sends confirmation message to LM Called by KwMiLkwCfgReq function
 436  *
 437  * @param[in] gCb    RLC Instance Control Block
 438  * @param[in] pst    Post structure
 439  * @param[in] cfm    RLC LM structure
 440  * @param[in] type   Type of LM message
 441  * @param[in] hdr    Message header
 442  *
 443  * @return  S16
 444  *     -# ROK
 445  */
 446 #ifdef ANSI
 447 PRIVATE Void kwLmmSendCfm
 448 (
 449 KwCb      *gCb,
 450 Pst       *pst,
 451 KwMngmt   *cfm,
 452 U8        type,
 453 Header    *hdr
 454 )
 455 #else
 456 PRIVATE Void kwLmmSendCfm(gCb,pst, cfm, type, hdr)
 457 KwCb      gCb;
 458 Pst       *pst;
 459 KwMngmt   *cfm;
 460 U8        type;
 461 Header    *hdr;
 462 #endif
 463 {
 464    Pst   rPst;   /* Reply post structure */
 465
 466    TRC2(kwLmmSendCfm);
 467
 468    KW_MEM_SET(&rPst, 0, sizeof(Pst));
 469
 470    /* reply post structure for confirmation */
 471    if (gCb)
 472    {
 473       rPst.srcEnt = gCb->init.ent;
 474       rPst.srcInst = gCb->init.inst;
 475       cfm->hdr.entId.ent = gCb->init.ent;
 476       cfm->hdr.entId.inst = gCb->init.inst;
 477    }
 478    else
 479    {
 480       rPst.srcEnt = pst->dstEnt;
 481       rPst.srcInst = pst->dstInst;
 482       cfm->hdr.entId.ent = pst->dstEnt;
 483       cfm->hdr.entId.inst = pst->dstInst;
 484    }
 485    rPst.srcProcId = SFndProcId();
 486    rPst.dstEnt = pst->srcEnt;
 487    rPst.dstInst = pst->srcInst;
 488    rPst.dstProcId = pst->srcProcId;
 489    rPst.selector = hdr->response.selector;
 490    rPst.prior = hdr->response.prior;
 491    rPst.route = hdr->response.route;
 492    rPst.region = hdr->response.mem.region;
 493    rPst.pool= hdr->response.mem.pool;
 494
 495    /* Fill the reply header */
 496    cfm->hdr.elmId.elmnt = hdr->elmId.elmnt;
 497    cfm->hdr.transId = hdr->transId;
 498
 499    switch(type)
 500    {
 501       case TCFG:
 502          KwMiLkwCfgCfm(&rPst,cfm);
 503          break;
 504       case TCNTRL:
 505          SGetDateTime(&(cfm->t.cntrl.dt));
 506          KwMiLkwCntrlCfm(&rPst,cfm);
 507          break;
 508       case TSTS:
 509          SGetDateTime(&(cfm->t.sts.dt));
 510          KwMiLkwStsCfm(&rPst,0,cfm);
 511          break;
 512       case TSSTA:
 513          SGetDateTime(&(cfm->t.ssta.dt));
 514          KwMiLkwStaCfm(&rPst,cfm);
 515          break;
 516       default:
 517 #if (ERRCLASS & ERRCLS_INT_PAR)
 518          RLOG0(L_ERROR, "Received Invalid Message Type");
 519          if(!gCb)
 520          {
 521             fflush(stdout);
 522          }
 523 #endif /* ERRCLASS & ERRCLS_INT_PAR */
 524          break;
 525    }
 526
 527    RETVOID;
 528 }
 529
 530
 531 /**
 532  * @brief
 533  *    This function processes configuration requests received from the layer
 534  *    manager.
 535  *
 536  * @details
 537  *    The configuration requests can be for general configuration, or
 538  *    configuration of RGU, KWU, and CKW SAPs. The type of the configuration
 539  *    request can be determined from the elmId field in the header of the layer
 540  *    manager message.This function is called by the layer manager to configure
 541  *    RLC.
 542  *
 543  *    This function implements the following logic:
 544  *
 545  *    - if genCfg is not done, send negative Cfm to the layer manager;
 546  *
 547  *    - switch (cfg->hdr.elmId.elmnt)
 548  *       - case STGEN
 549  *          - update the genCfg field in RlCb;
 550  *          - allocate the maximum static memory required by the RLC product;
 551  *          - register the timer service by calling SReqTmr;
 552  *          - set CfgDone for not configuring again;
 553  *       - case STKWUSAP
 554  *          - if all the parameters are valid, then allocate the KwuSap control
 555  *            block;
 556  *          - update the SAP control block with the information provided in the
 557  *          - configuration request;
 558  *          - send configuration confirm with the status, success;
 559  *       - case STCKWSAP
 560  *          - if all the parametes are valid, then allocate the CkwSap control
 561  *            block;
 562  *          - update the SAP control block with the information provided in the
 563  *            configuration request;
 564  *          - send configuration confirm with the status, success;
 565  *       - case STRGUSAP
 566  *          - if all the parametes are valid, then allocate the rguSap control
 567  *            block;
 568  *          - update the SAP control block with the information provided in the
 569  *            configuration request;
 570  *          - send configuration confirm with the status, success;
 571  *       - case STUDXSAP
 572  *          - if all the parametes are valid, then allocate the udxSap control
 573  *            block;
 574  *          - update the SAP control block with the information provided in the
 575  *            configuration request;
 576  *          - send configuration confirm with the status, success;
 577  *    - end switch;
 578  *
 579  * @param[in] pst   post structure
 580  * @param[in] cfg   LM management structure
 581  *
 582  * @return S16
 583  *    -# Success : ROK
 584  *    -# Failure : RFAILED
 585  */
 586
 587 #ifdef ANSI
 588 PUBLIC S16 KwMiLkwCfgReq
 589 (
 590 Pst       *pst,
 591 KwMngmt   *cfg
 592 )
 593 #else
 594 PUBLIC S16 KwMiLkwCfgReq (pst, cfg)
 595 Pst       *pst;
 596 KwMngmt   *cfg;
 597 #endif
 598 {
 599    Reason   reason;   /* failure reason */
 600    KwCb     *tKwCb=NULLP;
 601
 602    TRC3(KwMiLkwCfgReq);
 603
 604 #if (ERRCLASS & ERRCLS_INT_PAR)
 605    /* Check if the instance is configured */
 606    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 607    {
 608       cfg->cfm.status = LCM_PRIM_NOK;
 609       cfg->cfm.reason = LCM_REASON_INVALID_INSTANCE;
 610       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
 611       RETVALUE(RFAILED);
 612    }
 613 #endif
 614
 615    tKwCb =  KW_GET_KWCB(pst->dstInst);
 616
 617    if (!tKwCb)
 618    {
 619       cfg->cfm.status = LCM_PRIM_NOK;
 620       cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 621       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
 622       RETVALUE(RFAILED);
 623    }
 624    /* check configuration is done or not */
 625    if ((tKwCb->init.cfgDone != TRUE) &&
 626        (cfg->hdr.elmId.elmnt != STGEN))
 627    {
 628       /*
 629        * if general config is not over then use pst structure
 630        * in primitive to communicate to stack manager
 631        */
 632
 633       cfg->cfm.status = LCM_PRIM_NOK;
 634       cfg->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 635       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
 636       RETVALUE(RFAILED);
 637    }
 638
 639    RLOG1(L_DEBUG, "KwMiLkwCfgReq elmId(%d)", cfg->hdr.elmId.elmnt);
 640
 641    switch(cfg->hdr.elmId.elmnt)
 642    {
 643       case STGEN:
 644       {
 645          reason = kwLmmGenCfg(tKwCb,&cfg->t.cfg.s.gen);
 646          break;
 647       }
 648       case STKWUSAP:
 649       {
 650          reason = kwLmmCfgKwuSap(tKwCb,&cfg->t.cfg.s.sap);
 651          break;
 652       }
 653       case STCKWSAP:
 654       {
 655          reason = kwLmmCfgCkwSap(tKwCb,&cfg->t.cfg.s.sap);
 656          break;
 657       }
 658       case STRGUSAP:
 659       {
 660          reason = kwLmmCfgRguSap(tKwCb,&cfg->t.cfg.s.sap);
 661          break;
 662       }
 663       case STUDXSAP:
 664       {
 665          reason = kwLmmCfgUdxSap(tKwCb,&cfg->t.cfg.s.sap);
 666          break;
 667       }
 668       default:
 669       {
 670          reason = LCM_REASON_INVALID_ELMNT;
 671          break;
 672       }
 673    }
 674
 675    if (reason == LCM_REASON_NOT_APPL)
 676    {
 677       cfg->cfm.status = LCM_PRIM_OK;
 678       cfg->cfm.reason = LCM_REASON_NOT_APPL;
 679       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
 680       RETVALUE(ROK);
 681    }
 682    else
 683    {
 684       cfg->cfm.status = LCM_PRIM_NOK;
 685       cfg->cfm.reason = reason;
 686       kwLmmSendCfm(tKwCb,pst, cfg, TCFG, &cfg->hdr);
 687       RETVALUE(RFAILED);
 688    }
 689 }
 690
 691 /**
 692  * @brief
 693  *    The layer manager initiates and uses the management-control procedure to
 694  *    control RLC elements.The RLC control request primitive (KwMiLkwCntrlReq)
 695  *    can be called more than once and at any time after the
 696  *    management-configuration procedure.The control request primitive
 697  *    is confirmed by a KwMiLkwCntrlCfm primitive.
 698  *
 699  * @details
 700  *    This function implements the following logic:
 701  *
 702  *    - if(cfgDone = FALSE)
 703  *       - send negative confirmation to the layer manager;
 704  *       - return;
 705  *    - else
 706  *    - switch(cntrl->hdr.elmId.elmnt)
 707  *       -  case STGEN
 708  *           - switch (action)
 709  *           - case AENA
 710  *                - switch(subAction)
 711  *                - case SAUSTA
 712  *                     - enable the unsolicited status flag;
 713  *                     - send the control Cfm with success;
 714  *                - case SADBG
 715  *                     - set the debug mask;
 716  *                     - send the control Cfm with success;
 717  *                - case SATRC
 718  *                     - enable the trace flag;
 719  *                     - send the control Cfm with success;
 720  *            - case ADISIMM
 721  *               - switch(subAction)
 722  *               - case SAUSTA
 723  *                    - disable the unsolicited status flag;
 724  *                    - send the control Cfm with success;
 725  *               - case SATRC
 726  *                    - disable the trace flag;
 727  *                    - send the control Cfm with success;
 728  *          - case ASHUTDOWN
 729  *     - case STRGUSAP
 730  *          - Call LSapCntrl
 731  *     - case STUDXSAP
 732  *          - Call UdxSapCntrl
 733  *     - default
 734  *    - end else
 735  *
 736  * @param[in] pst     post structure
 737  * @param[in] cntrl   LM management structure
 738  *
 739  * @return S16
 740  *    -# ROK
 741  *    -# RFAILED
 742  */
 743 #ifdef ANSI
 744 PUBLIC S16 KwMiLkwCntrlReq
 745 (
 746 Pst       *pst,
 747 KwMngmt   *cntrl
 748 )
 749 #else
 750 PUBLIC S16 KwMiLkwCntrlReq(pst, cntrl)
 751 Pst       *pst;
 752 KwMngmt   *cntrl;
 753 #endif
 754 {
 755    Reason   reason;   /* failure reason */
 756    KwCb     *tKwCb=NULLP;
 757
 758    TRC3(KwMiLkwCntrlReq)
 759
 760 #if (ERRCLASS & ERRCLS_INT_PAR)
 761    /* Check if the instance is configured */
 762    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 763    {
 764       cntrl->cfm.status = LCM_PRIM_NOK;
 765       cntrl->cfm.reason =  LCM_REASON_INVALID_INSTANCE;
 766
 767       kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
 768       RETVALUE(RFAILED);
 769    }
 770 #endif
 771
 772    tKwCb =  KW_GET_KWCB(pst->dstInst);
 773
 774    if(!tKwCb)
 775    {
 776       cntrl->cfm.status = LCM_PRIM_NOK;
 777       cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 778       kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
 779       RETVALUE(RFAILED);
 780    }
 781
 782    if (!(tKwCb->init.cfgDone))
 783    {
 784       cntrl->cfm.status = LCM_PRIM_NOK;
 785       cntrl->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 786       kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
 787       RETVALUE(RFAILED);
 788    }
 789    RLOG1(L_DEBUG, "KwMiLkwCntrlReq(elmId(%d))", cntrl->hdr.elmId.elmnt);
 790
 791    /* In normal cases, LCM_REASON_NOT_APPL is returned in cfm.
 792     * In all error cases appropriate reason is returned
 793     * by the functions below
 794     */
 795
 796    switch (cntrl->hdr.elmId.elmnt)
 797    {
 798       case STGEN:
 799       {
 800          /* general control */
 801          reason = kwLmmGenCntrl(tKwCb,cntrl);
 802          break;
 803       }
 804       case STRGUSAP:
 805       {
 806          /* Lower SAP control */
 807          reason = kwLmmLSapCntrl(tKwCb,cntrl);
 808          break;
 809       }
 810       case STUDXSAP:
 811       {
 812          /* Udx Sap cntrl */
 813          reason = kwLmmUdxSapCntrl(tKwCb,cntrl);
 814          break;
 815       }
 816       default:
 817       {
 818          reason = LCM_REASON_INVALID_ELMNT;
 819          break;
 820       }
 821    } /* end switch */
 822
 823    if (reason == LCM_REASON_NOT_APPL)
 824    {
 825       cntrl->cfm.status = LCM_PRIM_OK;
 826       cntrl->cfm.reason = LCM_REASON_NOT_APPL;
 827    }
 828    else
 829    {
 830       cntrl->cfm.status = LCM_PRIM_NOK;
 831       cntrl->cfm.reason = reason;
 832    }
 833
 834    kwLmmSendCfm(tKwCb,pst, cntrl, TCNTRL, &cntrl->hdr);
 835
 836    RETVALUE(ROK);
 837 }
 838
 839 /**
 840  * @brief
 841  *    This function processes solicited status requests received from the layer
 842  *    manager. The layer manager can request status information regarding the
 843  *    system ID, RGUSAP,KWUSAP, or CKWSAP.
 844  *
 845  * @param[in] pst   post structure
 846  * @param[in] sta   LM management structure
 847  * @return S16
 848  *    -# ROK (SUCCESS)
 849  *    -# RFAILED
 850  */
 851 #ifdef ANSI
 852 PUBLIC S16 KwMiLkwStaReq
 853 (
 854 Pst       *pst,
 855 KwMngmt   *sta
 856 )
 857 #else
 858 PUBLIC S16 KwMiLkwStaReq(pst, sta)
 859 Pst       *pst;
 860 KwMngmt   *sta;
 861 #endif
 862 {
 863    KwMngmt   rSta;     /* Status */
 864    Reason    reason;   /* Failure reason */
 865    KwCb      *tKwCb=NULLP;
 866
 867    TRC3(KwMiLkwStaReq);
 868
 869 #if (ERRCLASS & ERRCLS_INT_PAR)
 870    /* Check if the instance is configured */
 871    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
 872    {
 873       sta->cfm.status = LCM_PRIM_NOK;
 874       sta->cfm.reason = LCM_REASON_INVALID_INSTANCE;
 875
 876       kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
 877       RETVALUE(RFAILED);
 878    }
 879 #endif
 880
 881    tKwCb =  KW_GET_KWCB(pst->dstInst);
 882    if (!tKwCb)
 883    {
 884       sta->cfm.status = LCM_PRIM_NOK;
 885       sta->cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
 886
 887       kwLmmSendCfm(tKwCb,pst, sta, TSSTA, &sta->hdr);
 888       RETVALUE(RFAILED);
 889    }
 890
 891    RLOG1(L_DEBUG, "Status request for elmId(%d))", sta->hdr.elmId.elmnt);
 892
 893    reason = LCM_REASON_NOT_APPL;
 894
 895    KW_MEM_SET(&rSta, 0, sizeof(KwMngmt));
 896    switch (sta->hdr.elmId.elmnt)
 897    {
 898       case STSID:
 899       {
 900          reason = LCM_REASON_NOT_APPL;
 901          kwGetSId(&rSta.t.ssta.s.sysId);
 902          break;
 903       }
 904       case STKWUSAP:
 905       {
 906          KW_MEM_CPY (&rSta.t.ssta.s.kwuSap,
 907                      &sta->t.ssta.s.kwuSap,
 908                      sizeof (KwKwuSapSta));
 909
 910          reason = kwLmmGetKwuSapSta (tKwCb,&rSta.t.ssta.s.kwuSap);
 911          break;
 912       }
 913       case STRGUSAP:
 914       {
 915          KW_MEM_CPY (&rSta.t.ssta.s.rguSap,
 916                      &sta->t.ssta.s.rguSap,
 917                      sizeof (KwRguSapSta));
 918
 919          reason = kwLmmGetRguSapSta (tKwCb,&rSta.t.ssta.s.rguSap);
 920          break;
 921       }
 922       case STCKWSAP:
 923       {
 924          KW_MEM_CPY (&rSta.t.ssta.s.ckwSap,
 925                      &sta->t.ssta.s.ckwSap,
 926                      sizeof (KwCkwCntSapSta));
 927
 928          reason = kwLmmGetCkwCntSapSta (tKwCb,&rSta.t.ssta.s.ckwSap);
 929          break;
 930       }
 931       default:
 932       {
 933          reason = LCM_REASON_INVALID_ELMNT;
 934          break;
 935       }
 936    } /* end of switch */
 937
 938    if (reason == LCM_REASON_NOT_APPL)
 939    {
 940       rSta.cfm.status = LCM_PRIM_OK;
 941       rSta.cfm.reason = LCM_REASON_NOT_APPL;
 942    }
 943    else
 944    {
 945       rSta.cfm.status = LCM_PRIM_NOK;
 946       rSta.cfm.reason = reason;
 947    }
 948    kwLmmSendCfm(tKwCb,pst, &rSta, TSSTA, &sta->hdr);
 949
 950    RETVALUE(ROK);
 951 }
 952
 953 /**
 954  * @brief
 955  *    This function processes statistics requests received from the layer
 956  *    manager.
 957  *
 958  * @details
 959  *    After collecting the statistics, ir calls the statistics confirm function
 960  *    to send the statistics to the layer manager.
 961  *
 962  *    - switch(sts->hdr.elmId.elmnt)
 963  *    - case STGEN
 964  *       - get the general statistics from the KW control block;
 965  *       - if (action = RESET)
 966  *          - reset the general statistic field in the RlCb;
 967  *          - call KwMiLkwStsCfm to send statistics back to layer manager;
 968  *    - case STCKWSAP
 969  *    - case STKWUSAP
 970  *    - case STRGUSAP
 971  *        - get the SAP specific statistics from KW control block;
 972  *        - if (action = RESET)
 973  *       - reset the general statistic field in the RlCb;
 974  *       - call KwMiLkwStsCfm to send statistics to the layer manager;
 975  *  -end switch;
 976  *
 977  * @param[in] pst      post structure
 978  * @param[in] action   action
 979  * @param[in] sts      LM management structure
 980  *
 981  * @return S16
 982  *    -# ROK
 983  *    -# RFAILED
 984  */
 985 #ifdef ANSI
 986 PUBLIC S16 KwMiLkwStsReq
 987 (
 988 Pst      *pst,
 989 Action    action,
 990 KwMngmt   *sts
 991 )
 992 #else
 993 PUBLIC S16 KwMiLkwStsReq (pst, action, sts)
 994 Pst       *pst;
 995 Action    action;
 996 KwMngmt   *sts;
 997 #endif
 998 {
 999    KwMngmt   rSts;     /* Statistics */
1000    Reason    reason;   /* Reason for failure */
1001    KwCb     *tKwCb=NULLP;
1002
1003    TRC3(KwMiLkwStsReq);
1004
1005 #if (ERRCLASS & ERRCLS_INT_PAR)
1006    /* Check if the instance is configured */
1007    if (pst->dstInst >= KW_MAX_RLC_INSTANCES)
1008    {
1009       rSts.cfm.status = LCM_PRIM_NOK;
1010       rSts.cfm.reason = LCM_REASON_INVALID_INSTANCE;
1011
1012       kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
1013       RETVALUE(RFAILED);
1014    }
1015 #endif
1016
1017    tKwCb =  KW_GET_KWCB(pst->dstInst);
1018    if (!tKwCb)
1019    {
1020       rSts.cfm.status = LCM_PRIM_NOK;
1021       rSts.cfm.reason = LCM_REASON_GENCFG_NOT_DONE;
1022
1023       kwLmmSendCfm(tKwCb,pst, &rSts, TCNTRL, &sts->hdr);
1024       RETVALUE(RFAILED);
1025    }
1026
1027    RLOG2(L_DEBUG, "KwMiLkwStsReq(elmId(%d),action(%d))",
1028                        action,
1029                        sts->hdr.elmId.elmnt);
1030
1031    KW_MEM_SET(&rSts, 0, sizeof(KwMngmt));
1032
1033    switch (sts->hdr.elmId.elmnt)
1034    {
1035       case STGEN:
1036       {
1037          reason = kwLmmGetGenSts(tKwCb,&rSts.t.sts.s.gen, action);
1038          break;
1039       }
1040       case STKWUSAP:
1041       case STCKWSAP:
1042       {
1043          if( sts->hdr.elmId.elmnt == STKWUSAP)
1044          {
1045             /* kw005.201, modified the element of kwuSap from suId to spId */
1046             rSts.t.sts.s.kwuSap.spId = sts->t.sts.s.kwuSap.spId;
1047          }
1048          reason = kwLmmGetSapSts(tKwCb,&rSts, sts->hdr.elmId.elmnt, action);
1049          break;
1050       }
1051       default:
1052       {
1053          reason = LCM_REASON_INVALID_ELMNT;
1054          break;
1055       }
1056    } /* end switch */
1057
1058    if (reason == LCM_REASON_NOT_APPL)
1059    {
1060       rSts.cfm.status = LCM_PRIM_OK;
1061       rSts.cfm.reason = LCM_REASON_NOT_APPL;
1062    }
1063    else
1064    {
1065       rSts.cfm.status = LCM_PRIM_NOK;
1066       rSts.cfm.reason = reason;
1067    }
1068    kwLmmSendCfm(tKwCb,pst, &rSts, TSTS, &sts->hdr);
1069
1070    RETVALUE(ROK);
1071 }
1072
1073 /* kw005.201 added support for L2 Measurement */
1074 #ifdef LTE_L2_MEAS
1075 /**
1076 @brief
1077 This function processes L2 Measurement requests received from the layer manager.
1078 The L2 Measurement is start for a time period and after the timer expiry, the
1079 measurement confirm is sent.
1080
1081 -  Accept only one set of measurements.
1082 -  Allocate and initialise KwL2MeasEvtCb.
1083 -  Validate if the measurement is already in progress.
1084    -  Loop through the existing measEvtCb with matching measType
1085       -  Check if measurement is running for any qci present in the measReq
1086       -  If present, move the qCi to list of invalid qCIs.
1087 -  Set KwL2MeasEvtCb.measOn to TRUE for QCIs to be measured.
1088 -  For the number of measurements requested.
1089    -  For all Ues with RBs matching qCI.
1090       -  Add RbCb to the RB linked list.
1091       -  Set kwRbCb.measOn to measurement type.
1092       -  If Meas type is DL_DELAY
1093          -  Update COUNT to startCount.
1094 -  Start l2Timer
1095
1096  *  @param[in] pst      post structure
1097  *  @param[in] action   action
1098  *  @param[in] cfg      LM management structure
1099  *  @return S16
1100  *      -# Success : ROK
1101  *      -# Failure : RFAILED
1102 */
1103 #ifdef ANSI
1104 PUBLIC S16 KwMiLkwL2MeasReq
1105 (
1106 Pst            *pst,
1107 KwL2MeasReqEvt *measReqEvt
1108 )
1109 #else
1110 PUBLIC S16 KwMiLkwL2MeasReq (pst, measReqEvt)
1111 Pst            *pst;
1112 KwL2MeasReqEvt *measReqEvt;
1113 #endif
1114 {
1115    S16            ret = ROK;
1116    U16            cntr;
1117    U8             measType;
1118    KwL2MeasCfmEvt measCfmEvt;
1119
1120    KwCb     *tKwCb;
1121
1122    TRC3(KwMiLkwL2MeasReq);
1123
1124    tKwCb =  KW_GET_KWCB(pst->dstInst);
1125
1126    /* Initialize measCfmEvt */
1127    KW_MEM_ZERO(&measCfmEvt, sizeof(KwL2MeasCfmEvt));
1128    /* validate the received measReqEvt */
1129    /*LTE_L2_MEAS_PHASE2*/
1130    if(measReqEvt->measPeriod != 0)
1131    {
1132       /* L2 MEAS AGHOSH */
1133       if((measReqEvt->measReq.measType & LKW_L2MEAS_DL_IP)||
1134             (measReqEvt->measReq.measType & LKW_L2MEAS_UL_IP))
1135       {
1136          ret = kwUtlValidateIpThL2Meas(measReqEvt, &measCfmEvt);
1137       }
1138
1139       if(ret != ROK)
1140       {
1141 #if (ERRCLASS & ERRCLS_ADD_RES)
1142 #endif /* ERRCLASS & ERRCLS_ADD_RES */
1143          kwUtlSndUlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
1144          KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
1145          RETVALUE(RFAILED);
1146       }
1147    }
1148
1149    measType = measReqEvt->measReq.measType;
1150
1151    if((measType != LKW_L2MEAS_DL_IP) &&
1152       (measType !=  LKW_L2MEAS_ACT_UE) &&
1153       (measType !=  LKW_L2MEAS_DL_DISC) &&
1154       (measType != LKW_L2MEAS_DL_DELAY) &&
1155       (measType != LKW_L2MEAS_UU_LOSS) &&
1156       (measType !=  LKW_L2MEAS_UL_IP))/* || (qci > LKW_MAX_QCI)*/
1157    {
1158       measCfmEvt.transId = measReqEvt->transId;
1159       measCfmEvt.measType = measType;
1160       measCfmEvt.status.status = LCM_PRIM_NOK;
1161       measCfmEvt.status.reason = LKW_CAUSE_INVALID_MEASTYPE;
1162       kwUtlSndDlL2MeasNCfm(tKwCb, measReqEvt, &measCfmEvt);
1163       KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt))
1164       RETVALUE(ROK);
1165    }
1166
1167    /* for UL IP throughput meas enable for all QCIs */
1168    if(measType & LKW_L2MEAS_UL_IP)
1169    {
1170       for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1171       {
1172          tKwCb->u.ulCb->kwL2Cb.measOn[cntr] |= LKW_L2MEAS_UL_IP;
1173       }
1174    }
1175
1176    if(measType &
1177       (LKW_L2MEAS_DL_IP | LKW_L2MEAS_DL_DISC |
1178       LKW_L2MEAS_DL_DELAY | LKW_L2MEAS_UU_LOSS))
1179    {
1180       KwL2MeasReqEvt *measEvt;
1181       Pst      *udxPst;
1182
1183       udxPst = &(KW_GET_UDX_SAP(tKwCb)->pst);
1184
1185       KW_ALLOC_SHRABL_BUF(udxPst->region,
1186                           udxPst->pool,
1187                           measEvt,
1188                           sizeof(KwL2MeasReqEvt));
1189
1190 #if (ERRCLASS & ERRCLS_ADD_RES) /* KW_FIX */
1191       if(measEvt == NULLP)
1192       {
1193          RLOG0(L_FATAL,"Memory Allocation failed");
1194          RETVALUE(RFAILED);
1195       }
1196 #endif
1197       cmMemcpy((Void*)measEvt, (Void*)measReqEvt, sizeof(KwL2MeasReqEvt));
1198       /*Redirect the request to DL task */
1199       /* NOTE:As of today, there are no cases where the Req will fail at DL
1200          as long as it reached the DL, so we don't wait for a confirmation from
1201          DL to send the confirmation to LM*/
1202       /* The interface for sending a confirmation back does not exist today;
1203          it needs to be created when the need arises */
1204       KwUlUdxL2MeasReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measEvt);
1205    }
1206
1207    /* We need to copy the transId for sending back confirms later */
1208    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1209    {
1210       KwL2MeasEvtCb* measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1211       if(measEvtCb->measCb.measType & measType)
1212       {
1213          measEvtCb->transId= measReqEvt->transId;
1214       }
1215    }
1216    /*KW_FREE(tKwCb, measReqEvt, sizeof(KwL2MeasReqEvt));*/
1217
1218    RETVALUE(ret);
1219 } /* KwMiLkwL2MeasReq */
1220
1221 /**
1222 @brief
1223 This function processes L2 Measurement stop request received from the layer manager.
1224 After receving this request, RLC stops L2 Measurement
1225  *  @param[in] pst      post structure
1226  *  @param[in] measType meas Type
1227  *  @return S16
1228  *      -# Success : ROK
1229  *      -# Failure : RFAILED
1230 */
1231
1232 #ifdef ANSI
1233 PUBLIC S16 KwMiLkwL2MeasStopReq
1234 (
1235 Pst            *pst,
1236 U8             measType
1237 )
1238 #else
1239 PUBLIC S16 KwMiLkwL2MeasStopReq (pst, measType)
1240 Pst            *pst;
1241 U8             measType;
1242 #endif
1243 {
1244    S16 ret = ROK;
1245    KwL2MeasEvtCb *measEvtCb = NULLP;
1246
1247    U16            cntr;
1248    U8             status = ROK;
1249    KwCb     *tKwCb;
1250
1251    TRC3(KwMiLkwL2MeasStopReq);
1252
1253    tKwCb =  KW_GET_KWCB(pst->dstInst);
1254
1255    /* reset the counter values for the measurement that is stopped */
1256    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1257    {
1258       measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1259       if(measEvtCb->measCb.measType & measType)
1260       {
1261          kwUtlResetUlL2MeasInKwRb(tKwCb, &measEvtCb->measCb, measType);
1262
1263       }
1264    }
1265
1266    /* for UL IP throughput meas disable for all QCIs */
1267    if(measType & LKW_L2MEAS_UL_IP)
1268    {
1269       for(cntr = 0; cntr < LKW_MAX_QCI; cntr++)
1270       {
1271          tKwCb->u.ulCb->kwL2Cb.measOn[cntr] &= ~LKW_L2MEAS_UL_IP;
1272       }
1273    }
1274
1275    if((measType & LKW_L2MEAS_DL_IP) || (measType & LKW_L2MEAS_DL_DISC)
1276        || (measType & LKW_L2MEAS_DL_DELAY))
1277    {
1278       /*Redirect the request to DL task */
1279       KwUlUdxL2MeasStopReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
1280       /*RETVALUE(ROK);*/
1281    }
1282    /*cmMemset((U8*)&measCfmEvt, 0, sizeof(KwL2MeasCfmEvt)); */
1283
1284    status = LCM_PRIM_OK;
1285    KwMiLkwL2MeasStopCfm(&tKwCb->genCfg.lmPst, measType,status);
1286
1287    RETVALUE(ret);
1288 }
1289 /**
1290 @brief
1291 This function processes L2 Measurement Send request received from the layer manager.
1292 After receving this request, RLC sends L2 Measurement
1293  *  @param[in] pst      post structure
1294  *  @param[in] measType meas Type
1295  *  @return S16
1296  *      -# Success : ROK
1297  *      -# Failure : RFAILED
1298 */
1299
1300 #ifdef ANSI
1301 PUBLIC S16 KwMiLkwL2MeasSendReq
1302 (
1303 Pst            *pst,
1304 U8             measType
1305 )
1306 #else
1307 PUBLIC S16 KwMiLkwL2MeasSendReq (pst, measType)
1308 Pst            *pst;
1309 U8             measType;
1310 #endif
1311 {
1312    /*S16 ret = ROK;*/
1313    KwL2MeasEvtCb *measEvtCb = NULLP;
1314    U16            cntr;
1315    KwCb     *tKwCb;
1316    TRC3(KwMiLkwL2MeasSendReq);
1317
1318    tKwCb =  KW_GET_KWCB(pst->dstInst);
1319
1320    /* In case of addition of any new measType here ,appropriate handling
1321     * has to be done in RLC DL (kwUtlSndDlL2MeasCfm)*/
1322    if(measType &
1323       (LKW_L2MEAS_DL_DISC | LKW_L2MEAS_DL_DELAY
1324        | LKW_L2MEAS_UU_LOSS| LKW_L2MEAS_DL_IP))
1325    {
1326       /*Redirect the request to DL task */
1327       KwUlUdxL2MeasSendReq(&(KW_GET_UDX_SAP(tKwCb)->pst),measType);
1328       /* L2 MEAS AGHOSH */
1329       /*RETVALUE(ROK);*/
1330    }
1331
1332    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
1333    {
1334       measEvtCb = &(tKwCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr]);
1335       /* L2 MEAS AGHOSH */
1336       if(measEvtCb->measCb.measType & measType)
1337       {
1338          kwUtlHdlL2TmrExp(tKwCb, measEvtCb);
1339       }
1340    }
1341
1342    RETVALUE(ROK);
1343 }
1344 #endif /* LTE_L2_MEAS */
1345
1346 /**
1347  * @brief
1348  *    This function configures the RLC data sap
1349  *
1350  * @param[in]  gCb   RLC Instance Control Block
1351  * @param[in]  cfg   RLC LM Sap configuration structure
1352  *
1353  * @return  S16
1354  *    -# LCM_REASON_NOT_APPL  (SUCCESS)
1355  *    -# LCM_REASON_INVALID_SAP
1356  *    -# LCM_REASON_MEM_NOAVAIL
1357  *    -# LCM_REASON_RECONFIG_FAIL
1358  */
1359 #ifdef ANSI
1360 PRIVATE S16 kwLmmCfgKwuSap
1361 (
1362 KwCb       *gCb,
1363 KwSapCfg   *cfg
1364 )
1365 #else
1366 PRIVATE S16 kwLmmCfgKwuSap(gCb,cfg)
1367 KwCb       *gCb;
1368 KwSapCfg   *cfg;
1369 #endif
1370 {
1371    KwKwuSapCb   *kwuSapCb;
1372    TRC2(kwLmmCfgKwuSap)
1373
1374 #if (ERRCLASS & ERRCLS_INT_PAR)
1375    /* Validate the protocol parameters */
1376    if((cfg->sapId >= (S16)gCb->genCfg.maxKwuSaps) || (cfg->sapId < 0))
1377    {
1378       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1379    }
1380 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1381
1382    kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1383               (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + cfg->sapId):
1384               (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + cfg->sapId);
1385
1386 #if (ERRCLASS & ERRCLS_INT_PAR)
1387    /* Check for reconfiguration */
1388    if (kwuSapCb->state != KW_SAP_NOT_CFG)
1389    {
1390       RLOG2(L_ERROR,"RLC Mode [%d] : Invalid kwuSap State [%d]",
1391             gCb->genCfg.rlcMode, kwuSapCb->state);
1392       /* reconfiguration not allowed */
1393       RETVALUE(LCM_REASON_RECONFIG_FAIL);
1394    }
1395 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1396
1397    /* Fill the parameters */
1398    KW_FILL_SAP_HELPER(kwuSapCb, cfg, gCb);
1399
1400    RETVALUE(LCM_REASON_NOT_APPL);
1401 }
1402
1403 /**
1404  * @brief
1405  *    This function configures the RLC control sap
1406  *
1407  * @param[in]  gCb   RLC Instance Control Block
1408  * @param[in]  cfg   RLC LM Sap configuration structure
1409  *
1410  * @return  S16
1411  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1412  *    -# LCM_REASON_INVALID_SAP
1413  *    -# LCM_REASON_INVALID_SAP
1414  *    -# LCM_REASON_RECONFIG_FAIL
1415  */
1416 #ifdef ANSI
1417 PRIVATE S16 kwLmmCfgCkwSap
1418 (
1419 KwCb       *gCb,
1420 KwSapCfg   *cfg
1421 )
1422 #else
1423 PRIVATE S16 kwLmmCfgCkwSap(gCb,cfg)
1424 KwCb       *gCb;
1425 KwSapCfg   *cfg;
1426 #endif
1427 {
1428    KwCkwSapCb  *ckwSap;
1429
1430    TRC2(kwLmmCfgCkwSap)
1431
1432 #if (ERRCLASS & ERRCLS_INT_PAR)
1433    /* Validate config parameters */
1434    if ((cfg->sapId >= KW_MAX_CKWSAPS) || (cfg->sapId < 0) )
1435    {
1436       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1437    }
1438
1439    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1440    {
1441       /* Get Sap control block */
1442       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1443    }
1444 #endif
1445
1446    ckwSap = &(gCb->u.ulCb->ckwSap);
1447
1448 #if (ERRCLASS & ERRCLS_INT_PAR)
1449    /* Check for reconfiguration */
1450    if(ckwSap->state  != KW_SAP_NOT_CFG)
1451    {
1452       RLOG1(L_ERROR,"Invalid kwuSap State [%d]",ckwSap->state);
1453       RETVALUE(LCM_REASON_RECONFIG_FAIL);
1454    }
1455 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1456
1457    /* Fill the parameters */
1458    KW_FILL_SAP_HELPER(ckwSap, cfg, gCb);
1459
1460    RETVALUE(LCM_REASON_NOT_APPL);
1461 }
1462
1463 /**
1464  * @brief
1465  *    This function configures the UDX sap
1466  *
1467  * @param[in]  gCb   RLC Instance Control Block
1468  * @param[in]  cfg   RLC LM Sap configuration structure
1469  *
1470  * @return  S16
1471  *    -# LCM_REASON_NOT_APPL   (SUCCESS)
1472  *    -# LCM_REASON_INVALID_SAP
1473  *    -# LCM_REASON_INVALID_SAP
1474  *    -# LCM_REASON_RECONFIG_FAIL
1475  */
1476 #ifdef ANSI
1477 PRIVATE S16 kwLmmCfgUdxSap
1478 (
1479 KwCb       *gCb,
1480 KwSapCfg   *cfg
1481 )
1482 #else
1483 PRIVATE S16 kwLmmCfgUdxSap(gCb,cfg)
1484 KwCb       *gCb;
1485 KwSapCfg   *cfg;
1486 #endif
1487 {
1488    KwUdxDlSapCb   *udxDlSap;
1489    KwUdxUlSapCb   *udxUlSap;
1490
1491    TRC2(kwLmmCfgUdxSap);
1492
1493 #if (ERRCLASS & ERRCLS_INT_PAR)
1494    /* Validate the protocol parameters */
1495    if((cfg->sapId >= KW_MAX_UDXSAPS) || (cfg->sapId < 0))
1496    {
1497       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1498    }
1499 #endif
1500    /* Get Sap control block */
1501    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1502    {
1503       udxDlSap = (gCb->u.dlCb->udxDlSap + cfg->sapId);
1504 #if (ERRCLASS & ERRCLS_INT_PAR)
1505       /* Check for reconfiguration */
1506       if(udxDlSap->state != KW_SAP_NOT_CFG)
1507       {
1508          RLOG1(L_ERROR,"Invalid udxDlSap State [%d]",udxDlSap->state);
1509          RETVALUE(LCM_REASON_RECONFIG_FAIL);
1510       }
1511 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1512
1513       /* Fill the parameters */
1514       KW_FILL_SAP_HELPER(udxDlSap, cfg, gCb);
1515    }
1516    else
1517    {
1518       udxUlSap = (gCb->u.ulCb->udxUlSap + cfg->sapId);
1519
1520 #if (ERRCLASS & ERRCLS_INT_PAR)
1521    /* Check for reconfiguration */
1522       if(udxUlSap->state != KW_SAP_NOT_CFG)
1523       {
1524          RLOG1(L_ERROR,"Invalid udxUlSap State [%d]", udxUlSap->state);
1525          RETVALUE(LCM_REASON_RECONFIG_FAIL);
1526       }
1527 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1528
1529       /* Fill the parameters */
1530       KW_FILL_SAP_HELPER(udxUlSap, cfg, gCb);
1531
1532       udxUlSap->bndTmrInt = cfg->bndTmrIntvl;
1533       udxUlSap->retryCnt = 0;
1534       cmInitTimers(&(udxUlSap->bndTmr), 1);
1535    }
1536
1537    RETVALUE(LCM_REASON_NOT_APPL);
1538 }
1539
1540 /**
1541  * @brief
1542  *    This function configures the RGU sap
1543  *
1544  * @param[in]  gCb   RLC Instance Control Block
1545  * @param[in]  cfg   RLC LM Sap configuration structure
1546  * @return  S16
1547  *    -# LCM_REASON_NOT_APPL    (SUCCESS)
1548  *    -# LCM_REASON_INVALID_SAP
1549  *    -# LCM_REASON_INVALID_SAP
1550  *    -# LCM_REASON_RECONFIG_FAIL
1551  */
1552 #ifdef ANSI
1553 PRIVATE S16 kwLmmCfgRguSap
1554 (
1555 KwCb       *gCb,
1556 KwSapCfg   *cfg
1557 )
1558 #else
1559 PRIVATE S16 kwLmmCfgRguSap(gCb,cfg)
1560 KwCb       *gCb;
1561 KwSapCfg   *cfg;
1562 #endif
1563 {
1564    KwRguSapCb   *rguSap;
1565
1566    TRC2(kwLmmCfgRguSap);
1567
1568 #if (ERRCLASS & ERRCLS_INT_PAR)
1569    /* Validate the protocol parameters */
1570    if((cfg->sapId >= gCb->genCfg.maxRguSaps) || \
1571       (cfg->sapId < 0))
1572    {
1573       KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cfg->sapId,
1574                "kwLmmCfgRguSap: Invalid RGU sapId\n");
1575       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
1576    }
1577 #endif
1578
1579    rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
1580             &(gCb->u.dlCb->rguDlSap[cfg->sapId]): &(gCb->u.ulCb->rguUlSap[cfg->sapId]);
1581
1582 #if (ERRCLASS & ERRCLS_INT_PAR)
1583    /* Check for reconfiguration */
1584    if(rguSap->state != KW_SAP_NOT_CFG)
1585    {
1586       RLOG2(L_ERROR,"RLC Mode [%d]: Invalid rguSap State [%d]",
1587             gCb->genCfg.rlcMode, rguSap->state);
1588       RETVALUE(LCM_REASON_RECONFIG_FAIL);
1589    }
1590 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1591
1592    /* Fill the parameters */
1593    KW_FILL_SAP_HELPER(rguSap, cfg, gCb);
1594    rguSap->suId = cfg->sapId;
1595    rguSap->bndTmrInt = cfg->bndTmrIntvl;
1596    rguSap->retryCnt = 0;
1597    rguSap->state = KW_SAP_CFG;
1598
1599    cmInitTimers(&(rguSap->bndTmr), 1);
1600
1601    RETVALUE(LCM_REASON_NOT_APPL);
1602 }
1603
1604 /**
1605  * @brief
1606  *    Validates the RLC general control parameters
1607  *
1608  * @param[in] cntrl   RLC LM structure
1609  *
1610  * @return  S16
1611  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1612  *    -# LCM_REASON_INVALID_SUBACTION
1613  *    -# LCM_REASON_INVALID_ACTION
1614  */
1615 #ifdef ANSI
1616 PRIVATE S16 kwLmmValidateGenCntrl
1617 (
1618 KwMngmt   *cntrl
1619 )
1620 #else
1621 PRIVATE S16 kwLmmValidateGenCntrl(cntrl)
1622 KwMngmt   *cntrl;
1623 #endif
1624 {
1625    S16   reason;    /* reason for failure */
1626    U8    sAction;   /* subaction field */
1627
1628    TRC2(kwLmmValidateGenCntrl);
1629
1630    reason = LCM_REASON_NOT_APPL;
1631    sAction = cntrl->t.cntrl.subAction;
1632
1633    switch (cntrl->t.cntrl.action)
1634    {
1635       case AENA:
1636       case ADISIMM:
1637          if ((sAction != SAUSTA) &&
1638              (sAction != SADBG) &&
1639              (sAction != SATRC))
1640          {
1641             reason = LCM_REASON_INVALID_SUBACTION;
1642          }
1643          break;
1644       case ASHUTDOWN:
1645          break;
1646       default:
1647          reason = LCM_REASON_INVALID_ACTION;
1648          break;
1649    }
1650
1651    RETVALUE(reason);
1652 }
1653
1654 /**
1655  * @brief
1656  *    it deregisters the timers and deregisters the kwuSap Control blocks
1657  *
1658  * @param[in]  gCb   RLC Instance Control Block
1659  *
1660  * @return  Void
1661  */
1662 #ifdef ANSI
1663 PRIVATE Void kwLmmCleanGblRsrcs
1664 (
1665 KwCb   *gCb
1666 )
1667 #else
1668 PRIVATE Void kwLmmCleanGblRsrcs(gCb)
1669 KwCb   *gCb;
1670 #endif
1671 {
1672    Size   kwSapSize;
1673    Size   kwUdxSapSize;
1674
1675    TRC2(kwLmmCleanGblRsrcs)
1676
1677    if (gCb->init.cfgDone)
1678    {
1679       /* Deregister the timers */
1680 /*Pradeep: changing the SDeregTmrMt() to SDeregTmr*/
1681       (Void) SDeregTmrMt(gCb->init.ent, gCb->init.inst,
1682                         (S16)gCb->genCfg.timeRes, kwActvTmr);
1683       /*(Void) SDeregTmr(gCb->init.ent, gCb->init.inst,
1684                         (S16)gCb->genCfg.timeRes, kwActvTmr);*/
1685
1686       kwSapSize = (Size)(gCb->genCfg.maxKwuSaps * sizeof(KwKwuSapCb));
1687
1688       if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1689       {
1690          kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxDlSapCb));
1691          if (gCb->u.dlCb)
1692          {
1693             gCb->u.dlCb->shutdownReceived = TRUE;
1694             kwUtlFreeDlMemory(gCb);
1695             if (gCb->u.dlCb->kwuDlSap != NULLP)
1696             {
1697                KW_FREE(gCb,gCb->u.dlCb->kwuDlSap, kwSapSize);
1698             }
1699
1700             if(gCb->u.dlCb->udxDlSap != NULLP)
1701             {
1702                KW_FREE(gCb,gCb->u.dlCb->udxDlSap, kwUdxSapSize);
1703             }
1704
1705             if(gCb->u.dlCb->rguDlSap != NULLP)
1706             {
1707                KW_FREE(gCb,gCb->u.dlCb->rguDlSap, gCb->genCfg.maxRguSaps);
1708                gCb->genCfg.maxRguSaps = 0;
1709             }
1710              if (gCb->u.dlCb->shutdownReceived)
1711             {
1712                if (gCb->u.dlCb->selfPstMBuf != NULL)
1713                {
1714                   SPutMsg(gCb->u.dlCb->selfPstMBuf);
1715                }
1716                KW_FREE(gCb,gCb->u.dlCb, sizeof (KwDlCb));
1717             }
1718          }
1719
1720       }
1721       else
1722       {
1723          kwUdxSapSize = (Size)(gCb->genCfg.maxUdxSaps * sizeof(KwUdxUlSapCb));
1724          if (gCb->u.ulCb)
1725          {
1726             if (gCb->u.ulCb->kwuUlSap != NULLP)
1727             {
1728                KW_FREE(gCb,gCb->u.ulCb->kwuUlSap, kwSapSize);
1729             }
1730
1731             if(gCb->u.ulCb->udxUlSap != NULLP)
1732             {
1733                KW_FREE(gCb,gCb->u.ulCb->udxUlSap, kwUdxSapSize);
1734             }
1735
1736             if(gCb->u.ulCb->rguUlSap != NULLP)
1737             {
1738                KW_FREE(gCb,gCb->u.ulCb->rguUlSap, gCb->genCfg.maxRguSaps);
1739                gCb->genCfg.maxRguSaps = 0;
1740             }
1741
1742             KW_FREE(gCb,gCb->u.ulCb, sizeof (KwUlCb));
1743          }
1744       }
1745
1746       gCb->init.cfgDone = FALSE;
1747       gCb->init.acnt = FALSE;
1748       gCb->init.trc = FALSE;
1749
1750       gCb->init.usta = FALSE;
1751    }
1752
1753    RETVOID;
1754 }
1755
1756 /**
1757  * @brief
1758  *    Delete all SAPs and Control Blocks
1759  *
1760  * @details
1761  *    Shutdown of RLC happens at modules level, tm, um and am modules will be
1762  *    shutdown using utility functin and dbm shutdown will clean up the SAPs,
1763  *    control blocks and lists.
1764  *
1765  * @params[in] gCb   RLC instance control block
1766  *
1767  * @return  S16
1768  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1769  *    -# LCM_REASON_HASHING_FAILED
1770  */
1771 #ifdef ANSI
1772 PRIVATE S16 kwLmmShutdown
1773 (
1774 KwCb   *gCb
1775 )
1776 #else
1777 PRIVATE S16 kwLmmShutdown(gCb)
1778 KwCb   *gCb;
1779 #endif
1780 {
1781    KwRguSapCb   *rguSap;
1782    U32          idx;
1783
1784    TRC2(kwLmmShutdown)
1785
1786    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1787    {
1788       for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1789       {
1790          rguSap = &(gCb->u.dlCb->rguDlSap[idx]);
1791          if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
1792          {
1793             KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1794          }
1795       }
1796    }
1797    else
1798    {
1799       for (idx = 0; idx < gCb->genCfg.maxRguSaps; idx++)
1800       {
1801          rguSap = &(gCb->u.ulCb->rguUlSap[idx]);
1802          if ((rguSap->state == KW_SAP_BND) || (rguSap->state == KW_SAP_BINDING))
1803          {
1804             KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
1805          }
1806       }
1807    }
1808
1809    if(gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1810    {
1811       kwDbmDlShutdown(gCb);
1812    }
1813    else
1814    {
1815       kwDbmUlShutdown(gCb);
1816    }
1817
1818    kwLmmCleanGblRsrcs(gCb);
1819
1820    KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
1821
1822    RETVALUE(LCM_REASON_NOT_APPL);
1823 }
1824
1825 /**
1826  * @brief
1827  *    Function processes the general control request
1828  *
1829  * @param[in] gCb     RLC instance control block
1830  * @param[in] cntrl   RLC LM structure
1831  *
1832  * @return  S16
1833  *    -# LCM_REASON_NOT_APPL (SUCCESS)
1834  *    -# LCM_REASON_INVALID_SUBACTION
1835  *    -# LCM_REASON_INVALID_ACTION
1836  */
1837 #ifdef ANSI
1838 PRIVATE S16 kwLmmGenCntrl
1839 (
1840 KwCb *gCb,
1841 KwMngmt *cntrl
1842 )
1843 #else
1844 PRIVATE S16 kwLmmGenCntrl(gCb,cntrl)
1845 KwCb    *gCb;
1846 KwMngmt *cntrl;
1847 #endif
1848 {
1849    KwTrcCntrl *trcCntrl; /* trace */
1850 #ifdef DEBUGP
1851    KwDbgCntrl *dbgCntrl; /* debug */
1852 #endif /* DEBUGP */
1853    S16   reason;         /* reason for failure */
1854
1855    TRC2(kwLmmGenCntrl);
1856
1857    /* Validate control parameters */
1858    reason = kwLmmValidateGenCntrl (cntrl);
1859
1860    if (reason != LCM_REASON_NOT_APPL)
1861    {
1862       RETVALUE(reason);
1863    }
1864
1865    switch(cntrl->t.cntrl.action)
1866    {
1867       case AENA:
1868       {
1869          switch(cntrl->t.cntrl.subAction)
1870          {
1871             case SAUSTA:
1872             {
1873                KW_SET_USTA_FLAG(gCb, TRUE);
1874                break;
1875             }
1876             case SADBG:
1877             {
1878 #ifdef DEBUGP
1879                dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1880                KW_GET_DBG_MASK(gCb) |= dbgCntrl->dbgMask;
1881 #endif /* DEBUGP */
1882                break;
1883             }
1884             case SATRC:
1885             {
1886                trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1887                gCb->init.trc = TRUE;
1888                gCb->trcLen = trcCntrl->trcLen;
1889                (gCb->trcMask) |= trcCntrl->trcMask;
1890                 break;
1891             }
1892          }
1893          break;
1894       }
1895       case ADISIMM:
1896       {
1897          switch(cntrl->t.cntrl.subAction)
1898          {
1899             case SAUSTA:
1900             {
1901                gCb->init.usta = FALSE;
1902             }
1903             break;
1904             case SADBG:
1905             {
1906 #ifdef DEBUGP
1907                dbgCntrl = &cntrl->t.cntrl.s.dbgCntrl;
1908                KW_GET_DBG_MASK(gCb) &= ~(dbgCntrl->dbgMask);
1909 #endif /* DEBUGP */
1910             }
1911             break;
1912             case SATRC:
1913             {
1914                trcCntrl = &cntrl->t.cntrl.s.trcCntrl;
1915                gCb->init.trc = FALSE;
1916                gCb->trcMask &= ~(trcCntrl->trcMask);
1917             }
1918             break;
1919          }
1920          break;
1921       }
1922       case ASHUTDOWN:
1923       {
1924          reason = kwLmmShutdown(gCb);
1925          break;
1926       }
1927    }
1928    RETVALUE(reason);
1929 }
1930
1931 /**
1932  * @brief
1933  *    Bind/Unbind RLC UDX sap
1934  *
1935  * @param[in]  gCb     RLC Instance Control Block
1936  * @param[in]  cntrl   RLC LM structure
1937  *
1938  * @return  S16
1939  *    -# LCM_REASON_NOT_/PPL (SUCCESS)
1940  *    -# LCM_REASON_INVALID_SAP
1941  *    -# LCM_REASON_INVALID_STATE
1942  *    -# LCM_REASON_INVALID_ACTION
1943  */
1944 #ifdef ANSI
1945 PRIVATE S16 kwLmmUdxSapCntrl
1946 (
1947 KwCb      *gCb,
1948 KwMngmt   *cntrl
1949 )
1950 #else
1951 PRIVATE S16 kwLmmUdxSapCntrl(gCb,cntrl)
1952 KwCb      *gCb;
1953 KwMngmt   *cntrl;
1954 #endif
1955 {
1956    TRC2(kwLmmUdxSapCntrl)
1957
1958 #if (ERRCLASS & ERRCLS_INT_PAR)
1959    if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
1960    {
1961       RETVALUE(LCM_REASON_INVALID_SAP);
1962    }
1963    /* validate SuId */
1964    if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
1965       (cntrl->t.cntrl.s.sapCntrl.suId >= KW_MAX_UDXSAPS))
1966    {
1967       RETVALUE(LCM_REASON_INVALID_SAP);
1968    }
1969 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1970
1971 #define UDX_SAP  gCb->u.ulCb->udxUlSap[cntrl->t.cntrl.s.sapCntrl.suId]
1972 #if (ERRCLASS & ERRCLS_INT_PAR)
1973    /* validate SAP */
1974    if(UDX_SAP.state == KW_SAP_NOT_CFG)
1975    {
1976       RLOG0(L_ERROR,"udxUlSap not configured yet");
1977       RETVALUE(LCM_REASON_INVALID_STATE);
1978    }
1979 #endif /* ERRCLASS & ERRCLS_INT_PAR */
1980
1981    switch(cntrl->t.cntrl.action)
1982    {
1983       case ABND:
1984       {
1985          if(UDX_SAP.state != KW_SAP_BND)
1986          {
1987             /* start timer to wait for bind confirm */
1988             kwStartTmr(gCb,(PTR)(&UDX_SAP), KW_EVT_WAIT_BNDCFM);
1989             UDX_SAP.state = KW_SAP_BINDING;
1990             KwUlUdxBndReq(&(UDX_SAP.pst), UDX_SAP.suId, UDX_SAP.spId);
1991          }
1992          else
1993          {
1994             /* control request received for an already bound SAP */
1995             RETVALUE(LCM_REASON_INVALID_STATE);
1996          }
1997       }
1998       break;
1999       case AUBND:
2000       {
2001          /* make the state of UDXSAP configured but not bound */
2002          UDX_SAP.state = KW_SAP_CFG;
2003          KwUlUdxUbndReq(&(UDX_SAP.pst), UDX_SAP.spId, 0);
2004       }
2005       break;
2006       default:
2007          RETVALUE(LCM_REASON_INVALID_ACTION);
2008          break;
2009    } /* end of switch */
2010 #undef UDX_SAP
2011    RETVALUE(LCM_REASON_NOT_APPL);
2012 }
2013
2014 /**
2015  * @brief
2016  *    Bind/Unbind RLC lower sap
2017  *
2018  * @param[in]  gCb     RLC Instance Control Block
2019  * @param[in]  cntrl   RLC LM structure
2020  * @return  S16
2021  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2022  *    -# LCM_REASON_INVALID_SAP
2023  *    -# LCM_REASON_INVALID_STATE
2024  *    -# LCM_REASON_INVALID_ACTION
2025  */
2026 #ifdef ANSI
2027 PRIVATE S16 kwLmmLSapCntrl
2028 (
2029 KwCb      *gCb,
2030 KwMngmt   *cntrl
2031 )
2032 #else
2033 PRIVATE S16 kwLmmLSapCntrl(gCb,cntrl)
2034 KwCb      *gCb;
2035 KwMngmt   *cntrl;
2036 #endif
2037 {
2038    KwRguSapCb   *rguSap;   /* rgu sap pointer */
2039
2040    TRC2(kwLmmLSapCntrl)
2041
2042 #if (ERRCLASS & ERRCLS_INT_PAR)
2043    /* validate SuId */
2044    if((cntrl->t.cntrl.s.sapCntrl.suId < 0) ||
2045       (cntrl->t.cntrl.s.sapCntrl.suId >= gCb->genCfg.maxRguSaps))
2046    {
2047       KWLOGERROR(gCb,ERRCLS_INT_PAR, EKW047, (ErrVal)cntrl->t.cntrl.s.sapCntrl.suId,
2048                "kwLmmLSapCntrl: Invalid RGU suId\n");
2049       RETVALUE(LCM_REASON_INVALID_SAP);
2050    }
2051 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2052    rguSap = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
2053             &(gCb->u.dlCb->rguDlSap[cntrl->t.cntrl.s.sapCntrl.suId]): \
2054             &(gCb->u.ulCb->rguUlSap[cntrl->t.cntrl.s.sapCntrl.suId]);
2055
2056 #if (ERRCLASS & ERRCLS_INT_PAR)
2057    /* validate SAP */
2058    if(rguSap->state == KW_SAP_NOT_CFG)
2059    {
2060       RLOG1(L_ERROR,"RLC Mode [%d]:rguSap not configured yet", gCb->genCfg.rlcMode);
2061       RETVALUE(LCM_REASON_INVALID_STATE);
2062    }
2063 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2064
2065    switch(cntrl->t.cntrl.action)
2066    {
2067       case ABND:
2068       {
2069          if(rguSap->state != KW_SAP_BND)
2070          {
2071             /* start timer to wait for bind confirm */
2072             kwStartTmr(gCb,(PTR)(rguSap), KW_EVT_WAIT_BNDCFM);
2073             rguSap->state = KW_SAP_BINDING;
2074             rguSap->spId = cntrl->t.cntrl.s.sapCntrl.spId;
2075             rguSap->suId = cntrl->t.cntrl.s.sapCntrl.suId;
2076             KwLiRguBndReq(&(rguSap->pst), rguSap->suId, rguSap->spId);
2077          }
2078          else
2079          {
2080             /* control request received for an already bound SAP */
2081             RETVALUE(LCM_REASON_INVALID_STATE);
2082          }
2083       }
2084       break;
2085       case AUBND:
2086       {
2087          /* make the state of RGUSAP is configure but not bound */
2088          rguSap->state = KW_SAP_CFG;
2089          KwLiRguUbndReq(&(rguSap->pst), rguSap->spId, 0);
2090       }
2091       break;
2092       default:
2093          RETVALUE(LCM_REASON_INVALID_ACTION);
2094          break;
2095    } /* end of switch */
2096
2097    RETVALUE(LCM_REASON_NOT_APPL);
2098 }
2099
2100 /**
2101  * @brief
2102  *    Function gather the general KWU SAP status
2103  *
2104  * @param[in] gCb   RLC Instance Control Block
2105  * @param[in] sta   LM KWU Sap Status structure
2106  *
2107  * @return  S16
2108  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2109  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2110  */
2111 #ifdef ANSI
2112 PRIVATE S16 kwLmmGetKwuSapSta
2113 (
2114 KwCb          *gCb,
2115 KwKwuSapSta   *sta
2116 )
2117 #else
2118 PRIVATE S16 kwLmmGetKwuSapSta(gCb,sta)
2119 KwCb          *gCb;
2120 KwKwuSapSta   *sta;
2121 #endif
2122 {
2123    KwKwuSapCb   *kwSapCb;
2124
2125    TRC2(kwLmmGetKwuSapSta);
2126
2127 #if (ERRCLASS & ERRCLS_INT_PAR)
2128    /* Validate the protocol parameters */
2129    if ((sta->spId >= (S16)gCb->genCfg.maxKwuSaps)||
2130        (sta->spId < 0))
2131    {
2132       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2133    }
2134 #endif
2135
2136    /* Get Sap control block */
2137    kwSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
2138              (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + sta->spId):
2139              (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + sta->spId);
2140
2141    sta->state = kwSapCb->state;
2142
2143    RETVALUE(LCM_REASON_NOT_APPL);
2144 }
2145
2146 /**
2147  * @brief
2148  *    Function gather the general RGU SAP status
2149  *
2150  * @param[in]  gCb   RLC Instance Control Block
2151  * @param[in]  sta   LM RGU Sap Status structure
2152  * @return  S16
2153  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2154  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2155  */
2156 #ifdef ANSI
2157 PRIVATE S16 kwLmmGetRguSapSta
2158 (
2159 KwCb          *gCb,
2160 KwRguSapSta   *sta
2161 )
2162 #else
2163 PRIVATE S16 kwLmmGetRguSapSta(gCb,sta)
2164 KwCb          *gCb;
2165 KwRguSapSta   *sta;
2166 #endif
2167 {
2168    TRC2(kwLmmGetRguSapSta);
2169
2170 #if (ERRCLASS & ERRCLS_INT_PAR)
2171    /* Validate the protocol parameters */
2172    if((sta->suId >= KW_MAX_RGUSAPS) || (sta->suId < 0))
2173    {
2174       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2175    }
2176 #endif
2177
2178    sta->state = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL) ?
2179                  gCb->u.dlCb->rguDlSap[sta->suId].state :
2180                  gCb->u.ulCb->rguUlSap[sta->suId].state ;
2181
2182    RETVALUE(LCM_REASON_NOT_APPL);
2183 }
2184
2185 /**
2186  * @brief
2187  *    Function gather the general CKW SAP status
2188  *
2189  * @param[in]  gCb   RLC Instance Control Block
2190  * @param[in]  sta   LM CKW Sap Status structure
2191  * @return  S16
2192  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2193  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2194  */
2195 #ifdef ANSI
2196 PRIVATE S16 kwLmmGetCkwCntSapSta
2197 (
2198 KwCb             *gCb,
2199 KwCkwCntSapSta   *sta
2200 )
2201 #else
2202 PRIVATE S16 kwLmmGetCkwCntSapSta(gCb,sta)
2203 kwCb             *gCb,
2204 KwCkwCntSapSta   *sta;
2205 #endif
2206 {
2207    TRC2(kwLmmGetCkwCntSapSta);
2208
2209 #if (ERRCLASS & ERRCLS_INT_PAR)
2210    /* Validate config parameters */
2211    if ((sta->spId >= KW_MAX_CKWSAPS ) ||
2212        (sta->spId < 0 ) ||
2213        (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL))
2214    {
2215       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2216    }
2217 #endif
2218    sta->state =  gCb->u.ulCb->ckwSap.state;
2219
2220    RETVALUE(LCM_REASON_NOT_APPL);
2221
2222 }
2223
2224 /**
2225  * @brief
2226  *    Gather the general statistics
2227  *
2228  * @param[in]  gCb      RLC Instance Control Block
2229  * @param[in]  sts      LM general statistics structure
2230  * @param[in]  action   action
2231  * @return  S16
2232  *    -# LCM_REASON_NOT_APPL       (SUCCESS)
2233  *    -# LCM_REASON_INVALID_PAR_VAL(FAILURE)
2234  */
2235 #ifdef ANSI
2236 PRIVATE S16 kwLmmGetGenSts
2237 (
2238 KwCb       *gCb,
2239 KwGenSts   *sts,
2240 Action     action
2241 )
2242 #else
2243 PRIVATE S16 kwLmmGetGenSts(gCb,sts, action)
2244 KwCb       *gCb;
2245 KwGenSts   *sts;
2246 Action     action;
2247 #endif
2248 {
2249    TRC2(kwLmmGetGenSts);
2250
2251 #if (ERRCLASS & ERRCLS_INT_PAR)
2252    /* Validate protocol parameters */
2253    if ((action != LKW_ZEROSTS) && (action != LKW_NOZEROSTS))
2254    {
2255       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2256    }
2257 #endif
2258
2259    *sts = gCb->genSts;
2260
2261    if(action == LKW_ZEROSTS)
2262    {
2263       KW_MEM_SET (&(gCb->genSts), 0, sizeof (KwGenSts));
2264    }
2265
2266    RETVALUE(LCM_REASON_NOT_APPL);
2267 }
2268
2269 /**
2270  * @brief
2271  *    Gather the SAP statistics
2272  *
2273  * @param[in]  gCb      RLC Instance Control Block
2274  * @param[in]  sts      LM general statistics structure
2275  * @param[in]  elmnt    element
2276  * @param[in]  action   action
2277  *
2278  * @return  S16
2279  *    -# LCM_REASON_NOT_APPL (SUCCESS)
2280  *    -# LCM_REASON_INVALID_PAR_VAL (FAIL)
2281  */
2282 #ifdef ANSI
2283 PRIVATE S16 kwLmmGetSapSts
2284 (
2285 KwCb      *gCb,
2286 KwMngmt   *sts,
2287 Elmnt     elmnt,
2288 Action    action
2289 )
2290 #else
2291 PRIVATE S16 kwLmmGetSapSts(sts, elmnt, action)
2292 KwCb      *gCb;
2293 KwMngmt   *sts;
2294 Elmnt     elmnt;
2295 Action    action;
2296 #endif
2297 {
2298    TRC2(kwLmmGetSapSts);
2299
2300    /* Validate protocol parameters */
2301    if (action != LKW_ZEROSTS && action != LKW_NOZEROSTS)
2302    {
2303       RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2304    }
2305    switch(elmnt)
2306    {
2307       case STKWUSAP:
2308       {
2309          KwKwuSapSts  *kwuSap;
2310          KwKwuSapCb   *kwuSapCb;
2311          kwuSap = &sts->t.sts.s.kwuSap;
2312
2313          /* Get Sap control block */
2314          /* kw005.201, modified the element of kwuSap from suId to spId */
2315          kwuSapCb = (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)?
2316               (KwKwuSapCb*)(gCb->u.dlCb->kwuDlSap + kwuSap->spId):
2317               (KwKwuSapCb*)(gCb->u.ulCb->kwuUlSap + kwuSap->spId);
2318
2319
2320          *kwuSap = kwuSapCb->sts;
2321
2322          if (action == LKW_ZEROSTS)
2323          {
2324             KW_MEM_SET (&kwuSapCb->sts, 0, sizeof (KwKwuSapSts));
2325          }
2326          break;
2327       }
2328       /* kw005.201 removed RGUSAP statistics support */
2329       case STCKWSAP:
2330       {
2331          KwCkwCntSts  *ckwSap;
2332          ckwSap = &sts->t.sts.s.ckwSap;
2333          if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
2334          {
2335             RETVALUE(LCM_REASON_INVALID_PAR_VAL);
2336          }
2337
2338          ckwSap->statMsgs = gCb->u.ulCb->ckwSap.sts.statMsgs;
2339
2340          if (action == LKW_ZEROSTS)
2341          {
2342             KW_MEM_SET (&(gCb->u.ulCb->ckwSap.sts), 0, sizeof (KwCkwCntSts));
2343          }
2344          break;
2345       }
2346       default:
2347          RETVALUE(LCM_REASON_INVALID_ELMNT);
2348    }
2349
2350    SGetDateTime(&sts->t.sts.dt);
2351
2352    RETVALUE(LCM_REASON_NOT_APPL);
2353 }
2354
2355 /**
2356  * @brief
2357  *    This function sends Unsolicited Status Indication to the Layer Management
2358  *    Entity.
2359  *
2360  * @param[in]  gCb        RLC Instance Control Block
2361  * @param[in]  category   Category
2362  * @param[in]  event      event
2363  * @param[in]  cause      cause
2364  * @param[in]  UeId       ueId
2365  * @param[in]  Qci        qci
2366  *
2367  * @return  Void
2368  */
2369 #ifdef LTE_L2_MEAS
2370 #ifdef ANSI
2371 PUBLIC Void kwLmmSendAlarm
2372 (
2373 KwCb   *gCb,
2374 U16    category,
2375 U16    event,
2376 U16    cause,
2377 SuId   suId,
2378 U32    ueId,
2379 U8     qci
2380 )
2381 #else
2382 PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId, qci)
2383 KwCb   *gCb;
2384 U16    category;
2385 U16    event;
2386 U16    cause;
2387 SuId   suId;
2388 U32    ueId;
2389 U8     qci;
2390 #endif
2391 #else /* LTE_L2_MEAS */
2392 #ifdef ANSI
2393 PUBLIC Void kwLmmSendAlarm
2394 (
2395 KwCb   *gCb,
2396 U16    category,
2397 U16    event,
2398 U16    cause,
2399 SuId   suId,
2400 U32    ueId
2401 )
2402 #else
2403 PUBLIC Void kwLmmSendAlarm(category, event, cause, suId, ueId)
2404 KwCb   *gCb;
2405 U16    category;
2406 U16    event;
2407 U16    cause;
2408 SuId   suId;
2409 U32    ueId;
2410 #endif
2411 #endif /* LTE_L2_MEAS */
2412 {
2413    KwMngmt   usta;   /* Rlc Management Structure */
2414
2415    TRC2(kwLmmSendAlarm);
2416
2417    if(gCb->init.usta == FALSE)
2418    {
2419       RETVOID;
2420    }
2421
2422    usta.hdr.elmId.elmnt = STGEN;
2423    usta.hdr.entId.ent = gCb->init.ent;
2424    usta.hdr.entId.inst = gCb->init.inst;
2425
2426    /* fill in the event and category */
2427    usta.t.usta.alarm.category = category;
2428    usta.t.usta.alarm.event = event;
2429    usta.t.usta.alarm.cause = cause;
2430
2431    /* set the suId and ueId */
2432    usta.t.usta.ueId = ueId;
2433    usta.t.usta.suId = suId;
2434 /* kw005.201 added support for L2 Measurement */
2435 #ifdef LTE_L2_MEAS
2436    if(event == LKW_EVT_MEAS_HALT)
2437    {
2438       usta.t.usta.qci = qci;
2439    }
2440 #endif /* LTE_L2_MEAS */
2441    /* update the date and time */
2442    (Void) SGetDateTime(&usta.t.usta.alarm.dt);
2443
2444    KwMiLkwStaInd(&(gCb->init.lmPst), &usta);
2445
2446    RETVOID;
2447
2448 }
2449
2450 /**
2451  * @brief
2452  *    This function sends trace indication to LM
2453  *
2454  * @param[in]  gCb     RLC Instance Control Block
2455  * @param[in]  event   event
2456  * @param[in]  mBuf    meessage buffer
2457  *
2458  * @return S16
2459  *    -# ROK
2460  *    -# RFAILED
2461  */
2462 #ifdef ANSI
2463 PUBLIC S16 kwLmmSendTrc
2464 (
2465 KwCb     *gCb,
2466 Event    event,
2467 Buffer   *mBuf
2468 )
2469 #else
2470 PUBLIC S16 kwLmmSendTrc(gCb,event, mBuf)
2471 KwCb     *gCb;
2472 Event    event;
2473 Buffer   *mBuf;
2474 #endif
2475 {
2476    KwMngmt   trc;              /* RLC management control block */
2477    Buffer    *dstMbuf;
2478    MsgLen    bufLen;
2479    Data      *tempBuf;
2480    MsgLen    tempCnt;
2481    Pst       pst;
2482
2483    TRC2(kwLmmSendTrc)
2484
2485    RLOG2(L_DEBUG, "kwLmmSendTrc(): Trace for event=%d, gCb->trcLen=%d",
2486                      event,
2487                      gCb->trcLen);
2488
2489    cmMemset((U8 *)&trc, 0, sizeof(KwMngmt));
2490
2491    pst = gCb->init.lmPst;
2492
2493    trc.t.trc.event = event;
2494    SGetDateTime(&trc.t.trc.dt);
2495    trc.cfm.status = LCM_PRIM_OK;
2496    trc.cfm.reason = LCM_REASON_NOT_APPL;
2497
2498    if(mBuf != NULLP)
2499    {
2500      /* Check if the whole buffer is to be sent in Trace indication */
2501      if(gCb->trcLen == LKW_FULL_TRACE)
2502      {
2503         if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2504             != ROK)
2505         {
2506            /* rg005.201 removed SPutSBuf on error */
2507            RLOG0(L_ERROR,"SCpyMsgMsg Failed");
2508            RETVALUE(RFAILED);
2509         }
2510         /* Send Trace Indication to Layer manager */
2511         KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2512      }
2513      /* check if only a specified number of bytes are to be sent */
2514      else if(gCb->trcLen > 0)
2515      {
2516         /* Get the length of the recvd message buffer */
2517         if (SFndLenMsg(mBuf, &bufLen) != ROK)
2518         {
2519            RLOG0(L_ERROR,"SFndLenMsg Failed");
2520            RETVALUE(RFAILED);
2521         }
2522         /* Check if the recvd buffer size is less than request trace len */
2523         if(bufLen < gCb->trcLen)
2524         {
2525            /* Copy the whole of the recvd buffer in trace indication */
2526
2527            if (SCpyMsgMsg(mBuf, pst.region, pst.pool, &dstMbuf)
2528               != ROK)
2529            {
2530               RLOG0(L_ERROR,"SCpyMsgMsg Failed");
2531               RETVALUE(RFAILED);
2532            }
2533
2534            /* Send Trace Indication to Layer manager */
2535            KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2536         }
2537         else
2538         {
2539            /* if the recvd buffer size is greater than request trace len */
2540            /* Get a temporary buffer to store the msg */
2541            KW_ALLOC(gCb,tempBuf, gCb->trcLen);
2542
2543 #if (ERRCLASS & ERRCLS_INT_PAR)
2544            if(tempBuf == NULLP)
2545            {
2546               (Void) SPutSMem(KW_GET_MEM_REGION(gCb), KW_GET_MEM_POOL(gCb));
2547
2548                RLOG0(L_FATAL,"Memory Allocation failed");
2549                RETVALUE(LCM_REASON_MEM_NOAVAIL);
2550            }
2551 #endif /* ERRCLASS & ERRCLS_INT_PAR */
2552
2553            /* Copy trcLen nos of bytes from the recvd message */
2554            if (SCpyMsgFix(mBuf,0,gCb->trcLen,tempBuf,&tempCnt) != ROK)
2555            {
2556               RLOG0(L_ERROR,"SCpyMsgFix Failed");
2557               RETVALUE(RFAILED);
2558            }
2559
2560            if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
2561            {
2562               RLOG0(L_FATAL,"Memory Allocation failed");
2563               RETVALUE(RFAILED);
2564            }
2565            /* Copy the tempBuf data to dst mBuf */
2566            if (SCpyFixMsg(tempBuf,dstMbuf,0,gCb->trcLen,&tempCnt) != ROK)
2567            {
2568               RLOG0(L_ERROR,"SCpyMsgFix Failed");
2569               RETVALUE(RFAILED);
2570            }
2571
2572            /* Free the memory allocated for tempBuf */
2573            KW_FREE(gCb,tempBuf, gCb->trcLen);
2574            /* Send Trace Indication to Layer manager */
2575            KwMiLkwTrcInd(&pst, &trc, dstMbuf);
2576         }
2577      }
2578    }
2579    else
2580    {
2581       KwMiLkwTrcInd(&pst, &trc, mBuf);
2582    }
2583
2584    RETVALUE(ROK);
2585 }
2586
2587 \f
2588 /*
2589  * @brief
2590  *    Activate Task - timer
2591  *
2592  * @details
2593  *    Invoked by system services to activate a task with a timer tick.
2594  *
2595  * @param[in] ent    entity
2596  * @param[in] inst   instance
2597  *
2598  * @return S16
2599  *    -# ROK
2600  *    -# RFAILED
2601  *
2602  */
2603
2604 #ifdef ANSI
2605 PUBLIC S16 kwActvTmr
2606 (
2607 Ent    ent,
2608 Inst   inst
2609 )
2610 #else
2611 PUBLIC S16 kwActvTmr(ent,inst)
2612 Ent    ent;
2613 Inst   inst;
2614 #endif
2615 {
2616    KwCb   *gCb;
2617    TRC2(kwActvTmr)
2618
2619    if (inst >= KW_MAX_RLC_INSTANCES)
2620    {
2621       RETVALUE (RFAILED);
2622    }
2623    gCb = KW_GET_KWCB(inst);
2624    cmPrcTmr(&(gCb->kwTqCp), gCb->kwTq, (PFV) kwTmrExpiry);
2625
2626    RETVALUE(ROK);
2627
2628 } /* end of kwActvTmr */
2629
2630
2631 /********************************************************************30**
2632
2633          End of file
2634 **********************************************************************/