Merge branch 'enhancement-10-harmony' of...

Merge branch 'enhancement-10-harmony' of https://gitlab.eurecom.fr/oai/openairinterface5g into enhancement-10-harmony

Conflicts:
	targets/RT/USER/lte-enb.c

cmake_targets/CMakeLists.txt

@@ -138,7 +138,7 @@ else (CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7l")
       set(C_FLAGS_PROCESSOR "${C_FLAGS_PROCESSOR} -mavx2")
     endif()
     if (CPUINFO MATCHES "sse4_1")
-      set(C_FLAGS_PROCESSOR "${C_FLAGS_PROCESSOR} -msse4.1 -mavx2")
+      set(C_FLAGS_PROCESSOR "${C_FLAGS_PROCESSOR} -msse4.1")
     endif()
     if (CPUINFO MATCHES "ssse3")
       set(C_FLAGS_PROCESSOR "${C_FLAGS_PROCESSOR} -mssse3")
@@ -960,6 +960,7 @@ add_boolean_option(OAI_NW_DRIVER_USE_NETLINK True "????")
 	  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/rar_tools.c
 	  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/print_stats.c
 	  ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/initial_sync.c
+      ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/if4_tools.c
 	  ${OPENAIR1_DIR}/PHY/MODULATION/ofdm_mod.c
 	  ${OPENAIR1_DIR}/PHY/MODULATION/slot_fep.c
 	  ${OPENAIR1_DIR}/PHY/MODULATION/slot_fep_mbsfn.c

openair1/PHY/LTE_TRANSPORT/if4_tools.c

@@ -29,7 +29,7 @@
 
 /*! \file PHY/LTE_TRANSPORT/if4_tools.c
 * \brief 
-* \author Mauricio Gunther, S. Sandeep Kumar, Raymond Knopp
+* \author Fredrik Skretteberg, Tobias Schuster, Mauricio Gunther, S. Sandeep Kumar, Raymond Knopp
 * \date 2016
 * \version 0.1
 * \company Eurecom
@@ -38,109 +38,137 @@
 * \warning
 */
 
-#ifndef USER_MODE
-#include "if4_tools.h"
 #include <stdint.h>
-#else
+
+#include "PHY/defs.h"
 #include "PHY/LTE_TRANSPORT/if4_tools.h"
-#endif
+#include "PHY/TOOLS/ALAW/alaw_lut.h"
 
 // Get device information
-void send_IF4(PHY_VARS_eNB *eNB, eNB_rxtx_proc_t *proc) {
-	int frame = proc->frame_tx;
-	int subframe = proc->subframe_tx;
-	LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
-	
-	uint16_t i;
-
-  float_t data_block_length = 1200*(fp->ofdm_symbol_size/2048);
-  uint16_t *data_block = (uint16_t*)malloc(data_block_length*sizeof(uint16_t));
+void send_IF4(PHY_VARS_eNB *eNB, eNB_rxtx_proc_t *proc, uint16_t packet_type) {
+  LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
+  int32_t **txdataF = eNB->common_vars.txdataF[0];
+  
+  uint16_t symbol_id, element_id;
+  uint16_t db_fulllength = 12*fp->N_RB_DL;
+  uint16_t db_halflength = db_fulllength>>1;
+  int slotoffsetF = (proc->subframe_tx)*(fp->ofdm_symbol_size)*((fp->Ncp==1) ? 12 : 14) + 1;
+  int blockoffsetF = slotoffsetF + fp->ofdm_symbol_size - db_halflength; 
+  
+  int16_t *data_block = (int16_t*)malloc(db_fulllength*sizeof(int16_t));  
 
   // Caller: RCC - DL *** handle RRU case - UL and PRACH *** 
-  if (eNB->node_function == NGFI_RCC_IF4) {
+  if (packet_type == IF4_PDLFFT) {
     IF4_dl_packet_t *dl_packet = (IF4_dl_packet_t*)malloc(sizeof_IF4_dl_packet_t);
     gen_IF4_dl_packet(dl_packet, proc);
 		
     dl_packet->data_block = data_block;
 
-    for(i=0; i<fp->symbols_per_tti; i++) {
-			
-      //Do compression of the two parts and generate data blocks
+    for (symbol_id=0; symbol_id<fp->symbols_per_tti; symbol_id++) {
+      
+      printf("\n Send IF4 for frame %d, subframe %d and symbol %d\n", proc->frame_tx, proc->subframe_tx, symbol_id);
 
-      //symbol = eNB->common_vars.txdataF[0][0 /*antenna number*/][subframe*fp->ofdm_symbol_size*(fp->symbols_per_tti)]
-      //data_block[j] = Atan(symbol[fp->ofmd_symbol_size - NrOfNonZeroValues + j -1])<<16 + Atan(symbol[fp->ofmd_symbol_size - NrOfNonZeroValues + j]);
-      //data_block[j+NrOfNonZeroValues] = Atan(subframe[i][j+1])<<16 + Atan(subframe[i][j+2]);
-	 		
+      // Do compression of the two parts and generate data blocks			
+      for (element_id=0; element_id<db_halflength; element_id++) {
+        data_block[element_id]  = lin2alaw[ (txdataF[0][blockoffsetF+element_id] & 0xffff) + 32768 ];          
+        data_block[element_id] |= lin2alaw[ (txdataF[0][blockoffsetF+element_id]>>16) + 32768 ]<<8;  
+        
+        data_block[element_id+db_halflength]  = lin2alaw[ (txdataF[0][slotoffsetF+element_id] & 0xffff) + 32768 ];     
+        data_block[element_id+db_halflength] |= lin2alaw[ (txdataF[0][slotoffsetF+element_id]>>16) + 32768 ]<<8;  
+      }
+				 		
       // Update information in generated packet
-      dl_packet->frame_status.sym_num = i; 
+      dl_packet->frame_status.sym_num = symbol_id; 
 			
       // Write the packet(s) to the fronthaul
-      //if ((bytes_sent = dev->eth_dev.trx_write_func (&dev->eth_dev,
-			//			                                         timestamp_rx,
-			//			                                         rx_eNB,
-			//			                                         spp_eth,
-			//			                                         dev->eth_dev.openair0_cfg->rx_num_channels,
-      //                                               0)) < 0) {
-      //  perror("RCC : ETHERNET write");
-      //}    
+    //  if ((bytes_sent = eNB->ifdevice.trx_write_func(&eNB->ifdevice,
+    //                                                (proc->timestamp_tx-eNB->ifdevice.openair0_cfg.tx_sample_advance),
+    //  			                                         dl_packet,
+    //  			                                         eNB->frame_parms.samples_per_tti,
+    //  			                                         eNB->frame_parms.nb_antennas_tx,
+    //                                                 0)) < 0) {
+    //    perror("RCC : ETHERNET write");
+    //}
+      
+      slotoffsetF  += fp->ofdm_symbol_size;
+      blockoffsetF += fp->ofdm_symbol_size;    
     }
-  }else {
+  } else if (packet_type == IF4_PULFFT) {
     IF4_ul_packet_t *ul_packet = (IF4_ul_packet_t*)malloc(sizeof_IF4_ul_packet_t);
     gen_IF4_ul_packet(ul_packet, proc);
 		
     ul_packet->data_block = data_block;
 
-    for(i=0; i<fp->symbols_per_tti; i++) {
-			
-      //Do compression of the two parts and generate data blocks
+    for (symbol_id=0; symbol_id<fp->symbols_per_tti; symbol_id++) {			
 
-      //symbol = eNB->common_vars.txdataF[0][0 /*antenna number*/][subframe*fp->ofdm_symbol_size*(fp->symbols_per_tti)]
-      //data_block[j] = Atan(symbol[fp->ofmd_symbol_size - NrOfNonZeroValues + j -1])<<16 + Atan(symbol[fp->ofmd_symbol_size - NrOfNonZeroValues + j]);
-      //data_block[j+NrOfNonZeroValues] = Atan(subframe[i][j+1])<<16 + Atan(subframe[i][j+2]);
-			
+      // Do compression of the two parts and generate data blocks - rxdataF		
+      for (element_id=0; element_id<db_halflength; element_id++) {
+        //data_block[element_id]  = lin2alaw[ (rxdataF[0][blockoffsetF+element_id] & 0xffff) + 32768 ];          
+        //data_block[element_id] |= lin2alaw[ (rxdataF[0][blockoffsetF+element_id]>>16) + 32768 ]<<8;  
+        
+        //data_block[element_id+db_halflength]  = lin2alaw[ (txdataF[0][slotoffsetF+element_id] & 0xffff) + 32768 ];     
+        //data_block[element_id+db_halflength] |= lin2alaw[ (txdataF[0][slotoffsetF+element_id]>>16) + 32768 ]<<8;  
+      }
+       			
       // Update information in generated packet
-      ul_packet->frame_status.sym_num = i; 
+      ul_packet->frame_status.sym_num = symbol_id; 
 			
       // Write the packet(s) to the fronthaul 
 
+      slotoffsetF  += fp->ofdm_symbol_size;
+      blockoffsetF += fp->ofdm_symbol_size;    
     }		
-	}
-  		    
+  } else if (packet_type == IF4_PRACH) {
+       
+       
+  } else {    
+    AssertFatal(1==0, "send_IF4 - Unknown packet_type %x", packet_type);     
+  }
+  
+  return;  		    
 }
 
-void recv_IF4(PHY_VARS_eNB *eNB, eNB_rxtx_proc_t *proc) {
-
-  // Caller: RRU - DL *** handle RCC case - UL and PRACH *** 
-
-  if (eNB->node_function == NGFI_RRU_IF4) {
-  
+void recv_IF4(PHY_VARS_eNB *eNB, eNB_rxtx_proc_t *proc, uint16_t *packet_type, uint32_t *symbol_number) {
+
+  *packet_type = 0;
+  int16_t *data_block=NULL;
+   
+  // Read packet(s) from the fronthaul    
+//    for(i=0; i<fp->symbols_per_tti; i++) {  
+//      if (dev->eth_dev.trx_read_func (&dev->eth_dev,
+//                                      timestamp_rx,
+//                                    rx_eNB,
+//                                      spp_eth,
+//                                      dev->eth_dev.openair0_cfg->rx_num_channels
+//                                      ) < 0) {
+//        perror("RRU : ETHERNET read");
+//      }
+//  printf("\n Recv IF4 for frame %d, subframe %d and symbol %d\n", proc->frame_tx, proc->subframe_tx, symbol_id);
+
+  //*packet_type = ;  
   
-  
-    for(i=0; i<fp->symbols_per_tti; i++) {  
-      // Read packet(s) from the fronthaul    
-      if (dev->eth_dev.trx_read_func (&dev->eth_dev,
-                                      timestamp_rx,
-                                      rx_eNB,
-                                      spp_eth,
-                                      dev->eth_dev.openair0_cfg->rx_num_channels
-                                      ) < 0) {
-        perror("RRU : ETHERNET read");
-      }
+  if (*packet_type == IF4_PDLFFT) {
       
       // Apply reverse processing - decompression
       // txAlawtolinear( Datablock )
       
       // Generate and return the OFDM symbols (txdataF)
-      txDataF 
-    }
-  }else {
+      // txDataF 
     
-  }  
+  } else if (*packet_type == IF4_PULFFT) {
+    
+  } else if (*packet_type == IF4_PRACH) {
+       
+  } else {
+    AssertFatal(1==0, "recv_IF4 - Unknown packet_type %x", *packet_type);            
+  }
+
+  return;   
 }
 
 void gen_IF4_dl_packet(IF4_dl_packet_t *dl_packet, eNB_rxtx_proc_t *proc) {      
   // Set Type and Sub-Type
-  dl_packet->type = 0x080A; 
+  dl_packet->type = IF4_PACKET_TYPE; 
   dl_packet->sub_type = IF4_PDLFFT;
 
   // Leave reserved as it is 
@@ -160,7 +188,7 @@ void gen_IF4_dl_packet(IF4_dl_packet_t *dl_packet, eNB_rxtx_proc_t *proc) {
 
 void gen_IF4_ul_packet(IF4_ul_packet_t *ul_packet, eNB_rxtx_proc_t *proc) {  
   // Set Type and Sub-Type
-  ul_packet->type = 0x080A; 
+  ul_packet->type = IF4_PACKET_TYPE; 
   ul_packet->sub_type = IF4_PULFFT;
 
   // Leave reserved as it is 
@@ -184,7 +212,7 @@ void gen_IF4_ul_packet(IF4_ul_packet_t *ul_packet, eNB_rxtx_proc_t *proc) {
 
 void gen_IF4_prach_packet(IF4_prach_packet_t *prach_packet, eNB_rxtx_proc_t *proc) {
   // Set Type and Sub-Type
-  prach_packet->type = 0x080A; 
+  prach_packet->type = IF4_PACKET_TYPE; 
   prach_packet->sub_type = IF4_PRACH;
 
   // Leave reserved as it is 

openair1/PHY/LTE_TRANSPORT/if4_tools.h

@@ -38,6 +38,10 @@
 * \warning
 */
 
+#include <stdint.h>
+
+/// Macro for IF4 packet type
+#define IF4_PACKET_TYPE 0x080A 
 #define IF4_PULFFT 0x0019 
 #define IF4_PDLFFT 0x0020
 #define IF4_PRACH 0x0021
@@ -103,7 +107,7 @@ struct IF4_dl_packet {
   /// Frame Status
   IF4_frame_status_t frame_status;
   /// Data Blocks
-  uint16_t *data_block;
+  int16_t *data_block;
   /// Frame Check Sequence
   uint32_t fcs; 
 };
@@ -141,7 +145,7 @@ struct IF4_ul_packet {
   /// Gain 7
   IF4_gain_t gain7;
   /// Data Blocks
-  uint16_t *data_block;
+  int16_t *data_block;
   /// Frame Check Sequence
   uint32_t fcs;
 };
@@ -163,7 +167,7 @@ struct IF4_prach_packet {
   /// LTE Prach Configuration
   IF4_lte_prach_conf_t prach_conf;
   /// Prach Data Block (one antenna)
-  uint16_t *data_block;
+  int16_t *data_block;
   /// Frame Check Sequence
   uint32_t fcs;
 };
@@ -177,6 +181,6 @@ void gen_IF4_ul_packet(IF4_ul_packet_t*, eNB_rxtx_proc_t*);
 
 void gen_IF4_prach_packet(IF4_prach_packet_t*, eNB_rxtx_proc_t*);
 
-void send_IF4(PHY_VARS_eNB*, eNB_rxtx_proc_t*);
+void send_IF4(PHY_VARS_eNB*, eNB_rxtx_proc_t*, uint16_t);
 
-void recv_IF4(PHY_VARS_eNB*, eNB_rxtx_proc_t*, int*, int*);
+void recv_IF4(PHY_VARS_eNB*, eNB_rxtx_proc_t*, uint16_t*, uint32_t*);

openair1/PHY/LTE_TRANSPORT/prach.c

@@ -1269,16 +1269,19 @@ void rx_prach(PHY_VARS_eNB *eNB,
   }
 
   if (eNB->node_function == NGFI_RRU_IF4) {
-    //send prachF to RCC
+    /// **** send_IF4 of prachF to RCC **** ///    
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4, 1 );   
+    // send_IF4();
+    VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4, 0 );   
+
     return;
   }
+  
   // in case of RCC and prach received rx_thread wakes up prach
   //else if (eNB->node_function == NGFI_RCC_IF4) {
-    //wait for prachF from RRU and continue with PRACH processing
+  //  wait for prachF from RRU and continue with PRACH processing
   //}
 
-
-
   // here onwards is for eNodeB_3GPP or NGFI_RCC_IF4
 
   preamble_offset_old = 99;

openair1/PHY/defs.h

@@ -139,6 +139,8 @@ static inline void* malloc16_clear( size_t size )
 #include "PHY/LTE_TRANSPORT/defs.h"
 #include <pthread.h>
 
+#include "targets/ARCH/COMMON/common_lib.h"
+
 #define NUM_DCI_MAX 32
 
 #define NUMBER_OF_eNB_SECTORS_MAX 3
@@ -456,6 +458,11 @@ typedef struct PHY_VARS_eNB_s {
   SLIST_HEAD(ral_thresholds_gen_poll_enb_s, ral_threshold_phy_t) ral_thresholds_gen_polled[RAL_LINK_PARAM_GEN_MAX];
   SLIST_HEAD(ral_thresholds_lte_poll_enb_s, ral_threshold_phy_t) ral_thresholds_lte_polled[RAL_LINK_PARAM_LTE_MAX];
 #endif
+  
+  /// RF and Interface devices per CC
+  openair0_device rfdevice; 
+  openair0_device ifdevice;
+  // *** Handle spatially distributed MIMO antenna ports   
 
 } PHY_VARS_eNB;
 

openair2/UTIL/LOG/vcd_signal_dumper.c

@@ -329,7 +329,11 @@ const char* eurecomFunctionsNames[] = {
   "itti_dump_enqueue_message",
   "itti_dump_enqueue_message_malloc",
   "itti_relay_thread",
-  "test"
+  "test",
+  
+  /* IF4 signals */
+  "send_if4",
+  "recv_if4"
 };
 
 struct vcd_module_s vcd_modules[VCD_SIGNAL_DUMPER_MODULE_END] = {

openair2/UTIL/LOG/vcd_signal_dumper.h

@@ -307,6 +307,11 @@ typedef enum {
   VCD_SIGNAL_DUMPER_FUNCTIONS_ITTI_DUMP_ENQUEUE_MESSAGE_MALLOC,
   VCD_SIGNAL_DUMPER_FUNCTIONS_ITTI_RELAY_THREAD,
   VCD_SIGNAL_DUMPER_FUNCTIONS_TEST,
+  
+  /* IF4 signals */
+  VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4,
+  VCD_SIGNAL_DUMPER_FUNCTIONS_RECV_IF4,
+  
   VCD_SIGNAL_DUMPER_FUNCTIONS_LAST,
   VCD_SIGNAL_DUMPER_FUNCTIONS_END = VCD_SIGNAL_DUMPER_FUNCTIONS_LAST,
 } vcd_signal_dump_functions;

targets/RT/USER/lte-softmodem.c

@@ -151,8 +151,6 @@ int sync_var=-1; //!< protected by mutex \ref sync_mutex.
 static pthread_t                forms_thread; //xforms
 #endif
 
-openair0_device openair0;
-
 uint16_t runtime_phy_rx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
 uint16_t runtime_phy_tx[29][6]; // SISO [MCS 0-28][RBs 0-5 : 6, 15, 25, 50, 75, 100]
 
@@ -281,6 +279,9 @@ eth_params_t *eth_params;
 
 openair0_config_t openair0_cfg[MAX_CARDS];
 
+// Change to openair_global to handle UE
+openair0_device openair0;
+
 double cpuf;
 
 char uecap_xer[1024],uecap_xer_in=0;
@@ -1574,14 +1575,26 @@ int main( int argc, char **argv )
   }
   LOG_I(HW, "CPU Affinity of main() function is... %s\n", cpu_affinity);
 #endif
-
+  
+  openair0_cfg[0].log_level = glog_level;
+  
+  for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
+    PHY_vars_eNB_g[0][CC_id]->rfdevice.host_type = BBU_HOST;
+    PHY_vars_eNB_g[0][CC_id]->rfdevice.type = NONE_DEV;
+    PHY_vars_eNB_g[0][CC_id]->rfdevice.transp_type = NONE_TP;
+       
+    PHY_vars_eNB_g[0][CC_id]->ifdevice.host_type = BBU_HOST;
+    PHY_vars_eNB_g[0][CC_id]->ifdevice.type = NONE_DEV;
+    PHY_vars_eNB_g[0][CC_id]->ifdevice.transp_type = NONE_TP;
+  }
+  
   /* device host type is set*/
   openair0.host_type = BBU_HOST;
   /* device type is initialized NONE_DEV (no RF device) when the RF device will be initiated device type will be set */
   openair0.type = NONE_DEV;
   /* transport type is initialized NONE_TP (no transport protocol) when the transport protocol will be initiated transport protocol type will be set */
   openair0.transp_type = NONE_TP;
-  openair0_cfg[0].log_level = glog_level;
+  //openair0_cfg[0].log_level = glog_level;
   
   // Legacy BBU - RRH init  
   //int returns=-1;
@@ -1613,36 +1626,41 @@ int main( int argc, char **argv )
   //printf("Done\n");
   
   int returns=-1;
-  
+    
+  // Handle spatially distributed MIMO antenna ports   
   // Load RF device and initialize
-  if (node_function == eNodeB_3GPP || node_function == NGFI_RRU_IF4) { 
-    if (mode!=loop_through_memory) {
-      returns=openair0_device_load(&openair0, &openair0_cfg[0]);
-      printf("openair0_device_init returns %d\n",returns);
-      if (returns<0) {
-	      printf("Exiting, cannot initialize device\n");
-	      exit(-1);
+  if (node_function != NGFI_RCC_IF4) { 
+    for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {  
+      if (mode!=loop_through_memory) {
+        returns=openair0_device_load(&(PHY_vars_eNB_g[0][CC_id]->rfdevice), &openair0_cfg[0]);
+        printf("openair0_device_init returns %d for CC_id %d\n",returns,CC_id);
+        if (returns<0) {
+	        printf("Exiting, cannot initialize device\n");
+	        exit(-1);
+        }
       }
-    }
-    else if (mode==loop_through_memory) {    
+      else if (mode==loop_through_memory) {    
+      }    
     }
   }  
   
   // Load transport protocol and initialize
-  if (node_function == NGFI_RCC_IF4 || node_function == NGFI_RRU_IF4){ 
-    if (mode!=loop_through_memory) {
-      returns=openair0_transport_load(&openair0, &openair0_cfg[0], eth_params);
-      printf("openair0_transport_init returns %d\n",returns);
-      if (returns<0) { 
-	      printf("Exiting, cannot initialize transport protocol\n");
-	      exit(-1);
+  if (node_function != eNodeB_3GPP){ 
+    for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {  
+      if (mode!=loop_through_memory) {
+        returns=openair0_transport_load(&(PHY_vars_eNB_g[0][CC_id]->ifdevice), &openair0_cfg[0], (eth_params+CC_id));
+        printf("openair0_transport_init returns %d for CC_id %d\n",returns,CC_id);
+        if (returns<0) {
+	        printf("Exiting, cannot initialize transport protocol\n");
+	        exit(-1);
+        }
       }
+      else if (mode==loop_through_memory) {    
+      }    
     }
-    else if (mode==loop_through_memory) {    
-    }
-  }   
+  }
 
-  printf("Done\n");
+  printf("Done initializing RF and IF devices\n");
   
   mac_xface = malloc(sizeof(MAC_xface));
 
@@ -1812,7 +1830,7 @@ int main( int argc, char **argv )
 
 
 
-
+// *** Handle per CC_id openair0
 #ifndef USRP_DEBUG
   if ((UE_flag==1) && (mode!=loop_through_memory))
     if (openair0.trx_start_func(&openair0) != 0 ) 
@@ -1882,7 +1900,7 @@ int main( int argc, char **argv )
   pthread_cond_destroy(&sync_cond);
   pthread_mutex_destroy(&sync_mutex);
 
-
+  // *** Handle per CC_id openair0
   openair0.trx_end_func(&openair0);
 
   if (ouput_vcd)