src/5gnrrlc/kw_cfg_ul.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 - Configuration Manager file
  22
  23         Type:    C source file
  24
  25         Desc:    It contains the following configuraiton primtives
  26                  for different actions
  27                     -- kwCfgValdtEntCfg
  28                     -- kwCfgFillRbCb
  29                     -- kwCfgRbInit
  30
  31         File:     kw_cfg_ul.c
  32
  33 *********************************************************************21*/
  34 static const char* RLOG_MODULE_NAME="CFG";
  35 static int RLOG_MODULE_ID=2048;
  36 static int RLOG_FILE_ID=192;
  37 /** @file kw_cfg_ul.c
  38 @brief RLC Uplink Configuration Module
  39 **/
  40
  41 \f
  42 /* header (.h) include files */
  43 #include "common_def.h"
  44 #include "lkw.h"           /* LKW defines */
  45 #include "ckw.h"           /* CKW defines */
  46 #include "kwu.h"           /* KWU defines */
  47 #include "rgu.h"           /* RGU defines */
  48 #include "kw_err.h"        /* RLC error options */
  49 #include "kw_env.h"        /* RLC environment options */
  50 #include "kw.h"            /* RLC defines */
  51 #include "kw_ul.h"
  52
  53 /* extern (.x) include files */
  54 #include "lkw.x"           /* LKW */
  55 #include "ckw.x"           /* CKW */
  56 #include "kwu.x"           /* KWU */
  57 #include "rgu.x"           /* RGU */
  58
  59 #include "kw.x"
  60 #include "kw_ul.x"
  61 #ifdef TENB_STATS
  62 #ifdef L2_L3_SPLIT
  63 #include "l2_tenb_stats.x"    /* Total EnodeB Stats declarations */
  64 #endif
  65 #endif
  66 PUBLIC S16 kwValidateRbCfgParams (KwCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
  67                                   CkwEntCfgInfo *cfgToValidate, CmStatus *status);
  68 #define KW_MODULE KW_DBGMASK_CFG
  69 #ifdef LTE_L2_MEAS
  70 /**
  71  *
  72  * @brief Handle modification of UE ID for L2 Meas data structs
  73  *
  74  *
  75  *  @param[in] ueId     ue ID
  76  *
  77  *  @return  S16
  78  *      -# ROK
  79  *      -# RFAILED
  80  *
  81 */
  82 PRIVATE S16 kwHdlMeasUlUeIdChg(KwCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
  83 {
  84    KwL2MeasCb    *measCb    = NULLP;
  85    U16           cntr;
  86    U16          ueIdx = 0;
  87
  88    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
  89    {
  90       measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
  91
  92       if( measCb->measType & LKW_L2MEAS_UL_IP)
  93       {
  94
  95          for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++)
  96          {
  97             if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == oldUeId)
  98             {
  99                measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = newUeId;
 100                break;
 101             }
 102          }
 103       }
 104    }
 105    RETVALUE(ROK);
 106 }
 107
 108 /**
 109  *
 110  * @brief Handler to delete an UE's L2 Meas ctxt
 111  *
 112 *
 113  *  @param[in] ueId     ue ID
 114  *
 115  *  @return  S16
 116  *      -# ROK
 117  *      -# RFAILED
 118  *
 119 */
 120 PRIVATE S16 kwDelFrmUlL2Meas(KwCb *gCb, U8 cellId,U8 ueId)
 121 {
 122    KwL2MeasCb    *measCb    = NULLP;
 123    U16           cntr;
 124    U16          ueIdx = 0;
 125
 126    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
 127    {
 128       measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
 129
 130
 131       if( measCb->measType & LKW_L2MEAS_UL_IP)
 132       {
 133
 134          for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++)
 135          {
 136             if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == ueId)
 137             {
 138                measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = FALSE;
 139                if (measCb->val.ipThMeas.numUes-1 == ueIdx)
 140                {
 141                   measCb->val.ipThMeas.numUes--;
 142                }
 143                break;
 144             }
 145          }
 146
 147
 148
 149       {
 150          U32 myIdx =0;
 151          S16                  ret;           /* Return value */
 152             KwUlUeCb             *ueCb = NULL;
 153
 154             for (myIdx = 0; myIdx < measCb->val.ipThMeas.numUes; myIdx++)
 155             {
 156                ueCb = NULL;
 157                ret = kwDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb);
 158             }
 159          }
 160
 161       }
 162    }
 163
 164    RETVALUE(ROK);
 165 }
 166
 167
 168 PRIVATE S16 kwAddToUlL2Meas(KwCb *gCb, KwUlRbCb *kwRbCb,U8 cellId,U8 ueId)
 169 {
 170    KwL2MeasCb    *measCb    = NULLP;
 171    U16           cntr;
 172    U16           cntr1;
 173    U16            ueIdx = 0;
 174    U16            qciIdx = 0;
 175    U16           *numQci;
 176    #ifndef XEON_SPECIFIC_CHANGES
 177    U8             freeIdx = gCb->genCfg.maxUe;
 178    #else
 179    U16           freeIdx = LKW_MAX_UE;
 180    #endif
 181
 182    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
 183    {
 184       measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
 185
 186       freeIdx = gCb->genCfg.maxUe;
 187
 188       if(measCb->measType & LKW_L2MEAS_ACT_UE )
 189       {
 190          for(cntr1 =0;cntr1<measCb->val.nonIpThMeas.numQci;cntr1++)
 191          {
 192             if(measCb->val.nonIpThMeas.qci[cntr1] != kwRbCb->qci)
 193             {
 194                measCb->val.nonIpThMeas.qci[cntr1]  = kwRbCb->qci;
 195                gCb->u.ulCb->kwL2Cb.measOn[kwRbCb->qci] |=measCb->measType;
 196                break;
 197             }
 198          }
 199       }
 200
 201       if(((kwRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE))
 202       {
 203 #ifdef LTE_L2_MEAS_RLC
 204          if (measCb->measType & LKW_L2MEAS_ACT_UE)
 205          {
 206             if((kwRbCb->mode == CM_LTE_MODE_UM) &&
 207                   (kwRbCb->dir & KW_DIR_DL ))
 208             {
 209                if (kwRbCb->m.um.umDl.sduQ.count)
 210                {
 211                   if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
 212                   {
 213                      kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
 214                      gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++;
 215                   }
 216                }
 217             }
 218             else if (kwRbCb->mode == CM_LTE_MODE_AM)
 219             {
 220                if ((kwRbCb->m.am.amDl.cntrlBo) ||
 221                      (kwRbCb->m.am.amDl.retxBo)  ||
 222                      (kwRbCb->m.am.amDl.bo))
 223                {
 224                   if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
 225                   {
 226                      kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
 227                      gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++;
 228                   }
 229                }
 230             }
 231          }
 232 #endif
 233       }
 234       if((measCb->measType & LKW_L2MEAS_UL_IP))
 235       {
 236
 237          for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++)
 238          {
 239             if ((freeIdx == gCb->genCfg.maxUe) &&
 240                   (measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid == FALSE))
 241             {
 242                freeIdx = ueIdx;
 243                continue;
 244             }
 245             if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == ueId)
 246             {
 247                break;
 248             }
 249          }
 250
 251          if (ueIdx ==  measCb->val.ipThMeas.numUes)
 252          {
 253             if (gCb->genCfg.maxUe == measCb->val.ipThMeas.numUes)
 254             {
 255                RETVALUE(RFAILED);
 256             }
 257             if (gCb->genCfg.maxUe == freeIdx)
 258             {
 259                measCb->val.ipThMeas.numUes++;
 260             }
 261             else
 262             {
 263                ueIdx = freeIdx;
 264             }
 265             measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE;
 266             cmMemset((U8 *)&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(KwL2Cntr) *LKW_MAX_QCI));
 267             measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci = 0;
 268          }
 269          measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = ueId;
 270          measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId = cellId;
 271          numQci = &(measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci);
 272
 273          for (qciIdx =0; qciIdx <  *numQci; qciIdx++)
 274          {
 275             if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == kwRbCb->qci)
 276             {
 277                break;
 278             }
 279          }
 280
 281          if (qciIdx == *numQci)
 282          {
 283             measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = kwRbCb->qci;
 284             (*numQci)++;
 285          }
 286 \f
 287          kwUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[kwRbCb->qci],
 288                &kwRbCb->rbL2Cb, measCb->measType);
 289       }
 290       kwRbCb->rbL2Cb.measOn |= measCb->measType;
 291    }
 292    RETVALUE(ROK);
 293 }/*kwAddToDlL2Meas*/
 294 #endif /*LTE_L2_MEAS*/
 295 \f
 296 /**
 297  * @brief
 298  *     This primitive fills the RbCb
 299  *
 300  * @param [in]    gCb      -  RLC Instance Control Block
 301  * @param [out]   rbCb     -  RB Control Block
 302  * @param [out]   ueCb     -  UE Control Block
 303  * @param [in]    entCfg   -  RLC Entity configuration
 304  *
 305  * @return  S16
 306  *    -#ROK
 307  *    -#RFAILED
 308  */
 309 #ifdef ANSI
 310 PRIVATE S16 kwCfgFillUlRbCb
 311 (
 312 KwCb            *gCb,
 313 KwUlRbCb        *rbCb,
 314 KwUlUeCb        *ueCb,
 315 CkwEntCfgInfo   *entCfg
 316 )
 317 #else
 318 PRIVATE S16 kwCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg)
 319 KwCb            *gCb;
 320 KwUlRbCb        *rbCb;
 321 KwUlUeCb        *ueCb;
 322 CkwEntCfgInfo   *entCfg;
 323 #endif
 324 {
 325    TRC3(kwCfgFillUlRbCb)
 326
 327    RLOG_ARG3(L_DEBUG,DBG_UEID,rbCb->rlcId.ueId,
 328                 "kwCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
 329                 rbCb->rlcId.cellId,
 330                 entCfg->rbId,
 331                 entCfg->rbType);
 332
 333    /* Initialize according to entMode */
 334    switch (entCfg->entMode)
 335    {
 336       case CM_LTE_MODE_TM:
 337       {
 338          rbCb->lch.lChId  = entCfg->lCh[0].lChId;
 339          rbCb->lch.lChType = entCfg->lCh[0].type;
 340          rbCb->dir = entCfg->dir;
 341          break;
 342       }
 343       case CM_LTE_MODE_UM:
 344       {
 345          rbCb->lch.lChId  = entCfg->lCh[0].lChId;
 346          rbCb->lch.lChType = entCfg->lCh[0].type;
 347
 348          rbCb->dir = entCfg->dir;
 349
 350          rbCb->m.umUl.snLen = entCfg->m.umInfo.ul.snLen;
 351
 352          /* the bitmask for SN = 10 is 0x3ff and for SN = 5 is 0x1f */
 353          rbCb->m.umUl.modBitMask = (rbCb->m.umUl.umWinSz << 1) - 1;
 354
 355          rbCb->m.umUl.reOrdTmrInt =
 356             entCfg->m.umInfo.ul.reOrdTmr;
 357          cmInitTimers(&(rbCb->m.umUl.reOrdTmr), 1);
 358          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
 359          break;
 360       }
 361       case CM_LTE_MODE_AM:
 362       {
 363          /* Down Link Information
 364           * indx = 1 as Up Link   */
 365          rbCb->lch.lChId  = entCfg->lCh[1].lChId;
 366          rbCb->lch.lChType = entCfg->lCh[1].type;
 367          rbCb->dir = KW_DIR_BOTH;
 368
 369          rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr;
 370          rbCb->m.amUl.reOrdTmrInt = entCfg->m.amInfo.ul.reOrdTmr;
 371
 372          rbCb->m.amUl.snLen = entCfg->m.amInfo.ul.snLen; /* 5GNR */
 373
 374          if(KW_AM_CFG_12BIT_SN_LEN == rbCb->m.amUl.snLen)
 375          {
 376             rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_12BITS) - 1; /* 5GNR */
 377          }
 378          else
 379          {
 380             rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_18BITS) - 1; /* 5GNR */
 381          }
 382
 383          cmInitTimers(&(rbCb->m.amUl.reOrdTmr), 1);
 384          cmInitTimers(&(rbCb->m.amUl.staProhTmr), 1);
 385
 386          rbCb->m.amUl.vrMr = rbCb->m.amUl.rxNext + (KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen));
 387
 388          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
 389
 390          break;
 391       }
 392       default:
 393       {
 394          RLOG_ARG2(L_ERROR,DBG_UEID,rbCb->rlcId.ueId,
 395                 "INVALID RB Mode cellId(%d), rbId(%d)",
 396                 rbCb->rlcId.cellId,
 397                 entCfg->rbId);
 398          RETVALUE(RFAILED);
 399       }
 400    }
 401    rbCb->mode = entCfg->entMode;
 402
 403    RETVALUE(ROK);
 404 }
 405
 406 \f
 407 /**
 408  * @brief This primitive Initializes the RB Cb
 409  *
 410  * @param [in]    gCb      -  RLC Instance Control Block
 411  * @param [out]   rbCb     -  RB Control Block
 412  * @param [in]    ptr      -  Void pointer
 413  * @param [in]    entCfg   -  Entity Configuration
 414  *
 415  * @return  S16
 416  *    -#ROK
 417  *    -#RFAILED
 418  */
 419 #ifdef ANSI
 420 PRIVATE S16 kwCfgUpdateUlRb
 421 (
 422 KwCb            *gCb,
 423 KwUlRbCb        *rbCb,
 424 void            *ptr,
 425 CkwEntCfgInfo   *entCfg
 426 )
 427 #else
 428 PRIVATE S16 kwCfgUpdateUlRb(gCb,rbCb, ptr, entCfg)
 429 KwCb            *gCb;
 430 KwUlRbCb        *rbCb;
 431 void            *ptr;
 432 CkwEntCfgInfo   *entCfg;
 433 #endif
 434 {
 435    TRC3(kwCfgUpdateUlRb)
 436
 437    switch (rbCb->mode)
 438    {
 439       case CM_LTE_MODE_TM:
 440       {
 441          KwUlCellCb *cellCb = (KwUlCellCb *)ptr;
 442          rbCb->dir = entCfg->dir;
 443          rbCb->lch.lChId = entCfg->lCh[0].lChId;
 444          rbCb->lch.lChType = entCfg->lCh[0].type;
 445
 446          cellCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
 447          break;
 448       }
 449       case CM_LTE_MODE_UM:
 450       {
 451          KwUlUeCb *ueCb = (KwUlUeCb *)ptr;
 452          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
 453          kwCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg);
 454          break;
 455       }
 456       case CM_LTE_MODE_AM:
 457       {
 458          KwUlUeCb *ueCb = (KwUlUeCb *)ptr;
 459
 460          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
 461          ueCb->lCh[entCfg->lCh[1].lChId - 1].ulRbCb = rbCb;
 462          /* Up Link */
 463          rbCb->lch.lChId = entCfg->lCh[1].lChId;
 464          rbCb->lch.lChType = entCfg->lCh[1].type;
 465          rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr;
 466          rbCb->m.amUl.reOrdTmrInt = entCfg->m.amInfo.ul.reOrdTmr;
 467          break;
 468       }
 469    }
 470    RETVALUE(CKW_CFG_REAS_NONE);
 471 }
 472
 473 \f
 474 /**
 475  * @brief
 476  *    This primitive validates uplink Add RB Configuration and reserve memory
 477  *    for RB creation.
 478  *
 479  * @param [in]  gCb      -  RLC Instance Control Block
 480  * @param [in]  ueId     -  UE Identifier
 481  * @param [in]  cellId   -  CELL Identifier
 482  * @param [in]  cfgToValidate   -  Entity Configuration needs to be validated.
 483  * @param [out] status  -  status of configuration
 484  *
 485  * @return  S16
 486  *    -# ROK
 487  *    -# RFAILED
 488  */
 489 #ifdef ANSI
 490 PUBLIC S16 kwValidateRbCfgParams
 491 (
 492 KwCb            *gCb,
 493 CmLteRnti       ueId,
 494 CmLteCellId     cellId,
 495 CkwEntCfgInfo   *cfgToValidate,
 496 CmStatus        *status
 497 )
 498 #else
 499 PUBLIC S16 kwValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status)
 500 KwCb            *gCb;
 501 CmLteRnti       ueId;
 502 CmLteCellId     cellId;
 503 CkwEntCfgInfo   *cfgToValidate;
 504 CmStatus        *status;
 505 #endif
 506 {
 507    if (cellId == 0)
 508    {
 509       status->reason = CKW_CFG_REAS_CELL_UNKWN;
 510       RETVALUE (RFAILED);
 511    }
 512    if ((cfgToValidate->rguSapId >= gCb->genCfg.maxRguSaps) || (cfgToValidate->rguSapId < 0))
 513    {
 514       KWDBGP_ERROR(gCb, "kwValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
 515             ueId, cellId, cfgToValidate->rguSapId);
 516       status->reason = CKW_CFG_REAS_INVALID_RGUSAP;
 517       RETVALUE(RFAILED);
 518    }
 519
 520    if((CKW_CFG_ADD == cfgToValidate->cfgType) ||
 521       (CKW_CFG_MODIFY == cfgToValidate->cfgType))
 522    {
 523       /* Validate LChId for UM and AM modes */
 524       if ((cfgToValidate->lCh[0].lChId <= 0) ||
 525            ((cfgToValidate->entMode == CM_LTE_MODE_AM) &&
 526              (cfgToValidate->lCh[1].lChId <= 0)))
 527       {
 528          status->reason = CKW_CFG_REAS_INVALID_LCHID;
 529          RETVALUE(RFAILED);
 530       }
 531       if((cfgToValidate->entMode == CM_LTE_MODE_UM) &&
 532          (cfgToValidate->m.umInfo.ul.snLen != KW_UM_CFG_5BIT_SN_LEN) &&
 533          (cfgToValidate->m.umInfo.ul.snLen != KW_UM_CFG_10BIT_SN_LEN))
 534       {
 535          RLOG_ARG2(L_ERROR,DBG_UEID,ueId,
 536                "CellId[%u]:UM Mode RB[%d],Invalid SN Len[%d]",
 537                cfgToValidate->rbId,
 538                cfgToValidate->m.umInfo.ul.snLen);
 539          status->reason = CKW_CFG_REAS_INVALID_SNLEN;
 540          RETVALUE(RFAILED);
 541       }
 542       /* Process Adding new RB */
 543       if (ueId == 0)
 544       {
 545          if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
 546          {
 547             status->reason = CKW_CFG_REAS_RB_UNKWN;
 548             RETVALUE(RFAILED);
 549          }
 550
 551          if ((cfgToValidate->lCh[0].type != CM_LTE_LCH_CCCH) &&
 552                (cfgToValidate->entMode != CM_LTE_MODE_TM))
 553          {
 554             status->reason= (cfgToValidate->entMode != CM_LTE_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
 555                CKW_CFG_REAS_LCHTYPE_MIS;
 556             RETVALUE(RFAILED);
 557          }
 558       }
 559       else
 560       {
 561          if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
 562          {
 563             status->reason = CKW_CFG_REAS_RB_UNKWN;
 564             RETVALUE(RFAILED);
 565          }
 566
 567          if(cfgToValidate->entMode == CM_LTE_MODE_TM)
 568          {
 569             status->reason = CKW_CFG_REAS_LCHTYPE_MIS;
 570             RETVALUE(RFAILED);
 571          }
 572          if (!(((cfgToValidate->lCh[0].type == CM_LTE_LCH_DCCH) &&
 573                (cfgToValidate->entMode != CM_LTE_MODE_UM))||
 574                (cfgToValidate->lCh[0].type == CM_LTE_LCH_DTCH)) )
 575          {
 576             status->reason = CKW_CFG_REAS_RB_MODE_MIS;
 577             RETVALUE(RFAILED);
 578          }
 579       }
 580    }
 581    else /* cfgType is CKW_CFG_DELETE */
 582    {
 583       if (ueId == 0)
 584       {
 585          if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
 586          {
 587             status->reason = CKW_CFG_REAS_RB_UNKWN;
 588             RETVALUE(RFAILED);
 589          }
 590
 591       }
 592       else
 593       {
 594          if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
 595          {
 596             status->reason = CKW_CFG_REAS_RB_UNKWN;
 597             RETVALUE(RFAILED);
 598          }
 599       }
 600    }
 601    RETVALUE(ROK);
 602 }
 603
 604 \f
 605 /**
 606  * @brief
 607  *    This primitive validates uplink Add RB Configuration and reserve memory
 608  *    for RB creation.
 609  *
 610  * @param [in]  gCb      -  RLC Instance Control Block
 611  * @param [in]  cfgToValidate   -  Entity Configuration needs to be validated.
 612  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 613  * @param [out] cfgTmpData    -  Configuration Temporary Data
 614  *
 615  * @return  S16
 616  *    -# ROK
 617  *    -# RFAILED
 618  */
 619 #ifdef ANSI
 620 PUBLIC S16 kwCfgValidateUlRb
 621 (
 622 KwCb             *gCb,
 623 CkwEntCfgInfo    *cfgToValidate,
 624 KwUlEntTmpData   *cfgEntData,
 625 KwUlCfgTmpData   *cfgTmpData
 626 )
 627 #else
 628 PUBLIC S16 kwCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
 629 KwCb             *gCb;
 630 CkwEntCfgInfo    *cfgToValidate;
 631 KwUlEntTmpData   *cfgEntData;
 632 KwUlCfgTmpData   *cfgTmpData;
 633 #endif
 634 {
 635    TRC3(kwCfgValidateUlRb)
 636
 637    RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
 638                "cellId(%d), cfgType(%d)",
 639                 cfgTmpData->cellId,
 640                 cfgToValidate->cfgType);
 641
 642    if(ROK != kwValidateRbCfgParams(gCb,
 643                                    cfgTmpData->ueId,
 644                                    cfgTmpData->cellId,
 645                                    cfgToValidate,
 646                                    &cfgEntData->entUlCfgCfm.status))
 647    {
 648       RETVALUE(RFAILED);
 649    }
 650
 651    cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_NONE;
 652    switch(cfgToValidate->cfgType)
 653    {
 654       case CKW_CFG_ADD:
 655       {
 656          if (cfgTmpData->ueId == 0)
 657          {
 658             /* Cell Cb is added if it not present , it is not roll backed if the
 659              * configuration fails */
 660             kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
 661             if(!cfgTmpData->cellCb)
 662             {
 663                /* cell cb does not exist we need to create a new one */
 664                KW_ALLOC(gCb,cfgTmpData->cellCb, sizeof(KwUlCellCb));
 665                if(!cfgTmpData->cellCb)
 666                {
 667                   RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId,
 668                         "Memory allocation failure CELLID:%d",
 669                         cfgTmpData->cellId);
 670                   cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL;
 671                   RETVALUE(RFAILED);
 672                }
 673                kwDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
 674             }
 675             else
 676             {
 677                if (( cfgTmpData->cellCb->rbCb[cfgToValidate->rbId] != NULLP))
 678                {
 679                   cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_PRSNT;;
 680                   RETVALUE(RFAILED);
 681                }
 682             }
 683
 684             KW_ALLOC(gCb,cfgEntData->rbCb, sizeof (KwUlRbCb));
 685             if (!cfgEntData->rbCb)
 686             {
 687                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
 688                RETVALUE(RFAILED);
 689             }
 690          }
 691          else
 692          {
 693             /* Ue Cb is added if it not present , it is not roll backed if the
 694              * configuration fails */
 695             kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
 696             if(!cfgTmpData->ueCb)
 697             {
 698                KW_ALLOC(gCb,cfgTmpData->ueCb, sizeof(KwUlUeCb));
 699                if(!cfgTmpData->ueCb)
 700                {
 701                   RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId,
 702                         "Memory allocation failure CELLID:%d",
 703                         cfgTmpData->cellId);
 704                   cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL;
 705                   RETVALUE(RFAILED);
 706                }
 707                kwDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
 708             }
 709             else
 710             {
 711                KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
 712                      cfgToValidate->rbType,
 713                      cfgTmpData->ueCb,
 714                      cfgEntData->rbCb);
 715                if(cfgEntData->rbCb != NULLP)
 716                {
 717                   cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_PRSNT;;
 718                   RETVALUE(RFAILED);
 719                }
 720             }
 721             KW_ALLOC(gCb,cfgEntData->rbCb, sizeof (KwUlRbCb));
 722             if (!cfgEntData->rbCb)
 723             {
 724                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
 725                RETVALUE(RFAILED);
 726             }
 727          }
 728          /*Allocating the memory for receive buffer */
 729          if(CM_LTE_MODE_UM == cfgToValidate->entMode)
 730          {
 731             U16 winLen;
 732
 733
 734             cfgEntData->rbCb->m.umUl.umWinSz = KW_POWER(2,
 735                   ((cfgToValidate->m.umInfo.ul.snLen *5)-1));
 736             winLen =  cfgEntData->rbCb->m.umUl.umWinSz << 1;
 737             KW_ALLOC(gCb,
 738                      cfgEntData->rbCb->m.umUl.recBuf,
 739                      (winLen * sizeof(KwUmRecBuf*)));
 740          }
 741          else if(CM_LTE_MODE_AM == cfgToValidate->entMode)
 742          {
 743 #ifndef LTE_TDD
 744              U32 hashIndex;
 745               KW_ALLOC(gCb,
 746                     cfgEntData->rbCb->m.amUl.recBufLst,
 747                     (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
 748               for(hashIndex = 0; hashIndex < KW_RCV_BUF_BIN_SIZE; hashIndex++)
 749               {
 750                   cmLListInit(&(cfgEntData->rbCb->m.amUl.recBufLst[hashIndex]));
 751               }
 752 #endif
 753          }
 754          break;
 755       }
 756       case CKW_CFG_MODIFY:
 757       case CKW_CFG_DELETE:
 758       {
 759          if (cfgTmpData->ueId == 0)
 760          {
 761             /* Try to get the CellCb if it already exists */
 762             kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
 763             if(!cfgTmpData->cellCb)
 764             {
 765                 RLOG_ARG1(L_ERROR, DBG_CELLID,cfgTmpData->cellId,
 766                       "CellCb not found UEID:%d",
 767                       cfgTmpData->ueId);
 768                /*how can a modify request come for a cell which does not exist*/
 769                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
 770                RETVALUE(RFAILED);
 771             }
 772
 773             cfgEntData->rbCb = cfgTmpData->cellCb->rbCb[cfgToValidate->rbId];
 774             if (!cfgEntData->rbCb)
 775             {
 776                /* something is wrong the rbId for this cell does not exist */
 777                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
 778                RETVALUE(RFAILED);
 779             }
 780             RETVALUE(ROK);
 781          }
 782          else
 783          {
 784             kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
 785             if(!cfgTmpData->ueCb)
 786             {
 787                RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
 788                      "UeId [%d]: UeCb not found",
 789                      cfgTmpData->ueId);
 790                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
 791                RETVALUE(RFAILED);
 792             }
 793
 794             /* Get rbCb */
 795             KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
 796                                       cfgToValidate->rbType,
 797                                       cfgTmpData->ueCb,
 798                                       cfgEntData->rbCb);
 799             if ( cfgEntData->rbCb == NULLP)
 800             {
 801                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
 802                RETVALUE(RFAILED);
 803             }
 804             RETVALUE(ROK);
 805          }
 806          break;
 807       }
 808    }
 809
 810    if(cfgToValidate->cfgType == CKW_CFG_MODIFY)
 811    {
 812       if(cfgToValidate->entMode != cfgEntData->rbCb->mode)
 813       {
 814          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_MODE_MIS;
 815          RETVALUE(RFAILED);
 816       }
 817
 818       if(cfgToValidate->m.umInfo.ul.snLen != cfgEntData->rbCb->m.umUl.snLen)
 819       {
 820          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_SNLEN_MIS;
 821          RETVALUE(RFAILED);
 822       }
 823    }
 824    RETVALUE(ROK);
 825 }
 826
 827 \f
 828 /**
 829  * @brief
 830  *    This primitive roll back the RB Configuration
 831  *
 832  * @param [in]  gCb      -  RLC Instance Control Block
 833  * @param [in]  ueId     -  UE Identifier
 834  * @param [in]  cfg   -     Configuration entity.
 835  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 836  *
 837  * @return  S16
 838  *    -# ROK
 839  *    -# RFAILED
 840  */
 841 #ifdef ANSI
 842 PUBLIC S16 kwCfgRollBackUlRb
 843 (
 844 KwCb             *gCb,
 845 CmLteRnti        ueId,
 846 CkwEntCfgInfo    *cfg,
 847 KwUlEntTmpData   *cfgEntData
 848 )
 849 #else
 850 PUBLIC S16 kwCfgRollBackUlRb(gCb, cfg, cfgEntData)
 851 (
 852 KwCb             *gCb;
 853 CmLteRnti        ueId;
 854 CkwEntCfgInfo    *cfg;
 855 KwUlEntTmpData   *cfgEntData;
 856 )
 857 #endif
 858 {
 859    TRC3(kwCfgRollBackUlRb)
 860
 861    if(CKW_CFG_ADD == cfg->cfgType)
 862    {
 863       if(CM_LTE_MODE_UM == cfg->entMode)
 864       {
 865          KW_FREE(gCb,
 866                cfgEntData->rbCb->m.umUl.recBuf,
 867                (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(KwUmRecBuf*));
 868       }
 869       else if(CM_LTE_MODE_AM == cfg->entMode)
 870       {
 871 #ifndef LTE_TDD
 872       KW_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
 873 #endif
 874       }
 875       KW_FREE(gCb,cfgEntData->rbCb, sizeof(KwUlRbCb));
 876    }
 877
 878    RETVALUE(ROK);
 879 }
 880
 881 \f
 882 /**
 883  * @brief
 884  *    This primitive apply RB Configuration.
 885  *
 886  * @param [in] gCb      -  RLC Instance Control Block
 887  * @param [in] cfgToAply  -   Configuration to be applied
 888  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 889  * @param [out] cfgTmpData    -  Configuration Temporary Data
 890  *
 891  * @return  S16
 892  *    -# ROK
 893  *    -# RFAILED
 894  */
 895 #ifdef ANSI
 896 PUBLIC Void kwCfgApplyUlRb
 897 (
 898 KwCb             *gCb,
 899 CkwEntCfgInfo    *cfgToAply,
 900 KwUlEntTmpData   *cfgEntData,
 901 KwUlCfgTmpData   *cfgTmpData
 902 )
 903 #else
 904 PUBLIC Void kwCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
 905 (
 906 KwCb             *gCb;
 907 CkwEntCfgInfo    *cfgToAply;
 908 KwUlEntTmpData   *cfgEntData;
 909 KwUlCfgTmpData   *cfgTmpData;
 910 )
 911 #endif
 912 {
 913    TRC3(kwCfgApplyUlRb)
 914
 915    switch(cfgToAply->cfgType)
 916    {
 917       case CKW_CFG_ADD:
 918       {
 919          /* copy the RB Cb into UeCb */
 920          cfgEntData->rbCb->rlcId.rbId = cfgToAply->rbId;
 921          if (cfgTmpData->ueId == 0)
 922          {
 923             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 924             cfgTmpData->cellCb->lCh[cfgToAply->lCh[0].lChId -1].ulRbCb = cfgEntData->rbCb;
 925          }
 926          else
 927          {
 928             if(cfgToAply->rbType == CM_LTE_SRB)
 929             {
 930                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 931             }
 932             else
 933             {
 934                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 935             }
 936          }
 937
 938          KW_LMM_RB_STS_INC(gCb);
 939
 940          cfgEntData->rbCb->rlcId.cellId = cfgTmpData->cellId;
 941          cfgEntData->rbCb->rlcId.ueId   = cfgTmpData->ueId;
 942          cfgEntData->rbCb->rlcId.rbType = cfgToAply->rbType;
 943          cfgEntData->rbCb->inst         = gCb->init.inst;
 944
 945          /* Fill RB CB */
 946          kwCfgFillUlRbCb(gCb,
 947                          cfgEntData->rbCb,
 948                          cfgTmpData->ueCb,
 949                          cfgToAply);
 950
 951 #ifdef LTE_L2_MEAS
 952          cfgEntData->rbCb->qci = cfgToAply->qci;
 953          cfgEntData->rbCb->ueCb =  cfgTmpData->ueCb;
 954          if (cfgToAply->lCh[1].type == CM_LTE_LCH_DTCH)
 955          {
 956             /* ccpu00129778 */
 957             kwAddToUlL2Meas(gCb, cfgEntData->rbCb,
 958                   cfgTmpData->cellId,cfgTmpData->ueId);
 959          }
 960 #endif /* LTE_L2_MEAS */
 961          break;
 962       }
 963       case CKW_CFG_MODIFY:
 964       {
 965          if(cfgTmpData->ueId == 0)
 966          {
 967             kwCfgUpdateUlRb(gCb,
 968                             cfgEntData->rbCb,
 969                             (void *)cfgTmpData->cellCb,
 970                             cfgToAply);
 971          }
 972          else
 973          {
 974             kwCfgUpdateUlRb(gCb,
 975                             cfgEntData->rbCb,
 976                             (void*)cfgTmpData->ueCb,
 977                             cfgToAply);
 978          }
 979          break;
 980       }
 981       case CKW_CFG_DELETE:
 982       {
 983          if (cfgTmpData->ueId == 0)
 984          {
 985             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = NULLP;
 986             cfgTmpData->cellCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb =
 987                                                                         NULLP;
 988          }
 989          else
 990          {
 991             cfgTmpData->ueCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb =
 992                                                                        NULLP;
 993
 994             /* Free the Buffers of RbCb */
 995             if( CM_LTE_MODE_UM == cfgEntData->rbCb->mode )
 996             {
 997                kwUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
 998             }
 999             else if(CM_LTE_MODE_AM == cfgEntData->rbCb->mode)
1000             {
1001                kwAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
1002             }
1003
1004             /* Assign NULLP to rbCb in rbCbLst */
1005             if ( cfgToAply->rbType == CM_LTE_SRB )
1006             {
1007                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = NULLP;
1008             }
1009             else
1010             {
1011                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = NULLP;
1012             }
1013          }
1014          /* Delete RbCb  */
1015          KW_FREE(gCb,cfgEntData->rbCb, sizeof(KwUlRbCb));
1016
1017          KW_LMM_RB_STS_DEC(gCb);
1018          break;
1019       }
1020    }
1021    RETVOID;
1022 }
1023
1024 \f
1025 /**
1026  * @brief
1027  *    This primitive validates uplink Delete UE request
1028  *    for RB creation.
1029  *
1030  * @param [in]  gCb      -  RLC Instance Control Block
1031  * @param [in]  cfgToValidate   -  Entity Configuration to be validated.
1032  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
1033  * @param [out] cfgTmpData    -  Configuration Temporary Data
1034  *
1035  * @return  S16
1036  *    -# ROK
1037  *    -# RFAILED
1038  */
1039 #ifdef ANSI
1040 PUBLIC S16 kwCfgValidateDelUlUe
1041 (
1042 KwCb             *gCb,
1043 CkwEntCfgInfo    *cfgToValidate,
1044 KwUlEntTmpData   *cfgEntData,
1045 KwUlCfgTmpData   *cfgTmpData
1046 )
1047 #else
1048 PUBLIC S16 kwCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
1049 KwCb             *gCb;
1050 CkwEntCfgInfo    *cfgToValidate;
1051 KwUlEntTmpData   *cfgEntData;
1052 KwUlCfgTmpData   *cfgTmpData;
1053 #endif
1054 {
1055    TRC3(kwCfgValidateDelUlUe)
1056
1057    RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
1058              "cellId(%d), cfgType(%d)",
1059               cfgTmpData->cellId,cfgToValidate->cfgType);
1060
1061    /* Check for ueId is present or not */
1062    if ( cfgTmpData->ueId == 0 )
1063    {
1064       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;;
1065       RLOG_ARG1(L_ERROR,DBG_UEID,cfgTmpData->ueId,
1066             "UeId is 0 for CELLID;%d",
1067             cfgTmpData->cellId);
1068       RETVALUE(RFAILED);
1069    }
1070
1071    /* Fetch Ue Cb */
1072    if(ROK != kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
1073    {
1074       RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
1075             "UeId [%d]: UeCb not found",
1076             cfgTmpData->ueId);
1077       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;;
1078       RETVALUE(RFAILED);
1079    }
1080    RETVALUE(ROK);
1081 }
1082
1083 \f
1084 /**
1085  * @brief
1086  *    This primitive apply Uplink Delete Ue request
1087  *
1088  * @param [in] gCb      -  RLC Instance Control Block
1089  * @param [in] cfgTmpData    -  Configuration Temporary Data
1090  *
1091  * @return  S16
1092  *    -# ROK
1093  */
1094 #ifdef ANSI
1095 PUBLIC Void kwCfgApplyDelUlUe
1096 (
1097 KwCb             *gCb,
1098 KwUlCfgTmpData   *cfgTmpData
1099 )
1100 #else
1101 PUBLIC Void kwCfgApplyDelUlUe(gCb, cfgTmpData)
1102 (
1103 KwCb             *gCb;
1104 KwUlCfgTmpData   *cfgTmpData;
1105 )
1106 #endif
1107 {
1108    TRC3(kwCfgApplyDelUlUe)
1109
1110 #ifdef LTE_L2_MEAS
1111    kwDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
1112 #endif
1113    kwDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
1114    RETVOID;
1115 }
1116
1117 \f
1118 /**
1119  * @brief
1120  *    This primitive validates uplink Delete UE request
1121  *    for RB creation.
1122  *
1123  * @param [in] gCb      -  RLC Instance Control Block
1124  * @param [in] ueId     -  UE Identifier
1125  * @param [in] cfgToValidate   -  Entity Configuration to be done.
1126  * @param [in] cfgEntData    -  Configuration Temporary Data Entity
1127  * @param [in] cfgTmpData    -  Configuration Temporary Data
1128  *
1129  * @return  S16
1130  *    -# ROK
1131  *    -# RFAILED
1132  */
1133 #ifdef ANSI
1134 PUBLIC S16 kwCfgValidateDelUlCell
1135 (
1136 KwCb             *gCb,
1137 CmLteCellId      cellId,
1138 CkwEntCfgInfo    *cfgToValidate,
1139 KwUlEntTmpData   *cfgEntData,
1140 KwUlCfgTmpData   *cfgTmpData
1141 )
1142 #else
1143 PUBLIC S16 kwCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
1144 KwCb             *gCb;
1145 CmLteCellId      cellId;
1146 CkwEntCfgInfo    *cfgToValidate;
1147 KwUlEntTmpData   *cfgEntData;
1148 KwUlCfgTmpData   *cfgTmpData;
1149 #endif
1150 {
1151    TRC3(kwCfgValidateDelUlCell)
1152
1153    RLOG_ARG1(L_DEBUG,DBG_CELLID,cellId ,"cfgType(%d)",
1154               cfgToValidate->cfgType);
1155
1156    cfgTmpData->cellCb = NULLP;
1157
1158    /* Check for cellId is present or not */
1159    if ( cellId == 0 )
1160    {
1161       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;;
1162       RLOG_ARG0(L_ERROR,DBG_CELLID,cellId , "CellId is 0");
1163       RETVALUE(RFAILED);
1164    }
1165
1166    /* Fetch Cell Cb */
1167    kwDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
1168    if (!cfgTmpData->cellCb)
1169    {
1170       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;;
1171       RLOG_ARG0(L_ERROR, DBG_CELLID,cellId, "CellCb not found");
1172       RETVALUE(RFAILED);
1173    }
1174    RETVALUE(ROK);
1175 }
1176
1177 \f
1178 /**
1179  * @brief
1180  *    This primitive apply Uplink Delete Ue request
1181  *
1182  * @param [in] gCb      -  RLC Instance Control Block
1183  * @param [in] cfgEntData  - Temporary Data maintained for a transaction
1184  *
1185  * @return  S16
1186  *    -# ROK
1187  */
1188 #ifdef ANSI
1189 PUBLIC Void kwCfgApplyDelUlCell
1190 (
1191 KwCb             *gCb,
1192 KwUlCfgTmpData   *cfgInfo
1193 )
1194 #else
1195 PUBLIC Void kwCfgApplyDelUlCell(gCb, cfgEntData)
1196 (
1197 KwCb             *gCb;
1198 KwUlCfgTmpData   *cfgInfo;
1199 )
1200 #endif
1201 {
1202    TRC3(kwCfgApplyDelUlCell)
1203
1204    kwDbmDelUlCellCb(gCb,cfgInfo->cellCb);
1205    RETVOID;
1206 }
1207 \f
1208 /**
1209  * @brief
1210  *    This primitive validates reestablishment of RB.
1211  *
1212  * @param [in]   gCb      -  RLC Instance Control Block
1213  * @param [in]   ueId     -  UE Identifier
1214  * @param [in]   cellId   -  CELL Identifier
1215  * @param [in]   cfgToValidate   -  Entity Configuration to be done.
1216  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
1217  *
1218  * @return  S16
1219  *    -# ROK
1220  *    -# RFAILED
1221  */
1222 #ifdef ANSI
1223 PUBLIC S16 kwCfgValidateReEstRb
1224 (
1225 KwCb             *gCb,
1226 CmLteRnti        ueId,
1227 CmLteCellId      cellId,
1228 CkwEntCfgInfo    *cfgToValidate,
1229 KwUlEntTmpData   *cfgEntData
1230 )
1231 #else
1232 PUBLIC S16 kwCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
1233 KwCb             *gCb;
1234 CmLteRnti        ueId;
1235 CmLteCellId      cellId;
1236 CkwEntCfgInfo    *cfgToValidate;
1237 KwUlEntTmpData   *cfgEntData;
1238 #endif
1239 {
1240    CmLteRlcId   rlcId;   /* RLC Identifier */
1241    TRC3(kwCfgValidateReEstRb)
1242
1243    RLOG_ARG2(L_DEBUG, DBG_UEID,ueId,
1244          "cellId(%d) RBID:%d",
1245          cellId,
1246          cfgToValidate->rbId);
1247
1248    /* Get rlcId */
1249    rlcId.ueId = ueId;
1250    rlcId.cellId = cellId;
1251    rlcId.rbId = cfgToValidate->rbId;
1252    rlcId.rbType = cfgToValidate->rbType;
1253
1254    kwDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
1255    if (cfgEntData->rbCb == NULLP)
1256    {
1257       RLOG_ARG2(L_WARNING, DBG_UEID,ueId,
1258             "CellId [%u]: rbId [%d] not found",
1259              cellId,
1260              cfgToValidate->rbId);
1261       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_UNKWN;
1262       RETVALUE(RFAILED);
1263    }
1264
1265    RETVALUE(ROK);
1266 }
1267
1268
1269 \f
1270 /**
1271  * @brief
1272  *    This primitive apply reestablishment of RB.
1273  *
1274  * @param [in] gCb        -  RLC Instance Control Block
1275  * @param [in] ueId       -  UE Identifier
1276  * @param [in] cellId     -  CELL Identifier
1277  * @param [in] sndReEstInd  -  ReEstablish Indication Flag
1278  * @param [in] cfgEntData -  Configuration Temporary Data Entity
1279  *
1280  * @return  S16
1281  *    -# ROK
1282  */
1283 #ifdef ANSI
1284 PUBLIC Void kwCfgApplyReEstUlRb
1285 (
1286 KwCb             *gCb,
1287 CmLteRnti        ueId,
1288 CmLteCellId      cellId,
1289 Bool             sndReEstInd,
1290 KwUlEntTmpData   *cfgEntData
1291 )
1292 #else
1293 PUBLIC Void kwCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
1294 (
1295 KwCb             *gCb;
1296 CmLteRnti        ueId;
1297 CmLteCellId      cellId;
1298 Bool             sndReEstInd;
1299 KwUlEntTmpData   *cfgEntData;
1300 )
1301 #endif
1302 {
1303    CmLteRlcId   rlcId;   /* RLC Identifier */
1304    TRC3(kwCfgApplyReEstUlRb)
1305
1306    rlcId.ueId = ueId;
1307    rlcId.cellId = cellId;
1308    rlcId.rbId = cfgEntData->entUlCfgCfm.rbId;
1309    rlcId.rbType = cfgEntData->entUlCfgCfm.rbType;
1310    cfgEntData->rbCb->rlcId.ueId = ueId;
1311    switch (cfgEntData->rbCb->mode)
1312    {
1313       case CM_LTE_MODE_TM:
1314          {
1315             kwTmmUlReEstablish(gCb,cfgEntData->rbCb);
1316             break;
1317          }
1318
1319       case CM_LTE_MODE_UM:
1320          {
1321             kwUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
1322             break;
1323          }
1324
1325       case CM_LTE_MODE_AM:
1326          {
1327             kwAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
1328             break;
1329          }
1330    }
1331    RETVOID;
1332 }
1333 \f
1334 /**
1335  * @brief
1336  *    This primitive validates reestablishment of RB.
1337  *
1338  * @param [in] gCb        -  RLC Instance Control Block
1339  * @param [in] ueInfo     -  UE Identifier
1340  * @param [in] newUeInfo  -  CELL Identifier
1341  * @param [in] cfgTmpData -  Configuration Temporary Data
1342  *
1343  * @return  S16
1344  *    -# ROK
1345  *    -# RFAILED
1346  */
1347 #ifdef ANSI
1348 PUBLIC S16 kwCfgValidateUeIdChng
1349 (
1350 KwCb             *gCb,
1351 CkwUeInfo        *ueInfo,
1352 CkwUeInfo        *newUeInfo,
1353 KwUlCfgTmpData   *cfgTmpData
1354 )
1355 #else
1356 PUBLIC S16 kwCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
1357 KwCb             *gCb;
1358 CkwUeInfo        *ueInfo;
1359 CkwUeInfo        *newUeInfo;
1360 KwUlCfgTmpData   *cfgTmpData;
1361 #endif
1362 {
1363    KwUlUeCb   *ueCb;
1364    TRC3(kwCfgValidateUeIdChng)
1365
1366 #define CFM_STATUS  cfgTmpData->cfgEntData[0].entUlCfgCfm.status
1367    if ( (ueInfo->ueId == newUeInfo->ueId) &&
1368         (ueInfo->cellId == newUeInfo->cellId))
1369    {
1370       CFM_STATUS.reason = CKW_CFG_REAS_SAME_UEID;
1371       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1372       RETVALUE(RFAILED);
1373    }
1374
1375    if(ROK == kwDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
1376    {
1377       RLOG_ARG1(L_ERROR, DBG_CELLID, newUeInfo->cellId,
1378             "NewUeId[%d]:ueCb already exists",
1379              newUeInfo->ueId);
1380       CFM_STATUS.reason = CKW_CFG_REAS_UE_EXISTS;
1381       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1382       RETVALUE(RFAILED);
1383    }
1384
1385    if(ROK != kwDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
1386                               &cfgTmpData->ueCb))
1387    {
1388       RLOG_ARG1(L_ERROR,DBG_CELLID, ueInfo->cellId,
1389             "UeId [%d]: UeCb not found",
1390             ueInfo->ueId);
1391       CFM_STATUS.reason = CKW_CFG_REAS_UE_UNKWN;
1392       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1393       RETVALUE(RFAILED);
1394    }
1395 #undef CFM_STATUS
1396    RETVALUE(ROK);
1397 }
1398
1399
1400 \f
1401 /**
1402  * @brief
1403  *    This primitive apply reestablishment of RB.
1404  *
1405  * @param [in] gCb        -  RLC Instance Control Block
1406  * @param [in] ueInfo     -  UE Identifier
1407  * @param [in] newUeInfo  -  CELL Identifier
1408  * @param [in] cfgTmpData -  Configuration Temporary Data
1409  *
1410  * @return  S16
1411  *    -# ROK
1412  */
1413 #ifdef ANSI
1414 PUBLIC Void kwCfgApplyUlUeIdChng
1415 (
1416 KwCb             *gCb,
1417 CkwUeInfo        *ueInfo,
1418 CkwUeInfo        *newUeInfo,
1419 KwUlCfgTmpData   *cfgTmpData
1420 )
1421 #else
1422 PUBLIC Void kwCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
1423 (
1424 KwCb             *gCb;
1425 CkwUeInfo        *ueInfo,
1426 CkwUeInfo        *newUeInfo,
1427 KwUlCfgTmpData   *cfgTmpData;
1428 )
1429 #endif
1430 {
1431    TRC3(kwCfgApplyUlUeIdChng)
1432
1433 #ifdef LTE_L2_MEAS
1434    kwHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
1435 #endif
1436    cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) cfgTmpData->ueCb);
1437    /* update the hash key with new values */
1438    cfgTmpData->ueCb->ueId = newUeInfo->ueId;
1439    cfgTmpData->ueCb->cellId =newUeInfo->cellId;
1440    if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp),
1441                               (PTR)cfgTmpData->ueCb,
1442                               (U8 *)&(cfgTmpData->ueCb->ueId),
1443                               (U16) sizeof(CmLteRnti)))
1444
1445    {
1446       RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId,
1447             "UeId[%u] HashList Insertion Failed",
1448             newUeInfo->ueId);
1449    }
1450
1451    RETVOID;
1452 }
1453 /********************************************************************30**
1454
1455          End of file
1456 **********************************************************************/