#include "l2_tenb_stats.x" /* Total EnodeB Stats declarations */
#endif
#endif
-PUBLIC S16 kwValidateRbCfgParams (RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
+S16 rlcValidateRbCfgParams (RlcCb *gCb, CmLteRnti ueId, CmLteCellId cellId,
RlcEntCfgInfo *cfgToValidate, CmStatus *status);
-#define KW_MODULE KW_DBGMASK_CFG
+#define RLC_MODULE RLC_DBGMASK_CFG
#ifdef LTE_L2_MEAS
/**
*
* -# RFAILED
*
*/
-PRIVATE S16 kwHdlMeasUlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
+PRIVATE S16 rlcHdlMeasUlUeIdChg(RlcCb *gCb, uint8_t cellId,uint8_t oldUeId, uint8_t newUeId)
{
- KwL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 ueIdx = 0;
+ RlcL2MeasCb *measCb = NULLP;
+ uint16_t cntr;
+ uint16_t ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
+ measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
if( measCb->measType & LKW_L2MEAS_UL_IP)
{
* -# RFAILED
*
*/
-PRIVATE S16 kwDelFrmUlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
+PRIVATE S16 rlcDelFrmUlL2Meas(RlcCb *gCb, uint8_t cellId,uint8_t ueId)
{
- KwL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 ueIdx = 0;
+ RlcL2MeasCb *measCb = NULLP;
+ uint16_t cntr;
+ uint16_t ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
+ measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
if( measCb->measType & LKW_L2MEAS_UL_IP)
{
- U32 myIdx =0;
+ uint32_t myIdx =0;
S16 ret; /* Return value */
RlcUlUeCb *ueCb = NULL;
for (myIdx = 0; myIdx < measCb->val.ipThMeas.numUes; myIdx++)
{
ueCb = NULL;
- ret = kwDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb);
+ ret = rlcDbmFetchUlUeCb(gCb, measCb->val.ipThMeas.ueInfoLst[myIdx].ueId, cellId, &ueCb);
}
}
}
-PRIVATE S16 kwAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *kwRbCb,U8 cellId,U8 ueId)
+PRIVATE S16 rlcAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *rlcRbCb,uint8_t cellId,uint8_t ueId)
{
- KwL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 cntr1;
- U16 ueIdx = 0;
- U16 qciIdx = 0;
- U16 *numQci;
+ RlcL2MeasCb *measCb = NULLP;
+ uint16_t cntr;
+ uint16_t cntr1;
+ uint16_t ueIdx = 0;
+ uint16_t qciIdx = 0;
+ uint16_t *numQci;
#ifndef XEON_SPECIFIC_CHANGES
- U8 freeIdx = gCb->genCfg.maxUe;
+ uint8_t freeIdx = gCb->genCfg.maxUe;
#else
- U16 freeIdx = LKW_MAX_UE;
+ uint16_t freeIdx = LKW_MAX_UE;
#endif
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
- measCb = &(gCb->u.ulCb->kwL2Cb.kwL2EvtCb[cntr].measCb);
+ measCb = &(gCb->u.ulCb->rlcL2Cb.rlcL2EvtCb[cntr].measCb);
freeIdx = gCb->genCfg.maxUe;
{
for(cntr1 =0;cntr1<measCb->val.nonIpThMeas.numQci;cntr1++)
{
- if(measCb->val.nonIpThMeas.qci[cntr1] != kwRbCb->qci)
+ if(measCb->val.nonIpThMeas.qci[cntr1] != rlcRbCb->qci)
{
- measCb->val.nonIpThMeas.qci[cntr1] = kwRbCb->qci;
- gCb->u.ulCb->kwL2Cb.measOn[kwRbCb->qci] |=measCb->measType;
+ measCb->val.nonIpThMeas.qci[cntr1] = rlcRbCb->qci;
+ gCb->u.ulCb->rlcL2Cb.measOn[rlcRbCb->qci] |=measCb->measType;
break;
}
}
}
- if(((kwRbCb->rbL2Cb.measOn & measCb->measType) == LKW_L2MEAS_NONE))
+ if(((rlcRbCb->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((rlcRbCb->mode == CM_LTE_MODE_UM) &&
+ (rlcRbCb->dir & RLC_DIR_DL ))
{
- if (kwRbCb->m.um.umDl.sduQ.count)
+ if (rlcRbCb->m.um.umDl.sduQ.count)
{
- if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
+ if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
{
- kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
- gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++;
+ rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
+ gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
}
}
}
- else if (kwRbCb->mode == CM_LTE_MODE_AM)
+ else if (rlcRbCb->mode == CM_LTE_MODE_AM)
{
- if ((kwRbCb->m.am.amDl.cntrlBo) ||
- (kwRbCb->m.am.amDl.retxBo) ||
- (kwRbCb->m.am.amDl.bo))
+ if ((rlcRbCb->m.am.amDl.cntrlBo) ||
+ (rlcRbCb->m.am.amDl.retxBo) ||
+ (rlcRbCb->m.am.amDl.bo))
{
- if (kwRbCb->ueCb->numActRb[kwRbCb->qci] == 0)
+ if (rlcRbCb->ueCb->numActRb[rlcRbCb->qci] == 0)
{
- kwRbCb->ueCb->numActRb[kwRbCb->qci]++;
- gCb->u.ulCb->kwL2Cb.numActUe[kwRbCb->qci]++;
+ rlcRbCb->ueCb->numActRb[rlcRbCb->qci]++;
+ gCb->u.ulCb->rlcL2Cb.numActUe[rlcRbCb->qci]++;
}
}
}
ueIdx = freeIdx;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].isValid = TRUE;
- cmMemset((U8 *)&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(KwL2Cntr) *LKW_MAX_QCI));
+ memset(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[0],0x00,(sizeof(RlcL2Cntr) *LKW_MAX_QCI));
measCb->val.ipThMeas.ueInfoLst[ueIdx].numQci = 0;
}
measCb->val.ipThMeas.ueInfoLst[ueIdx].ueId = ueId;
for (qciIdx =0; qciIdx < *numQci; qciIdx++)
{
- if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == kwRbCb->qci)
+ if (measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] == rlcRbCb->qci)
{
break;
}
if (qciIdx == *numQci)
{
- measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = kwRbCb->qci;
+ measCb->val.ipThMeas.ueInfoLst[ueIdx].qci[qciIdx] = rlcRbCb->qci;
(*numQci)++;
}
\f
- kwUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[kwRbCb->qci],
- &kwRbCb->rbL2Cb, measCb->measType);
+ rlcUtlPlcMeasDatInL2Sts(&measCb->val.ipThMeas.ueInfoLst[ueIdx].measData[rlcRbCb->qci],
+ &rlcRbCb->rbL2Cb, measCb->measType);
}
- kwRbCb->rbL2Cb.measOn |= measCb->measType;
+ rlcRbCb->rbL2Cb.measOn |= measCb->measType;
}
- return ROK;
-}/*kwAddToDlL2Meas*/
+ return (ROK);
+}/*rlcAddToDlL2Meas*/
#endif /*LTE_L2_MEAS*/
\f
/**
RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(rlcCfgFillUlRbCb)
RLOG_ARG3(L_DEBUG,DBG_UEID,rbCb->rlcId.ueId,
"rlcCfgFillRbCb(cellId(%d), rbId(%d), rbType(%d))",
* 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->dir = RLC_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)
+ if(RLC_AM_CFG_12BIT_SN_LEN == rbCb->m.amUl.snLen)
{
- rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_12BITS) - 1; /* 5GNR */
+ rbCb->m.amUl.snModMask = (1 << RLC_SN_LEN_12BITS) - 1; /* 5GNR */
}
else
{
- rbCb->m.amUl.snModMask = (1 << KW_SN_LEN_18BITS) - 1; /* 5GNR */
+ rbCb->m.amUl.snModMask = (1 << RLC_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));
+ rbCb->m.amUl.vrMr = rbCb->m.amUl.rxNext + (RLC_AM_GET_WIN_SZ(rbCb->m.amUl.snLen));
ueCb->lCh[rbCb->lch.lChId - 1].ulRbCb = rbCb;
RlcEntCfgInfo *entCfg;
#endif
{
- TRC3(rlcCfgUpdateUlRb)
switch (rbCb->mode)
{
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 kwValidateRbCfgParams
+S16 rlcValidateRbCfgParams
(
RlcCb *gCb,
CmLteRnti ueId,
CmStatus *status
)
#else
-PUBLIC S16 kwValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status)
+S16 rlcValidateRbCfgParams(gCb,ueId, cellId, cfgToValidate, status)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
}
if ((cfgToValidate->rguSapId >= gCb->genCfg.maxRguSaps) || (cfgToValidate->rguSapId < 0))
{
- KWDBGP_ERROR(gCb, "kwValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
+ RLCDBGP_ERROR(gCb, "rlcValidateRbCfgParams ueId (%u) cellId (%u) Invalid rguSapId (%d))\n",
ueId, cellId, cfgToValidate->rguSapId);
status->reason = CKW_CFG_REAS_INVALID_RGUSAP;
return RFAILED;
return 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))
+ (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_5BIT_SN_LEN) &&
+ (cfgToValidate->m.umInfo.ul.snLen != RLC_UM_CFG_10BIT_SN_LEN))
{
RLOG_ARG2(L_ERROR,DBG_UEID,ueId,
"CellId[%u]:UM Mode RB[%d],Invalid SN Len[%d]",
/* Process Adding new RB */
if (ueId == 0)
{
- if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
+ if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
}
else
{
- if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
{
if (ueId == 0)
{
- if(cfgToValidate->rbId >= KW_MAX_RB_PER_CELL)
+ if(cfgToValidate->rbId >= RLC_MAX_RB_PER_CELL)
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
}
else
{
- if (!(KW_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
+ if (!(RLC_VALIDATE_UE_RBID(cfgToValidate->rbType, cfgToValidate->rbId)))
{
status->reason = CKW_CFG_REAS_RB_UNKWN;
return RFAILED;
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateUlRb
+S16 rlcCfgValidateUlRb
(
RlcCb *gCb,
RlcEntCfgInfo *cfgToValidate,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
+S16 rlcCfgValidateUlRb(gCb,cfgToValidate, cfgEntData, cfgTmpData)
RlcCb *gCb;
RlcEntCfgInfo *cfgToValidate;
RlcUlEntTmpData *cfgEntData;
RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(rlcCfgValidateUlRb)
RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
"cellId(%d), cfgType(%d)",
cfgTmpData->cellId,
cfgToValidate->cfgType);
- if(ROK != kwValidateRbCfgParams(gCb,
+ if(ROK != rlcValidateRbCfgParams(gCb,
cfgTmpData->ueId,
cfgTmpData->cellId,
cfgToValidate,
{
/* Cell Cb is added if it not present , it is not roll backed if the
* configuration fails */
- kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
+ rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
if(!cfgTmpData->cellCb)
{
/* cell cb does not exist we need to create a new one */
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_CREAT_FAIL;
return RFAILED;
}
- kwDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
+ rlcDbmAddUlCellCb(gCb, cfgTmpData->cellId, cfgTmpData->cellCb);
}
else
{
if (( cfgTmpData->cellCb->rbCb[cfgToValidate->rbId] != NULLP))
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;
return RFAILED;
}
}
{
/* 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);
+ rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
if(!cfgTmpData->ueCb)
{
RLC_ALLOC(gCb,cfgTmpData->ueCb, sizeof(RlcUlUeCb));
cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_CREAT_FAIL;
return RFAILED;
}
- kwDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
+ rlcDbmAddUlUeCb(gCb, cfgTmpData->ueId, cfgTmpData->cellId, cfgTmpData->ueCb);
}
else
{
- KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
+ RLC_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;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;
return RFAILED;
}
}
/*Allocating the memory for receive buffer */
if(CM_LTE_MODE_UM == cfgToValidate->entMode)
{
- U16 winLen;
+ uint16_t winLen;
- cfgEntData->rbCb->m.umUl.umWinSz = KW_POWER(2,
+ cfgEntData->rbCb->m.umUl.umWinSz = RLC_POWER(2,
((cfgToValidate->m.umInfo.ul.snLen *5)-1));
winLen = cfgEntData->rbCb->m.umUl.umWinSz << 1;
RLC_ALLOC(gCb,
cfgEntData->rbCb->m.umUl.recBuf,
- (winLen * sizeof(KwUmRecBuf*)));
+ (winLen * sizeof(RlcUmRecBuf*)));
}
else if(CM_LTE_MODE_AM == cfgToValidate->entMode)
{
#ifndef LTE_TDD
- U32 hashIndex;
+ uint32_t hashIndex;
RLC_ALLOC(gCb,
cfgEntData->rbCb->m.amUl.recBufLst,
- (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
- for(hashIndex = 0; hashIndex < KW_RCV_BUF_BIN_SIZE; hashIndex++)
+ (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
+ for(hashIndex = 0; hashIndex < RLC_RCV_BUF_BIN_SIZE; hashIndex++)
{
cmLListInit(&(cfgEntData->rbCb->m.amUl.recBufLst[hashIndex]));
}
if (cfgTmpData->ueId == 0)
{
/* Try to get the CellCb if it already exists */
- kwDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
+ rlcDbmFetchUlCellCb(gCb,cfgTmpData->cellId, &cfgTmpData->cellCb);
if(!cfgTmpData->cellCb)
{
RLOG_ARG1(L_ERROR, DBG_CELLID,cfgTmpData->cellId,
}
else
{
- kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
+ rlcDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb);
if(!cfgTmpData->ueCb)
{
RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
}
/* Get rbCb */
- KW_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
+ RLC_DBM_GET_RBCB_FROM_UECB(cfgToValidate->rbId,
cfgToValidate->rbType,
cfgTmpData->ueCb,
cfgEntData->rbCb);
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgRollBackUlRb
+S16 rlcCfgRollBackUlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC S16 rlcCfgRollBackUlRb(gCb, cfg, cfgEntData)
+S16 rlcCfgRollBackUlRb(gCb, cfg, cfgEntData)
(
RlcCb *gCb;
CmLteRnti ueId;
)
#endif
{
- TRC3(rlcCfgRollBackUlRb)
if(CKW_CFG_ADD == cfg->cfgType)
{
{
RLC_FREE(gCb,
cfgEntData->rbCb->m.umUl.recBuf,
- (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(KwUmRecBuf*));
+ (cfgEntData->rbCb->m.umUl.umWinSz << 1) * sizeof(RlcUmRecBuf*));
}
else if(CM_LTE_MODE_AM == cfg->entMode)
{
#ifndef LTE_TDD
- RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (KW_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
+ RLC_FREE(gCb,cfgEntData->rbCb->m.amUl.recBufLst, (RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp)));
#endif
}
RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyUlRb
+Void rlcCfgApplyUlRb
(
RlcCb *gCb,
RlcEntCfgInfo *cfgToAply,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void rlcCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
+Void rlcCfgApplyUlRb(gCb, cfgToApply, cfgEntData, cfgTmpData)
(
RlcCb *gCb;
RlcEntCfgInfo *cfgToAply;
)
#endif
{
- TRC3(rlcCfgApplyUlRb)
switch(cfgToAply->cfgType)
{
}
}
- KW_LMM_RB_STS_INC(gCb);
+ RLC_LMM_RB_STS_INC(gCb);
cfgEntData->rbCb->rlcId.cellId = cfgTmpData->cellId;
cfgEntData->rbCb->rlcId.ueId = cfgTmpData->ueId;
if (cfgToAply->lCh[1].type == CM_LTE_LCH_DTCH)
{
/* ccpu00129778 */
- kwAddToUlL2Meas(gCb, cfgEntData->rbCb,
+ rlcAddToUlL2Meas(gCb, cfgEntData->rbCb,
cfgTmpData->cellId,cfgTmpData->ueId);
}
#endif /* LTE_L2_MEAS */
/* Free the Buffers of RbCb */
if( CM_LTE_MODE_UM == cfgEntData->rbCb->mode )
{
- kwUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
+ rlcUmmFreeUlRbCb(gCb, cfgEntData->rbCb);
}
else if(CM_LTE_MODE_AM == cfgEntData->rbCb->mode)
{
- kwAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
+ rlcAmmFreeUlRbCb(gCb,cfgEntData->rbCb);
}
/* Assign NULLP to rbCb in rbCbLst */
/* Delete RbCb */
RLC_FREE(gCb,cfgEntData->rbCb, sizeof(RlcUlRbCb));
- KW_LMM_RB_STS_DEC(gCb);
+ RLC_LMM_RB_STS_DEC(gCb);
break;
}
}
- RETVOID;
+ return;
}
\f
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateDelUlUe
+S16 rlcCfgValidateDelUlUe
(
RlcCb *gCb,
RlcEntCfgInfo *cfgToValidate,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
+S16 rlcCfgValidateDelUlUe(gCb,cfgToValidate, cfgEntData,cfgTmpData)
RlcCb *gCb;
RlcEntCfgInfo *cfgToValidate;
RlcUlEntTmpData *cfgEntData;
RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(rlcCfgValidateDelUlUe)
RLOG_ARG2(L_DEBUG,DBG_UEID,cfgTmpData->ueId,
"cellId(%d), cfgType(%d)",
/* Check for ueId is present or not */
if ( cfgTmpData->ueId == 0 )
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;;
+ 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);
}
/* Fetch Ue Cb */
- if(ROK != kwDbmFetchUlUeCb(gCb,cfgTmpData->ueId, cfgTmpData->cellId, &cfgTmpData->ueCb))
+ if(ROK != rlcDbmFetchUlUeCb(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;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
return RFAILED;
}
return ROK;
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyDelUlUe
+Void rlcCfgApplyDelUlUe
(
RlcCb *gCb,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void rlcCfgApplyDelUlUe(gCb, cfgTmpData)
+Void rlcCfgApplyDelUlUe(gCb, cfgTmpData)
(
RlcCb *gCb;
RlcUlCfgTmpData *cfgTmpData;
)
#endif
{
- TRC3(rlcCfgApplyDelUlUe)
#ifdef LTE_L2_MEAS
- kwDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
+ rlcDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
#endif
- kwDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
- RETVOID;
+ rlcDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
+ return;
}
\f
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateDelUlCell
+S16 rlcCfgValidateDelUlCell
(
RlcCb *gCb,
CmLteCellId cellId,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
+S16 rlcCfgValidateDelUlCell(gCb, cellId, cfgToValidate, cfgTmpData)
RlcCb *gCb;
CmLteCellId cellId;
RlcEntCfgInfo *cfgToValidate;
RlcUlCfgTmpData *cfgTmpData;
#endif
{
- TRC3(rlcCfgValidateDelUlCell)
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellId ,"cfgType(%d)",
cfgToValidate->cfgType);
/* Check for cellId is present or not */
if ( cellId == 0 )
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
RLOG_ARG0(L_ERROR,DBG_CELLID,cellId , "CellId is 0");
return RFAILED;
}
/* Fetch Cell Cb */
- kwDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
+ rlcDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
if (!cfgTmpData->cellCb)
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
RLOG_ARG0(L_ERROR, DBG_CELLID,cellId, "CellCb not found");
return RFAILED;
}
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyDelUlCell
+Void rlcCfgApplyDelUlCell
(
RlcCb *gCb,
RlcUlCfgTmpData *cfgInfo
)
#else
-PUBLIC Void rlcCfgApplyDelUlCell(gCb, cfgEntData)
+Void rlcCfgApplyDelUlCell(gCb, cfgEntData)
(
RlcCb *gCb;
RlcUlCfgTmpData *cfgInfo;
)
#endif
{
- TRC3(rlcCfgApplyDelUlCell)
- kwDbmDelUlCellCb(gCb,cfgInfo->cellCb);
- RETVOID;
+ rlcDbmDelUlCellCb(gCb,cfgInfo->cellCb);
+ return;
}
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateReEstRb
+S16 rlcCfgValidateReEstRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC S16 rlcCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
+S16 rlcCfgValidateReEstRb(gCb,ueId, cellId, cfgToValidate, cfgEntData)
RlcCb *gCb;
CmLteRnti ueId;
CmLteCellId cellId;
#endif
{
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(rlcCfgValidateReEstRb)
RLOG_ARG2(L_DEBUG, DBG_UEID,ueId,
"cellId(%d) RBID:%d",
rlcId.rbId = cfgToValidate->rbId;
rlcId.rbType = cfgToValidate->rbType;
- kwDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
+ rlcDbmFetchUlRbCbByRbId(gCb,&rlcId, &cfgEntData->rbCb);
if (cfgEntData->rbCb == NULLP)
{
RLOG_ARG2(L_WARNING, DBG_UEID,ueId,
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyReEstUlRb
+Void rlcCfgApplyReEstUlRb
(
RlcCb *gCb,
CmLteRnti ueId,
RlcUlEntTmpData *cfgEntData
)
#else
-PUBLIC Void rlcCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
+Void rlcCfgApplyReEstUlRb(gCb, ueId, cellId, sndReEstInd, cfgEntData)
(
RlcCb *gCb;
CmLteRnti ueId;
#endif
{
CmLteRlcId rlcId; /* RLC Identifier */
- TRC3(rlcCfgApplyReEstUlRb)
rlcId.ueId = ueId;
rlcId.cellId = cellId;
{
case CM_LTE_MODE_TM:
{
- kwTmmUlReEstablish(gCb,cfgEntData->rbCb);
+ rlcTmmUlReEstablish(gCb,cfgEntData->rbCb);
break;
}
case CM_LTE_MODE_UM:
{
- kwUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
+ rlcUmmUlReEstablish(gCb,&rlcId,cfgEntData->rbCb);
break;
}
case CM_LTE_MODE_AM:
{
- kwAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
+ rlcAmmUlReEstablish(gCb,rlcId,sndReEstInd,cfgEntData->rbCb);
break;
}
}
- RETVOID;
+ return;
}
\f
/**
* -# RFAILED
*/
#ifdef ANSI
-PUBLIC S16 rlcCfgValidateUeIdChng
+S16 rlcCfgValidateUeIdChng
(
RlcCb *gCb,
CkwUeInfo *ueInfo,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC S16 rlcCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
+S16 rlcCfgValidateUeIdChng(gCb,ueInfo,newUeInfo,cfgTmpData)
RlcCb *gCb;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
#endif
{
RlcUlUeCb *ueCb;
- TRC3(rlcCfgValidateUeIdChng)
#define CFM_STATUS cfgTmpData->cfgEntData[0].entUlCfgCfm.status
if ( (ueInfo->ueId == newUeInfo->ueId) &&
return RFAILED;
}
- if(ROK == kwDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
+ if(ROK == rlcDbmFetchUlUeCb(gCb,newUeInfo->ueId, newUeInfo->cellId, &ueCb))
{
RLOG_ARG1(L_ERROR, DBG_CELLID, newUeInfo->cellId,
"NewUeId[%d]:ueCb already exists",
return RFAILED;
}
- if(ROK != kwDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
+ if(ROK != rlcDbmFetchUlUeCb(gCb,ueInfo->ueId, ueInfo->cellId,
&cfgTmpData->ueCb))
{
RLOG_ARG1(L_ERROR,DBG_CELLID, ueInfo->cellId,
* -# ROK
*/
#ifdef ANSI
-PUBLIC Void rlcCfgApplyUlUeIdChng
+Void rlcCfgApplyUlUeIdChng
(
RlcCb *gCb,
CkwUeInfo *ueInfo,
RlcUlCfgTmpData *cfgTmpData
)
#else
-PUBLIC Void rlcCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
+Void rlcCfgApplyUlUeIdChng(gCb, ueId, cellId, cfgTmpData)
(
RlcCb *gCb;
CkwUeInfo *ueInfo,
)
#endif
{
- TRC3(rlcCfgApplyUlUeIdChng)
#ifdef LTE_L2_MEAS
- kwHdlMeasUlUeIdChg(gCb, ueInfo->cellId, ueInfo->ueId, newUeInfo->ueId);
+ rlcHdlMeasUlUeIdChg(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->cellId =newUeInfo->cellId;
if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp),
(PTR)cfgTmpData->ueCb,
- (U8 *)&(cfgTmpData->ueCb->ueId),
- (U16) sizeof(CmLteRnti)))
+ (uint8_t *)&(cfgTmpData->ueCb->ueId),
+ (uint16_t) sizeof(CmLteRnti)))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId,
newUeInfo->ueId);
}
- RETVOID;
+ return;
}
/********************************************************************30**
Code Review / o-du / l2.git / blobdiff