main.c 7.19 KB
Newer Older
1 2 3 4 5
/*
 * 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
6
 * the OAI Public License, Version 1.1  (the "License"); you may not use this file
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
 * 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
 */

22
/*! \file main.c
23
 * \brief top init of Layer 2
24
 * \author  Navid Nikaein and Raymond Knopp
25
 * \date 2010 - 2014
26
 * \version 1.0
27 28
 * \email: navid.nikaein@eurecom.fr
 * @ingroup _mac
29

30
 */
31

32
#include <dlfcn.h>
33 34 35
#include "mac.h"
#include "mac_proto.h"
#include "mac_extern.h"
Lionel Gauthier's avatar
Lionel Gauthier committed
36
#include "assertions.h"
Lionel Gauthier's avatar
Lionel Gauthier committed
37
#include "LAYER2/PDCP_v10.1.0/pdcp.h"
38
#include "RRC/LTE/rrc_defs.h"
39
#include "common/utils/LOG/log.h"
40
#include "RRC/L2_INTERFACE/openair_rrc_L2_interface.h"
41
#include "common/ran_context.h"
42
#include "intertask_interface.h"
43 44 45

extern RAN_CONTEXT_t RC;

46
void init_UE_info(UE_info_t *UE_info)
47
{
48
  UE_info->num_UEs = 0;
49
  init_ue_list(&UE_info->list);
50 51 52 53 54
  memset(UE_info->DLSCH_pdu, 0, sizeof(UE_info->DLSCH_pdu));
  memset(UE_info->UE_template, 0, sizeof(UE_info->UE_template));
  memset(UE_info->eNB_UE_stats, 0, sizeof(UE_info->eNB_UE_stats));
  memset(UE_info->UE_sched_ctrl, 0, sizeof(UE_info->UE_sched_ctrl));
  memset(UE_info->active, 0, sizeof(UE_info->active));
55 56
}

57
void mac_top_init_eNB(void)
58
{
59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
  module_id_t i, j;
  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 = NULL;
    return;
  }

  mac = malloc16(RC.nb_macrlc_inst * sizeof(eNB_MAC_INST *));
  AssertFatal(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++) {
    mac[i] = malloc16(sizeof(eNB_MAC_INST));
    AssertFatal(mac[i] != 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, mac);
    bzero(mac[i], sizeof(eNB_MAC_INST));
    mac[i]->Mod_id = i;
    for (j = 0; j < MAX_NUM_CCs; j++) {
      mac[i]->DL_req[j].dl_config_request_body.dl_config_pdu_list =
          mac[i]->dl_config_pdu_list[j];
      mac[i]->UL_req[j].ul_config_request_body.ul_config_pdu_list =
          mac[i]->ul_config_pdu_list[j];
      for (int k = 0; k < 10; k++)
        mac[i]->UL_req_tmp[j][k].ul_config_request_body.ul_config_pdu_list =
            mac[i]->ul_config_pdu_list_tmp[j][k];
      for(int sf=0;sf<10;sf++)
        mac[i]->HI_DCI0_req[j][sf].hi_dci0_request_body.hi_dci0_pdu_list =
            mac[i]->hi_dci0_pdu_list[j][sf];
      mac[i]->TX_req[j].tx_request_body.tx_pdu_list = mac[i]->tx_request_pdu[j];
      mac[i]->ul_handle = 0;
99
    }
100

101
    mac[i]->if_inst = IF_Module_init(i);
102

103
    mac[i]->pre_processor_dl.algorithm = 0;
104
    mac[i]->pre_processor_dl.dl = dlsch_scheduler_pre_processor;
105 106 107
    char *s = "round_robin_dl";
    void *d = dlsym(NULL, s);
    AssertFatal(d, "%s(): no scheduler algo '%s' found\n", __func__, s);
108 109 110
    mac[i]->pre_processor_dl.dl_algo = *(default_sched_dl_algo_t *) d;
    mac[i]->pre_processor_dl.dl_algo.data = mac[i]->pre_processor_dl.dl_algo.setup();

111
    mac[i]->pre_processor_ul.algorithm = 0;
112
    mac[i]->pre_processor_ul.ul = ulsch_scheduler_pre_processor;
113 114 115
    s = "round_robin_ul";
    d = dlsym(NULL, s);
    AssertFatal(d, "%s(): no scheduler algo '%s' found\n", __func__, s);
116 117 118
    mac[i]->pre_processor_ul.ul_algo = *(default_sched_ul_algo_t *) d;
    mac[i]->pre_processor_ul.ul_algo.data = mac[i]->pre_processor_ul.ul_algo.setup();

119
    init_UE_info(&mac[i]->UE_info);
120 121 122 123
  }

  RC.mac = mac;

Cedric Roux's avatar
Cedric Roux committed
124
  AssertFatal(rlc_module_init(1) == 0,
125 126 127 128 129 130
      "Could not initialize RLC layer\n");

  // These should be out of here later
  pdcp_layer_init();

  rrc_init_global_param();
131
}
132

133 134
void mac_init_cell_params(int Mod_idP, int CC_idP)
{
135

136 137
    int j;
    UE_TEMPLATE *UE_template;
138

139
    LOG_D(MAC, "[MSC_NEW][FRAME 00000][MAC_eNB][MOD %02d][]\n", Mod_idP);
140
    //COMMON_channels_t *cc = &RC.mac[Mod_idP]->common_channels[CC_idP];
141

142 143
    memset(&RC.mac[Mod_idP]->eNB_stats, 0, sizeof(eNB_STATS));
    UE_template =
144
	(UE_TEMPLATE *) & RC.mac[Mod_idP]->UE_info.UE_template[CC_idP][0];
145

146
    for (j = 0; j < MAX_MOBILES_PER_ENB; j++) {
147 148
	UE_template[j].rnti = 0;
	// initiallize the eNB to UE statistics
149
	memset(&RC.mac[Mod_idP]->UE_info.eNB_UE_stats[CC_idP][j], 0,
150
	       sizeof(eNB_UE_STATS));
151 152 153 154 155 156
    }

}


int rlcmac_init_global_param(void)
157
{
158

159

160
    LOG_I(MAC, "[MAIN] CALLING RLC_MODULE_INIT...\n");
161

Cedric Roux's avatar
Cedric Roux committed
162
    if (rlc_module_init(1) != 0) {
163 164
	return (-1);
    }
165

166
    pdcp_layer_init();
167

168
    LOG_I(MAC, "[MAIN] Init Global Param Done\n");
169

170
    return 0;
171 172 173
}


174 175
void mac_top_cleanup(void)
{
176

177 178 179
    if (NB_UE_INST > 0) {
	free(UE_mac_inst);
    }
180

181 182 183
    if (RC.nb_macrlc_inst > 0) {
	free(RC.mac);
    }
184

185 186
}

187
int l2_init_eNB(void)
188
{
189 190 191



192
    LOG_I(MAC, "[MAIN] MAC_INIT_GLOBAL_PARAM IN...\n");
193

194
    rlcmac_init_global_param();
195

196
    LOG_D(MAC, "[MAIN] ALL INIT OK\n");
197 198


199
    return (1);
200
}
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243

//-----------------------------------------------------------------------------
/*
 * Main loop of MAC itti message handling
 */
void *mac_enb_task(void *arg)
//-----------------------------------------------------------------------------
{
  MessageDef *received_msg = NULL;
  int         result;

  itti_mark_task_ready(TASK_MAC_ENB); // void function 10/2019
  LOG_I(MAC,"Starting main loop of MAC message task\n");

  while (1) {
    itti_receive_msg(TASK_MAC_ENB, &received_msg);

    switch (ITTI_MSG_ID(received_msg)) {
      case RRC_MAC_DRX_CONFIG_REQ:
        LOG_I(MAC, "MAC Task Received RRC_MAC_DRX_CONFIG_REQ\n");
        /* Set timers and thresholds values in local MAC context of UE */
        eNB_Config_Local_DRX(ITTI_MESSAGE_GET_INSTANCE(received_msg), &received_msg->ittiMsg.rrc_mac_drx_config_req);
        break;

      case TERMINATE_MESSAGE:
        LOG_W(MAC, " *** Exiting MAC thread\n");
        itti_exit_task();
        break;

      default:
        LOG_E(MAC, "MAC instance received unhandled message: %d:%s\n",
              ITTI_MSG_ID(received_msg), 
              ITTI_MSG_NAME(received_msg));
        break;  
    } // end switch

    result = itti_free(ITTI_MSG_ORIGIN_ID(received_msg), received_msg);
    AssertFatal(result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
    
    received_msg = NULL;
  } // end while

  return NULL;
244
}