Cedric Roux
7757b9e7e7
It has been chosen to not include the full history of commits from David. He included a binary version of wireshark, probably a modified one that understands NFAPI. Wireshark is released under the GPL license, we cannot include it in the repository. We could have done a next commit to remove this binary. But then it would still be present in the history of commits, which may not be allowed. And it would take space on disk. We could edit the history to remove wireshark entirely. But this operation is too complicated. There was also a pcap capture file, which has nothing to do in the history of commits and would take space on disk. There again, it's too difficult to edit the history to remove it. There was a file .gitignore that was also removed. The original history can be found on David's repository: https://gitlab.eurecom.fr/daveprice/openairinterface5g/ The branch is: nfapi-ru-rau-split. A copy of that branch has been included in the internal OAI repository, for those who have access to it. The branch is the same. The last commit ID is 9106438239e0bc626ff1fa1d97d911caadd0fbb9. You can compare the current commit with the commit 9106... to see what differs. The current commit has to be considered non-working. The commit following the current commit will fix problems with the work in the current commit. If you use git bisect, don't spend time analyzing the current commit.
293 lines
7.3 KiB
C
293 lines
7.3 KiB
C
/*
|
|
* 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 main.c
|
|
* \brief top init of Layer 2
|
|
* \author Navid Nikaein and Raymond Knopp
|
|
* \date 2010 - 2014
|
|
* \version 1.0
|
|
* \email: navid.nikaein@eurecom.fr
|
|
* @ingroup _mac
|
|
|
|
*/
|
|
|
|
#include "defs.h"
|
|
#include "proto.h"
|
|
#include "extern.h"
|
|
#include "assertions.h"
|
|
#include "PHY_INTERFACE/extern.h"
|
|
#include "PHY/defs.h"
|
|
#include "SCHED/defs.h"
|
|
#include "LAYER2/PDCP_v10.1.0/pdcp.h"
|
|
#include "RRC/LITE/defs.h"
|
|
#include "UTIL/LOG/log.h"
|
|
#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
|
|
|
|
#include "SCHED/defs.h"
|
|
|
|
|
|
#include "common/ran_context.h"
|
|
|
|
extern RAN_CONTEXT_t RC;
|
|
extern void openair_rrc_top_init_ue( int eMBMS_active, char* uecap_xer, uint8_t cba_group_active, uint8_t HO_active);
|
|
|
|
void dl_phy_sync_success(module_id_t module_idP, frame_t frameP, unsigned char eNB_index, uint8_t first_sync) //init as MR
|
|
{
|
|
LOG_D(MAC, "[UE %d] Frame %d: PHY Sync to eNB_index %d successful \n",
|
|
module_idP, frameP, eNB_index);
|
|
#if defined(ENABLE_USE_MME)
|
|
int mme_enabled = 1;
|
|
#else
|
|
int mme_enabled = 0;
|
|
#endif
|
|
|
|
if (first_sync == 1 && !(mme_enabled == 1)) {
|
|
//layer2_init_UE(module_idP);
|
|
openair_rrc_ue_init(module_idP, eNB_index);
|
|
} else {
|
|
rrc_in_sync_ind(module_idP, frameP, eNB_index);
|
|
}
|
|
}
|
|
|
|
void
|
|
mac_UE_out_of_sync_ind(module_id_t module_idP, frame_t frameP,
|
|
uint16_t eNB_index)
|
|
{
|
|
|
|
// Mac_rlc_xface->mac_out_of_sync_ind(Mod_id, frameP, eNB_index);
|
|
}
|
|
|
|
|
|
int
|
|
mac_top_init_ue(int eMBMS_active, char *uecap_xer,
|
|
uint8_t cba_group_active, uint8_t HO_active)
|
|
{
|
|
|
|
int i;
|
|
|
|
LOG_I(MAC, "[MAIN] Init function start:Nb_UE_INST=%d\n", NB_UE_INST);
|
|
|
|
if (NB_UE_INST > 0) {
|
|
UE_mac_inst =
|
|
(UE_MAC_INST *) malloc16(NB_UE_INST * sizeof(UE_MAC_INST));
|
|
|
|
AssertFatal(UE_mac_inst != NULL,
|
|
"[MAIN] Can't ALLOCATE %zu Bytes for %d UE_MAC_INST with size %zu \n",
|
|
NB_UE_INST * sizeof(UE_MAC_INST), NB_UE_INST,
|
|
sizeof(UE_MAC_INST));
|
|
|
|
LOG_D(MAC, "[MAIN] ALLOCATE %zu Bytes for %d UE_MAC_INST @ %p\n",
|
|
NB_UE_INST * sizeof(UE_MAC_INST), NB_UE_INST, UE_mac_inst);
|
|
|
|
bzero(UE_mac_inst, NB_UE_INST * sizeof(UE_MAC_INST));
|
|
|
|
for (i = 0; i < NB_UE_INST; i++) {
|
|
ue_init_mac(i);
|
|
}
|
|
} else {
|
|
UE_mac_inst = NULL;
|
|
}
|
|
|
|
|
|
LOG_I(MAC, "[MAIN] calling RRC\n");
|
|
openair_rrc_top_init_ue(eMBMS_active, uecap_xer, cba_group_active,
|
|
HO_active);
|
|
|
|
|
|
LOG_I(MAC, "[MAIN][INIT] Init function finished\n");
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
void mac_top_init_eNB(void)
|
|
{
|
|
|
|
module_id_t i, j;
|
|
int list_el;
|
|
UE_list_t *UE_list;
|
|
eNB_MAC_INST *mac;
|
|
|
|
LOG_I(MAC, "[MAIN] Init function start:nb_macrlc_inst=%d\n",
|
|
RC.nb_macrlc_inst);
|
|
|
|
if (RC.nb_macrlc_inst > 0) {
|
|
RC.mac =
|
|
(eNB_MAC_INST **) malloc16(RC.nb_macrlc_inst *
|
|
sizeof(eNB_MAC_INST *));
|
|
AssertFatal(RC.mac != NULL,
|
|
"can't ALLOCATE %zu Bytes for %d eNB_MAC_INST with size %zu \n",
|
|
RC.nb_macrlc_inst * sizeof(eNB_MAC_INST *),
|
|
RC.nb_macrlc_inst, sizeof(eNB_MAC_INST));
|
|
for (i = 0; i < RC.nb_macrlc_inst; i++) {
|
|
RC.mac[i] = (eNB_MAC_INST *) malloc16(sizeof(eNB_MAC_INST));
|
|
AssertFatal(RC.mac != NULL,
|
|
"can't ALLOCATE %zu Bytes for %d eNB_MAC_INST with size %zu \n",
|
|
RC.nb_macrlc_inst * sizeof(eNB_MAC_INST *),
|
|
RC.nb_macrlc_inst, sizeof(eNB_MAC_INST));
|
|
LOG_D(MAC,
|
|
"[MAIN] ALLOCATE %zu Bytes for %d eNB_MAC_INST @ %p\n",
|
|
sizeof(eNB_MAC_INST), RC.nb_macrlc_inst, RC.mac);
|
|
bzero(RC.mac[i], sizeof(eNB_MAC_INST));
|
|
RC.mac[i]->Mod_id = i;
|
|
for (j = 0; j < MAX_NUM_CCs; j++) {
|
|
RC.mac[i]->DL_req[j].dl_config_request_body.
|
|
dl_config_pdu_list = RC.mac[i]->dl_config_pdu_list[j];
|
|
RC.mac[i]->UL_req[j].ul_config_request_body.
|
|
ul_config_pdu_list = RC.mac[i]->ul_config_pdu_list[j];
|
|
for (int k = 0; k < 10; k++)
|
|
RC.mac[i]->UL_req_tmp[j][k].
|
|
ul_config_request_body.ul_config_pdu_list =
|
|
RC.mac[i]->ul_config_pdu_list_tmp[j][k];
|
|
RC.mac[i]->HI_DCI0_req[j].
|
|
hi_dci0_request_body.hi_dci0_pdu_list =
|
|
RC.mac[i]->hi_dci0_pdu_list[j];
|
|
RC.mac[i]->TX_req[j].tx_request_body.tx_pdu_list =
|
|
RC.mac[i]->tx_request_pdu[j];
|
|
RC.mac[i]->ul_handle = 0;
|
|
}
|
|
}
|
|
|
|
AssertFatal(rlc_module_init() == 0,
|
|
"Could not initialize RLC layer\n");
|
|
|
|
// These should be out of here later
|
|
pdcp_layer_init();
|
|
|
|
rrc_init_global_param();
|
|
|
|
} else {
|
|
RC.mac = NULL;
|
|
}
|
|
|
|
// Initialize Linked-List for Active UEs
|
|
for (i = 0; i < RC.nb_macrlc_inst; i++) {
|
|
mac = RC.mac[i];
|
|
|
|
|
|
mac->if_inst = IF_Module_init(i);
|
|
|
|
UE_list = &mac->UE_list;
|
|
|
|
UE_list->num_UEs = 0;
|
|
UE_list->head = -1;
|
|
UE_list->head_ul = -1;
|
|
UE_list->avail = 0;
|
|
|
|
for (list_el = 0; list_el < NUMBER_OF_UE_MAX - 1; list_el++) {
|
|
UE_list->next[list_el] = list_el + 1;
|
|
UE_list->next_ul[list_el] = list_el + 1;
|
|
}
|
|
|
|
UE_list->next[list_el] = -1;
|
|
UE_list->next_ul[list_el] = -1;
|
|
}
|
|
|
|
}
|
|
|
|
void mac_init_cell_params(int Mod_idP, int CC_idP)
|
|
{
|
|
|
|
int j;
|
|
UE_TEMPLATE *UE_template;
|
|
|
|
LOG_D(MAC, "[MSC_NEW][FRAME 00000][MAC_eNB][MOD %02d][]\n", Mod_idP);
|
|
//COMMON_channels_t *cc = &RC.mac[Mod_idP]->common_channels[CC_idP];
|
|
|
|
memset(&RC.mac[Mod_idP]->eNB_stats, 0, sizeof(eNB_STATS));
|
|
UE_template =
|
|
(UE_TEMPLATE *) & RC.mac[Mod_idP]->UE_list.UE_template[CC_idP][0];
|
|
|
|
for (j = 0; j < NUMBER_OF_UE_MAX; j++) {
|
|
UE_template[j].rnti = 0;
|
|
// initiallize the eNB to UE statistics
|
|
memset(&RC.mac[Mod_idP]->UE_list.eNB_UE_stats[CC_idP][j], 0,
|
|
sizeof(eNB_UE_STATS));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
int rlcmac_init_global_param(void)
|
|
{
|
|
|
|
|
|
LOG_I(MAC, "[MAIN] CALLING RLC_MODULE_INIT...\n");
|
|
|
|
if (rlc_module_init() != 0) {
|
|
return (-1);
|
|
}
|
|
|
|
pdcp_layer_init();
|
|
|
|
LOG_I(MAC, "[MAIN] Init Global Param Done\n");
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void mac_top_cleanup(void)
|
|
{
|
|
|
|
#ifndef USER_MODE
|
|
pdcp_module_cleanup();
|
|
#endif
|
|
|
|
if (NB_UE_INST > 0) {
|
|
free(UE_mac_inst);
|
|
}
|
|
|
|
if (RC.nb_macrlc_inst > 0) {
|
|
free(RC.mac);
|
|
}
|
|
|
|
}
|
|
|
|
int
|
|
l2_init_ue(int eMBMS_active, char *uecap_xer, uint8_t cba_group_active,
|
|
uint8_t HO_active)
|
|
{
|
|
LOG_I(MAC, "[MAIN] MAC_INIT_GLOBAL_PARAM IN...\n");
|
|
// NB_NODE=2;
|
|
// NB_INST=2;
|
|
|
|
rlcmac_init_global_param();
|
|
LOG_I(MAC, "[MAIN] init UE MAC functions \n");
|
|
mac_top_init_ue(eMBMS_active, uecap_xer, cba_group_active, HO_active);
|
|
return (1);
|
|
}
|
|
|
|
int l2_init_eNB(void)
|
|
{
|
|
|
|
|
|
|
|
LOG_I(MAC, "[MAIN] MAC_INIT_GLOBAL_PARAM IN...\n");
|
|
|
|
rlcmac_init_global_param();
|
|
|
|
LOG_D(MAC, "[MAIN] ALL INIT OK\n");
|
|
|
|
|
|
return (1);
|
|
}
|