rlc.c 27.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
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"
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
  const protocol_ctxt_t *const ctxt_pP,
42 43 44 45
  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,
46
  mem_block_t *const sdu_buffer_pP);
47

gauthier's avatar
gauthier committed
48
#define DEBUG_RLC_PDCP_INTERFACE 1
49
//#define TRACE_RLC_PAYLOAD 1
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
//-----------------------------------------------------------------------------
{
  unsigned long octet_index = 0;

  if (dataP == NULL) {
    return;
  }

62 63 64
  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");
65

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

Cedric Roux's avatar
Cedric Roux committed
72
      LOG_T(componentP, " %04lu |", octet_index);
73
    }
74

75 76 77 78 79 80 81 82 83 84 85 86 87
    /*
     * 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;
88

89
  for (index = octet_index; index < 16; ++index) {
90
    LOG_T(componentP, "   ");
91
  }
92

93 94
  LOG_T(componentP, " |\n");
}
95

96
//-----------------------------------------------------------------------------
97
rlc_op_status_t rlc_stat_req     (
98
  const protocol_ctxt_t *const ctxt_pP,
99 100
  const srb_flag_t    srb_flagP,
  const rb_id_t       rb_idP,
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
  unsigned int *stat_rlc_mode,
  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) {
129 130 131
  //-----------------------------------------------------------------------------
  rlc_mode_t             rlc_mode        = RLC_MODE_NONE;
  rlc_union_t           *rlc_union_p     = NULL;
132
  hash_key_t             key             = HASHTABLE_NOT_A_KEY_VALUE;
133
  hashtable_rc_t         h_rc;
134

135
  //AssertFatal (rb_idP < NB_RB_MAX, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MAX);
136 137 138 139 140
  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;
  }

141
  key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
142
  h_rc = hashtable_get(rlc_coll_p, key, (void **)&rlc_union_p);
143 144 145 146

  if (h_rc == HASH_TABLE_OK) {
    rlc_mode = rlc_union_p->mode;
  }
147

148
  *stat_rlc_mode                     = rlc_mode;
149

150
  switch (rlc_mode) {
151 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 185 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 230 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
    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:
      rlc_am_stat_req(ctxt_pP,
                      &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;
      rlc_um_stat_req (&rlc_union_p->rlc.um,
                       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;
308
  }
309
}
310

311
//-----------------------------------------------------------------------------
312
rlc_op_status_t rlc_data_req     (const protocol_ctxt_t *const ctxt_pP,
313 314 315 316
                                  const srb_flag_t   srb_flagP,
                                  const MBMS_flag_t  MBMS_flagP,
                                  const rb_id_t      rb_idP,
                                  const mui_t        muiP,
317 318
                                  confirm_t    confirmP,
                                  sdu_size_t   sdu_sizeP,
319
                                  mem_block_t *sdu_pP
320
#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
321 322
  ,const uint32_t *const sourceL2Id
  ,const uint32_t *const destinationL2Id
323
#endif
324
                                 ) {
325
  //-----------------------------------------------------------------------------
326
  mem_block_t           *new_sdu_p    = NULL;
gauthier's avatar
gauthier committed
327
  rlc_mode_t             rlc_mode     = RLC_MODE_NONE;
328
  rlc_union_t           *rlc_union_p = NULL;
329
  hash_key_t             key         = HASHTABLE_NOT_A_KEY_VALUE;
330
  hashtable_rc_t         h_rc;
331
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
332 333
  rlc_mbms_id_t         *mbms_id_p  = NULL;
  logical_chan_id_t      log_ch_id  = 0;
334 335
#endif
#ifdef DEBUG_RLC_DATA_REQ
Cedric Roux's avatar
Cedric Roux committed
336
  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",
337
        PROTOCOL_CTXT_ARGS(ctxt_pP),
338 339 340 341 342 343
        rb_idP,
        NB_RAB_MAX,
        muiP,
        confirmP,
        sdu_sizeP,
        sdu_pP);
344
#endif
345
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
346
#else
347
  AssertFatal(MBMS_flagP == 0, "MBMS_flagP %u", MBMS_flagP);
348
#endif
Cedric Roux's avatar
Cedric Roux committed
349
#if T_TRACER
350

Cedric Roux's avatar
Cedric Roux committed
351 352
  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));
353

Cedric Roux's avatar
Cedric Roux committed
354 355
#endif

356
  if (MBMS_flagP) {
357
    //AssertFatal (rb_idP < NB_RB_MBMS_MAX, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MBMS_MAX);
358 359 360 361
    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;
    }
362
  } else {
363
    //AssertFatal (rb_idP < NB_RB_MAX, "RB id is too high (%u/%d)!\n", rb_idP, NB_RB_MAX);
364 365 366 367
    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;
    }
368
  }
369

370
  //DevAssert(sdu_pP != NULL);
371 372 373 374 375
  if(sdu_pP == NULL) {
    LOG_E(RLC, "sdu_pP == NULL\n");
    return RLC_OP_STATUS_BAD_PARAMETER;
  }

376 377
  //DevCheck(sdu_sizeP > 0, sdu_sizeP, 0, 0);
  if(sdu_sizeP <= 0) {
378
    LOG_E(RLC, "sdu_sizeP %d, file %s, line %d\n", sdu_sizeP, __FILE__ ,__LINE__);
379 380
    return RLC_OP_STATUS_BAD_PARAMETER;
  }
381

382
#if (LTE_RRC_VERSION < MAKE_VERSION(10, 0, 0))
383 384
  DevCheck(MBMS_flagP == 0, MBMS_flagP, 0, 0);
#endif
gauthier's avatar
gauthier committed
385
  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_IN);
386
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
387

388
  if (MBMS_flagP == TRUE) {
389 390 391
    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];
392
    } else {
393 394
      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];
395 396
    }

397
    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);
398
  }
399

400 401 402 403 404 405 406
  if (sourceL2Id && destinationL2Id) {
    LOG_D (RLC, "RLC_COLL_KEY_VALUE: ctxt_pP->module_id: %d, ctxt_pP->rnti: %d, ctxt_pP->enb_flag: %d, rb_idP:%d, srb_flagP: %d \n \n", ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP,
           srb_flagP);
    key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
    //Thinh's line originally uncommented
    //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);
407 408 409
  } else
#endif
  {
410 411
    LOG_D (RLC, "RLC_COLL_KEY_VALUE: ctxt_pP->module_id: %d, ctxt_pP->rnti: %d, ctxt_pP->enb_flag: %d, rb_idP:%d, srb_flagP: %d \n \n", ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP,
           srb_flagP);
412
    key = RLC_COLL_KEY_VALUE(ctxt_pP->module_id, ctxt_pP->rnti, ctxt_pP->enb_flag, rb_idP, srb_flagP);
413 414
  }

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

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

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

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

446
      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 461 462 463 464 465 466 467 468
        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);
          free_mem_block(sdu_pP, __func__);
          rlc_am_data_req(ctxt_pP, &rlc_union_p->rlc.am, new_sdu_p);
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
          return RLC_OP_STATUS_OK;
        } else {
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
          free_mem_block(sdu_pP, __func__);
          return RLC_OP_STATUS_INTERNAL_ERROR;
        }
469

470
        break;
471

472
      case RLC_MODE_UM:
473

474 475 476 477 478 479 480 481
        /* 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;
        }
482

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 492 493 494 495 496 497 498 499 500
        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);
          free_mem_block(sdu_pP, __func__);
          rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p);
          //free_mem_block(new_sdu, __func__);
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
          return RLC_OP_STATUS_OK;
        } else {
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
          free_mem_block(sdu_pP, __func__);
          return RLC_OP_STATUS_INTERNAL_ERROR;
        }
501

502
        break;
503

504 505
      case RLC_MODE_TM:
        new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_tm_data_req_alloc), __func__);
506

507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
        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);
          free_mem_block(sdu_pP, __func__);
          rlc_tm_data_req(ctxt_pP, &rlc_union_p->rlc.tm, new_sdu_p);
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
          return RLC_OP_STATUS_OK;
        } else {
          //handle_event(ERROR,"FILE %s FONCTION rlc_data_req() LINE %s : out of memory\n", __FILE__, __LINE__);
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
          free_mem_block(sdu_pP, __func__);
          return RLC_OP_STATUS_INTERNAL_ERROR;
        }
523

524
        break;
525

526
      default:
527
        free_mem_block(sdu_pP, __func__);
gauthier's avatar
gauthier committed
528
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
529 530 531
        return RLC_OP_STATUS_INTERNAL_ERROR;
    }

532
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
533
  } else { /* MBMS_flag != 0 */
534 535 536 537
    //  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);
538
        new_sdu_p = get_free_mem_block (sdu_sizeP + sizeof (struct rlc_um_data_req_alloc), __func__);
539 540 541 542 543 544 545

        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);
546
          free_mem_block(sdu_pP, __func__);
547
          rlc_um_data_req(ctxt_pP, &rlc_union_p->rlc.um, new_sdu_p);
548
          //free_mem_block(new_sdu, __func__);
gauthier's avatar
gauthier committed
549
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
550 551
          return RLC_OP_STATUS_OK;
        } else {
gauthier's avatar
gauthier committed
552
          VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
553
          free_mem_block(sdu_pP, __func__);
554 555 556
          return RLC_OP_STATUS_BAD_PARAMETER;
        }
      } else {
gauthier's avatar
gauthier committed
557
        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
558 559 560
        return RLC_OP_STATUS_BAD_PARAMETER;
      }
    } else {
gauthier's avatar
gauthier committed
561
      VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
562 563
      return RLC_OP_STATUS_BAD_PARAMETER;
    }
564
  }
565

566
#else
567
  }
568
  else { /* MBMS_flag != 0 */
569
    free_mem_block(sdu_pP, __func__);
Cedric Roux's avatar
Cedric Roux committed
570
    LOG_E(RLC, "MBMS_flag != 0 while Rel10/Rel14 is not defined...\n");
571
    //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
572
    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_RLC_DATA_REQ,VCD_FUNCTION_OUT);
573
    return RLC_OP_STATUS_BAD_PARAMETER;
574
  }
575

576
#endif
577 578 579
}

//-----------------------------------------------------------------------------
580
void rlc_data_ind     (
581
  const protocol_ctxt_t *const ctxt_pP,
582 583 584 585
  const srb_flag_t  srb_flagP,
  const MBMS_flag_t MBMS_flagP,
  const rb_id_t     rb_idP,
  const sdu_size_t  sdu_sizeP,
586
  mem_block_t      *sdu_pP) {
587
  //-----------------------------------------------------------------------------
588 589 590
#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),
591
        (srb_flagP) ? "SRB" : "DRB",
592 593
        rb_idP,
        sdu_sizeP);
594
  rlc_util_print_hex_octets(RLC, (unsigned char *)sdu_pP->data, sdu_sizeP);
gauthier's avatar
gauthier committed
595
#endif
Cedric Roux's avatar
Cedric Roux committed
596
#if T_TRACER
597

Cedric Roux's avatar
Cedric Roux committed
598 599 600
  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));

601
#endif
602
  pdcp_data_ind (
603
    ctxt_pP,
604 605 606 607 608
    srb_flagP,
    MBMS_flagP,
    rb_idP,
    sdu_sizeP,
    sdu_pP);
609 610
}
//-----------------------------------------------------------------------------
611
void rlc_data_conf     (const protocol_ctxt_t *const ctxt_pP,
612 613 614
                        const srb_flag_t      srb_flagP,
                        const rb_id_t         rb_idP,
                        const mui_t           muiP,
615
                        const rlc_tx_status_t statusP) {
616 617 618
  //-----------------------------------------------------------------------------
  if (srb_flagP) {
    if (rlc_rrc_data_conf != NULL) {
619
      rlc_rrc_data_conf (ctxt_pP, rb_idP , muiP, statusP);
620
    }
621
  }
622 623 624
}
//-----------------------------------------------------------------------------
int
625
rlc_module_init (void) {
626 627 628
  //-----------------------------------------------------------------------------
  int          k;
  module_id_t  module_id1;
Cedric Roux's avatar
Cedric Roux committed
629 630
  /* for no gcc warnings */
  (void)k;
631 632 633
  LOG_D(RLC, "MODULE INIT\n");
  rlc_rrc_data_ind  = NULL;
  rlc_rrc_data_conf = NULL;
634
  rlc_coll_p = hashtable_create ((LTE_maxDRB + 2) * 16, NULL, rb_free_rlc_union);
635

636 637 638 639 640
  //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;
  }
641

knopp's avatar
knopp committed
642
  for (module_id1=0; module_id1 < MAX_MOBILES_PER_ENB; module_id1++) {
643
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
644 645 646 647 648 649 650

    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++) {
651
      rlc_mbms_rbid2lcid_ue[module_id1][k] = RLC_LC_UNALLOCATED;
652 653
    }

gauthier's avatar
gauthier committed
654
#endif
655
  }
656

657
  for (module_id1=0; module_id1 < NUMBER_OF_eNB_MAX; module_id1++) {
658
#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
659 660 661 662 663 664 665

    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++) {
666
      rlc_mbms_rbid2lcid_eNB[module_id1][k] = RLC_LC_UNALLOCATED;
667 668
    }

gauthier's avatar
gauthier committed
669
#endif
670
  }
671

672 673
  pool_buffer_init();
  return(0);
674 675 676
}
//-----------------------------------------------------------------------------
void
677
rlc_module_cleanup (void)
678 679
//-----------------------------------------------------------------------------
{
680
  hashtable_destroy(rlc_coll_p);
681 682 683
}
//-----------------------------------------------------------------------------
void
684
rlc_layer_init (void) {
685
  //-----------------------------------------------------------------------------
686 687 688
}
//-----------------------------------------------------------------------------
void
689
rlc_layer_cleanup (void)
690 691 692 693
//-----------------------------------------------------------------------------
{
}