X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrrlc%2Fkw_cfg_ul.c;fp=src%2F5gnrrlc%2Fkw_cfg_ul.c;h=c55f6a35a06129bd3d45dae9a93ce1758a4fdcf8;hb=5625a52ad68f6ad93684e68bbbdbaef0d462cf9a;hp=0000000000000000000000000000000000000000;hpb=59f84608ec15c016958a6e0e0ddd813f376c0925;p=o-du%2Fl2.git diff --git a/src/5gnrrlc/kw_cfg_ul.c b/src/5gnrrlc/kw_cfg_ul.c new file mode 100755 index 000000000..c55f6a35a --- /dev/null +++ b/src/5gnrrlc/kw_cfg_ul.c @@ -0,0 +1,1477 @@ +/******************************************************************************* +################################################################################ +# Copyright (c) [2017-2019] [Radisys] # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +################################################################################ +*******************************************************************************/ + +/********************************************************************20** + + Name: LTE RLC - Configuration Manager file + + Type: C source file + + Desc: It contains the following configuraiton primtives + for different actions + -- kwCfgValdtEntCfg + -- kwCfgFillRbCb + -- kwCfgRbInit + + File: kw_cfg_ul.c + +*********************************************************************21*/ +static const char* RLOG_MODULE_NAME="CFG"; +static int RLOG_MODULE_ID=2048; +static int RLOG_FILE_ID=192; +/** @file kw_cfg_ul.c +@brief RLC Uplink Configuration Module +**/ + + +/* header (.h) include files */ +#include "envopt.h" /* environment options */ +#include "envdep.h" /* environment dependent */ +#include "envind.h" /* environment independent */ + +#include "gen.h" /* general */ +#include "ssi.h" /* system services */ +#include "cm5.h" /* common timer defines */ +#include "cm_tkns.h" /* common tokens defines */ +#include "cm_mblk.h" /* common memory allocation library defines */ +#include "cm_llist.h" /* common link list defines */ +#include "cm_hash.h" /* common hash list defines */ +#include "cm_lte.h" /* common LTE defines */ +#include "lkw.h" /* LKW defines */ +#include "ckw.h" /* CKW defines */ +#include "kwu.h" /* KWU defines */ +#include "rgu.h" /* RGU defines */ +#include "kw_err.h" /* RLC error options */ +#include "kw_env.h" /* RLC environment options */ +#include "kw.h" /* RLC defines */ +#include "kw_ul.h" + +/* extern (.x) include files */ +#include "gen.x" /* general */ +#include "ssi.x" /* system services */ + +#include "cm5.x" /* common timer library */ +#include "cm_tkns.x" /* common tokens */ +#include "cm_mblk.x" /* common memory allocation */ +#include "cm_llist.x" /* common link list */ +#include "cm_hash.x" /* common hash list */ +#include "cm_lte.x" /* common LTE includes */ +#include "cm_lib.x" /* common memory allocation library */ +#include "lkw.x" /* LKW */ +#include "ckw.x" /* CKW */ +#include "kwu.x" /* KWU */ +#include "rgu.x" /* RGU */ + +#include "kw.x" +#include "kw_ul.x" +#ifdef TENB_STATS +#ifdef L2_L3_SPLIT +#include "l2_tenb_stats.x" /* Total EnodeB Stats declarations */ +#endif +#endif +PUBLIC S16 kwValidateRbCfgParams (KwCb *gCb, CmLteRnti ueId, CmLteCellId cellId, + CkwEntCfgInfo *cfgToValidate, CmStatus *status); +#define KW_MODULE KW_DBGMASK_CFG +#ifdef LTE_L2_MEAS +/** + * + * @brief Handle modification of UE ID for L2 Meas data structs + * + * + * @param[in] ueId ue ID + * + * @return S16 + * -# ROK + * -# RFAILED + * +*/ +PRIVATE S16 kwHdlMeasUlUeIdChg(KwCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId) +{ + KwL2MeasCb *measCb = NULLP; + U16 cntr; + U16 ueIdx = 0; + + for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++) + { + measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb); + + if( measCb->measType & LKW_L2MEAS_UL_IP) + { + + for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++) + { + if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == oldUeId) + { + measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = newUeId; + break; + } + } + } + } + RETVALUE(ROK); +} + +/** + * + * @brief Handler to delete an UE's L2 Meas ctxt + * +* + * @param[in] ueId ue ID + * + * @return S16 + * -# ROK + * -# RFAILED + * +*/ +PRIVATE S16 kwDelFrmUlL2Meas(KwCb *gCb, U8 cellId,U8 ueId) +{ + KwL2MeasCb *measCb = NULLP; + U16 cntr; + U16 ueIdx = 0; + + for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++) + { + measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb); + + + if( measCb->measType & LKW_L2MEAS_UL_IP) + { + + for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++) + { + if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == ueId) + { + measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = FALSE; + if (measCb->val.ipThMeas.numUes-1 == ueIdx) + { + measCb->val.ipThMeas.numUes--; + } + break; + } + } + + + + { + U32 myIdx =0; + S16 ret; /* Return value */ + KwUlUeCb *ueCb = NULL; + + for (myIdx = 0; myIdx < measCb->val.ipThMeas.numUes; myIdx++) + { + ueCb = NULL; + ret = kwDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb); + } + } + + } + } + + RETVALUE(ROK); +} + + +PRIVATE S16 kwAddToUlL2Meas(KwCb *gCb, KwUlRbCb *kwRbCb,U8 cellId,U8 ueId) +{ + KwL2MeasCb *measCb = NULLP; + U16 cntr; + U16 cntr1; + U16 ueIdx = 0; + U16 qciIdx = 0; + U16 *numQci; + #ifndef XEON_SPECIFIC_CHANGES + U8 freeIdx = gCb->genCfg.maxUe; + #else + U16 freeIdx = LKW_MAX_UE; + #endif + + for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++) + { + measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb); + + freeIdx = gCb->genCfg.maxUe; + + if(measCb->measType & LKW_L2MEAS_ACT_UE ) + { + for(cntr1 =0;cntr1val.nonIpThMeas.numQci;cntr1++) + { + if(measCb->val.nonIpThMeas.qci[cntr1] != kwRbCb->qci) + { + measCb->val.nonIpThMeas.qci[cntr1] = kwRbCb->qci; + gCb->u.ulCb->kwL2Cb.measOn[kwRbCb->qci] |=measCb->measType; + break; + } + } + } + + if(((kwRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE)) + { +#ifdef LTE_L2_MEAS_RLC + if (measCb->measType & LKW_L2MEAS_ACT_UE) + { + if((kwRbCb->mode == CM_LTE_MODE_UM) && + (kwRbCb->dir & KW_DIR_DL )) + { + if (kwRbCb->m.um.umDl.sduQ.count) + { + if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0) + { + kwRbCb->ueCb->numActRb[kwRbCb->qci]++; + gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++; + } + } + } + else if (kwRbCb->mode == CM_LTE_MODE_AM) + { + if ((kwRbCb->m.am.amDl.cntrlBo) || + (kwRbCb->m.am.amDl.retxBo) || + (kwRbCb->m.am.amDl.bo)) + { + if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0) + { + kwRbCb->ueCb->numActRb[kwRbCb->qci]++; + gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++; + } + } + } + } +#endif + } + if((measCb->measType & LKW_L2MEAS_UL_IP)) + { + + for(ueIdx = 0; ueIdx < measCb->val.ipThMeas.numUes; ueIdx++) + { + if ((freeIdx == gCb->genCfg.maxUe) && + (measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid == FALSE)) + { + freeIdx = ueIdx; + continue; + } + if((measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId) == ueId) + { + break; + } + } + + if (ueIdx == measCb->val.ipThMeas.numUes) + { + if (gCb->genCfg.maxUe == measCb->val.ipThMeas.numUes) + { + RETVALUE(RFAILED); + } + if (gCb->genCfg.maxUe == freeIdx) + { + measCb->val.ipThMeas.numUes++; + } + else + { + ueIdx = freeIdx; + } + measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE; + cmMemset((U8 *)&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(KwL2Cntr) *LKW_MAX_QCI)); + measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci = 0; + } + measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = ueId; + measCb->val.ipThMeas.ueInfoLst[ueIdx].cellId = cellId; + numQci = &(measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci); + + for (qciIdx =0; qciIdx < *numQci; qciIdx++) + { + if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == kwRbCb->qci) + { + break; + } + } + + if (qciIdx == *numQci) + { + measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = kwRbCb->qci; + (*numQci)++; + } + + kwUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[kwRbCb->qci], + &kwRbCb->rbL2Cb, measCb->measType); + } + kwRbCb->rbL2Cb.measOn |= measCb->measType; + } + RETVALUE(ROK); +}/*kwAddToDlL2Meas*/ +#endif /*LTE_L2_MEAS*/ + +/** + * @brief + * This primitive fills the RbCb + * + * @param [in] gCb - RLC Instance Control Block + * @param [out] rbCb - RB Control Block + * @param [out] ueCb - UE Control Block + * @param [in] entCfg - RLC Entity configuration + * + * @return S16 + * -#ROK + * -#RFAILED + */ +#ifdef ANSI +PRIVATE S16 kwCfgFillUlRbCb +( +KwCb *gCb, +KwUlRbCb *rbCb, +KwUlUeCb *ueCb, +CkwEntCfgInfo *entCfg +) +#else +PRIVATE S16 kwCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg) +KwCb *gCb; +KwUlRbCb *rbCb; +KwUlUeCb *ueCb; +CkwEntCfgInfo *entCfg; +#endif +{ + TRC3(kwCfgFillUlRbCb) + + RLOG_ARG3(L_DEBUG,DBG_UEID,rbCb->rlcId.ueId, + "kwCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))", + rbCb->rlcId.cellId, + entCfg->rbId, + entCfg->rbType); + + /* Initialize according to entMode */ + switch (entCfg->entMode) + { + case CM_LTE_MODE_TM: + { + rbCb->lch.lChId = entCfg->lCh[0].lChId; + rbCb->lch.lChType = entCfg->lCh[0].type; + rbCb->dir = entCfg->dir; + break; + } + case CM_LTE_MODE_UM: + { + rbCb->lch.lChId = entCfg->lCh[0].lChId; + rbCb->lch.lChType = entCfg->lCh[0].type; + + rbCb->dir = entCfg->dir; + + rbCb->m.umUl.snLen = entCfg->m.umInfo.ul.snLen; + + /* the bitmask for SN = 10 is 0x3ff and for SN = 5 is 0x1f */ + rbCb->m.umUl.modBitMask = (rbCb->m.umUl.umWinSz << 1) - 1; + + rbCb->m.umUl.reOrdTmrInt = + entCfg->m.umInfo.ul.reOrdTmr; + cmInitTimers(&(rbCb->m.umUl.reOrdTmr), 1); + ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb; + break; + } + case CM_LTE_MODE_AM: + { + /* Down Link Information + * indx = 1 as Up Link */ + rbCb->lch.lChId = entCfg->lCh[1].lChId; + rbCb->lch.lChType = entCfg->lCh[1].type; + rbCb->dir = KW_DIR_BOTH; + + rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr; + rbCb->m.amUl.reOrdTmrInt = entCfg->m.amInfo.ul.reOrdTmr; + + rbCb->m.amUl.snLen = entCfg->m.amInfo.ul.snLen; /* 5GNR */ + + if(KW_AM_CFG_12BIT_SN_LEN == rbCb->m.amUl.snLen) + { + rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_12BITS) - 1; /* 5GNR */ + } + else + { + rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_18BITS) - 1; /* 5GNR */ + } + + cmInitTimers(&(rbCb->m.amUl.reOrdTmr), 1); + cmInitTimers(&(rbCb->m.amUl.staProhTmr), 1); + + rbCb->m.amUl.vrMr = rbCb->m.amUl.rxNext + (KW_AM_GET_WIN_SZ(rbCb->m.amUl.snLen)); + + ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb; + + break; + } + default: + { + RLOG_ARG2(L_ERROR,DBG_UEID,rbCb->rlcId.ueId, + "INVALID RB Mode cellId(%d), rbId(%d)", + rbCb->rlcId.cellId, + entCfg->rbId); + RETVALUE(RFAILED); + } + } + rbCb->mode = entCfg->entMode; + + RETVALUE(ROK); +} + + +/** + * @brief This primitive Initializes the RB Cb + * + * @param [in] gCb - RLC Instance Control Block + * @param [out] rbCb - RB Control Block + * @param [in] ptr - Void pointer + * @param [in] entCfg - Entity Configuration + * + * @return S16 + * -#ROK + * -#RFAILED + */ +#ifdef ANSI +PRIVATE S16 kwCfgUpdateUlRb +( +KwCb *gCb, +KwUlRbCb *rbCb, +void *ptr, +CkwEntCfgInfo *entCfg +) +#else +PRIVATE S16 kwCfgUpdateUlRb(gCb,rbCb, ptr, entCfg) +KwCb *gCb; +KwUlRbCb *rbCb; +void *ptr; +CkwEntCfgInfo *entCfg; +#endif +{ + TRC3(kwCfgUpdateUlRb) + + switch (rbCb->mode) + { + case CM_LTE_MODE_TM: + { + KwUlCellCb *cellCb = (KwUlCellCb *)ptr; + rbCb->dir = entCfg->dir; + rbCb->lch.lChId = entCfg->lCh[0].lChId; + rbCb->lch.lChType = entCfg->lCh[0].type; + + cellCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb; + break; + } + case CM_LTE_MODE_UM: + { + KwUlUeCb *ueCb = (KwUlUeCb *)ptr; + ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP; + kwCfgFillUlRbCb(gCb,rbCb, ueCb, entCfg); + break; + } + case CM_LTE_MODE_AM: + { + KwUlUeCb *ueCb = (KwUlUeCb *)ptr; + + ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = NULLP; + ueCb->lCh[entCfg->lCh[1].lChId - 1].ulRbCb = rbCb; + /* Up Link */ + rbCb->lch.lChId = entCfg->lCh[1].lChId; + rbCb->lch.lChType = entCfg->lCh[1].type; + rbCb->m.amUl.staProhTmrInt = entCfg->m.amInfo.ul.staProhTmr; + rbCb->m.amUl.reOrdTmrInt = entCfg->m.amInfo.ul.reOrdTmr; + break; + } + } + RETVALUE(CKW_CFG_REAS_NONE); +} + + +/** + * @brief + * This primitive validates uplink Add RB Configuration and reserve memory + * for RB creation. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] ueId - UE Identifier + * @param [in] cellId - CELL Identifier + * @param [in] cfgToValidate - Entity Configuration needs to be validated. + * @param [out] status - status of configuration + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC S16 kwValidateRbCfgParams +( +KwCb *gCb, +CmLteRnti ueId, +CmLteCellId cellId, +CkwEntCfgInfo *cfgToValidate, +CmStatus *status +) +#else +PUBLIC S16 kwValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status) +KwCb *gCb; +CmLteRnti ueId; +CmLteCellId cellId; +CkwEntCfgInfo *cfgToValidate; +CmStatus *status; +#endif +{ + if (cellId == 0) + { + status->reason = CKW_CFG_REAS_CELL_UNKWN; + RETVALUE (RFAILED); + } + if ((cfgToValidate->rguSapId >= gCb->genCfg.maxRguSaps) || (cfgToValidate->rguSapId < 0)) + { + KWDBGP_ERROR(gCb, "kwValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n", + ueId, cellId, cfgToValidate->rguSapId); + status->reason = CKW_CFG_REAS_INVALID_RGUSAP; + RETVALUE(RFAILED); + } + + if((CKW_CFG_ADD == cfgToValidate->cfgType) || + (CKW_CFG_MODIFY == cfgToValidate->cfgType)) + { + /* Validate LChId for UM and AM modes */ + if ((cfgToValidate->lCh[0].lChId <= 0) || + ((cfgToValidate->entMode == CM_LTE_MODE_AM) && + (cfgToValidate->lCh[1].lChId <= 0))) + { + status->reason = CKW_CFG_REAS_INVALID_LCHID; + RETVALUE(RFAILED); + } + if((cfgToValidate->entMode == CM_LTE_MODE_UM) && + (cfgToValidate->m.umInfo.ul.snLen != KW_UM_CFG_5BIT_SN_LEN) && + (cfgToValidate->m.umInfo.ul.snLen != KW_UM_CFG_10BIT_SN_LEN)) + { + RLOG_ARG2(L_ERROR,DBG_UEID,ueId, + "CellId[%u]:UM Mode RB[%d],Invalid SN Len[%d]", + cfgToValidate->rbId, + cfgToValidate->m.umInfo.ul.snLen); + status->reason = CKW_CFG_REAS_INVALID_SNLEN; + RETVALUE(RFAILED); + } + /* Process Adding new RB */ + if (ueId == 0) + { + if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL) + { + status->reason = CKW_CFG_REAS_RB_UNKWN; + RETVALUE(RFAILED); + } + + if ((cfgToValidate->lCh[0].type != CM_LTE_LCH_CCCH) && + (cfgToValidate->entMode != CM_LTE_MODE_TM)) + { + status->reason= (cfgToValidate->entMode != CM_LTE_MODE_TM)? CKW_CFG_REAS_RB_MODE_MIS: + CKW_CFG_REAS_LCHTYPE_MIS; + RETVALUE(RFAILED); + } + } + else + { + if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId))) + { + status->reason = CKW_CFG_REAS_RB_UNKWN; + RETVALUE(RFAILED); + } + + if(cfgToValidate->entMode == CM_LTE_MODE_TM) + { + status->reason = CKW_CFG_REAS_LCHTYPE_MIS; + RETVALUE(RFAILED); + } + if (!(((cfgToValidate->lCh[0].type == CM_LTE_LCH_DCCH) && + (cfgToValidate->entMode != CM_LTE_MODE_UM))|| + (cfgToValidate->lCh[0].type == CM_LTE_LCH_DTCH)) ) + { + status->reason = CKW_CFG_REAS_RB_MODE_MIS; + RETVALUE(RFAILED); + } + } + } + else /* cfgType is CKW_CFG_DELETE */ + { + if (ueId == 0) + { + if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL) + { + status->reason = CKW_CFG_REAS_RB_UNKWN; + RETVALUE(RFAILED); + } + + } + else + { + if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId))) + { + status->reason = CKW_CFG_REAS_RB_UNKWN; + RETVALUE(RFAILED); + } + } + } + RETVALUE(ROK); +} + + +/** + * @brief + * This primitive validates uplink Add RB Configuration and reserve memory + * for RB creation. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] cfgToValidate - Entity Configuration needs to be validated. + * @param [out] cfgEntData - Configuration Temporary Data Entity + * @param [out] cfgTmpData - Configuration Temporary Data + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC S16 kwCfgValidateUlRb +( +KwCb *gCb, +CkwEntCfgInfo *cfgToValidate, +KwUlEntTmpData *cfgEntData, +KwUlCfgTmpData *cfgTmpData +) +#else +PUBLIC S16 kwCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData) +KwCb *gCb; +CkwEntCfgInfo *cfgToValidate; +KwUlEntTmpData *cfgEntData; +KwUlCfgTmpData *cfgTmpData; +#endif +{ + TRC3(kwCfgValidateUlRb) + + RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId, + "cellId(%d), cfgType(%d)", + cfgTmpData->cellId, + cfgToValidate->cfgType); + + if(ROK != kwValidateRbCfgParams(gCb, + cfgTmpData->ueId, + cfgTmpData->cellId, + cfgToValidate, + &cfgEntData->entUlCfgCfm.status)) + { + RETVALUE(RFAILED); + } + + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_NONE; + switch(cfgToValidate->cfgType) + { + case CKW_CFG_ADD: + { + if (cfgTmpData->ueId == 0) + { + /* Cell Cb is added if it not present , it is not roll backed if the + * configuration fails */ + kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb); + if(!cfgTmpData->cellCb) + { + /* cell cb does not exist we need to create a new one */ + KW_ALLOC(gCb,cfgTmpData->cellCb, sizeof(KwUlCellCb)); + if(!cfgTmpData->cellCb) + { + RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId, + "Memory allocation failure CELLID:%d", + cfgTmpData->cellId); + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL; + RETVALUE(RFAILED); + } + kwDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb); + } + else + { + if (( cfgTmpData->cellCb->rbCb[cfgToValidate->rbId] != NULLP)) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;; + RETVALUE(RFAILED); + } + } + + KW_ALLOC(gCb,cfgEntData->rbCb, sizeof (KwUlRbCb)); + if (!cfgEntData->rbCb) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL; + RETVALUE(RFAILED); + } + } + else + { + /* Ue Cb is added if it not present , it is not roll backed if the + * configuration fails */ + kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb); + if(!cfgTmpData->ueCb) + { + KW_ALLOC(gCb,cfgTmpData->ueCb, sizeof(KwUlUeCb)); + if(!cfgTmpData->ueCb) + { + RLOG_ARG1(L_FATAL,DBG_UEID,cfgTmpData->ueId, + "Memory allocation failure CELLID:%d", + cfgTmpData->cellId); + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL; + RETVALUE(RFAILED); + } + kwDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb); + } + else + { + KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId, + cfgToValidate->rbType, + cfgTmpData->ueCb, + cfgEntData->rbCb); + if(cfgEntData->rbCb != NULLP) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;; + RETVALUE(RFAILED); + } + } + KW_ALLOC(gCb,cfgEntData->rbCb, sizeof (KwUlRbCb)); + if (!cfgEntData->rbCb) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_CREAT_FAIL; + RETVALUE(RFAILED); + } + } + /*Allocating the memory for receive buffer */ + if(CM_LTE_MODE_UM == cfgToValidate->entMode) + { + U16 winLen; + + + cfgEntData->rbCb->m.umUl.umWinSz = KW_POWER(2, + ((cfgToValidate->m.umInfo.ul.snLen *5)-1)); + winLen = cfgEntData->rbCb->m.umUl.umWinSz << 1; + KW_ALLOC(gCb, + cfgEntData->rbCb->m.umUl.recBuf, + (winLen * sizeof(KwUmRecBuf*))); + } + else if(CM_LTE_MODE_AM == cfgToValidate->entMode) + { +#ifndef LTE_TDD + U32 hashIndex; + KW_ALLOC(gCb, + cfgEntData->rbCb->m.amUl.recBufLst, + (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp ))); + for(hashIndex = 0; hashIndex < KW_RCV_BUF_BIN_SIZE; hashIndex++) + { + cmLListInit(&(cfgEntData->rbCb->m.amUl.recBufLst[hashIndex])); + } +#endif + } + break; + } + case CKW_CFG_MODIFY: + case CKW_CFG_DELETE: + { + if (cfgTmpData->ueId == 0) + { + /* Try to get the CellCb if it already exists */ + kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb); + if(!cfgTmpData->cellCb) + { + RLOG_ARG1(L_ERROR, DBG_CELLID,cfgTmpData->cellId, + "CellCb not found UEID:%d", + cfgTmpData->ueId); + /*how can a modify request come for a cell which does not exist*/ + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN; + RETVALUE(RFAILED); + } + + cfgEntData->rbCb = cfgTmpData->cellCb->rbCb[cfgToValidate->rbId]; + if (!cfgEntData->rbCb) + { + /* something is wrong the rbId for this cell does not exist */ + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN; + RETVALUE(RFAILED); + } + RETVALUE(ROK); + } + else + { + kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb); + if(!cfgTmpData->ueCb) + { + RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId, + "UeId [%d]: UeCb not found", + cfgTmpData->ueId); + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN; + RETVALUE(RFAILED); + } + + /* Get rbCb */ + KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId, + cfgToValidate->rbType, + cfgTmpData->ueCb, + cfgEntData->rbCb); + if ( cfgEntData->rbCb == NULLP) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN; + RETVALUE(RFAILED); + } + RETVALUE(ROK); + } + break; + } + } + + if(cfgToValidate->cfgType == CKW_CFG_MODIFY) + { + if(cfgToValidate->entMode != cfgEntData->rbCb->mode) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_MODE_MIS; + RETVALUE(RFAILED); + } + + if(cfgToValidate->m.umInfo.ul.snLen != cfgEntData->rbCb->m.umUl.snLen) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_SNLEN_MIS; + RETVALUE(RFAILED); + } + } + RETVALUE(ROK); +} + + +/** + * @brief + * This primitive roll back the RB Configuration + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] ueId - UE Identifier + * @param [in] cfg - Configuration entity. + * @param [out] cfgEntData - Configuration Temporary Data Entity + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC S16 kwCfgRollBackUlRb +( +KwCb *gCb, +CmLteRnti ueId, +CkwEntCfgInfo *cfg, +KwUlEntTmpData *cfgEntData +) +#else +PUBLIC S16 kwCfgRollBackUlRb(gCb, cfg, cfgEntData) +( +KwCb *gCb; +CmLteRnti ueId; +CkwEntCfgInfo *cfg; +KwUlEntTmpData *cfgEntData; +) +#endif +{ + TRC3(kwCfgRollBackUlRb) + + if(CKW_CFG_ADD == cfg->cfgType) + { + if(CM_LTE_MODE_UM == cfg->entMode) + { + KW_FREE(gCb, + cfgEntData->rbCb->m.umUl.recBuf, + (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(KwUmRecBuf*)); + } + else if(CM_LTE_MODE_AM == cfg->entMode) + { +#ifndef LTE_TDD + KW_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp))); +#endif + } + KW_FREE(gCb,cfgEntData->rbCb, sizeof(KwUlRbCb)); + } + + RETVALUE(ROK); +} + + +/** + * @brief + * This primitive apply RB Configuration. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] cfgToAply - Configuration to be applied + * @param [out] cfgEntData - Configuration Temporary Data Entity + * @param [out] cfgTmpData - Configuration Temporary Data + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC Void kwCfgApplyUlRb +( +KwCb *gCb, +CkwEntCfgInfo *cfgToAply, +KwUlEntTmpData *cfgEntData, +KwUlCfgTmpData *cfgTmpData +) +#else +PUBLIC Void kwCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData) +( +KwCb *gCb; +CkwEntCfgInfo *cfgToAply; +KwUlEntTmpData *cfgEntData; +KwUlCfgTmpData *cfgTmpData; +) +#endif +{ + TRC3(kwCfgApplyUlRb) + + switch(cfgToAply->cfgType) + { + case CKW_CFG_ADD: + { + /* copy the RB Cb into UeCb */ + cfgEntData->rbCb->rlcId.rbId = cfgToAply->rbId; + if (cfgTmpData->ueId == 0) + { + cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = cfgEntData->rbCb; + cfgTmpData->cellCb->lCh[cfgToAply->lCh[0].lChId -1].ulRbCb = cfgEntData->rbCb; + } + else + { + if(cfgToAply->rbType == CM_LTE_SRB) + { + cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = cfgEntData->rbCb; + } + else + { + cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = cfgEntData->rbCb; + } + } + + KW_LMM_RB_STS_INC(gCb); + + cfgEntData->rbCb->rlcId.cellId = cfgTmpData->cellId; + cfgEntData->rbCb->rlcId.ueId = cfgTmpData->ueId; + cfgEntData->rbCb->rlcId.rbType = cfgToAply->rbType; + cfgEntData->rbCb->inst = gCb->init.inst; + + /* Fill RB CB */ + kwCfgFillUlRbCb(gCb, + cfgEntData->rbCb, + cfgTmpData->ueCb, + cfgToAply); + +#ifdef LTE_L2_MEAS + cfgEntData->rbCb->qci = cfgToAply->qci; + cfgEntData->rbCb->ueCb = cfgTmpData->ueCb; + if (cfgToAply->lCh[1].type == CM_LTE_LCH_DTCH) + { + /* ccpu00129778 */ + kwAddToUlL2Meas(gCb, cfgEntData->rbCb, + cfgTmpData->cellId,cfgTmpData->ueId); + } +#endif /* LTE_L2_MEAS */ + break; + } + case CKW_CFG_MODIFY: + { + if(cfgTmpData->ueId == 0) + { + kwCfgUpdateUlRb(gCb, + cfgEntData->rbCb, + (void *)cfgTmpData->cellCb, + cfgToAply); + } + else + { + kwCfgUpdateUlRb(gCb, + cfgEntData->rbCb, + (void*)cfgTmpData->ueCb, + cfgToAply); + } + break; + } + case CKW_CFG_DELETE: + { + if (cfgTmpData->ueId == 0) + { + cfgTmpData->cellCb->rbCb[cfgToAply->rbId] = NULLP; + cfgTmpData->cellCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb = + NULLP; + } + else + { + cfgTmpData->ueCb->lCh[cfgEntData->rbCb->lch.lChId - 1].ulRbCb = + NULLP; + + /* Free the Buffers of RbCb */ + if( CM_LTE_MODE_UM == cfgEntData->rbCb->mode ) + { + kwUmmFreeUlRbCb(gCb, cfgEntData->rbCb); + } + else if(CM_LTE_MODE_AM == cfgEntData->rbCb->mode) + { + kwAmmFreeUlRbCb(gCb,cfgEntData->rbCb); + } + + /* Assign NULLP to rbCb in rbCbLst */ + if ( cfgToAply->rbType == CM_LTE_SRB ) + { + cfgTmpData->ueCb->srbCb[cfgToAply->rbId] = NULLP; + } + else + { + cfgTmpData->ueCb->drbCb[cfgToAply->rbId] = NULLP; + } + } + /* Delete RbCb */ + KW_FREE(gCb,cfgEntData->rbCb, sizeof(KwUlRbCb)); + + KW_LMM_RB_STS_DEC(gCb); + break; + } + } + RETVOID; +} + + +/** + * @brief + * This primitive validates uplink Delete UE request + * for RB creation. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] cfgToValidate - Entity Configuration to be validated. + * @param [out] cfgEntData - Configuration Temporary Data Entity + * @param [out] cfgTmpData - Configuration Temporary Data + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC S16 kwCfgValidateDelUlUe +( +KwCb *gCb, +CkwEntCfgInfo *cfgToValidate, +KwUlEntTmpData *cfgEntData, +KwUlCfgTmpData *cfgTmpData +) +#else +PUBLIC S16 kwCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData) +KwCb *gCb; +CkwEntCfgInfo *cfgToValidate; +KwUlEntTmpData *cfgEntData; +KwUlCfgTmpData *cfgTmpData; +#endif +{ + TRC3(kwCfgValidateDelUlUe) + + RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId, + "cellId(%d), cfgType(%d)", + cfgTmpData->cellId,cfgToValidate->cfgType); + + /* Check for ueId is present or not */ + if ( cfgTmpData->ueId == 0 ) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;; + RLOG_ARG1(L_ERROR,DBG_UEID,cfgTmpData->ueId, + "UeId is 0 for CELLID;%d", + cfgTmpData->cellId); + RETVALUE(RFAILED); + } + + /* Fetch Ue Cb */ + if(ROK != kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb)) + { + RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId, + "UeId [%d]: UeCb not found", + cfgTmpData->ueId); + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;; + RETVALUE(RFAILED); + } + RETVALUE(ROK); +} + + +/** + * @brief + * This primitive apply Uplink Delete Ue request + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] cfgTmpData - Configuration Temporary Data + * + * @return S16 + * -# ROK + */ +#ifdef ANSI +PUBLIC Void kwCfgApplyDelUlUe +( +KwCb *gCb, +KwUlCfgTmpData *cfgTmpData +) +#else +PUBLIC Void kwCfgApplyDelUlUe(gCb, cfgTmpData) +( +KwCb *gCb; +KwUlCfgTmpData *cfgTmpData; +) +#endif +{ + TRC3(kwCfgApplyDelUlUe) + +#ifdef LTE_L2_MEAS + kwDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId); +#endif + kwDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE); + RETVOID; +} + + +/** + * @brief + * This primitive validates uplink Delete UE request + * for RB creation. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] ueId - UE Identifier + * @param [in] cfgToValidate - Entity Configuration to be done. + * @param [in] cfgEntData - Configuration Temporary Data Entity + * @param [in] cfgTmpData - Configuration Temporary Data + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC S16 kwCfgValidateDelUlCell +( +KwCb *gCb, +CmLteCellId cellId, +CkwEntCfgInfo *cfgToValidate, +KwUlEntTmpData *cfgEntData, +KwUlCfgTmpData *cfgTmpData +) +#else +PUBLIC S16 kwCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData) +KwCb *gCb; +CmLteCellId cellId; +CkwEntCfgInfo *cfgToValidate; +KwUlEntTmpData *cfgEntData; +KwUlCfgTmpData *cfgTmpData; +#endif +{ + TRC3(kwCfgValidateDelUlCell) + + RLOG_ARG1(L_DEBUG,DBG_CELLID,cellId ,"cfgType(%d)", + cfgToValidate->cfgType); + + cfgTmpData->cellCb = NULLP; + + /* Check for cellId is present or not */ + if ( cellId == 0 ) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;; + RLOG_ARG0(L_ERROR,DBG_CELLID,cellId , "CellId is 0"); + RETVALUE(RFAILED); + } + + /* Fetch Cell Cb */ + kwDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb); + if (!cfgTmpData->cellCb) + { + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;; + RLOG_ARG0(L_ERROR, DBG_CELLID,cellId, "CellCb not found"); + RETVALUE(RFAILED); + } + RETVALUE(ROK); +} + + +/** + * @brief + * This primitive apply Uplink Delete Ue request + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] cfgEntData - Temporary Data maintained for a transaction + * + * @return S16 + * -# ROK + */ +#ifdef ANSI +PUBLIC Void kwCfgApplyDelUlCell +( +KwCb *gCb, +KwUlCfgTmpData *cfgInfo +) +#else +PUBLIC Void kwCfgApplyDelUlCell(gCb, cfgEntData) +( +KwCb *gCb; +KwUlCfgTmpData *cfgInfo; +) +#endif +{ + TRC3(kwCfgApplyDelUlCell) + + kwDbmDelUlCellCb(gCb,cfgInfo->cellCb); + RETVOID; +} + +/** + * @brief + * This primitive validates reestablishment of RB. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] ueId - UE Identifier + * @param [in] cellId - CELL Identifier + * @param [in] cfgToValidate - Entity Configuration to be done. + * @param [out] cfgEntData - Configuration Temporary Data Entity + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC S16 kwCfgValidateReEstRb +( +KwCb *gCb, +CmLteRnti ueId, +CmLteCellId cellId, +CkwEntCfgInfo *cfgToValidate, +KwUlEntTmpData *cfgEntData +) +#else +PUBLIC S16 kwCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData) +KwCb *gCb; +CmLteRnti ueId; +CmLteCellId cellId; +CkwEntCfgInfo *cfgToValidate; +KwUlEntTmpData *cfgEntData; +#endif +{ + CmLteRlcId rlcId; /* RLC Identifier */ + TRC3(kwCfgValidateReEstRb) + + RLOG_ARG2(L_DEBUG, DBG_UEID,ueId, + "cellId(%d) RBID:%d", + cellId, + cfgToValidate->rbId); + + /* Get rlcId */ + rlcId.ueId = ueId; + rlcId.cellId = cellId; + rlcId.rbId = cfgToValidate->rbId; + rlcId.rbType = cfgToValidate->rbType; + + kwDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb); + if (cfgEntData->rbCb == NULLP) + { + RLOG_ARG2(L_WARNING, DBG_UEID,ueId, + "CellId [%u]: rbId [%d] not found", + cellId, + cfgToValidate->rbId); + cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_UNKWN; + RETVALUE(RFAILED); + } + + RETVALUE(ROK); +} + + + +/** + * @brief + * This primitive apply reestablishment of RB. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] ueId - UE Identifier + * @param [in] cellId - CELL Identifier + * @param [in] sndReEstInd - ReEstablish Indication Flag + * @param [in] cfgEntData - Configuration Temporary Data Entity + * + * @return S16 + * -# ROK + */ +#ifdef ANSI +PUBLIC Void kwCfgApplyReEstUlRb +( +KwCb *gCb, +CmLteRnti ueId, +CmLteCellId cellId, +Bool sndReEstInd, +KwUlEntTmpData *cfgEntData +) +#else +PUBLIC Void kwCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData) +( +KwCb *gCb; +CmLteRnti ueId; +CmLteCellId cellId; +Bool sndReEstInd; +KwUlEntTmpData *cfgEntData; +) +#endif +{ + CmLteRlcId rlcId; /* RLC Identifier */ + TRC3(kwCfgApplyReEstUlRb) + + rlcId.ueId = ueId; + rlcId.cellId = cellId; + rlcId.rbId = cfgEntData->entUlCfgCfm.rbId; + rlcId.rbType = cfgEntData->entUlCfgCfm.rbType; + cfgEntData->rbCb->rlcId.ueId = ueId; + switch (cfgEntData->rbCb->mode) + { + case CM_LTE_MODE_TM: + { + kwTmmUlReEstablish(gCb,cfgEntData->rbCb); + break; + } + + case CM_LTE_MODE_UM: + { + kwUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb); + break; + } + + case CM_LTE_MODE_AM: + { + kwAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb); + break; + } + } + RETVOID; +} + +/** + * @brief + * This primitive validates reestablishment of RB. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] ueInfo - UE Identifier + * @param [in] newUeInfo - CELL Identifier + * @param [in] cfgTmpData - Configuration Temporary Data + * + * @return S16 + * -# ROK + * -# RFAILED + */ +#ifdef ANSI +PUBLIC S16 kwCfgValidateUeIdChng +( +KwCb *gCb, +CkwUeInfo *ueInfo, +CkwUeInfo *newUeInfo, +KwUlCfgTmpData *cfgTmpData +) +#else +PUBLIC S16 kwCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData) +KwCb *gCb; +CkwUeInfo *ueInfo; +CkwUeInfo *newUeInfo; +KwUlCfgTmpData *cfgTmpData; +#endif +{ + KwUlUeCb *ueCb; + TRC3(kwCfgValidateUeIdChng) + +#define CFM_STATUS cfgTmpData->cfgEntData[0].entUlCfgCfm.status + if ( (ueInfo->ueId == newUeInfo->ueId) && + (ueInfo->cellId == newUeInfo->cellId)) + { + CFM_STATUS.reason = CKW_CFG_REAS_SAME_UEID; + CFM_STATUS.status = CKW_CFG_CFM_NOK; + RETVALUE(RFAILED); + } + + if(ROK == kwDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb)) + { + RLOG_ARG1(L_ERROR, DBG_CELLID, newUeInfo->cellId, + "NewUeId[%d]:ueCb already exists", + newUeInfo->ueId); + CFM_STATUS.reason = CKW_CFG_REAS_UE_EXISTS; + CFM_STATUS.status = CKW_CFG_CFM_NOK; + RETVALUE(RFAILED); + } + + if(ROK != kwDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId, + &cfgTmpData->ueCb)) + { + RLOG_ARG1(L_ERROR,DBG_CELLID, ueInfo->cellId, + "UeId [%d]: UeCb not found", + ueInfo->ueId); + CFM_STATUS.reason = CKW_CFG_REAS_UE_UNKWN; + CFM_STATUS.status = CKW_CFG_CFM_NOK; + RETVALUE(RFAILED); + } +#undef CFM_STATUS + RETVALUE(ROK); +} + + + +/** + * @brief + * This primitive apply reestablishment of RB. + * + * @param [in] gCb - RLC Instance Control Block + * @param [in] ueInfo - UE Identifier + * @param [in] newUeInfo - CELL Identifier + * @param [in] cfgTmpData - Configuration Temporary Data + * + * @return S16 + * -# ROK + */ +#ifdef ANSI +PUBLIC Void kwCfgApplyUlUeIdChng +( +KwCb *gCb, +CkwUeInfo *ueInfo, +CkwUeInfo *newUeInfo, +KwUlCfgTmpData *cfgTmpData +) +#else +PUBLIC Void kwCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData) +( +KwCb *gCb; +CkwUeInfo *ueInfo, +CkwUeInfo *newUeInfo, +KwUlCfgTmpData *cfgTmpData; +) +#endif +{ + TRC3(kwCfgApplyUlUeIdChng) + +#ifdef LTE_L2_MEAS + kwHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId); +#endif + cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) cfgTmpData->ueCb); + /* update the hash key with new values */ + cfgTmpData->ueCb->ueId = newUeInfo->ueId; + cfgTmpData->ueCb->cellId =newUeInfo->cellId; + if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp), + (PTR)cfgTmpData->ueCb, + (U8 *)&(cfgTmpData->ueCb->ueId), + (U16) sizeof(CmLteRnti))) + + { + RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId, + "UeId[%u] HashList Insertion Failed", + newUeInfo->ueId); + } + + RETVOID; +} +/********************************************************************30** + + End of file +**********************************************************************/