Generate the DCCH and send from pdcp

openair2/F1AP/f1ap_cu_rrc_message_transfer.c

@@ -365,13 +365,15 @@ int CU_handle_UL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   */
   protocol_ctxt_t ctxt;
   ctxt.module_id = instance;
+  ctxt.instance = instance;
   ctxt.rnti = f1ap_get_rnti_by_cu_id(&f1ap_cu_ue[instance],cu_ue_f1ap_id);
   ctxt.enb_flag = 1;
   mem_block_t *mb = get_free_mem_block(ie->value.choice.RRCContainer.size,__func__);
   memcpy((void*)mb->data,(void*)ie->value.choice.RRCContainer.buf,ie->value.choice.RRCContainer.size);
+  LOG_I(CU_F1AP, "Calling pdcp_data_ind for UE RNTI %x srb_id %lu with size %d (DCCH) \n", ctxt.rnti, srb_id, ie->value.choice.RRCContainer.size);
   pdcp_data_ind (&ctxt,
-		 1,
-		 0,
+     1, // srb_flag
+     0, // embms_flag
      srb_id,
      ie->value.choice.RRCContainer.size,
      mb);

openair2/F1AP/f1ap_du_rrc_message_transfer.c

@@ -175,6 +175,12 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
   // decode RRC Container and act on the message type
   AssertFatal(srb_id<3,"illegal srb_id\n");
 
+  protocol_ctxt_t ctxt;
+  ctxt.rnti      = f1ap_get_rnti_by_du_id(&f1ap_du_ue[instance],du_ue_f1ap_id);
+  ctxt.module_id = instance;
+  ctxt.instance  = instance;
+  ctxt.enb_flag  = 1;
+
   if (srb_id == 0) {
     DL_CCCH_Message_t* dl_ccch_msg=NULL;
     asn_dec_rval_t dec_rval;
@@ -238,15 +244,8 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
             } else {
               SRB1_logicalChannelConfig = &SRB1_logicalChannelConfig_defaultValue;
             }
-	    
-	    
-	  }
           }
-
-	protocol_ctxt_t ctxt;
-	ctxt.rnti      = f1ap_get_rnti_by_du_id(&f1ap_du_ue[instance],du_ue_f1ap_id);
-        ctxt.module_id = instance;
-	ctxt.enb_flag  = 1;
+        } // for
         rrc_rlc_config_asn1_req(&ctxt,
           SRB_configList,
           (DRB_ToAddModList_t*) NULL,
@@ -308,20 +307,76 @@ int DU_handle_DL_RRC_MESSAGE_TRANSFER(instance_t       instance,
 #endif
           );
           break;
+      } // case
 
       default:
         AssertFatal(1==0,
         "Unknown message\n");
         break;
-      }
+    }// switch case
+  } else if (srb_id == 1) { 
+//     rrc_rlc_config_asn1_req(&ctxt,
+//         SRB_configList,
+//         (DRB_ToAddModList_t*) NULL,
+//         (DRB_ToReleaseList_t*) NULL
+// #if (RRC_VERSION >= MAKE_VERSION(9, 0, 0))
+//         , (PMCH_InfoList_r9_t *) NULL,
+//         0,0
+// #   endif
+//         );
+
+    LOG_I(DU_F1AP, "Received DL RRC Transfer on srb_id 1\n");
+    rlc_op_status_t    rlc_status;
+    boolean_t          ret             = TRUE;
+    mem_block_t       *pdcp_pdu_p      = NULL; 
+    pdcp_pdu_p = get_free_mem_block(rrc_dl_sdu_len, __func__);
+    memset(&pdcp_pdu_p->data[0], 0, rrc_dl_sdu_len);
+    memcpy(&pdcp_pdu_p->data[0], ie->value.choice.RRCContainer.buf, rrc_dl_sdu_len);
+
+    if (pdcp_pdu_p != NULL) {
+      rlc_status = rlc_data_req(&ctxt
+                                , 1
+                                , MBMS_FLAG_NO
+                                , srb_id
+                                , 0
+                                , 0
+                                , rrc_dl_sdu_len
+                                , pdcp_pdu_p
+#ifdef Rel14
+                                ,NULL
+                                ,NULL
+#endif
+                                );
+      switch (rlc_status) {
+        case RLC_OP_STATUS_OK:
+          LOG_D(PDCP, "Data sending request over RLC succeeded!\n");
+          ret=TRUE;
+          break;
 
-    }
-  }
-  else if (srb_id == 1){ 
+        case RLC_OP_STATUS_BAD_PARAMETER:
+          LOG_W(PDCP, "Data sending request over RLC failed with 'Bad Parameter' reason!\n");
+          ret= FALSE;
+          break;
 
-  }
+        case RLC_OP_STATUS_INTERNAL_ERROR:
+          LOG_W(PDCP, "Data sending request over RLC failed with 'Internal Error' reason!\n");
+          ret= FALSE;
+          break;
 
-  else if (srb_id == 2){
+        case RLC_OP_STATUS_OUT_OF_RESSOURCES:
+          LOG_W(PDCP, "Data sending request over RLC failed with 'Out of Resources' reason!\n");
+          ret= FALSE;
+          break;
+
+        default:
+          LOG_W(PDCP, "RLC returned an unknown status code after PDCP placed the order to send some data (Status Code:%d)\n", rlc_status);
+          ret= FALSE;
+          break;
+      } // switch case
+      return ret; 
+    } // if pdcp_pdu_p
+  
+  } else if (srb_id == 2) {
 
   }
 #endif
@@ -336,7 +391,6 @@ int DU_send_UL_RRC_MESSAGE_TRANSFER(const protocol_ctxt_t* const ctxt_pP,
                                     ) {
 
 
-
   rnti_t     rnti      = ctxt_pP->rnti;
 
   F1AP_F1AP_PDU_t                pdu;
@@ -402,6 +456,7 @@ int DU_send_UL_RRC_MESSAGE_TRANSFER(const protocol_ctxt_t* const ctxt_pP,
     LOG_E(DU_F1AP, "Failed to encode F1 setup request\n");
     return -1;
   }
+  LOG_W(DU_F1AP, "DU_send_UL_RRC_MESSAGE_TRANSFER on SRB %d for UE %x \n", rb_idP, rnti);
 
   du_f1ap_itti_send_sctp_data_req(instance, f1ap_du_data->assoc_id, buffer, len, f1ap_du_data->default_sctp_stream_id);
   return 0;

openair2/F1AP/f1ap_du_task.c

@@ -175,8 +175,9 @@ void *F1AP_DU_task(void *arg) {
 
      case F1AP_UL_RRC_MESSAGE: // from rrc
         LOG_I(DU_F1AP, "DU Task Received F1AP_UL_RRC_MESSAGE\n");
-        DU_send_UL_RRC_MESSAGE_TRANSFER(ITTI_MESSAGE_GET_INSTANCE(received_msg),
-                                        &F1AP_UL_RRC_MESSAGE(received_msg));
+        AssertFatal (1 == 0, "Should not be here!\n" );
+        //DU_send_UL_RRC_MESSAGE_TRANSFER(ITTI_MESSAGE_GET_INSTANCE(received_msg),
+         //                               &F1AP_UL_RRC_MESSAGE(received_msg));
         break;
 
       case TERMINATE_MESSAGE:

openair2/F1AP/f1ap_handlers.c

@@ -119,7 +119,7 @@ int f1ap_handle_message(instance_t instance, uint32_t assoc_id, int32_t stream,
   }
 
   /* Calling the right handler */
-  LOG_I(DU_F1AP, "Calling handler with instance %d\n",instance);
+  LOG_I(F1AP, "Calling handler with instance %d\n",instance);
   ret = (*f1ap_messages_callback[pdu.choice.initiatingMessage->procedureCode][pdu.present - 1])
         (instance, assoc_id, stream, &pdu);
   ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_F1AP_F1AP_PDU, &pdu);

openair2/LAYER2/PDCP_v10.1.0/pdcp.c

@@ -49,9 +49,7 @@
 #include "platform_constants.h"
 #include "common/utils/LOG/vcd_signal_dumper.h"
 #include "msc.h"
-
-
-
+#include "common/ngran_types.h"
 
 #if defined(ENABLE_SECURITY)
 # include "UTIL/OSA/osa_defs.h"
@@ -411,11 +409,34 @@ boolean_t pdcp_data_req(
       free_mem_block(pdcp_pdu_p, __FUNCTION__);
       rlc_status = ack_result;
     }
-
-    else
+    else // SRB
 #endif /*UETARGET*/ 
     {
+     LOG_I(PDCP, "Sending F1AP_DL_RRC_MESSAGE with ITTI\n");
+
       //It should never get here
+      if ((RC.rrc[ctxt_pP->module_id]->node_type  == ngran_eNB_CU)   ||
+        (RC.rrc[ctxt_pP->module_id]->node_type   == ngran_ng_eNB_CU)||
+        (RC.rrc[ctxt_pP->module_id]->node_type   == ngran_gNB_CU)  ) {
+        // DL transfer
+        MessageDef                            *message_p;
+        // Note: the acyual task must be TASK_PDCP_ENB, but this task is not created
+        message_p = itti_alloc_new_message (TASK_PDCP_ENB, F1AP_DL_RRC_MESSAGE);
+        F1AP_DL_RRC_MESSAGE (message_p).rrc_container =  &pdcp_pdu_p->data[0] ;
+        F1AP_DL_RRC_MESSAGE (message_p).rrc_container_length = pdcp_pdu_size;
+        F1AP_DL_RRC_MESSAGE (message_p).gNB_CU_ue_id  = 0;  
+        F1AP_DL_RRC_MESSAGE (message_p).gNB_DU_ue_id  = 0;
+        F1AP_DL_RRC_MESSAGE (message_p).old_gNB_DU_ue_id  = 0xFFFFFFFF; // unknown
+        F1AP_DL_RRC_MESSAGE (message_p).rnti = ctxt_pP->rnti;
+        F1AP_DL_RRC_MESSAGE (message_p).srb_id = rb_idP;
+        F1AP_DL_RRC_MESSAGE (message_p).execute_duplication      = 1;
+        F1AP_DL_RRC_MESSAGE (message_p).RAT_frequency_priority_information.en_dc      = 0;
+        itti_send_msg_to_task (TASK_CU_F1, ctxt_pP->module_id, message_p);
+        //CU_send_DL_RRC_MESSAGE_TRANSFER(ctxt_pP->module_id, message_p);
+        LOG_I(PDCP, "Send F1AP_DL_RRC_MESSAGE with ITTI\n");
+        ret=TRUE;
+
+      } else{
         rlc_status = rlc_data_req(ctxt_pP
                                   , srb_flagP
                                   , MBMS_FLAG_NO
@@ -424,15 +445,11 @@ boolean_t pdcp_data_req(
                                   , confirmP
                                   , pdcp_pdu_size
                                   , pdcp_pdu_p
-      #ifdef Rel14
+#ifdef Rel14
                                   ,NULL
                                   ,NULL
-      #endif
+#endif
                                   );
-    }
-
-  }
-
         switch (rlc_status) {
           case RLC_OP_STATUS_OK:
             LOG_D(PDCP, "Data sending request over RLC succeeded!\n");
@@ -458,6 +475,9 @@ boolean_t pdcp_data_req(
             LOG_W(PDCP, "RLC returned an unknown status code after PDCP placed the order to send some data (Status Code:%d)\n", rlc_status);
             ret= FALSE;
             break;
+        } // switch case
+      }
+    }
   }
 
   if (ctxt_pP->enb_flag == ENB_FLAG_YES) {
@@ -978,6 +998,8 @@ void pdcp_update_stats(const protocol_ctxt_t* const  ctxt_pP){
     
   }
 }
+
+
 //-----------------------------------------------------------------------------
 void
 pdcp_run (
@@ -1020,6 +1042,7 @@ pdcp_run (
           RRC_DCCH_DATA_REQ (msg_p).frame, 
 	  0,
 	  RRC_DCCH_DATA_REQ (msg_p).eNB_index);
+
         LOG_I(PDCP, PROTOCOL_CTXT_FMT"Received %s from %s: instance %d, rb_id %d, muiP %d, confirmP %d, mode %d\n",
               PROTOCOL_CTXT_ARGS(&ctxt),
               ITTI_MSG_NAME (msg_p),
@@ -1030,6 +1053,8 @@ pdcp_run (
               RRC_DCCH_DATA_REQ (msg_p).confirmp,
               RRC_DCCH_DATA_REQ (msg_p).mode);
 
+        log_dump(PDCP, RRC_DCCH_DATA_REQ (msg_p).sdu_p, RRC_DCCH_DATA_REQ (msg_p).sdu_size, LOG_DUMP_CHAR,"[MSG] pdcp run\n");
+
         result = pdcp_data_req (&ctxt,
                                 SRB_FLAG_YES,
                                 RRC_DCCH_DATA_REQ (msg_p).rb_id,

openair2/LAYER2/RLC/rlc_mac.c

@@ -260,12 +260,12 @@ void mac_rlc_data_ind     (
 #ifdef DEBUG_MAC_INTERFACE
 
   if (num_tbP) {
-    LOG_I(RLC, PROTOCOL_CTXT_FMT" MAC_RLC_DATA_IND on channel %d (%d), rb max %d, Num_tb %d\n",
+    LOG_I(RLC, PROTOCOL_CTXT_FMT" MAC_RLC_DATA_IND on channel %d (%d), rb max %d, tb_sizeP %d\n",
           PROTOCOL_CTXT_ARGS(&ctxt),
           channel_idP,
           RLC_MAX_LC,
           NB_RB_MAX,
-          num_tbP);
+          tb_sizeP);
   }
 
 #endif // DEBUG_MAC_INTERFACE

openair2/RRC/LTE/L2_interface_common.c

@@ -94,6 +94,8 @@ rrc_data_req(
     RRC_DCCH_DATA_REQ (message_p).confirmp  = confirmP;
     RRC_DCCH_DATA_REQ (message_p).sdu_size  = sdu_sizeP;
     RRC_DCCH_DATA_REQ (message_p).sdu_p     = message_buffer;
+    //memcpy (RRC_DCCH_DATA_REQ (message_p).sdu_p, buffer_pP, sdu_sizeP);
+
     RRC_DCCH_DATA_REQ (message_p).mode      = modeP;
     RRC_DCCH_DATA_REQ (message_p).module_id = ctxt_pP->module_id;
     RRC_DCCH_DATA_REQ (message_p).rnti      = ctxt_pP->rnti;
@@ -103,6 +105,10 @@ rrc_data_req(
       ctxt_pP->enb_flag ? TASK_PDCP_ENB : TASK_PDCP_UE,
       ctxt_pP->instance,
       message_p);
+    LOG_I(RRC,"sent RRC_DCCH_DATA_REQ to TASK_PDCP_ENB\n");
+    // RS/BK: Fix ME
+    pdcp_run(ctxt_pP);
+
     return TRUE; // TODO should be changed to a CNF message later, currently RRC lite does not used the returned value anyway.
 
   }

openair2/RRC/LTE/rrc_eNB.c

@@ -1167,8 +1167,10 @@ rrc_eNB_generate_SecurityModeCommand(
     rrc_eNB_mui,
     size);
 
- if ((RC.rrc[ctxt_pP->module_id]->node_type  == ngran_eNB) ||
-	(RC.rrc[ctxt_pP->module_id]->node_type  == ngran_ng_eNB)) {
+ if ((RC.rrc[ctxt_pP->module_id]->node_type  != ngran_eNB_DU) ||
+	   (RC.rrc[ctxt_pP->module_id]->node_type  != ngran_gNB_DU)) {
+  LOG_I(RRC,"calling rrc_data_req :securityModeCommand\n");
+
     rrc_data_req(
 	       ctxt_pP,
 	       DCCH,

openair2/RRC/LTE/rrc_eNB_S1AP.c

@@ -923,7 +923,6 @@ rrc_eNB_process_S1AP_DOWNLINK_NAS(
                S1AP_DOWNLINK_NAS (msg_p).nas_pdu.buffer);
 
     LOG_DUMPMSG(RRC,DEBUG_RRC,buffer,length,"[MSG] RRC DL Information Transfer\n");
-
     /* 
      * switch UL or DL NAS message without RRC piggybacked to SRB2 if active. 
      */

targets/COMMON/create_tasks.c

@@ -85,6 +85,10 @@ int create_tasks(uint32_t enb_nb)
     if (enb_nb > 0) {
       rc = itti_create_task(TASK_CU_F1, F1AP_CU_task, NULL);
       AssertFatal(rc >= 0, "Create task for CU F1AP failed\n");
+      //RS/BK: Fix me!
+      rc = itti_create_task (TASK_L2L1, l2l1_task, NULL);
+      AssertFatal(rc >= 0, "Create task for L2L1 failed\n");
+
     }
     /* fall through */
   case ngran_eNB:

targets/RT/USER/lte-softmodem.c

@@ -1082,6 +1082,16 @@ int main( int argc, char **argv )
     RCconfig_L1();
   }
 
+
+  if (RC.rrc[0]->node_type == ngran_eNB_CU || RC.rrc[0]->node_type == ngran_ng_eNB_CU) {
+    protocol_ctxt_t ctxt;
+    ctxt.module_id = 0 ;
+    ctxt.instance = 0;
+    ctxt.rnti = 0;
+    ctxt.enb_flag = 1;
+    pdcp_run(&ctxt);
+  }
+
   /* start threads if only L1 or not a CU */
   if (RC.nb_inst == 0 ||
       !(RC.rrc[0]->node_type == ngran_eNB_CU || RC.rrc[0]->node_type == ngran_ng_eNB_CU)) {