src/5gnrrlc/kw_cfg_ul.c

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