+ while(1)
+ {
+ DU_LOG("\nF1AP : Building DU config update\n");
+ /* Allocate the memory for F1DuCfg */
+ DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
+ if(f1apDuCfg == NULLP)
+ {
+ DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
+ DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ if(f1apDuCfg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG("\nF1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apDuCfg->choice.initiatingMessage->procedureCode = \
+ ProcedureCode_id_gNBDUConfigurationUpdate;
+ f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
+ f1apDuCfg->choice.initiatingMessage->value.present = \
+ InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
+ duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
+ choice.GNBDUConfigurationUpdate;
+ elementCnt = 3;
+ duCfgUpdate->protocolIEs.list.count = elementCnt;
+ duCfgUpdate->protocolIEs.list.size = \
+ elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
+
+ /* Initialize the F1Setup members */
+ DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
+ if(duCfgUpdate->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG("F1AP : Memory allocation for F1RequestIEs failed");
+ break;
+ }
+ for(idx=0;idx<elementCnt;idx++)
+ {
+ DU_ALLOC(duCfgUpdate->protocolIEs.list.array[idx],sizeof(GNBDUConfigurationUpdateIEs_t));
+ if(duCfgUpdate->protocolIEs.list.array[idx] == NULLP)
+ {
+ break;
+ }
+ }
+
+ /*TransactionID*/
+ idx1 = 0;
+ duCfgUpdate->protocolIEs.list.array[idx1]->id=ProtocolIE_ID_id_TransactionID;
+ duCfgUpdate->protocolIEs.list.array[idx1]->criticality= Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[idx1]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
+ duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.TransactionID = \
+ TRANS_ID;
+
+ /*Served Cell to Modify */
+ idx1++;
+ duCfgUpdate->protocolIEs.list.array[idx1]->id = \
+ ProtocolIE_ID_id_Served_Cells_To_Modify_List;
+ duCfgUpdate->protocolIEs.list.array[idx1]->criticality =Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[idx1]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
+ cellsToModify = &duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.\
+ Served_Cells_To_Modify_List;
+ modifyCnt = 1;
+ cellsToModify->list.count = modifyCnt;
+ cellsToModify->list.size = \
+ modifyCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
+ DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
+ if(cellsToModify->list.array == NULLP)
+ {
+ break;
+ }
+ for(idy=0; idy<modifyCnt ;idy++)
+ {
+ DU_ALLOC(cellsToModify->list.array[idy],sizeof(\
+ Served_Cells_To_Modify_ItemIEs_t));
+ if(cellsToModify->list.array[idy] == NULLP)
+ {
+ break;
+ }
+ }
+ cellsToModify->list.array[0]->id = \
+ ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
+ cellsToModify->list.array[0]->criticality = Criticality_reject;
+ cellsToModify->list.array[0]->value.present =\
+ Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
+ modifyItem=&cellsToModify->list.array[0]->value.choice.\
+ Served_Cells_To_Modify_Item;
+
+ /*pLMN_Identity*/
+ modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
+ if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
+ {
+ break;
+ }
+ buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
+ &modifyItem->oldNRCGI.pLMN_Identity);
+
+ /*nRCellIdentity*/
+ modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
+ modifyItem->oldNRCGI.nRCellIdentity.size);
+ if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
+ {
+ break;
+ }
+ for (int tmp = 0;tmp < modifyItem->oldNRCGI.nRCellIdentity.size-1;tmp++)
+ {
+ modifyItem->oldNRCGI.nRCellIdentity.buf[tmp] = 0;
+ }
+ modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
+ modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
+ /*pLMN_Identity*/
+ /*nRCGI*/
+ modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
+ if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf == NULLP)
+ {
+ break;
+ }
+ buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
+ &modifyItem->served_Cell_Information.nRCGI.pLMN_Identity);
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
+ if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf == NULLP)
+ {
+ break;
+ }
+ for (int tmp = 0 ; tmp < modifyItem->served_Cell_Information.\
+ nRCGI.nRCellIdentity.size-1 ; tmp++)
+ {
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf[tmp] = 0;
+ }
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf[4] = 16;
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.bits_unused =4;
+ /*nRPCI*/
+ modifyItem->served_Cell_Information.nRPCI = \
+ duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
+ /*servedPLMNs*/
+ servPlmnCnt = 1;
+ modifyItem->served_Cell_Information.servedPLMNs.list.count = servPlmnCnt;
+ modifyItem->served_Cell_Information.servedPLMNs.list.size = \
+ servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
+ modifyItem->served_Cell_Information.servedPLMNs.list.size);
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array == NULLP)
+ {
+ break;
+ }
+ for(idy1=0;idy1<servPlmnCnt;idy1++)
+ {
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy1],\
+ sizeof(ServedPLMNs_Item_t));
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idy1]== NULLP)
+ {
+ break;
+ }
+ }
+ modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->pLMN_Identity.buf,modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->pLMN_Identity.size);
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->pLMN_Identity.buf == NULLP)
+ {
+ break;
+ }
+ buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
+ &modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->pLMN_Identity);
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->iE_Extensions == NULLP)
+ {
+ break;
+ }
+ extensionCnt=1;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.count = extensionCnt;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.size = extensionCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.size);
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->iE_Extensions->list.array == NULLP)
+ {
+ break;
+ }
+ for(idy2=0;idy2<extensionCnt;idy2++)
+ {
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->iE_Extensions->list.array[idy2],\
+ sizeof(ServedPLMNs_ItemExtIEs_t));
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[0]->iE_Extensions->list.array[idy2] == NULLP)
+ {
+ break;
+ }
+ }
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->criticality = Criticality_ignore;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.present = \
+ ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.count = 1;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.size = sizeof(SliceSupportItem_t *);
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array == NULLP)
+ {
+ break;
+ }
+
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0],sizeof( SliceSupportItem_t));
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0] == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sST.buf == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sST.buf[0] = 3;
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
+ DU_ALLOC(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD->size);
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD->buf == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD->buf[0] = 3;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD->buf[1] = 6;
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[0]->\
+ iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
+ list.array[0]->sNSSAI.sD->buf[2] = 9;
+
+ /*nR Mode Info with FDD*/
+ modifyItem->served_Cell_Information.nR_Mode_Info.present = \
+ NR_Mode_Info_PR_fDD;
+ DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,\
+ sizeof(FDD_Info_t));
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ uL_NRFreqInfo.freqBandListNr.list.count = 1;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
+ DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
+ fDD->uL_NRFreqInfo.freqBandListNr.list.\
+ array, modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ uL_NRFreqInfo.freqBandListNr.list.size);
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
+ fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
+ {
+ break;
+ }
+ DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->
+ uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
+ freqBandListNr.list.array[0]->freqBandIndicatorNr = \
+ duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
+ freqBand[0].nrFreqBand;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
+ freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
+ dlNrFreqInfo.nrArfcn;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ freqBandListNr.list.count = 1;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
+ DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ dL_NRFreqInfo.freqBandListNr.list.array,modifyItem->served_Cell_Information.nR_Mode_Info.\
+ choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
+ {
+ break;
+ }
+ DU_ALLOC(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ dL_NRFreqInfo.freqBandListNr.list.array[0],\
+ sizeof(FreqBandNrItem_t));
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ freqBandListNr.list.array[0]->freqBandIndicatorNr = \
+ duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
+ freqBand[0].nrFreqBand;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
+ freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
+
+ /*Transmission Bandwidth*/
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.ulTxBw.nrScs;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.ulTxBw.nrb;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.dlTxBw.nrScs;
+ modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
+ dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
+ f1Mode.mode.fdd.dlTxBw.nrb;
+ /*Measurement timing Config*/
+ modifyItem->served_Cell_Information.measurementTimingConfiguration.size = \
+ sizeof(uint8_t);
+ DU_ALLOC(modifyItem->served_Cell_Information.measurementTimingConfiguration.\
+ buf,modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
+ if(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf == NULLP)
+ {
+ break;
+ }
+ modifyItem->served_Cell_Information.measurementTimingConfiguration.\
+ buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
+
+ // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
+ /*GNB DU ID */
+ idx1++;
+ duCfgUpdate->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_ID;
+ duCfgUpdate->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ duCfgUpdate->protocolIEs.list.array[idx1]->value.present = \
+ GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
+ duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.size = \
+ sizeof(uint8_t);
+ DU_ALLOC(duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf,\
+ duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.size);
+ if(duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf == NULLP)
+ {
+ break;
+ }
+ duCfgUpdate->protocolIEs.list.array[idx1]->value.choice.GNB_DU_ID.buf[0] = \
+ duCfgParam.duId;
+
+ xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
+
+ /* Encode the DU Config Update type as APER */
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
+
+ /* Checking encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG("F1AP : Could not encode DUConfigUpdate structure (at %s)\n",encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\nF1AP : Created APER encoded buffer for DUConfigUpdate\n");
+ for(i=0; i< encBufSize; i++)
+ {
+ printf("%x",encBuf[i]);
+ }
+ }
+ /* Sending msg */
+ if(SendF1APMsg(DU_APP_MEM_REGION, DU_POOL) != ROK)
+ {
+ DU_LOG("\nF1AP : Sending GND-DU Config Update failed");
+ break;
+ }
+
+ ret = ROK;
+ break;
+ }
+ FreeDUConfigUpdate(f1apDuCfg);
+
+ return ret;
+}
+ /*******************************************************************
+ *
+ * @brief Deallocating memory of BuildAndSendDUConfigUpdate
+ *
+ * @details
+ *
+ * Function : FreeDUConfigUpdate
+ *
+ * Functionality: Deallocating memory of variables allocated in
+ * BuildAndSendDUConfigUpdate function
+ *
+ * @params[in] F1AP_PDU_t *f1apDuCfg
+ *
+ * @return ROK - void
+ *
+ * ****************************************************************/
+void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
+{
+ uint8_t i;
+ uint8_t idx;
+ GNBDUConfigurationUpdate_t *duCfgUpdate;
+ Served_Cells_To_Modify_List_t *cellsToModify;
+ Served_Cells_To_Modify_Item_t *modifyItem;
+ idx=0;
+ i=1;
+ if(f1apDuCfg != NULLP)
+ {
+ if(f1apDuCfg->choice.initiatingMessage != NULLP)
+ {
+ duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
+ value.choice.GNBDUConfigurationUpdate;
+ if(duCfgUpdate->protocolIEs.list.array != NULLP)
+ {
+ if(duCfgUpdate->protocolIEs.list.array[i] != NULLP)
+ {
+ cellsToModify = &duCfgUpdate->protocolIEs.list.array[i]->\
+ value.choice.Served_Cells_To_Modify_List;
+ if(cellsToModify->list.array != NULLP)
+ {
+ if(cellsToModify->list.array[idx] != NULLP)
+ {
+ modifyItem=&cellsToModify->list.array[idx]->value.choice.\
+ Served_Cells_To_Modify_Item;
+ if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
+ {
+ if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
+ != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
+ != NULLP)
+ {
+ if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[idx])
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->pLMN_Identity.buf != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions!= NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions->list.array != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions->list.array[idx])
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array !=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array[idx]!=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array[idx]->sNSSAI.sST.buf!=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array[idx]->sNSSAI.sD != NULLP)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array[idx]->sNSSAI.sD->buf!=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
+ !=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
+ fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
+ fDD->uL_NRFreqInfo.freqBandListNr.list.array[idx]!=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
+ fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
+ {
+ if(modifyItem->served_Cell_Information.nR_Mode_Info.\
+ choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
+ array[idx]!= NULLP)
+ {
+ if(modifyItem->served_Cell_Information.\
+ measurementTimingConfiguration.buf !=NULLP)
+ {
+ idx=2;
+ if(duCfgUpdate->protocolIEs.list.array[idx]->value.\
+ choice.GNB_DU_ID.buf!=NULLP)
+ {
+ DU_FREE(duCfgUpdate->protocolIEs.list.\
+ array[idx]->value.choice.GNB_DU_ID.buf,\
+ duCfgUpdate->protocolIEs.list.array[idx]->\
+ value.choice.GNB_DU_ID.size);
+ }
+ idx=0;
+ DU_FREE(modifyItem->served_Cell_Information.\
+ measurementTimingConfiguration.\
+ buf,modifyItem->served_Cell_Information.\
+ measurementTimingConfiguration.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.\
+ nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.\
+ list.array[idx],sizeof(FreqBandNrItem_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
+ .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
+ modifyItem->served_Cell_Information.nR_Mode_Info.\
+ choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
+ choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
+ array[idx],sizeof(FreqBandNrItem_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
+ choice.\
+ fDD->uL_NRFreqInfo.freqBandListNr.list.\
+ array,modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
+ fDD->uL_NRFreqInfo.freqBandListNr.list.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
+ fDD,sizeof(FDD_Info_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
+ SliceSupportList.\
+ list.array[idx]->sNSSAI.sD->buf,modifyItem->served_Cell_Information.\
+ servedPLMNs.list.array[idx]->iE_Extensions->list.array[idx]->\
+ extensionValue.choice.SliceSupportList.list.array[idx]->\
+ sNSSAI.sD->size);
+
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array[idx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array[idx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
+ servedPLMNs.\
+ list.array[idx]->iE_Extensions->list.array[idx]->extensionValue.choice.\
+ SliceSupportList.list.array[idx]->sNSSAI.sST.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array[idx],sizeof(SliceSupportItem_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.\
+ list.array,\
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->\
+ iE_Extensions->list.array[idx]->extensionValue.choice.SliceSupportList.list.size);
+ }
+ }
+ for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions->list.count;i++)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions->list.array[i],\
+ sizeof(ServedPLMNs_ItemExtIEs_t ));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.servedPLMNs.
+ list.array[idx]->iE_Extensions->list.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
+ array[idx]->pLMN_Identity.buf,
+ modifyItem->served_Cell_Information.servedPLMNs.list.array[idx]->pLMN_Identity.size);
+ }
+ }
+ for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
+ {
+ if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
+ != NULLP)
+ {
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
+ sizeof(ServedPLMNs_Item_t));
+ }
+ }
+ DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
+ modifyItem->served_Cell_Information.servedPLMNs.list.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
+ }
+ DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
+ modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
+ }
+ DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
+ modifyItem->oldNRCGI.nRCellIdentity.size);
+ }
+ DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
+ modifyItem->oldNRCGI.pLMN_Identity.size);
+ }
+ }
+ for(i=0; i<cellsToModify->list.count ;i++)
+ {
+ if(cellsToModify->list.array[i] != NULLP)
+ {
+ DU_FREE(cellsToModify->list.array[i],\
+ sizeof(Served_Cells_To_Modify_ItemIEs_t));
+ }
+ }
+ DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
+ }
+ }
+ for(i=0;i<duCfgUpdate->protocolIEs.list.count;i++)
+ {
+ if(duCfgUpdate->protocolIEs.list.array[i] !=NULLP)
+ {
+ DU_FREE(duCfgUpdate->protocolIEs.list.array[i],\
+ sizeof(GNBDUConfigurationUpdateIEs_t));
+ }
+ }
+ DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
+ }
+ DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ }
+ DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
+ }
+}
+ /*******************************************************************
+ *
+ * @brief free the ULRRCMessageTransfer
+ *
+ * @details
+ *
+ * Function : FreeULRRCMessageTransfer
+ *
+ * Functionality: Deallocating the memory of variable allocated in
+ * FreeULRRCMessageTransfer
+ *
+ * @params[in]
+ *
+ * @return ROK - void
+ *
+ ******************************************************************/
+void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
+{
+ uint8_t idx1;
+ ULRRCMessageTransfer_t *ulRRCMsg;
+
+ if(f1apMsg != NULLP)
+ {
+ if(f1apMsg->choice.initiatingMessage != NULLP)
+ {
+ ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
+ if(ulRRCMsg->protocolIEs.list.array != NULLP)
+ {
+ for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
+ {
+ if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
+ {
+ DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
+ }
+ }
+ DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
+ }
+ DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ }
+ DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
+ }
+}
+/*******************************************************************
+ *
+ * @brief Builds and sends the ULRRCMessageTransfer
+ *
+ * @details
+ *
+ * Function : BuildAndSendULRRCMessageTransfer
+ *
+ * Functionality: Constructs the UL RRC Message Transfer and sends
+ * it to the CU through SCTP.
+ *
+ * @params[in]
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildAndSendULRRCMessageTransfer()
+{
+ uint8_t elementCnt;
+ uint8_t idx1;
+ uint8_t idx;
+ F1AP_PDU_t *f1apMsg = NULL;
+ ULRRCMessageTransfer_t *ulRRCMsg;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
+ uint8_t ret =RFAILED;
+ while(1)
+ {
+ DU_LOG("\n F1AP : Building UL RRC Message Transfer Message\n");
+
+ DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
+ if(f1apMsg == NULLP)
+ {
+ DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+
+ f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
+ DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
+ if(f1apMsg->choice.initiatingMessage == NULLP)
+ {
+ DU_LOG(" F1AP : Memory allocation for F1AP-PDU failed");
+ break;
+ }
+ f1apMsg->choice.initiatingMessage->procedureCode = \
+ ProcedureCode_id_ULRRCMessageTransfer;
+ f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
+ f1apMsg->choice.initiatingMessage->value.present = \
+ InitiatingMessage__value_PR_ULRRCMessageTransfer;
+ ulRRCMsg =
+ &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
+ elementCnt = 3;
+ ulRRCMsg->protocolIEs.list.count = elementCnt;
+ ulRRCMsg->protocolIEs.list.size = \
+ elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
+
+ /* Initialize the F1Setup members */
+ DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
+ if(ulRRCMsg->protocolIEs.list.array == NULLP)
+ {
+ DU_LOG(" F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
+ break;
+ }
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
+ if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
+ {
+ break;
+ }
+ }
+
+ idx1 = 0;
+
+ /*GNB CU UE F1AP ID*/
+ ulRRCMsg->protocolIEs.list.array[idx1]->id = \
+ ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
+ ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = CU_ID;
+
+ /*GNB DU UE F1AP ID*/
+ idx1++;
+ ulRRCMsg->protocolIEs.list.array[idx1]->id = \
+ ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
+ ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = DU_ID;
+
+ /*SRBID*/
+ idx1++;
+ ulRRCMsg->protocolIEs.list.array[idx1]->id = \
+ ProtocolIE_ID_id_SRBID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
+ ULRRCMessageTransferIEs__value_PR_SRBID;
+ ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = UL_SRBID;
+
+ /*RRCContainer*/
+ //YET TO FILL
+
+ xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
+
+ /* Encode the F1SetupRequest type as APER */
+ cmMemset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
+ encBuf);
+ /* Encode results */
+ if(encRetVal.encoded == ENCODE_FAIL)
+ {
+ DU_LOG( "\n F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
+ encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
+ break;
+ }
+ else
+ {
+ DU_LOG("\n F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x",encBuf[i]);
+ }
+ }
+
+ /* Sending msg */
+ if(SendF1APMsg(DU_APP_MEM_REGION,DU_POOL) != ROK)
+ {
+ DU_LOG("\n F1AP : Sending UL RRC Message Transfer Failed");
+ break;
+ }
+ ret = ROK;
+ break;
+ }
+ FreeULRRCMessageTransfer(f1apMsg);
+
+ return ret;
+}/* End of BuildAndSendULRRCMessageTransfer*/
+
+/*******************************************************************
+*
+* @brief Builds tag config
+*
+* @details
+*
+* Function : BuildTagConfig
+*
+* Functionality: Builds tag config in MacCellGroupConfig
+*
+* @params[in] TAG_Config *tag_Config
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
+{
+ struct TAG_Config__tag_ToAddModList *tagList;
+ uint8_t idx, elementCnt;
+
+ tagConfig->tag_ToReleaseList = NULLP;
+ tagConfig->tag_ToAddModList = NULLP;
+ DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
+ if(!tagConfig->tag_ToAddModList)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+
+ elementCnt = 1; //ODU_VALUE_ONE;
+ tagList = tagConfig->tag_ToAddModList;
+ tagList->list.count = elementCnt;
+ tagList->list.size = elementCnt * sizeof(struct TAG *);
+
+ tagList->list.array = NULLP;
+ DU_ALLOC(tagList->list.array, tagList->list.size);
+ if(!tagList->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+
+ for(idx=0; idx<tagList->list.count; idx++)
+ {
+ tagList->list.array[idx] = NULLP;
+ DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
+ if(!tagList->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildTagConfig");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ tagList->list.array[idx]->tag_Id = TAG_ID;
+ tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
+
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Builds PHR Config
+*
+* @details
+*
+* Function : BuildPhrConfig
+*
+* Functionality: Builds phrConfig in MacCellGroupConfig
+*
+* @params[in] PHR Config *
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
+{
+
+ phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
+ phrConfig->choice.setup = NULLP;
+ DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
+ if(!phrConfig->choice.setup)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildPhrConfig");
+ return RFAILED;
+ }
+
+ phrConfig->choice.setup->phr_PeriodicTimer = PHR_PERIODIC_TMR;
+ phrConfig->choice.setup->phr_ProhibitTimer = PHR_PROHIBHIT_TMR;
+ phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
+ phrConfig->choice.setup->multiplePHR = false;
+ phrConfig->choice.setup->dummy = false;
+ phrConfig->choice.setup->phr_Type2OtherCell = false;
+ phrConfig->choice.setup->phr_ModeOtherCG = PHR_MODE_OTHER_CG;
+
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Builds BSR Config
+*
+* @details
+*
+* Function : BuildBsrConfig
+*
+* Functionality: Builds BuildBsrConfig in MacCellGroupConfig
+*
+* @params[in] BSR_Config *bsrConfig
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
+{
+ bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
+ bsrConfig->retxBSR_Timer = RETX_BSR_TMR;
+ bsrConfig->logicalChannelSR_DelayTimer = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Builds scheduling request config
+*
+* @details
+*
+* Function : BuildSchedulingReqConfig
+*
+* Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
+*
+* @params[in] SchedulingRequestConfig *schedulingRequestConfig
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
+{
+ struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
+ uint8_t idx, elementCnt;
+
+ schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
+ DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
+ sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
+ if(!schedulingRequestConfig->schedulingRequestToAddModList)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+
+ elementCnt = 1; //ODU_VALUE_ONE;
+ schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
+ schReqList->list.count = elementCnt;
+ schReqList->list.size = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
+
+ schReqList->list.array = NULLP;
+ DU_ALLOC(schReqList->list.array, schReqList->list.size);
+ if(!schReqList->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+
+ for(idx=0;idx<schReqList->list.count; idx++)
+ {
+ schReqList->list.array[idx] = NULLP;
+ DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
+ if(!schReqList->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
+
+ schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
+ DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
+ if(!schReqList->list.array[idx]->sr_ProhibitTimer)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildSchedulingReqConfig");
+ return RFAILED;
+ }
+ *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
+ schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
+ schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Builds RLC Config
+*
+* @details
+*
+* Function : BuildRlcConfig
+*
+* Functionality: Builds RLC Config in BuildRlcBearerToAddModList
+*
+* @params[in] RLC_Config *rlcConfig
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
+{
+
+ rlcConfig->present = RLC_Config_PR_am;
+
+ rlcConfig->choice.am = NULLP;
+ DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
+ if(!rlcConfig->choice.am)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+
+ /* UL */
+ rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
+ DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
+ 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;
+ rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold = MAX_RETX_THRESHOLD;
+
+ /* DL */
+ rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
+ DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
+ if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcConfig");
+ return RFAILED;
+ }
+ *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
+ rlcConfig->choice.am->dl_AM_RLC.t_Reassembly = T_REASSEMBLY;
+ rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit = T_STATUS_PROHIBHIT;
+
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Builds MAC LC Config
+*
+* @details
+*
+* Function : BuildMacLCConfig
+*
+* Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
+*
+* @params[in] struct LogicalChannelConfig macLcConfig
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
+{
+
+ macLcConfig->ul_SpecificParameters = NULLP;
+ DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
+ if(!macLcConfig->ul_SpecificParameters)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
+ return RFAILED;
+ }
+
+ macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
+ macLcConfig->ul_SpecificParameters->prioritisedBitRate = PRIORTISIED_BIT_RATE;
+ macLcConfig->ul_SpecificParameters->bucketSizeDuration = BUCKET_SIZE_DURATION;
+ macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
+ macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
+ macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
+ macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
+
+ macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
+ DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup, sizeof(long));
+ if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
+ return RFAILED;
+ }
+ *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
+
+ macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
+ DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID, sizeof(SchedulingRequestId_t));
+ if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildMacLCConfig");
+ return RFAILED;
+ }
+ *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
+
+ macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
+ macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
+ macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
+
+ return ROK;
+}
+
+/*******************************************************************
+*
+* @brief Builds RLC Bearer to Add/Mod list
+*
+* @details
+*
+* Function :BuildRlcBearerToAddModList
+*
+* Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
+*
+* @params[in] rlc_BearerToAddModList
+*
+* @return ROK - success
+* RFAILED - failure
+*
+* ****************************************************************/
+uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
+{
+ uint8_t idx, elementCnt;
+
+ elementCnt = 1;
+ rlcBearerList->list.count = elementCnt;
+ rlcBearerList->list.size = elementCnt * sizeof(struct RLC_BearerConfig *);
+
+ rlcBearerList->list.array = NULLP;
+ DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
+ if(!rlcBearerList->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ for(idx=0; idx<rlcBearerList->list.count; idx++)
+ {
+ rlcBearerList->list.array[idx] = NULLP;
+ DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
+ if(!rlcBearerList->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ rlcBearerList->list.array[idx]->logicalChannelIdentity = RLC_LCID;
+
+ DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
+ if(!rlcBearerList->list.array[idx]->servedRadioBearer)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->servedRadioBearer->present = RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
+ rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = SRB_ID_1;
+
+ rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
+ rlcBearerList->list.array[idx]->rlc_Config = NULLP;
+ DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
+ if(!rlcBearerList->list.array[idx]->rlc_Config)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
+ {
+ DU_LOG("\nF1AP : BuildRlcConfig failed");
+ return RFAILED;
+ }
+
+ rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
+ DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
+ if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
+ {
+ DU_LOG("\nF1AP : Memory allocation failure in BuildRlcBearerToAddModList");
+ return RFAILED;
+ }
+
+ if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
+ {
+ DU_LOG("\nF1AP : BuildMacLCConfig failed");
+ return RFAILED;
+ }
+
+ return ROK;
+}
+
+/*******************************************************************
+ *
+ * @brief Build Control resource set to add/modify list
+ *
+ * @details
+ *
+ * Function : BuildControlRSetToAddModList
+ *
+ * Functionality: Build Control resource set to add/modify list
+ *
+ * @params[in]
+ * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
+ *
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t BuildControlRSetToAddModList
+(
+struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
+)
+{
+ uint8_t idx;
+ uint8_t elementCnt;
+ uint8_t numBytes;
+ uint8_t byteIdx;
+ uint8_t bitsUnused;
+ struct ControlResourceSet *controlRSet;
+
+ elementCnt = 1;
+ controlRSetList->list.count = elementCnt;
+ controlRSetList->list.size = \
+ elementCnt * sizeof(struct ControlResourceSet *);
+
+ controlRSetList->list.array = NULLP;
+ DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
+ if(!controlRSetList->list.array)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ for(idx = 0; idx < elementCnt; idx++)
+ {
+ controlRSetList->list.array[idx] = NULLP;
+ DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
+ if(!controlRSetList->list.array[idx])
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ }
+
+ idx=0;
+ controlRSet = controlRSetList->list.array[idx];
+
+ controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
+
+ /* Values taken from reference logs :
+ * size 6 bytes
+ * 3 LSBs unsued
+ * Bit string stored ff0000000000
+ */
+ numBytes = 6;
+ bitsUnused = 3;
+ controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
+
+ controlRSet->frequencyDomainResources.buf = NULLP;
+ DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
+ controlRSet->frequencyDomainResources.size);
+ if(!controlRSet->frequencyDomainResources.buf)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+ byteIdx = 0;
+ controlRSet->frequencyDomainResources.buf[byteIdx] = 255; /* setting 8 MSBs i.e. ff */
+ for(byteIdx = 1; byteIdx < numBytes; byteIdx++)
+ {
+ controlRSet->frequencyDomainResources.buf[byteIdx] = 0;
+ }
+ controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
+
+ controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
+ controlRSet->cce_REG_MappingType.present = \
+ ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
+
+ controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
+ controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
+ controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
+ controlRSet->tci_PresentInDCI = NULLP;
+#if 0
+ uint8_t tciStateIdx;
+
+ DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
+ sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
+ if(!controlRset->tci_StatesPDCCH_ToAddList)
+ {
+ DU_LOG("\nF1AP : Memory allocation failed in BuildControlRSetToAddModList");
+ return RFAILED;
+ }
+
+ elementCnt = 1;
+ controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
+ controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
+ DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
+ controlRset->tci_StatesPDCCH_ToAddList->list.size)
+ if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)