enb_app.c 13.9 KB
Newer Older
winckel's avatar
winckel committed
1
2
/*******************************************************************************

3
4
 Eurecom OpenAirInterface
 Copyright(c) 1999 - 2012 Eurecom
winckel's avatar
winckel committed
5

6
7
8
 This program is free software; you can redistribute it and/or modify it
 under the terms and conditions of the GNU General Public License,
 version 2, as published by the Free Software Foundation.
winckel's avatar
winckel committed
9

10
11
12
13
 This program is distributed in the hope it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 more details.
winckel's avatar
winckel committed
14

15
16
17
 You should have received a copy of the GNU General Public License along with
 this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
winckel's avatar
winckel committed
18

19
20
 The full GNU General Public License is included in this distribution in
 the file called "COPYING".
winckel's avatar
winckel committed
21

22
23
24
25
26
27
 Contact Information
 Openair Admin: openair_admin@eurecom.fr
 Openair Tech : openair_tech@eurecom.fr
 Forums       : http://forums.eurecom.fr/openairinterface
 Address      : EURECOM, Campus SophiaTech, 450 Route des Chappes
 06410 Biot FRANCE
winckel's avatar
winckel committed
28

29
 *******************************************************************************/
winckel's avatar
winckel committed
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

#include <string.h>

#include "enb_app.h"
#include "assertions.h"

#include "log.h"
#if defined(OAI_EMU)
# include "OCG.h"
# include "OCG_extern.h"
#endif

#if defined(ENABLE_ITTI)
# include "intertask_interface.h"
# include "timer.h"
# if defined(ENABLE_USE_MME)
#   include "s1ap_eNB.h"
#   include "sctp_eNB_task.h"
# endif
49
50

extern unsigned char NB_eNB_INST;
winckel's avatar
winckel committed
51
52
53
54
#endif

#if defined(ENABLE_ITTI)

55
/*------------------------------------------------------------------------------*/
56
57
58
# if defined(ENABLE_USE_MME)
#   define ENB_REGISTER_RETRY_DELAY 10
# endif
winckel's avatar
winckel committed
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
99
100
typedef struct mme_ip_address_s {
    unsigned ipv4:1;
    unsigned ipv6:1;
    char *ipv4_address;
    char *ipv6_address;
} mme_ip_address_t;

typedef struct Enb_properties_s {
    /* Unique eNB_id to identify the eNB within EPC.
     * For macro eNB ids this field should be 20 bits long.
     * For home eNB ids this field should be 28 bits long.
     */
    uint32_t eNB_id;

    /* The type of the cell */
    enum cell_type_e cell_type;

    /* Optional name for the cell
     * NOTE: the name can be NULL (i.e no name) and will be cropped to 150
     * characters.
     */
    char *eNB_name;

    /* Tracking area code */
    uint16_t tac;

    /* Mobile Country Code
     * Mobile Network Code
     */
    uint16_t mcc;
    uint16_t mnc;

    /* Default Paging DRX of the eNB as defined in TS 36.304 */
    paging_drx_t default_drx;

    /* Nb of MME to connect to */
    uint8_t          nb_mme;
    /* List of MME to connect to */
    mme_ip_address_t mme_ip_address[S1AP_MAX_NB_MME_IP_ADDRESS];
} Enb_properties_t;

101
/*------------------------------------------------------------------------------*/
102
# if defined(ENABLE_USE_MME)
103
static uint32_t enb_nb = 1; /* Default number of eNB */
104
# endif
105
106
107
108
109
110
111
112
113

/* eNB 0 properties */
static Enb_properties_t enb_0_properties =
{
    347472,
    CELL_MACRO_ENB,
    "eNB_Eurecom_0",
    0,
    208,
114
    92,
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
    PAGING_DRX_256,
    1, /* There are 2 addresses defined, but use only one by default */
    {
        {
            1,
            0,
            "192.168.12.87",
            "2001:660:5502:12:30da:829a:2343:b6cf"
        },
        {
            1,
            0,
            "192.168.12.86",
            ""
        }
    }
};

/* eNB 1 properties */
static Enb_properties_t enb_1_properties =
{
    347473,
    CELL_MACRO_ENB,
    "eNB_Eurecom_1",
    0,
    208,
141
    92,
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
    PAGING_DRX_256,
    1, /* There are 2 addresses defined, but use only one by default */
    {
        {
            1,
            0,
            "192.168.12.87",
            "2001:660:5502:12:30da:829a:2343:b6cf"
        },
        {
            1,
            0,
            "192.168.12.88",
            ""
        }
    }
};

160
161
162
163
164
165
166
167
/* eNB 2 properties */
static Enb_properties_t enb_2_properties =
{
    347474,
    CELL_MACRO_ENB,
    "eNB_Eurecom_2",
    0,
    208,
168
    92,
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
    PAGING_DRX_256,
    1,
    {
        {
            1,
            0,
            "192.168.12.87",
            "2001:660:5502:12:30da:829a:2343:b6cf"
        },
    }
};

/* eNB 3 properties */
static Enb_properties_t enb_3_properties =
{
    347475,
    CELL_MACRO_ENB,
    "eNB_Eurecom_3",
    0,
    208,
189
    92,
190
191
192
193
194
195
196
197
198
199
200
201
    PAGING_DRX_256,
    1,
    {
        {
            1,
            0,
            "192.168.12.87",
            "2001:660:5502:12:30da:829a:2343:b6cf"
        },
    }
};

202
203
204
205
static Enb_properties_t *enb_properties[] =
{
    &enb_0_properties,
    &enb_1_properties,
206
207
    &enb_2_properties,
    &enb_3_properties,
208
};
209
210

/*------------------------------------------------------------------------------*/
winckel's avatar
winckel committed
211
static void configure_rrc(void)
winckel's avatar
winckel committed
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
{
    uint32_t eNB_id_start = 0;
    uint32_t eNB_id_end = 1;
    uint32_t eNB_id;
    MessageDef *msg_p;

#   if defined(OAI_EMU)
    eNB_id_start = oai_emulation.info.first_enb_local;
    eNB_id_end = oai_emulation.info.first_enb_local + oai_emulation.info.nb_enb_local;
#   endif

    for (eNB_id = eNB_id_start; (eNB_id < eNB_id_end) ; eNB_id++)
    {
        msg_p = itti_alloc_new_message (TASK_ENB_APP, RRC_CONFIGURATION_REQ);

        RRC_CONFIGURATION_REQ (msg_p).cell_identity =   enb_properties[eNB_id]->eNB_id;
        RRC_CONFIGURATION_REQ (msg_p).tac =             enb_properties[eNB_id]->tac;
        RRC_CONFIGURATION_REQ (msg_p).mcc =             enb_properties[eNB_id]->mcc;
        RRC_CONFIGURATION_REQ (msg_p).mnc =             enb_properties[eNB_id]->mnc;

        itti_send_msg_to_task (TASK_RRC_ENB, eNB_id, msg_p);
    }
}

236
# if defined(ENABLE_USE_MME)
winckel's avatar
winckel committed
237
238
static uint32_t eNB_app_register()
{
239
240
241
    uint32_t eNB_id_start = 0;
    uint32_t eNB_id_end = 1;
    uint32_t eNB_id;
242
    uint32_t mme_id;
243
244
245
246
247
248
    MessageDef *msg_p;
    uint32_t register_enb_pending = 0;

#   if defined(OAI_EMU)
    eNB_id_start = oai_emulation.info.first_enb_local;
    eNB_id_end = oai_emulation.info.first_enb_local + oai_emulation.info.nb_enb_local;
winckel's avatar
winckel committed
249

250
    DevCheck(eNB_id_end <= NUMBER_OF_eNB_MAX, eNB_id_end, NUMBER_OF_eNB_MAX, 0);
winckel's avatar
winckel committed
251
#   endif
252
    DevCheck(eNB_id_end <= (sizeof(enb_properties) / sizeof(enb_properties[0])), eNB_id_end, (sizeof(enb_properties) / sizeof(enb_properties[0])), 0);
253
254
255

    for (eNB_id = eNB_id_start; (eNB_id < eNB_id_end) ; eNB_id++)
    {
256
#   if defined(OAI_EMU)
257
        if (oai_emulation.info.cli_start_enb[eNB_id] == 1)
258
259
#   endif
        {
260
261
262
263
264
265
266
267
268
269
            s1ap_register_enb_req_t *s1ap_register_eNB;
            uint32_t hash;

            /* Overwrite default eNB ID */
            hash = s1ap_generate_eNB_id ();
            enb_properties[eNB_id]->eNB_id = eNB_id + (hash & 0xFFFF8);

            if (EPC_MODE_ENABLED)
            {
                /* Overwrite default IP v4 address by value from command line */
winckel's avatar
winckel committed
270
                enb_properties[eNB_id]->mme_ip_address[0].ipv4_address = EPC_MODE_MME_ADDRESS;
271
272
273
274
275
276
277
278
279
280
            }

            /* note:  there is an implicit relationship between the data structure and the message name */
            msg_p = itti_alloc_new_message (TASK_ENB_APP, S1AP_REGISTER_ENB_REQ);

            s1ap_register_eNB = &S1AP_REGISTER_ENB_REQ(msg_p);

            /* Some default/random parameters */
            s1ap_register_eNB->eNB_id = enb_properties[eNB_id]->eNB_id;
            s1ap_register_eNB->cell_type = enb_properties[eNB_id]->cell_type;
winckel's avatar
winckel committed
281
            s1ap_register_eNB->eNB_name = enb_properties[eNB_id]->eNB_name;
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
            s1ap_register_eNB->tac = enb_properties[eNB_id]->tac;
            s1ap_register_eNB->mcc = enb_properties[eNB_id]->mcc;
            s1ap_register_eNB->mnc = enb_properties[eNB_id]->mnc;
            s1ap_register_eNB->default_drx = enb_properties[eNB_id]->default_drx;

            s1ap_register_eNB->nb_mme = enb_properties[eNB_id]->nb_mme;
            DevCheck(s1ap_register_eNB->nb_mme <= S1AP_MAX_NB_MME_IP_ADDRESS, eNB_id, s1ap_register_eNB->nb_mme, S1AP_MAX_NB_MME_IP_ADDRESS);

            for (mme_id = 0; mme_id < s1ap_register_eNB->nb_mme; mme_id++)
            {
                s1ap_register_eNB->mme_ip_address[mme_id].ipv4 = enb_properties[eNB_id]->mme_ip_address[mme_id].ipv4;
                s1ap_register_eNB->mme_ip_address[mme_id].ipv6 = enb_properties[eNB_id]->mme_ip_address[mme_id].ipv6;
                strncpy (s1ap_register_eNB->mme_ip_address[mme_id].ipv4_address,
                         enb_properties[eNB_id]->mme_ip_address[mme_id].ipv4_address,
                         sizeof(s1ap_register_eNB->mme_ip_address[0].ipv4_address));
                strncpy (s1ap_register_eNB->mme_ip_address[mme_id].ipv6_address,
                         enb_properties[eNB_id]->mme_ip_address[mme_id].ipv6_address,
                         sizeof(s1ap_register_eNB->mme_ip_address[0].ipv6_address));
            }

            itti_send_msg_to_task (TASK_S1AP, eNB_id, msg_p);

            register_enb_pending++;
305
306
        }
    }
winckel's avatar
winckel committed
307

308
    return register_enb_pending;
winckel's avatar
winckel committed
309
310
311
312
}
# endif
#endif

313
314
315
/*------------------------------------------------------------------------------*/
void *eNB_app_task(void *args_p)
{
winckel's avatar
winckel committed
316
317
#if defined(ENABLE_ITTI)
# if defined(ENABLE_USE_MME)
318
319
320
321
322
323
    static uint32_t register_enb_pending;
    static uint32_t registered_enb;
    static long enb_register_retry_timer_id;
# endif
    MessageDef *msg_p;
    const char *msg_name;
324
325
326
    instance_t  instance;
    int         result;

327
328
    itti_mark_task_ready (TASK_ENB_APP);

329
330
# if defined(ENABLE_USE_MME)
#   if defined(OAI_EMU)
331
    enb_nb = oai_emulation.info.nb_enb_local;
332
#   endif
winckel's avatar
winckel committed
333
334
# endif

winckel's avatar
winckel committed
335
336
    configure_rrc();

winckel's avatar
winckel committed
337
# if defined(ENABLE_USE_MME)
338
339
340
    /* Try to register each eNB */
    registered_enb = 0;
    register_enb_pending = eNB_app_register ();
winckel's avatar
winckel committed
341
# else
342
343
344
    /* Start L2L1 task */
    msg_p = itti_alloc_new_message(TASK_ENB_APP, INITIALIZE_MESSAGE);
    itti_send_msg_to_task(TASK_L2L1, INSTANCE_DEFAULT, msg_p);
winckel's avatar
winckel committed
345
346
# endif

347
348
349
350
    do
    {
        // Wait for a message
        itti_receive_msg (TASK_ENB_APP, &msg_p);
winckel's avatar
winckel committed
351

352
353
        msg_name = ITTI_MSG_NAME (msg_p);
        instance = ITTI_MSG_INSTANCE (msg_p);
winckel's avatar
winckel committed
354

355
356
357
358
359
        switch (ITTI_MSG_ID(msg_p))
        {
            case TERMINATE_MESSAGE:
                itti_exit_task ();
                break;
winckel's avatar
winckel committed
360

361
            case MESSAGE_TEST:
362
                LOG_I(ENB_APP, "Received %s\n", ITTI_MSG_NAME(msg_p));
363
                break;
winckel's avatar
winckel committed
364
365

# if defined(ENABLE_USE_MME)
366
            case S1AP_REGISTER_ENB_CNF:
367
368
                LOG_I(ENB_APP, "[eNB %d] Received %s: associated MME %d\n", instance, msg_name,
                      S1AP_REGISTER_ENB_CNF(msg_p).nb_mme);
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388

                DevAssert(register_enb_pending > 0);
                register_enb_pending--;

                /* Check if at least eNB is registered with one MME */
                if (S1AP_REGISTER_ENB_CNF(msg_p).nb_mme > 0)
                {
                    registered_enb++;
                }

                /* Check if all register eNB requests have been processed */
                if (register_enb_pending == 0)
                {
                    if (registered_enb == enb_nb)
                    {
                        /* If all eNB are registered, start L2L1 task */
                        MessageDef *msg_init_p;

                        msg_init_p = itti_alloc_new_message (TASK_ENB_APP, INITIALIZE_MESSAGE);
                        itti_send_msg_to_task (TASK_L2L1, INSTANCE_DEFAULT, msg_init_p);
389
390
391
392
393
394
395
396
397
398

#   if defined(OAI_EMU)
                        /* If also inform all NAS UE tasks */
                        for (instance = NB_eNB_INST + oai_emulation.info.first_ue_local;
                            instance < (NB_eNB_INST + oai_emulation.info.first_ue_local + oai_emulation.info.nb_ue_local); instance ++)
                        {
                            msg_init_p = itti_alloc_new_message (TASK_ENB_APP, INITIALIZE_MESSAGE);
                            itti_send_msg_to_task (TASK_NAS_UE, instance, msg_init_p);
                        }
#   endif
399
400
401
402
403
                    }
                    else
                    {
                        uint32_t not_associated = enb_nb - registered_enb;

404
                        LOG_W(ENB_APP, " %d eNB %s not associated with a MME, retrying registration in %d seconds ...\n",
405
406
407
408
409
410
                              not_associated, not_associated > 1 ? "are" : "is", ENB_REGISTER_RETRY_DELAY);

                        /* Restart the eNB registration process in ENB_REGISTER_RETRY_DELAY seconds */
                        if (timer_setup (ENB_REGISTER_RETRY_DELAY, 0, TASK_ENB_APP, INSTANCE_DEFAULT, TIMER_ONE_SHOT,
                                         NULL, &enb_register_retry_timer_id) < 0)
                        {
411
                            LOG_E(ENB_APP, " Can not start eNB register retry timer, use \"sleep\" instead!\n");
412

413
                            sleep(ENB_REGISTER_RETRY_DELAY);
414
415
416
                            /* Restart the registration process */
                            registered_enb = 0;
                            register_enb_pending = eNB_app_register ();
417
418
419
420
421
                        }
                    }
                }
                break;

422
423
424
425
426
427
428
            case S1AP_DEREGISTERED_ENB_IND:
                LOG_W(ENB_APP, "[eNB %d] Received %s: associated MME %d\n", instance, msg_name,
                      S1AP_DEREGISTERED_ENB_IND(msg_p).nb_mme);

                /* TODO handle recovering of registration */
                break;

429
            case TIMER_HAS_EXPIRED:
430
                LOG_I(ENB_APP, " Received %s: timer_id %d\n", msg_name, TIMER_HAS_EXPIRED(msg_p).timer_id);
431
432
433
434
435
436
437
438

                if (TIMER_HAS_EXPIRED (msg_p).timer_id == enb_register_retry_timer_id)
                {
                    /* Restart the registration process */
                    registered_enb = 0;
                    register_enb_pending = eNB_app_register ();
                }
                break;
winckel's avatar
winckel committed
439
440
# endif

441
            default:
442
                LOG_E(ENB_APP, "Received unexpected message %s\n", msg_name);
443
444
                break;
        }
winckel's avatar
winckel committed
445

446
447
        result = itti_free (ITTI_MSG_ORIGIN_ID(msg_p), msg_p);
        AssertFatal (result == EXIT_SUCCESS, "Failed to free memory (%d)!\n", result);
448
    } while (1);
winckel's avatar
winckel committed
449
450
#endif

451
    return NULL;
winckel's avatar
winckel committed
452
}