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                     -- rlcCfgValdtEntCfg
  28                     -- rlcCfgFillRbCb
  29                     -- rlcCfgRbInit
  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 S16 rlcValidateRbCfgParams (RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
  67                                   RlcEntCfgInfo *cfgToValidate, CmStatus *status);
  68 #define RLC_MODULE RLC_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 rlcHdlMeasUlUeIdChg(RlcCb *gCb, uint8_t cellId,uint8_t oldUeId, uint8_t newUeId)
  83 {
  84    RlcL2MeasCb    *measCb    = NULLP;
  85    uint16_t       cntr;
  86    uint16_t       ueIdx = 0;
  87
  88    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
  89    {
  90       measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[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    return 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 rlcDelFrmUlL2Meas(RlcCb *gCb, uint8_t cellId,uint8_t ueId)
 121 {
 122    RlcL2MeasCb    *measCb    = NULLP;
 123    uint16_t       cntr;
 124    uint16_t       ueIdx = 0;
 125
 126    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
 127    {
 128       measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[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          uint32_t myIdx =0;
 151          S16                  ret;           /* Return value */
 152             RlcUlUeCb             *ueCb = NULL;
 153
 154             for (myIdx = 0; myIdx < measCb->val.ipThMeas.numUes; myIdx++)
 155             {
 156                ueCb = NULL;
 157                ret = rlcDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb);
 158             }
 159          }
 160
 161       }
 162    }
 163
 164    return ROK;
 165 }
 166
 167
 168 PRIVATE S16 rlcAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *rlcRbCb,uint8_t cellId,uint8_t ueId)
 169 {
 170    RlcL2MeasCb    *measCb    = NULLP;
 171    uint16_t       cntr;
 172    uint16_t       cntr1;
 173    uint16_t       ueIdx = 0;
 174    uint16_t       qciIdx = 0;
 175    uint16_t       *numQci;
 176    #ifndef XEON_SPECIFIC_CHANGES
 177    uint8_t        freeIdx = gCb->genCfg.maxUe;
 178    #else
 179    uint16_t       freeIdx = LKW_MAX_UE;
 180    #endif
 181
 182    for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
 183    {
 184       measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[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] != rlcRbCb->qci)
 193             {
 194                measCb->val.nonIpThMeas.qci[cntr1]  = rlcRbCb->qci;
 195                gCb->u.ulCb->rlcL2Cb.measOn[rlcRbCb->qci] |=measCb->measType;
 196                break;
 197             }
 198          }
 199       }
 200
 201       if(((rlcRbCb->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((rlcRbCb->mode == CM_LTE_MODE_UM) &&
 207                   (rlcRbCb->dir & RLC_DIR_DL ))
 208             {
 209                if (rlcRbCb->m.um.umDl.sduQ.count)
 210                {
 211                   if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
 212                   {
 213                      rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
 214                      gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
 215                   }
 216                }
 217             }
 218             else if (rlcRbCb->mode == CM_LTE_MODE_AM)
 219             {
 220                if ((rlcRbCb->m.am.amDl.cntrlBo) ||
 221                      (rlcRbCb->m.am.amDl.retxBo)  ||
 222                      (rlcRbCb->m.am.amDl.bo))
 223                {
 224                   if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
 225                   {
 226                      rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
 227                      gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->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                return 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             memset(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(RlcL2Cntr) *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] == rlcRbCb->qci)
 276             {
 277                break;
 278             }
 279          }
 280
 281          if (qciIdx == *numQci)
 282          {
 283             measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = rlcRbCb->qci;
 284             (*numQci)++;
 285          }
 286 \f
 287          rlcUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[rlcRbCb->qci],
 288                &rlcRbCb->rbL2Cb, measCb->measType);
 289       }
 290       rlcRbCb->rbL2Cb.measOn |= measCb->measType;
 291    }
 292    return (ROK);
 293 }/*rlcAddToDlL2Meas*/
 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 rlcCfgFillUlRbCb
 311 (
 312 RlcCb            *gCb,
 313 RlcUlRbCb        *rbCb,
 314 RlcUlUeCb        *ueCb,
 315 RlcEntCfgInfo   *entCfg
 316 )
 317 #else
 318 PRIVATE S16 rlcCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg)
 319 RlcCb            *gCb;
 320 RlcUlRbCb        *rbCb;
 321 RlcUlUeCb        *ueCb;
 322 RlcEntCfgInfo   *entCfg;
 323 #endif
 324 {
 325
 326    RLOG_ARG3(L_DEBUG,DBG_UEID,rbCb->rlcId.ueId,
 327                 "rlcCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
 328                 rbCb->rlcId.cellId,
 329                 entCfg->rbId,
 330                 entCfg->rbType);
 331
 332    /* Initialize according to entMode */
 333    switch (entCfg->entMode)
 334    {
 335       case CM_LTE_MODE_TM:
 336       {
 337          rbCb->lch.lChId  = entCfg->lCh[0].lChId;
 338          rbCb->lch.lChType = entCfg->lCh[0].type;
 339          rbCb->dir = entCfg->dir;
 340          break;
 341       }
 342       case CM_LTE_MODE_UM:
 343       {
 344          rbCb->lch.lChId  = entCfg->lCh[0].lChId;
 345          rbCb->lch.lChType = entCfg->lCh[0].type;
 346
 347          rbCb->dir = entCfg->dir;
 348
 349          rbCb->m.umUl.snLen = entCfg->m.umInfo.ul.snLen;
 350
 351          /* the bitmask for SN = 10 is 0x3ff and for SN = 5 is 0x1f */
 352          rbCb->m.umUl.modBitMask = (rbCb->m.umUl.umWinSz << 1) - 1;
 353
 354          rbCb->m.umUl.reOrdTmrInt =
 355             entCfg->m.umInfo.ul.reOrdTmr;
 356          cmInitTimers(&(rbCb->m.umUl.reOrdTmr), 1);
 357          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
 358          break;
 359       }
 360       case CM_LTE_MODE_AM:
 361       {
 362          /* Down Link Information
 363           * indx = 1 as Up Link   */
 364          rbCb->lch.lChId  = entCfg->lCh[1].lChId;
 365          rbCb->lch.lChType = entCfg->lCh[1].type;
 366          rbCb->dir = RLC_DIR_BOTH;
 367
 368          rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr;
 369          rbCb->m.amUl.reOrdTmrInt = entCfg->m.amInfo.ul.reOrdTmr;
 370
 371          rbCb->m.amUl.snLen = entCfg->m.amInfo.ul.snLen; /* 5GNR */
 372
 373          if(RLC_AM_CFG_12BIT_SN_LEN == rbCb->m.amUl.snLen)
 374          {
 375             rbCb->m.amUl.snModMask = (1 << RLC_SN_LEN_12BITS) - 1; /* 5GNR */
 376          }
 377          else
 378          {
 379             rbCb->m.amUl.snModMask = (1 << RLC_SN_LEN_18BITS) - 1; /* 5GNR */
 380          }
 381
 382          cmInitTimers(&(rbCb->m.amUl.reOrdTmr), 1);
 383          cmInitTimers(&(rbCb->m.amUl.staProhTmr), 1);
 384
 385          rbCb->m.amUl.vrMr = rbCb->m.amUl.rxNext + (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen));
 386
 387          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
 388
 389          break;
 390       }
 391       default:
 392       {
 393          RLOG_ARG2(L_ERROR,DBG_UEID,rbCb->rlcId.ueId,
 394                 "INVALID RB Mode cellId(%d), rbId(%d)",
 395                 rbCb->rlcId.cellId,
 396                 entCfg->rbId);
 397          return RFAILED;
 398       }
 399    }
 400    rbCb->mode = entCfg->entMode;
 401
 402    return ROK;
 403 }
 404
 405 \f
 406 /**
 407  * @brief This primitive Initializes the RB Cb
 408  *
 409  * @param [in]    gCb      -  RLC Instance Control Block
 410  * @param [out]   rbCb     -  RB Control Block
 411  * @param [in]    ptr      -  Void pointer
 412  * @param [in]    entCfg   -  Entity Configuration
 413  *
 414  * @return  S16
 415  *    -#ROK
 416  *    -#RFAILED
 417  */
 418 #ifdef ANSI
 419 PRIVATE S16 rlcCfgUpdateUlRb
 420 (
 421 RlcCb            *gCb,
 422 RlcUlRbCb        *rbCb,
 423 void            *ptr,
 424 RlcEntCfgInfo   *entCfg
 425 )
 426 #else
 427 PRIVATE S16 rlcCfgUpdateUlRb(gCb,rbCb, ptr, entCfg)
 428 RlcCb            *gCb;
 429 RlcUlRbCb        *rbCb;
 430 void            *ptr;
 431 RlcEntCfgInfo   *entCfg;
 432 #endif
 433 {
 434
 435    switch (rbCb->mode)
 436    {
 437       case CM_LTE_MODE_TM:
 438       {
 439          RlcUlCellCb *cellCb = (RlcUlCellCb *)ptr;
 440          rbCb->dir = entCfg->dir;
 441          rbCb->lch.lChId = entCfg->lCh[0].lChId;
 442          rbCb->lch.lChType = entCfg->lCh[0].type;
 443
 444          cellCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
 445          break;
 446       }
 447       case CM_LTE_MODE_UM:
 448       {
 449          RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
 450          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
 451          rlcCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg);
 452          break;
 453       }
 454       case CM_LTE_MODE_AM:
 455       {
 456          RlcUlUeCb *ueCb = (RlcUlUeCb *)ptr;
 457
 458          ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP;
 459          ueCb->lCh[entCfg->lCh[1].lChId - 1].ulRbCb = rbCb;
 460          /* Up Link */
 461          rbCb->lch.lChId = entCfg->lCh[1].lChId;
 462          rbCb->lch.lChType = entCfg->lCh[1].type;
 463          rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr;
 464          rbCb->m.amUl.reOrdTmrInt = entCfg->m.amInfo.ul.reOrdTmr;
 465          break;
 466       }
 467    }
 468    return (CKW_CFG_REAS_NONE);
 469 }
 470
 471 \f
 472 /**
 473  * @brief
 474  *    This primitive validates uplink Add RB Configuration and reserve memory
 475  *    for RB creation.
 476  *
 477  * @param [in]  gCb      -  RLC Instance Control Block
 478  * @param [in]  ueId     -  UE Identifier
 479  * @param [in]  cellId   -  CELL Identifier
 480  * @param [in]  cfgToValidate   -  Entity Configuration needs to be validated.
 481  * @param [out] status  -  status of configuration
 482  *
 483  * @return  S16
 484  *    -# ROK
 485  *    -# RFAILED
 486  */
 487 #ifdef ANSI
 488 S16 rlcValidateRbCfgParams
 489 (
 490 RlcCb            *gCb,
 491 CmLteRnti       ueId,
 492 CmLteCellId     cellId,
 493 RlcEntCfgInfo   *cfgToValidate,
 494 CmStatus        *status
 495 )
 496 #else
 497 S16 rlcValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status)
 498 RlcCb            *gCb;
 499 CmLteRnti       ueId;
 500 CmLteCellId     cellId;
 501 RlcEntCfgInfo   *cfgToValidate;
 502 CmStatus        *status;
 503 #endif
 504 {
 505    if (cellId == 0)
 506    {
 507       status->reason = CKW_CFG_REAS_CELL_UNKWN;
 508       return  (RFAILED);
 509    }
 510    if ((cfgToValidate->rguSapId >= gCb->genCfg.maxRguSaps) || (cfgToValidate->rguSapId < 0))
 511    {
 512       RLCDBGP_ERROR(gCb, "rlcValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
 513             ueId, cellId, cfgToValidate->rguSapId);
 514       status->reason = CKW_CFG_REAS_INVALID_RGUSAP;
 515       return RFAILED;
 516    }
 517
 518    if((CKW_CFG_ADD == cfgToValidate->cfgType) ||
 519       (CKW_CFG_MODIFY == cfgToValidate->cfgType))
 520    {
 521       /* Validate LChId for UM and AM modes */
 522       if ((cfgToValidate->lCh[0].lChId <= 0) ||
 523            ((cfgToValidate->entMode == CM_LTE_MODE_AM) &&
 524              (cfgToValidate->lCh[1].lChId <= 0)))
 525       {
 526          status->reason = CKW_CFG_REAS_INVALID_LCHID;
 527          return RFAILED;
 528       }
 529       if((cfgToValidate->entMode == CM_LTE_MODE_UM) &&
 530          (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_5BIT_SN_LEN) &&
 531          (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_10BIT_SN_LEN))
 532       {
 533          RLOG_ARG2(L_ERROR,DBG_UEID,ueId,
 534                "CellId[%u]:UM Mode RB[%d],Invalid SN Len[%d]",
 535                cfgToValidate->rbId,
 536                cfgToValidate->m.umInfo.ul.snLen);
 537          status->reason = CKW_CFG_REAS_INVALID_SNLEN;
 538          return RFAILED;
 539       }
 540       /* Process Adding new RB */
 541       if (ueId == 0)
 542       {
 543          if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
 544          {
 545             status->reason = CKW_CFG_REAS_RB_UNKWN;
 546             return RFAILED;
 547          }
 548
 549          if ((cfgToValidate->lCh[0].type != CM_LTE_LCH_CCCH) &&
 550                (cfgToValidate->entMode != CM_LTE_MODE_TM))
 551          {
 552             status->reason= (cfgToValidate->entMode != CM_LTE_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS:
 553                CKW_CFG_REAS_LCHTYPE_MIS;
 554             return RFAILED;
 555          }
 556       }
 557       else
 558       {
 559          if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
 560          {
 561             status->reason = CKW_CFG_REAS_RB_UNKWN;
 562             return RFAILED;
 563          }
 564
 565          if(cfgToValidate->entMode == CM_LTE_MODE_TM)
 566          {
 567             status->reason = CKW_CFG_REAS_LCHTYPE_MIS;
 568             return RFAILED;
 569          }
 570          if (!(((cfgToValidate->lCh[0].type == CM_LTE_LCH_DCCH) &&
 571                (cfgToValidate->entMode != CM_LTE_MODE_UM))||
 572                (cfgToValidate->lCh[0].type == CM_LTE_LCH_DTCH)) )
 573          {
 574             status->reason = CKW_CFG_REAS_RB_MODE_MIS;
 575             return RFAILED;
 576          }
 577       }
 578    }
 579    else /* cfgType is CKW_CFG_DELETE */
 580    {
 581       if (ueId == 0)
 582       {
 583          if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
 584          {
 585             status->reason = CKW_CFG_REAS_RB_UNKWN;
 586             return RFAILED;
 587          }
 588
 589       }
 590       else
 591       {
 592          if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
 593          {
 594             status->reason = CKW_CFG_REAS_RB_UNKWN;
 595             return RFAILED;
 596          }
 597       }
 598    }
 599    return ROK;
 600 }
 601
 602 \f
 603 /**
 604  * @brief
 605  *    This primitive validates uplink Add RB Configuration and reserve memory
 606  *    for RB creation.
 607  *
 608  * @param [in]  gCb      -  RLC Instance Control Block
 609  * @param [in]  cfgToValidate   -  Entity Configuration needs to be validated.
 610  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 611  * @param [out] cfgTmpData    -  Configuration Temporary Data
 612  *
 613  * @return  S16
 614  *    -# ROK
 615  *    -# RFAILED
 616  */
 617 #ifdef ANSI
 618 S16 rlcCfgValidateUlRb
 619 (
 620 RlcCb             *gCb,
 621 RlcEntCfgInfo    *cfgToValidate,
 622 RlcUlEntTmpData   *cfgEntData,
 623 RlcUlCfgTmpData   *cfgTmpData
 624 )
 625 #else
 626 S16 rlcCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
 627 RlcCb             *gCb;
 628 RlcEntCfgInfo    *cfgToValidate;
 629 RlcUlEntTmpData   *cfgEntData;
 630 RlcUlCfgTmpData   *cfgTmpData;
 631 #endif
 632 {
 633
 634    RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
 635                "cellId(%d), cfgType(%d)",
 636                 cfgTmpData->cellId,
 637                 cfgToValidate->cfgType);
 638
 639    if(ROK != rlcValidateRbCfgParams(gCb,
 640                                    cfgTmpData->ueId,
 641                                    cfgTmpData->cellId,
 642                                    cfgToValidate,
 643                                    &cfgEntData->entUlCfgCfm.status))
 644    {
 645       return RFAILED;
 646    }
 647
 648    cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_NONE;
 649    switch(cfgToValidate->cfgType)
 650    {
 651       case CKW_CFG_ADD:
 652       {
 653          if (cfgTmpData->ueId == 0)
 654          {
 655             /* Cell Cb is added if it not present , it is not roll backed if the
 656              * configuration fails */
 657             rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
 658             if(!cfgTmpData->cellCb)
 659             {
 660                /* cell cb does not exist we need to create a new one */
 661                RLC_ALLOC(gCb,cfgTmpData->cellCb, sizeof(RlcUlCellCb));
 662                if(!cfgTmpData->cellCb)
 663                {
 664                   RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId,
 665                         "Memory allocation failure CELLID:%d",
 666                         cfgTmpData->cellId);
 667                   cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL;
 668                   return RFAILED;
 669                }
 670                rlcDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
 671             }
 672             else
 673             {
 674                if (( cfgTmpData->cellCb->rbCb[cfgToValidate->rbId] != NULLP))
 675                {
 676                   cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_PRSNT;
 677                   return RFAILED;
 678                }
 679             }
 680
 681             RLC_ALLOC(gCb,cfgEntData->rbCb, sizeof (RlcUlRbCb));
 682             if (!cfgEntData->rbCb)
 683             {
 684                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
 685                return RFAILED;
 686             }
 687          }
 688          else
 689          {
 690             /* Ue Cb is added if it not present , it is not roll backed if the
 691              * configuration fails */
 692             rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
 693             if(!cfgTmpData->ueCb)
 694             {
 695                RLC_ALLOC(gCb,cfgTmpData->ueCb, sizeof(RlcUlUeCb));
 696                if(!cfgTmpData->ueCb)
 697                {
 698                   RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId,
 699                         "Memory allocation failure CELLID:%d",
 700                         cfgTmpData->cellId);
 701                   cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL;
 702                   return RFAILED;
 703                }
 704                rlcDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
 705             }
 706             else
 707             {
 708                RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
 709                      cfgToValidate->rbType,
 710                      cfgTmpData->ueCb,
 711                      cfgEntData->rbCb);
 712                if(cfgEntData->rbCb != NULLP)
 713                {
 714                   cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_PRSNT;
 715                   return RFAILED;
 716                }
 717             }
 718             RLC_ALLOC(gCb,cfgEntData->rbCb, sizeof (RlcUlRbCb));
 719             if (!cfgEntData->rbCb)
 720             {
 721                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL;
 722                return RFAILED;
 723             }
 724          }
 725          /*Allocating the memory for receive buffer */
 726          if(CM_LTE_MODE_UM == cfgToValidate->entMode)
 727          {
 728             uint16_t winLen;
 729
 730
 731             cfgEntData->rbCb->m.umUl.umWinSz = RLC_POWER(2,
 732                   ((cfgToValidate->m.umInfo.ul.snLen *5)-1));
 733             winLen =  cfgEntData->rbCb->m.umUl.umWinSz << 1;
 734             RLC_ALLOC(gCb,
 735                      cfgEntData->rbCb->m.umUl.recBuf,
 736                      (winLen * sizeof(RlcUmRecBuf*)));
 737          }
 738          else if(CM_LTE_MODE_AM == cfgToValidate->entMode)
 739          {
 740 #ifndef LTE_TDD
 741              uint32_t hashIndex;
 742               RLC_ALLOC(gCb,
 743                     cfgEntData->rbCb->m.amUl.recBufLst,
 744                     (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
 745               for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++)
 746               {
 747                   cmLListInit(&(cfgEntData->rbCb->m.amUl.recBufLst[hashIndex]));
 748               }
 749 #endif
 750          }
 751          break;
 752       }
 753       case CKW_CFG_MODIFY:
 754       case CKW_CFG_DELETE:
 755       {
 756          if (cfgTmpData->ueId == 0)
 757          {
 758             /* Try to get the CellCb if it already exists */
 759             rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
 760             if(!cfgTmpData->cellCb)
 761             {
 762                 RLOG_ARG1(L_ERROR, DBG_CELLID,cfgTmpData->cellId,
 763                       "CellCb not found UEID:%d",
 764                       cfgTmpData->ueId);
 765                /*how can a modify request come for a cell which does not exist*/
 766                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
 767                return RFAILED;
 768             }
 769
 770             cfgEntData->rbCb = cfgTmpData->cellCb->rbCb[cfgToValidate->rbId];
 771             if (!cfgEntData->rbCb)
 772             {
 773                /* something is wrong the rbId for this cell does not exist */
 774                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
 775                return RFAILED;
 776             }
 777             return ROK;
 778          }
 779          else
 780          {
 781             rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
 782             if(!cfgTmpData->ueCb)
 783             {
 784                RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
 785                      "UeId [%d]: UeCb not found",
 786                      cfgTmpData->ueId);
 787                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
 788                return RFAILED;
 789             }
 790
 791             /* Get rbCb */
 792             RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
 793                                       cfgToValidate->rbType,
 794                                       cfgTmpData->ueCb,
 795                                       cfgEntData->rbCb);
 796             if ( cfgEntData->rbCb == NULLP)
 797             {
 798                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
 799                return RFAILED;
 800             }
 801             return ROK;
 802          }
 803          break;
 804       }
 805    }
 806
 807    if(cfgToValidate->cfgType == CKW_CFG_MODIFY)
 808    {
 809       if(cfgToValidate->entMode != cfgEntData->rbCb->mode)
 810       {
 811          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_MODE_MIS;
 812          return RFAILED;
 813       }
 814
 815       if(cfgToValidate->m.umInfo.ul.snLen != cfgEntData->rbCb->m.umUl.snLen)
 816       {
 817          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_SNLEN_MIS;
 818          return RFAILED;
 819       }
 820    }
 821    return ROK;
 822 }
 823
 824 \f
 825 /**
 826  * @brief
 827  *    This primitive roll back the RB Configuration
 828  *
 829  * @param [in]  gCb      -  RLC Instance Control Block
 830  * @param [in]  ueId     -  UE Identifier
 831  * @param [in]  cfg   -     Configuration entity.
 832  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 833  *
 834  * @return  S16
 835  *    -# ROK
 836  *    -# RFAILED
 837  */
 838 #ifdef ANSI
 839 S16 rlcCfgRollBackUlRb
 840 (
 841 RlcCb             *gCb,
 842 CmLteRnti        ueId,
 843 RlcEntCfgInfo    *cfg,
 844 RlcUlEntTmpData   *cfgEntData
 845 )
 846 #else
 847 S16 rlcCfgRollBackUlRb(gCb, cfg, cfgEntData)
 848 (
 849 RlcCb             *gCb;
 850 CmLteRnti        ueId;
 851 RlcEntCfgInfo    *cfg;
 852 RlcUlEntTmpData   *cfgEntData;
 853 )
 854 #endif
 855 {
 856
 857    if(CKW_CFG_ADD == cfg->cfgType)
 858    {
 859       if(CM_LTE_MODE_UM == cfg->entMode)
 860       {
 861          RLC_FREE(gCb,
 862                cfgEntData->rbCb->m.umUl.recBuf,
 863                (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(RlcUmRecBuf*));
 864       }
 865       else if(CM_LTE_MODE_AM == cfg->entMode)
 866       {
 867 #ifndef LTE_TDD
 868       RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
 869 #endif
 870       }
 871       RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
 872    }
 873
 874    return ROK;
 875 }
 876
 877 \f
 878 /**
 879  * @brief
 880  *    This primitive apply RB Configuration.
 881  *
 882  * @param [in] gCb      -  RLC Instance Control Block
 883  * @param [in] cfgToAply  -   Configuration to be applied
 884  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 885  * @param [out] cfgTmpData    -  Configuration Temporary Data
 886  *
 887  * @return  S16
 888  *    -# ROK
 889  *    -# RFAILED
 890  */
 891 #ifdef ANSI
 892 Void rlcCfgApplyUlRb
 893 (
 894 RlcCb             *gCb,
 895 RlcEntCfgInfo    *cfgToAply,
 896 RlcUlEntTmpData   *cfgEntData,
 897 RlcUlCfgTmpData   *cfgTmpData
 898 )
 899 #else
 900 Void rlcCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
 901 (
 902 RlcCb             *gCb;
 903 RlcEntCfgInfo    *cfgToAply;
 904 RlcUlEntTmpData   *cfgEntData;
 905 RlcUlCfgTmpData   *cfgTmpData;
 906 )
 907 #endif
 908 {
 909
 910    switch(cfgToAply->cfgType)
 911    {
 912       case CKW_CFG_ADD:
 913       {
 914          /* copy the RB Cb into UeCb */
 915          cfgEntData->rbCb->rlcId.rbId = cfgToAply->rbId;
 916          if (cfgTmpData->ueId == 0)
 917          {
 918             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 919             cfgTmpData->cellCb->lCh[cfgToAply->lCh[0].lChId -1].ulRbCb = cfgEntData->rbCb;
 920          }
 921          else
 922          {
 923             if(cfgToAply->rbType == CM_LTE_SRB)
 924             {
 925                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 926             }
 927             else
 928             {
 929                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 930             }
 931          }
 932
 933          RLC_LMM_RB_STS_INC(gCb);
 934
 935          cfgEntData->rbCb->rlcId.cellId = cfgTmpData->cellId;
 936          cfgEntData->rbCb->rlcId.ueId   = cfgTmpData->ueId;
 937          cfgEntData->rbCb->rlcId.rbType = cfgToAply->rbType;
 938          cfgEntData->rbCb->inst         = gCb->init.inst;
 939
 940          /* Fill RB CB */
 941          rlcCfgFillUlRbCb(gCb,
 942                          cfgEntData->rbCb,
 943                          cfgTmpData->ueCb,
 944                          cfgToAply);
 945
 946 #ifdef LTE_L2_MEAS
 947          cfgEntData->rbCb->qci = cfgToAply->qci;
 948          cfgEntData->rbCb->ueCb =  cfgTmpData->ueCb;
 949          if (cfgToAply->lCh[1].type == CM_LTE_LCH_DTCH)
 950          {
 951             /* ccpu00129778 */
 952             rlcAddToUlL2Meas(gCb, cfgEntData->rbCb,
 953                   cfgTmpData->cellId,cfgTmpData->ueId);
 954          }
 955 #endif /* LTE_L2_MEAS */
 956          break;
 957       }
 958       case CKW_CFG_MODIFY:
 959       {
 960          if(cfgTmpData->ueId == 0)
 961          {
 962             rlcCfgUpdateUlRb(gCb,
 963                             cfgEntData->rbCb,
 964                             (void *)cfgTmpData->cellCb,
 965                             cfgToAply);
 966          }
 967          else
 968          {
 969             rlcCfgUpdateUlRb(gCb,
 970                             cfgEntData->rbCb,
 971                             (void*)cfgTmpData->ueCb,
 972                             cfgToAply);
 973          }
 974          break;
 975       }
 976       case CKW_CFG_DELETE:
 977       {
 978          if (cfgTmpData->ueId == 0)
 979          {
 980             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = NULLP;
 981             cfgTmpData->cellCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb =
 982                                                                         NULLP;
 983          }
 984          else
 985          {
 986             cfgTmpData->ueCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb =
 987                                                                        NULLP;
 988
 989             /* Free the Buffers of RbCb */
 990             if( CM_LTE_MODE_UM == cfgEntData->rbCb->mode )
 991             {
 992                rlcUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
 993             }
 994             else if(CM_LTE_MODE_AM == cfgEntData->rbCb->mode)
 995             {
 996                rlcAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
 997             }
 998
 999             /* Assign NULLP to rbCb in rbCbLst */
1000             if ( cfgToAply->rbType == CM_LTE_SRB )
1001             {
1002                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = NULLP;
1003             }
1004             else
1005             {
1006                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = NULLP;
1007             }
1008          }
1009          /* Delete RbCb  */
1010          RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
1011
1012          RLC_LMM_RB_STS_DEC(gCb);
1013          break;
1014       }
1015    }
1016    return;
1017 }
1018
1019 \f
1020 /**
1021  * @brief
1022  *    This primitive validates uplink Delete UE request
1023  *    for RB creation.
1024  *
1025  * @param [in]  gCb      -  RLC Instance Control Block
1026  * @param [in]  cfgToValidate   -  Entity Configuration to be validated.
1027  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
1028  * @param [out] cfgTmpData    -  Configuration Temporary Data
1029  *
1030  * @return  S16
1031  *    -# ROK
1032  *    -# RFAILED
1033  */
1034 #ifdef ANSI
1035 S16 rlcCfgValidateDelUlUe
1036 (
1037 RlcCb             *gCb,
1038 RlcEntCfgInfo    *cfgToValidate,
1039 RlcUlEntTmpData   *cfgEntData,
1040 RlcUlCfgTmpData   *cfgTmpData
1041 )
1042 #else
1043 S16 rlcCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
1044 RlcCb             *gCb;
1045 RlcEntCfgInfo    *cfgToValidate;
1046 RlcUlEntTmpData   *cfgEntData;
1047 RlcUlCfgTmpData   *cfgTmpData;
1048 #endif
1049 {
1050
1051    RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
1052              "cellId(%d), cfgType(%d)",
1053               cfgTmpData->cellId,cfgToValidate->cfgType);
1054
1055    /* Check for ueId is present or not */
1056    if ( cfgTmpData->ueId == 0 )
1057    {
1058       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;
1059       RLOG_ARG1(L_ERROR,DBG_UEID,cfgTmpData->ueId,
1060             "UeId is 0 for CELLID;%d",
1061             cfgTmpData->cellId);
1062       return RFAILED;
1063    }
1064
1065    /* Fetch Ue Cb */
1066    if(ROK != rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
1067    {
1068       RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
1069             "UeId [%d]: UeCb not found",
1070             cfgTmpData->ueId);
1071       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;
1072       return RFAILED;
1073    }
1074    return ROK;
1075 }
1076
1077 \f
1078 /**
1079  * @brief
1080  *    This primitive apply Uplink Delete Ue request
1081  *
1082  * @param [in] gCb      -  RLC Instance Control Block
1083  * @param [in] cfgTmpData    -  Configuration Temporary Data
1084  *
1085  * @return  S16
1086  *    -# ROK
1087  */
1088 #ifdef ANSI
1089 Void rlcCfgApplyDelUlUe
1090 (
1091 RlcCb             *gCb,
1092 RlcUlCfgTmpData   *cfgTmpData
1093 )
1094 #else
1095 Void rlcCfgApplyDelUlUe(gCb, cfgTmpData)
1096 (
1097 RlcCb             *gCb;
1098 RlcUlCfgTmpData   *cfgTmpData;
1099 )
1100 #endif
1101 {
1102
1103 #ifdef LTE_L2_MEAS
1104    rlcDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
1105 #endif
1106    rlcDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
1107    return;
1108 }
1109
1110 \f
1111 /**
1112  * @brief
1113  *    This primitive validates uplink Delete UE request
1114  *    for RB creation.
1115  *
1116  * @param [in] gCb      -  RLC Instance Control Block
1117  * @param [in] ueId     -  UE Identifier
1118  * @param [in] cfgToValidate   -  Entity Configuration to be done.
1119  * @param [in] cfgEntData    -  Configuration Temporary Data Entity
1120  * @param [in] cfgTmpData    -  Configuration Temporary Data
1121  *
1122  * @return  S16
1123  *    -# ROK
1124  *    -# RFAILED
1125  */
1126 #ifdef ANSI
1127 S16 rlcCfgValidateDelUlCell
1128 (
1129 RlcCb             *gCb,
1130 CmLteCellId      cellId,
1131 RlcEntCfgInfo    *cfgToValidate,
1132 RlcUlEntTmpData   *cfgEntData,
1133 RlcUlCfgTmpData   *cfgTmpData
1134 )
1135 #else
1136 S16 rlcCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
1137 RlcCb             *gCb;
1138 CmLteCellId      cellId;
1139 RlcEntCfgInfo    *cfgToValidate;
1140 RlcUlEntTmpData   *cfgEntData;
1141 RlcUlCfgTmpData   *cfgTmpData;
1142 #endif
1143 {
1144
1145    RLOG_ARG1(L_DEBUG,DBG_CELLID,cellId ,"cfgType(%d)",
1146               cfgToValidate->cfgType);
1147
1148    cfgTmpData->cellCb = NULLP;
1149
1150    /* Check for cellId is present or not */
1151    if ( cellId == 0 )
1152    {
1153       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;
1154       RLOG_ARG0(L_ERROR,DBG_CELLID,cellId , "CellId is 0");
1155       return RFAILED;
1156    }
1157
1158    /* Fetch Cell Cb */
1159    rlcDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
1160    if (!cfgTmpData->cellCb)
1161    {
1162       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;
1163       RLOG_ARG0(L_ERROR, DBG_CELLID,cellId, "CellCb not found");
1164       return RFAILED;
1165    }
1166    return ROK;
1167 }
1168
1169 \f
1170 /**
1171  * @brief
1172  *    This primitive apply Uplink Delete Ue request
1173  *
1174  * @param [in] gCb      -  RLC Instance Control Block
1175  * @param [in] cfgEntData  - Temporary Data maintained for a transaction
1176  *
1177  * @return  S16
1178  *    -# ROK
1179  */
1180 #ifdef ANSI
1181 Void rlcCfgApplyDelUlCell
1182 (
1183 RlcCb             *gCb,
1184 RlcUlCfgTmpData   *cfgInfo
1185 )
1186 #else
1187 Void rlcCfgApplyDelUlCell(gCb, cfgEntData)
1188 (
1189 RlcCb             *gCb;
1190 RlcUlCfgTmpData   *cfgInfo;
1191 )
1192 #endif
1193 {
1194
1195    rlcDbmDelUlCellCb(gCb,cfgInfo->cellCb);
1196    return;
1197 }
1198 \f
1199 /**
1200  * @brief
1201  *    This primitive validates reestablishment of RB.
1202  *
1203  * @param [in]   gCb      -  RLC Instance Control Block
1204  * @param [in]   ueId     -  UE Identifier
1205  * @param [in]   cellId   -  CELL Identifier
1206  * @param [in]   cfgToValidate   -  Entity Configuration to be done.
1207  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
1208  *
1209  * @return  S16
1210  *    -# ROK
1211  *    -# RFAILED
1212  */
1213 #ifdef ANSI
1214 S16 rlcCfgValidateReEstRb
1215 (
1216 RlcCb             *gCb,
1217 CmLteRnti        ueId,
1218 CmLteCellId      cellId,
1219 RlcEntCfgInfo    *cfgToValidate,
1220 RlcUlEntTmpData   *cfgEntData
1221 )
1222 #else
1223 S16 rlcCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
1224 RlcCb             *gCb;
1225 CmLteRnti        ueId;
1226 CmLteCellId      cellId;
1227 RlcEntCfgInfo    *cfgToValidate;
1228 RlcUlEntTmpData   *cfgEntData;
1229 #endif
1230 {
1231    CmLteRlcId   rlcId;   /* RLC Identifier */
1232
1233    RLOG_ARG2(L_DEBUG, DBG_UEID,ueId,
1234          "cellId(%d) RBID:%d",
1235          cellId,
1236          cfgToValidate->rbId);
1237
1238    /* Get rlcId */
1239    rlcId.ueId = ueId;
1240    rlcId.cellId = cellId;
1241    rlcId.rbId = cfgToValidate->rbId;
1242    rlcId.rbType = cfgToValidate->rbType;
1243
1244    rlcDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
1245    if (cfgEntData->rbCb == NULLP)
1246    {
1247       RLOG_ARG2(L_WARNING, DBG_UEID,ueId,
1248             "CellId [%u]: rbId [%d] not found",
1249              cellId,
1250              cfgToValidate->rbId);
1251       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_UNKWN;
1252       return RFAILED;
1253    }
1254
1255    return ROK;
1256 }
1257
1258
1259 \f
1260 /**
1261  * @brief
1262  *    This primitive apply reestablishment of RB.
1263  *
1264  * @param [in] gCb        -  RLC Instance Control Block
1265  * @param [in] ueId       -  UE Identifier
1266  * @param [in] cellId     -  CELL Identifier
1267  * @param [in] sndReEstInd  -  ReEstablish Indication Flag
1268  * @param [in] cfgEntData -  Configuration Temporary Data Entity
1269  *
1270  * @return  S16
1271  *    -# ROK
1272  */
1273 #ifdef ANSI
1274 Void rlcCfgApplyReEstUlRb
1275 (
1276 RlcCb             *gCb,
1277 CmLteRnti        ueId,
1278 CmLteCellId      cellId,
1279 Bool             sndReEstInd,
1280 RlcUlEntTmpData   *cfgEntData
1281 )
1282 #else
1283 Void rlcCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
1284 (
1285 RlcCb             *gCb;
1286 CmLteRnti        ueId;
1287 CmLteCellId      cellId;
1288 Bool             sndReEstInd;
1289 RlcUlEntTmpData   *cfgEntData;
1290 )
1291 #endif
1292 {
1293    CmLteRlcId   rlcId;   /* RLC Identifier */
1294
1295    rlcId.ueId = ueId;
1296    rlcId.cellId = cellId;
1297    rlcId.rbId = cfgEntData->entUlCfgCfm.rbId;
1298    rlcId.rbType = cfgEntData->entUlCfgCfm.rbType;
1299    cfgEntData->rbCb->rlcId.ueId = ueId;
1300    switch (cfgEntData->rbCb->mode)
1301    {
1302       case CM_LTE_MODE_TM:
1303          {
1304             rlcTmmUlReEstablish(gCb,cfgEntData->rbCb);
1305             break;
1306          }
1307
1308       case CM_LTE_MODE_UM:
1309          {
1310             rlcUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
1311             break;
1312          }
1313
1314       case CM_LTE_MODE_AM:
1315          {
1316             rlcAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
1317             break;
1318          }
1319    }
1320    return;
1321 }
1322 \f
1323 /**
1324  * @brief
1325  *    This primitive validates reestablishment of RB.
1326  *
1327  * @param [in] gCb        -  RLC Instance Control Block
1328  * @param [in] ueInfo     -  UE Identifier
1329  * @param [in] newUeInfo  -  CELL Identifier
1330  * @param [in] cfgTmpData -  Configuration Temporary Data
1331  *
1332  * @return  S16
1333  *    -# ROK
1334  *    -# RFAILED
1335  */
1336 #ifdef ANSI
1337 S16 rlcCfgValidateUeIdChng
1338 (
1339 RlcCb             *gCb,
1340 CkwUeInfo        *ueInfo,
1341 CkwUeInfo        *newUeInfo,
1342 RlcUlCfgTmpData   *cfgTmpData
1343 )
1344 #else
1345 S16 rlcCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
1346 RlcCb             *gCb;
1347 CkwUeInfo        *ueInfo;
1348 CkwUeInfo        *newUeInfo;
1349 RlcUlCfgTmpData   *cfgTmpData;
1350 #endif
1351 {
1352    RlcUlUeCb   *ueCb;
1353
1354 #define CFM_STATUS  cfgTmpData->cfgEntData[0].entUlCfgCfm.status
1355    if ( (ueInfo->ueId == newUeInfo->ueId) &&
1356         (ueInfo->cellId == newUeInfo->cellId))
1357    {
1358       CFM_STATUS.reason = CKW_CFG_REAS_SAME_UEID;
1359       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1360       return RFAILED;
1361    }
1362
1363    if(ROK == rlcDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
1364    {
1365       RLOG_ARG1(L_ERROR, DBG_CELLID, newUeInfo->cellId,
1366             "NewUeId[%d]:ueCb already exists",
1367              newUeInfo->ueId);
1368       CFM_STATUS.reason = CKW_CFG_REAS_UE_EXISTS;
1369       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1370       return RFAILED;
1371    }
1372
1373    if(ROK != rlcDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
1374                               &cfgTmpData->ueCb))
1375    {
1376       RLOG_ARG1(L_ERROR,DBG_CELLID, ueInfo->cellId,
1377             "UeId [%d]: UeCb not found",
1378             ueInfo->ueId);
1379       CFM_STATUS.reason = CKW_CFG_REAS_UE_UNKWN;
1380       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1381       return RFAILED;
1382    }
1383 #undef CFM_STATUS
1384    return ROK;
1385 }
1386
1387
1388 \f
1389 /**
1390  * @brief
1391  *    This primitive apply reestablishment of RB.
1392  *
1393  * @param [in] gCb        -  RLC Instance Control Block
1394  * @param [in] ueInfo     -  UE Identifier
1395  * @param [in] newUeInfo  -  CELL Identifier
1396  * @param [in] cfgTmpData -  Configuration Temporary Data
1397  *
1398  * @return  S16
1399  *    -# ROK
1400  */
1401 #ifdef ANSI
1402 Void rlcCfgApplyUlUeIdChng
1403 (
1404 RlcCb             *gCb,
1405 CkwUeInfo        *ueInfo,
1406 CkwUeInfo        *newUeInfo,
1407 RlcUlCfgTmpData   *cfgTmpData
1408 )
1409 #else
1410 Void rlcCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
1411 (
1412 RlcCb             *gCb;
1413 CkwUeInfo        *ueInfo,
1414 CkwUeInfo        *newUeInfo,
1415 RlcUlCfgTmpData   *cfgTmpData;
1416 )
1417 #endif
1418 {
1419
1420 #ifdef LTE_L2_MEAS
1421    rlcHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
1422 #endif
1423    cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) cfgTmpData->ueCb);
1424    /* update the hash key with new values */
1425    cfgTmpData->ueCb->ueId = newUeInfo->ueId;
1426    cfgTmpData->ueCb->cellId =newUeInfo->cellId;
1427    if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp),
1428                               (PTR)cfgTmpData->ueCb,
1429                               (uint8_t *)&(cfgTmpData->ueCb->ueId),
1430                               (uint16_t) sizeof(CmLteRnti)))
1431
1432    {
1433       RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId,
1434             "UeId[%u] HashList Insertion Failed",
1435             newUeInfo->ueId);
1436    }
1437
1438    return;
1439 }
1440 /********************************************************************30**
1441
1442          End of file
1443 **********************************************************************/