/* This file contains F1AP message handler functions */
#include "common_def.h"
+#include "du_tmr.h"
#include "ckw.h"
#include "ckw.x"
#include "kwu.h"
#include "du_app_mac_inf.h"
#include "du_cfg.h"
#include "du_app_rlc_inf.h"
+#include "du_e2ap_mgr.h"
+#include "du_e2ap_msg_hdl.h"
#include "du_mgr_main.h"
#include "du_mgr.h"
#include "du_utils.h"
#include "UPTransportLayerInformation.h"
#include "GTPTunnel.h"
#include "SupportedSULFreqBandItem.h"
-#include "du_e2ap_msg_hdl.h"
#include "du_f1ap_conversions.h"
#include "CNUEPagingIdentity.h"
#include "PCCH-Config.h"
#include "CFRA-SSB-Resource.h"
#include "BWP-UplinkCommon.h"
#include "ReconfigurationWithSync.h"
+#include "BCCH-DL-SCH-Message.h"
#include "du_sys_info_hdl.h"
#include "DRX-ConfigRrc.h"
+#include "MeasurementTimingConfigurationRrc.h"
+#include "MeasurementTimingConfigurationRrc-IEs.h"
+#include "MeasTimingList.h"
+#include "MeasTiming.h"
+#include "Cells-Status-List.h"
+#include "Cells-Status-Item.h"
#ifdef O1_ENABLE
#include "CmInterface.h"
extern StartupConfig g_cfg;
#endif
-DuCfgParams duCfgParam;
+extern DuCfgParams duCfgParam;
/******************************************************************
*
freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
+
freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
}
return ROK;
}
+
+/*******************************************************************
+ *
+ * @brief Frees Measurement Timing configuration
+ *
+ * @details
+ *
+ * Function : FreeMeasTimingConf
+ *
+ * Functionality: Frees Timing Configuration
+ *
+ * @params[in] MeasurementTimingConfigurationRrc_t measTimingConfRrc
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+void FreeMeasTimingConf(MeasurementTimingConfigurationRrc_t measTimingConfRrc)
+{
+ uint8_t measIeIdx = 0;
+ MeasurementTimingConfigurationRrc_IEs_t *measTimingConfIEs = NULLP;
+
+ if(measTimingConfRrc.criticalExtensions.choice.c1)
+ {
+ if(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf)
+ {
+ measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf;
+ if(measTimingConfIEs->measTiming)
+ {
+ if(measTimingConfIEs->measTiming->list.array)
+ {
+ for(measIeIdx = 0; measIeIdx < measTimingConfIEs->measTiming->list.count; measIeIdx++)
+ {
+ if(measTimingConfIEs->measTiming->list.array[measIeIdx])
+ {
+ DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
+ DU_FREE(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t));
+ }
+ }
+ DU_FREE(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size);
+ }
+ DU_FREE(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t));
+ }
+ DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t));
+ }
+ DU_FREE(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Builds MEasuerment Timing Configuration
+ *
+ * @details
+ *
+ * Function : BuildMeasTimingConf
+ *
+ * Functionality: Building Measurement Timing Configuration
+ *
+ * @params[in] Pointer to octet string to store Measurement timing
+ * Configuration
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildMeasTimingConf(OCTET_STRING_t *measTimingConf)
+{
+ uint8_t ret = RFAILED;
+ uint8_t elementCnt = 0;
+ uint8_t measIeIdx = 0;
+ asn_enc_rval_t encRetVal;
+ MeasurementTimingConfigurationRrc_t measTimingConfRrc;
+ MeasurementTimingConfigurationRrc_IEs_t *measTimingConfIEs = NULLP;
+ struct MeasTiming__frequencyAndTiming *freqAndTiming = NULLP;
+
+ while(true)
+ {
+ measTimingConfRrc.criticalExtensions.present = MeasurementTimingConfigurationRrc__criticalExtensions_PR_c1;
+ DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1, sizeof(struct MeasurementTimingConfigurationRrc__criticalExtensions__c1));
+ if(!measTimingConfRrc.criticalExtensions.choice.c1)
+ {
+ DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for critical extension choice C1");
+ break;
+ }
+ measTimingConfRrc.criticalExtensions.choice.c1->present = MeasurementTimingConfigurationRrc__criticalExtensions__c1_PR_measTimingConf;
+
+ DU_ALLOC(measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf, sizeof(MeasurementTimingConfigurationRrc_IEs_t));
+ if(!measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf)
+ {
+ DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for measTimingConf");
+ break;
+ }
+ measTimingConfIEs = measTimingConfRrc.criticalExtensions.choice.c1->choice.measTimingConf;
+
+ DU_ALLOC(measTimingConfIEs->measTiming, sizeof(MeasTimingList_t));
+ if(!measTimingConfIEs->measTiming)
+ {
+ DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList");
+ break;
+ }
+
+ elementCnt = 1;
+ measTimingConfIEs->measTiming->list.count = elementCnt;
+ measTimingConfIEs->measTiming->list.size = elementCnt * sizeof(MeasTiming_t *);
+ DU_ALLOC(measTimingConfIEs->measTiming->list.array, measTimingConfIEs->measTiming->list.size);
+ if(!measTimingConfIEs->measTiming->list.array)
+ {
+ DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array");
+ break;
+ }
+
+ for(measIeIdx = 0; measIeIdx < elementCnt; measIeIdx++)
+ {
+ DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx], sizeof(MeasTiming_t));
+ if(!measTimingConfIEs->measTiming->list.array[measIeIdx])
+ {
+ DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for MeasTimingList array index %d", measIeIdx);
+ break;
+ }
+ }
+ if(measIeIdx < elementCnt)
+ {
+ break;
+ }
+
+ measIeIdx = 0;
+ DU_ALLOC(measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming, sizeof(struct MeasTiming__frequencyAndTiming));
+ if(!measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming)
+ {
+ DU_LOG("ERROR --> DU_APP : BuildMeasTimingConf(): Memory allocation failure for frequencyAndTiming");
+ break;
+ }
+ freqAndTiming = measTimingConfIEs->measTiming->list.array[measIeIdx]->frequencyAndTiming;
+ freqAndTiming->carrierFreq = MEAS_TIMING_ARFCN;
+ freqAndTiming->ssbSubcarrierSpacing = duCfgParam.macCellCfg.ssbCfg.scsCmn;
+ freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.present = duCfgParam.macCellCfg.ssbCfg.ssbPeriod + 1;
+ freqAndTiming->ssb_MeasurementTimingConfiguration.periodicityAndOffset.choice.sf20 = duCfgParam.macCellCfg.ssbCfg.ssbScOffset;
+ freqAndTiming->ssb_MeasurementTimingConfiguration.duration = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfgDuration;
+
+ /* Encode the F1SetupRequest type as APER */
+ xer_fprint(stdout, &asn_DEF_MeasurementTimingConfigurationRrc, &measTimingConfRrc);
+
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = uper_encode(&asn_DEF_MeasurementTimingConfigurationRrc, 0, &measTimingConfRrc, PrepFinalEncBuf, encBuf);
+
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("\nERROR --> F1AP : Could not encode Measurement Timing Configuration structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nDEBUG --> F1AP : Created APER encoded buffer for Measurement Timing Configuration \n");
+#ifdef DEBUG_ASN_PRINT
+ for(measIeIdx=0; measIeIdx< encBufSize; measIeIdx++)
+ {
+ printf("%x",encBuf[measIeIdx]);
+ }
+#endif
+
+ measTimingConf->size = encBufSize;
+ DU_ALLOC(measTimingConf->buf, encBufSize);
+ if(measTimingConf->buf == NULLP)
+ {
+ DU_LOG("\nERROR --> F1AP : Memory allocation failed for MeasurementTimingConfiguration buffer");
+ return RFAILED;
+ }
+ memcpy(measTimingConf->buf, &encBuf, encBufSize);
+
+ FreeMeasTimingConf(measTimingConfRrc);
+
+ ret = ROK;
+ break;
+ }
+ }
+ return ret;
+}
+
/*******************************************************************
*
* @brief Builds Served Cell List
for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
{
DU_ALLOC(duServedCell->list.array[plmnidx],\
- sizeof(GNB_DU_Served_Cells_ItemIEs_t));
+ sizeof(GNB_DU_Served_Cells_ItemIEs_t));
if(duServedCell->list.array[plmnidx] == NULLP)
{
- return RFAILED;
+ return RFAILED;
}
}
idx = 0;
duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
duServedCell->list.array[idx]->criticality = Criticality_reject;
duServedCell->list.array[idx]->value.present = \
- GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
+ GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
srvCellItem = \
- &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
+ &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
/*nRCGI*/
BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
if(BuildNrcgiret != ROK)
}
/*nRPCI*/
srvCellItem->served_Cell_Information.nRPCI = \
- duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
+ duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
- /*fiveGS_TAC*/
+ /* fiveGS_TAC */
BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
if(BuildFiveGSTacret != ROK)
{
return RFAILED;
}
- /*Served PLMNs*/
+
+ /* Served PLMNs */
BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
if(BuildServedPlmnret !=ROK)
{
return RFAILED;
}
- /*nR Mode Info with FDD*/
+
+ /* nR Mode Info with FDD/TDD */
BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
if(BuildNrModeret != ROK)
{
return RFAILED;
}
+
/*Measurement timing Config*/
- srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
- size = sizeof(uint8_t);
- DU_ALLOC(srvCellItem->served_Cell_Information.\
- measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
- if(srvCellItem->served_Cell_Information.\
- measurementTimingConfiguration.buf == NULLP)
- {
+ if(BuildMeasTimingConf(&srvCellItem->served_Cell_Information.measurementTimingConfiguration) != ROK)
return RFAILED;
- }
- srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
- duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
/* GNB DU System Information */
DU_ALLOC(srvCellItem->gNB_DU_System_Information,
- sizeof(GNB_DU_System_Information_t));
+ sizeof(GNB_DU_System_Information_t));
if(!srvCellItem->gNB_DU_System_Information)
{
return RFAILED;
/* MIB */
srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
- srvCellItem->gNB_DU_System_Information->mIB_message.size);
+ srvCellItem->gNB_DU_System_Information->mIB_message.size);
if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
{
return RFAILED;
}
memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
- srvCellItem->gNB_DU_System_Information->mIB_message.size);
+ srvCellItem->gNB_DU_System_Information->mIB_message.size);
/* SIB1 */
srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
- duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
+ duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
- srvCellItem->gNB_DU_System_Information->sIB1_message.size);
+ srvCellItem->gNB_DU_System_Information->sIB1_message.size);
if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
{
return RFAILED;
for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
{
srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
- duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
+ duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
}
return ROK;
}
{
if(f1apMsg->choice.initiatingMessage != NULLP)
{
- f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
- if(f1SetupReq->protocolIEs.list.array != NULLP)
- {
- for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
- {
- if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
- {
- switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
- {
- case ProtocolIE_ID_id_TransactionID:
- break;
- case ProtocolIE_ID_id_gNB_DU_ID:
- DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
- f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
- break;
- case ProtocolIE_ID_id_gNB_DU_Name:
- DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
- strlen((char *)duCfgParam.duName));
- break;
- case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
- FreeServedCellList(&f1SetupReq->protocolIEs.list.\
- array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
- break;
- case ProtocolIE_ID_id_GNB_DU_RRC_Version:
- FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
- break;
- default:
- DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
- break;
- }
- }
- }
- for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
- {
- DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
- }
- DU_FREE(f1SetupReq->protocolIEs.list.array,\
- f1SetupReq->protocolIEs.list.size);
- }
- DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
+ f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
+ if(f1SetupReq->protocolIEs.list.array != NULLP)
+ {
+ for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
+ {
+ if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
+ {
+ switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
+ {
+ case ProtocolIE_ID_id_TransactionID:
+ break;
+ case ProtocolIE_ID_id_gNB_DU_ID:
+ DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
+ f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
+ break;
+ case ProtocolIE_ID_id_gNB_DU_Name:
+ DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
+ strlen((char *)duCfgParam.duName));
+ break;
+ case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
+ FreeServedCellList(&f1SetupReq->protocolIEs.list.\
+ array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
+ break;
+ case ProtocolIE_ID_id_GNB_DU_RRC_Version:
+ FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
+ break;
+ default:
+ DU_LOG("\nERROR --> Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
+ break;
+ }
+ }
+ }
+ for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
+ {
+ DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
+ }
+ DU_FREE(f1SetupReq->protocolIEs.list.array,\
+ f1SetupReq->protocolIEs.list.size);
+ }
+ DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
}
DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
}
}
+
/*******************************************************************
*
* @brief Builds and Send the F1SetupRequest
DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
if(f1apMsg == NULLP)
{
- break;
+ break;
}
f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
if(f1apMsg->choice.initiatingMessage == NULLP)
{
- break;
+ break;
}
f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
f1apMsg->choice.initiatingMessage->value.present = \
- InitiatingMessage__value_PR_F1SetupRequest;
+ InitiatingMessage__value_PR_F1SetupRequest;
f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
- elementCnt = 4;
+ elementCnt = 5;
f1SetupReq->protocolIEs.list.count = elementCnt;
- f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
+ f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t *);
/* Initialize the F1Setup members */
DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
duCfgParam.duId;
-#if 0
/* DU name IE is of type printableString_t which wireshark is unable to decode.
* However this string is decoded successfully on online decoders.
* Since this is an optional IE and the value received in it are not
break;
}
strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,
- (char*)&duCfgParam.duName);
+ (char*)duCfgParam.duName);
}
-#endif
/*Served Cell list */
ieIdx++;
break;
}
-
/*RRC Version*/
ieIdx++;
f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
printf("%x",encBuf[ieIdx]);
}
#endif
+
- duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
- DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
- if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
- {
- DU_LOG("\nERROR --> F1AP : Memory allocation failed to store the encoding of f1setup req");
- return RFAILED;
- }
- memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
}
-
+
/* Sending msg */
if(sendF1APMsg() != ROK)
{
DU_LOG("\nERROR --> F1AP : Sending F1 Setup request failed");
break;
}
+
+ if(fillE2NodeComponentReqInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_ADD, encBufSize, encBuf) !=ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to add the e2 node in the list");
+ break;
+ }
ret=ROK;
break;
}
}
DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
- modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
+ modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
}
/*******************************************************************
* ****************************************************************/
void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
{
- uint8_t ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
+ uint8_t idx=0,ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
Served_Cells_To_Modify_List_t *cellsToModify=NULLP;
Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
Served_Cells_To_Delete_Item_t *deleteItem = NULLP;
Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
+ Cells_Status_ItemIEs_t *cellStatusItemIE;
if(f1apDuCfg != NULLP)
{
duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
break;
}
+ case ProtocolIE_ID_id_Cells_Status_List:
+ {
+ for(idx = 0; idx < duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.count; idx++)
+ {
+ cellStatusItemIE = (Cells_Status_ItemIEs_t *)duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array[idx];
+ DU_FREE(cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.nRCellIdentity.buf, cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.nRCellIdentity.size);
+ DU_FREE(cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.pLMN_Identity.buf, cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI.pLMN_Identity.size);
+ DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array[idx],sizeof(Cells_Status_ItemIEs_t));
+ }
+ DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.array,\
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List.list.size);
+ }
}
DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
sizeof(GNBDUConfigurationUpdateIEs_t));
#endif
/*Measurement timing Config*/
- srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
- DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
- buf,srvCellInfo->measurementTimingConfiguration.size);
- if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
- {
+ if(BuildMeasTimingConf(&srvCellInfo->measurementTimingConfiguration) != ROK)
return RFAILED;
- }
- srvCellInfo->measurementTimingConfiguration.\
- buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
return ROK;
}
fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
return ROK;
}
+
/*******************************************************************
*
* @brief Builds ServCellToDeleteList
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Builds CellsStatusList
+ *
+ * @details
+ *
+ * Function : buildCellsStatusList
+ *
+ * Functionality: Builds the Cell Status List
+ *
+ * @params[in] Pointer to Cells_Status_List_t *
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ *****************************************************************/
+uint8_t buildCellsStatusList(Cells_Status_List_t *cellStatusList)
+{
+ uint8_t elementCnt = 0, idx = 0, ret = ROK;
+ Cells_Status_ItemIEs_t *cellStatusItemIE;
+
+ elementCnt = 1;
+ cellStatusList->list.count = elementCnt;
+ cellStatusList->list.size = elementCnt * sizeof(Cells_Status_ItemIEs_t *);
+ DU_ALLOC(cellStatusList->list.array, cellStatusList->list.size);
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ DU_ALLOC(cellStatusList->list.array[idx], sizeof(Cells_Status_ItemIEs_t));
+ if(!cellStatusList->list.array[idx])
+ {
+ DU_LOG("ERROR --> F1AP: buildCellsStatusList() memory allocation failure");
+ return RFAILED;
+ }
+ }
+ idx = 0;
+ cellStatusItemIE = (Cells_Status_ItemIEs_t *)cellStatusList->list.array[idx];
+ cellStatusItemIE->id = ProtocolIE_ID_id_Cells_Status_Item;
+ cellStatusItemIE->criticality = Criticality_reject;
+ cellStatusItemIE->value.present = Cells_Status_ItemIEs__value_PR_Cells_Status_Item;
+ ret = BuildNrcgi(&cellStatusItemIE->value.choice.Cells_Status_Item.nRCGI);
+ if(ret == RFAILED)
+ {
+ DU_LOG("ERROR --> F1AP: buildCellsStatusList() NRCGI failed");
+ return RFAILED;
+ }
+ cellStatusItemIE->value.choice.Cells_Status_Item.service_status.service_state = Service_State_in_service;
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Builds and sends the DUConfigUpdate
InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
choice.GNBDUConfigurationUpdate;
- elementCnt = 3;
+ elementCnt = 4;
duCfgUpdate->protocolIEs.list.count = elementCnt;
duCfgUpdate->protocolIEs.list.size = \
elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
}
}
- // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
+ // TODO :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
+
+ /*Cell Status List*/
+ ieIdx++;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_Cells_Status_List;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_Cells_Status_List;
+ ret = buildCellsStatusList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.Cells_Status_List);
+ if(ret == RFAILED)
+ {
+ DU_LOG("ERROR --> DU APP : BuildAndSendDUConfigUpdate(): Cell Status List building failed");
+ break;
+ }
+
/*GNB DU ID */
ieIdx++;
duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
}
#endif
}
+
/* Sending msg */
if(sendF1APMsg() != ROK)
{
DU_LOG("\nERROR --> F1AP : Sending GNB-DU Config Update failed");
break;
}
+
+ if(fillE2NodeComponentReqInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_UPDATE, encBufSize, encBuf)!=ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to update the e2 node in the list");
+ break;
+ }
ret = ROK;
break;
/* Fill default AM UL configuration if input pointer to DU database is NULL */
if(amCfg == NULLP)
{
- *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
+
+ *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN_12BIT; /*As per Spec 38.331, "Network configures only value size12 in SN-FieldLengthAM for SRB"*/
rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit = T_POLL_RETRANSMIT;
rlcConfig->choice.am->ul_AM_RLC.pollPDU = POLL_PDU;
rlcConfig->choice.am->ul_AM_RLC.pollByte = POLL_BYTE;
/* Fill default AM DL configuration if input pointer to DU database is NULL */
if(amCfg == NULLP)
{
- *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
+ *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN_12BIT; /*As per Spec 38.331, "Network configures only value size12 in SN-FieldLengthAM for SRB"*/
rlcConfig->choice.am->dl_AM_RLC.t_Reassembly = T_REASSEMBLY;
rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit = T_STATUS_PROHIBHIT;
}
return ROK;
} /* End BuildControlRSetToAddModList */
+/*******************************************************************
+ *
+ * @brief build SlotOffset for SearchSpace
+ *
+ * @details
+ *
+ * Function : BuildSearchSpcSlotOffset
+ *
+ * Functionality: Build Slot Offset for search space to add/modify list
+ *
+ * @params[in] SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityAndOffset
+ * uint16_t slotOffset
+ * @return void
+ *
+ * ****************************************************************/
+void BuildSearchSpcSlotOffset(struct SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityAndOffset, uint16_t slotOffset)
+{
+ switch(mSlotPeriodicityAndOffset->present)
+ {
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1:
+ mSlotPeriodicityAndOffset->choice.sl1 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2:
+ mSlotPeriodicityAndOffset->choice.sl2 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl4:
+ mSlotPeriodicityAndOffset->choice.sl4 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl5:
+ mSlotPeriodicityAndOffset->choice.sl5 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl8:
+ mSlotPeriodicityAndOffset->choice.sl8 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl10:
+ mSlotPeriodicityAndOffset->choice.sl10 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl16:
+ mSlotPeriodicityAndOffset->choice.sl16 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl20:
+ mSlotPeriodicityAndOffset->choice.sl20 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl40:
+ mSlotPeriodicityAndOffset->choice.sl40 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl80:
+ mSlotPeriodicityAndOffset->choice.sl80 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl160:
+ mSlotPeriodicityAndOffset->choice.sl160 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl320:
+ mSlotPeriodicityAndOffset->choice.sl320 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl640:
+ mSlotPeriodicityAndOffset->choice.sl640 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1280:
+ mSlotPeriodicityAndOffset->choice.sl1280 = slotOffset;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2560:
+ mSlotPeriodicityAndOffset->choice.sl2560 = slotOffset;
+ break;
+ default:
+ break;
+ }
+}
+
+
/*******************************************************************
*
* @brief Build search space to add/modify list
if(pdcchCfg == NULLP)
searchSpc->monitoringSlotPeriodicityAndOffset->present = SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
else
- searchSpc->monitoringSlotPeriodicityAndOffset->present = pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset;
+ {
+ searchSpc->monitoringSlotPeriodicityAndOffset->present = \
+ pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset.mSlotPeriodicity;
+ BuildSearchSpcSlotOffset(searchSpc->monitoringSlotPeriodicityAndOffset, \
+ pdcchCfg->searchSpcToAddModList[idx].mSlotPeriodicityAndOffset.mSlotOffset);
+ }
searchSpc->duration = NULLP;
searchSpc->monitoringSymbolsWithinSlot = NULLP;
}
/*******************************************************************
- *
* @brief Builds DMRS DL PDSCH Mapping type A
*
* @details
#ifdef O1_ENABLE
cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
#else
- cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
+ ipv4_du = duCfgParam.egtpParams.localIp.ipV4Addr;
#endif
for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
}
}
+/*******************************************************************
+ *
+ * @brief Fills SlotOffset value for SearchSpace received by CU
+ *
+ * @details
+ *
+ * Function : extractSlotOffset
+ *
+ * Functionality: Fills SlotOffset received by CU
+ *
+ * @params[in] SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityOffset,
+ * uint16_t *slotOffset
+ * @return void
+ *
+ *
+ ****************************************************************/
+void extractSlotOffset(struct SearchSpace__monitoringSlotPeriodicityAndOffset *mSlotPeriodicityAndOffset, uint16_t *slotOffset)
+{
+ switch(mSlotPeriodicityAndOffset->present)
+ {
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_NOTHING:
+ *slotOffset = NULLD;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl1;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl2;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl4:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl4;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl5:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl5;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl8:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl8;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl10:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl10;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl16:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl16;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl20:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl20;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl40:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl40;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl80:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl80;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl160:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl160;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl320:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl320;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl640:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl640;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1280:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl1280;
+ break;
+ case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2560:
+ *slotOffset = mSlotPeriodicityAndOffset->choice.sl2560;
+ break;
+ default:
+ *slotOffset = 0;
+ }
+}
+
+
/*******************************************************************
*
* @brief Fills PdcchCfg received by CU
*(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
{
- macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
- srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
+ macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset.mSlotPeriodicity =\
+ srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
+ extractSlotOffset(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset,\
+ &macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset.mSlotOffset);
}
if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
{
*
* @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
* DRBs_ToBeModified_Item_t , lcId, DuLcCfg pointer,
- * RlcBearerCfg , UpTnlCfg, RlcUeCfg
+ * RlcBearerCfg , UpTnlCfg, DuRlcUeCfg
* @return void
*
* ****************************************************************/
DU_LOG("\nERROR --> DU_APP : Invalid IE received in F1SetupRsp:%ld",
f1SetRspMsg->protocolIEs.list.array[idx]->id);
}
- duProcF1SetupRsp();
}
+ duProcF1SetupRsp();
freeAperDecodeF1SetupRsp(f1SetRspMsg);
-
- duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
- DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
- if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
+
+ if(fillE2NodeComponentRspInfo(F1, duCfgParam.duId, E2_NODE_COMPONENT_ADD, recvBufLen, recvBuf) !=ROK)
{
- DU_LOG("\nERROR --> F1AP : Memory allocation failed to store the buf of F1setup response");
+ DU_LOG("\nERROR --> F1AP : Failed to add the e2 node in the list");
return RFAILED;
}
- memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
if(BuildAndSendE2SetupReq() != ROK)
{
*
* Functionality: added free part for the memory allocated by aper_decoder
*
-* @params[in] F1AP_PDU_t *f1apMsg
+* @params[in] F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf
* @return void
*
* ****************************************************************/
-uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
+
+uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
{
uint8_t ieIdx=0,transId=0;
GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
#endif
freeAperDecodeGnbDuAck(gnbDuAck);
+
+ if(fillE2NodeComponentRspInfo(F1,duCfgParam.duId, E2_NODE_COMPONENT_UPDATE, recvBufLen, recvBuf) !=ROK)
+ {
+ DU_LOG("\nERROR --> F1AP : Failed to update the e2 node in the list");
+ return RFAILED;
+ }
+
return ROK;
}
/******************************************************************
break;
case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
break;
+ case ProtocolIE_ID_id_DUtoCURRCInformation:
+ {
+ DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCInformation.\
+ cellGroupConfig.buf, ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.\
+ DUtoCURRCInformation.cellGroupConfig.size);
+ break;
+ }
case ProtocolIE_ID_id_DRBs_SetupMod_List:
{
FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
ret = ROK;
break;
}
+
FreeUeContextModResp(f1apMsg);
return ret;
}
case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
{
- procF1GNBDUCfgUpdAck(f1apMsg);
+ procF1GNBDUCfgUpdAck(f1apMsg, recvBufLen, recvBuf);
break;
}