diff --git a/ci-scripts/conf_files/rcc.band7.tm1.mbms.if4p5.50PRB.lo.conf b/ci-scripts/conf_files/rcc.band7.tm1.mbms.if4p5.50PRB.lo.conf new file mode 100644 index 0000000000000000000000000000000000000000..cda4c0a461f3ca8feda3c8fad825c45819a6e8e7 --- /dev/null +++ b/ci-scripts/conf_files/rcc.band7.tm1.mbms.if4p5.50PRB.lo.conf @@ -0,0 +1,417 @@ +Active_eNBs = ( "eNB-Eurecom-LTEBox"); +# Asn1_verbosity, choice in: none, info, annoying +Asn1_verbosity = "none"; + +eNBs = +( + { + # real_time choice in {hard, rt-preempt, no} + real_time = "no"; + + ////////// Identification parameters: + eNB_ID = 0xe00; + + cell_type = "CELL_MACRO_ENB"; + + eNB_name = "eNB-Eurecom-LTEBox"; + + // Tracking area code, 0x0000 and 0xfffe are reserved values + tracking_area_code = 1; + + plmn_list = ( { mcc = 208; mnc = 93; mnc_length = 2; } ); + + tr_s_preference = "local_mac" + + ////////// Physical parameters: + + component_carriers = ( + { + node_function = "NGFI_RCC_IF4p5"; + node_timing = "synch_to_ext_device"; + node_synch_ref = 0; + frame_type = "FDD"; + tdd_config = 3; + tdd_config_s = 0; + prefix_type = "NORMAL"; + eutra_band = 7; + downlink_frequency = 2685000000L; + uplink_frequency_offset = -120000000; + Nid_cell = 0; + N_RB_DL = 50; + Nid_cell_mbsfn = 0; + nb_antenna_ports = 2; + nb_antennas_tx = 1; + nb_antennas_rx = 1; + tx_gain = 90; + rx_gain = 125; + pbch_repetition = "FALSE"; + prach_root = 0; + prach_config_index = 0; + prach_high_speed = "DISABLE"; + prach_zero_correlation = 1; + prach_freq_offset = 2; + pucch_delta_shift = 1; + pucch_nRB_CQI = 0; + pucch_nCS_AN = 0; + pucch_n1_AN = 0; + pdsch_referenceSignalPower = -27; + pdsch_p_b = 0; + pusch_n_SB = 1; + pusch_enable64QAM = "DISABLE"; + pusch_hoppingMode = "interSubFrame"; + pusch_hoppingOffset = 0; + pusch_groupHoppingEnabled = "ENABLE"; + pusch_groupAssignment = 0; + pusch_sequenceHoppingEnabled = "DISABLE"; + pusch_nDMRS1 = 1; + phich_duration = "NORMAL"; + phich_resource = "ONESIXTH"; + srs_enable = "DISABLE"; + /* srs_BandwidthConfig =; + srs_SubframeConfig =; + srs_ackNackST =; + srs_MaxUpPts =;*/ + + pusch_p0_Nominal = -104; + pusch_alpha = "AL1"; + pucch_p0_Nominal = -108; + msg3_delta_Preamble = 6; + pucch_deltaF_Format1 = "deltaF2"; + pucch_deltaF_Format1b = "deltaF3"; + pucch_deltaF_Format2 = "deltaF0"; + pucch_deltaF_Format2a = "deltaF0"; + pucch_deltaF_Format2b = "deltaF0"; + + rach_numberOfRA_Preambles = 64; + rach_preamblesGroupAConfig = "DISABLE"; + /* + rach_sizeOfRA_PreamblesGroupA = ; + rach_messageSizeGroupA = ; + rach_messagePowerOffsetGroupB = ; + */ + rach_powerRampingStep = 4; + rach_preambleInitialReceivedTargetPower = -108; + rach_preambleTransMax = 10; + rach_raResponseWindowSize = 10; + rach_macContentionResolutionTimer = 48; + rach_maxHARQ_Msg3Tx = 4; + + pcch_default_PagingCycle = 128; + pcch_nB = "oneT"; + bcch_modificationPeriodCoeff = 2; + ue_TimersAndConstants_t300 = 1000; + ue_TimersAndConstants_t301 = 1000; + ue_TimersAndConstants_t310 = 1000; + ue_TimersAndConstants_t311 = 10000; + ue_TimersAndConstants_n310 = 20; + ue_TimersAndConstants_n311 = 1; + ue_TransmissionMode = 1; + mbms_dedicated_serving_cell = "DISABLE" + } + ); + + + srb1_parameters : + { + # timer_poll_retransmit = (ms) [5, 10, 15, 20,... 250, 300, 350, ... 500] + timer_poll_retransmit = 80; + + # timer_reordering = (ms) [0,5, ... 100, 110, 120, ... ,200] + timer_reordering = 35; + + # timer_reordering = (ms) [0,5, ... 250, 300, 350, ... ,500] + timer_status_prohibit = 0; + + # poll_pdu = [4, 8, 16, 32 , 64, 128, 256, infinity(>10000)] + poll_pdu = 4; + + # poll_byte = (kB) [25,50,75,100,125,250,375,500,750,1000,1250,1500,2000,3000,infinity(>10000)] + poll_byte = 99999; + + # max_retx_threshold = [1, 2, 3, 4 , 6, 8, 16, 32] + max_retx_threshold = 4; + } + + # ------- SCTP definitions + SCTP : + { + # Number of streams to use in input/output + SCTP_INSTREAMS = 2; + SCTP_OUTSTREAMS = 2; + }; + + + ////////// MME parameters: + mme_ip_address = ( { ipv4 = "127.0.0.3"; + ipv6 = "192:168:30::17"; + active = "yes"; + preference = "ipv4"; + } + ); + + enable_measurement_reports = "no"; + + ///X2 + enable_x2 = "no"; + t_reloc_prep = 1000; /* unit: millisecond */ + tx2_reloc_overall = 2000; /* unit: millisecond */ + + + ////////// MCE parameters: + target_mce_m2_ip_address = ( { ipv4 = "127.0.0.7"; + ipv6 = "192:168:30::17"; + active = "yes"; + preference = "ipv4"; + } + ); + + ///M2 + enable_enb_m2 = "yes"; + + + mbms_configuration_data_list = ( + { + mbsfn_sync_area = 0x0001; + mbms_service_area_list=( + { + mbms_service_area=0x0001; + } + ); + } + + ); + + NETWORK_INTERFACES : + { + ENB_INTERFACE_NAME_FOR_S1_MME = "lo"; + ENB_IPV4_ADDRESS_FOR_S1_MME = "127.0.0.2/24"; + ENB_INTERFACE_NAME_FOR_S1U = "lo"; + ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.5/24"; + ENB_PORT_FOR_S1U = 2152; # Spec 2152 + + ENB_IPV4_ADDRESS_FOR_X2C = "127.0.0.2/24"; + ENB_PORT_FOR_X2C = 36422; # Spec 36422 + + ENB_IPV4_ADDRESS_FOR_M2C = "127.0.0.2/24"; + ENB_PORT_FOR_M2C = 36443; # Spec 36443 + }; + } +); + +MCEs = ( + { + MCE_ID = 0xe00; + + MCE_name = "MCE-Vicomtech-LTEBox"; + + //M2 + enable_mce_m2 = "yes"; + + //M3 + enable_mce_m3 = "yes"; + + target_mme_m3_ip_address = ( { ipv4 = "127.0.0.18"; + ipv6 = "192:168:30::17"; + active = "yes"; + preference = "ipv4"; + } + ); + + + + NETWORK_INTERFACES : + { + #ENB_INTERFACE_NAME_FOR_S1_MME = "lo"; + #ENB_IPV4_ADDRESS_FOR_S1_MME = "127.0.0.2/24"; + #ENB_INTERFACE_NAME_FOR_S1U = "lo"; + #ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.5/24"; + #ENB_IPV4_ADDRESS_FOR_S1U = "224.10.10.10/24"; + #ENB_PORT_FOR_S1U = 2152; # Spec 2152 + #ENB_IPV4_ADDRESS_FOR_X2C = "127.0.0.2/24"; + #ENB_PORT_FOR_X2C = 36422; # Spec 36422 + #ENB_IPV4_ADDRESS_FOR_M2C = "127.0.0.2/24"; + #ENB_PORT_FOR_M2C = 36443; # Spec 36443 + MCE_INTERFACE_NAME_FOR_M2_ENB = "lo"; + MCE_IPV4_ADDRESS_FOR_M2C = "127.0.0.7/24"; + MCE_PORT_FOR_M2C = 36443; # Spec 36443 + + MCE_INTERFACE_NAME_FOR_M3_MME = "lo"; + MCE_IPV4_ADDRESS_FOR_M3C = "127.0.0.3/24"; + MCE_PORT_FOR_M3C = 36444; # Spec 36444 + #MME_IPV4_ADDRESS_FOR_M3C = "127.0.0.8/24"; + #MME_PORT_FOR_M3C = 36444; # Spec 36444 + + }; + + plnm: + { + mcc = 208; + mnc = 93; + mnc_length = 2; + }; + + mbms_sched_info : + { + mcch_update_time = 10; + mbms_area_config_list = ( + { + common_sf_allocation_period = 2; #rf4(0) rf8(1) rf16(2) rf32(3) rf64(4) rf128(5) rf256(6) + mbms_area_id = 0; + pmch_config_list = ( + { + allocated_sf_end=32; + data_mcs=14; + mch_scheduling_period = 0; #rf8(0) + mbms_session_list = ( + { + #plnm + service_id ->tmgi + plnm: + { + mcc = 208; + mnc = 93; + mnc_length = 2; + } + service_id=0; #keep this allways as 0 (workaround for TUN if) + lcid=6; #this must be properly defined lcid:8+service:0 -> rab_id:8 + } + ); + } + ); + + mbms_sf_config_list = ( + { + radioframe_allocation_period=1; #n1(0) n2(1) n4(2) n8(3) n16(4) n32(5) + radioframe_alloocation_offset=0; + num_frame="oneFrame"; + subframe_allocation=57; #xx100000 + //num_frame="fourFrame"; + //subframe_allocation=14548987; # + } + ); + + } + ); + }; + + + mcch_config_per_mbsfn_area = ( + { + mbsfn_area = 0; + pdcch_length = 1; #s1(0), s2(1) + repetition_period = 0; #rf32(0), rf64(1), rf128(2), rf256(3) + offset = 0; + modification_period = 0; #rf512(0; rf1024(1) + subframe_allocation_info = 32; #BITSTRING (6bits -> one frame) xx100101 + mcs = 1; #n2(0), n7(1), n13(2), n19(3) + } + // , + // { + // mbsfn_area = 0; + // pdcch_length = 0; #s1(0), s2(1) + // repetition_period = 2; #rf32(0), rf64(1), rf128(2), rf256(3) + // offset = 0; + // modification_period = 1; #rf512(0; rf1024(1) + // subframe_allocation_info = 32; #BITSTRING (6bits -> one frame) xx100000 + // mcs = 0; #n2(0), n7(1), n13(2), n19(3) + // } + + ); + #); #end mbms_scheduling_info + + } +); +MMEs = ( + { + MME_ID = 0xe00; + + MME_name = "MME-MBMS-Vicomtech-LTEBox"; + + //M3 + enable_mme_m3 = "yes"; + NETWORK_INTERFACES : + { + #ENB_INTERFACE_NAME_FOR_S1_MME = "lo"; + #ENB_IPV4_ADDRESS_FOR_S1_MME = "127.0.0.2/24"; + #ENB_INTERFACE_NAME_FOR_S1U = "lo"; + #ENB_IPV4_ADDRESS_FOR_S1U = "127.0.0.5/24"; + #ENB_IPV4_ADDRESS_FOR_S1U = "224.10.10.10/24"; + #ENB_PORT_FOR_S1U = 2152; # Spec 2152 + #ENB_IPV4_ADDRESS_FOR_X2C = "127.0.0.2/24"; + #ENB_PORT_FOR_X2C = 36422; # Spec 36422 + #ENB_IPV4_ADDRESS_FOR_M2C = "127.0.0.2/24"; + #ENB_PORT_FOR_M2C = 36443; # Spec 36443 + #MCE_INTERFACE_NAME_FOR_M2_ENB = "lo"; + #MCE_IPV4_ADDRESS_FOR_M2C = "127.0.0.7/24"; + #MCE_PORT_FOR_M2C = 36443; # Spec 36443 + + MME_INTERFACE_NAME_FOR_M3_MCE = "lo"; + #MCE_IPV4_ADDRESS_FOR_M3C = "127.0.0.3/24"; + #MCE_PORT_FOR_M3C = 36444; # Spec 36444 + MME_IPV4_ADDRESS_FOR_M3C = "127.0.0.18/24"; + MME_PORT_FOR_M3C = 36444; # Spec 36444 + + }; + } +); + + +MACRLCs = ( + { + num_cc = 1; + tr_s_preference = "local_L1"; + tr_n_preference = "local_RRC"; + } +); + +L1s = ( + { + num_cc = 1; + tr_n_preference = "local_mac"; + } +); + +RUs = ( + { + local_if_name = "lo"; + remote_address = "127.0.0.2"; + local_address = "127.0.0.1"; + local_portc = 50000; + remote_portc = 50000; + local_portd = 50001; + remote_portd = 50001; + local_rf = "no" + tr_preference = "udp_if4p5" + nb_tx = 2 + nb_rx = 2 + att_tx = 0 + att_rx = 0; + eNB_instances = [0]; + is_slave = "no"; + } +); + +THREAD_STRUCT = ( + { + #three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT" + parallel_config = "PARALLEL_SINGLE_THREAD"; + #two option for worker "WORKER_DISABLE" or "WORKER_ENABLE" + worker_config = "WORKER_ENABLE"; + } +); + +log_config = { + global_log_level ="info"; + global_log_verbosity ="medium"; + hw_log_level ="info"; + hw_log_verbosity ="medium"; + phy_log_level ="info"; + phy_log_verbosity ="medium"; + mac_log_level ="info"; + mac_log_verbosity ="high"; + rlc_log_level ="info"; + rlc_log_verbosity ="medium"; + pdcp_log_level ="info"; + pdcp_log_verbosity ="medium"; + rrc_log_level ="info"; + rrc_log_verbosity ="medium"; +}; diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt index 0a20060af855783f86c013e0817a9974253d3783..5c999e353a1eceec77bde97caa636e7c9db1abdb 100644 --- a/cmake_targets/CMakeLists.txt +++ b/cmake_targets/CMakeLists.txt @@ -405,6 +405,145 @@ add_library(S1AP_ENB ) add_dependencies(S1AP_ENB rrc_flag s1ap_flag) + +#M2AP +# Same limitation as described in RRC/S1AP: unknown generated file list +# so we generate it at cmake time +############## +add_list1_option(M2AP_RELEASE R14 "M2AP ASN.1 grammar version" R14) + +set(M2AP_DIR ${OPENAIR2_DIR}/M2AP) +if (${M2AP_RELEASE} STREQUAL "R8") + make_version(M2AP_VERSION 8 9 0) + set(M2AP_ASN_FILES m2ap-8.9.0.asn1) +elseif (${M2AP_RELEASE} STREQUAL "R11") + make_version(M2AP_VERSION 11 9 0) + set(M2AP_ASN_FILES m2ap-11.9.0.asn1) +elseif (${M2AP_RELEASE} STREQUAL "R12") + make_version(M2AP_VERSION 12 9 0) + set(M2AP_ASN_FILES m2ap-12.9.0.asn1) +elseif (${M2AP_RELEASE} STREQUAL "R14") + make_version(M2AP_VERSION 14 0 0) + set(M2AP_ASN_FILES m2ap-14.0.0.asn1) +elseif (${M2AP_RELEASE} STREQUAL "R15") + make_version(M2AP_VERSION 15 1 0) + set(M2AP_ASN_FILES m2ap-15.1.0.asn1) +endif(${M2AP_RELEASE} STREQUAL "R8") +add_definitions(-DM2AP_VERSION=${M2AP_VERSION}) +set(M2AP_ASN_DIR ${M2AP_DIR}/MESSAGES/ASN1/${M2AP_RELEASE}) +set(M2AP_C_DIR ${asn1_generated_dir}/M2AP_${M2AP_RELEASE}) + +# Warning: if you modify ASN.1 source file to generate new C files, cmake should be re-run instead of make +execute_process(COMMAND ${OPENAIR_CMAKE}/tools/make_asn1c_includes.sh "${M2AP_C_DIR}" "${M2AP_ASN_DIR}/${M2AP_ASN_FILES}" "M2AP_" -fno-include-deps -DEMIT_ASN_DEBUG=1 + RESULT_VARIABLE ret) +if (NOT ${ret} STREQUAL 0) + message(FATAL_ERROR "${ret}: error") +endif (NOT ${ret} STREQUAL 0) + +file(GLOB M2AP_source ${M2AP_C_DIR}/*.c) + +add_custom_target ( + m2_flag ALL + COMMAND ${OPENAIR_CMAKE}/tools/make_asn1c_includes.sh "${M2AP_C_DIR}" "${M2AP_ASN_DIR}/${M2AP_ASN_FILES}" "M2AP_" -fno-include-deps + DEPENDS ${M2AP_ASN_DIR}/${M2AP_ASN_FILES} + ) + +add_library(M2AP_LIB + ${M2AP_source} + ${M2AP_DIR}/m2ap_common.c + ) +add_dependencies(M2AP_LIB rrc_flag m2_flag) + +include_directories ("${M2AP_C_DIR}") +include_directories ("${M2AP_DIR}") + +add_library(M2AP_ENB + ${M2AP_DIR}/m2ap_eNB.c + ${M2AP_DIR}/m2ap_MCE.c + ${M2AP_DIR}/m2ap_decoder.c + ${M2AP_DIR}/m2ap_encoder.c + ${M2AP_DIR}/m2ap_MCE_handler.c + ${M2AP_DIR}/m2ap_eNB_handler.c + ${M2AP_DIR}/m2ap_itti_messaging.c + ${M2AP_DIR}/m2ap_eNB_management_procedures.c + ${M2AP_DIR}/m2ap_eNB_generate_messages.c + ${M2AP_DIR}/m2ap_MCE_management_procedures.c + ${M2AP_DIR}/m2ap_MCE_generate_messages.c + ${M2AP_DIR}/m2ap_ids.c + ${M2AP_DIR}/m2ap_timers.c + ${M2AP_DIR}/m2ap_MCE_interface_management.c + ${M2AP_DIR}/m2ap_eNB_interface_management.c + ) +add_dependencies(M2AP_ENB rrc_flag m2_flag) + +#M3AP +# Same limitation as described in RRC/S1AP: unknown generated file list +# so we generate it at cmake time +############## +add_list1_option(M3AP_RELEASE R14 "M3AP ASN.1 grammar version" R14) + +set(M3AP_DIR ${OPENAIR3_DIR}/M3AP) +if (${M3AP_RELEASE} STREQUAL "R8") + make_version(M3AP_VERSION 8 9 0) + set(M3AP_ASN_FILES m3ap-8.9.0.asn1) +elseif (${M3AP_RELEASE} STREQUAL "R11") + make_version(M3AP_VERSION 11 9 0) + set(M3AP_ASN_FILES m3ap-11.9.0.asn1) +elseif (${M3AP_RELEASE} STREQUAL "R12") + make_version(M3AP_VERSION 12 9 0) + set(M3AP_ASN_FILES m3ap-12.9.0.asn1) +elseif (${M3AP_RELEASE} STREQUAL "R14") + make_version(M3AP_VERSION 14 0 0) + set(M3AP_ASN_FILES m3ap-14.0.0.asn1) +elseif (${M3AP_RELEASE} STREQUAL "R15") + make_version(M3AP_VERSION 15 1 0) + set(M3AP_ASN_FILES m3ap-15.1.0.asn1) +endif(${M3AP_RELEASE} STREQUAL "R8") +add_definitions(-DM3AP_VERSION=${M3AP_VERSION}) +set(M3AP_ASN_DIR ${M3AP_DIR}/MESSAGES/ASN1/${M3AP_RELEASE}) +set(M3AP_C_DIR ${asn1_generated_dir}/M3AP_${M3AP_RELEASE}) + +# Warning: if you modify ASN.1 source file to generate new C files, cmake should be re-run instead of make +execute_process(COMMAND ${OPENAIR_CMAKE}/tools/make_asn1c_includes.sh "${M3AP_C_DIR}" "${M3AP_ASN_DIR}/${M3AP_ASN_FILES}" "M3AP_" -fno-include-deps + RESULT_VARIABLE ret) +if (NOT ${ret} STREQUAL 0) + message(FATAL_ERROR "${ret}: error") +endif (NOT ${ret} STREQUAL 0) + +file(GLOB M3AP_source ${M3AP_C_DIR}/*.c) + +add_custom_target ( + m3_flag ALL + COMMAND ${OPENAIR_CMAKE}/tools/make_asn1c_includes.sh "${M3AP_C_DIR}" "${M3AP_ASN_DIR}/${M3AP_ASN_FILES}" "M3AP_" -fno-include-deps + DEPENDS ${M3AP_ASN_DIR}/${M3AP_ASN_FILES} + ) + +add_library(M3AP_LIB + ${M3AP_source} + ${M3AP_DIR}/m3ap_common.c + ) +add_dependencies(M3AP_LIB rrc_flag m3_flag) + +include_directories ("${M3AP_C_DIR}") +include_directories ("${M3AP_DIR}") + +add_library(M3AP_ENB + ${M3AP_DIR}/m3ap_decoder.c + ${M3AP_DIR}/m3ap_encoder.c + ${M3AP_DIR}/m3ap_MCE_handler.c + ${M3AP_DIR}/m3ap_MME_handler.c + ${M3AP_DIR}/m3ap_MME.c + ${M3AP_DIR}/m3ap_MME_management_procedures.c + ${M3AP_DIR}/m3ap_MME_interface_management.c + ${M3AP_DIR}/m3ap_MCE.c + ${M3AP_DIR}/m3ap_MCE_management_procedures.c + ${M3AP_DIR}/m3ap_MCE_interface_management.c + ${M3AP_DIR}/m3ap_itti_messaging.c + ${M3AP_DIR}/m3ap_ids.c + ${M3AP_DIR}/m3ap_timers.c + ) +add_dependencies(M3AP_ENB rrc_flag m3_flag) + #X2AP # Same limitation as described in RRC/S1AP: unknown generated file list # so we generate it at cmake time @@ -763,6 +902,7 @@ include_directories("${OPENAIR1_DIR}") include_directories("${OPENAIR2_DIR}") include_directories("${OPENAIR3_DIR}/NAS/TOOLS") include_directories("${OPENAIR2_DIR}/ENB_APP") +include_directories("${OPENAIR2_DIR}/MCE_APP") include_directories("${OPENAIR2_DIR}/LAYER2/RLC") include_directories("${OPENAIR2_DIR}/LAYER2/RLC/AM_v9.3.0") include_directories("${OPENAIR2_DIR}/LAYER2/RLC/UM_v9.3.0") @@ -785,9 +925,12 @@ include_directories("${OPENAIR3_DIR}/SECU") include_directories("${OPENAIR3_DIR}/SCTP") include_directories("${OPENAIR3_DIR}/S1AP") include_directories("${OPENAIR2_DIR}/X2AP") +include_directories("${OPENAIR2_DIR}/M2AP") include_directories("${OPENAIR2_DIR}/F1AP") include_directories("${OPENAIR3_DIR}/UDP") include_directories("${OPENAIR3_DIR}/GTPV1-U") +include_directories("${OPENAIR3_DIR}/M3AP") +include_directories("${OPENAIR3_DIR}/MME_APP") include_directories("${OPENAIR_DIR}/targets/COMMON") include_directories("${OPENAIR_DIR}/targets/ARCH/COMMON") include_directories("${OPENAIR2_DIR}/ENB_APP/CONTROL_MODULES/PHY") @@ -1371,6 +1514,7 @@ set(L2_SRC # ${RRC_DIR}/rrc_UE.c ${RRC_DIR}/rrc_eNB.c ${RRC_DIR}/rrc_eNB_S1AP.c + ${RRC_DIR}/rrc_eNB_M2AP.c ${RRC_DIR}/rrc_eNB_UE_context.c ${RRC_DIR}/rrc_common.c ${RRC_DIR}/L2_interface.c @@ -1461,12 +1605,20 @@ set (ENB_APP_SRC ${OPENAIR2_DIR}/ENB_APP/RRC_config_tools.c ) + +set (MCE_APP_SRC + ${OPENAIR2_DIR}/MCE_APP/mce_app.c + ${OPENAIR2_DIR}/MCE_APP/mce_config.c + ) + + add_library(L2 ${L2_SRC} ${MAC_SRC} - ${ENB_APP_SRC}) + ${ENB_APP_SRC} + ${MCE_APP_SRC}) # ${OPENAIR2_DIR}/RRC/L2_INTERFACE/openair_rrc_L2_interface.c) -add_dependencies(L2 rrc_flag s1ap_flag x2_flag) +add_dependencies(L2 rrc_flag s1ap_flag x2_flag m2_flag m3_flag) add_library(L2_UE ${L2_SRC_UE} @@ -1500,6 +1652,13 @@ set (GTPV1U_SRC add_library(GTPV1U ${GTPV1U_SRC}) add_dependencies(GTPV1U rrc_flag) +set (MME_APP_SRC + ${OPENAIR3_DIR}/MME_APP/mme_app.c + ${OPENAIR3_DIR}/MME_APP/mme_config.c +) +add_library(MME_APP ${MME_APP_SRC}) +add_dependencies(MME_APP rrc_flag s1ap_flag x2_flag m2_flag m3_flag) + set(SCTP_SRC ${OPENAIR3_DIR}/SCTP/sctp_common.c ${OPENAIR3_DIR}/SCTP/sctp_eNB_task.c @@ -2070,6 +2229,7 @@ add_executable(lte-softmodem ${OPENAIR2_DIR}/ENB_APP/NB_IoT_interface.c ${OPENAIR1_DIR}/SIMULATION/TOOLS/taus.c ${OPENAIR_TARGETS}/COMMON/create_tasks.c + ${OPENAIR_TARGETS}/COMMON/create_tasks_mbms.c ${OPENAIR_TARGETS}/ARCH/COMMON/common_lib.c ${OPENAIR2_DIR}/RRC/NAS/nas_config.c ${OPENAIR2_DIR}/RRC/NAS/rb_config.c @@ -2089,7 +2249,7 @@ add_dependencies(lte-softmodem rrc_flag s1ap_flag x2_flag) target_link_libraries (lte-softmodem -Wl,--start-group - RRC_LIB S1AP_LIB S1AP_ENB F1AP_LIB F1AP X2AP_LIB X2AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB SCHED_RU_LIB PHY_COMMON PHY PHY_RU LFDS L2 + RRC_LIB S1AP_LIB S1AP_ENB F1AP_LIB F1AP M2AP_LIB M2AP_ENB X2AP_LIB X2AP_ENB M3AP_LIB M3AP_ENB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_LIB SCHED_RU_LIB PHY_COMMON PHY PHY_RU LFDS L2 ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} ${FLEXRAN_AGENT_LIB} ${FSPT_MSG_LIB} ${PROTO_AGENT_LIB} LFDS7 NFAPI_COMMON_LIB NFAPI_LIB NFAPI_VNF_LIB NFAPI_PNF_LIB NFAPI_USER_LIB -Wl,--end-group z dl) @@ -2157,7 +2317,7 @@ add_executable(lte-uesoftmodem add_dependencies(lte-uesoftmodem rrc_flag s1ap_flag x2_flag) target_link_libraries (lte-uesoftmodem -Wl,--start-group - RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB F1AP F1AP_LIB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT UDP SCHED_RU_LIB SCHED_UE_LIB PHY_COMMON PHY_UE PHY_RU LFDS L2_UE SIMU + RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB F1AP F1AP_LIB GTPV1U SECU_CN SECU_OSA UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_RU_LIB SCHED_UE_LIB PHY_COMMON PHY_UE PHY_RU LFDS L2_UE SIMU ${MSC_LIB} ${RAL_LIB} ${NAS_UE_LIB} ${ITTI_LIB} ${FLPT_MSG_LIB} ${ASYNC_IF_LIB} LFDS7 ${ATLAS_LIBRARIES} NFAPI_COMMON_LIB NFAPI_LIB NFAPI_PNF_LIB NFAPI_USER_LIB -Wl,--end-group z dl) @@ -2236,7 +2396,7 @@ add_executable(test_epc_generate_scenario ${OPENAIR3_DIR}/S1AP/s1ap_eNB_defs.h ) target_link_libraries (test_epc_generate_scenario - -Wl,--start-group RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY LFDS ${ITTI_LIB} ${MSC_LIB} L2 -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIBRARIES} + -Wl,--start-group RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_LIB PHY LFDS ${ITTI_LIB} ${MSC_LIB} L2 -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIBRARIES} ) add_executable(test_epc_play_scenario @@ -2255,7 +2415,7 @@ add_executable(test_epc_play_scenario ) target_include_directories(test_epc_play_scenario PUBLIC /usr/local/share/asn1c) target_link_libraries (test_epc_play_scenario - -Wl,--start-group RRC_LIB S1AP_LIB X2AP_LIB X2AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT UDP SCHED_LIB PHY_COMMON PHY PHY_UE LFDS ${ITTI_LIB} ${MSC_LIB} -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIBRARIES} + -Wl,--start-group RRC_LIB S1AP_LIB X2AP_LIB X2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP GTPV1U LIB_NAS_UE SECU_CN UTIL HASHTABLE SCTP_CLIENT MME_APP UDP SCHED_LIB PHY_COMMON PHY PHY_UE LFDS ${ITTI_LIB} ${MSC_LIB} -Wl,--end-group pthread m rt crypt sctp ${LIBXML2_LIBRARIES} ${LIBXSLT_LIBRARIES} ${CRYPTO_LIBRARIES} ${OPENSSL_LIBRARIES} ${NETTLE_LIBRARIES} ${CONFIG_LIBRARIES} ) @@ -2291,12 +2451,12 @@ if (${T_TRACER}) dlsim_tm4 dlsim dlsim_tm7 ulsim pbchsim scansim mbmssim pdcchsim pucchsim prachsim syncsim ulsim cu_test du_test #all "add_library" definitions - ITTI RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB F1AP_LIB F1AP + ITTI RRC_LIB S1AP_LIB S1AP_ENB X2AP_LIB X2AP_ENB M2AP_LIB M2AP_ENB M3AP_LIB M3AP_ENB F1AP_LIB F1AP oai_exmimodevif oai_usrpdevif oai_bladerfdevif oai_lmssdrdevif oai_eth_transpro FLPT_MSG ASYNC_IF FLEXRAN_AGENT HASHTABLE MSC UTIL OMG_SUMO SECU_OSA SECU_CN SCHED_LIB SCHED_RU_LIB SCHED_UE_LIB PHY L2 default_sched - remote_sched RAL CN_UTILS GTPV1U SCTP_CLIENT UDP LIB_NAS_UE LFDS + remote_sched RAL CN_UTILS GTPV1U SCTP_CLIENT MME_APP UDP LIB_NAS_UE LFDS LFDS7 SIMU OPENAIR0_LIB PHY_MEX coding) if (TARGET ${i}) add_dependencies(${i} generate_T) diff --git a/targets/COMMON/create_tasks.h b/targets/COMMON/create_tasks.h index ff1d9ace5199fbc0dbf3bf8b9cc7a52f1db983c5..339f4aaa8f5fdaa1d0a8c2839afda9586e9f2053 100644 --- a/targets/COMMON/create_tasks.h +++ b/targets/COMMON/create_tasks.h @@ -28,6 +28,7 @@ extern void *l2l1_task(void *arg); int create_tasks(uint32_t enb_nb); int create_tasks_ue(uint32_t ue_nb); +int create_tasks_mbms(uint32_t enb_nb); #endif #endif /* CREATE_TASKS_H_ */ diff --git a/targets/COMMON/create_tasks_mbms.c b/targets/COMMON/create_tasks_mbms.c new file mode 100644 index 0000000000000000000000000000000000000000..5f81592b96640211e55f9590c8a611c81990c1a8 --- /dev/null +++ b/targets/COMMON/create_tasks_mbms.c @@ -0,0 +1,148 @@ +/* + * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The OpenAirInterface Software Alliance licenses this file to You under + * the OAI Public License, Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.openairinterface.org/?page_id=698 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------------------- + * For more information about the OpenAirInterface (OAI) Software Alliance: + * contact@openairinterface.org + */ + +# include "intertask_interface.h" +# include "create_tasks.h" +# include "common/utils/LOG/log.h" +# include "targets/RT/USER/lte-softmodem.h" +# include "common/ran_context.h" + +#ifdef OPENAIR2 + #include "sctp_eNB_task.h" + #include "x2ap_eNB.h" + #include "s1ap_eNB.h" + #include "udp_eNB_task.h" + #include "gtpv1u_eNB_task.h" + #include "m2ap_eNB.h" + #include "m2ap_MCE.h" + #include "m3ap_MME.h" + #include "m3ap_MCE.h" + #if ENABLE_RAL + #include "lteRALue.h" + #include "lteRALenb.h" + #endif + #include "RRC/LTE/rrc_defs.h" +#endif +# include "f1ap_cu_task.h" +# include "f1ap_du_task.h" +# include "enb_app.h" +# include "mce_app.h" +# include "mme_app.h" + +//extern RAN_CONTEXT_t RC; + +int create_tasks_mbms(uint32_t enb_nb) { + // LOG_D(ENB_APP, "%s(enb_nb:%d\n", __FUNCTION__, enb_nb); + // ngran_node_t type = RC.rrc[0]->node_type; + int rc; + + if (enb_nb == 0) return 0; + + if(!EPC_MODE_ENABLED){ + rc = itti_create_task(TASK_SCTP, sctp_eNB_task, NULL); + AssertFatal(rc >= 0, "Create task for SCTP failed\n"); + } + + + LOG_I(MME_APP, "Creating MME_APP eNB Task\n"); + rc = itti_create_task (TASK_MME_APP, MME_app_task, NULL); + AssertFatal(rc >= 0, "Create task for MME APP failed\n"); + + if (is_m3ap_MME_enabled()) { + rc = itti_create_task(TASK_M3AP_MME, m3ap_MME_task, NULL); + AssertFatal(rc >= 0, "Create task for M3AP MME failed\n"); + } + + LOG_I(MCE_APP, "Creating MCE_APP eNB Task\n"); + rc = itti_create_task (TASK_MCE_APP, MCE_app_task, NULL); + AssertFatal(rc >= 0, "Create task for MCE APP failed\n"); + + +// LOG_I(ENB_APP, "Creating ENB_APP eNB Task\n"); +// rc = itti_create_task (TASK_ENB_APP, eNB_app_task, NULL); +// AssertFatal(rc >= 0, "Create task for eNB APP failed\n"); +// +// LOG_I(RRC,"Creating RRC eNB Task\n"); +// rc = itti_create_task (TASK_RRC_ENB, rrc_enb_task, NULL); +// AssertFatal(rc >= 0, "Create task for RRC eNB failed\n"); +// +// if (EPC_MODE_ENABLED) { +// rc = itti_create_task(TASK_SCTP, sctp_eNB_task, NULL); +// AssertFatal(rc >= 0, "Create task for SCTP failed\n"); +// } +// rc = itti_create_task(TASK_SCTP, sctp_eNB_task, NULL); +// AssertFatal(rc >= 0, "Create task for SCTP failed\n"); +// +// +// if (EPC_MODE_ENABLED && !NODE_IS_DU(type)) { +// rc = itti_create_task(TASK_S1AP, s1ap_eNB_task, NULL); +// AssertFatal(rc >= 0, "Create task for S1AP failed\n"); +// if (!(get_softmodem_params()->emulate_rf)){ +// rc = itti_create_task(TASK_UDP, udp_eNB_task, NULL); +// AssertFatal(rc >= 0, "Create task for UDP failed\n"); +// } +// rc = itti_create_task(TASK_GTPV1_U, gtpv1u_eNB_task, NULL); +// AssertFatal(rc >= 0, "Create task for GTPV1U failed\n"); +// if (is_x2ap_enabled()) { +// rc = itti_create_task(TASK_X2AP, x2ap_task, NULL); +// AssertFatal(rc >= 0, "Create task for X2AP failed\n"); +// } else { +// LOG_I(X2AP, "X2AP is disabled.\n"); +// } +// } +//// + if(!EPC_MODE_ENABLED){ + // rc = itti_create_task(TASK_SCTP, sctp_eNB_task, NULL); + // AssertFatal(rc >= 0, "Create task for SCTP failed\n"); + rc = itti_create_task(TASK_UDP, udp_eNB_task, NULL); + AssertFatal(rc >= 0, "Create task for UDP failed\n"); + rc = itti_create_task(TASK_GTPV1_U, gtpv1u_eNB_task, NULL); + AssertFatal(rc >= 0, "Create task for GTPV1U failed\n"); + } +/// +// if (NODE_IS_CU(type)) { +// rc = itti_create_task(TASK_CU_F1, F1AP_CU_task, NULL); +// AssertFatal(rc >= 0, "Create task for CU F1AP failed\n"); +// } +// +// if (NODE_IS_DU(type)) { +// rc = itti_create_task(TASK_DU_F1, F1AP_DU_task, NULL); +// AssertFatal(rc >= 0, "Create task for DU F1AP failed\n"); +// } +// + + if (is_m3ap_MCE_enabled()) { + rc = itti_create_task(TASK_M3AP_MCE, m3ap_MCE_task, NULL); + AssertFatal(rc >= 0, "Create task for M3AP MCE failed\n"); + + } + if (is_m2ap_MCE_enabled()) { + rc = itti_create_task(TASK_M2AP_MCE, m2ap_MCE_task, NULL); + AssertFatal(rc >= 0, "Create task for M2AP failed\n"); + } + + if (is_m2ap_eNB_enabled()) { + rc = itti_create_task(TASK_M2AP_ENB, m2ap_eNB_task, NULL); + AssertFatal(rc >= 0, "Create task for M2AP failed\n"); + } + + return 0; +} diff --git a/targets/COMMON/create_tasks_mbms.h b/targets/COMMON/create_tasks_mbms.h new file mode 100644 index 0000000000000000000000000000000000000000..339f4aaa8f5fdaa1d0a8c2839afda9586e9f2053 --- /dev/null +++ b/targets/COMMON/create_tasks_mbms.h @@ -0,0 +1,34 @@ +/* + * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The OpenAirInterface Software Alliance licenses this file to You under + * the OAI Public License, Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.openairinterface.org/?page_id=698 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------------------- + * For more information about the OpenAirInterface (OAI) Software Alliance: + * contact@openairinterface.org + */ + +#ifndef CREATE_TASKS_H_ +#define CREATE_TASKS_H_ + +#if defined(ENABLE_ITTI) +/* External declaration of L2L1 task that depend on the target */ +extern void *l2l1_task(void *arg); + +int create_tasks(uint32_t enb_nb); +int create_tasks_ue(uint32_t ue_nb); +int create_tasks_mbms(uint32_t enb_nb); +#endif + +#endif /* CREATE_TASKS_H_ */ diff --git a/targets/RT/USER/lte-enb.c b/targets/RT/USER/lte-enb.c index 1ad25febac2003cbbb260be42153e2c7a4b1ba2e..3cb1171782df73e593fcc908eca33322a8d476b9 100644 --- a/targets/RT/USER/lte-enb.c +++ b/targets/RT/USER/lte-enb.c @@ -1280,6 +1280,8 @@ void init_eNB(int single_thread_flag,int wait_for_sync) { AssertFatal((eNB->if_inst = IF_Module_init(inst))!=NULL,"Cannot register interface"); eNB->if_inst->schedule_response = schedule_response; eNB->if_inst->PHY_config_req = phy_config_request; + eNB->if_inst->PHY_config_update_sib2_req = phy_config_update_sib2_request; + eNB->if_inst->PHY_config_update_sib13_req = phy_config_update_sib13_request; memset((void *)&eNB->UL_INFO,0,sizeof(eNB->UL_INFO)); memset((void *)&eNB->Sched_INFO,0,sizeof(eNB->Sched_INFO)); LOG_I(PHY,"Setting indication lists\n"); diff --git a/targets/RT/USER/lte-ru.c b/targets/RT/USER/lte-ru.c index 89abd124999abc6d964670340d9f57997e7c96ff..06be260f1d6eed87878cd7c90b69bb7cfa22ca8e 100644 --- a/targets/RT/USER/lte-ru.c +++ b/targets/RT/USER/lte-ru.c @@ -1800,6 +1800,14 @@ void *ru_thread( void *param ) { #endif // wakeup all eNB processes waiting for this RU if (ru->num_eNB>0) wakeup_L1s(ru); + + //Workaround ... this must be properly handled + if(ru->if_south!=LOCAL_RF && RC.eNB[0][0]!=NULL){ + if(ru->frame_parms.num_MBSFN_config!=RC.eNB[0][0]->frame_parms.num_MBSFN_config){ + ru->frame_parms = RC.eNB[0][0]->frame_parms;//->frame_parms; + LOG_W(PHY,"RU MBSFN SF PARAMS Updated\n"); + } + } #ifndef PHY_TX_THREAD diff --git a/targets/RT/USER/lte-softmodem.c b/targets/RT/USER/lte-softmodem.c index 70b458a7fea8724c6542bcdf3025fc4cf7342a9c..1bc02f358c0ec7b28984c2aec59238f3b67a7034 100644 --- a/targets/RT/USER/lte-softmodem.c +++ b/targets/RT/USER/lte-softmodem.c @@ -708,6 +708,8 @@ int main( int argc, char **argv ) { pthread_mutex_unlock(&sync_mutex); config_check_unknown_cmdlineopt(CONFIG_CHECKALLSECTIONS); } + create_tasks_mbms(1); + // wait for end of program LOG_UI(ENB_APP,"TYPE <CTRL-C> TO TERMINATE\n"); // CI -- Flushing the std outputs for the previous marker to show on the eNB / DU / CU log file diff --git a/targets/RT/USER/ru_control.c b/targets/RT/USER/ru_control.c index 0f043c8fa371818f285357e1a1075deb4ffb8dbc..2b4ba056890cd37b880641eff27f380cab16587c 100644 --- a/targets/RT/USER/ru_control.c +++ b/targets/RT/USER/ru_control.c @@ -493,6 +493,27 @@ void configure_rru(int idx, } +static int send_update_rru(RU_t * ru, LTE_DL_FRAME_PARMS * fp){ + //ssize_t msg_len/*,len*/; + int i; + //LTE_DL_FRAME_PARMS *fp = &RC.eNB[0][0]->frame_parms; + RRU_CONFIG_msg_t rru_config_msg; + memset((void *)&rru_config_msg,0,sizeof(rru_config_msg)); + rru_config_msg.type = RRU_config_update; + rru_config_msg.len = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_config_t); + LOG_I(PHY,"Sending RAU tick to RRU %d %lu bytes\n",ru->idx,rru_config_msg.len); + + RRU_config_t *config = (RRU_config_t *)&rru_config_msg.msg[0]; + config->num_MBSFN_config=fp->num_MBSFN_config; + for(i=0; i < fp->num_MBSFN_config; i++){ + config->MBSFN_config[i] = fp->MBSFN_config[i]; + LOG_W(PHY,"Configuration send to RAU (num MBSFN %d, MBSFN_SubframeConfig[%d] pattern is %x )\n",config->num_MBSFN_config,i,config->MBSFN_config[i].mbsfn_SubframeConfig); + + } + AssertFatal((ru->ifdevice.trx_ctlsend_func(&ru->ifdevice,&rru_config_msg,rru_config_msg.len)!=-1), + "RU %d cannot access remote radio\n",ru->idx); + return 0; +} void* ru_thread_control( void* param ) { @@ -502,6 +523,7 @@ void* ru_thread_control( void* param ) { RRU_CONFIG_msg_t rru_config_msg; ssize_t msg_len; int len; + int ru_sf_update=0; // SF config update flag (MBSFN) // Start IF device if any if (ru->start_if) { @@ -523,6 +545,16 @@ void* ru_thread_control( void* param ) { if (ru->state == RU_IDLE && ru->if_south != LOCAL_RF) send_tick(ru); + if (ru->state == RU_RUN && ru->if_south != LOCAL_RF){ + LTE_DL_FRAME_PARMS *fp = &RC.eNB[0][0]->frame_parms; + LOG_D(PHY,"Check MBSFN SF changes\n"); + if(fp->num_MBSFN_config != ru_sf_update){ + ru_sf_update = fp->num_MBSFN_config; + LOG_W(PHY,"RU SF should be updated ... calling send_update_rru(ru)\n"); + send_update_rru(ru,fp); + } + } + if ((len = ru->ifdevice.trx_ctlrecv_func(&ru->ifdevice, &rru_config_msg, @@ -656,6 +688,30 @@ void* ru_thread_control( void* param ) { } } break; + case RRU_config_update: //RRU + if (ru->if_south == LOCAL_RF){ + LOG_W(PHY,"Configuration update received from RAU \n"); + + msg_len = sizeof(RRU_CONFIG_msg_t)-MAX_RRU_CONFIG_SIZE+sizeof(RRU_config_t); + + LOG_W(PHY,"New MBSFN config received from RAU --- num_MBSFN_config %d\n",((RRU_config_t *)&rru_config_msg.msg[0])->num_MBSFN_config); + ru->frame_parms.num_MBSFN_config = ((RRU_config_t *)&rru_config_msg.msg[0])->num_MBSFN_config; + for(int i=0; i < ((RRU_config_t *)&rru_config_msg.msg[0])->num_MBSFN_config; i++){ + ru->frame_parms.MBSFN_config[i].mbsfn_SubframeConfig=((RRU_config_t *)&rru_config_msg.msg[0])->MBSFN_config[i].mbsfn_SubframeConfig; + LOG_W(PHY,"Configuration received from RAU (num MBSFN %d, MBSFN_SubframeConfig[%d] pattern is %x )\n", + ((RRU_config_t *)&rru_config_msg.msg[0])->num_MBSFN_config, + i, + ((RRU_config_t *)&rru_config_msg.msg[0])->MBSFN_config[i].mbsfn_SubframeConfig + ); + } + } else LOG_E(PHY,"Received RRU_config msg...Ignoring\n"); + break; + case RRU_config_update_ok: //RAU + if (ru->if_south == LOCAL_RF) LOG_E(PHY,"Received RRU_config_update_ok msg...Ignoring\n"); + else{ + LOG_W(PHY,"Received RRU_config_update_ok msg...\n"); + } + break; case RRU_start: // RRU if (ru->if_south == LOCAL_RF){