//------------------------------------------------------------------------------ int main( int argc, char **argv ) //------------------------------------------------------------------------------ { // initialize the log (see log.h for details) logInit(); get_options (argc, argv); //Command-line options set_glog(glog_level, glog_verbosity); log_set_instance_type (LOG_INSTANCE_ENB); /* Read eNB configuration file */ enb_properties = enb_config_init(conf_config_file_name); itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info, messages_definition_xml, itti_dump_file); itti_wait_ready(1); if (itti_create_task (TASK_SCTP, sctp_eNB_task, NULL) < 0) { LOG_E(SCTP, "Create task for SCTP failed\n"); return -1; } if (itti_create_task (TASK_S1AP, s1ap_eNB_task, NULL) < 0) { LOG_E(S1AP, "Create task for S1AP failed\n"); return -1; } if (itti_create_task (TASK_ENB_APP, eNB_app_task, NULL) < 0) { LOG_E(S1AP, "Create task for S1AP failed\n"); return -1; } itti_wait_ready(0); sleep(30); logClean(); return 0; }
int nas_init(mme_config_t *mme_config_p) { NAS_DEBUG("Initializing NAS task interface\n"); #if !defined(DISABLE_USE_NAS) nas_log_init(0x3F); nas_network_initialize(mme_config_p); #endif if (itti_create_task(TASK_NAS_MME, &nas_intertask_interface, NULL) < 0) { NAS_ERROR("Create task failed"); NAS_DEBUG("Initializing NAS task interface: FAILED\n"); return -1; } NAS_DEBUG("Initializing NAS task interface: DONE\n"); return 0; }
int sctp_init(const mme_config_t *mme_config_p) { SCTP_DEBUG("Initializing SCTP task interface\n"); memset(&sctp_desc, 0, sizeof(struct sctp_descriptor_s)); /* Number of streams from configuration */ sctp_desc.nb_instreams = mme_config_p->sctp_config.in_streams; sctp_desc.nb_outstreams = mme_config_p->sctp_config.out_streams; if (itti_create_task(TASK_SCTP, &sctp_intertask_interface, NULL) < 0) { SCTP_ERROR("create task failed"); SCTP_DEBUG("Initializing SCTP task interface: FAILED\n"); return -1; } SCTP_DEBUG("Initializing SCTP task interface: DONE\n"); return 0; }
int gtpv1u_init(const mme_config_t *mme_config_p) { int ret = 0; NwGtpv1uRcT rc = 0; NwGtpv1uUlpEntityT ulp; NwGtpv1uUdpEntityT udp; NwGtpv1uLogMgrEntityT log; NwGtpv1uTimerMgrEntityT tmr; GTPU_DEBUG("Initializing GTPV1U interface\n"); memset(>pv1u_sgw_data, 0, sizeof(gtpv1u_sgw_data)); gtpv1u_sgw_data.sgw_ip_address_for_S1u_S12_S4_up = mme_config_p->ipv4.sgw_ip_address_for_S1u_S12_S4_up; if (itti_create_task(TASK_GTPV1_U, >pv1u_thread, NULL) < 0) { GTPU_ERROR("gtpv1u phtread_create: %s", strerror(errno)); return -1; } GTPU_DEBUG("Initializing GTPV1U interface: DONE\n"); return ret; }
int s6a_init(const mme_config_t *mme_config_p) { int ret; S6A_DEBUG("Initializing S6a interface\n"); memset(&s6a_fd_cnf, 0, sizeof(s6a_fd_cnf_t)); /*if (strcmp(fd_core_version(), FREE_DIAMETER_MINIMUM_VERSION) != 0) { S6A_ERROR("Freediameter version %s found, expecting %s\n", fd_core_version(), FREE_DIAMETER_MINIMUM_VERSION); return -1; } else { S6A_DEBUG("Freediameter version %s\n", fd_core_version()); }*/ /* Initializing freeDiameter core */ S6A_DEBUG("Initializing freeDiameter core...\n"); ret = fd_core_initialize(); if (ret != 0) { S6A_ERROR("An error occurred during freeDiameter core library initialization: %d\n",ret); return ret; } else { S6A_DEBUG("Initializing freeDiameter core done\n"); } S6A_DEBUG("Default ext path: %s\n", DEFAULT_EXTENSIONS_PATH); ret = fd_core_parseconf(mme_config_p->s6a_config.conf_file); if (ret != 0) { S6A_ERROR("An error occurred during fd_core_parseconf file :%s.\n", mme_config_p->s6a_config.conf_file); return ret; } /* Set gnutls debug level ? */ if (gnutls_debug) { gnutls_global_set_log_function((gnutls_log_func)fd_gnutls_debug); gnutls_global_set_log_level (gnutls_debug); S6A_DEBUG("Enabled GNUTLS debug at level %d", gnutls_debug); } /* Starting freeDiameter core */ ret = fd_core_start(); if (ret != 0) { S6A_ERROR("An error occurred during freeDiameter core library start\n"); return ret; } ret = fd_core_waitstartcomplete(); if (ret != 0) { S6A_ERROR("An error occurred during fd_core_waitstartcomplete.\n"); return ret; } ret = s6a_fd_init_dict_objs(); if (ret != 0) { S6A_ERROR("An error occurred during s6a_fd_init_dict_objs.\n"); return ret; } /* Trying to connect to peers */ CHECK_FCT(s6a_fd_new_peer()); if (itti_create_task(TASK_S6A, &s6a_thread, NULL) < 0) { S6A_ERROR("s6a create task\n"); return -1; } S6A_DEBUG("Initializing S6a interface: DONE\n"); return 0; }
int flexran_agent_start(mid_t mod_id, const Enb_properties_array_t* enb_properties){ int channel_id; flexran_set_enb_vars(mod_id, RAN_LTE_OAI); flexran_agent[mod_id].enb_id = mod_id; /* * check the configuration */ if (enb_properties->properties[mod_id]->flexran_agent_cache != NULL) { strncpy(local_cache, enb_properties->properties[mod_id]->flexran_agent_cache, sizeof(local_cache)); local_cache[sizeof(local_cache) - 1] = 0; } else { strcpy(local_cache, DEFAULT_FLEXRAN_AGENT_CACHE); } if (enb_properties->properties[mod_id]->flexran_agent_ipv4_address != 0) { inet_ntop(AF_INET, &(enb_properties->properties[mod_id]->flexran_agent_ipv4_address), in_ip, INET_ADDRSTRLEN); } else { strcpy(in_ip, DEFAULT_FLEXRAN_AGENT_IPv4_ADDRESS ); } if (enb_properties->properties[mod_id]->flexran_agent_port != 0 ) { in_port = enb_properties->properties[mod_id]->flexran_agent_port; } else { in_port = DEFAULT_FLEXRAN_AGENT_PORT ; } LOG_I(FLEXRAN_AGENT,"starting enb agent client for module id %d on ipv4 %s, port %d\n", flexran_agent[mod_id].enb_id, in_ip, in_port); /* * Initialize the channel container */ if (!channel_container_init) { flexran_agent_init_channel_container(); channel_container_init = 1; } /*Create the async channel info*/ flexran_agent_async_channel_t *channel_info = flexran_agent_async_channel_info(mod_id, in_ip, in_port); /*Create a channel using the async channel info*/ channel_id = flexran_agent_create_channel((void *) channel_info, flexran_agent_async_msg_send, flexran_agent_async_msg_recv, flexran_agent_async_release); if (channel_id <= 0) { goto error; } flexran_agent_channel_t *channel = get_channel(channel_id); if (channel == NULL) { goto error; } /*Register the channel for all underlying agents (use FLEXRAN_AGENT_MAX)*/ flexran_agent_register_channel(mod_id, channel, FLEXRAN_AGENT_MAX); /*Example of registration for a specific agent(MAC): *flexran_agent_register_channel(mod_id, channel, FLEXRAN_AGENT_MAC); */ /*Initialize the continuous MAC stats update mechanism*/ flexran_agent_init_cont_mac_stats_update(mod_id); new_thread(receive_thread, &flexran_agent[mod_id]); /*Initialize and register the mac xface. Must be modified later *for more flexibility in agent management */ AGENT_MAC_xface *mac_agent_xface = (AGENT_MAC_xface *) malloc(sizeof(AGENT_MAC_xface)); flexran_agent_register_mac_xface(mod_id, mac_agent_xface); /* * initilize a timer */ flexran_agent_init_timer(); /* * Initialize the mac agent */ flexran_agent_init_mac_agent(mod_id); /* * start the enb agent task for tx and interaction with the underlying network function */ if (!agent_task_created) { if (itti_create_task (TASK_FLEXRAN_AGENT, flexran_agent_task, (void *) &flexran_agent[mod_id]) < 0) { LOG_E(FLEXRAN_AGENT, "Create task for FlexRAN Agent failed\n"); return -1; } agent_task_created = 1; } LOG_I(FLEXRAN_AGENT,"client ends\n"); return 0; error: LOG_I(FLEXRAN_AGENT,"there was an error\n"); return 1; }
int s11_sgw_init(const mme_config_t *mme_config_p) { int ret = 0; NwGtpv2cUlpEntityT ulp; NwGtpv2cUdpEntityT udp; NwGtpv2cTimerMgrEntityT tmrMgr; NwGtpv2cLogMgrEntityT logMgr; struct in_addr addr; char *s11_address_str = NULL; S11_DEBUG("Initializing S11 interface\n"); if (nwGtpv2cInitialize(&s11_sgw_stack_handle) != NW_OK) { S11_ERROR("Failed to initialize gtpv2-c stack\n"); goto fail; } /* Set ULP entity */ ulp.hUlp = (NwGtpv2cUlpHandleT)NULL; ulp.ulpReqCallback = s11_sgw_ulp_process_stack_req_cb; DevAssert(NW_OK == nwGtpv2cSetUlpEntity(s11_sgw_stack_handle, &ulp)); /* Set UDP entity */ udp.hUdp = (NwGtpv2cUdpHandleT)NULL; udp.udpDataReqCallback = s11_sgw_send_udp_msg; DevAssert(NW_OK == nwGtpv2cSetUdpEntity(s11_sgw_stack_handle, &udp)); /* Set Timer entity */ tmrMgr.tmrMgrHandle = (NwGtpv2cTimerMgrHandleT)NULL; tmrMgr.tmrStartCallback = s11_sgw_start_timer_wrapper; tmrMgr.tmrStopCallback = s11_sgw_stop_timer_wrapper; DevAssert(NW_OK == nwGtpv2cSetTimerMgrEntity(s11_sgw_stack_handle, &tmrMgr)); logMgr.logMgrHandle = 0; logMgr.logReqCallback = s11_sgw_log_wrapper; DevAssert(NW_OK == nwGtpv2cSetLogMgrEntity(s11_sgw_stack_handle, &logMgr)); if (itti_create_task(TASK_S11, &s11_sgw_thread, NULL) < 0) { S11_ERROR("gtpv1u phtread_create: %s\n", strerror(errno)); goto fail; } DevAssert(NW_OK == nwGtpv2cSetLogLevel(s11_sgw_stack_handle, NW_LOG_LEVEL_DEBG)); config_read_lock(&mme_config); addr.s_addr = mme_config.ipv4.sgw_ip_address_for_S11; config_unlock(&mme_config); s11_address_str = inet_ntoa(addr); DevAssert(s11_address_str != NULL); s11_send_init_udp(s11_address_str, 2123); S11_DEBUG("Initializing S11 interface: DONE\n"); return ret; fail: S11_DEBUG("Initializing S11 interface: FAILURE\n"); return -1; }
int main(int argc, char **argv) { #ifdef RTAI RT_TASK *task; RTIME period; #endif int i,j,aa; void *status; /* uint32_t rf_mode_max[4] = {55759,55759,55759,55759}; uint32_t rf_mode_med[4] = {39375,39375,39375,39375}; uint32_t rf_mode_byp[4] = {22991,22991,22991,22991}; */ uint32_t my_rf_mode = RXEN + TXEN + TXLPFNORM + TXLPFEN + TXLPF25 + RXLPFNORM + RXLPFEN + RXLPF25 + LNA1ON +LNAMax + RFBBNORM + DMAMODE_RX + DMAMODE_TX; uint32_t rf_mode_base = TXLPFNORM + TXLPFEN + TXLPF25 + RXLPFNORM + RXLPFEN + RXLPF25 + LNA1ON +LNAMax + RFBBNORM; uint32_t rf_mode[4] = {my_rf_mode,0,0,0}; uint32_t rf_local[4] = {8255000,8255000,8255000,8255000}; // UE zepto //{8254617, 8254617, 8254617, 8254617}; //eNB khalifa //{8255067,8254810,8257340,8257340}; // eNB PETRONAS uint32_t rf_vcocal[4] = {910,910,910,910}; uint32_t rf_vcocal_850[4] = {2015, 2015, 2015, 2015}; uint32_t rf_rxdc[4] = {32896,32896,32896,32896}; uint32_t rxgain[4] = {20,20,20,20}; uint32_t txgain[4] = {20,20,20,20}; uint16_t Nid_cell = 0; uint8_t cooperation_flag=0, transmission_mode=1, abstraction_flag=0; uint8_t beta_ACK=0,beta_RI=0,beta_CQI=2; int c; char do_forms=0; unsigned int fd; unsigned int tcxo = 114; int amp; uint8_t prach_fmt; int N_ZC; char rxg_fname[100]; char txg_fname[100]; char rflo_fname[100]; char rfdc_fname[100]; FILE *rxg_fd=NULL; FILE *txg_fd=NULL; FILE *rflo_fd=NULL; FILE *rfdc_fd=NULL; unsigned int rxg_max[4]={133,133,133,133}, rxg_med[4]={127,127,127,127}, rxg_byp[4]={120,120,120,120}; int tx_max_power=0; char line[1000]; int l; int ret, ant; int ant_offset=0; int error_code; char *itti_dump_file = NULL; const struct option long_options[] = { {"calib-ue-rx", required_argument, NULL, 256}, {"calib-ue-rx-med", required_argument, NULL, 257}, {"calib-ue-rx-byp", required_argument, NULL, 258}, {"debug-ue-prach", no_argument, NULL, 259}, {"no-L2-connect", no_argument, NULL, 260}, {NULL, 0, NULL, 0}}; //mode = normal_txrx; while ((c = getopt_long (argc, argv, "C:K:O:ST:UdF:V",long_options,NULL)) != -1) { switch (c) { case 'V': ouput_vcd = 1; break; case 'd': do_forms=1; break; case 'U': UE_flag = 1; break; case 'C': carrier_freq[0] = atoi(optarg); carrier_freq[1] = atoi(optarg); carrier_freq[2] = atoi(optarg); carrier_freq[3] = atoi(optarg); break; case 'S': fs4_test=1; break; case 'T': tcxo=atoi(optarg); break; case 'K': #if defined(ENABLE_ITTI) itti_dump_file = strdup(optarg); #else printf("-K option is disabled when ENABLE_ITTI is not defined\n"); #endif break; case 'O': #if defined(ENABLE_USE_MME) EPC_MODE_ENABLED = 1; if (optarg == NULL) /* No IP address provided: use localhost */ { memcpy(&EPC_MODE_MME_ADDRESS[0], "127.0.0.1", 10); } else { uint8_t ip_length = strlen(optarg) + 1; memcpy(&EPC_MODE_MME_ADDRESS[0], optarg, ip_length > 16 ? 16 : ip_length); } #else printf("You enabled mme mode without s1ap compiled...\n"); #endif break; case 'F': sprintf(rxg_fname,"%srxg.lime",optarg); rxg_fd = fopen(rxg_fname,"r"); if (rxg_fd) { printf("Loading RX Gain parameters from %s\n",rxg_fname); l=0; while (fgets(line, sizeof(line), rxg_fd)) { if ((strlen(line)==0) || (*line == '#')) continue; //ignore empty or comment lines else { if (l==0) sscanf(line,"%d %d %d %d",&rxg_max[0],&rxg_max[1],&rxg_max[2],&rxg_max[3]); if (l==1) sscanf(line,"%d %d %d %d",&rxg_med[0],&rxg_med[1],&rxg_med[2],&rxg_med[3]); if (l==2) sscanf(line,"%d %d %d %d",&rxg_byp[0],&rxg_byp[1],&rxg_byp[2],&rxg_byp[3]); l++; } } } else printf("%s not found, running with defaults\n",rxg_fname); sprintf(txg_fname,"%stxg.lime",optarg); txg_fd = fopen(txg_fname,"r"); if (txg_fd) { printf("Loading TX Gain parameters from %s\n",txg_fname); l=0; while (fgets(line, sizeof(line), txg_fd)) { if ((strlen(line)==0) || (*line == '#')) { continue; //ignore empty or comment lines } else { if (l==0) sscanf(line,"%d %d %d %d",&txgain[0],&txgain[1],&txgain[2],&txgain[3]); if (l==1) sscanf(line,"%d",&tx_max_power); l++; } } } else printf("%s not found, running with defaults\n",txg_fname); sprintf(rflo_fname,"%srflo.lime",optarg); rflo_fd = fopen(rflo_fname,"r"); if (rflo_fd) { printf("Loading RF LO parameters from %s\n",rflo_fname); fscanf(rflo_fd,"%d %d %d %d",&rf_local[0],&rf_local[1],&rf_local[2],&rf_local[3]); } else printf("%s not found, running with defaults\n",rflo_fname); sprintf(rfdc_fname,"%srfdc.lime",optarg); rfdc_fd = fopen(rfdc_fname,"r"); if (rfdc_fd) { printf("Loading RF DC parameters from %s\n",rfdc_fname); fscanf(rfdc_fd,"%d %d %d %d",&rf_rxdc[0],&rf_rxdc[1],&rf_rxdc[2],&rf_rxdc[3]); } else printf("%s not found, running with defaults\n",rfdc_fname); break; /* case 256: mode = rx_calib_ue; rx_input_level_dBm = atoi(optarg); printf("Running with UE calibration on (LNA max), input level %d dBm\n",rx_input_level_dBm); break; case 257: mode = rx_calib_ue_med; rx_input_level_dBm = atoi(optarg); printf("Running with UE calibration on (LNA med), input level %d dBm\n",rx_input_level_dBm); break; case 258: mode = rx_calib_ue_byp; rx_input_level_dBm = atoi(optarg); printf("Running with UE calibration on (LNA byp), input level %d dBm\n",rx_input_level_dBm); break; case 259: mode = debug_prach; break; case 260: mode = no_L2_connect; break; */ default: break; } } if (UE_flag==1) printf("configuring for UE\n"); else printf("configuring for eNB\n"); //randominit (0); //set_taus_seed (0); // initialize the log (see log.h for details) logInit(); #if defined(ENABLE_ITTI) itti_init(TASK_MAX, THREAD_MAX, MESSAGES_ID_MAX, tasks_info, messages_info, messages_definition_xml, itti_dump_file); # if defined(ENABLE_USE_MME) if (itti_create_task(TASK_SCTP, sctp_eNB_task, NULL) < 0) { LOG_E(EMU, "Create task failed"); LOG_D(EMU, "Initializing SCTP task interface: FAILED\n"); return -1; } if (itti_create_task(TASK_S1AP, s1ap_eNB_task, NULL) < 0) { LOG_E(EMU, "Create task failed"); LOG_D(EMU, "Initializing S1AP task interface: FAILED\n"); return -1; } # endif if (itti_create_task(TASK_L2L1, l2l1_task, NULL) < 0) { LOG_E(EMU, "Create task failed"); LOG_D(EMU, "Initializing L2L1 task interface: FAILED\n"); return -1; } // Handle signals until all tasks are terminated // itti_wait_tasks_end(); #endif if (ouput_vcd) { if (UE_flag==1) vcd_signal_dumper_init("/tmp/openair_dump_UE.vcd"); else vcd_signal_dumper_init("/tmp/openair_dump_eNB.vcd"); } #ifdef NAS_NETLINK netlink_init(); #endif // to make a graceful exit when ctrl-c is pressed signal(SIGSEGV, signal_handler); signal(SIGINT, signal_handler); #ifndef RTAI check_clock(); #endif g_log->log_component[HW].level = LOG_DEBUG; g_log->log_component[HW].flag = LOG_HIGH; #ifdef OPENAIR2 g_log->log_component[PHY].level = LOG_INFO; #else g_log->log_component[PHY].level = LOG_INFO; #endif g_log->log_component[PHY].flag = LOG_HIGH; g_log->log_component[MAC].level = LOG_INFO; g_log->log_component[MAC].flag = LOG_HIGH; g_log->log_component[RLC].level = LOG_INFO; g_log->log_component[RLC].flag = LOG_HIGH; g_log->log_component[PDCP].level = LOG_INFO; g_log->log_component[PDCP].flag = LOG_HIGH; g_log->log_component[OTG].level = LOG_INFO; g_log->log_component[OTG].flag = LOG_HIGH; g_log->log_component[RRC].level = LOG_INFO; g_log->log_component[RRC].flag = LOG_HIGH; // Initialize card ret = openair0_open(); if ( ret != 0 ) { if (ret == -1) printf("Error opening /dev/openair0"); if (ret == -2) printf("Error mapping bigshm"); if (ret == -3) printf("Error mapping RX or TX buffer"); return(ret); } printf ("Detected %d number of cards, %d number of antennas.\n", openair0_num_detected_cards, openair0_num_antennas[card]); p_exmimo_config = openair0_exmimo_pci[card].exmimo_config_ptr; p_exmimo_id = openair0_exmimo_pci[card].exmimo_id_ptr; printf("Card %d: ExpressMIMO %d, HW Rev %d, SW Rev 0x%d\n", card, p_exmimo_id->board_exmimoversion, p_exmimo_id->board_hwrev, p_exmimo_id->board_swrev); if (p_exmimo_id->board_swrev>=BOARD_SWREV_CNTL2) p_exmimo_config->framing.eNB_flag = 0; else p_exmimo_config->framing.eNB_flag = !UE_flag; p_exmimo_config->framing.tdd_config = DUPLEXMODE_FDD + TXRXSWITCH_LSB; for (ant=0; ant<4; ant++) p_exmimo_config->framing.resampling_factor[ant] = RESAMPLING_FACTOR; /* for (ant=0;ant<max(frame_parms->nb_antennas_tx,frame_parms->nb_antennas_rx);ant++) p_exmimo_config->rf.rf_mode[ant] = rf_mode_base; for (ant=0;ant<frame_parms->nb_antennas_tx;ant++) p_exmimo_config->rf.rf_mode[ant] += (TXEN + DMAMODE_TX); for (ant=0;ant<frame_parms->nb_antennas_rx;ant++) p_exmimo_config->rf.rf_mode[ant] += (RXEN + DMAMODE_RX); for (ant=max(frame_parms->nb_antennas_tx,frame_parms->nb_antennas_rx);ant<4;ant++) { p_exmimo_config->rf.rf_mode[ant] = 0; carrier_freq[ant] = 0; //this turns off all other LIMEs } */ ant_offset = 0; for (ant=0; ant<4; ant++) { if (ant==ant_offset) { //if (1) { p_exmimo_config->rf.rf_mode[ant] = rf_mode_base; //p_exmimo_config->rf.rf_mode[ant] += (TXEN + DMAMODE_TX); p_exmimo_config->rf.rf_mode[ant] += (RXEN + DMAMODE_RX); } else { p_exmimo_config->rf.rf_mode[ant] = 0; carrier_freq[ant] = 0; //this turns off all other LIMEs } } for (ant = 0; ant<4; ant++) { p_exmimo_config->rf.do_autocal[ant] = 1; p_exmimo_config->rf.rf_freq_rx[ant] = carrier_freq[ant]; p_exmimo_config->rf.rf_freq_tx[ant] = carrier_freq[ant]; p_exmimo_config->rf.rx_gain[ant][0] = rxgain[ant]; p_exmimo_config->rf.tx_gain[ant][0] = txgain[ant]; p_exmimo_config->rf.rf_local[ant] = rf_local[ant]; p_exmimo_config->rf.rf_rxdc[ant] = rf_rxdc[ant]; if ((carrier_freq[ant] >= 850000000) && (carrier_freq[ant] <= 865000000)) { p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal_850[ant]; p_exmimo_config->rf.rffe_band_mode[ant] = DD_TDD; } else if ((carrier_freq[ant] >= 1900000000) && (carrier_freq[ant] <= 2000000000)) { p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal[ant]; p_exmimo_config->rf.rffe_band_mode[ant] = B19G_TDD; } else { p_exmimo_config->rf.rf_vcocal[ant] = rf_vcocal[ant]; p_exmimo_config->rf.rffe_band_mode[ant] = 0; } p_exmimo_config->rf.rffe_gain_txlow[ant] = 31; p_exmimo_config->rf.rffe_gain_txhigh[ant] = 31; p_exmimo_config->rf.rffe_gain_rxfinal[ant] = 52; p_exmimo_config->rf.rffe_gain_rxlow[ant] = 31; } number_of_cards = openair0_num_detected_cards; /* if (p_exmimo_id->board_exmimoversion==1) //ExpressMIMO1 openair_daq_vars.timing_advance = 138; else //ExpressMIMO2 openair_daq_vars.timing_advance = 0; */ openair0_dump_config(card); printf("EXMIMO_CONFIG: rf_mode 0x %x %x %x %x, [0]: TXRXEn %d, TXLPFEn %d, TXLPF %d, RXLPFEn %d, RXLPF %d, RFBB %d, LNA %d, LNAGain %d, RXLPFMode %d, SWITCH %d, rf_rxdc %d, rf_local %d, rf_vcocal %d\n", p_exmimo_config->rf.rf_mode[0], p_exmimo_config->rf.rf_mode[1], p_exmimo_config->rf.rf_mode[2], p_exmimo_config->rf.rf_mode[3], (p_exmimo_config->rf.rf_mode[0]&3), // RXen+TXen (p_exmimo_config->rf.rf_mode[0]&4)>>2, //TXLPFen (p_exmimo_config->rf.rf_mode[0]&TXLPFMASK)>>3, //TXLPF (p_exmimo_config->rf.rf_mode[0]&128)>>7, //RXLPFen (p_exmimo_config->rf.rf_mode[0]&RXLPFMASK)>>8, //TXLPF (p_exmimo_config->rf.rf_mode[0]&RFBBMASK)>>16, // RFBB mode (p_exmimo_config->rf.rf_mode[0]&LNAMASK)>>12, // RFBB mode (p_exmimo_config->rf.rf_mode[0]&LNAGAINMASK)>>14, // RFBB mode (p_exmimo_config->rf.rf_mode[0]&RXLPFMODEMASK)>>19, // RXLPF mode (p_exmimo_config->framing.tdd_config&TXRXSWITCH_MASK)>>1, // Switch mode p_exmimo_config->rf.rf_rxdc[0], p_exmimo_config->rf.rf_local[0], p_exmimo_config->rf.rf_vcocal[0]); for (ant=0;ant<4;ant++) p_exmimo_config->rf.do_autocal[ant] = 0; #ifdef EMOS error_code = rtf_create(CHANSOUNDER_FIFO_MINOR,CHANSOUNDER_FIFO_SIZE); if (error_code==0) printf("[OPENAIR][SCHED][INIT] Created EMOS FIFO %d\n",CHANSOUNDER_FIFO_MINOR); else if (error_code==ENODEV) printf("[OPENAIR][SCHED][INIT] Problem: EMOS FIFO %d is greater than or equal to RTF_NO\n",CHANSOUNDER_FIFO_MINOR); else if (error_code==ENOMEM) printf("[OPENAIR][SCHED][INIT] Problem: cannot allocate memory for EMOS FIFO %d\n",CHANSOUNDER_FIFO_MINOR); else printf("[OPENAIR][SCHED][INIT] Problem creating EMOS FIFO %d, error_code %d\n",CHANSOUNDER_FIFO_MINOR,error_code); #endif mlockall(MCL_CURRENT | MCL_FUTURE); #ifdef RTAI // make main thread LXRT soft realtime task = rt_task_init_schmod(nam2num("MYTASK"), 9, 0, 0, SCHED_FIFO, 0xF); // start realtime timer and scheduler #ifdef TIMER_ONESHOT_MODE rt_set_oneshot_mode(); start_rt_timer(0); printf("started RTAI timer inoneshot mode\n"); #else rt_set_periodic_mode(); period = start_rt_timer(nano2count(500000)); printf("started RTAI timer with period %llu ns\n",count2nano(period)); #endif printf("Init mutex\n"); //mutex = rt_get_adr(nam2num("MUTEX")); mutex = rt_sem_init(nam2num("MUTEX"), 1); if (mutex==0) { printf("Error init mutex\n"); exit(-1); } else printf("mutex=%p\n",mutex); #endif DAQ_MBOX = (volatile unsigned int *) openair0_exmimo_pci[card].rxcnt_ptr[0]; // this starts the DMA transfers if (UE_flag!=1) openair0_start_rt_acquisition(card); #ifdef XFORMS if (do_forms==1) { fl_initialize (&argc, argv, NULL, 0, 0); form_stats = create_form_stats_form(); if (UE_flag==1) { form_ue[UE_id] = create_lte_phy_scope_ue(); sprintf (title, "LTE DL SCOPE UE"); fl_show_form (form_ue[UE_id]->lte_phy_scope_ue, FL_PLACE_HOTSPOT, FL_FULLBORDER, title); } else { for(UE_id=0;UE_id<scope_enb_num_ue;UE_id++) { form_enb[UE_id] = create_lte_phy_scope_enb(); sprintf (title, "UE%d LTE UL SCOPE eNB",UE_id+1); fl_show_form (form_enb[UE_id]->lte_phy_scope_enb, FL_PLACE_HOTSPOT, FL_FULLBORDER, title); } } fl_show_form (form_stats->stats_form, FL_PLACE_HOTSPOT, FL_FULLBORDER, "stats"); if (UE_flag==0) { for (UE_id=0;UE_id<scope_enb_num_ue;UE_id++) { if (otg_enabled) { fl_set_button(form_enb[UE_id]->button_0,1); fl_set_object_label(form_enb[UE_id]->button_0,"DL Traffic ON"); } else { fl_set_button(form_enb[UE_id]->button_0,0); fl_set_object_label(form_enb[UE_id]->button_0,"DL Traffic OFF"); } } } else { if (openair_daq_vars.use_ia_receiver) { fl_set_button(form_ue[UE_id]->button_0,1); fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver ON"); } else { fl_set_button(form_ue[UE_id]->button_0,0); fl_set_object_label(form_ue[UE_id]->button_0, "IA Receiver OFF"); } } ret = pthread_create(&thread2, NULL, scope_thread, NULL); printf("Scope thread created, ret=%d\n",ret); } #endif #ifdef EMOS ret = pthread_create(&thread3, NULL, emos_thread, NULL); printf("EMOS thread created, ret=%d\n",ret); #endif rt_sleep_ns(10*FRAME_PERIOD); #ifndef RTAI pthread_attr_init (&attr_dlsch_threads); pthread_attr_setstacksize(&attr_dlsch_threads,OPENAIR_THREAD_STACK_SIZE); //attr_dlsch_threads.priority = 1; sched_param_dlsch.sched_priority = sched_get_priority_max(SCHED_FIFO); //OPENAIR_THREAD_PRIORITY; pthread_attr_setschedparam (&attr_dlsch_threads, &sched_param_dlsch); pthread_attr_setschedpolicy (&attr_dlsch_threads, SCHED_FIFO); #endif // start the main thread if (UE_flag == 1) { /* #ifdef RTAI thread1 = rt_thread_create(UE_thread, NULL, 100000000); #else error_code = pthread_create(&thread1, &attr_dlsch_threads, UE_thread, NULL); if (error_code!= 0) { LOG_D(HW,"[lte-softmodem.c] Could not allocate UE_thread, error %d\n",error_code); return(error_code); } else { LOG_D(HW,"[lte-softmodem.c] Allocate UE_thread successful\n"); } #endif #ifdef DLSCH_THREAD init_rx_pdsch_thread(); rt_sleep_ns(FRAME_PERIOD/10); init_dlsch_threads(); #endif printf("UE threads created\n"); */ } else { #ifdef RTAI thread0 = rt_thread_create(eNB_thread, NULL, 100000000); #else error_code = pthread_create(&thread0, &attr_dlsch_threads, eNB_thread, NULL); if (error_code!= 0) { LOG_D(HW,"[lte-softmodem.c] Could not allocate eNB_thread, error %d\n",error_code); return(error_code); } else { LOG_D(HW,"[lte-softmodem.c] Allocate eNB_thread successful\n"); } #endif #ifdef ULSCH_THREAD init_ulsch_threads(); #endif printf("eNB threads created\n"); } // wait for end of program printf("TYPE <CTRL-C> TO TERMINATE\n"); //getchar(); while (oai_exit==0) rt_sleep_ns(FRAME_PERIOD); // stop threads #ifdef XFORMS printf("waiting for XFORMS thread\n"); if (do_forms==1) { pthread_join(thread2,&status); fl_hide_form(form_stats->stats_form); fl_free_form(form_stats->stats_form); if (UE_flag==1) { fl_hide_form(form_ue[UE_id]->lte_phy_scope_ue); fl_free_form(form_ue[UE_id]->lte_phy_scope_ue); } else { for(UE_id=0;UE_id<scope_enb_num_ue;UE_id++) { fl_hide_form(form_enb[UE_id]->lte_phy_scope_enb); fl_free_form(form_enb[UE_id]->lte_phy_scope_enb); } } } #endif printf("stopping MODEM threads\n"); // cleanup if (UE_flag == 1) { /* #ifdef RTAI rt_thread_join(thread1); #else pthread_join(thread1,&status); #endif #ifdef DLSCH_THREAD cleanup_dlsch_threads(); cleanup_rx_pdsch_thread(); #endif */ } else { #ifdef RTAI rt_thread_join(thread0); #else pthread_join(thread0,&status); #endif #ifdef ULSCH_THREAD cleanup_ulsch_threads(); #endif } #ifdef OPENAIR2 //cleanup_pdcp_thread(); #endif #ifdef RTAI stop_rt_timer(); #endif printf("stopping card\n"); openair0_stop(card); printf("closing openair0_lib\n"); openair0_close(); #ifdef EMOS printf("waiting for EMOS thread\n"); pthread_cancel(thread3); pthread_join(thread3,&status); #endif #ifdef EMOS error_code = rtf_destroy(CHANSOUNDER_FIFO_MINOR); printf("[OPENAIR][SCHED][CLEANUP] EMOS FIFO closed, error_code %d\n", error_code); #endif if (ouput_vcd) vcd_signal_dumper_close(); logClean(); return 0; }
int create_tasks(uint32_t enb_nb, uint32_t ue_nb) { itti_wait_ready(1); # ifdef OPENAIR2 { # if defined(ENABLE_USE_MME) { if (enb_nb > 0) { if (itti_create_task (TASK_SCTP, sctp_eNB_task, NULL) < 0) { LOG_E(SCTP, "Create task for SCTP failed\n"); return -1; } if (itti_create_task (TASK_S1AP, s1ap_eNB_task, NULL) < 0) { LOG_E(S1AP, "Create task for S1AP failed\n"); return -1; } if (itti_create_task (TASK_UDP, udp_eNB_task, NULL) < 0) { LOG_E(UDP_, "Create task for UDP failed\n"); return -1; } if (itti_create_task (TASK_GTPV1_U, >pv1u_eNB_task, NULL) < 0) { LOG_E(GTPU, "Create task for GTPV1U failed\n"); return -1; } } # if defined(NAS_BUILT_IN_UE) if (ue_nb > 0) { if (itti_create_task (TASK_NAS_UE, nas_ue_task, NULL) < 0) { LOG_E(NAS, "Create task for NAS UE failed\n"); return -1; } } # endif } # endif if (enb_nb > 0) { if (itti_create_task (TASK_RRC_ENB, rrc_enb_task, NULL) < 0) { LOG_E(RRC, "Create task for RRC eNB failed\n"); return -1; } # if ENABLE_RAL if (itti_create_task (TASK_RAL_ENB, eRAL_task, NULL) < 0) { LOG_E(RAL_ENB, "Create task for RAL eNB failed\n"); return -1; } # endif } if (ue_nb > 0) { if (itti_create_task (TASK_RRC_UE, rrc_ue_task, NULL) < 0) { LOG_E(RRC, "Create task for RRC UE failed\n"); return -1; } # if ENABLE_RAL if (itti_create_task (TASK_RAL_UE, mRAL_task, NULL) < 0) { LOG_E(RAL_UE, "Create task for RAL UE failed\n"); return -1; } # endif } } # endif if (itti_create_task (TASK_L2L1, l2l1_task, NULL) < 0) { LOG_E(PDCP, "Create task for L2L1 failed\n"); return -1; } if (enb_nb > 0) { /* Last task to create, others task must be ready before its start */ if (itti_create_task (TASK_ENB_APP, eNB_app_task, NULL) < 0) { LOG_E(ENB_APP, "Create task for eNB APP failed\n"); return -1; } } itti_wait_ready(0); return 0; }
//------------------------------------------------------------------------------ int msc_init ( const msc_env_t envP, const int max_threadsP) //------------------------------------------------------------------------------ { int i; int rv; void *pointer_p; char msc_filename[256]; fprintf (stderr, "Initializing MSC logs\n"); rv = snprintf (msc_filename, 256, "/tmp/openair.msc.%u.log", envP); // TODO NAME if ((0 >= rv) || (256 < rv)) { fprintf (stderr, "Error in MSC log file name"); } g_msc_fd = fopen (msc_filename, "w"); AssertFatal (g_msc_fd != NULL, "Could not open MSC log file %s : %s", msc_filename, strerror (errno)); rv = lfds611_stack_new (&g_msc_memory_stack_p, (lfds611_atom_t) max_threadsP + 2); if (0 >= rv) { AssertFatal (0, "lfds611_stack_new failed!\n"); } rv = lfds611_queue_new (&g_msc_message_queue_p, (lfds611_atom_t) MSC_MAX_QUEUE_ELEMENTS); AssertFatal (rv, "lfds611_queue_new failed!\n"); AssertFatal (g_msc_message_queue_p != NULL, "g_msc_message_queue_p is NULL!\n"); msc_start_use (); for (i = 0; i < max_threadsP * 30; i++) { pointer_p = malloc (MSC_MAX_MESSAGE_LENGTH); AssertFatal (pointer_p, "malloc failed!\n"); rv = lfds611_stack_guaranteed_push (g_msc_memory_stack_p, pointer_p); AssertFatal (rv, "lfds611_stack_guaranteed_push failed for item %u\n", i); } for (i = MIN_MSC_PROTOS; i < MAX_MSC_PROTOS; i++) { switch (i) { case MSC_NAS_UE: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "NAS_UE"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } break; case MSC_S1AP_ENB: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "S1AP_ENB"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if ((envP == MSC_MME_GW) || (envP == MSC_MME)) { msc_log_declare_proto (i); } break; case MSC_GTPU_ENB: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "GTPU_ENB"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } break; case MSC_GTPU_SGW: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "GTPU_SGW"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if (envP == MSC_MME_GW) { msc_log_declare_proto (i); } break; case MSC_S1AP_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "S1AP_MME"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if ((envP == MSC_MME_GW) || (envP == MSC_MME)) { msc_log_declare_proto (i); } break; case MSC_MMEAPP_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "MME_APP"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if ((envP == MSC_MME_GW) || (envP == MSC_MME)) { msc_log_declare_proto (i); } break; case MSC_NAS_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "NAS_MME"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } msc_log_declare_proto (i); break; case MSC_NAS_EMM_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "NAS_EMM"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if ((envP == MSC_MME_GW) || (envP == MSC_MME)) { msc_log_declare_proto (i); } break; case MSC_NAS_ESM_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "NAS_ESM"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if ((envP == MSC_MME_GW) || (envP == MSC_MME)) { msc_log_declare_proto (i); } break; case MSC_SP_GWAPP_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "SP_GW_MME"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if (envP == MSC_MME_GW) { msc_log_declare_proto (i); } break; case MSC_S11_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "S11_MME"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if (envP == MSC_MME) { msc_log_declare_proto (i); } break; case MSC_S6A_MME: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "S6A"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if ((envP == MSC_MME_GW) || (envP == MSC_MME)) { msc_log_declare_proto (i); } break; case MSC_HSS: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "HSS"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } if ((envP == MSC_MME_GW) || (envP == MSC_MME)) { msc_log_declare_proto (i); } break; default: rv = snprintf (&g_msc_proto2str[i][0], MSC_MAX_PROTO_NAME_LENGTH, "UNKNOWN"); if (rv >= MSC_MAX_PROTO_NAME_LENGTH) { g_msc_proto2str[i][MSC_MAX_PROTO_NAME_LENGTH - 1] = 0; } } } rv = itti_create_task (TASK_MSC, msc_task, NULL); AssertFatal (rv == 0, "Create task for MSC failed!\n"); fprintf (stderr, "Initializing MSC logs Done\n"); return 0; }