* add RRH gateway module, IQ transports, and its gtkwave template (experimental)

* update ethernet library and common lib 
* update runtime values of the lte-softmodem tx and rx threads based on an empirical model


git-svn-id: http://svn.eurecom.fr/openair4G/trunk@7709 818b1a75-f10b-46b9-bf7c-635c3b92a50f

targets/ARCH/BLADERF/USERSPACE/LIB/bladerf_lib.c

@@ -132,7 +132,7 @@ int trx_brf_end(openair0_device *device) {
   return 0;
 }
 
-//int openair0_device_brf_init(openair0_device *device, openair0_config_t *openair0_cfg) {
+//int  openair0_dev_init_bladerf(openair0_device *device, openair0_config_t *openair0_cfg) {
 int openair0_device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
 
   int status;
@@ -263,15 +263,27 @@ int openair0_device_init(openair0_device *device, openair0_config_t *openair0_cf
   return 0;
 }
 
-void brf_error(int status) {
+int brf_error(int status) {
   
   exit(-1);
+  //return 1; // or status error code
 }
 
 int openair0_stop(int card) {
 
   return(0);
 
+}
+
+int openair0_print_stats(openair0_device* device) {
+
+  return(0);
+
+}
+int openair0_reset_stats(openair0_device* device) {
+
+  return(0);
+
 }
 int openair0_set_frequencies(openair0_device* device, openair0_config_t *openair0_cfg,int dummy) {
   return 0;

targets/ARCH/BLADERF/USERSPACE/LIB/bladerf_lib.h

@@ -78,4 +78,4 @@ typedef struct {
  * func prototypes 
  */
 
-void brf_error(int status);
+int brf_error(int status);

targets/ARCH/COMMON/common_lib.h

@@ -26,16 +26,23 @@
    Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
 
  *******************************************************************************/
+/*! \file common_lib.h 
+ * \brief common APIs for different RF frontend device 
+ * \author HongliangXU, Navid Nikaein
+ * \date 2015
+ * \version 0.2
+ * \company Eurecom
+ * \maintainer:  navid.nikaein@eurecom.fr
+ * \note
+ * \warning
+ */
 
-/** common_lib.h
-*
-* Author: HongliangXU : hong-liang-xu@agilent.com
-*/
 #ifndef COMMON_LIB_H
 #define COMMON_LIB_H
 #include <stdint.h>
 
 typedef int64_t openair0_timestamp;
+typedef volatile int64_t openair0_vtimestamp;
 typedef struct openair0_device_t openair0_device;
 /* structrue holds the parameters to configure USRP devices
  */
@@ -56,10 +63,18 @@ typedef struct {
   int Mod_id;
   // device log level
   int log_level;
+  //! number of downlink resource blocks
+  int num_rb_dl;
+  //! number of samples per frame 
+  unsigned int  samples_per_frame;
   //! the sample rate for both transmit and receive.
   double sample_rate;
   //! number of samples per RX/TX packet (USRP + Ethernet)
   int samples_per_packet;
+  // delay in sending samples (write)  due to hardware access, softmodem processing and fronthaul delay if exist
+  int   	tx_delay;
+  //! adjust the position of the samples after delay when sending   
+  unsigned int	tx_forward_nsamps;
   //! number of RX channels (=RX antennas)
   int rx_num_channels;
   //! number of TX channels (=TX antennas)
@@ -84,9 +99,14 @@ typedef struct {
   //! Auto calibration flag
   int autocal[4];
   //! RRH IP addr for Ethernet interface
-  char *rrh_ip;
+  char *remote_ip;
   //! RRH port number for Ethernet interface
-  int rrh_port;
+  int remote_port;
+  //! my IP addr for Ethernet interface (eNB/BBU, UE)
+  char *my_ip;
+  //! my port number for Ethernet interface (eNB/BBU, UE)
+  int my_port;
+
 } openair0_config_t;
 
 typedef struct {
@@ -98,10 +118,42 @@ typedef struct {
 
 
 
+/*!\brief device type */
+typedef enum {
+  MIN_DEV_TYPE = 0,
+  /*!\brief device is ETH */
+  ETH_IF,
+  /*!\brief device is ExpressMIMO */
+  EXMIMO_IF,
+  /*!\brief device is USRP*/
+  USRP_IF,
+  /*!\brief device is BLADE RF*/
+  BLADERF_IF,
+  /*!\brief device is NONE*/
+  NONE_IF,
+  MAX_DEV_TYPE
+
+} dev_type_t;
+
+/*!\brief  type */
+typedef enum {
+  MIN_FUNC_TYPE = 0,
+  BBU_FUNC,
+  RRH_FUNC,
+  MAX_FUNC_TYPE
+
+}func_type_t;
+
 struct openair0_device_t {
   /* Module ID of this device */
   int Mod_id;
 
+  /* Type of this device */
+  func_type_t func_type;
+  
+  /* Type of this device */
+  dev_type_t type;
+
   /* RF frontend parameters set by application */
   openair0_config_t openair0_cfg;
 
@@ -113,11 +165,20 @@ struct openair0_device_t {
   /* Called to start the transceiver. Return 0 if OK, < 0 if error */
   int (*trx_start_func)(openair0_device *device);
 
+  /* Called to initiate transceiver threads */
+  void (*trx_thread_func)(openair0_device *device, unsigned int rt_period, uint8_t RT_flag,uint8_t NRT_flag);
+    
+  /* Called to request connection from the transceiver/RRH. Return 0 if OK, < 0 if error */
+  int (*trx_request_func)(openair0_device *device);
+
+  /* Called to reply back to connection state to eNB/BBU. Return 0 if OK, < 0 if error */
+  int (*trx_reply_func)(openair0_device *openair0);
+
   /* Write 'nsamps' samples on each channel from buffers. buff[0] is the array for
    * the first channel. timestamp if the time (in samples) at which the first sample
    * MUST be sent
    * use flags = 1 to send as timestamp specfied*/
-  void (*trx_write_func)(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags);
+  int (*trx_write_func)(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int antenna_id, int flags);
 
   /*! \brief Receive samples from hardware.
    * Read \ref nsamps samples from each channel to buffers. buff[0] is the array for
@@ -130,7 +191,19 @@ struct openair0_device_t {
    * \param cc Number of channels. If cc == 1, only buff[0] is filled with samples.
    * \returns the number of sample read
    */
-  int (*trx_read_func)(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps,int cc);
+  int (*trx_read_func)(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps,int antenna_id);
+
+  /*! \brief print the device statistics  
+   * \param device the hardware to use
+   * \returns  0 on success
+   */
+  int (*trx_get_stats_func)(openair0_device *device);
+
+  /*! \brief Reset device statistics  
+   * \param device the hardware to use
+   * \returns 0 in success 
+   */
+  int (*trx_reset_stats_func)(openair0_device *device);
 
   /* Terminate operation of the transceiver -- free all associated resources */
   void (*trx_end_func)(openair0_device *device);
@@ -142,15 +215,33 @@ extern "C"
 {
 #endif
 
-/* return 0 if OK, < 0 if error */
-  int openair0_device_init(openair0_device* device, openair0_config_t *openair0_cfg);
-  openair0_timestamp get_usrp_time(openair0_device *device);
-  int openair0_set_frequencies(openair0_device* device, openair0_config_t *openair0_cfg,int exmimo_dump_config);
-  int openair0_set_rx_frequencies(openair0_device* device, openair0_config_t *openair0_cfg);
-  
-  int openair0_set_gains(openair0_device* device, openair0_config_t *openair0_cfg);
-  
-  int openair0_stop(int card);
+/* return 0 if OK */
+
+int openair0_device_init(openair0_device* device, openair0_config_t *openair0_cfg);
+openair0_timestamp get_usrp_time(openair0_device *device);
+
+//EXMIMO
+//int openair0_dev_init_exmimo(openair0_device *device, openair0_config_t *openair0_cfg);
+//USPRP
+//int openair0_dev_init_usrp(openair0_device* device, openair0_config_t *openair0_cfg);
+//BLADERF
+//int openair0_dev_init_bladerf(openair0_device* device, openair0_config_t *openair0_cfg);
+
+//ETHERNET
+int openair0_dev_init_eth(openair0_device *device, openair0_config_t *openair0_cfg);
+
+int openair0_set_frequencies(openair0_device* device, openair0_config_t *openair0_cfg,int exmimo_dump_config);
+
+int openair0_set_rx_frequencies(openair0_device* device, openair0_config_t *openair0_cfg);
+
+int openair0_set_gains(openair0_device* device, openair0_config_t *openair0_cfg);
+
+int openair0_print_stats(openair0_device* device);
+
+int openair0_reset_stats(openair0_device* device);
+
+int openair0_stop(int card);
+
 #ifdef __cplusplus
 }
 #endif

targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.c

@@ -26,16 +26,16 @@
    Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
 
  *******************************************************************************/
-
-/** ethernet_lib : API to stream I/Q samples over standard ethernet
-*
-*  Authors: Pedro Dinis    <pedrodinis20@gmail.com>
-*           Lucio Ferreira <lucio.ferreira@inov.pt>
-*           Raymond Knopp  <raymond.knopp@eurecom.fr>
-*
-*  Changelog:
-*  06.10.2014: Initial version
-*/
+/*! \fileethernet_lib.c 
+ * \brief API to stream I/Q samples over standard ethernet
+ * \author Katerina Trilyraki, Navid Nikaein, Pedro Dinis, Lucio Ferreira, Raymond Knopp
+ * \date 2015
+ * \version 0.2
+ * \company Eurecom
+ * \maintainer:  navid.nikaein@eurecom.fr
+ * \note
+ * \warning 
+ */
 
 #include <arpa/inet.h>
 #include <linux/if_packet.h>
@@ -50,203 +50,361 @@
 #include <errno.h>
 
 #include "common_lib.h"
+#include "ethernet_lib.h"
 
 #define DEFAULT_IF  "eth0"
-#define BUF_SIZ   8960 /*Jumbo frame size*/
+#define BUF_SIZ      8960 /*Jumbo frame size*/
 #define MAX_INST        4
 
-int sockfd[MAX_INST];
-struct sockaddr_in dest_addr[MAX_INST];
+//int sockfd[MAX_INST];
+int num_devices = 0;
 int dest_addr_len[MAX_INST];
-
-int i;
-int tx_len = 0;
 char sendbuf[MAX_INST][BUF_SIZ]; /*TODO*/
 
 
-/**PDF: Initialization of UDP Socket to communicate with one DEST */
-int ethernet_socket_init(int Mod_id, char *dest_ip,int dest_port)
-{
+/* Initialization of UDP Socket to communicate with one destination */
+int ethernet_socket_init(openair0_device *device) {
 
-  /**PDF: To be passed by input argument*/
-  //  DEST_port = 32000;
-  struct sockaddr_in *dest = &dest_addr[Mod_id];
+  int i = 0;
+  eth_state_t *eth = (eth_state_t*)device->priv;
+  int Mod_id = device->Mod_id;
+  
+//  struct sockaddr_in *dest = &dest_addr[Mod_id];
   char str[INET_ADDRSTRLEN];
-
+  const char *dest_ip;
+  int dest_port;
+  
+  if (device->func_type == RRH_FUNC ){
+    dest_ip   = device->openair0_cfg.my_ip;   
+    dest_port = device->openair0_cfg.my_port;
+    printf("[RRH] ip addr %s port %d\n",dest_ip, dest_port);
+  } else {
+    dest_ip   = device->openair0_cfg.remote_ip;
+    dest_port = device->openair0_cfg.remote_port;
+    printf("[BBU] ip addr %s port %d\n",dest_ip, dest_port);
+  }
+    
   /* Open RAW socket to send on */
-
-  if ((sockfd[Mod_id] = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
+  if ((eth->sockfd[Mod_id] = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
     perror("ETHERNET: Error opening socket");
     exit(0);
   }
 
-  bzero((void *)dest,sizeof(struct sockaddr));
-  dest->sin_family = AF_INET;
-  dest->sin_addr.s_addr=inet_addr(dest_ip);
-  dest->sin_port=htons(dest_port);
-  dest_addr_len[Mod_id] = sizeof(struct sockaddr);
+  /* initialize destination address */
+  for (i=0; i< MAX_INST; i++)  
+    bzero((void *)&(eth->dest_addr[i]), sizeof(eth->dest_addr[i]));
 
-  inet_ntop(AF_INET, &(dest->sin_addr), str, INET_ADDRSTRLEN);
-  printf("Connecting to %s:%d\n",str,ntohs(dest->sin_port));
+ // bzero((void *)dest,sizeof(struct sockaddr_in));
+  eth->dest_addr[Mod_id].sin_family = AF_INET;
+  inet_pton(AF_INET,dest_ip,&(eth->dest_addr[Mod_id].sin_addr.s_addr));
+  eth->dest_addr[Mod_id].sin_port=htons(dest_port);
+  dest_addr_len[Mod_id] = sizeof(struct sockaddr_in);
+  inet_ntop(AF_INET, &(eth->dest_addr[Mod_id].sin_addr), str, INET_ADDRSTRLEN);
+  
+  /* if RRH, then I am the server, so bind */
+  if (device->func_type == RRH_FUNC ){    
+    if (bind(eth->sockfd[Mod_id],(struct sockaddr *)&eth->dest_addr[Mod_id], dest_addr_len[Mod_id])<0) {
+      perror("ETHERNET: Cannot bind to socket");
+      exit(0);
+    }else {
+      printf("[RRH] binding mod_%d to %s:%d\n",Mod_id,str,ntohs(eth->dest_addr[Mod_id].sin_port));
+    }
+    
+  }else {
+    printf("[BBU] Connecting to %s:%d\n",str,ntohs(eth->dest_addr[Mod_id].sin_port));
+  }
+  
+  return 0;
+}
+
+void ethernet_socket_opt (openair0_device *device){
+
+  eth_state_t *eth = (eth_state_t*)device->priv;
+  int Mod_id=device->Mod_id;
+  
+  int sndbuf_size=0, rcvbuf_size=0;      
+  socklen_t optlen;    
+  /* chang the MTU of the eth interface */ 
+  struct ifreq ifr; 
+  
+  optlen = sizeof(int);  
+  
+  if (getsockopt(eth->sockfd[Mod_id],  
+                 SOL_SOCKET,  
+                 SO_SNDBUF,  
+                 &sndbuf_size,&optlen))   
+    printf("error:getsockopt()\n");  
+  
+  if (getsockopt(eth->sockfd[Mod_id],  
+                 SOL_SOCKET,  
+                 SO_RCVBUF,  
+                 &rcvbuf_size,&optlen))
+    printf("error:getsockopt()\n"); 
+
+  printf( "sndbuf_size= %d bytes rcvbuf_size= %d bytes\n", sndbuf_size,
+	  rcvbuf_size); 
+
+  ifr.ifr_addr.sa_family = AF_INET;
+  //iap->ifa_name is bond1:xx
+  strncpy(ifr.ifr_name, DEFAULT_IF, sizeof(ifr.ifr_name));
+  ifr.ifr_mtu = device->openair0_cfg.samples_per_packet*5; 
+  if (ioctl(eth->sockfd[Mod_id], SIOCSIFMTU, (caddr_t)&ifr)  < 0 )
+    perror ("Can't set the MTU");
+  else 
+    printf("[ETHERNET] %s MTU size has changed to %d\n",DEFAULT_IF,ifr.ifr_mtu);
+  
+}
 
 
+int trx_eth_request(openair0_device *device) {
+
+  int 	       Mod_id = device->Mod_id;
+  eth_state_t *eth = (eth_state_t*)device->priv;
+  void 	      *msg;
+  ssize_t     msg_len;
+
+  
+  /* send to RRH (server) required configuration parameters:
+     -number of downlink RBs (so that frame/packet size can be set accordingly)
+     -rx_num_0channels
+     -tx_num_channels
+     -rx_freq
+     -tx_freq
+     -rxg_mode[4]	
+     -rx_gain
+     -tx_gain
+     -rx_bw
+     -tx_bw
+     -autocal */ 
+  
+  msg=malloc(sizeof(openair0_config_t));
+  msg_len=sizeof(openair0_config_t);
+  memcpy(msg,(void*)&device->openair0_cfg,msg_len);	
+  
+  if (sendto(eth->sockfd[Mod_id],msg,msg_len,0,(struct sockaddr *)&eth->dest_addr[Mod_id],dest_addr_len[Mod_id])==-1){
+    perror("ETHERNET: ");
+    exit(0);
+  }
+     
+  return 0;
 }
 
 
 
-int ethernet_write_data(int Mod_id, openair0_timestamp timestamp, const void **buff, int antenna_id, int nsamps)
-{
+int trx_eth_reply(openair0_device *device) {
 
-  void *buff2 = (void*)buff[antenna_id]-sizeof(openair0_timestamp)-(sizeof(int16_t)*2);
-  int32_t temp0 = *(int32_t *)buff2;
-  openair0_timestamp temp1 = *(openair0_timestamp *)(buff2+(sizeof(int16_t)*2));
+  eth_state_t   *eth = (eth_state_t*)device->priv;
+  int 		Mod_id = device->Mod_id;
+  char 		str[INET_ADDRSTRLEN];
+  void 		*msg;
+  ssize_t	msg_len;
+  
+  msg=malloc(sizeof(openair0_config_t));
+  msg_len=sizeof(openair0_config_t);
 
+  /* receive from client (lte-softmodem)  */
+  if (recvfrom(eth->sockfd[Mod_id],
+	       msg,
+	       msg_len,
+	       0,
+	       (struct sockaddr *)&eth->dest_addr[Mod_id],
+	       (socklen_t *)&dest_addr_len[Mod_id])==-1){
+    perror("ETHERNET: ");
+    exit(0);
+  }
+		
+   memcpy((void*)&device->openair0_cfg,msg,msg_len);	
+   inet_ntop(AF_INET, &(eth->dest_addr[Mod_id].sin_addr), str, INET_ADDRSTRLEN);
+   device->openair0_cfg.remote_port =ntohs(eth->dest_addr[Mod_id].sin_port);
+   device->openair0_cfg.remote_ip=str;
+   //ethernet_socket_opt (device);
+   printf("[RRH] write mod_%d %d to %s:%d\n",Mod_id,eth->sockfd[Mod_id],str,ntohs(eth->dest_addr[Mod_id].sin_port));
+
+   return 1;
+}
+
+
+int ethernet_write_data(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int antenna_id) {	
+	
   int n_written;
+  uint16_t header_size=sizeof(int32_t) + sizeof(openair0_timestamp);
+  eth_state_t *eth = (eth_state_t*)device->priv;
+  int Mod_id = device->Mod_id;
+  int sendto_flag =0;
+  sendto_flag|=MSG_DONTWAIT;
+	
+  /* buff[antenna_id] points to the position in tx buffer where the payload to be sent is
+     buff2 points to the position in tx buffer where the packet header will be placed */
+  void *buff2 = (void*)(buff[antenna_id]-header_size); // (void*)((unsigned char *)buff[antenna_id]-header_size);
 
+  /* we don't want to ovewrite with the header info the previous tx buffer data so we store it*/
+  int32_t temp0 = *(int32_t *)buff2;
+  openair0_timestamp  temp1 = *(openair0_timestamp *)(buff2 + sizeof(int32_t));
+  //printf("temp0=%d temp=%d\n",temp0,temp1);
+  //char str[INET_ADDRSTRLEN];
+  
   n_written = 0;
-  ((int16_t *)buff2)[0] = 1+(antenna_id<<1);
-  ((int16_t *)buff2)[1] = nsamps;
-  *((openair0_timestamp *)(buff2+(sizeof(int16_t)*2))) = timestamp;
-  //  printf("Timestamp TX sent : %d\n",timestamp);
-
-  //  printf("buffer head : %d %d %d %d \n",((int16_t *)buff2)[0],((int16_t *)buff2)[1],((int16_t *)buff2)[2],((int16_t *)buff2)[3]);
-  while(n_written < nsamps) {
+  
+  *(int16_t *)(buff2 + sizeof(int16_t))=1+(antenna_id<<1);
+  *(openair0_timestamp *)(buff2 + sizeof(int32_t)) = timestamp;
+	
+  //inet_ntop(AF_INET, &(eth->dest_addr[Mod_id].sin_addr), str, INET_ADDRSTRLEN);
+  //printf("[RRH]write mod_%d %d to %s:%d, len %d, buff %p antenna %d\n",
+  //Mod_id,eth->sockfd[Mod_id],str,ntohs(eth->dest_addr[Mod_id].sin_port),(nsamps<<2)+header_size, buff2, antenna_id);
+	
+while(n_written < nsamps) {
     /* Send packet */
-    if ((n_written += sendto(sockfd[Mod_id],
-                             buff2,
-                             (nsamps<<2)+sizeof(openair0_timestamp)+(2*sizeof(int16_t)),
-                             0,
-                             (struct sockaddr*)&dest_addr[Mod_id],
-                             dest_addr_len[Mod_id])) < 0) {
-      printf("Send failed for Mod_id %d\n",Mod_id);
-      perror("ETHERNET:");
-      exit(-1);
+  if ((n_written += sendto(eth->sockfd[Mod_id],
+			   buff2, 
+                           (nsamps<<2)+header_size,
+                           0,
+                           (struct sockaddr*)&eth->dest_addr[Mod_id],
+                           dest_addr_len[Mod_id])) < 0) {
+    perror("ETHERNET WRITE");
+    exit(-1);
     }
   }
 
+/* printf("Buffer head TX: nu=%d an_id=%d ts%d byte_send=%d \n",		*(int16_t *)buff2,
+  *(int16_t *)(buff2 + sizeof(int16_t)),
+  *(openair0_timestamp *)(buff2 + sizeof(int32_t)),
+  n_written>>2);*/
+  
+  /* tx buffer values restored */  
   *(int32_t *)buff2 = temp0;
-  *(openair0_timestamp *)(buff2+2*sizeof(int16_t)) = temp1;
+  *(openair0_timestamp *)(buff2 + sizeof(int32_t)) = temp1;
+  //printf("-----------------temp0=%d temp=%d\n",*(int32_t *)buff2,*(openair0_timestamp *)(buff2 + sizeof(int32_t)));
   return n_written;
 
 }
 
 
-int ethernet_read_data(int Mod_id,openair0_timestamp *timestamp,void **buff, int antenna_id, int nsamps)
-{
+int ethernet_read_data(openair0_device *device,openair0_timestamp *timestamp,void **buff, int nsamps,int antenna_id) {
 
-  void *buff2 = (void*)buff[antenna_id]-sizeof(openair0_timestamp);
   int bytes_received;
   int block_cnt;
   int ret;
-  openair0_timestamp temp = *(openair0_timestamp*)(buff2);
-  int16_t mesg[2];
   char str[INET_ADDRSTRLEN];
+  uint16_t  header_size=sizeof(int32_t) + sizeof(openair0_timestamp);
 
-  //mesg[0] = 0+(antenna_id<<1);
-  //mesg[1] = nsamps;
-
-  inet_ntop(AF_INET, &(dest_addr[Mod_id].sin_addr), str, INET_ADDRSTRLEN);
+  
+  /* buff[antenna_id] points to the position in rx buffer where the payload to be received will be placed
+     buff2 points to the position in rx buffer where the packet header will be placed */
+  void *buff2 = (void*)(buff[antenna_id]-header_size);
+  
+  /* we don't want to ovewrite with the header info the previous rx buffer data so we store it*/
+  int32_t temp0 = *(int32_t *)buff2;
+  openair0_timestamp temp1 = *(openair0_timestamp *)(buff2 + sizeof(int32_t));
+  
+  eth_state_t *eth = (eth_state_t*)device->priv;
+  int Mod_id = device->Mod_id;
+  
+  inet_ntop(AF_INET, &(eth->dest_addr[Mod_id].sin_addr), str, INET_ADDRSTRLEN);
   // send command RX for nsamps samples
-  //  printf("requesting %d samples from (%s:%d)\n",nsamps,str,ntohs(dest_addr[Mod_id].sin_port));
-
-  //sendto(sockfd[Mod_id],mesg,4,0,(struct sockaddr *)&dest_addr[Mod_id],dest_addr_len[Mod_id]);
+  // printf("requesting %d samples from (%s:%d)\n",nsamps,str,ntohs(eth->dest_addr[Mod_id].sin_port));
 
   bytes_received=0;
   block_cnt=0;
 
   while(bytes_received < (int)((nsamps<<2))) {
     //printf("requesting %d bytes\n",(nsamps<<2));
-    ret=recvfrom(sockfd[Mod_id],
+    ret=recvfrom(eth->sockfd[Mod_id],
                  buff2+bytes_received,
-                 (nsamps<<2)+sizeof(openair0_timestamp)-bytes_received,
+                 (nsamps<<2)+header_size-bytes_received,
                  0,//MSG_DONTWAIT,
-                 (struct sockaddr *)&dest_addr[Mod_id],
-                 &dest_addr_len[Mod_id]);
+                 (struct sockaddr *)&eth->dest_addr[Mod_id],
+                 (socklen_t *)&dest_addr_len[Mod_id]);
 
     //printf("bytes_received %d (ret %d)\n",bytes_received+ret,ret);
     if (ret==-1) {
       if (errno == EAGAIN) {
-        perror("ETHERNET: ");
-        return((nsamps<<2)+sizeof(openair0_timestamp));
+        perror("ETHERNET READ: ");
+        return((nsamps<<2) + header_size);
       } else if (errno == EWOULDBLOCK) {
         block_cnt++;
         usleep(10);
-
+	
         if (block_cnt == 100) return(-1);
       }
     } else {
       bytes_received+=ret;
     }
   }
-
-
-  //printf("buffer head : %x %x %x %x \n",((int32_t *)buff2)[0],((int32_t *)buff2)[1],((int32_t *)buff2)[2],((int32_t *)buff2)[3]);
-  *timestamp =  *(openair0_timestamp *)(buff2);
-  //  printf("Received %d samples, timestamp = %d\n",bytes_received>>2,*(int32_t*)timestamp);
-  *(openair0_timestamp *)(buff2) = temp;
+  /*
+    printf("Buffer head RX: nu=%d an_id=%d ts%d byte_recv=%d\n",      *(int16_t *)buff2,
+    *(int16_t *)(buff2 + sizeof(int16_t)),
+    *(openair0_timestamp *)(buff2 + sizeof(int32_t)),
+    ret>>2);*/
+  
+  /* store the timestamp value from packet's header */
+  *timestamp =  *(openair0_timestamp *)(buff2 + sizeof(int32_t));
+  
+  /* tx buffer values restored */  
+  *(int32_t *)buff2 = temp0;
+  *(openair0_timestamp *)(buff2 + sizeof(int32_t)) = temp1;
+  // printf("Received %d samples, timestamp = %d\n",bytes_received>>2,*(int32_t*)timestamp);
+  
   return nsamps;
-
+  
 }
 
 
-int trx_eth_start(openair0_device *openair0)
-{
+int trx_eth_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int antenna_id, int flags) {
+  
+  return ethernet_write_data(device,timestamp,buff,nsamps,antenna_id);
+}
 
-  int16_t mesg[2];
-  int Mod_id;
-
-  Mod_id = openair0->openair0_cfg.Mod_id;
-  ethernet_socket_init(openair0->openair0_cfg.Mod_id, openair0->openair0_cfg.rrh_ip,openair0->openair0_cfg.rrh_port);
-
-  mesg[0] = 1 + 0;  //antenna index is 0, to be replaced by the number of active antennas
-  mesg[1] = openair0->openair0_cfg.samples_per_packet;
-
-  sendto(sockfd[Mod_id],mesg,4,0,(struct sockaddr *)&dest_addr[Mod_id],dest_addr_len[Mod_id]);
+int trx_eth_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int antenna_id) {
+  
+  return(ethernet_read_data(device,ptimestamp,buff,nsamps,antenna_id));
+  
+}
 
+int openair0_stop(int card) {
 
   return(0);
-}
-
-void trx_eth_write(openair0_device *device, openair0_timestamp timestamp, const void **buff, int nsamps, int cc, int flags)
-{
-  int i;
-
-  for (i=0; i<cc; i++)
-    ethernet_write_data(device->Mod_id,timestamp,buff,i,nsamps);
-}
-int trx_eth_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps,int cc)
-{
-
-  int i;
-
-  for (i=0; i<cc; i++)
-    return(ethernet_read_data(device->Mod_id,ptimestamp,buff,i,nsamps));
 
 }
 
-void trx_eth_end(openair0_device *device)
-{
-
-
+int openair0_print_stats(openair0_device* device) {
 
+  return(0);
 
 }
+int openair0_reset_stats(openair0_device* device) {
 
-int openair0_stop(int dummy) {
+  return(0);
 
-   return 0;
+}
+void trx_eth_end(openair0_device *device) {
+  // close all the sockets
+
+  
 }
 
-int num_devices = 0;
 
-int openair0_device_init(openair0_device *device, openair0_config_t *openair0_cfg)
-{
+int openair0_dev_init_eth(openair0_device *device, openair0_config_t *openair0_cfg){
 
-  printf("ETHERNET: Initializing openair0_device\n");
-  device->Mod_id         = num_devices++;
-  device->trx_start_func = trx_eth_start;
-  device->trx_end_func   = trx_eth_end;
-  device->trx_read_func  = trx_eth_read;
-  device->trx_write_func = trx_eth_write;
+  eth_state_t *eth = (eth_state_t*)malloc(sizeof(eth_state_t));
+  int card = 0;
+  memset(eth, 0, sizeof(eth_state_t));
+  eth->buffer_size = (unsigned int)openair0_cfg[card].samples_per_packet*sizeof(int32_t); // buffer size = 4096 for sample_len of 1024
+  eth->sample_rate = (unsigned int)openair0_cfg[card].sample_rate;
+  device->priv = eth; 	
+
+  printf("ETHERNET: Initializing openair0_device for %s ...\n", ((device->func_type == BBU_FUNC) ? "BBU": "RRH"));
+  device->Mod_id           = num_devices++;
+  device->trx_request_func = trx_eth_request;
+  device->trx_reply_func   = trx_eth_reply;
+  device->trx_end_func     = trx_eth_end;
+  device->trx_read_func    = trx_eth_read;
+  device->trx_write_func   = trx_eth_write;
+  
   memcpy((void*)&device->openair0_cfg,(void*)openair0_cfg,sizeof(openair0_config_t));
+
+  if (ethernet_socket_init(device)!=0){
+    return -1;
+  }
+  
+  return 0;
 }

targets/ARCH/ETHERNET/USERSPACE/LIB/ethernet_lib.h

@@ -1,3 +1,42 @@
+/*******************************************************************************
+    OpenAirInterface
+    Copyright(c) 1999 - 2014 Eurecom
+
+    OpenAirInterface is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+
+    OpenAirInterface is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenAirInterface.The full GNU General Public License is
+    included in this distribution in the file called "COPYING". If not,
+    see <http://www.gnu.org/licenses/>.
+
+   Contact Information
+   OpenAirInterface Admin: openair_admin@eurecom.fr
+   OpenAirInterface Tech : openair_tech@eurecom.fr
+   OpenAirInterface Dev  : openair4g-devel@eurecom.fr
+
+   Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
+
+ *******************************************************************************/
+/*! \file ethernet_lib.h
+ * \brief API to stream I/Q samples over standard ethernet
+ * \author Katerina Trilyraki, Navid Nikaein
+ * \date 2015
+ * \version 0.2
+ * \company Eurecom
+ * \maintainer:  navid.nikaein@eurecom.fr
+ * \note
+ * \warning 
+ */
+
 #include <arpa/inet.h>
 #include <linux/if_packet.h>
 #include <stdio.h>
@@ -8,8 +47,75 @@
 #include <net/if.h>
 #include <netinet/ether.h>
 
-int ethernet_socket_init(int Mod_id, char *dest_ip,int dest_port);
 
-int ethernet_write_data(int Mod_id, const void *buff, int nsamps,int cc);
+typedef struct {
 
-int ethernet_read_data(int Mod_id,void *buff, int nsamps,int cc);
+  // opaque eth data struct
+  //struct eth_if *dev;
+  // An empty ("") or NULL device identifier will result in the first encountered device being opened (using the first discovered backend)
+
+  int sockfd[4];
+  struct sockaddr_in dest_addr[4];
+
+
+  unsigned int buffer_size;
+  unsigned int timeout_ns;
+
+  //struct eth_metadata meta_rx;
+  //struct eth_metadata meta_tx;
+
+  unsigned int sample_rate;
+  // time offset between transmiter timestamp and receiver timestamp;
+  double tdiff;
+  // use brf_time_offset to get this value
+  int tx_forward_nsamps; //166 for 20Mhz
+
+
+  // --------------------------------
+  // Debug and output control
+  // --------------------------------
+  int num_underflows;
+  int num_overflows;
+  int num_seq_errors;
+  int num_rx_errors;
+  int num_tx_errors;
+
+  uint64_t tx_actual_nsamps; // actual number of samples transmitted
+  uint64_t rx_actual_nsamps;
+  uint64_t tx_nsamps; // number of planned samples
+  uint64_t rx_nsamps;
+  uint64_t tx_count; // number pf packets
+  uint64_t rx_count;
+  //openair0_timestamp rx_timestamp;
+
+} eth_state_t;
+
+#define 	ETH_META_STATUS_OVERRUN   (1 << 0)
+#define 	ETH_META_STATUS_UNDERRUN  (1 << 1)
+
+struct eth_meta_data{
+	uint64_t 	timestamp;
+	uint32_t 	flags;	 
+	uint32_t 	status;
+ 	unsigned int 	actual_count;
+};
+
+
+typedef struct {
+	/* packet's timestamp */
+  openair0_timestamp timestamp;
+  /* variable declared for alignment purposes (sample size=32 bit)  */
+  int16_t 	not_used;
+  /* antenna port used to resynchronize*/
+  int16_t 	antenna_id;
+} header_t;
+
+
+
+int ethernet_socket_init(openair0_device *device);
+
+int ethernet_write_data(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps,int antenna_id);
+
+int ethernet_read_data(openair0_device *device,openair0_timestamp *timestamp,void **buff, int nsamps,int antenna_id);
+
+void ethernet_socket_opt (openair0_device *device);

targets/ARCH/EXMIMO/USERSPACE/LIB/openair0_lib.c

@@ -247,6 +247,7 @@ int openair0_stop_without_reset(int card)
 #define MY_RF_MODE      (RXEN + TXEN + TXLPFNORM + TXLPFEN + TXLPF25 + RXLPFNORM + RXLPFEN + RXLPF25 + LNA1ON +LNAMax + RFBBNORM + DMAMODE_RX + DMAMODE_TX)
 #define RF_MODE_BASE    (LNA1ON + RFBBNORM)
 
+//int openair0_dev_init_exmimo(openair0_device *device, openair0_config_t *openair0_cfg) {
 int openair0_device_init(openair0_device *device, openair0_config_t *openair0_cfg) {
 
   // Initialize card

targets/ARCH/USRP/USERSPACE/LIB/usrp_lib.cpp

@@ -44,8 +44,10 @@
 #include <complex>
 #include <fstream>
 #include <cmath>
+
 #include "common_lib.h"
 
+
 typedef struct
 {
 
@@ -121,7 +123,7 @@ static void trx_usrp_end(openair0_device *device)
 	s->tx_stream->send("", 0, s->tx_md);
 	s->tx_md.end_of_burst = false;
 }
-static void trx_usrp_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
+static int trx_usrp_write(openair0_device *device, openair0_timestamp timestamp, void **buff, int nsamps, int cc, int flags)
 {
   usrp_state_t *s = (usrp_state_t*)device->priv;
   s->tx_md.time_spec = uhd::time_spec_t::from_ticks(timestamp, s->sample_rate);
@@ -138,6 +140,8 @@ static void trx_usrp_write(openair0_device *device, openair0_timestamp timestamp
   else
     s->tx_stream->send(buff[0], nsamps, s->tx_md);
   s->tx_md.start_of_burst = false;
+
+  return 0;
 }
 
 static int trx_usrp_read(openair0_device *device, openair0_timestamp *ptimestamp, void **buff, int nsamps, int cc)
@@ -195,7 +199,7 @@ static bool is_equal(double a, double b)
   return std::fabs(a-b) < std::numeric_limits<double>::epsilon();
 }
 
-int openair0_set_frequencies(openair0_device* device, openair0_config_t *openair0_cfg,int dummy) {
+int openair0_set_frequencies(openair0_device* device, openair0_config_t *openair0_cfg, int dummy) {
 
   usrp_state_t *s = (usrp_state_t*)device->priv;
 
@@ -237,7 +241,17 @@ int openair0_stop(int card) {
   return(0);
 
 }
+int openair0_print_stats(openair0_device* device) {
 
+  return(0);
+
+}
+int openair0_reset_stats(openair0_device* device) {
+
+  return(0);
+
+}
+//int openair0_dev_init_usrp(openair0_device* device, openair0_config_t *openair0_cfg)
 int openair0_device_init(openair0_device* device, openair0_config_t *openair0_cfg)
 {
   uhd::set_thread_priority_safe(1.0);
@@ -376,7 +390,7 @@ int openair0_device_init(openair0_device* device, openair0_config_t *openair0_cf
   device->trx_end_func   = trx_usrp_end;
   device->trx_read_func  = trx_usrp_read;
   device->trx_write_func = trx_usrp_write;
-
+  
   s->sample_rate = openair0_cfg[0].sample_rate;
   // TODO:
   // init tx_forward_nsamps based usrp_time_offset ex