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