rlc.c 26.4 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
Cedric Roux's avatar
Cedric Roux committed
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
 */

gauthier's avatar
gauthier committed
22 23 24 25 26 27 28
/*
                                rlc.c
                             -------------------
  AUTHOR  : Lionel GAUTHIER
  COMPANY : EURECOM
  EMAIL   : Lionel.Gauthier at eurecom dot fr
*/
29 30 31
#define RLC_C
#include "rlc.h"
#include "mem_block.h"
32
#include "../MAC/mac_extern.h"
Thomas Laurent's avatar
Thomas Laurent committed
33
#include "LAYER2/RLC/UM_v9.3.0/rlc_um.h"
34
#include "common/utils/LOG/log.h"
gauthier's avatar
gauthier committed
35
#include "UTIL/OCG/OCG_vars.h"
36
#include "common/utils/LOG/vcd_signal_dumper.h"
37 38 39

#include "assertions.h"

40
extern boolean_t pdcp_data_ind(
41 42 43 44 45 46
  const protocol_ctxt_t* const ctxt_pP,
  const srb_flag_t srb_flagP,
  const MBMS_flag_t MBMS_flagP,
  const rb_id_t rb_idP,
  const sdu_size_t sdu_buffer_sizeP,
  mem_block_t* const sdu_buffer_pP);
47

48
#define DEBUG_RLC_PDCP_INTERFACE 1
49
//#define TRACE_RLC_PAYLOAD 1
gauthier's avatar
gauthier committed
50
#define DEBUG_RLC_DATA_REQ 1
51 52

//-----------------------------------------------------------------------------
53
void rlc_util_print_hex_octets(comp_name_t componentP, unsigned char* dataP, const signed long sizeP)
54 55 56 57 58 59 60 61 62
//-----------------------------------------------------------------------------
{
  unsigned long octet_index = 0;

  if (dataP == NULL) {
    return;
  }


63 64 65 66 67


  LOG_T(componentP, "+-----+-------------------------------------------------+\n");
  LOG_T(componentP, "|     |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |\n");
  LOG_T(componentP, "+-----+-------------------------------------------------+\n");
68

69
  for (octet_index = 0; octet_index < sizeP; octet_index++) {
70
    if ((octet_index % 16) == 0) {
71
      if (octet_index != 0) {
72
        LOG_T(componentP, " |\n");
73
      }
74

Cedric Roux's avatar
Cedric Roux committed
75
      LOG_T(componentP, " %04lu |", octet_index);
76
    }
77

78 79 80 81 82 83 84 85 86 87 88 89 90
    /*
     * Print every single octet in hexadecimal form
     */
    LOG_T(componentP, " %02x", dataP[octet_index]);
    /*
     * Align newline and pipes according to the octets in groups of 2
     */
  }

  /*
   * Append enough spaces and put final pipe
   */
  unsigned char index;
91

92
  for (index = octet_index; index < 16; ++index) {
93
    LOG_T(componentP, "   ");
94
  }
95

96 97
  LOG_T(componentP, " |\n");
}
98

99
//-----------------------------------------------------------------------------
gauthier's avatar
gauthier committed
100
rlc_op_status_t rlc_stat_req     (
101
  const protocol_ctxt_t* const ctxt_pP,
102 103
  const srb_flag_t    srb_flagP,
  const rb_id_t       rb_idP,
104
  unsigned int* stat_rlc_mode,
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
  unsigned int* stat_tx_pdcp_sdu,
  unsigned int* stat_tx_pdcp_bytes,
  unsigned int* stat_tx_pdcp_sdu_discarded,
  unsigned int* stat_tx_pdcp_bytes_discarded,
  unsigned int* stat_tx_data_pdu,
  unsigned int* stat_tx_data_bytes,
  unsigned int* stat_tx_retransmit_pdu_by_status,
  unsigned int* stat_tx_retransmit_bytes_by_status,
  unsigned int* stat_tx_retransmit_pdu,
  unsigned int* stat_tx_retransmit_bytes,
  unsigned int* stat_tx_control_pdu,
  unsigned int* stat_tx_control_bytes,
  unsigned int* stat_rx_pdcp_sdu,
  unsigned int* stat_rx_pdcp_bytes,
  unsigned int* stat_rx_data_pdus_duplicate,
  unsigned int* stat_rx_data_bytes_duplicate,
  unsigned int* stat_rx_data_pdu,
  unsigned int* stat_rx_data_bytes,
  unsigned int* stat_rx_data_pdu_dropped,
  unsigned int* stat_rx_data_bytes_dropped,
  unsigned int* stat_rx_data_pdu_out_of_window,
  unsigned int* stat_rx_data_bytes_out_of_window,
  unsigned int* stat_rx_control_pdu,
  unsigned int* stat_rx_control_bytes,
  unsigned int* stat_timer_reordering_timed_out,
  unsigned int* stat_timer_poll_retransmit_timed_out,
  unsigned int* stat_timer_status_prohibit_timed_out)
{
  //-----------------------------------------------------------------------------
  rlc_mode_t             rlc_mode        = RLC_MODE_NONE;
  rlc_union_t           *rlc_union_p     = NULL;
136
  hash_key_t             key             = HASHTABLE_NOT_A_KEY_VALUE;
137
  hashtable_rc_t         h_rc;
gauthier's avatar
gauthier committed
138

teramoto.genki's avatar
teramoto.genki committed
139 140 141 142 143 144
  //AssertFatal (rb_idP < NB_RB_MAX, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MAX);
	if(rb_idP >= NB_RB_MAX){
		LOG_E(RLC, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MAX);
		return RLC_OP_STATUS_BAD_PARAMETER;
	}
	
145
  key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
146 147 148 149 150
  h_rc = hashtable_get(rlc_coll_p, key, (void**)&rlc_union_p);

  if (h_rc == HASH_TABLE_OK) {
    rlc_mode = rlc_union_p->mode;
  }
151
  *stat_rlc_mode                     = rlc_mode;
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
  switch (rlc_mode) {
  case RLC_MODE_NONE:
    *stat_tx_pdcp_sdu                     = 0;
    *stat_tx_pdcp_bytes                   = 0;
    *stat_tx_pdcp_sdu_discarded           = 0;
    *stat_tx_pdcp_bytes_discarded         = 0;
    *stat_tx_data_pdu                     = 0;
    *stat_tx_data_bytes                   = 0;
    *stat_tx_retransmit_pdu_by_status     = 0;
    *stat_tx_retransmit_bytes_by_status   = 0;
    *stat_tx_retransmit_pdu               = 0;
    *stat_tx_retransmit_bytes             = 0;
    *stat_tx_control_pdu                  = 0;
    *stat_tx_control_bytes                = 0;
    *stat_rx_pdcp_sdu                     = 0;
    *stat_rx_pdcp_bytes                   = 0;
    *stat_rx_data_pdus_duplicate          = 0;
    *stat_rx_data_bytes_duplicate         = 0;
    *stat_rx_data_pdu                     = 0;
    *stat_rx_data_bytes                   = 0;
    *stat_rx_data_pdu_dropped             = 0;
    *stat_rx_data_bytes_dropped           = 0;
    *stat_rx_data_pdu_out_of_window       = 0;
    *stat_rx_data_bytes_out_of_window     = 0;
    *stat_rx_control_pdu                  = 0;
    *stat_rx_control_bytes                = 0;
    *stat_timer_reordering_timed_out      = 0;
    *stat_timer_poll_retransmit_timed_out = 0;
    *stat_timer_status_prohibit_timed_out = 0;
    return RLC_OP_STATUS_BAD_PARAMETER;
    break;

  case RLC_MODE_AM:
185
    rlc_am_stat_req(ctxt_pP,
186 187 188 189 190 191 192 193 194 195 196 197 198 199 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
                    &rlc_union_p->rlc.am,
                    stat_tx_pdcp_sdu,
                    stat_tx_pdcp_bytes,
                    stat_tx_pdcp_sdu_discarded,
                    stat_tx_pdcp_bytes_discarded,
                    stat_tx_data_pdu,
                    stat_tx_data_bytes,
                    stat_tx_retransmit_pdu_by_status,
                    stat_tx_retransmit_bytes_by_status,
                    stat_tx_retransmit_pdu,
                    stat_tx_retransmit_bytes,
                    stat_tx_control_pdu,
                    stat_tx_control_bytes,
                    stat_rx_pdcp_sdu,
                    stat_rx_pdcp_bytes,
                    stat_rx_data_pdus_duplicate,
                    stat_rx_data_bytes_duplicate,
                    stat_rx_data_pdu,
                    stat_rx_data_bytes,
                    stat_rx_data_pdu_dropped,
                    stat_rx_data_bytes_dropped,
                    stat_rx_data_pdu_out_of_window,
                    stat_rx_data_bytes_out_of_window,
                    stat_rx_control_pdu,
                    stat_rx_control_bytes,
                    stat_timer_reordering_timed_out,
                    stat_timer_poll_retransmit_timed_out,
                    stat_timer_status_prohibit_timed_out);
    return RLC_OP_STATUS_OK;
    break;

  case RLC_MODE_UM:
    *stat_tx_retransmit_pdu_by_status     = 0;
    *stat_tx_retransmit_bytes_by_status   = 0;
    *stat_tx_retransmit_pdu               = 0;
    *stat_tx_retransmit_bytes             = 0;
    *stat_tx_control_pdu                  = 0;
    *stat_tx_control_bytes                = 0;
    *stat_rx_data_pdu_dropped             = 0;
    *stat_rx_data_bytes_dropped           = 0;
    *stat_rx_data_pdu_out_of_window       = 0;
    *stat_rx_data_bytes_out_of_window     = 0;
    *stat_timer_poll_retransmit_timed_out = 0;
    *stat_timer_status_prohibit_timed_out = 0;
Thomas Laurent's avatar
Thomas Laurent committed
230
    rlc_um_stat_req (&rlc_union_p->rlc.um,
231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
                     stat_tx_pdcp_sdu,
                     stat_tx_pdcp_bytes,
                     stat_tx_pdcp_sdu_discarded,
                     stat_tx_pdcp_bytes_discarded,
                     stat_tx_data_pdu,
                     stat_tx_data_bytes,
                     stat_rx_pdcp_sdu,
                     stat_rx_pdcp_bytes,
                     stat_rx_data_pdus_duplicate,
                     stat_rx_data_bytes_duplicate,
                     stat_rx_data_pdu,
                     stat_rx_data_bytes,
                     stat_rx_data_pdu_dropped,
                     stat_rx_data_bytes_dropped,
                     stat_rx_data_pdu_out_of_window,
                     stat_rx_data_bytes_out_of_window,
                     stat_timer_reordering_timed_out);
    return RLC_OP_STATUS_OK;
    break;

  case RLC_MODE_TM:
    *stat_tx_pdcp_sdu                     = 0;
    *stat_tx_pdcp_bytes                   = 0;
    *stat_tx_pdcp_sdu_discarded           = 0;
    *stat_tx_pdcp_bytes_discarded         = 0;
    *stat_tx_data_pdu                     = 0;
    *stat_tx_data_bytes                   = 0;
    *stat_tx_retransmit_pdu_by_status     = 0;
    *stat_tx_retransmit_bytes_by_status   = 0;
    *stat_tx_retransmit_pdu               = 0;
    *stat_tx_retransmit_bytes             = 0;
    *stat_tx_control_pdu                  = 0;
    *stat_tx_control_bytes                = 0;
    *stat_rx_pdcp_sdu                     = 0;
    *stat_rx_pdcp_bytes                   = 0;
    *stat_rx_data_pdus_duplicate          = 0;
    *stat_rx_data_bytes_duplicate         = 0;
    *stat_rx_data_pdu                     = 0;
    *stat_rx_data_bytes                   = 0;
    *stat_rx_data_pdu_dropped             = 0;
    *stat_rx_data_bytes_dropped           = 0;
    *stat_rx_data_pdu_out_of_window       = 0;
    *stat_rx_data_bytes_out_of_window     = 0;
    *stat_rx_control_pdu                  = 0;
    *stat_rx_control_bytes                = 0;
    *stat_timer_reordering_timed_out      = 0;
    *stat_timer_poll_retransmit_timed_out = 0;
    *stat_timer_status_prohibit_timed_out = 0;
    return RLC_OP_STATUS_BAD_PARAMETER;
    break;

  default:
    *stat_tx_pdcp_sdu                     = 0;
    *stat_tx_pdcp_bytes                   = 0;
    *stat_tx_pdcp_sdu_discarded           = 0;
    *stat_tx_pdcp_bytes_discarded         = 0;
    *stat_tx_data_pdu                     = 0;
    *stat_tx_data_bytes                   = 0;
    *stat_tx_retransmit_pdu_by_status     = 0;
    *stat_tx_retransmit_bytes_by_status   = 0;
    *stat_tx_retransmit_pdu               = 0;
    *stat_tx_retransmit_bytes             = 0;
    *stat_tx_control_pdu                  = 0;
    *stat_tx_control_bytes                = 0;
    *stat_rx_pdcp_sdu                     = 0;
    *stat_rx_pdcp_bytes                   = 0;
    *stat_rx_data_pdus_duplicate          = 0;
    *stat_rx_data_bytes_duplicate         = 0;
    *stat_rx_data_pdu                     = 0;
    *stat_rx_data_bytes                   = 0;
    *stat_rx_data_pdu_dropped             = 0;
    *stat_rx_data_bytes_dropped           = 0;
    *stat_rx_data_pdu_out_of_window       = 0;
    *stat_rx_data_bytes_out_of_window     = 0;
    *stat_rx_control_pdu                  = 0;
    *stat_rx_control_bytes                = 0;

    *stat_timer_poll_retransmit_timed_out = 0;
    *stat_timer_status_prohibit_timed_out = 0;
    return RLC_OP_STATUS_BAD_PARAMETER;
  }
312
}
313

314
//-----------------------------------------------------------------------------
315
rlc_op_status_t rlc_data_req     (const protocol_ctxt_t* const ctxt_pP,
316 317 318 319
                                  const srb_flag_t   srb_flagP,
                                  const MBMS_flag_t  MBMS_flagP,
                                  const rb_id_t      rb_idP,
                                  const mui_t        muiP,
320 321
                                  confirm_t    confirmP,
                                  sdu_size_t   sdu_sizeP,
322
                                  mem_block_t *sdu_pP
323
#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
324 325 326 327
                                  ,const uint32_t * const sourceL2Id
                                  ,const uint32_t * const destinationL2Id
#endif
                                  )
328 329
{
  //-----------------------------------------------------------------------------
330
  mem_block_t           *new_sdu_p    = NULL;
gauthier's avatar
gauthier committed
331
  rlc_mode_t             rlc_mode     = RLC_MODE_NONE;
332
  rlc_union_t           *rlc_union_p = NULL;
333
  hash_key_t             key         = HASHTABLE_NOT_A_KEY_VALUE;
334 335
  hashtable_rc_t         h_rc;

336
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
337 338
  rlc_mbms_id_t         *mbms_id_p  = NULL;
  logical_chan_id_t      log_ch_id  = 0;
339 340
#endif
#ifdef DEBUG_RLC_DATA_REQ
Cedric Roux's avatar
typo  
Cedric Roux committed
341
  LOG_D(RLC,PROTOCOL_CTXT_FMT"rlc_data_req:  rb_id %u (MAX %d), muip %d, confirmP %d, sdu_sizeP %d, sdu_pP %p\n",
342
        PROTOCOL_CTXT_ARGS(ctxt_pP),
gauthier's avatar
gauthier committed
343 344 345 346 347 348
        rb_idP,
        NB_RAB_MAX,
        muiP,
        confirmP,
        sdu_sizeP,
        sdu_pP);
349
#endif
350
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
351
#else
gauthier's avatar
gauthier committed
352
  AssertFatal(MBMS_flagP == 0, "MBMS_flagP %u", MBMS_flagP);
353
#endif
354

Cedric Roux's avatar
Cedric Roux committed
355 356 357 358 359
#if T_TRACER
  if (ctxt_pP->enb_flag)
    T(T_ENB_RLC_DL, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->rnti), T_INT(rb_idP), T_INT(sdu_sizeP));
#endif

360
  if (MBMS_flagP) {
teramoto.genki's avatar
teramoto.genki committed
361 362 363 364 365
    //AssertFatal (rb_idP < NB_RB_MBMS_MAX, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MBMS_MAX);
  	if(rb_idP >= NB_RB_MBMS_MAX){
  		LOG_E(RLC, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MBMS_MAX);
  		return RLC_OP_STATUS_BAD_PARAMETER;
  	}
366
  } else {
teramoto.genki's avatar
teramoto.genki committed
367 368 369 370 371
    //AssertFatal (rb_idP < NB_RB_MAX, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MAX);
  	if(rb_idP >= NB_RB_MAX){
  		LOG_E(RLC, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MAX);
  		return RLC_OP_STATUS_BAD_PARAMETER;
  	}
372
  }
373

teramoto.genki's avatar
teramoto.genki committed
374 375 376 377 378 379
  //DevAssert(sdu_pP != NULL);
	if(sdu_pP == NULL){
		LOG_E(RLC, "sdu_pP == NULL\n");
		return RLC_OP_STATUS_BAD_PARAMETER;
	}
	
Haruki Naoi's avatar
Haruki Naoi committed
380 381
  //DevCheck(sdu_sizeP > 0, sdu_sizeP, 0, 0);
  if(sdu_sizeP <= 0) {
382
    LOG_E(RLC, "sdu_sizeP %d, file %s, line %d\n", sdu_sizeP, __FILE__ ,__LINE__);
Haruki Naoi's avatar
Haruki Naoi committed
383 384
    return RLC_OP_STATUS_BAD_PARAMETER;
  }
385

386
#if (LTE_RRC_VERSION < MAKE_VERSION(10, 0, 0))
387 388 389
  DevCheck(MBMS_flagP == 0, MBMS_flagP, 0, 0);
#endif

gauthier's avatar
gauthier committed
390
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_IN);
391

392
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
393

394
  if (MBMS_flagP == TRUE) {
395 396 397
    if (ctxt_pP->enb_flag) {
      log_ch_id = rlc_mbms_enb_get_lcid_by_rb_id(ctxt_pP->module_id,rb_idP);
      mbms_id_p = &rlc_mbms_lcid2service_session_id_eNB[ctxt_pP->module_id][log_ch_id];
398
    } else {
399 400
      log_ch_id = rlc_mbms_ue_get_lcid_by_rb_id(ctxt_pP->rnti,rb_idP);
      mbms_id_p = &rlc_mbms_lcid2service_session_id_ue[ctxt_pP->rnti][log_ch_id];
401 402
    }

403
    key = RLC_COLL_KEY_MBMS_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, mbms_id_p->service_id, mbms_id_p->session_id);
404 405 406 407
  }
  if (sourceL2Id && destinationL2Id){
     key = RLC_COLL_KEY_SOURCE_DEST_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, *sourceL2Id, *destinationL2Id, srb_flagP);
     //key_lcid = RLC_COLL_KEY_LCID_SOURCE_DEST_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, chan_idP, *sourceL2Id, *destinationL2Id, srb_flagP);
408 409 410
  } else
#endif
  {
411
    key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
412 413 414
  }

  h_rc = hashtable_get(rlc_coll_p, key, (void**)&rlc_union_p);
415

416
  if (h_rc == HASH_TABLE_OK) {
417
    rlc_mode = rlc_union_p->mode;
418
  } else {
419
    rlc_mode = RLC_MODE_NONE;
teramoto.genki's avatar
teramoto.genki committed
420
    //AssertFatal (0 , "RLC not configured key %ju\n", key);
421
  	LOG_E(RLC, "not configured key %lu\n", key);
teramoto.genki's avatar
teramoto.genki committed
422
  	return RLC_OP_STATUS_OUT_OF_RESSOURCES;
gauthier's avatar
gauthier committed
423 424
  }

425
  if (MBMS_flagP == 0) {
426 427
    LOG_D(RLC, PROTOCOL_CTXT_FMT"[RB %u] Display of rlc_data_req:\n",
          PROTOCOL_CTXT_ARGS(ctxt_pP),
gauthier's avatar
gauthier committed
428
          rb_idP);
429
#if defined(TRACE_RLC_PAYLOAD)
430
    rlc_util_print_hex_octets(RLC, (unsigned char*)sdu_pP->data, sdu_sizeP);
431
#endif
432 433

#ifdef DEBUG_RLC_DATA_REQ
Cedric Roux's avatar
typo  
Cedric Roux committed
434
    LOG_D(RLC,"RLC_TYPE : %d\n", rlc_mode);
435
#endif
436 437 438

    switch (rlc_mode) {
    case RLC_MODE_NONE:
439
      free_mem_block(sdu_pP, __func__);
440 441
      LOG_E(RLC, PROTOCOL_CTXT_FMT" Received RLC_MODE_NONE as rlc_type for rb_id %u\n",
            PROTOCOL_CTXT_ARGS(ctxt_pP),
442
            rb_idP);
gauthier's avatar
gauthier committed
443
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
444 445 446
      return RLC_OP_STATUS_BAD_PARAMETER;

    case RLC_MODE_AM:
447
#ifdef DEBUG_RLC_DATA_REQ
448
      LOG_D(RLC,"RLC_MODE_AM\n");
449
#endif
450
      new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_am_data_req_alloc), __func__);
451 452 453 454 455 456 457 458 459 460

      if (new_sdu_p != NULL) {
        // PROCESS OF COMPRESSION HERE:
        memset (new_sdu_p->data, 0, sizeof (struct rlc_am_data_req_alloc));
        memcpy (&new_sdu_p->data[sizeof (struct rlc_am_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP);

        ((struct rlc_am_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP;
        ((struct rlc_am_data_req *) (new_sdu_p->data))->conf = confirmP;
        ((struct rlc_am_data_req *) (new_sdu_p->data))->mui  = muiP;
        ((struct rlc_am_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_am_data_req_alloc);
461
        free_mem_block(sdu_pP, __func__);
462
        rlc_am_data_req(ctxt_pP, &rlc_union_p->rlc.am, new_sdu_p);
gauthier's avatar
gauthier committed
463
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
464 465
        return RLC_OP_STATUS_OK;
      } else {
gauthier's avatar
gauthier committed
466
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
467
        free_mem_block(sdu_pP, __func__);
468 469 470 471 472 473
        return RLC_OP_STATUS_INTERNAL_ERROR;
      }

      break;

    case RLC_MODE_UM:
474 475 476 477 478 479 480 481 482
      /* TODO: this is a hack, needs better solution. Let's not use too
       * much memory and store at maximum 5 millions bytes.
       */
      /* look for HACK_RLC_UM_LIMIT for others places related to the hack. Please do not remove this comment. */
      if (rlc_um_get_buffer_occupancy(&rlc_union_p->rlc.um) > 5000000) {
        free_mem_block(sdu_pP, __func__);
        return RLC_OP_STATUS_OUT_OF_RESSOURCES;
      }

483
      new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_um_data_req_alloc), __func__);
484 485 486 487 488 489 490 491

      if (new_sdu_p != NULL) {
        // PROCESS OF COMPRESSION HERE:
        memset (new_sdu_p->data, 0, sizeof (struct rlc_um_data_req_alloc));
        memcpy (&new_sdu_p->data[sizeof (struct rlc_um_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP);

        ((struct rlc_um_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP;
        ((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc);
492
        free_mem_block(sdu_pP, __func__);
493

494
        rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p);
495

496
        //free_mem_block(new_sdu, __func__);
gauthier's avatar
gauthier committed
497
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
498 499
        return RLC_OP_STATUS_OK;
      } else {
gauthier's avatar
gauthier committed
500
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
501
        free_mem_block(sdu_pP, __func__);
502 503
        return RLC_OP_STATUS_INTERNAL_ERROR;
      }
gauthier's avatar
gauthier committed
504

505 506 507
      break;

    case RLC_MODE_TM:
508
      new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_tm_data_req_alloc), __func__);
509 510 511 512 513 514 515 516

      if (new_sdu_p != NULL) {
        // PROCESS OF COMPRESSION HERE:
        memset (new_sdu_p->data, 0, sizeof (struct rlc_tm_data_req_alloc));
        memcpy (&new_sdu_p->data[sizeof (struct rlc_tm_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP);

        ((struct rlc_tm_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP;
        ((struct rlc_tm_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_tm_data_req_alloc);
517
        free_mem_block(sdu_pP, __func__);
518
        rlc_tm_data_req(ctxt_pP, &rlc_union_p->rlc.tm, new_sdu_p);
gauthier's avatar
gauthier committed
519
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
520 521 522
        return RLC_OP_STATUS_OK;
      } else {
        //handle_event(ERROR,"FILE %s FONCTION rlc_data_req() LINE %s : out of memory\n", __FILE__, __LINE__);
gauthier's avatar
gauthier committed
523
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
524
        free_mem_block(sdu_pP, __func__);
525
        return RLC_OP_STATUS_INTERNAL_ERROR;
gauthier's avatar
gauthier committed
526
      }
527

528 529 530
      break;

    default:
531
      free_mem_block(sdu_pP, __func__);
gauthier's avatar
gauthier committed
532
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
533 534 535 536
      return RLC_OP_STATUS_INTERNAL_ERROR;

    }

537
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
538
  } else { /* MBMS_flag != 0 */
539 540 541 542
    //  LOG_I(RLC,"DUY rlc_data_req: mbms_rb_id in RLC instant is: %d\n", mbms_rb_id);
    if (sdu_pP != NULL) {
      if (sdu_sizeP > 0) {
        LOG_I(RLC,"received a packet with size %d for MBMS \n", sdu_sizeP);
543
        new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_um_data_req_alloc), __func__);
544 545 546 547 548 549 550

        if (new_sdu_p != NULL) {
          // PROCESS OF COMPRESSION HERE:
          memset (new_sdu_p->data, 0, sizeof (struct rlc_um_data_req_alloc));
          memcpy (&new_sdu_p->data[sizeof (struct rlc_um_data_req_alloc)], &sdu_pP->data[0], sdu_sizeP);
          ((struct rlc_um_data_req *) (new_sdu_p->data))->data_size = sdu_sizeP;
          ((struct rlc_um_data_req *) (new_sdu_p->data))->data_offset = sizeof (struct rlc_um_data_req_alloc);
551
          free_mem_block(sdu_pP, __func__);
552
          rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p);
553

554
          //free_mem_block(new_sdu, __func__);
gauthier's avatar
gauthier committed
555
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
556 557
          return RLC_OP_STATUS_OK;
        } else {
gauthier's avatar
gauthier committed
558
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
559
          free_mem_block(sdu_pP, __func__);
560 561 562
          return RLC_OP_STATUS_BAD_PARAMETER;
        }
      } else {
gauthier's avatar
gauthier committed
563
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
564 565 566
        return RLC_OP_STATUS_BAD_PARAMETER;
      }
    } else {
gauthier's avatar
gauthier committed
567
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
568 569
      return RLC_OP_STATUS_BAD_PARAMETER;
    }
570
  }
571

572
#else
573 574 575
  }
  else  /* MBMS_flag != 0 */
  {
576
    free_mem_block(sdu_pP, __func__);
Cedric Roux's avatar
Cedric Roux committed
577
    LOG_E(RLC, "MBMS_flag != 0 while Rel10/Rel14 is not defined...\n");
578
    //handle_event(ERROR,"FILE %s FONCTION rlc_data_req() LINE %s : parameter module_id out of bounds :%d\n", __FILE__, __LINE__, module_idP);
gauthier's avatar
gauthier committed
579
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
580
    return RLC_OP_STATUS_BAD_PARAMETER;
581
  }
582

583
#endif
584 585 586
}

//-----------------------------------------------------------------------------
587
void rlc_data_ind     (
588
  const protocol_ctxt_t* const ctxt_pP,
589 590 591 592 593 594 595
  const srb_flag_t  srb_flagP,
  const MBMS_flag_t MBMS_flagP,
  const rb_id_t     rb_idP,
  const sdu_size_t  sdu_sizeP,
  mem_block_t      *sdu_pP)
{
  //-----------------------------------------------------------------------------
gauthier's avatar
gauthier committed
596 597


598 599 600
#if defined(TRACE_RLC_PAYLOAD)
  LOG_D(RLC, PROTOCOL_CTXT_FMT"[%s %u] Display of rlc_data_ind: size %u\n",
        PROTOCOL_CTXT_ARGS(ctxt_pP),
601
        (srb_flagP) ? "SRB" : "DRB",
gauthier's avatar
gauthier committed
602 603 604 605
        rb_idP,
        sdu_sizeP);

  rlc_util_print_hex_octets(RLC, (unsigned char*)sdu_pP->data, sdu_sizeP);
606
#endif
607

Cedric Roux's avatar
Cedric Roux committed
608 609 610 611 612 613
#if T_TRACER
  if (ctxt_pP->enb_flag)
    T(T_ENB_RLC_UL, T_INT(ctxt_pP->module_id), T_INT(ctxt_pP->rnti), T_INT(rb_idP), T_INT(sdu_sizeP));
#endif


614
  pdcp_data_ind (
615
    ctxt_pP,
616 617 618 619 620
    srb_flagP,
    MBMS_flagP,
    rb_idP,
    sdu_sizeP,
    sdu_pP);
621 622
}
//-----------------------------------------------------------------------------
623
void rlc_data_conf     (const protocol_ctxt_t* const ctxt_pP,
624 625 626
                        const srb_flag_t      srb_flagP,
                        const rb_id_t         rb_idP,
                        const mui_t           muiP,
627 628 629 630 631 632
                        const rlc_tx_status_t statusP)
{
  //-----------------------------------------------------------------------------

  if (srb_flagP) {
    if (rlc_rrc_data_conf != NULL) {
633
      rlc_rrc_data_conf (ctxt_pP, rb_idP , muiP, statusP);
634
    }
635
  }
636 637 638
}
//-----------------------------------------------------------------------------
int
639
rlc_module_init (void)
640
{
641 642 643
  //-----------------------------------------------------------------------------
  int          k;
  module_id_t  module_id1;
gauthier's avatar
gauthier committed
644

Cedric Roux's avatar
Cedric Roux committed
645 646 647
  /* for no gcc warnings */
  (void)k;

648 649 650
  LOG_D(RLC, "MODULE INIT\n");
  rlc_rrc_data_ind  = NULL;
  rlc_rrc_data_conf = NULL;
gauthier's avatar
gauthier committed
651

652
  rlc_coll_p = hashtable_create ((LTE_maxDRB + 2) * 16, NULL, rb_free_rlc_union);
Haruki Naoi's avatar
Haruki Naoi committed
653 654 655 656 657
  //AssertFatal(rlc_coll_p != NULL, "UNRECOVERABLE error, RLC hashtable_create failed");
  if(rlc_coll_p == NULL) {
    LOG_E(RLC, "UNRECOVERABLE error, RLC hashtable_create failed\n");
    return -1;
  }
gauthier's avatar
gauthier committed
658

knopp's avatar
knopp committed
659
  for (module_id1=0; module_id1 < MAX_MOBILES_PER_ENB; module_id1++) {
660
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
661 662 663 664 665 666 667

    for (k=0; k < RLC_MAX_MBMS_LC; k++) {
      rlc_mbms_lcid2service_session_id_ue[module_id1][k].service_id = 0;
      rlc_mbms_lcid2service_session_id_ue[module_id1][k].session_id = 0;
    }

    for (k=0; k < NB_RB_MBMS_MAX; k++) {
668
      rlc_mbms_rbid2lcid_ue[module_id1][k] = RLC_LC_UNALLOCATED;
669 670
    }

gauthier's avatar
gauthier committed
671
#endif
672
  }
gauthier's avatar
gauthier committed
673

674
  for (module_id1=0; module_id1 < NUMBER_OF_eNB_MAX; module_id1++) {
675
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
676 677 678 679 680 681 682

    for (k=0; k < RLC_MAX_MBMS_LC; k++) {
      rlc_mbms_lcid2service_session_id_eNB[module_id1][k].service_id = 0;
      rlc_mbms_lcid2service_session_id_eNB[module_id1][k].session_id = 0;
    }

    for (k=0; k < NB_RB_MBMS_MAX; k++) {
683
      rlc_mbms_rbid2lcid_eNB[module_id1][k] = RLC_LC_UNALLOCATED;
684 685
    }

gauthier's avatar
gauthier committed
686
#endif
687
  }
gauthier's avatar
gauthier committed
688

689
  pool_buffer_init();
690

691
  return(0);
692 693 694
}
//-----------------------------------------------------------------------------
void
695
rlc_module_cleanup (void)
696 697
//-----------------------------------------------------------------------------
{
698
  hashtable_destroy(rlc_coll_p);
699 700 701
}
//-----------------------------------------------------------------------------
void
702
rlc_layer_init (void)
703
{
704
  //-----------------------------------------------------------------------------
705 706 707
}
//-----------------------------------------------------------------------------
void
708
rlc_layer_cleanup (void)
709 710 711 712
//-----------------------------------------------------------------------------
{
}