ueCfg->spCellCfg.servCellCfg.pdschServCellCfg.numHarqProcForPdsch;
}
- if(ueCfg->crnti)
- ueCb->state = UE_STATE_ACTIVE;
- else
- ueCb->state = UE_HANDIN_IN_PROGRESS;
-
/*TODO: To check the bsr value during implementation */
if(ueCfg->macCellGrpCfgPres)
{
uint8_t updateMacRaCb(uint16_t cellIdx, MacUeCb *ueCb)
{
- uint8_t ueIdx;
/* Copy RA Cb */
- for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ if(macCb.macCell[cellIdx]->macRaCb[ueCb->ueId-1].crnti == ueCb->crnti)
{
- if(macCb.macCell[cellIdx]->macRaCb[ueIdx].crnti == ueCb->crnti)
- {
- ueCb->raCb = &macCb.macCell[cellIdx]->macRaCb[ueIdx];
- break;
- }
+ ueCb->raCb = &macCb.macCell[cellIdx]->macRaCb[ueCb->ueId-1];
+ }
+ else
+ {
+ DU_LOG("\nERROR --> MAC : No RA CB found for UE ID [%d]", ueCb->ueId);
+ return RFAILED;
}
return ROK;
}
}
else
{
- if(ueCb->state == UE_STATE_ACTIVE)
+ /* If UE has not requested for RACH yet, it means UE context is created for a
+ * UE in handover */
+ if(macCb.macCell[cellIdx]->macRaCb[ueCb->ueId-1].crnti == ueCb->crnti)
{
+ ueCb->state = UE_STATE_ACTIVE;
macCb.macCell[cellIdx]->numActvUe++;
updateMacRaCb(cellIdx, ueCb);
}
+ else
+ ueCb->state = UE_HANDIN_IN_PROGRESS;
+
return ROK;
}
-
}
-
+ return ROK;
}
/*******************************************************************
memset(ueCb, 0, sizeof(SchUeCb));
ueCb->ueId = ueCfg->ueId;
ueCb->crnti = ueCfg->crnti;
- if(ueCb->crnti)
- ueCb->state = SCH_UE_STATE_ACTIVE;
- else
- ueCb->state = SCH_UE_HANDIN_IN_PROGRESS;
ret = fillSchUeCb(inst, ueCb, ueCfg);
if(ret == ROK)
{
- if(ueCb->state == SCH_UE_STATE_ACTIVE)
+ /* If UE has initiated RACH and then UE context is created, it means UE is
+ * active now.
+ * Else if UE context is created before RACH, this means that UE is being
+ * handed-in from source DU */
+ if(cellCb->raCb[ueCb->ueId-1].tcrnti == ueCb->crnti)
{
cellCb->numActvUe++;
SET_ONE_BIT(ueCb->ueId, cellCb->actvUeBitMap);
+ ueCb->state = SCH_UE_STATE_ACTIVE;
}
+ else
+ ueCb->state = SCH_UE_HANDIN_IN_PROGRESS;
+
ueCb->cellCb = cellCb;
ueCb->srRcvd = false;
ueCb->bsrRcvd = false;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildULTnlInfo(TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
+uint8_t BuildULTnlInfo(uint8_t duId, TnlInfo *ulUpTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, bool hoInProgress)
{
uint8_t idx;
uint8_t ulCnt;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildDRBSetup(CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
+uint8_t BuildDRBSetup(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetup_List_t *drbSet)
{
uint8_t idx = 0, extIeIdx = 0;
uint8_t elementCnt = 0, drbCnt = 0;
/*ULUPTNLInformation To Be Setup List*/
if(ueCb->state != UE_HANDOVER_IN_PROGRESS)
- BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
+ BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
FALSE);
else
- BuildULTnlInforet = BuildULTnlInfo(&ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
+ BuildULTnlInforet = BuildULTnlInfo(duId, &ueCb->drbList[idx].ulUpTnlInfo, &drbSetItem->uLUPTNLInformation_ToBeSetup_List,\
TRUE);
if(BuildULTnlInforet != ROK)
{
ueSetReq->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_DRBs_ToBeSetup_List;
ueSetReq->protocolIEs.list.array[idx]->criticality = Criticality_reject;
ueSetReq->protocolIEs.list.array[idx]->value.present = UEContextSetupRequestIEs__value_PR_DRBs_ToBeSetup_List;
- ret1 = BuildDRBSetup(ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
+ ret1 = BuildDRBSetup(duId, ueCb, &ueSetReq->protocolIEs.list.array[idx]->value.choice.DRBs_ToBeSetup_List);
if(ret1 != ROK)
{
break;
* RFAILED - failure
*
* ****************************************************************/
-uint8_t addDrbTunnels(uint8_t teId)
+uint8_t addDrbTunnels(uint32_t duId, uint8_t teId)
{
uint8_t ret = ROK;
EgtpTnlEvt tnlEvt;
tnlEvt.action = EGTP_TNL_MGMT_ADD;
tnlEvt.lclTeid = teId;
tnlEvt.remTeid = teId;
- ret = cuEgtpTnlMgmtReq(tnlEvt);
+ ret = cuEgtpTnlMgmtReq(duId, tnlEvt);
if(ret != ROK)
{
DU_LOG("\nERROR --> EGTP : Tunnel management request failed for teId %x", teId);
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procDrbSetupList(DRBs_Setup_List_t *drbSetupList)
+uint8_t procDrbSetupList(uint32_t duId, DRBs_Setup_List_t *drbSetupList)
{
uint8_t arrIdx = 0;
uint32_t teId = 0;
teId = extractTeId(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
if(teId > 0)
{
- if(addDrbTunnels(teId)== ROK)
+ if(addDrbTunnels(duId, teId)== ROK)
{
DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
}
* ****************************************************************/
uint8_t procUeContextSetupResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
{
- uint8_t duIdx=0, idx, duUeF1apId;
- DuDb *duDb;
- CuUeCb *ueCb;
+ uint8_t duIdx = 0, idx = 0, ueIdx = 0;
+ uint8_t duUeF1apId = 0, cuUeF1apId = 0;
+ DuDb *duDb = NULLP;
+ CuUeCb *ueCb = NULLP;
UEContextSetupResponse_t *ueCtxtSetupRsp = NULLP;
SEARCH_DU_DB(duIdx, duId, duDb);
{
switch(ueCtxtSetupRsp->protocolIEs.list.array[idx]->id)
{
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ {
+ cuUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
+ break;
+ }
case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
{
duUeF1apId = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
ueCb = &duDb->ueCb[duUeF1apId-1];
+ /* If ue context is not present in du db, then create UE context
+ * here. This flow is hit in case of UE handover where UE
+ * context is created before UE performs RACH on target DU */
+ if(ueCb->gnbDuUeF1apId == 0)
+ {
+ /* Creating UE context in target DU */
+ memset(ueCb, 0, sizeof(CuUeCb));
+ ueCb->cellCb = &duDb->cellCb[0];
+ ueCb->gnbDuUeF1apId = duUeF1apId;
+ ueCb->gnbCuUeF1apId = cuUeF1apId;
+ ueCb->state = UE_HANDOVER_IN_PROGRESS;
+ ueCb->hoInfo.targetDuId = duId;
+ (duDb->numUe)++;
+
+ ueCb->cellCb->ueCb[ueCb->cellCb->numUe] = ueCb;
+ ueCb->cellCb->numUe++;
+ }
+ break;
+ }
+ case ProtocolIE_ID_id_C_RNTI:
+ {
+ ueCb->crnti = ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI;
break;
}
case ProtocolIE_ID_id_DRBs_Setup_List:
{
/* Adding Tunnels for successful DRB */
- procDrbSetupList(&ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
+ procDrbSetupList(duId, &ueCtxtSetupRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
break;
}
case ProtocolIE_ID_id_DUtoCURRCInformation:
}
}
}
+
ueCb->f1apMsgDb.dlRrcMsgCount++; /* keeping DL RRC Msg Count */
+
+ /* If the UE is in handover, UE context modification request is to be sent to
+ * source DU once UE context setup response is received from target DU */
+ if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
+ {
+ DuDb *srcDuDb = NULLP;
+ CuUeCb *ueCbInSrcDu = NULLP;
+
+ /* Since Source DU Id and DU UE F1AP ID assigned to UE by source DU is not known here, we
+ * need to find Source DU and UE CB in source DU using CU UE F1AP ID */
+ for(duIdx=0; duIdx < cuCb.numDu; duIdx++)
+ {
+ /* UE context setup response is received from target DU. Search all
+ * DUs to find source DU except this target DU Id.*/
+ if(cuCb.duInfo[duIdx].duId != duId)
+ {
+ for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ {
+ /* Check following:
+ * 1. CU UE F1AP ID in srcDU->ueCb should be same as cuUeF1apId
+ * received in UE context setup response since CU UE F1AP ID does not
+ * change for UE in handover.
+ * 2. srcDU->UeCb->uestate should be UE_HANDOVER_IN_PROGRESS
+ */
+ if((cuCb.duInfo[duIdx].ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId) &&
+ (cuCb.duInfo[duIdx].ueCb[ueIdx].state == UE_HANDOVER_IN_PROGRESS))
+ {
+ srcDuDb = &cuCb.duInfo[duIdx];
+ ueCbInSrcDu = &cuCb.duInfo[duIdx].ueCb[ueIdx];
+
+ /* Store source DU info in the new UE context created in
+ * tareget DU */
+ ueCb->hoInfo.sourceDuId = srcDuDb->duId;
+ if(BuildAndSendUeContextModificationReq(srcDuDb->duId, ueCbInSrcDu, STOP_DATA_TX) != ROK)
+ {
+ DU_LOG("\nERROR -> F1AP : Failed at BuildAndSendUeContextModificationReq()");
+ return RFAILED;
+ }
+ break;
+ }
+ }
+ }
+ if(srcDuDb && ueCbInSrcDu)
+ break;
+ }
+ }
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t deleteEgtpTunnel(uint8_t *buf)
+uint8_t deleteEgtpTunnel(uint32_t duId, uint8_t *buf)
{
uint32_t teId = 0;
EgtpTnlEvt tnlEvt;
tnlEvt.action = EGTP_TNL_MGMT_DEL;
tnlEvt.lclTeid = teId;
tnlEvt.remTeid = teId;
- if((cuEgtpTnlMgmtReq(tnlEvt)) != ROK)
+ if((cuEgtpTnlMgmtReq(duId, tnlEvt)) != ROK)
{
DU_LOG("\nERROR --> EGTP : Failed to delete tunnel Id %d", teId);
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildUlTnlInfoforSetupMod(uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
+uint8_t BuildUlTnlInfoforSetupMod(uint32_t duId, uint8_t ueId, uint8_t drbId, TnlInfo *ulTnlInfo, ULUPTNLInformation_ToBeSetup_List_t *ulInfo, uint8_t actionType)
{
uint8_t arrIdx;
uint8_t ulCnt;
*
* ****************************************************************/
-uint8_t FillDrbItemToSetupMod(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
+uint8_t FillDrbItemToSetupMod(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeSetupMod_Item_t *drbItem)
{
uint8_t ret = ROK;
}
/*ULUPTNLInformation To Be Setup List*/
- ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
+ ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &ueCb->drbList[ueCb->numDrb].ulUpTnlInfo, \
&drbItem->uLUPTNLInformation_ToBeSetup_List, ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item);
if(ret != ROK)
{
*
* ****************************************************************/
-uint8_t FillDrbItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
+uint8_t FillDrbItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe)
{
drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeSetupMod_Item;
drbItemIe->criticality = Criticality_reject;
drbItemIe->value.present = DRBs_ToBeSetupMod_ItemIEs__value_PR_DRBs_ToBeSetupMod_Item;
- if(FillDrbItemToSetupMod(ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
+ if(FillDrbItemToSetupMod(duId, ueCb, arrIdx, (&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item))) != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbItemToSetupMod failed");
return RFAILED;
*
* ****************************************************************/
-uint8_t BuildDrbToBeSetupList(CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
+uint8_t BuildDrbToBeSetupList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeSetupMod_List_t *drbSet)
{
uint8_t ret = ROK;
uint8_t arrIdx =0;
return RFAILED;
}
- ret = FillDrbItemList(ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
+ ret = FillDrbItemList(duId, ueCb, arrIdx, (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbItemList failed");
*
* ****************************************************************/
-uint8_t FillDrbToBeModItem(CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
+uint8_t FillDrbToBeModItem(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, DRBs_ToBeModified_Item_t *drbItem)
{
uint8_t ret = ROK;
uint drbIdx=0;
}/* End of QoS */
/*ULUPTNLInformation To Be Setup List*/
- ret = BuildUlTnlInfoforSetupMod(ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
+ ret = BuildUlTnlInfoforSetupMod(duId, ueCb->gnbCuUeF1apId, drbItem->dRBID, &drbToBeMod->ulUpTnlInfo, &drbItem->uLUPTNLInformation_ToBeSetup_List,\
ProtocolIE_ID_id_DRBs_ToBeModified_Item);
if(ret != ROK)
{
*
* ****************************************************************/
-uint8_t FillDrbToBeModItemList(CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
+uint8_t FillDrbToBeModItemList(uint32_t duId, CuUeCb *ueCb, uint8_t arrIdx, struct DRBs_ToBeModified_ItemIEs *drbItemIe)
{
drbItemIe->id = ProtocolIE_ID_id_DRBs_ToBeModified_Item;
drbItemIe->criticality = Criticality_reject;
drbItemIe->value.present = DRBs_ToBeModified_ItemIEs__value_PR_DRBs_ToBeModified_Item;
- if(FillDrbToBeModItem(ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
+ if(FillDrbToBeModItem(duId, ueCb, arrIdx, &(drbItemIe->value.choice.DRBs_ToBeModified_Item)) != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbToBeModItem failed");
return RFAILED;
*
* ****************************************************************/
-uint8_t BuildDrbToBeModifiedList(CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
+uint8_t BuildDrbToBeModifiedList(uint32_t duId, CuUeCb *ueCb, DRBs_ToBeModified_List_t *drbSet)
{
uint8_t ret = ROK;
uint8_t arrIdx =0;
return RFAILED;
}
- ret = FillDrbToBeModItemList(ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
+ ret = FillDrbToBeModItemList(duId, ueCb, arrIdx, (DRBs_ToBeModified_ItemIEs_t *)drbSet->list.array[arrIdx]);
if(ret != ROK)
{
DU_LOG("\nERROR --> F1AP : FillDrbToBeModItemList failed");
CuUeCb *ueCb = (CuUeCb *)cuUeCb;
F1AP_PDU_t *f1apMsg = NULLP;
UEContextModificationRequest_t *ueContextModifyReq = NULLP;
- action =RESTART_DATA_TX;
asn_enc_rval_t encRetVal;
DU_LOG("\nINFO --> F1AP : Building Ue context modification request\n");
while(1)
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List;
- ret = BuildDrbToBeSetupList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
+ ret = BuildDrbToBeSetupList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
value.choice.DRBs_ToBeSetupMod_List));
/* DRB to be modified list */
ueContextModifyReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present =\
UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List;
- ret = BuildDrbToBeModifiedList(ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
+ ret = BuildDrbToBeModifiedList(duId, ueCb, &(ueContextModifyReq->protocolIEs.list.array[ieIdx]->\
value.choice.DRBs_ToBeModified_List));
/* TODO: DRB to be release list */
{
SEARCH_DU_DB(duIdx, duId, duDb);
SEARCH_CELL_DB(cellIdx, duDb, nrCellId, cellCb);
- for(ueIdx = 0; ueIdx < cellCb->numUe; ueIdx++)
+ if(cellCb->numUe == 0)
{
- CU_FREE(cellCb->ueCb[ueIdx]->f1apMsgDb.duToCuContainer.buf, cellCb->ueCb[ueIdx]->f1apMsgDb.duToCuContainer.size);
- memset(cellCb->ueCb[ueIdx], 0, sizeof(CuUeCb));
+ memset(cellCb, 0, sizeof(CuCellCb));
+ duDb->numCells--;
}
+ else
+ cellCb->cellStatus = CELL_DELETION_IN_PROGRESS;
}
-
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t procDrbSetupModList(CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
+uint8_t procDrbSetupModList(uint32_t duId, CuUeCb *ueCb, DRBs_SetupMod_List_t *drbSetupList)
{
uint8_t arrIdx = 0, drbIdx;
uint32_t teId = 0;
teId = extractTeId(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
if(teId > 0)
{
- if(addDrbTunnels(teId)== ROK)
+ if(addDrbTunnels(duId, teId)== ROK)
{
DU_LOG("\nDEBUG --> EGTP: Tunnel Added for TeId %d", teId);
}
* ****************************************************************/
uint8_t procUeContextModificationResponse(uint32_t duId, F1AP_PDU_t *f1apMsg)
{
- uint8_t idx=0, duIdx=0, duUeF1apId;
- DuDb *duDb;
- CuUeCb *ueCb;
+ uint8_t idx=0, duIdx=0;
+ uint8_t duUeF1apId = 0, cuUeF1apId = 0;
+ DuDb *duDb = NULLP;
+ CuUeCb *ueCb = NULLP;
UEContextModificationResponse_t *ueCtxtModRsp = NULLP;
SEARCH_DU_DB(duIdx, duId, duDb);
{
switch(ueCtxtModRsp->protocolIEs.list.array[idx]->id)
{
+ case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
+ {
+ cuUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
+ break;
+ }
case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
{
duUeF1apId = ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
case ProtocolIE_ID_id_DRBs_SetupMod_List:
{
/* Adding Tunnels for successful DRB */
- procDrbSetupModList(ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
+ procDrbSetupModList(duId, ueCb, &ueCtxtModRsp->protocolIEs.list.array[idx]->value.choice.DRBs_SetupMod_List);
break;
}
}
}
+
+ /* If UE is in handover and UE context is not yet created at target DU, then send
+ * UE context setup request to target DU */
if(ueCb->state == UE_HANDOVER_IN_PROGRESS)
{
- BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb, 0, NULLP);
- return ROK;
+ uint8_t ueIdx = 0;
+ DuDb *tgtDuDb = NULLP;
+ CuUeCb *ueCbInTgtDu = NULLP;
+
+ SEARCH_DU_DB(duIdx, ueCb->hoInfo.targetDuId, tgtDuDb);
+ if(tgtDuDb)
+ {
+ /* Since DU UE F1AP ID assigned by target DU to this UE in handover is
+ * not known here, using CU UE F1AP ID to search for UE Cb in target DU
+ * DB */
+ for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
+ {
+ if(tgtDuDb->ueCb[ueIdx].gnbCuUeF1apId == cuUeF1apId)
+ {
+ ueCbInTgtDu = &tgtDuDb->ueCb[ueIdx];
+ break;
+ }
+ }
+
+ /* If UE context is not found in Target DU DU, send UE context setup
+ * request */
+ if(ueCbInTgtDu == NULLP)
+ {
+ if((BuildAndSendUeContextSetupReq(ueCb->hoInfo.targetDuId, ueCb, 0, NULLP)) != ROK)
+ {
+ DU_LOG("\nERROR -> F1AP : Failed at BuildAndSendUeContextSetupReq");
+ return RFAILED;
+ }
+ }
+ }
}
return ROK;
cellCb = &duDb->cellCb[duDb->numCells];
memset(cellCb, 0, sizeof(CuCellCb));
cellCb->nrCellId = nrCellId;
+ cellCb->cellStatus = CELL_ACTIVE;
duDb->numCells++;
}
}
{
gnbDuUeF1apId = ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
ueCb = &duDb->ueCb[gnbDuUeF1apId-1];
-
- for(ueIdx = 0; ueIdx < ueCb->cellCb->numUe; ueIdx++)
+ for(ueIdx = 0; ueIdx <MAX_NUM_UE; ueIdx++)
{
- if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
- (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
+ if(ueCb->cellCb && ueCb->cellCb->ueCb[ueIdx])
{
- ueCb->cellCb->ueCb[ueIdx] = NULLP;
- ueCb->cellCb->numUe--;
- break;
-
+ if((ueCb->cellCb->ueCb[ueIdx]->gnbCuUeF1apId == gnbCuUeF1apId) &&
+ (ueCb->cellCb->ueCb[ueIdx]->gnbDuUeF1apId == gnbDuUeF1apId))
+ {
+ ueCb->cellCb->ueCb[ueIdx] = NULLP;
+ ueCb->cellCb->numUe--;
+ if((ueCb->cellCb->numUe == 0) && (ueCb->cellCb->cellStatus = CELL_DELETION_IN_PROGRESS))
+ {
+ memset(ueCb->cellCb, 0, sizeof(CuCellCb));
+ duDb->numCells--;
+ }
+ break;
+ }
}
}
memset(ueCb, 0, sizeof(CuUeCb));
void readCuCfg()
{
- uint8_t *numDu;
+ uint8_t numDu;
uint32_t ipv4_du, ipv4_cu;
DU_LOG("\nDEBUG --> CU_STUB : Reading CU configurations");
cuCb.cuCfgParams.sctpParams.numDu = 1;
#else
cuCb.cuCfgParams.sctpParams.numDu = 0;
- numDu = &cuCb.cuCfgParams.sctpParams.numDu;
- while(*numDu < MAX_DU_SUPPORTED)
+ cuCb.cuCfgParams.egtpParams.numDu = 0;
+ numDu = 0;
+ while(numDu < MAX_DU_SUPPORTED)
{
/* DU IP Address and Port*/
memset(&ipv4_du, 0, sizeof(uint32_t));
- cmInetAddr((S8*)DU_IP_V4_ADDR[*numDu], &ipv4_du);
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duIpAddr.ipV4Addr = ipv4_du;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duIpAddr.ipV6Pres = false;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].duPort = DU_SCTP_PORT[*numDu];
+ cmInetAddr((S8*)DU_IP_V4_ADDR[numDu], &ipv4_du);
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duIpAddr.ipV4Addr = ipv4_du;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duIpAddr.ipV6Pres = false;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].duPort = DU_SCTP_PORT[numDu];
/* CU IP Address and Port*/
memset(&ipv4_du, 0, sizeof(uint32_t));
cmInetAddr((S8*)CU_IP_V4_ADDR, &ipv4_cu);
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuIpAddr.ipV4Addr = ipv4_cu;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuIpAddr.ipV6Pres = false;
- cuCb.cuCfgParams.sctpParams.sctpAssoc[*numDu].cuPort = CU_SCTP_PORT_TO_DU[*numDu];
- (*numDu)++;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuIpAddr.ipV4Addr = ipv4_cu;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuIpAddr.ipV6Pres = false;
+ cuCb.cuCfgParams.sctpParams.sctpAssoc[numDu].cuPort = CU_SCTP_PORT_TO_DU[numDu];
+
+ /* EGTP Parameters */
+ memset(&ipv4_du, 0, sizeof(uint32_t));
+ cmInetAddr((S8*)DU_IP_V4_ADDR[numDu], &ipv4_du);
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localIp.ipV4Pres = TRUE;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localIp.ipV4Addr = ipv4_cu;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].localPort = CU_EGTP_PORT[numDu];
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destIp.ipV4Pres = TRUE;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destIp.ipV4Addr = ipv4_du;
+ cuCb.cuCfgParams.egtpParams.egtpAssoc[numDu].destPort = DU_EGTP_PORT[numDu];
+
+ (numDu)++;
}
+ cuCb.cuCfgParams.egtpParams.minTunnelId = MIN_TEID;
+ cuCb.cuCfgParams.egtpParams.currTunnelId = cuCb.cuCfgParams.egtpParams.minTunnelId;
+ cuCb.cuCfgParams.egtpParams.maxTunnelId = MAX_TEID;
+ cuCb.cuCfgParams.egtpParams.numDu = numDu;
+ cuCb.cuCfgParams.sctpParams.numDu = numDu;
#endif
/*PLMN*/
cuCb.cuCfgParams.rrcVersion.extRrcVer = EXT_RRC_VER;
- /* EGTP Parameters */
- cuCb.cuCfgParams.egtpParams.localIp.ipV4Pres = TRUE;
- cuCb.cuCfgParams.egtpParams.localIp.ipV4Addr = ipv4_cu;
- cuCb.cuCfgParams.egtpParams.localPort = CU_EGTP_PORT;
- cuCb.cuCfgParams.egtpParams.destIp.ipV4Pres = TRUE;
- cuCb.cuCfgParams.egtpParams.destIp.ipV4Addr = ipv4_du;
- cuCb.cuCfgParams.egtpParams.destPort = DU_EGTP_PORT;
- cuCb.cuCfgParams.egtpParams.minTunnelId = MIN_TEID;
- cuCb.cuCfgParams.egtpParams.currTunnelId = cuCb.cuCfgParams.egtpParams.minTunnelId;
- cuCb.cuCfgParams.egtpParams.maxTunnelId = MAX_TEID;
} /* End of readCuCfg */
* NUM_TUNNEL_TO_PUMP_DATA = 9, NUM_DL_PACKETS = 1.
* totalDataPacket = totalNumOfTestFlow * NUM_TUNNEL_TO_PUMP_DATA * NUM_DL_PACKETS
* totalDataPacket = [500*9*1] */
- int32_t totalNumOfTestFlow = 500;
+ int32_t totalNumOfTestFlow = 5;
while(true)
{
#define CU_SCTP_PORT_TO_DU (int[]){38472, 38473}
#endif
-#define DU_EGTP_PORT 39001
-#define CU_EGTP_PORT 39002
+#define DU_EGTP_PORT (int[]){39001, 39002}
+#define CU_EGTP_PORT (int[]){39003, 39004}
#define RRC_VER 0
#define EXT_RRC_VER 5
#define PLMN_MCC0 3
}\
}
+typedef enum
+{
+ CELL_INACTIVE,
+ CELL_ACTIVE,
+ CELL_DELETION_IN_PROGRESS
+}CellStatusInfo;
typedef enum
{
char cuName[CU_DU_NAME_LEN_MAX];
CuSctpParams sctpParams;
Plmn plmn;
- EgtpParams egtpParams;
+ CuEgtpParams egtpParams;
RrcVersion rrcVersion;
}CuCfgParams;
uint32_t nrCellId;
uint8_t numUe;
CuUeCb *ueCb[MAX_NUM_UE];
+ CellStatusInfo cellStatus;
};
typedef struct duDb
uint8_t egtpInitReq()
{
uint8_t ret = ROK;
-
+
+ egtpCb.egtpCfg = cuCb.cuCfgParams.egtpParams;
ret = cuEgtpCfgReq();
if(ret != ROK)
{
* ***********************************************************************/
S16 cuEgtpCfgReq()
{
- uint8_t ret;
-
- memcpy(&egtpCb.egtpCfg, &cuCb.cuCfgParams.egtpParams, sizeof(EgtpParams));
-
- egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
+ uint8_t ret, destIdx =0;
+
+ memcpy(&egtpCb.egtpCfg, &cuCb.cuCfgParams.egtpParams, sizeof(CuEgtpParams));
+
+ for(destIdx=0; destIdx < egtpCb.egtpCfg.numDu; destIdx++)
+ {
+ egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].localIp.ipV4Addr);
+ egtpCb.recvTptSrvr.addr.port = EGTP_RECVR_PORT;
- egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
- egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
- egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort;
- egtpCb.dstCb.numTunn = 0;
+ egtpCb.dstCb[destIdx].duId = destIdx+1;
+ egtpCb.dstCb[destIdx].dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].destIp.ipV4Addr);
+ egtpCb.dstCb[destIdx].dstPort = egtpCb.egtpCfg.egtpAssoc[destIdx].destPort;
+ egtpCb.dstCb[destIdx].sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[destIdx].localIp.ipV4Addr);
+ egtpCb.dstCb[destIdx].sendTptSrvr.addr.port = egtpCb.egtpCfg.egtpAssoc[destIdx].localPort;
+ egtpCb.dstCb[destIdx].numTunn = 0;
- ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL);
+ ret = cmHashListInit(&(egtpCb.dstCb[destIdx].teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL);
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed");
- return RFAILED;
- }
- else
- {
- DU_LOG("\nINFO --> EGTP : Configuration successful");
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : TeId hash list initialization failed");
+ return RFAILED;
+ }
+ else
+ {
+ DU_LOG("\nINFO --> EGTP : Configuration successful");
+ }
}
+ egtpCb.numDu = egtpCb.egtpCfg.numDu;
return ROK;
} /* cuEgtpCfgReq */
S16 cuEgtpSrvOpenReq(Pst *pst)
{
- uint8_t ret;
+ uint8_t ret, destIdx;
DU_LOG("\nINFO --> EGTP : Received open server request");
-
+
sockType = CM_INET_DGRAM;
if((ret = (cmInetSocket(sockType, &(egtpCb.recvTptSrvr.sockFd), protType))) != ROK)
{
DU_LOG("\nERROR --> EGTP : Failed to bind socket");
return RFAILED;
}
+
+ for(destIdx=0; destIdx < egtpCb.egtpCfg.numDu; destIdx++)
+ {
+ if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb[destIdx].sendTptSrvr.sockFd), protType)) != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to open UDP socket");
+ return RFAILED;
+ }
- if(ret = (cmInetSocket(sockType, &(egtpCb.dstCb.sendTptSrvr.sockFd), protType)) != ROK)
- {
- DU_LOG("\nERROR --> EGTP : Failed to open UDP socket");
- return RFAILED;
- }
-
- ret = cmInetBind(&(egtpCb.dstCb.sendTptSrvr.sockFd), &(egtpCb.dstCb.sendTptSrvr.addr));
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> EGTP : Failed to bind socket");
- return RFAILED;
- }
-
- /* TODO: set socket options */
+ ret = cmInetBind(&(egtpCb.dstCb[destIdx].sendTptSrvr.sockFd), &(egtpCb.dstCb[destIdx].sendTptSrvr.addr));
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to bind socket");
+ return RFAILED;
+ }
- DU_LOG("\nINFO --> EGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd,\
- egtpCb.dstCb.sendTptSrvr.sockFd.fd);
+ /* TODO: set socket options */
+
+ DU_LOG("\nINFO --> EGTP : Receiver socket[%d] and Sender socket[%d] open", egtpCb.recvTptSrvr.sockFd.fd,\
+ egtpCb.dstCb[destIdx].sendTptSrvr.sockFd.fd);
+ }
return ROK;
} /* cuEgtpSrvOpenReq */
*
* ***************************************************************************/
-S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlMgmtReq(uint32_t duId, EgtpTnlEvt tnlEvt)
{
S8 ret;
{
case EGTP_TNL_MGMT_ADD:
{
- ret = cuEgtpTnlAdd(tnlEvt);
+ ret = cuEgtpTnlAdd(duId, tnlEvt);
break;
}
case EGTP_TNL_MGMT_MOD:
{
- ret = cuEgtpTnlMod(tnlEvt);
+ ret = cuEgtpTnlMod(duId, tnlEvt);
break;
}
case EGTP_TNL_MGMT_DEL:
{
- ret = cuEgtpTnlDel(tnlEvt);
+ ret = cuEgtpTnlDel(duId, tnlEvt);
break;
}
default:
* RFAILED - failure
*
* ***************************************************************************/
-S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlAdd(uint32_t duId, EgtpTnlEvt tnlEvt)
{
S16 ret;
EgtpTeIdCb *teidCb;
return RFAILED;
}
-
memset(teidCb, 0, sizeof(EgtpTeIdCb));
teidCb->teId = tnlEvt.lclTeid;
teidCb->remTeId = tnlEvt.remTeid;
- ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
+ ret = cmHashListInsert(&(egtpCb.dstCb[duId-1].teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
if(ret != ROK)
{
DU_LOG("\nERROR --> EGTP : Failed to insert in hash list");
CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
return RFAILED;
}
- egtpCb.dstCb.numTunn++;
+ egtpCb.dstCb[duId-1].numTunn++;
/* Encoding pre-defined header */
memset(&preDefHdr, 0, sizeof(EgtpMsgHdr));
* RFAILED - failure
*
* ***************************************************************************/
-S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlMod(uint32_t duId, EgtpTnlEvt tnlEvt)
{
#if 0
S16 ret;
DU_LOG("\nDEBUG --> CU_STUB : Tunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nDEBUG --> CU_STUBTunnel id not found");
* RFAILED - failure
*
* ***************************************************************************/
-S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt)
+S16 cuEgtpTnlDel(uint32_t duId, EgtpTnlEvt tnlEvt)
{
EgtpTeIdCb *teidCb = NULLP;
DU_LOG("\nDEBUG --> EGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
return RFAILED;
}
- cmHashListDelete(&(egtpCb.dstCb.teIdLst), (PTR)teidCb);
+ cmHashListDelete(&(egtpCb.dstCb[duId-1].teIdLst), (PTR)teidCb);
CU_FREE(teidCb, (Size)sizeof(EgtpTeIdCb));
- egtpCb.dstCb.numTunn--;
+ egtpCb.dstCb[duId-1].numTunn--;
return ROK;
} /* cuEgtpTnlDel */
} /* egtpEncodeHdr */
+/*******************************************************************
+ *
+ * @brief This handles the any EGTP received message
+ *
+ * @details
+ *
+ * Function : cuEgtpHdlRecvMsg
+ *
+ * Functionality:
+ * This handles the any EGTP received message
+ *
+ * @params[in] Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
S16 cuEgtpHdlRecvMsg(Buffer *mBuf)
{
/*Decoding of EGTP message header */
}
+/*******************************************************************
+ *
+ * @brief Decodes message header
+ *
+ * @details
+ *
+ * Function : cuEgtpDecodeHdr
+ *
+ * Functionality:
+ * Decodes EGTP message haeder
+ *
+ * @params[in] Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
S16 cuEgtpDecodeHdr(Buffer *mBuf)
{
EgtpMsg egtpMsg;
} /* End of cuEgtpDecodeHdr */
+/*******************************************************************
+ *
+ * @brief This function is responsible to build application message, encode EGTP
+ * header to it and send to DU over tunnel (teId)
+ *
+ * @details
+ *
+ * Function : cuEgtpDatReq
+ *
+ * Functionality:
+ * function is responsible to build application message, encode EGTP
+ * header to it and send to DU over tunnel (teId)
+ *
+ * @params[in] uint8_t teId
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
uint16_t cuEgtpDatReq(uint8_t teId)
{
- uint8_t ret = ROK, cnt = 0;
+ uint8_t ret = ROK, cnt = 0, duId =0;
EgtpMsg egtpMsg;
egtpMsg.msgHdr.teId = teId;
DU_LOG("\nERROR --> EGTP : DRB not created");
return RFAILED ;
}
- /* Build Application message that is supposed to come from app to egtp */
- ret = BuildAppMsg(&egtpMsg);
- if(ret != ROK)
+ for(duId = 1; duId<=egtpCb.numDu; duId++)
{
- DU_LOG("\nERROR --> EGTP : Failed to build App Msg");
- return RFAILED;
- }
+ /* Build Application message that is supposed to come from app to egtp */
+ ret = BuildAppMsg(duId, &egtpMsg);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to build App Msg");
+ return RFAILED;
+ }
- /* Encode EGTP header to build final EGTP message */
- ret = BuildEgtpMsg(&egtpMsg);
- if(ret != ROK)
- {
- DU_LOG("\nERROR --> EGTP : Failed to build EGTP Msg");
- return RFAILED;
+ /* Encode EGTP header to build final EGTP message */
+ ret = BuildEgtpMsg(duId, &egtpMsg);
+ if(ret != ROK)
+ {
+ DU_LOG("\nERROR --> EGTP : Failed to build EGTP Msg");
+ return RFAILED;
+ }
+ cuEgtpSendMsg(duId, egtpMsg.msg);
+ ODU_PUT_MSG_BUF(egtpMsg.msg);
}
- cuEgtpSendMsg(egtpMsg.msg);
- ODU_PUT_MSG_BUF(egtpMsg.msg);
-
return ROK;
}
-S16 BuildAppMsg(EgtpMsg *egtpMsg)
+/*******************************************************************
+ *
+ * @brief Builds application message to be sent to DU in DL path
+ *
+ * @details
+ *
+ * Function : BuildAppMsg
+ *
+ * Functionality:
+ * Builds application message to be sent to DU in DL path
+ *
+ * @params[in] uint32_t duId,EGTP message
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+S16 BuildAppMsg(uint32_t duId, EgtpMsg *egtpMsg)
{
char data[1215] = "In telecommunications, 5G is the fifth generation technology standard for broadband cellular"
" networks, which cellular phone companies began deploying worldwide in 2019, and is the planned successor to the 4G "
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
- ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
+ ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[duId-1].localIp.ipV4Addr);
+ ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.egtpAssoc[duId-1].destIp.ipV4Addr);
/* Packing IPv4 header into buffer */
S16 ret, cnt, idx;
return ret;
}
-S16 BuildEgtpMsg(EgtpMsg *egtpMsg)
+/*******************************************************************
+ *
+ * @brief Encodes EGTP header to application message to send to DU
+ *
+ * @details
+ *
+ * Function : BuildEgtpMsg
+ *
+ * Functionality:
+ * Encodes EGTP header to application message to send to DU
+ *
+ * @params[in] uint32_t duId,EGTP message
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+S16 BuildEgtpMsg(uint32_t duId, EgtpMsg *egtpMsg)
{
EgtpTeIdCb *teidCb = NULLP;
MsgLen tPduSize;
uint32_t msgLen;
EgtpMsgHdr *msgHdr;
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb[duId-1].teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nERROR --> EGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
return ROK;
}
-S16 cuEgtpSendMsg(Buffer *mBuf)
+/*******************************************************************
+ *
+ * @brief Send the egtp message to the destination DU
+ *
+ * @details
+ *
+ * Function : cuEgtpSendMsg
+ *
+ * Functionality:
+ * Send the egtp message to the destination DU
+ *
+ * @params[in] uint32_t duId
+ * Message Buffer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+S16 cuEgtpSendMsg(uint32_t duId, Buffer *mBuf)
{
S16 ret;
MsgLen txLen;
info.region = CU_APP_MEM_REG;
info.pool = CU_POOL;
- dstAddr.port = EGTP_DFLT_PORT;
- dstAddr.address = egtpCb.dstCb.dstIp;
+ dstAddr.port = EGTP_RECVR_PORT;
+ dstAddr.address = egtpCb.dstCb[duId-1].dstIp;
- ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
+ ret = cmInetSendMsg(&(egtpCb.dstCb[duId-1].sendTptSrvr.sockFd), &dstAddr, &info, mBuf, &txLen, CM_INET_NO_FLAG);
if(ret != ROK && ret != RWOULDBLOCK)
{
DU_LOG("\nERROR --> EGTP : Message send failure");
#ifndef __CU_STUB_EGTP_H__
#define __CU_STUB_EGTP_H__
-#define EGTP_DFLT_PORT 2152
+#define EGTP_RECVR_PORT 2152 /* As per the spec 29.281, the registered port number for GTP-U is 2152 */
#define EGTP_TNL_MGMT_ADD 1
#define EGTP_TNL_MGMT_MOD 2
#define EGTP_TNL_MGMT_DEL 3
typedef struct egtpDstCb
{
+ uint32_t duId;
CmInetIpAddr dstIp; /* destination IP */
uint16_t dstPort; /* Remote port that sends data */
EgtpTptSrvr sendTptSrvr; /* Transport server for sending UDP msg to */
CmHashListCp teIdLst; /* Tunnel Id list for this destination */
}EgtpDstCb;
-typedef struct egtpParams
+typedef struct egtpAssoc
{
SctpIpAddr localIp;
uint16_t localPort;
SctpIpAddr destIp;
uint16_t destPort;
- uint32_t currTunnelId;
- uint32_t minTunnelId;
- uint32_t maxTunnelId;
-}EgtpParams;
+}EgtpAssoc;
+
+typedef struct cuEgtpParams
+{
+ uint32_t currTunnelId;
+ uint32_t minTunnelId;
+ uint32_t maxTunnelId;
+ uint8_t numDu;
+ EgtpAssoc egtpAssoc[MAX_DU_SUPPORTED];
+}CuEgtpParams;
typedef struct egtpGlobalCb
{
- EgtpParams egtpCfg; /* EGTP configuration */
+ CuEgtpParams egtpCfg; /* EGTP configuration */
EgtpTptSrvr recvTptSrvr; /* Transport server for receiving UDP msg */
- EgtpDstCb dstCb; /* Destination endpoint */
+ uint8_t numDu;
+ EgtpDstCb dstCb[MAX_DU_SUPPORTED]; /* Destination endpoint */
uint8_t gCntPdu[MAX_TEID+1]; /* Maintaining PDU count for each bearer */
}EgtpGlobalCb;
EgtpGlobalCb egtpCb; /* EGTP global control block */
S16 egtpActvInit();
S16 cuEgtpCfgReq();
S16 cuEgtpSrvOpenReq();
-S16 cuEgtpTnlMgmtReq(EgtpTnlEvt tnlEvt);
-S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt);
-S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt);
-S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlMgmtReq(uint32_t duId,EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlAdd(uint32_t duId, EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlMod(uint32_t duId,EgtpTnlEvt tnlEvt);
+S16 cuEgtpTnlDel(uint32_t duId,EgtpTnlEvt tnlEvt);
S16 cuEgtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx);
S16 cuEgtpHdlRecvMsg(Buffer *mBuf);
uint16_t cuEgtpDatReq(uint8_t teId);
-S16 BuildAppMsg(EgtpMsg *egtpMsg);
-S16 BuildEgtpMsg(EgtpMsg *egtpMsg);
-S16 cuEgtpSendMsg(Buffer *mBuf);
+S16 BuildAppMsg(uint32_t duId, EgtpMsg *egtpMsg);
+S16 BuildEgtpMsg(uint32_t duId, EgtpMsg *egtpMsg);
+S16 cuEgtpSendMsg(uint32_t duId, Buffer *mBuf);
S16 cuEgtpDecodeHdr(Buffer *mBuf);
#endif
memset(&f1PollParams, 0, sizeof(sctpSockPollParams));
- egtpFromAddr.port = egtpCb.dstCb.dstPort;
- egtpFromAddr.address = egtpCb.dstCb.dstIp;
/* All sockets are non-blocking */
timeout = 0;
}
/* Receiving EGTP data */
- egtpBufLen = -1;
- ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG);
- if(ret == ROK && egtpBuf != NULLP)
+ for(destIdx = 0; destIdx < egtpCb.numDu; destIdx++)
{
- DU_LOG("\nINFO --> EGTP : Received UL Message [%ld]\n", numMsgRcvd+1);
- numMsgRcvd++;
- //ODU_PRINT_MSG(egtpBuf, 0 ,0);
- cuEgtpHdlRecvMsg(egtpBuf);
+
+ egtpFromAddr.port = egtpCb.dstCb[destIdx].dstPort;
+ egtpFromAddr.address = egtpCb.dstCb[destIdx].dstIp;
+ egtpBufLen = -1;
+ ret = cmInetRecvMsg(&(egtpCb.recvTptSrvr.sockFd), &egtpFromAddr, &memInfo, &egtpBuf, &egtpBufLen, CM_INET_NO_FLAG);
+ if(ret == ROK && egtpBuf != NULLP)
+ {
+ DU_LOG("\nINFO --> EGTP : Received UL Message [%ld] from DUid %d\n", numMsgRcvd+1, egtpCb.dstCb[destIdx].duId);
+ numMsgRcvd++;
+ //ODU_PRINT_MSG(egtpBuf, 0 ,0);
+ cuEgtpHdlRecvMsg(egtpBuf);
+ }
}
};
return (ret);
uint16_t cuPort;
}SctpAssocInfo;
-typedef struct CuSctpParams
+typedef struct cuSctpParams
{
uint8_t numDu;
SctpAssocInfo sctpAssoc[MAX_DU_SUPPORTED];
#endif
#define DU_EGTP_PORT 39001
-#define CU_EGTP_PORT 39002
+#define CU_EGTP_PORT 39003
#define NR_PCI 1
#define NR_CELL_ID 1
memcpy(&egtpCb.egtpCfg, &egtpCfg, sizeof(EgtpConfig));
egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
- egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
+ egtpCb.recvTptSrvr.addr.port = EGTP_RECVR_PORT;
egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
info.region = DU_APP_MEM_REGION;
info.pool = DU_POOL;
- dstAddr.port = EGTP_DFLT_PORT;
+ dstAddr.port = EGTP_RECVR_PORT;
dstAddr.address = egtpCb.dstCb.dstIp;
ret = cmInetSendMsg(&(egtpCb.dstCb.sendTptSrvr.sockFd), &dstAddr, &info, \
#ifndef __DU_EGTP_H__
#define __DU_EGTP_H__
-#define EGTP_DFLT_PORT 2152
+#define EGTP_RECVR_PORT 2152 /* As per the spec 29.281, the registered port number for GTP-U is 2152 */
#define EGTP_MAX_HDR_LEN 40
#define EGTP_MAX_MSG_RECV 10
uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
{
int8_t ueIdx = -1;
- uint8_t ret=0, ieIdx=0, ieExtIdx = 0, cellIdx=0, servCellIdx = 0;
+ uint8_t ret=0, ieIdx=0, ieExtIdx = 0, servCellIdx = 0;
bool ueCbFound = false, hoInProgress = false;
- uint16_t nrCellId = 0;
+ uint16_t nrCellId = 0, cellIdx=0;
uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
DuUeCb *duUeCb = NULL;
UEContextSetupRequest_t *ueSetReq = NULL;
duUeCb->f1UeDb = NULL;
duUeCb->gnbCuUeF1apId = gnbCuUeF1apId;
duUeCb->gnbDuUeF1apId = gnbDuUeF1apId;
+ GET_CRNTI(duUeCb->crnti, duUeCb->gnbDuUeF1apId);
duUeCb->ueState = UE_HANDIN_IN_PROGRESS;
}
ueSetRsp =
&f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
- elementCnt = 4;
+ elementCnt = 5;
ueSetRsp->protocolIEs.list.count = elementCnt;
ueSetRsp->protocolIEs.list.size = \
elementCnt * sizeof(UEContextSetupResponse_t *);
UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
BuildCellGroupConfigRrc(ueCb, &ueSetRsp->protocolIEs.list.array[idx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
+ /* CRNTI */
+ idx++;
+ ueSetRsp->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_C_RNTI;
+ ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
+ ueSetRsp->protocolIEs.list.array[idx]->value.present = UEContextSetupResponseIEs__value_PR_C_RNTI;
+ ueSetRsp->protocolIEs.list.array[idx]->value.choice.C_RNTI = ueCb->crnti;
+
+
/* Drb Setup List */
idx++;
ueSetRsp->protocolIEs.list.array[idx]->id = \
{
case UE_CTXT_SETUP:
{
- BuildAndSendUeContextSetupRsp(cellId,ueId);
+ if((BuildAndSendUeContextSetupRsp(cellId,ueId)) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed at BuildAndSendUeContextSetupRsp()");
+ return RFAILED;
+ }
break;
}
case UE_CTXT_MOD:
{
- BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1]);
+ if((BuildAndSendUeContextModRsp(&duCb.actvCellLst[cellIdx]->ueCb[ueId-1])) != ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed at BuildAndSendUeContextModRsp");
+ return RFAILED;
+ }
break;
}
default:
BuildCellGroupConfigRrc(ueCb, &ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.cellGroupConfig);
}
- if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || (ueCb->f1UeDb->actionType == UE_CTXT_MOD))
+ if((ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY) || ((ueCb->f1UeDb->actionType == UE_CTXT_MOD) && (ueCb->f1UeDb->duUeCfg.numDrbSetupMod)))
{
- if(ueCb->f1UeDb->duUeCfg.numDrbSetupMod)
+ ieIdx++;
+ ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
+ ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
+ UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
+ if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
{
- ieIdx++;
- ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
- ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
- ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
- UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
- if(ueCb->f1UeDb->actionType == UE_CTXT_CFG_QUERY)
+ for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
{
- for(tnlIdx = 0; tnlIdx < duCb.numTeId; tnlIdx++)
+ if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
{
- if(duCb.upTnlCfg[tnlIdx]->ueId == ueCb->gnbDuUeF1apId)
- {
- memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
- }
+ memcpy(&ueCb->f1UeDb->duUeCfg.upTnlInfo[ueCb->f1UeDb->duUeCfg.numDrbSetupMod++], duCb.upTnlCfg[tnlIdx], sizeof(UpTnlCfg));
}
}
- ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
- value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
- if(ret != ROK)
- {
- DU_LOG( "\nERROR --> F1AP : Failed to build DRB setupmod List ");
- break;
- }
+ }
+ ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
+ value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
+ if(ret != ROK)
+ {
+ DU_LOG( "\nERROR --> F1AP : Failed to build DRB setupmod List ");
+ break;
}
}
* @return ROK/RFAILED
*
*****************************************************************/
-uint8_t fillMacUeCfg(uint16_t cellId, uint8_t gnbDuUef1apId, uint16_t crnti, DuUeCfg *ueCfgDb, MacUeCfg *macUeCfg)
+uint8_t fillMacUeCfg(uint16_t cellId, uint8_t gnbDuUef1apId, DuUeCfg *ueCfgDb, MacUeCfg *macUeCfg)
{
uint8_t ret = ROK, dbIdx = 0, lcIdx = 0, cellIdx = 0;
bool lcIdFound = false;
macUeCfg->cellId = cellId;
macUeCfg->ueId = gnbDuUef1apId;
- macUeCfg->crnti = crnti;
+ GET_CRNTI(macUeCfg->crnti, macUeCfg->ueId);
if(!ueCfgDb)
{
macUeCfg->transmissionAction = ueCfgDb->dataTransmissionAction;
return ROK;
}
-
- /* Fetching MacDb from DuUeCb.
- * In case of UE hand-in, UE context is created before RRC setup. Hence
- * crnti is not known yet. Thus, passing crnti=0 to this function.
- * In such a case actvCellLst doesnt yet have any entry for this UE. So
- * duMacDb will be NULL.
- */
-
- if(crnti != 0)
+
+ GET_CELL_IDX(cellId, cellIdx);
+ if(duCb.actvCellLst[cellIdx])
+ duMacDb = &duCb.actvCellLst[cellIdx]->ueCb[macUeCfg->ueId-1].macUeCfg;
+ else
{
- GET_CELL_IDX(cellId, cellIdx);
- if(duCb.actvCellLst[cellIdx])
- duMacDb = &duCb.actvCellLst[cellIdx]->ueCb[macUeCfg->ueId-1].macUeCfg;
- else
- {
- DU_LOG("\nERROR --> DU APP : Cell Id [%d] does not exist", cellId);
- return RFAILED;
- }
- duMacDb->macUeCfgState = UE_CFG_INPROGRESS;
+ DU_LOG("\nERROR --> DU APP : Cell Id [%d] does not exist", cellId);
+ return RFAILED;
}
+ duMacDb->macUeCfgState = UE_CFG_INPROGRESS;
if(ueCfgDb->cellGrpCfg)
{
*
*
*****************************************************************/
-uint8_t fillRlcUeCfg(uint16_t cellId, uint8_t ueId, DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg)
+uint8_t fillRlcUeCfg(uint16_t cellId, uint8_t duUeF1apId, DuUeCfg *ueCfgDb, RlcUeCfg *rlcUeCfg)
{
uint8_t ret, dbIdx, lcIdx, cellIdx;
bool lcIdFound = false;
RlcUeCfg *duRlcDb = NULLP;
ret = ROK;
+ rlcUeCfg->cellId = cellId;
+ rlcUeCfg->ueId = duUeF1apId;
+
if(!ueCfgDb)
{
/* Initial RB being Added */
- rlcUeCfg->cellId = cellId;
- rlcUeCfg->ueId = ueId;
ret = fillRlcSrb1LcCfg(&rlcUeCfg->rlcLcCfg[0]);
if(ret == ROK)
rlcUeCfg->numLcs++;
{
/* Fetch RlcDb from DuUeCb */
GET_CELL_IDX(cellId, cellIdx);
- duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg;
+ duRlcDb = &duCb.actvCellLst[cellIdx]->ueCb[rlcUeCfg->ueId-1].rlcUeCfg;
duRlcDb->rlcUeCfgState = UE_CFG_INPROGRESS;
- /*Filling RlcUeCfg */
- rlcUeCfg->cellId = cellId;
- rlcUeCfg->ueId = ueId;
for(dbIdx = 0; (dbIdx < ueCfgDb->numRlcLcs && ret == ROK); dbIdx++)
{
memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
return ret;
}
- /* Fill Rlc Ue Cfg List for ADD/MOD/DEL */
- for(lcIdx = 0; lcIdx < duRlcDb->numLcs; lcIdx++)
- {
- if(ueCfgDb->rlcLcCfg[dbIdx].lcId == duRlcDb->rlcLcCfg[lcIdx].lcId)
- {
- lcIdFound = true;
- if((ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_UNKNOWN)||
- (ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_MOD))
+
+ if(duRlcDb)
+ {
+ /* Fill Rlc Ue Cfg List for ADD/MOD/DEL */
+ for(lcIdx = 0; lcIdx < duRlcDb->numLcs; lcIdx++)
+ {
+ if(ueCfgDb->rlcLcCfg[dbIdx].lcId == duRlcDb->rlcLcCfg[lcIdx].lcId)
{
- /* MOD */
- ueCfgDb->rlcLcCfg[dbIdx].configType = CONFIG_MOD; /* update Db for MOD type */
- memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
- fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].snssai, ueCfgDb->rlcLcCfg[dbIdx].snssai,\
- &duRlcDb->rlcLcCfg[lcIdx].snssai,false);
+ lcIdFound = true;
+ if((ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_UNKNOWN)||
+ (ueCfgDb->rlcLcCfg[dbIdx].configType == CONFIG_MOD))
+ {
+ /* MOD */
+ ueCfgDb->rlcLcCfg[dbIdx].configType = CONFIG_MOD; /* update Db for MOD type */
+ memcpy(&rlcUeCfg->rlcLcCfg[dbIdx], &ueCfgDb->rlcLcCfg[dbIdx], sizeof(RlcBearerCfg));
+ fillSnssaiInfo(rlcUeCfg->rlcLcCfg[dbIdx].snssai, ueCfgDb->rlcLcCfg[dbIdx].snssai,\
+ &duRlcDb->rlcLcCfg[lcIdx].snssai,false);
+ }
}
+ else
+ lcIdFound = false;
}
- else
- lcIdFound = false;
}
+
if(!lcIdFound)
{
/* ADD/ DEL Config Type */
/* Filling Mac Ue Config */
memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg, 0, sizeof(MacUeCfg));
- ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueCcchCtxt->gnbDuUeF1apId, ueCcchCtxt->crnti, NULL,
+ ret = duBuildAndSendUeCreateReqToMac(ueCcchCtxt->cellId, ueCcchCtxt->gnbDuUeF1apId, NULL,
&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].macUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to send UE create request to MAC");
/* Filling Rlc Ue Config */
memset(&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg, 0, sizeof(RlcUeCfg));
- ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueId, \
+ ret = duBuildAndSendUeCreateReqToRlc(ueCcchCtxt->cellId, ueCcchCtxt->gnbDuUeF1apId, NULL,
&duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to send UE create request to RLC");
*
* ****************************************************************/
-uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t gnbDuUeF1apId, uint16_t crnti, DuUeCfg *ueCfgDb, MacUeCfg *duMacUeCfg)
+uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t gnbDuUeF1apId, DuUeCfg *ueCfgDb, MacUeCfg *duMacUeCfg)
{
uint8_t ret = ROK;
MacUeCfg *macUeCfg = NULLP;
memset(&pst, 0, sizeof(Pst));
- ret = fillMacUeCfg(cellId, gnbDuUeF1apId, crnti, ueCfgDb, duMacUeCfg);
+ ret = fillMacUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, duMacUeCfg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : Failed to fill MacUeCfg at duBuildAndSendUeCreateReqToMac()");
DuUeCb *ueCb = NULLP;
GET_CELL_IDX(cellId, cellIdx);
-
- if(duCb.actvCellLst[cellIdx] && (duCb.actvCellLst[cellIdx]->ueCb[ueId-1].macUeCfg.macUeCfgState == UE_RECFG_COMPLETE) &&
- (duCb.actvCellLst[cellIdx]->ueCb[ueId-1].rlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
- {
- ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
+ ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
- /*Filling RLC Ue Cfg */
- ueCb->rlcUeCfg.cellId = cellId;
- ueCb->rlcUeCfg.ueId = ueId;
- ret = duUpdateRlcLcCfg(&ueCb->rlcUeCfg, ueCb->f1UeDb);
- if(ret == ROK)
+ /*Filling RLC Ue Cfg */
+ ueCb->rlcUeCfg.cellId = cellId;
+ ueCb->rlcUeCfg.ueId = ueId;
+ ret = duUpdateRlcLcCfg(&ueCb->rlcUeCfg, ueCb->f1UeDb);
+ if(ret == ROK)
+ {
+ /*Filling MAC Ue Cfg */
+ GET_CRNTI(crnti, ueId);
+ ueCb->macUeCfg.cellId = cellId;
+ ueCb->macUeCfg.ueId = ueId;
+ ueCb->macUeCfg.crnti = crnti;
+ ret = duUpdateMacCfg(&ueCb->macUeCfg, ueCb->f1UeDb);
+ if(ret == RFAILED)
+ DU_LOG("\nERROR --> DU APP : Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
+ else
{
- /*Filling MAC Ue Cfg */
- GET_CRNTI(crnti, ueId);
- ueCb->macUeCfg.cellId = cellId;
- ueCb->macUeCfg.ueId = ueId;
- ueCb->macUeCfg.crnti = crnti;
- ret = duUpdateMacCfg(&ueCb->macUeCfg, ueCb->f1UeDb);
- if(ret == RFAILED)
- DU_LOG("\nERROR --> DU APP : Failed while updating MAC LC Config at duUpdateDuUeCbCfg()");
- else
- {
- if(duUpdateTunnelCfgDb(ueId, cellId, &ueCb->f1UeDb->duUeCfg) != ROK)
- {
- DU_LOG("\nERROR --> DU_APP : Failed to establish tunnel in duUpdateDuUeCbCfg()");
- return RFAILED;
- }
- }
+ if(duUpdateTunnelCfgDb(ueId, cellId, &ueCb->f1UeDb->duUeCfg) != ROK)
+ {
+ DU_LOG("\nERROR --> DU_APP : Failed to establish tunnel in duUpdateDuUeCbCfg()");
+ return RFAILED;
+ }
}
- else
- DU_LOG("\nERROR --> DU APP : Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
}
else
- ret = RFAILED;
+ DU_LOG("\nERROR --> DU APP : Failed while updating RLC LC Config at duUpdateDuUeCbCfg()");
return ret;
}
{
duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState = UE_CREATE_COMPLETE;
- /* TODO : IF UE state is HANDIN_IN_PROGRESS, then send UE Context Setup Response */
+ if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].ueState == UE_HANDIN_IN_PROGRESS) &&
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState == UE_CREATE_COMPLETE) &&
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_CREATE_COMPLETE))
+ {
+ if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
+ {
+ if((BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
+ {
+ DU_LOG("\nERROR -> DU APP : Failure in BuildAndSendUeCtxtRsp()");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR -> DU APP : Failure in updating DU UE CB");
+ return RFAILED;
+ }
+ }
}
}
else if(pst->event == EVENT_MAC_UE_RECONFIG_RSP)
(duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].gnbDuUeF1apId == cfgRsp->ueId))
{
duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState = UE_RECFG_COMPLETE;
- if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
- {
- BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId);
+ if((duCb.actvCellLst[cellIdx]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState == UE_RECFG_COMPLETE) &&
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
+ {
+ if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
+ {
+ if((BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
+ {
+ DU_LOG("\nERROR -> DU APP : Failure in BuildAndSendUeCtxtRsp()");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR -> DU APP : Failure in updating DU UE CB");
+ return RFAILED;
+ }
}
}
}
*
*****************************************************************/
-uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueId, RlcUeCfg *duRlcUeCfg)
+uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t gnbDuUeF1apId, DuUeCfg *ueCfgDb, RlcUeCfg *duRlcUeCfg)
{
uint8_t ret = ROK;
RlcUeCfg *rlcUeCfg = NULLP;
Pst pst;
- ret = fillRlcUeCfg(cellId, ueId, NULL, duRlcUeCfg);
+ ret = fillRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, duRlcUeCfg);
if(ret == RFAILED)
{
DU_LOG("\nERROR --> DU APP : Failed to fill Rlc Ue Cfg at duBuildAndSendUeCreateReqToRlc()");
if(pst->event == EVENT_RLC_UE_CREATE_RSP)
{
DU_LOG("\nINFO --> DU_APP: RLC UE Create Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
- duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].\
- rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
+ duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState = UE_CREATE_COMPLETE;
+
+ if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].ueState == UE_HANDIN_IN_PROGRESS) &&
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState == UE_CREATE_COMPLETE) &&
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_CREATE_COMPLETE))
+ {
+ if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
+ {
+ if((BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU APP : Failure in BuildAndSendUeCtxtRsp");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : Failure in updating DU UE CB");
+ return RFAILED;
+ }
+ }
}
else if(pst->event == EVENT_RLC_UE_RECONFIG_RSP)
{
DU_LOG("\nINFO --> DU_APP: RLC UE Reconfig Response : SUCCESS [UE IDX:%d]", cfgRsp->ueId);
- duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].\
- rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
- if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
+
+ duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState = UE_RECFG_COMPLETE;
+ if((duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].macUeCfg.macUeCfgState == UE_RECFG_COMPLETE) &&
+ (duCb.actvCellLst[cfgRsp->cellId -1]->ueCb[cfgRsp->ueId -1].rlcUeCfg.rlcUeCfgState == UE_RECFG_COMPLETE))
{
- BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId);
- }
+ if((ret = duUpdateDuUeCbCfg(cfgRsp->ueId, cfgRsp->cellId)) == ROK)
+ {
+ if((BuildAndSendUeCtxtRsp(cfgRsp->cellId, cfgRsp->ueId)) != ROK)
+ {
+ DU_LOG("\nERROR --> DU APP : Failure in BuildAndSendUeCtxtRsp");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nERROR --> DU APP : Failure in updating DU UE CB");
+ return RFAILED;
+ }
+ }
}
}
else
*
* ****************************************************************/
-uint8_t duBuildAndSendUeReCfgReqToRlc(uint8_t cellId, uint8_t crnti, DuUeCfg *ueCfgDb)
+uint8_t duBuildAndSendUeReCfgReqToRlc(uint8_t cellId, uint8_t gnbDuUeF1apId, uint8_t crnti, DuUeCfg *ueCfgDb)
{
- uint8_t ret = ROK, ueId = 0;
+ uint8_t ret = ROK;
RlcUeCfg *rlcUeCfg = NULLP;
- GET_UE_ID(crnti, ueId);
DU_ALLOC_SHRABL_BUF(rlcUeCfg, sizeof(RlcUeCfg));
if(rlcUeCfg)
{
memset(rlcUeCfg, 0, sizeof(RlcUeCfg));
- ret = fillRlcUeCfg(cellId, ueId, ueCfgDb, rlcUeCfg);
+ ret = fillRlcUeCfg(cellId, gnbDuUeF1apId, ueCfgDb, rlcUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed at duBuildAndSendUeReCfgReqToRlc()");
else
if(macUeCfg)
{
memset(macUeCfg, 0, sizeof(MacUeCfg));
- ret = fillMacUeCfg(cellId, duUeF1apId, crnti, ueCfgDb, macUeCfg);
+ ret = fillMacUeCfg(cellId, duUeF1apId, ueCfgDb, macUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to fill Mac Ue Cfg at duBuildAndSendUeReCfgReqToMac()");
else
/* Filling MAC UE Config */
memset(&ueCb->macUeCfg, 0, sizeof(MacUeCfg));
- /* Since UE attach has not yet happened, ueId and crnti is unknow. Hence
- * passing 0 */
- ret = duBuildAndSendUeCreateReqToMac(cellId, ueCb->gnbDuUeF1apId, 0, duUeCfg, &ueCb->macUeCfg);
+ /* Since UE attach has not yet happened, crnti is unknow. Hence passing 0 */
+ ret = duBuildAndSendUeCreateReqToMac(cellId, ueCb->gnbDuUeF1apId, duUeCfg, &ueCb->macUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to send UE create request to MAC");
+
+ ret = duBuildAndSendUeCreateReqToRlc(cellId, ueCb->gnbDuUeF1apId, duUeCfg, &ueCb->rlcUeCfg);
+ if(ret == RFAILED)
+ DU_LOG("\nERROR --> DU APP : Failed to send UE create request to RLC");
+
}
else
{
/* Filling RLC UE Reconfig */
- ret = duBuildAndSendUeReCfgReqToRlc(cellId, crnti, duUeCfg);
+ ret = duBuildAndSendUeReCfgReqToRlc(cellId, ueCb->gnbDuUeF1apId, crnti, duUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextSetupReq()");
DU_LOG("\nDEBUG --> DU_APP: Processing Ue Context Mod Request for cellId [%d]", cellId);
/* Filling RLC Ue Reconfig */
- ret = duBuildAndSendUeReCfgReqToRlc(cellId, crnti, duUeCfg);
+ ret = duBuildAndSendUeReCfgReqToRlc(cellId, gnbDuUeF1apId, crnti, duUeCfg);
if(ret == RFAILED)
DU_LOG("\nERROR --> DU APP : Failed to build ctxt setup req for RLC at duBuildAndSendUeContextModReq()");
uint8_t duHdlRlcUlData(Pst *pst, KwuDatIndInfo* datInd, Buffer *mBuf);
uint8_t cmPkRlcDatReq(Pst * pst,RlcDatReqInfo* datReq,Buffer * mBuf);
-uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueId, uint16_t crnti, DuUeCfg *ueCfgDb, MacUeCfg *duMacUeCfg);
-uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueId, RlcUeCfg *duRlcUeCfg);
+uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t duUeF1apId, DuUeCfg *ueCfgDb, MacUeCfg *duMacUeCfg);
+uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t duUeF1apId, DuUeCfg *ueCfgDb, RlcUeCfg *duRlcUeCfg);
uint8_t duCreateUeCb(UeCcchCtxt *ueCcchCtxt, uint32_t gnbCuUeF1apId);
uint8_t duProcUlCcchInd(UlCcchIndInfo *ulCcchIndInfo);
uint8_t duBuildAndSendUeDeleteReq(uint16_t cellId, uint16_t crnti);
memset(&pst, 0, sizeof(Pst));
FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_SLOT_IND);
-
ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
if(!mBuf)
{