From 1cefbdb87f0247b6193808bec81a2b407031e34c Mon Sep 17 00:00:00 2001 From: Robert Schmidt Date: Sun, 11 Feb 2024 17:45:04 +0100 Subject: [PATCH] F1AP for gNB-DU config update & ack in CU --- openair2/F1AP/f1ap_cu_interface_management.c | 345 ++++++++++++++++++- openair2/F1AP/f1ap_cu_interface_management.h | 7 +- openair2/F1AP/f1ap_cu_task.c | 3 + openair2/F1AP/f1ap_handlers.c | 2 +- openair2/RRC/NR/mac_rrc_dl_f1ap.c | 6 +- 5 files changed, 353 insertions(+), 10 deletions(-) diff --git a/openair2/F1AP/f1ap_cu_interface_management.c b/openair2/F1AP/f1ap_cu_interface_management.c index 41c783a2db..c44ab89018 100644 --- a/openair2/F1AP/f1ap_cu_interface_management.c +++ b/openair2/F1AP/f1ap_cu_interface_management.c @@ -431,17 +431,352 @@ int CU_send_F1_SETUP_FAILURE(sctp_assoc_t assoc_id, const f1ap_setup_failure_t * int CU_handle_gNB_DU_CONFIGURATION_UPDATE(instance_t instance, sctp_assoc_t assoc_id, uint32_t stream, F1AP_F1AP_PDU_t *pdu) { - AssertFatal(1==0,"Not implemented yet\n"); + LOG_D(F1AP, "CU_handle_gNB_DU_CONFIGURATION_UPDATE\n"); + F1AP_GNBDUConfigurationUpdate_t *container; + F1AP_GNBDUConfigurationUpdateIEs_t *ie; + int i = 0; + DevAssert(pdu != NULL); + container = &pdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate; + + /* gNB DU Configuration Update == Non UE-related procedure -> stream 0 */ + if (stream != 0) { + LOG_W(F1AP, "[SCTP %d] Received f1 setup request on stream != 0 (%d)\n", assoc_id, stream); + } + + MessageDef *message_p = itti_alloc_new_message(TASK_CU_F1, 0, F1AP_GNB_DU_CONFIGURATION_UPDATE); + message_p->ittiMsgHeader.originInstance = assoc_id; + f1ap_gnb_du_configuration_update_t *req = &F1AP_GNB_DU_CONFIGURATION_UPDATE(message_p); + + /* 3GPP TS 38.473 Transaction ID*/ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, ie, container, F1AP_ProtocolIE_ID_id_TransactionID, true); + req->transaction_id = ie->value.choice.TransactionID; + LOG_D(F1AP, "req->transaction_id %lu \n", req->transaction_id); + + /* 3GPP TS 38.473 Served Cells To Add List */ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, + ie, + container, + F1AP_ProtocolIE_ID_id_Served_Cells_To_Add_List, + false); + + if (ie != NULL) { + req->num_cells_to_add = ie->value.choice.Served_Cells_To_Add_List.list.count; + LOG_D(F1AP, "req->num_cells_to_add %d \n", req->num_cells_to_add); + + for (i = 0; i < req->num_cells_to_add; i++) { + F1AP_Served_Cells_To_Add_Item_t *served_cells_item = + &((F1AP_Served_Cells_To_Add_ItemIEs_t *)ie->value.choice.Served_Cells_To_Add_List.list.array[i]) + ->value.choice.Served_Cells_To_Add_Item; + F1AP_Served_Cell_Information_t *servedCellInformation = &served_cells_item->served_Cell_Information; + /* tac */ + if (servedCellInformation->fiveGS_TAC) { + req->cell_to_add[i].info.tac = malloc(sizeof(*req->cell_to_add[i].info.tac)); + AssertFatal(req->cell_to_add[i].info.tac != NULL, "out of memory\n"); + OCTET_STRING_TO_INT24(servedCellInformation->fiveGS_TAC, *req->cell_to_add[i].info.tac); + LOG_D(F1AP, "req->tac[%d] %d \n", i, *req->cell_to_add[i].info.tac); + } + + /* - nRCGI */ + TBCD_TO_MCC_MNC(&(servedCellInformation->nRCGI.pLMN_Identity), + req->cell_to_add[i].info.plmn.mcc, + req->cell_to_add[i].info.plmn.mnc, + req->cell_to_add[i].info.plmn.mnc_digit_length); + // NR cellID + BIT_STRING_TO_NR_CELL_IDENTITY(&servedCellInformation->nRCGI.nRCellIdentity, req->cell_to_add[i].info.nr_cellid); + LOG_D(F1AP, + "[SCTP %d] Received nRCGI: MCC %d, MNC %d, CELL_ID %llu\n", + assoc_id, + req->cell_to_add[i].info.plmn.mcc, + req->cell_to_add[i].info.plmn.mnc, + (long long unsigned int)req->cell_to_add[i].info.nr_cellid); + + /* - nRPCI */ + req->cell_to_add[i].info.nr_pci = servedCellInformation->nRPCI; + LOG_D(F1AP, "req->nr_pci[%d] %d \n", i, req->cell_to_add[i].info.nr_pci); + + // FDD Cells + if (servedCellInformation->nR_Mode_Info.present == F1AP_NR_Mode_Info_PR_fDD) { + req->cell_to_add[i].info.mode = F1AP_MODE_FDD; + f1ap_fdd_info_t *FDDs = &req->cell_to_add[i].info.fdd; + F1AP_FDD_Info_t *fDD_Info = servedCellInformation->nR_Mode_Info.choice.fDD; + FDDs->ul_freqinfo.arfcn = fDD_Info->uL_NRFreqInfo.nRARFCN; + AssertFatal(fDD_Info->uL_NRFreqInfo.freqBandListNr.list.count == 1, "cannot handle more than one frequency band\n"); + for (int f = 0; f < fDD_Info->uL_NRFreqInfo.freqBandListNr.list.count; f++) { + F1AP_FreqBandNrItem_t *FreqItem = fDD_Info->uL_NRFreqInfo.freqBandListNr.list.array[f]; + FDDs->ul_freqinfo.band = FreqItem->freqBandIndicatorNr; + AssertFatal(FreqItem->supportedSULBandList.list.count == 0, "cannot handle SUL bands!\n"); + } + FDDs->dl_freqinfo.arfcn = fDD_Info->dL_NRFreqInfo.nRARFCN; + int dlBands = fDD_Info->dL_NRFreqInfo.freqBandListNr.list.count; + AssertFatal(dlBands == 0, "cannot handled more than one frequency band\n"); + for (int dlB = 0; dlB < dlBands; dlB++) { + F1AP_FreqBandNrItem_t *FreqItem = fDD_Info->dL_NRFreqInfo.freqBandListNr.list.array[dlB]; + FDDs->dl_freqinfo.band = FreqItem->freqBandIndicatorNr; + int num_available_supported_SULBands = FreqItem->supportedSULBandList.list.count; + AssertFatal(num_available_supported_SULBands == 0, "cannot handle SUL bands!\n"); + } + FDDs->ul_tbw.scs = fDD_Info->uL_Transmission_Bandwidth.nRSCS; + FDDs->ul_tbw.nrb = nrb_lut[fDD_Info->uL_Transmission_Bandwidth.nRNRB]; + FDDs->dl_tbw.scs = fDD_Info->dL_Transmission_Bandwidth.nRSCS; + FDDs->dl_tbw.nrb = nrb_lut[fDD_Info->dL_Transmission_Bandwidth.nRNRB]; + } else if (servedCellInformation->nR_Mode_Info.present == F1AP_NR_Mode_Info_PR_tDD) { + req->cell_to_add[i].info.mode = F1AP_MODE_TDD; + f1ap_tdd_info_t *TDDs = &req->cell_to_add[i].info.tdd; + F1AP_TDD_Info_t *tDD_Info = servedCellInformation->nR_Mode_Info.choice.tDD; + TDDs->freqinfo.arfcn = tDD_Info->nRFreqInfo.nRARFCN; + AssertFatal(tDD_Info->nRFreqInfo.freqBandListNr.list.count == 1, "cannot handle more than one frequency band\n"); + for (int f = 0; f < tDD_Info->nRFreqInfo.freqBandListNr.list.count; f++) { + struct F1AP_FreqBandNrItem *FreqItem = tDD_Info->nRFreqInfo.freqBandListNr.list.array[f]; + TDDs->freqinfo.band = FreqItem->freqBandIndicatorNr; + int num_available_supported_SULBands = FreqItem->supportedSULBandList.list.count; + AssertFatal(num_available_supported_SULBands == 0, "cannot hanlde SUL bands!\n"); + } + TDDs->tbw.scs = tDD_Info->transmission_Bandwidth.nRSCS; + TDDs->tbw.nrb = nrb_lut[tDD_Info->transmission_Bandwidth.nRNRB]; + } else { + AssertFatal(false, "unknown NR Mode info %d\n", servedCellInformation->nR_Mode_Info.present); + } + + struct F1AP_GNB_DU_System_Information *DUsi = served_cells_item->gNB_DU_System_Information; + // System Information + req->cell_to_add[i].sys_info = calloc(1, sizeof(*req->cell_to_add[i].sys_info)); + AssertFatal(req->cell_to_add[i].sys_info != NULL, "out of memory\n"); + f1ap_gnb_du_system_info_t *sys_info = req->cell_to_add[i].sys_info; + /* mib */ + sys_info->mib = calloc(DUsi->mIB_message.size, sizeof(char)); + memcpy(sys_info->mib, DUsi->mIB_message.buf, DUsi->mIB_message.size); + sys_info->mib_length = DUsi->mIB_message.size; + /* sib1 */ + sys_info->sib1 = calloc(DUsi->sIB1_message.size, sizeof(char)); + memcpy(sys_info->sib1, DUsi->sIB1_message.buf, DUsi->sIB1_message.size); + sys_info->sib1_length = DUsi->sIB1_message.size; + } + } else { + req->num_cells_to_add = 0; + } + /* 3GPP TS 38.473 Served Cells To Modify List */ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, + ie, + container, + F1AP_ProtocolIE_ID_id_Served_Cells_To_Modify_List, + false); + + if (ie) { + req->num_cells_to_modify = ie->value.choice.Served_Cells_To_Modify_List.list.count; + LOG_D(F1AP, "req->num_cells_to_modify %d \n", req->num_cells_to_modify); + + for (i = 0; i < req->num_cells_to_modify; i++) { + F1AP_Served_Cells_To_Modify_Item_t *served_cells_item = + &((F1AP_Served_Cells_To_Modify_ItemIEs_t *)ie->value.choice.Served_Cells_To_Modify_List.list.array[i]) + ->value.choice.Served_Cells_To_Modify_Item; + + /* OLD NRCGI */ + TBCD_TO_MCC_MNC(&(served_cells_item->oldNRCGI.pLMN_Identity), + req->cell_to_modify[i].old_plmn.mcc, + req->cell_to_modify[i].old_plmn.mnc, + req->cell_to_modify[i].old_plmn.mnc_digit_length); + + BIT_STRING_TO_NR_CELL_IDENTITY(&served_cells_item->oldNRCGI.nRCellIdentity, req->cell_to_modify[i].old_nr_cellid); + + F1AP_Served_Cell_Information_t *servedCellInformation = &served_cells_item->served_Cell_Information; + /* SERVED CELL INFORMATION*/ + /* tac */ + if (servedCellInformation->fiveGS_TAC) { + req->cell_to_modify[i].info.tac = malloc(sizeof(*req->cell_to_modify[i].info.tac)); + AssertFatal(req->cell_to_modify[i].info.tac != NULL, "out of memory\n"); + OCTET_STRING_TO_INT16(servedCellInformation->fiveGS_TAC, *req->cell_to_modify[i].info.tac); + LOG_D(F1AP, "req->tac[%d] %d \n", i, *req->cell_to_modify[i].info.tac); + } + + /* - nRCGI */ + TBCD_TO_MCC_MNC(&(servedCellInformation->nRCGI.pLMN_Identity), + req->cell_to_modify[i].info.plmn.mcc, + req->cell_to_modify[i].info.plmn.mnc, + req->cell_to_modify[i].info.plmn.mnc_digit_length); + // NR cellID + BIT_STRING_TO_NR_CELL_IDENTITY(&servedCellInformation->nRCGI.nRCellIdentity, req->cell_to_modify[i].info.nr_cellid); + LOG_D(F1AP, + "[SCTP %d] Received nRCGI: MCC %d, MNC %d, CELL_ID %llu\n", + assoc_id, + req->cell_to_modify[i].info.plmn.mcc, + req->cell_to_modify[i].info.plmn.mnc, + (long long unsigned int)req->cell_to_modify[i].info.nr_cellid); + + /* - nRPCI */ + req->cell_to_modify[i].info.nr_pci = servedCellInformation->nRPCI; + LOG_D(F1AP, "req->nr_pci[%d] %d \n", i, req->cell_to_modify[i].info.nr_pci); + + // FDD Cells + if (servedCellInformation->nR_Mode_Info.present == F1AP_NR_Mode_Info_PR_fDD) { + req->cell_to_modify[i].info.mode = F1AP_MODE_FDD; + f1ap_fdd_info_t *FDDs = &req->cell_to_modify[i].info.fdd; + F1AP_FDD_Info_t *fDD_Info = servedCellInformation->nR_Mode_Info.choice.fDD; + FDDs->ul_freqinfo.arfcn = fDD_Info->uL_NRFreqInfo.nRARFCN; + AssertFatal(fDD_Info->uL_NRFreqInfo.freqBandListNr.list.count == 1, "cannot handle more than one frequency band\n"); + for (int f = 0; f < fDD_Info->uL_NRFreqInfo.freqBandListNr.list.count; f++) { + F1AP_FreqBandNrItem_t *FreqItem = fDD_Info->uL_NRFreqInfo.freqBandListNr.list.array[f]; + FDDs->ul_freqinfo.band = FreqItem->freqBandIndicatorNr; + AssertFatal(FreqItem->supportedSULBandList.list.count == 0, "cannot handle SUL bands!\n"); + } + FDDs->dl_freqinfo.arfcn = fDD_Info->dL_NRFreqInfo.nRARFCN; + int dlBands = fDD_Info->dL_NRFreqInfo.freqBandListNr.list.count; + AssertFatal(dlBands == 0, "cannot handled more than one frequency band\n"); + for (int dlB = 0; dlB < dlBands; dlB++) { + F1AP_FreqBandNrItem_t *FreqItem = fDD_Info->dL_NRFreqInfo.freqBandListNr.list.array[dlB]; + FDDs->dl_freqinfo.band = FreqItem->freqBandIndicatorNr; + int num_available_supported_SULBands = FreqItem->supportedSULBandList.list.count; + AssertFatal(num_available_supported_SULBands == 0, "cannot handle SUL bands!\n"); + } + FDDs->ul_tbw.scs = fDD_Info->uL_Transmission_Bandwidth.nRSCS; + FDDs->ul_tbw.nrb = nrb_lut[fDD_Info->uL_Transmission_Bandwidth.nRNRB]; + FDDs->dl_tbw.scs = fDD_Info->dL_Transmission_Bandwidth.nRSCS; + FDDs->dl_tbw.nrb = nrb_lut[fDD_Info->dL_Transmission_Bandwidth.nRNRB]; + } else if (servedCellInformation->nR_Mode_Info.present == F1AP_NR_Mode_Info_PR_tDD) { + req->cell_to_modify[i].info.mode = F1AP_MODE_TDD; + f1ap_tdd_info_t *TDDs = &req->cell_to_modify[i].info.tdd; + F1AP_TDD_Info_t *tDD_Info = servedCellInformation->nR_Mode_Info.choice.tDD; + TDDs->freqinfo.arfcn = tDD_Info->nRFreqInfo.nRARFCN; + AssertFatal(tDD_Info->nRFreqInfo.freqBandListNr.list.count == 1, "cannot handle more than one frequency band\n"); + for (int f = 0; f < tDD_Info->nRFreqInfo.freqBandListNr.list.count; f++) { + struct F1AP_FreqBandNrItem *FreqItem = tDD_Info->nRFreqInfo.freqBandListNr.list.array[f]; + TDDs->freqinfo.band = FreqItem->freqBandIndicatorNr; + int num_available_supported_SULBands = FreqItem->supportedSULBandList.list.count; + AssertFatal(num_available_supported_SULBands == 0, "cannot hanlde SUL bands!\n"); + } + TDDs->tbw.scs = tDD_Info->transmission_Bandwidth.nRSCS; + TDDs->tbw.nrb = nrb_lut[tDD_Info->transmission_Bandwidth.nRNRB]; + } else { + AssertFatal(false, "unknown NR Mode info %d\n", servedCellInformation->nR_Mode_Info.present); + } + // TODO: Measurement Config + + /*gNB DU SYSTEM INFORMATION */ + struct F1AP_GNB_DU_System_Information *DUsi = served_cells_item->gNB_DU_System_Information; + if (DUsi != NULL) { + // System Information + req->cell_to_modify[i].sys_info = calloc(1, sizeof(*req->cell_to_modify[i].sys_info)); + AssertFatal(req->cell_to_modify[i].sys_info != NULL, "out of memory\n"); + f1ap_gnb_du_system_info_t *sys_info = req->cell_to_modify[i].sys_info; + /* mib */ + sys_info->mib = calloc(DUsi->mIB_message.size, sizeof(char)); + AssertFatal(req->cell_to_modify[i].sys_info->mib != NULL, "out of memory\n"); + memcpy(sys_info->mib, DUsi->mIB_message.buf, DUsi->mIB_message.size); + sys_info->mib_length = DUsi->mIB_message.size; + + /* sib1 */ + sys_info->sib1 = calloc(DUsi->sIB1_message.size, sizeof(char)); + AssertFatal(req->cell_to_modify[i].sys_info->sib1 != NULL, "out of memory\n"); + memcpy(sys_info->sib1, DUsi->sIB1_message.buf, DUsi->sIB1_message.size); + sys_info->sib1_length = DUsi->sIB1_message.size; + } + } + } else { + req->num_cells_to_modify = 0; + } + + /* 3GPP TS 38.473 Served Cells To Delete List */ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, + ie, + container, + F1AP_ProtocolIE_ID_id_Served_Cells_To_Delete_List, + false); + if (ie) { + req->num_cells_to_delete = ie->value.choice.Served_Cells_To_Delete_List.list.count; + LOG_D(F1AP, "req->num_cells_to_delete %d \n", req->num_cells_to_delete); + + for (i = 0; i < req->num_cells_to_delete; i++) { + F1AP_Served_Cells_To_Delete_Item_t *served_cells_item = + &((F1AP_Served_Cells_To_Delete_ItemIEs_t *)ie->value.choice.Served_Cells_To_Delete_List.list.array[i]) + ->value.choice.Served_Cells_To_Delete_Item; + /* - Old nRCGI */ + TBCD_TO_MCC_MNC(&(served_cells_item->oldNRCGI.pLMN_Identity), + req->cell_to_delete[i].plmn.mcc, + req->cell_to_delete[i].plmn.mnc, + req->cell_to_delete[i].plmn.mnc_digit_length); + // NR cellID + BIT_STRING_TO_NR_CELL_IDENTITY(&served_cells_item->oldNRCGI.nRCellIdentity, req->cell_to_delete[i].nr_cellid); + LOG_D(F1AP, + "[SCTP %d] Received nRCGI to delete: MCC %d, MNC %d, CELL_ID %llu\n", + assoc_id, + req->cell_to_delete[i].plmn.mcc, + req->cell_to_delete[i].plmn.mnc, + (long long unsigned int)req->cell_to_delete[i].nr_cellid); + } + } else { + req->num_cells_to_delete = 0; + } + + /* 3GPP TS 38.473 Cells Status List */ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, ie, container, F1AP_ProtocolIE_ID_id_Cells_Status_List, false); + + /* 3GPP TS 38.473 Dedicated SI Delivery Needed UE List */ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, + ie, + container, + F1AP_ProtocolIE_ID_id_Dedicated_SIDelivery_NeededUE_List, + false); + + /* 3GPP TS 38.473 gNB-DU ID */ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, ie, container, F1AP_ProtocolIE_ID_id_gNB_DU_ID, false); + if (ie != NULL) + asn_INTEGER2ulong(&ie->value.choice.GNB_DU_ID, req->gNB_DU_ID); + + /* 3GPP TS 38.473 gNB-DU TNL Association To Remove List */ + F1AP_FIND_PROTOCOLIE_BY_ID(F1AP_GNBDUConfigurationUpdateIEs_t, + ie, + container, + F1AP_ProtocolIE_ID_id_GNB_DU_TNL_Association_To_Remove_List, + false); + + LOG_D(F1AP, "Sending F1AP_GNB_DU_CONFIGURATION_UPDATE ITTI message \n"); + itti_send_msg_to_task(TASK_RRC_GNB, GNB_MODULE_ID_TO_INSTANCE(instance), message_p); + return 0; } int CU_send_gNB_DU_CONFIGURATION_FAILURE(sctp_assoc_t assoc_id, - F1AP_GNBDUConfigurationUpdateFailure_t *GNBDUConfigurationUpdateFailure) { + f1ap_gnb_du_configuration_update_failure_t *GNBDUConfigurationUpdateFailure) +{ AssertFatal(1==0,"Not implemented yet\n"); } -int CU_send_gNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE(sctp_assoc_t assoc_id, - F1AP_GNBDUConfigurationUpdateAcknowledge_t *GNBDUConfigurationUpdateAcknowledge) { - AssertFatal(1==0,"Not implemented yet\n"); +int CU_send_gNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE( + sctp_assoc_t assoc_id, + f1ap_gnb_du_configuration_update_acknowledge_t *GNBDUConfigurationUpdateAcknowledge) +{ + F1AP_F1AP_PDU_t pdu = {}; + uint8_t *buffer; + uint32_t len; + + /* Create */ + /* 0. Message */ + + pdu.present = F1AP_F1AP_PDU_PR_successfulOutcome; + asn1cCalloc(pdu.choice.successfulOutcome, succOut); + succOut->procedureCode = F1AP_ProcedureCode_id_gNBDUConfigurationUpdate; + succOut->criticality = F1AP_Criticality_reject; + succOut->value.present = F1AP_SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge; + F1AP_GNBDUConfigurationUpdateAcknowledge_t *ack = &succOut->value.choice.GNBDUConfigurationUpdateAcknowledge; + + /* Mandatory */ + /* Transaction Id */ + asn1cSequenceAdd(ack->protocolIEs.list, F1AP_GNBDUConfigurationUpdateAcknowledgeIEs_t, ie1); + ie1->id = F1AP_ProtocolIE_ID_id_TransactionID; + ie1->criticality = F1AP_Criticality_reject; + ie1->value.present = F1AP_GNBDUConfigurationUpdateAcknowledgeIEs__value_PR_TransactionID; + ie1->value.choice.TransactionID = GNBDUConfigurationUpdateAcknowledge->transaction_id; + + /* Todo add optional fields */ + /* encode */ + + if (f1ap_encode_pdu(&pdu, &buffer, &len) < 0) { + LOG_E(F1AP, "Failed to encode F1 gNB-DU CONFIGURATION UPDATE\n"); + return -1; + } + + LOG_DUMPMSG(F1AP, LOG_DUMP_CHAR, buffer, len, "F1AP gNB-DU CONFIGURATION UPDATE : "); + ASN_STRUCT_RESET(asn_DEF_F1AP_F1AP_PDU, &pdu); + f1ap_itti_send_sctp_data_req(assoc_id, buffer, len); + return 0; } /* diff --git a/openair2/F1AP/f1ap_cu_interface_management.h b/openair2/F1AP/f1ap_cu_interface_management.h index 4d3f562128..f506b83152 100644 --- a/openair2/F1AP/f1ap_cu_interface_management.h +++ b/openair2/F1AP/f1ap_cu_interface_management.h @@ -62,10 +62,11 @@ int CU_send_F1_SETUP_FAILURE(sctp_assoc_t assoc_id, const f1ap_setup_failure_t * int CU_handle_gNB_DU_CONFIGURATION_UPDATE(instance_t instance, sctp_assoc_t assoc_id, uint32_t stream, F1AP_F1AP_PDU_t *pdu); int CU_send_gNB_DU_CONFIGURATION_FAILURE(sctp_assoc_t assoc_id, - F1AP_GNBDUConfigurationUpdateFailure_t *GNBDUConfigurationUpdateFailure); + f1ap_gnb_du_configuration_update_failure_t *GNBDUConfigurationUpdateFailure); -int CU_send_gNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE(sctp_assoc_t assoc_id, - F1AP_GNBDUConfigurationUpdateAcknowledge_t *GNBDUConfigurationUpdateAcknowledge); +int CU_send_gNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE( + sctp_assoc_t assoc_id, + f1ap_gnb_du_configuration_update_acknowledge_t *GNBDUConfigurationUpdateAcknowledge); /* * gNB-CU Configuration Update diff --git a/openair2/F1AP/f1ap_cu_task.c b/openair2/F1AP/f1ap_cu_task.c index 2731fa8e0b..3d8061b961 100644 --- a/openair2/F1AP/f1ap_cu_task.c +++ b/openair2/F1AP/f1ap_cu_task.c @@ -174,6 +174,9 @@ void *F1AP_CU_task(void *arg) { &F1AP_GNB_CU_CONFIGURATION_UPDATE(received_msg)); break; + case F1AP_GNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE: + CU_send_gNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE(assoc_id, &F1AP_GNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE(received_msg)); + break; case F1AP_DL_RRC_MESSAGE: // from rrc CU_send_DL_RRC_MESSAGE_TRANSFER(assoc_id, &F1AP_DL_RRC_MESSAGE(received_msg)); diff --git a/openair2/F1AP/f1ap_handlers.c b/openair2/F1AP/f1ap_handlers.c index 458299e626..ecdda72000 100644 --- a/openair2/F1AP/f1ap_handlers.c +++ b/openair2/F1AP/f1ap_handlers.c @@ -45,7 +45,7 @@ static const f1ap_message_processing_t f1ap_messages_processing[][3] = { {0, 0, 0}, /* Reset */ {CU_handle_F1_SETUP_REQUEST, DU_handle_F1_SETUP_RESPONSE, DU_handle_F1_SETUP_FAILURE}, /* F1Setup */ {0, 0, 0}, /* ErrorIndication */ - {0, 0, 0}, /* gNBDUConfigurationUpdate */ + {CU_handle_gNB_DU_CONFIGURATION_UPDATE, 0, 0}, /* gNBDUConfigurationUpdate */ {DU_handle_gNB_CU_CONFIGURATION_UPDATE, CU_handle_gNB_CU_CONFIGURATION_UPDATE_ACKNOWLEDGE, CU_handle_gNB_CU_CONFIGURATION_UPDATE_FAILURE}, /* gNBCUConfigurationUpdate */ diff --git a/openair2/RRC/NR/mac_rrc_dl_f1ap.c b/openair2/RRC/NR/mac_rrc_dl_f1ap.c index e3bdca518f..9a934cc675 100644 --- a/openair2/RRC/NR/mac_rrc_dl_f1ap.c +++ b/openair2/RRC/NR/mac_rrc_dl_f1ap.c @@ -46,7 +46,11 @@ static void f1_setup_failure_f1ap(sctp_assoc_t assoc_id, const f1ap_setup_failur static void gnb_du_configuration_update_ack_f1ap(sctp_assoc_t assoc_id, const f1ap_gnb_du_configuration_update_acknowledge_t *ack) { - AssertFatal(false, "%s() not implemented\n", __func__); + MessageDef *msg = itti_alloc_new_message(TASK_RRC_GNB, 0, F1AP_GNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE); + msg->ittiMsgHeader.originInstance = assoc_id; + f1ap_gnb_du_configuration_update_acknowledge_t *f1ap_msg = &F1AP_GNB_DU_CONFIGURATION_UPDATE_ACKNOWLEDGE(msg); + *f1ap_msg = *ack; + itti_send_msg_to_task(TASK_CU_F1, 0, msg); } static void ue_context_setup_request_f1ap(sctp_assoc_t assoc_id, const f1ap_ue_context_setup_t *req)