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