/* * 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 */ /*! \file flexran_agent_mac.c * \brief FlexRAN agent Control Module RRC * \author shahab SHARIAT BAGHERI * \date 2017 * \version 0.1 */ #include "flexran_agent_rrc.h" #include "flexran_agent_ran_api.h" #include "liblfds700.h" #include "common/utils/LOG/log.h" /*Trigger boolean for RRC measurement*/ bool triggered_rrc = false; /*Array containing the Agent-RRC interfaces*/ AGENT_RRC_xface *agent_rrc_xface[NUM_MAX_ENB]; void flexran_agent_ue_state_change(mid_t mod_id, uint32_t rnti, uint8_t state_change) { int size; Protocol__FlexranMessage *msg = NULL; Protocol__FlexHeader *header = NULL; Protocol__FlexUeStateChange *ue_state_change_msg = NULL; Protocol__FlexUeConfig *config = NULL; void *data; int priority = 0; err_code_t err_code=0; int xid = 0; if (flexran_create_header(xid, PROTOCOL__FLEX_TYPE__FLPT_UE_STATE_CHANGE, &header) != 0) goto error; ue_state_change_msg = malloc(sizeof(Protocol__FlexUeStateChange)); if(ue_state_change_msg == NULL) { goto error; } protocol__flex_ue_state_change__init(ue_state_change_msg); ue_state_change_msg->has_type = 1; ue_state_change_msg->type = state_change; config = malloc(sizeof(Protocol__FlexUeConfig)); if (config == NULL) { goto error; } protocol__flex_ue_config__init(config); switch (state_change) { case PROTOCOL__FLEX_UE_STATE_CHANGE_TYPE__FLUESC_DEACTIVATED: config->has_rnti = 1; config->rnti = rnti; break; case PROTOCOL__FLEX_UE_STATE_CHANGE_TYPE__FLUESC_UPDATED: case PROTOCOL__FLEX_UE_STATE_CHANGE_TYPE__FLUESC_ACTIVATED: flexran_agent_fill_rrc_ue_config(mod_id, rnti, config); /* we don't call into the MAC CM here; it will be called later through an * ue_config_request */ break; case PROTOCOL__FLEX_UE_STATE_CHANGE_TYPE__FLUESC_MOVED: default: LOG_E(FLEXRAN_AGENT, "state change FLUESC_MOVED or unknown state occured for RNTI %x\n", rnti); } ue_state_change_msg->config = config; msg = malloc(sizeof(Protocol__FlexranMessage)); if (msg == NULL) { goto error; } protocol__flexran_message__init(msg); msg->msg_case = PROTOCOL__FLEXRAN_MESSAGE__MSG_UE_STATE_CHANGE_MSG; msg->msg_dir = PROTOCOL__FLEXRAN_DIRECTION__INITIATING_MESSAGE; msg->ue_state_change_msg = ue_state_change_msg; data = flexran_agent_pack_message(msg, &size); /*Send sr info using the MAC channel of the eNB*/ if (flexran_agent_msg_send(mod_id, FLEXRAN_AGENT_DEFAULT, data, size, priority)) { err_code = PROTOCOL__FLEXRAN_ERR__MSG_ENQUEUING; goto error; } LOG_D(FLEXRAN_AGENT,"sent message with size %d\n", size); free(header); return; error: if (err_code != 0) LOG_E(FLEXRAN_AGENT, "Could not send UE state message becasue of %d for RNTI %x\n", err_code, rnti); if (header){ free(header); } if (ue_state_change_msg) { free(ue_state_change_msg); } if (config) { free(config); } if (msg) { free(msg); } } int flexran_agent_destroy_ue_state_change(Protocol__FlexranMessage *msg) { if(msg->msg_case != PROTOCOL__FLEXRAN_MESSAGE__MSG_UE_STATE_CHANGE_MSG) goto error; free(msg->ue_state_change_msg->header); if (msg->ue_state_change_msg->config->capabilities) free(msg->ue_state_change_msg->config->capabilities); free(msg->ue_state_change_msg->config); free(msg->ue_state_change_msg); free(msg); return 0; error: //LOG_E(MAC, "%s: an error occured\n", __FUNCTION__); return -1; } /* this is called by RRC as a part of rrc xface . The controller previously requested this*/ void flexran_trigger_rrc_measurements (mid_t mod_id, LTE_MeasResults_t* measResults) { // int priority = 0; // Warning Preventing // void *data; // int size; // err_code_t err_code = -100; triggered_rrc = true; /* TODO do we need this at the current state? meas_stats is never put into a * protobuf message?! int num = flexran_get_rrc_num_ues (mod_id); rnti_t rntis[num]; flexran_get_rrc_rnti_list(mod_id, rntis, num); meas_stats = malloc(sizeof(rrc_meas_stats) * num); for (int i = 0; i < num; i++){ const rnti_t rnti = rntis[i]; meas_stats[i].rnti = rnti; meas_stats[i].meas_id = flexran_get_rrc_pcell_measid(mod_id, rnti); meas_stats[i].rsrp = flexran_get_rrc_pcell_rsrp(mod_id, rnti) - 140; // measResults->measResultPCell.rsrpResult - 140; meas_stats[i].rsrq = flexran_get_rrc_pcell_rsrq(mod_id, rnti)/2 - 20; */ // repl->neigh_meas = NULL; // if (meas->measResultNeighCells != NULL) { // /* // * Neighboring cells measurements performed by UE. // */ // NeighCellsMeasurements *neigh_meas; // neigh_meas = malloc(sizeof(NeighCellsMeasurements)); // if (neigh_meas == NULL) // goto error; // neigh_cells_measurements__init(neigh_meas); // /* EUTRAN RRC Measurements. */ // if (meas->measResultNeighCells->present == // MeasResults__measResultNeighCells_PR_measResultListEUTRA) { // MeasResultListEUTRA_t meas_list = meas->measResultNeighCells-> // choice.measResultListEUTRA; // /* Set the number of EUTRAN measurements present in report. */ // neigh_meas->n_eutra_meas = meas_list.list.count; // if (neigh_meas->n_eutra_meas > 0) { // /* Initialize EUTRAN measurements. */ // EUTRAMeasurements **eutra_meas; // eutra_meas = malloc(sizeof(EUTRAMeasurements *) * // neigh_meas->n_eutra_meas); // for (i = 0; i < neigh_meas->n_eutra_meas; i++) { // eutra_meas[i] = malloc(sizeof(EUTRAMeasurements)); // eutra_measurements__init(eutra_meas[i]); // /* Fill in the physical cell identifier. */ // eutra_meas[i]->has_phys_cell_id = 1; // eutra_meas[i]->phys_cell_id = meas_list.list.array[i]-> // physCellId; // // log_i(agent,"PCI of Target %d", eutra_meas[i]->phys_cell_id); // /* Check for Reference signal measurements. */ // if (&(meas_list.list.array[i]->measResult)) { // /* Initialize Ref. signal measurements. */ // EUTRARefSignalMeas *meas_result; // meas_result = malloc(sizeof(EUTRARefSignalMeas)); // eutra_ref_signal_meas__init(meas_result); // if (meas_list.list.array[i]->measResult.rsrpResult) { // meas_result->has_rsrp = 1; // meas_result->rsrp = RSRP_meas_mapping[*(meas_list. // list.array[i]->measResult.rsrpResult)]; // // log_i(agent,"RSRP of Target %d", meas_result->rsrp); // } // if (meas_list.list.array[i]->measResult.rsrqResult) { // meas_result->has_rsrq = 1; // meas_result->rsrq = RSRQ_meas_mapping[*(meas_list. // list.array[i]->measResult.rsrqResult)]; // // log_i(agent,"RSRQ of Target %d", meas_result->rsrq); // } // eutra_meas[i]->meas_result = meas_result; // } // /* Check for CGI measurements. */ // if (meas_list.list.array[i]->cgi_Info) { // /* Initialize CGI measurements. */ // EUTRACgiMeasurements *cgi_meas; // cgi_meas = malloc(sizeof(EUTRACgiMeasurements)); // eutra_cgi_measurements__init(cgi_meas); // /* EUTRA Cell Global Identity (CGI). */ // CellGlobalIdEUTRA *cgi; // cgi = malloc(sizeof(CellGlobalIdEUTRA)); // cell_global_id__eutra__init(cgi); // cgi->has_cell_id = 1; // CellIdentity_t cId = meas_list.list.array[i]-> // cgi_Info->cellGlobalId.cellIdentity; // cgi->cell_id = (cId.buf[0] << 20) + (cId.buf[1] << 12) + // (cId.buf[2] << 4) + (cId.buf[3] >> 4); // /* Public land mobile network identifier of neighbor // * cell. // */ // PlmnIdentity *plmn_id; // plmn_id = malloc(sizeof(PlmnIdentity)); // plmn_identity__init(plmn_id); // MNC_t mnc = meas_list.list.array[i]-> // cgi_Info->cellGlobalId.plmn_Identity.mnc; // plmn_id->has_mnc = 1; // plmn_id->mnc = 0; // for (m = 0; m < mnc.list.count; m++) { // plmn_id->mnc += *mnc.list.array[m] * // ((uint32_t) pow(10, mnc.list.count - m - 1)); // } // MCC_t *mcc = meas_list.list.array[i]-> // cgi_Info->cellGlobalId.plmn_Identity.mcc; // plmn_id->has_mcc = 1; // plmn_id->mcc = 0; // for (m = 0; m < mcc->list.count; m++) { // plmn_id->mcc += *mcc->list.array[m] * // ((uint32_t) pow(10, mcc->list.count - m - 1)); // } // TrackingAreaCode_t tac = meas_list.list.array[i]-> // cgi_Info->trackingAreaCode; // cgi_meas->has_tracking_area_code = 1; // cgi_meas->tracking_area_code = (tac.buf[0] << 8) + // (tac.buf[1]); // PLMN_IdentityList2_t *plmn_l = meas_list.list.array[i]-> // cgi_Info->plmn_IdentityList; // cgi_meas->n_plmn_id = plmn_l->list.count; // /* Set the PLMN ID list in CGI measurements. */ // PlmnIdentity **plmn_id_l; // plmn_id_l = malloc(sizeof(PlmnIdentity *) * // cgi_meas->n_plmn_id); // MNC_t mnc2; // MCC_t *mcc2; // for (m = 0; m < cgi_meas->n_plmn_id; m++) { // plmn_id_l[m] = malloc(sizeof(PlmnIdentity)); // plmn_identity__init(plmn_id_l[m]); // mnc2 = plmn_l->list.array[m]->mnc; // plmn_id_l[m]->has_mnc = 1; // plmn_id_l[m]->mnc = 0; // for (k = 0; k < mnc2.list.count; k++) { // plmn_id_l[m]->mnc += *mnc2.list.array[k] * // ((uint32_t) pow(10, mnc2.list.count - k - 1)); // } // mcc2 = plmn_l->list.array[m]->mcc; // plmn_id_l[m]->has_mcc = 1; // plmn_id_l[m]->mcc = 0; // for (k = 0; k < mcc2->list.count; k++) { // plmn_id_l[m]->mcc += *mcc2->list.array[k] * // ((uint32_t) pow(10, mcc2->list.count - k - 1)); // } // } // cgi_meas->plmn_id = plmn_id_l; // eutra_meas[i]->cgi_meas = cgi_meas; // } // } // neigh_meas->eutra_meas = eutra_meas; // } // } // repl->neigh_meas = neigh_meas; // } /* Attach the RRC measurement reply message to RRC measurements message. */ // mrrc_meas->repl = repl; /* Attach RRC measurement message to triggered event message. */ // te->mrrc_meas = mrrc_meas; // te->has_action = 0; /* Attach the triggered event message to main message. */ // reply->te = te; /* Send the report to controller. */ // if (flexran_agent_msg_send(b_id, reply) < 0) { // goto error; // } /* Free the measurement report received from UE. */ // ASN_STRUCT_FREE(asn_DEF_MeasResults, p->meas); /* Free the params. */ // free(p); // stats_reply_msg->cell_report = cell_report; // stats_reply_msg->ue_report = ue_report; // msg = malloc(sizeof(Protocol__FlexranMessage)); // if(msg == NULL) // goto error; // protocol__flexran_message__init(msg); // msg->msg_case = PROTOCOL__FLEXRAN_MESSAGE__MSG_STATS_REPLY_MSG; // msg->msg_dir = PROTOCOL__FLEXRAN_DIRECTION__SUCCESSFUL_OUTCOME; // msg->stats_reply_msg = stats_reply_msg; // data = flexran_agent_pack_message(msg, &size); // if (flexran_agent_msg_send(mod_id, FLEXRAN_AGENT_DEFAULT, data, size, priority)) { // err_code = PROTOCOL__FLEXRAN_ERR__MSG_ENQUEUING; // goto error; // } // LOG_I(FLEXRAN_AGENT,"RRC Trigger is done \n"); return; // error: // LOG_E(FLEXRAN_AGENT, "Could not send UE state message becasue of %d \n",err_code); /* Free the measurement report received from UE. */ // ASN_STRUCT_FREE(asn_DEF_MeasResults, p->meas); /* Free the params. */ // free(p); // return -1; } int flexran_agent_rrc_stats_reply(mid_t mod_id, const report_config_t *report_config, Protocol__FlexUeStatsReport **ue_report, Protocol__FlexCellStatsReport **cell_report) { if (report_config->nr_ue > 0) { rnti_t rntis[report_config->nr_ue]; flexran_get_rrc_rnti_list(mod_id, rntis, report_config->nr_ue); for (int i = 0; i < report_config->nr_ue; i++) { const rnti_t rnti = rntis[i]; /* Check flag for creation of buffer status report */ if (report_config->ue_report_type[i].ue_report_flags & PROTOCOL__FLEX_UE_STATS_TYPE__FLUST_RRC_MEASUREMENTS) { /*Source Cell*/ Protocol__FlexRrcMeasurements *rrc_measurements; rrc_measurements = malloc(sizeof(Protocol__FlexRrcMeasurements)); if (rrc_measurements == NULL) goto error; protocol__flex_rrc_measurements__init(rrc_measurements); rrc_measurements->measid = flexran_get_rrc_pcell_measid(mod_id, rnti); rrc_measurements->has_measid = 1; rrc_measurements->pcell_rsrp = flexran_get_rrc_pcell_rsrp(mod_id, rnti); rrc_measurements->has_pcell_rsrp = 1; rrc_measurements->pcell_rsrq = flexran_get_rrc_pcell_rsrq(mod_id, rnti); rrc_measurements->has_pcell_rsrq = 1 ; /* Target Cell, Neghibouring*/ Protocol__FlexNeighCellsMeasurements *neigh_meas; neigh_meas = malloc(sizeof(Protocol__FlexNeighCellsMeasurements)); if (neigh_meas == NULL) { free(rrc_measurements); rrc_measurements = NULL; goto error; } protocol__flex_neigh_cells_measurements__init(neigh_meas); neigh_meas->n_eutra_meas = flexran_get_rrc_num_ncell(mod_id, rnti); Protocol__FlexEutraMeasurements **eutra_meas = NULL; if (neigh_meas->n_eutra_meas > 0){ eutra_meas = malloc(sizeof(Protocol__FlexEutraMeasurements) * neigh_meas->n_eutra_meas); if (eutra_meas == NULL) { free(neigh_meas); free(rrc_measurements); rrc_measurements = NULL; goto error; } for (int j = 0; j < neigh_meas->n_eutra_meas; j++ ){ eutra_meas[j] = malloc(sizeof(Protocol__FlexEutraMeasurements)); if (eutra_meas[j] == NULL) { for (int k = 0 ; k < j ; k++) { free(eutra_meas[k]); } free(eutra_meas); free(neigh_meas); free(rrc_measurements); rrc_measurements = NULL; goto error; } protocol__flex_eutra_measurements__init(eutra_meas[j]); eutra_meas[j]->phys_cell_id = flexran_get_rrc_neigh_phy_cell_id(mod_id, rnti, j); eutra_meas[j]->has_phys_cell_id = 1; /*TODO: Extend for CGI and PLMNID*/ Protocol__FlexEutraRefSignalMeas *meas_result; meas_result = malloc(sizeof(Protocol__FlexEutraRefSignalMeas)); protocol__flex_eutra_ref_signal_meas__init(meas_result); meas_result->rsrp = flexran_get_rrc_neigh_rsrp(mod_id, rnti, eutra_meas[j]->phys_cell_id); meas_result->has_rsrp = 1; meas_result->rsrq = flexran_get_rrc_neigh_rsrq(mod_id, rnti, eutra_meas[j]->phys_cell_id); meas_result->has_rsrq = 1; eutra_meas[j]->meas_result = meas_result; } neigh_meas->eutra_meas = eutra_meas; rrc_measurements->neigh_meas = neigh_meas; } else { free(neigh_meas); } ue_report[i]->rrc_measurements = rrc_measurements; ue_report[i]->flags |= PROTOCOL__FLEX_UE_STATS_TYPE__FLUST_RRC_MEASUREMENTS; } } } /* To be considered for RRC signaling of cell*/ // if (report_config->nr_cc > 0) { // // Fill in the Cell reports // for (i = 0; i < report_config->nr_cc; i++) { // /* Check flag for creation of noise and interference report */ // if(report_config->cc_report_type[i].cc_report_flags & PROTOCOL__FLEX_CELL_STATS_TYPE__FLCST_NOISE_INTERFERENCE) { // // TODO: Fill in the actual noise and interference report for this cell // Protocol__FlexNoiseInterferenceReport *ni_report; // ni_report = malloc(sizeof(Protocol__FlexNoiseInterferenceReport)); // if(ni_report == NULL) // goto error; // protocol__flex_noise_interference_report__init(ni_report); // // Current frame and subframe number // ni_report->sfn_sf = flexran_get_sfn_sf(enb_id); // ni_report->has_sfn_sf = 1; // //TODO:Received interference power in dbm // ni_report->rip = 0; // ni_report->has_rip = 1; // //TODO:Thermal noise power in dbm // ni_report->tnp = 0; // ni_report->has_tnp = 1; // ni_report->p0_nominal_pucch = flexran_get_p0_nominal_pucch(enb_id, 0); // ni_report->has_p0_nominal_pucch = 1; // cell_report[i]->noise_inter_report = ni_report; // cell_report[i]->flags |= PROTOCOL__FLEX_CELL_STATS_TYPE__FLCST_NOISE_INTERFERENCE; // } // } // } return 0; error: for (int i = 0; i < report_config->nr_ue; i++){ if (ue_report[i]->rrc_measurements && ue_report[i]->rrc_measurements->neigh_meas != NULL){ for (int j = 0; j < ue_report[i]->rrc_measurements->neigh_meas->n_eutra_meas; j++){ free(ue_report[i]->rrc_measurements->neigh_meas->eutra_meas[j]); } free(ue_report[i]->rrc_measurements->neigh_meas); } } if (cell_report != NULL) free(cell_report); if (ue_report != NULL) free(ue_report); return -1; } int flexran_agent_rrc_destroy_stats_reply(Protocol__FlexStatsReply *reply) { for (int i = 0; i < reply->n_ue_report; i++){ if (reply->ue_report[i]->rrc_measurements && reply->ue_report[i]->rrc_measurements->neigh_meas){ for (int j = 0; j < reply->ue_report[i]->rrc_measurements->neigh_meas->n_eutra_meas; j++){ free(reply->ue_report[i]->rrc_measurements->neigh_meas->eutra_meas[j]->meas_result); free(reply->ue_report[i]->rrc_measurements->neigh_meas->eutra_meas[j]); } free(reply->ue_report[i]->rrc_measurements->neigh_meas->eutra_meas); free(reply->ue_report[i]->rrc_measurements->neigh_meas); free(reply->ue_report[i]->rrc_measurements); } } return 0; } void flexran_agent_fill_rrc_ue_config(mid_t mod_id, rnti_t rnti, Protocol__FlexUeConfig *ue_conf) { if (ue_conf->has_rnti && ue_conf->rnti != rnti) { LOG_E(FLEXRAN_AGENT, "ue_config existing RNTI %x does not match RRC RNTI %x\n", ue_conf->rnti, rnti); return; } ue_conf->has_rnti = 1; ue_conf->rnti = rnti; ue_conf->imsi = flexran_get_ue_imsi(mod_id, rnti); ue_conf->has_imsi = 1; //TODO: Set the DRX configuration (optional) //Not supported for now, so we do not set it ue_conf->time_alignment_timer = flexran_get_time_alignment_timer(mod_id, rnti); ue_conf->has_time_alignment_timer = 1; ue_conf->meas_gap_config_pattern = flexran_get_meas_gap_config(mod_id, rnti); ue_conf->has_meas_gap_config_pattern = 1; if(ue_conf->meas_gap_config_pattern != PROTOCOL__FLEX_MEAS_GAP_CONFIG_PATTERN__FLMGCP_OFF) { ue_conf->meas_gap_config_sf_offset = flexran_get_meas_gap_config_offset(mod_id, rnti); ue_conf->has_meas_gap_config_sf_offset = 1; } //TODO: Set the SPS configuration (Optional) //Not supported for now, so we do not set it //TODO: Set the SR configuration (Optional) //We do not set it for now //TODO: Set the CQI configuration (Optional) //We do not set it for now ue_conf->transmission_mode = flexran_get_ue_transmission_mode(mod_id, rnti); ue_conf->has_transmission_mode = 1; Protocol__FlexUeCapabilities *c_capabilities; c_capabilities = malloc(sizeof(Protocol__FlexUeCapabilities)); if (c_capabilities) { protocol__flex_ue_capabilities__init(c_capabilities); c_capabilities->has_half_duplex = 1; c_capabilities->half_duplex = flexran_get_half_duplex(mod_id, rnti); c_capabilities->has_intra_sf_hopping = 1; c_capabilities->intra_sf_hopping = flexran_get_intra_sf_hopping(mod_id, rnti); c_capabilities->has_type2_sb_1 = 1; c_capabilities->type2_sb_1 = flexran_get_type2_sb_1(mod_id, rnti); c_capabilities->has_ue_category = 1; c_capabilities->ue_category = flexran_get_ue_category(mod_id, rnti); c_capabilities->has_res_alloc_type1 = 1; c_capabilities->res_alloc_type1 = flexran_get_res_alloc_type1(mod_id, rnti); ue_conf->capabilities = c_capabilities; } ue_conf->has_ue_transmission_antenna = 1; ue_conf->ue_transmission_antenna = flexran_get_ue_transmission_antenna(mod_id, rnti); ue_conf->has_tti_bundling = 1; ue_conf->tti_bundling = flexran_get_tti_bundling(mod_id, rnti); ue_conf->has_max_harq_tx = 1; ue_conf->max_harq_tx = flexran_get_maxHARQ_TX(mod_id, rnti); ue_conf->has_beta_offset_ack_index = 1; ue_conf->beta_offset_ack_index = flexran_get_beta_offset_ack_index(mod_id, rnti); ue_conf->has_beta_offset_ri_index = 1; ue_conf->beta_offset_ri_index = flexran_get_beta_offset_ri_index(mod_id, rnti); ue_conf->has_beta_offset_cqi_index = 1; ue_conf->beta_offset_cqi_index = flexran_get_beta_offset_cqi_index(mod_id, rnti); /* assume primary carrier */ ue_conf->has_ack_nack_simultaneous_trans = 1; ue_conf->ack_nack_simultaneous_trans = flexran_get_ack_nack_simultaneous_trans(mod_id,0); ue_conf->has_simultaneous_ack_nack_cqi = 1; ue_conf->simultaneous_ack_nack_cqi = flexran_get_simultaneous_ack_nack_cqi(mod_id, rnti); ue_conf->has_aperiodic_cqi_rep_mode = 1; ue_conf->aperiodic_cqi_rep_mode = flexran_get_aperiodic_cqi_rep_mode(mod_id, rnti); ue_conf->has_tdd_ack_nack_feedback = 1; ue_conf->tdd_ack_nack_feedback = flexran_get_tdd_ack_nack_feedback_mode(mod_id, rnti); ue_conf->has_ack_nack_repetition_factor = 1; ue_conf->ack_nack_repetition_factor = flexran_get_ack_nack_repetition_factor(mod_id, rnti); ue_conf->has_extended_bsr_size = 1; ue_conf->extended_bsr_size = flexran_get_extended_bsr_size(mod_id, rnti); } int flexran_agent_register_rrc_xface(mid_t mod_id) { if (agent_rrc_xface[mod_id]) { LOG_E(FLEXRAN_AGENT, "RRC agent for eNB %d is already registered\n", mod_id); return -1; } AGENT_RRC_xface *xface = malloc(sizeof(AGENT_RRC_xface)); if (!xface) { LOG_E(FLEXRAN_AGENT, "could not allocate memory for RRC agent xface %d\n", mod_id); return -1; } // xface->flexran_agent_send_update_rrc_stats = flexran_agent_send_update_rrc_stats; xface->flexran_agent_notify_ue_state_change = flexran_agent_ue_state_change; xface->flexran_trigger_rrc_measurements = flexran_trigger_rrc_measurements; agent_rrc_xface[mod_id] = xface; return 0; } void flexran_agent_fill_rrc_cell_config(mid_t mod_id, uint8_t cc_id, Protocol__FlexCellConfig *conf) { if (!conf->si_config) { conf->si_config = malloc(sizeof(Protocol__FlexSiConfig)); if (conf->si_config) protocol__flex_si_config__init(conf->si_config); } if (conf->si_config) { // TODO THIS IS DU RRC conf->si_config->sib1_length = flexran_get_sib1_length(mod_id, cc_id); conf->si_config->has_sib1_length = 1; conf->si_config->si_window_length = (uint32_t) flexran_get_si_window_length(mod_id, cc_id); conf->si_config->has_si_window_length = 1; conf->si_config->n_si_message = 0; /* Protocol__FlexSiMessage **si_message; */ /* si_message = malloc(sizeof(Protocol__FlexSiMessage *) * si_config->n_si_message); */ /* if(si_message == NULL) */ /* goto error; */ /* for(j = 0; j < si_config->n_si_message; j++){ */ /* si_message[j] = malloc(sizeof(Protocol__FlexSiMessage)); */ /* if(si_message[j] == NULL) */ /* goto error; */ /* protocol__flex_si_message__init(si_message[j]); */ /* //TODO: Fill in with actual value, Periodicity of SI msg in radio frames */ /* si_message[j]->periodicity = 1; //SIPeriod */ /* si_message[j]->has_periodicity = 1; */ /* //TODO: Fill in with actual value, rhe length of the SI message in bytes */ /* si_message[j]->length = 10; */ /* si_message[j]->has_length = 1; */ /* } */ /* if(si_config->n_si_message > 0){ */ /* si_config->si_message = si_message; */ /* } */ } conf->ra_response_window_size = flexran_get_ra_ResponseWindowSize(mod_id, cc_id); conf->has_ra_response_window_size = 1; // belongs to MAC but is read in RRC conf->mac_contention_resolution_timer = flexran_get_mac_ContentionResolutionTimer(mod_id, cc_id); conf->has_mac_contention_resolution_timer = 1; conf->ul_pusch_power = flexran_agent_get_operating_pusch_p0 (mod_id, cc_id); conf->has_ul_pusch_power = 1; conf->n_plmn_id = flexran_get_rrc_num_plmn_ids(mod_id); conf->plmn_id = calloc(conf->n_plmn_id, sizeof(Protocol__FlexPlmn *)); if (conf->plmn_id) { for (int i = 0; i < conf->n_plmn_id; i++) { conf->plmn_id[i] = malloc(sizeof(Protocol__FlexPlmn)); if (!conf->plmn_id[i]) continue; protocol__flex_plmn__init(conf->plmn_id[i]); conf->plmn_id[i]->mcc = flexran_get_rrc_mcc(mod_id, i); conf->plmn_id[i]->has_mcc = 1; conf->plmn_id[i]->mnc = flexran_get_rrc_mnc(mod_id, i); conf->plmn_id[i]->has_mnc = 1; conf->plmn_id[i]->mnc_length = flexran_get_rrc_mnc_digit_length(mod_id, i); conf->plmn_id[i]->has_mnc_length = 1; } } else { conf->n_plmn_id = 0; } } int flexran_agent_unregister_rrc_xface(mid_t mod_id) { if (!agent_rrc_xface[mod_id]) { LOG_E(FLEXRAN_AGENT, "RRC agent for eNB %d is not registered\n", mod_id); return -1; } //xface->agent_ctxt = NULL; // xface->flexran_agent_send_update_rrc_stats = NULL; agent_rrc_xface[mod_id]->flexran_agent_notify_ue_state_change = NULL; agent_rrc_xface[mod_id]->flexran_trigger_rrc_measurements = NULL; free(agent_rrc_xface[mod_id]); agent_rrc_xface[mod_id] = NULL; return 0; } AGENT_RRC_xface *flexran_agent_get_rrc_xface(mid_t mod_id) { return agent_rrc_xface[mod_id]; }