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             uint16_t winLen;
 677
 678
 679             cfgEntData->rbCb->m.umUl.umWinSz = RLC_POWER(2,
 680                   ((cfgToValidate->m.umInfo.ul.snLen *5)-1));
 681             winLen =  cfgEntData->rbCb->m.umUl.umWinSz << 1;
 682             RLC_ALLOC(gCb,
 683                      cfgEntData->rbCb->m.umUl.recBuf,
 684                      (winLen * sizeof(RlcUmRecBuf*)));
 685          }
 686          else if(CM_LTE_MODE_AM == cfgToValidate->entMode)
 687          {
 688 #ifndef LTE_TDD
 689              uint32_t hashIndex;
 690               RLC_ALLOC(gCb,
 691                     cfgEntData->rbCb->m.amUl.recBufLst,
 692                     (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
 693               for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++)
 694               {
 695                   cmLListInit(&(cfgEntData->rbCb->m.amUl.recBufLst[hashIndex]));
 696               }
 697 #endif
 698          }
 699          break;
 700       }
 701       case CKW_CFG_MODIFY:
 702       case CKW_CFG_DELETE:
 703       {
 704          if (cfgTmpData->ueId == 0)
 705          {
 706             /* Try to get the CellCb if it already exists */
 707             rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
 708             if(!cfgTmpData->cellCb)
 709             {
 710                 RLOG_ARG1(L_ERROR, DBG_CELLID,cfgTmpData->cellId,
 711                       "CellCb not found UEID:%d",
 712                       cfgTmpData->ueId);
 713                /*how can a modify request come for a cell which does not exist*/
 714                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
 715                return RFAILED;
 716             }
 717
 718             cfgEntData->rbCb = cfgTmpData->cellCb->rbCb[cfgToValidate->rbId];
 719             if (!cfgEntData->rbCb)
 720             {
 721                /* something is wrong the rbId for this cell does not exist */
 722                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
 723                return RFAILED;
 724             }
 725             return ROK;
 726          }
 727          else
 728          {
 729             rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
 730             if(!cfgTmpData->ueCb)
 731             {
 732                RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
 733                      "UeId [%d]: UeCb not found",
 734                      cfgTmpData->ueId);
 735                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
 736                return RFAILED;
 737             }
 738
 739             /* Get rbCb */
 740             RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
 741                                       cfgToValidate->rbType,
 742                                       cfgTmpData->ueCb,
 743                                       cfgEntData->rbCb);
 744             if ( cfgEntData->rbCb == NULLP)
 745             {
 746                cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN;
 747                return RFAILED;
 748             }
 749             return ROK;
 750          }
 751          break;
 752       }
 753    }
 754
 755    if(cfgToValidate->cfgType == CKW_CFG_MODIFY)
 756    {
 757       if(cfgToValidate->entMode != cfgEntData->rbCb->mode)
 758       {
 759          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_MODE_MIS;
 760          return RFAILED;
 761       }
 762
 763       if(cfgToValidate->m.umInfo.ul.snLen != cfgEntData->rbCb->m.umUl.snLen)
 764       {
 765          cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_SNLEN_MIS;
 766          return RFAILED;
 767       }
 768    }
 769    return ROK;
 770 }
 771
 772 \f
 773 /**
 774  * @brief
 775  *    This primitive roll back the RB Configuration
 776  *
 777  * @param [in]  gCb      -  RLC Instance Control Block
 778  * @param [in]  ueId     -  UE Identifier
 779  * @param [in]  cfg   -     Configuration entity.
 780  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 781  *
 782  * @return  S16
 783  *    -# ROK
 784  *    -# RFAILED
 785  */
 786 S16 rlcCfgRollBackUlRb
 787 (
 788 RlcCb             *gCb,
 789 CmLteRnti        ueId,
 790 RlcEntCfgInfo    *cfg,
 791 RlcUlEntTmpData   *cfgEntData
 792 )
 793 {
 794
 795    if(CKW_CFG_ADD == cfg->cfgType)
 796    {
 797       if(CM_LTE_MODE_UM == cfg->entMode)
 798       {
 799          RLC_FREE(gCb,
 800                cfgEntData->rbCb->m.umUl.recBuf,
 801                (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(RlcUmRecBuf*));
 802       }
 803       else if(CM_LTE_MODE_AM == cfg->entMode)
 804       {
 805 #ifndef LTE_TDD
 806       RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
 807 #endif
 808       }
 809       RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
 810    }
 811
 812    return ROK;
 813 }
 814
 815 \f
 816 /**
 817  * @brief
 818  *    This primitive apply RB Configuration.
 819  *
 820  * @param [in] gCb      -  RLC Instance Control Block
 821  * @param [in] cfgToAply  -   Configuration to be applied
 822  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 823  * @param [out] cfgTmpData    -  Configuration Temporary Data
 824  *
 825  * @return  S16
 826  *    -# ROK
 827  *    -# RFAILED
 828  */
 829 Void rlcCfgApplyUlRb
 830 (
 831 RlcCb             *gCb,
 832 RlcEntCfgInfo    *cfgToAply,
 833 RlcUlEntTmpData   *cfgEntData,
 834 RlcUlCfgTmpData   *cfgTmpData
 835 )
 836 {
 837
 838    switch(cfgToAply->cfgType)
 839    {
 840       case CKW_CFG_ADD:
 841       {
 842          /* copy the RB Cb into UeCb */
 843          cfgEntData->rbCb->rlcId.rbId = cfgToAply->rbId;
 844          if (cfgTmpData->ueId == 0)
 845          {
 846             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 847             cfgTmpData->cellCb->lCh[cfgToAply->lCh[0].lChId -1].ulRbCb = cfgEntData->rbCb;
 848          }
 849          else
 850          {
 851             if(cfgToAply->rbType == CM_LTE_SRB)
 852             {
 853                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 854             }
 855             else
 856             {
 857                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = cfgEntData->rbCb;
 858             }
 859          }
 860
 861          RLC_LMM_RB_STS_INC(gCb);
 862
 863          cfgEntData->rbCb->rlcId.cellId = cfgTmpData->cellId;
 864          cfgEntData->rbCb->rlcId.ueId   = cfgTmpData->ueId;
 865          cfgEntData->rbCb->rlcId.rbType = cfgToAply->rbType;
 866          cfgEntData->rbCb->inst         = gCb->init.inst;
 867
 868          /* Fill RB CB */
 869          rlcCfgFillUlRbCb(gCb,
 870                          cfgEntData->rbCb,
 871                          cfgTmpData->ueCb,
 872                          cfgToAply);
 873
 874 #ifdef LTE_L2_MEAS
 875          cfgEntData->rbCb->qci = cfgToAply->qci;
 876          cfgEntData->rbCb->ueCb =  cfgTmpData->ueCb;
 877          if (cfgToAply->lCh[1].type == CM_LTE_LCH_DTCH)
 878          {
 879             /* ccpu00129778 */
 880             rlcAddToUlL2Meas(gCb, cfgEntData->rbCb,
 881                   cfgTmpData->cellId,cfgTmpData->ueId);
 882          }
 883 #endif /* LTE_L2_MEAS */
 884          break;
 885       }
 886       case CKW_CFG_MODIFY:
 887       {
 888          if(cfgTmpData->ueId == 0)
 889          {
 890             rlcCfgUpdateUlRb(gCb,
 891                             cfgEntData->rbCb,
 892                             (void *)cfgTmpData->cellCb,
 893                             cfgToAply);
 894          }
 895          else
 896          {
 897             rlcCfgUpdateUlRb(gCb,
 898                             cfgEntData->rbCb,
 899                             (void*)cfgTmpData->ueCb,
 900                             cfgToAply);
 901          }
 902          break;
 903       }
 904       case CKW_CFG_DELETE:
 905       {
 906          if (cfgTmpData->ueId == 0)
 907          {
 908             cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = NULLP;
 909             cfgTmpData->cellCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb =
 910                                                                         NULLP;
 911          }
 912          else
 913          {
 914             cfgTmpData->ueCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb =
 915                                                                        NULLP;
 916
 917             /* Free the Buffers of RbCb */
 918             if( CM_LTE_MODE_UM == cfgEntData->rbCb->mode )
 919             {
 920                rlcUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
 921             }
 922             else if(CM_LTE_MODE_AM == cfgEntData->rbCb->mode)
 923             {
 924                rlcAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
 925             }
 926
 927             /* Assign NULLP to rbCb in rbCbLst */
 928             if ( cfgToAply->rbType == CM_LTE_SRB )
 929             {
 930                cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = NULLP;
 931             }
 932             else
 933             {
 934                cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = NULLP;
 935             }
 936          }
 937          /* Delete RbCb  */
 938          RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
 939
 940          RLC_LMM_RB_STS_DEC(gCb);
 941          break;
 942       }
 943    }
 944    return;
 945 }
 946
 947 \f
 948 /**
 949  * @brief
 950  *    This primitive validates uplink Delete UE request
 951  *    for RB creation.
 952  *
 953  * @param [in]  gCb      -  RLC Instance Control Block
 954  * @param [in]  cfgToValidate   -  Entity Configuration to be validated.
 955  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
 956  * @param [out] cfgTmpData    -  Configuration Temporary Data
 957  *
 958  * @return  S16
 959  *    -# ROK
 960  *    -# RFAILED
 961  */
 962 S16 rlcCfgValidateDelUlUe
 963 (
 964 RlcCb             *gCb,
 965 RlcEntCfgInfo    *cfgToValidate,
 966 RlcUlEntTmpData   *cfgEntData,
 967 RlcUlCfgTmpData   *cfgTmpData
 968 )
 969 {
 970
 971    RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
 972              "cellId(%d), cfgType(%d)",
 973               cfgTmpData->cellId,cfgToValidate->cfgType);
 974
 975    /* Check for ueId is present or not */
 976    if ( cfgTmpData->ueId == 0 )
 977    {
 978       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;
 979       RLOG_ARG1(L_ERROR,DBG_UEID,cfgTmpData->ueId,
 980             "UeId is 0 for CELLID;%d",
 981             cfgTmpData->cellId);
 982       return RFAILED;
 983    }
 984
 985    /* Fetch Ue Cb */
 986    if(ROK != rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
 987    {
 988       RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
 989             "UeId [%d]: UeCb not found",
 990             cfgTmpData->ueId);
 991       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_UE_UNKWN;
 992       return RFAILED;
 993    }
 994    return ROK;
 995 }
 996
 997 \f
 998 /**
 999  * @brief
1000  *    This primitive apply Uplink Delete Ue request
1001  *
1002  * @param [in] gCb      -  RLC Instance Control Block
1003  * @param [in] cfgTmpData    -  Configuration Temporary Data
1004  *
1005  * @return  S16
1006  *    -# ROK
1007  */
1008 Void rlcCfgApplyDelUlUe
1009 (
1010 RlcCb             *gCb,
1011 RlcUlCfgTmpData   *cfgTmpData
1012 )
1013 {
1014
1015 #ifdef LTE_L2_MEAS
1016    rlcDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
1017 #endif
1018    rlcDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
1019    return;
1020 }
1021
1022 \f
1023 /**
1024  * @brief
1025  *    This primitive validates uplink Delete UE request
1026  *    for RB creation.
1027  *
1028  * @param [in] gCb      -  RLC Instance Control Block
1029  * @param [in] ueId     -  UE Identifier
1030  * @param [in] cfgToValidate   -  Entity Configuration to be done.
1031  * @param [in] cfgEntData    -  Configuration Temporary Data Entity
1032  * @param [in] cfgTmpData    -  Configuration Temporary Data
1033  *
1034  * @return  S16
1035  *    -# ROK
1036  *    -# RFAILED
1037  */
1038 S16 rlcCfgValidateDelUlCell
1039 (
1040 RlcCb             *gCb,
1041 CmLteCellId      cellId,
1042 RlcEntCfgInfo    *cfgToValidate,
1043 RlcUlEntTmpData   *cfgEntData,
1044 RlcUlCfgTmpData   *cfgTmpData
1045 )
1046 {
1047
1048    RLOG_ARG1(L_DEBUG,DBG_CELLID,cellId ,"cfgType(%d)",
1049               cfgToValidate->cfgType);
1050
1051    cfgTmpData->cellCb = NULLP;
1052
1053    /* Check for cellId is present or not */
1054    if ( cellId == 0 )
1055    {
1056       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;
1057       RLOG_ARG0(L_ERROR,DBG_CELLID,cellId , "CellId is 0");
1058       return RFAILED;
1059    }
1060
1061    /* Fetch Cell Cb */
1062    rlcDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
1063    if (!cfgTmpData->cellCb)
1064    {
1065       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_CELL_UNKWN;
1066       RLOG_ARG0(L_ERROR, DBG_CELLID,cellId, "CellCb not found");
1067       return RFAILED;
1068    }
1069    return ROK;
1070 }
1071
1072 \f
1073 /**
1074  * @brief
1075  *    This primitive apply Uplink Delete Ue request
1076  *
1077  * @param [in] gCb      -  RLC Instance Control Block
1078  * @param [in] cfgEntData  - Temporary Data maintained for a transaction
1079  *
1080  * @return  S16
1081  *    -# ROK
1082  */
1083 Void rlcCfgApplyDelUlCell(RlcCb *gCb,RlcUlCfgTmpData *cfgInfo)
1084 {
1085
1086    rlcDbmDelUlCellCb(gCb,cfgInfo->cellCb);
1087    return;
1088 }
1089 \f
1090 /**
1091  * @brief
1092  *    This primitive validates reestablishment of RB.
1093  *
1094  * @param [in]   gCb      -  RLC Instance Control Block
1095  * @param [in]   ueId     -  UE Identifier
1096  * @param [in]   cellId   -  CELL Identifier
1097  * @param [in]   cfgToValidate   -  Entity Configuration to be done.
1098  * @param [out] cfgEntData    -  Configuration Temporary Data Entity
1099  *
1100  * @return  S16
1101  *    -# ROK
1102  *    -# RFAILED
1103  */
1104 S16 rlcCfgValidateReEstRb
1105 (
1106 RlcCb             *gCb,
1107 CmLteRnti        ueId,
1108 CmLteCellId      cellId,
1109 RlcEntCfgInfo    *cfgToValidate,
1110 RlcUlEntTmpData   *cfgEntData
1111 )
1112 {
1113    CmLteRlcId   rlcId;   /* RLC Identifier */
1114
1115    RLOG_ARG2(L_DEBUG, DBG_UEID,ueId,
1116          "cellId(%d) RBID:%d",
1117          cellId,
1118          cfgToValidate->rbId);
1119
1120    /* Get rlcId */
1121    rlcId.ueId = ueId;
1122    rlcId.cellId = cellId;
1123    rlcId.rbId = cfgToValidate->rbId;
1124    rlcId.rbType = cfgToValidate->rbType;
1125
1126    rlcDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
1127    if (cfgEntData->rbCb == NULLP)
1128    {
1129       RLOG_ARG2(L_WARNING, DBG_UEID,ueId,
1130             "CellId [%u]: rbId [%d] not found",
1131              cellId,
1132              cfgToValidate->rbId);
1133       cfgEntData->entUlCfgCfm.status.reason =  CKW_CFG_REAS_RB_UNKWN;
1134       return RFAILED;
1135    }
1136
1137    return ROK;
1138 }
1139
1140
1141 \f
1142 /**
1143  * @brief
1144  *    This primitive apply reestablishment of RB.
1145  *
1146  * @param [in] gCb        -  RLC Instance Control Block
1147  * @param [in] ueId       -  UE Identifier
1148  * @param [in] cellId     -  CELL Identifier
1149  * @param [in] sndReEstInd  -  ReEstablish Indication Flag
1150  * @param [in] cfgEntData -  Configuration Temporary Data Entity
1151  *
1152  * @return  S16
1153  *    -# ROK
1154  */
1155 Void rlcCfgApplyReEstUlRb
1156 (
1157 RlcCb           *gCb,
1158 CmLteRnti       ueId,
1159 CmLteCellId     cellId,
1160 Bool            sndReEstInd,
1161 RlcUlEntTmpData *cfgEntData
1162 )
1163 {
1164    CmLteRlcId   rlcId;   /* RLC Identifier */
1165
1166    rlcId.ueId = ueId;
1167    rlcId.cellId = cellId;
1168    rlcId.rbId = cfgEntData->entUlCfgCfm.rbId;
1169    rlcId.rbType = cfgEntData->entUlCfgCfm.rbType;
1170    cfgEntData->rbCb->rlcId.ueId = ueId;
1171    switch (cfgEntData->rbCb->mode)
1172    {
1173       case CM_LTE_MODE_TM:
1174          {
1175             rlcTmmUlReEstablish(gCb,cfgEntData->rbCb);
1176             break;
1177          }
1178
1179       case CM_LTE_MODE_UM:
1180          {
1181             rlcUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
1182             break;
1183          }
1184
1185       case CM_LTE_MODE_AM:
1186          {
1187             rlcAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
1188             break;
1189          }
1190    }
1191    return;
1192 }
1193 \f
1194 /**
1195  * @brief
1196  *    This primitive validates reestablishment of RB.
1197  *
1198  * @param [in] gCb        -  RLC Instance Control Block
1199  * @param [in] ueInfo     -  UE Identifier
1200  * @param [in] newUeInfo  -  CELL Identifier
1201  * @param [in] cfgTmpData -  Configuration Temporary Data
1202  *
1203  * @return  S16
1204  *    -# ROK
1205  *    -# RFAILED
1206  */
1207 S16 rlcCfgValidateUeIdChng
1208 (
1209 RlcCb            *gCb,
1210 CkwUeInfo        *ueInfo,
1211 CkwUeInfo        *newUeInfo,
1212 RlcUlCfgTmpData  *cfgTmpData
1213 )
1214 {
1215    RlcUlUeCb   *ueCb;
1216
1217 #define CFM_STATUS  cfgTmpData->cfgEntData[0].entUlCfgCfm.status
1218    if ( (ueInfo->ueId == newUeInfo->ueId) &&
1219         (ueInfo->cellId == newUeInfo->cellId))
1220    {
1221       CFM_STATUS.reason = CKW_CFG_REAS_SAME_UEID;
1222       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1223       return RFAILED;
1224    }
1225
1226    if(ROK == rlcDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
1227    {
1228       RLOG_ARG1(L_ERROR, DBG_CELLID, newUeInfo->cellId,
1229             "NewUeId[%d]:ueCb already exists",
1230              newUeInfo->ueId);
1231       CFM_STATUS.reason = CKW_CFG_REAS_UE_EXISTS;
1232       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1233       return RFAILED;
1234    }
1235
1236    if(ROK != rlcDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
1237                               &cfgTmpData->ueCb))
1238    {
1239       RLOG_ARG1(L_ERROR,DBG_CELLID, ueInfo->cellId,
1240             "UeId [%d]: UeCb not found",
1241             ueInfo->ueId);
1242       CFM_STATUS.reason = CKW_CFG_REAS_UE_UNKWN;
1243       CFM_STATUS.status = CKW_CFG_CFM_NOK;
1244       return RFAILED;
1245    }
1246 #undef CFM_STATUS
1247    return ROK;
1248 }
1249
1250
1251 \f
1252 /**
1253  * @brief
1254  *    This primitive apply reestablishment of RB.
1255  *
1256  * @param [in] gCb        -  RLC Instance Control Block
1257  * @param [in] ueInfo     -  UE Identifier
1258  * @param [in] newUeInfo  -  CELL Identifier
1259  * @param [in] cfgTmpData -  Configuration Temporary Data
1260  *
1261  * @return  S16
1262  *    -# ROK
1263  */
1264 Void rlcCfgApplyUlUeIdChng
1265 (
1266 RlcCb            *gCb,
1267 CkwUeInfo        *ueInfo,
1268 CkwUeInfo        *newUeInfo,
1269 RlcUlCfgTmpData  *cfgTmpData
1270 )
1271 {
1272
1273 #ifdef LTE_L2_MEAS
1274    rlcHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
1275 #endif
1276    cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) cfgTmpData->ueCb);
1277    /* update the hash key with new values */
1278    cfgTmpData->ueCb->ueId = newUeInfo->ueId;
1279    cfgTmpData->ueCb->cellId =newUeInfo->cellId;
1280    if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp),
1281                               (PTR)cfgTmpData->ueCb,
1282                               (uint8_t *)&(cfgTmpData->ueCb->ueId),
1283                               (uint16_t) sizeof(CmLteRnti)))
1284
1285    {
1286       RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId,
1287             "UeId[%u] HashList Insertion Failed",
1288             newUeInfo->ueId);
1289    }
1290
1291    return;
1292 }
1293 /********************************************************************30**
1294
1295          End of file
1296 **********************************************************************/