Merge remote-tracking branch 'origin/develop' into RU-RAU-split-parallel-EMUFH-phy-test-merge

Conflicts:
	cmake_targets/build_oai
	common/utils/itti/intertask_interface.c
	openair1/PHY/INIT/lte_init.c
	openair1/PHY/LTE_TRANSPORT/dci.c
	openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
	openair1/PHY/defs.h
	openair1/SCHED/phy_procedures_lte_eNb.c
	openair2/ENB_APP/enb_paramdef.h
	openair2/LAYER2/MAC/defs.h
	openair2/LAYER2/MAC/eNB_scheduler.c
	targets/ARCH/COMMON/common_lib.c
	targets/COMMON/create_tasks.c
	targets/RT/USER/lte-enb.c
	targets/RT/USER/lte-ru.c
	targets/RT/USER/lte-softmodem.h

openair1/Makefile

@@ -1,121 +0,0 @@
-# command line flags are automatically exported and thus passed down to any sub-make. 
-# here we set the default flags in case on command line flags are provided
-# these flags have to be explicitely exported so that the sub-make is aware of them
-
-
-include $(OPENAIR_DIR)/common/utils/Makefile.inc
-ifndef OPENAIR_LTE
-export OPENAIR_LTE=1
-endif
-
-ifndef OPENAIR1
-export OPENAIR1=1
-endif
-
-ifndef OPENAIR2
-export OPENAIR2=0
-endif
-
-ifndef EMOS
-export EMOS=0
-endif
-
-ifndef FIRMWARE2010
-export FIRMWARE2010=0
-endif
-
-all: openair_rf_cbmimo1_softmodem.ko asn1_msg_kern.ko
-
-openair_rf_cbmimo1_softmodem.ko:  
-	(cd ARCH/CBMIMO1/DEVICE_DRIVER && $(MAKE) -C $(KERNEL_DIR)/build V=1 M=`pwd` RTAI=1 CBMIMO1=1 && mv openair_rf.ko openair_rf_softmodem.ko)
-
-oai_user_cbmimo1.ko:
-	(cd ARCH/CBMIMO1/DEVICE_DRIVER && $(MAKE) -C $(KERNEL_DIR)/build V=1 M=`pwd` RTAI=1 CBMIMO1=1 BIT8_TX=1 OPENAIR1=0 OPENAIR2=0 && mv openair_rf.ko openair_rf_softmodem.ko)
-
-oai_user_exmimo.ko:
-	(cd ARCH/CBMIMO1/DEVICE_DRIVER && $(MAKE) -C $(KERNEL_DIR)/build V=1 M=`pwd` RTAI=1 CBMIMO1=1 OPENAIR1=0 OPENAIR2=0 && mv openair_rf.ko openair_rf_softmodem.ko)
-
-asn1_msg_kern.ko:
-	(cd ../openair2/RRC/LITE/MESSAGES && $(MAKE) -C $(KERNEL_DIR) V=0 M=`pwd` RTAI=1 -j2)
-
-#Remove all but source files
-cleanall: 
-	find -name '*.o' -delete -print; \
-	find -name '*.ko' -delete -print; \
-	find -name '*.bak' -delete -print; \
-	find -name '*.cmd' -delete -print; \
-	find -name '*~' -delete -print; \
-	find -name octave-core -delete -print; \
-
-#Remove files created by SVN, dangerous!!! DO NOT RUN ON YOUR WORKING REPOSITORY!
-#FK: Don't do this! Use svn export instead.
-#cleansvn:
-#	rm -rf `find -name *.svn* -print`; \
-#	find -name *.svn* -delete -print
-
-tgz:
-	mkdir /tmp/openair1_tmp; \
-	$(MAKE) cleanall; \
-	cp -r . /tmp/openair1_tmp; \
-	(cd /tmp/openair1_tmp && $(MAKE) cleansvn && cd .. && tar czfv openair1.tgz openair1_tmp) ; \
-	cp /tmp/openair1.tgz . ;\
-	rm -rf /tmp/openair1_tmp
-
-fifos:
-	@for i in `seq 0 64`;\
-	do \
-	have_rtfX=`ls /dev/ |grep -c rtf$$i`;\
-	if [ "$$have_rtfX" -eq 0 ] ;then \
-	mknod -m 666 /dev/rtf$$i c 150 $$i; \
-	fi;\
-	done
-
-openair0:
-	mknod /dev/openair0 c 127 0
-	chmod a+rw /dev/openair0
-
-install_oai_user:
-	make fifos
-	insmod ARCH/CBMIMO1/DEVICE_DRIVER/openair_rf_softmodem.ko
-
-updatefw:
-	USERSPACE_TOOLS/OAI_FW_INIT/updatefw -f $$OPENAIR0_DIR/express-mimo/software/sdr_exmimo2/main -s 0x43fffff0 
-
-boot_exmimo:
-	sudo make install_oai_user
-	USERSPACE_TOOLS/OAI_FW_INIT/updatefw -f $$OPENAIR0_DIR/express-mimo/software/sdr/main -s 0x43fffff0 
-	sudo rmmod openair_rf
-	sudo make install_oai_user
-
-reboot_exmimo:
-	USERSPACE_TOOLS/OAI_FW_INIT/updatefw -f $$OPENAIR0_DIR/express-mimo/software/sdr/main -s 0x43fffff0 -b
-	rmmod openair_rf
-	make install_oai_user
-	USERSPACE_TOOLS/OAI_FW_INIT/updatefw -f $$OPENAIR0_DIR/express-mimo/software/sdr/main -s 0x43fffff0 
-	rmmod openair_rf
-	make install_oai_user
-
-install_softmodem:
-	make fifos
-ifeq ($(OPENAIR2),1)
-	insmod ../openair2/RRC/LITE/MESSAGES/asn1_msg_kern.ko
-endif
-	insmod ARCH/CBMIMO1/DEVICE_DRIVER/openair_rf_softmodem.ko ; \
-
-remove:
-	rmmod openair_rf
-ifeq ($(OPENAIR2),1)
-	rmmod asn1_msg_kern
-endif
-
-test:
-	(cd ARCH/CBMIMO1/DEVICE_DRIVER && $(MAKE) test RTAI=1 CBMIMO1=1)	
-	(cd ../openair2/RRC/LITE/MESSAGES && $(MAKE) test)
-
-clean: clean_l1 
-
-clean_l1:
-	(cd ARCH/CBMIMO1/DEVICE_DRIVER && $(MAKE) clean RTAI=1 CBMIMO1=1)
-
-clean_asn1:
-	(cd ../openair2/RRC/LITE/MESSAGES && $(MAKE) clean)

openair1/PHY/CODING/3gpplte.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -27,7 +27,9 @@
 #ifndef TC_MAIN
 //#include "defs.h"
 #endif
-
+#include <stdint.h>
+#include <stdio.h>
+#include "PHY/CODING/defs.h"
 #include "extern_3GPPinterleaver.h"
 
 //#define DEBUG_TURBO_ENCODER 1
@@ -35,7 +37,7 @@
 uint32_t threegpplte_interleaver_output;
 uint32_t threegpplte_interleaver_tmp;
 
-inline void threegpplte_interleaver_reset()
+inline void threegpplte_interleaver_reset(void)
 {
   threegpplte_interleaver_output = 0;
   threegpplte_interleaver_tmp    = 0;
@@ -82,7 +84,7 @@ uint8_t output_lut[16],state_lut[16];
 inline uint8_t threegpplte_rsc_lut(uint8_t input,uint8_t *state)
 {
 
-  uint8_t output;
+
   uint8_t off;
 
   off = (*state<<1)|input;
@@ -146,7 +148,7 @@ void threegpplte_turbo_encoder(uint8_t *input,
   for (i=0; f1f2mat[i].nb_bits!= input_length_bits && i <188; i++);
 
   if ( i == 188 ) {
-    msg("Illegal frame length!\n");
+    printf("Illegal frame length!\n");
     return;
   } else {
     base_interleaver=il_tb+f1f2mat[i].beg_index;

openair1/PHY/CODING/3gpplte_sse.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -96,7 +96,7 @@ static inline void threegpplte_rsc_termination(unsigned char *x,unsigned char *z
   *state = (*state)>>1;
 }
 
-void treillis_table_init(void)
+static void treillis_table_init(void)
 {
   //struct treillis t[][]=all_treillis;
   //t=memalign(16,sizeof(struct treillis)*8*256);
@@ -536,12 +536,12 @@ char interleave_compact_byte(short * base_interleaver,unsigned char * input, uns
   }
 */
 
-void threegpplte_turbo_encoder(unsigned char *input,
-                               unsigned short input_length_bytes,
-                               unsigned char *output,
-                               unsigned char F,
-                               unsigned short interleaver_f1,
-                               unsigned short interleaver_f2)
+void threegpplte_turbo_encoder_sse(unsigned char *input,
+                                   unsigned short input_length_bytes,
+                                   unsigned char *output,
+                                   unsigned char F,
+                                   unsigned short interleaver_f1,
+                                   unsigned short interleaver_f2)
 {
 
   int i;
@@ -641,7 +641,24 @@ void threegpplte_turbo_encoder(unsigned char *input,
 #endif
 }
 
-
+void init_encoder_sse (void) {
+    treillis_table_init(); 	   
+}
+/* function which will be called by the shared lib loader, to check shared lib version
+   against main exec version. version mismatch no considered as fatal (interfaces not supposed to change)
+*/ 
+int  coding_checkbuildver(char * mainexec_buildversion, char ** shlib_buildversion)
+{
+#ifndef PACKAGE_VERSION
+#define PACKAGE_VERSION "standalone built: " __DATE__ __TIME__
+#endif
+    *shlib_buildversion = PACKAGE_VERSION;
+    if (strcmp(mainexec_buildversion, *shlib_buildversion) != 0) {
+          fprintf(stderr,"[CODING] shared lib version %s, doesn't match main version %s, compatibility should be checked\n",
+                mainexec_buildversion,*shlib_buildversion);
+    }
+    return 0;
+}
 
 #ifdef TC_MAIN
 #define INPUT_LENGTH 20 
@@ -679,7 +696,7 @@ int main(int argc,char **argv)
     printf("Input %d : %d\n",i,input[i]);
   }
 
-  threegpplte_turbo_encoder(&input[0],
+  threegpplte_turbo_encoder_sse(&input[0],
                             INPUT_LENGTH,
                             &output[0],
                             0,

openair1/PHY/CODING/3gpplte_turbo_decoder.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -550,7 +550,7 @@ void compute_alpha_s(llr_t* alpha,llr_t* m_11,llr_t* m_10,unsigned short frame_l
 
 void compute_beta_s(llr_t* beta,llr_t *m_11,llr_t* m_10,llr_t* alpha,unsigned short frame_length,unsigned char F)
 {
-  int k,i;
+  int k;
   llr_t old0, old1, old2, old3, old4, old5, old6, old7;
   llr_t new0, new1, new2, new3, new4, new5, new6, new7;
   llr_t m_b0, m_b1, m_b2, m_b3, m_b4,m_b5, m_b6, m_b7;
@@ -874,14 +874,22 @@ void compute_ext_s(llr_t* alpha,llr_t* beta,llr_t* m_11,llr_t* m_10,llr_t* ext,
 
 
 unsigned char phy_threegpplte_turbo_decoder_scalar(llr_t *y,
+    llr_t *y2,
     unsigned char *decoded_bytes,
+    unsigned char *decoded_bytes2,
     unsigned short n,
     unsigned short f1,
     unsigned short f2,
     unsigned char max_iterations,
     unsigned char crc_type,
     unsigned char F,
-    unsigned char inst)
+    time_stats_t *init_stats,
+    time_stats_t *alpha_stats,
+    time_stats_t *beta_stats,
+    time_stats_t *gamma_stats,
+    time_stats_t *ext_stats,
+    time_stats_t *intl1_stats,
+    time_stats_t *intl2_stats)
 {
 
   /*  y is a pointer to the input
@@ -897,7 +905,7 @@ unsigned char phy_threegpplte_turbo_decoder_scalar(llr_t *y,
   unsigned char crc_len,temp;
 
   if (crc_type > 3) {
-    msg("Illegal crc length!\n");
+    fprintf(stderr,"Illegal crc length!\n");
     return 255;
   }
 

openair1/PHY/CODING/3gpplte_turbo_decoder_avx2_16bit.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -37,9 +37,9 @@
 ///
 ///
 
-#ifdef __AVX2__
 
-#include "PHY/sse_intrin.h"
+
+
 
 #ifndef TEST_DEBUG
 #include "PHY/defs.h"
@@ -58,6 +58,8 @@
 #include "mex.h"
 #endif
 
+#ifdef __AVX2__
+#include "PHY/sse_intrin.h"
 
 //#define DEBUG_LOGMAP
 
@@ -830,14 +832,14 @@ void free_td16avx2(void)
   int ind;
 
   for (ind=0; ind<188; ind++) {
-    free(pi2tab16avx2[ind]);
-    free(pi5tab16avx2[ind]);
-    free(pi4tab16avx2[ind]);
-    free(pi6tab16avx2[ind]);
+    free_and_zero(pi2tab16avx2[ind]);
+    free_and_zero(pi5tab16avx2[ind]);
+    free_and_zero(pi4tab16avx2[ind]);
+    free_and_zero(pi6tab16avx2[ind]);
   }
 }
 
-void init_td16avx2()
+void init_td16avx2(void)
 {
 
   int ind,i,i2,i3,j,n,pi,pi2_i,pi2_pi;
@@ -1408,6 +1410,36 @@ unsigned char phy_threegpplte_turbo_decoder16avx2(int16_t *y,
 #endif
   return(iteration_cnt);
 }
+#else  //__AVX2__
+unsigned char phy_threegpplte_turbo_decoder16avx2(int16_t *y,
+						  int16_t *y2,
+						  uint8_t *decoded_bytes,
+						  uint8_t *decoded_bytes2,
+						  uint16_t n,
+						  uint16_t f1,
+						  uint16_t f2,
+						  uint8_t max_iterations,
+						  uint8_t crc_type,
+						  uint8_t F,
+						  time_stats_t *init_stats,
+						  time_stats_t *alpha_stats,
+						  time_stats_t *beta_stats,
+						  time_stats_t *gamma_stats,
+						  time_stats_t *ext_stats,
+						  time_stats_t *intl1_stats,
+						  time_stats_t *intl2_stats)
+{
+   return 0;
+}
+void free_td16avx2(void)
+{
+
+}
+
+void init_td16avx2(void)
+{
+    
+}
 
 #endif //__AVX2__
 

openair1/PHY/CODING/3gpplte_turbo_decoder_sse.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -1907,6 +1907,18 @@ void compute_ext(llr_t* alpha,llr_t* beta,llr_t* m_11,llr_t* m_10,llr_t* ext, ll
 //int pi2[n],pi3[n+8],pi5[n+8],pi4[n+8],pi6[n+8],
 int *pi2tab[188],*pi5tab[188],*pi4tab[188],*pi6tab[188];
 
+void free_td()
+{
+  int ind;
+
+  for (ind = 0; ind < 188; ind++) {
+    free_and_zero(pi2tab[ind]);
+    free_and_zero(pi5tab[ind]);
+    free_and_zero(pi4tab[ind]);
+    free_and_zero(pi6tab[ind]);
+  }
+}
+
 void init_td()
 {
 

openair1/PHY/CODING/3gpplte_turbo_decoder_sse_16bit.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -1117,14 +1117,14 @@ void free_td16(void)
   int ind;
 
   for (ind=0; ind<188; ind++) {
-    free(pi2tab16[ind]);
-    free(pi5tab16[ind]);
-    free(pi4tab16[ind]);
-    free(pi6tab16[ind]);
+    free_and_zero(pi2tab16[ind]);
+    free_and_zero(pi5tab16[ind]);
+    free_and_zero(pi4tab16[ind]);
+    free_and_zero(pi6tab16[ind]);
   }
 }
 
-void init_td16()
+void init_td16(void)
 {
 
   int ind,i,i2,i3,j,n,pi,pi3;
@@ -1172,7 +1172,9 @@ void init_td16()
 }
 
 unsigned char phy_threegpplte_turbo_decoder16(short *y,
+    short *y2,
     unsigned char *decoded_bytes,
+    unsigned char *decoded_bytes2,
     unsigned short n,
     unsigned short f1,
     unsigned short f2,

openair1/PHY/CODING/3gpplte_turbo_decoder_sse_8bit.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -838,10 +838,10 @@ void free_td8(void)
   int ind;
 
   for (ind=0; ind<188; ind++) {
-    free(pi2tab8[ind]);
-    free(pi5tab8[ind]);
-    free(pi4tab8[ind]);
-    free(pi6tab8[ind]);
+    free_and_zero(pi2tab8[ind]);
+    free_and_zero(pi5tab8[ind]);
+    free_and_zero(pi4tab8[ind]);
+    free_and_zero(pi6tab8[ind]);
   }
 }
 
@@ -849,7 +849,7 @@ void free_td8(void)
 
 extern RAN_CONTEXT_t RC;
 
-void init_td8()
+void init_td8(void)
 {
 
   int ind,i,j,n,n2,pi,pi3;
@@ -898,7 +898,9 @@ void init_td8()
 }
 
 unsigned char phy_threegpplte_turbo_decoder8(short *y,
+    short y2,
     unsigned char *decoded_bytes,
+    unsigned char *decoded_bytes2,
     unsigned short n,
     unsigned short f1,
     unsigned short f2,

openair1/PHY/CODING/Makefile.arm

@@ -5,7 +5,7 @@ RATE12CC_SRC = ccoding_byte.c viterbi.c crc_byte.c
 all: 3gpplte_sse 
 
 3gpplte_sse: $(TURBO_SRC)
-	gcc -O3  -gdwarf-2 -mfloat-abi=hard -mfpu=neon -lm -lgcc -lrt ../../SIMULATION/TOOLS/taus.c -I$$OPENAIR1_DIR -I$$OPENAIR_TARGETS -I$$OPENAIR2_DIR/COMMON -DUSER_MODE -DTC_MAIN -DNB_ANTENNAS_RX=1 -o 3gpplte_sse 3gpplte_sse.c -Wall -g -ggdb -DTC_MAIN
+	gcc -O3  -gdwarf-2 -mfloat-abi=hard -mfpu=neon -lm -lgcc -lrt ../../SIMULATION/TOOLS/taus.c -I$$OPENAIR1_DIR -I$$OPENAIR_TARGETS -I$$OPENAIR2_DIR/COMMON -DTC_MAIN -DNB_ANTENNAS_RX=1 -o 3gpplte_sse 3gpplte_sse.c -Wall -g -ggdb -DTC_MAIN
 
 
 

openair1/PHY/CODING/TESTBENCH/Makefile

@@ -7,7 +7,7 @@ OPENAIR2_TOP = $(OPENAIR2_DIR)
 OPENAIR3 = $(OPENAIR3_DIR)
 
 
-CFLAGS += -DNODE_RG -DUSER_MODE -DPC_TARGET -DNO_UL_REF -DNB_ANTENNAS_RX=2 -DNB_ANTENNAS_TXRX=2 -DNB_ANTENNAS_TX=2 -DOPENAIR_LTE -DMAX_NUM_CCs=1
+CFLAGS += -DNODE_RG -DNO_UL_REF -DNB_ANTENNAS_RX=2 -DNB_ANTENNAS_TX=2 -DOPENAIR_LTE -DMAX_NUM_CCs=1
 
 ASN1_MSG_INC = $(OPENAIR2_DIR)/RRC/LITE/MESSAGES
 

openair1/PHY/CODING/TESTBENCH/ltetest.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/TESTBENCH/pdcch_test.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/TESTBENCH/viterbi_test.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/ccoding_byte.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/ccoding_byte_lte.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/coding_load.c

@@ -0,0 +1,183 @@
+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+/*! \file openair1/PHY/CODING
+ * \brief: load library implementing coding/decoding algorithms
+ * \author Francois TABURET
+ * \date 2017
+ * \version 0.1
+ * \company NOKIA BellLabs France
+ * \email: francois.taburet@nokia-bell-labs.com
+ * \note
+ * \warning
+ */
+#define _GNU_SOURCE 
+#include <sys/types.h>
+
+
+#include "PHY/defs.h"
+#include "PHY/extern.h"
+#include "common/utils/load_module_shlib.h" 
+#include "common/utils/telnetsrv/telnetsrv.h" 
+
+static int coding_setmod_cmd(char *buff, int debug, telnet_printfunc_t prnt);
+static telnetshell_cmddef_t coding_cmdarray[] = {
+   {"mode","[sse,avx2,stdc,none]",coding_setmod_cmd},
+   {"","",NULL},
+};
+telnetshell_vardef_t coding_vardef[] = {
+{"maxiter",TELNET_VARTYPE_INT32,&max_turbo_iterations},
+{"",0,NULL}
+};
+/* PHY/defs.h contains MODE_DECODE_XXX macros, following table must match */
+static char *modedesc[] = {"none","sse","C","avx2"};
+static int curmode;
+/* function description array, to be used when loading the encoding/decoding shared lib */
+loader_shlibfunc_t shlib_fdesc[DECODE_NUM_FPTR];
+
+/* encoding decoding functions pointers, filled here and used when encoding/decoding */
+/*defined as extern in PHY?CODING/extern.h */
+decoder_if_t    decoder16;
+decoder_if_t    decoder8;
+encoder_if_t    encoder;
+
+extern int _may_i_use_cpu_feature(unsigned __int64);
+uint8_t  nodecod(short *y,
+    short *y2,
+    unsigned char *decoded_bytes,
+    unsigned char *decoded_bytes2,
+    unsigned short n,
+    unsigned short f1,
+    unsigned short f2,
+    unsigned char max_iterations,
+    unsigned char crc_type,
+    unsigned char F,
+    time_stats_t *init_stats,
+    time_stats_t *alpha_stats,
+    time_stats_t *beta_stats,
+    time_stats_t *gamma_stats,
+    time_stats_t *ext_stats,
+    time_stats_t *intl1_stats,
+    time_stats_t *intl2_stats)
+{
+ return max_iterations+1;
+};
+
+void decoding_setmode (int mode) {
+   switch (mode) {
+       case MODE_DECODE_NONE:
+          decoder8=nodecod;
+          decoder16=nodecod;
+          encoder=(encoder_if_t)shlib_fdesc[ENCODE_C_FPTRIDX].fptr;
+       break;
+       case MODE_DECODE_C:
+          decoder16=(decoder_if_t)shlib_fdesc[DECODE_TD_C_FPTRIDX].fptr;
+          decoder8=(decoder_if_t)shlib_fdesc[DECODE_TD_C_FPTRIDX].fptr;
+          encoder=(encoder_if_t)shlib_fdesc[ENCODE_C_FPTRIDX].fptr;   
+       break;
+       case MODE_DECODE_AVX2:
+          decoder16=(decoder_if_t)shlib_fdesc[DECODE_TD16_AVX2_FPTRIDX].fptr;
+          decoder8=(decoder_if_t)shlib_fdesc[DECODE_TD8_SSE_FPTRIDX].fptr; 
+          encoder=(encoder_if_t)shlib_fdesc[ENCODE_SSE_FPTRIDX].fptr;  
+       break;
+       default:
+           mode=MODE_DECODE_SSE;
+       case MODE_DECODE_SSE:
+          decoder8=(decoder_if_t)shlib_fdesc[DECODE_TD8_SSE_FPTRIDX].fptr; 
+          decoder16=(decoder_if_t)shlib_fdesc[DECODE_TD16_SSE_FPTRIDX].fptr;
+          encoder=(encoder_if_t)shlib_fdesc[ENCODE_SSE_FPTRIDX].fptr;
+       break;
+   }
+   curmode=mode;
+}
+
+
+int load_codinglib(void) {
+ int ret;
+ 
+     memset(shlib_fdesc,0,sizeof(shlib_fdesc));
+     shlib_fdesc[DECODE_INITTD8_SSE_FPTRIDX].fname = "init_td8";
+     shlib_fdesc[DECODE_INITTD16_SSE_FPTRIDX].fname= "init_td16";
+     shlib_fdesc[DECODE_INITTD_AVX2_FPTRIDX].fname="init_td16avx2";
+
+     shlib_fdesc[DECODE_TD8_SSE_FPTRIDX].fname=   "phy_threegpplte_turbo_decoder8";
+     shlib_fdesc[DECODE_TD16_SSE_FPTRIDX].fname=  "phy_threegpplte_turbo_decoder16";
+     shlib_fdesc[DECODE_TD_C_FPTRIDX].fname=      "phy_threegpplte_turbo_decoder_scalar";
+     shlib_fdesc[DECODE_TD16_AVX2_FPTRIDX].fname= "phy_threegpplte_turbo_decoder16avx2";
+
+
+     shlib_fdesc[DECODE_FREETD8_FPTRIDX].fname =    "free_td8";
+     shlib_fdesc[DECODE_FREETD16_FPTRIDX].fname=    "free_td16";
+     shlib_fdesc[DECODE_FREETD_AVX2_FPTRIDX].fname= "free_td16avx2";    
+
+     shlib_fdesc[ENCODE_SSE_FPTRIDX].fname=    "threegpplte_turbo_encoder_sse";
+     shlib_fdesc[ENCODE_C_FPTRIDX].fname=      "threegpplte_turbo_encoder";
+     shlib_fdesc[ENCODE_INIT_SSE_FPTRIDX].fname=       "init_encoder_sse";
+     ret=load_module_shlib("coding",shlib_fdesc,DECODE_NUM_FPTR);
+     if (ret < 0) exit_fun("Error loading coding library");
+
+/* execute encoder/decoder init functions */     
+     shlib_fdesc[DECODE_INITTD8_SSE_FPTRIDX].fptr();
+     shlib_fdesc[DECODE_INITTD16_SSE_FPTRIDX].fptr();
+     if(shlib_fdesc[DECODE_INITTD_AVX2_FPTRIDX].fptr != NULL) {
+        shlib_fdesc[DECODE_INITTD_AVX2_FPTRIDX].fptr();
+     }
+     if(shlib_fdesc[ENCODE_INIT_SSE_FPTRIDX].fptr != NULL) {
+        shlib_fdesc[ENCODE_INIT_SSE_FPTRIDX].fptr();
+     }
+     decoding_setmode(MODE_DECODE_SSE);
+/* look for telnet server, if it is loaded, add the coding commands to it */
+     add_telnetcmd_func_t addcmd = (add_telnetcmd_func_t)get_shlibmodule_fptr("telnetsrv", TELNET_ADDCMD_FNAME);
+     if (addcmd != NULL) {
+         addcmd("coding",coding_vardef,coding_cmdarray); 
+     }
+return 0;
+}
+
+void free_codinglib(void) {
+
+     shlib_fdesc[DECODE_FREETD8_FPTRIDX].fptr();
+     shlib_fdesc[DECODE_FREETD16_FPTRIDX].fptr();
+     shlib_fdesc[DECODE_FREETD_AVX2_FPTRIDX].fptr();
+
+
+}
+
+/* functions for telnet support, when telnet server is loaded */
+int coding_setmod_cmd(char *buff, int debug, telnet_printfunc_t prnt)
+{
+   if (debug > 0)
+       prnt( "coding_setmod_cmd received %s\n",buff);
+
+      if (strcasestr(buff,"sse") != NULL) {
+         decoding_setmode(MODE_DECODE_SSE);
+      } else if (strcasestr(buff,"avx2") != NULL) {
+         decoding_setmode(MODE_DECODE_AVX2);
+      } else if (strcasestr(buff,"stdc") != NULL) {
+         decoding_setmode(MODE_DECODE_C);
+      } else if (strcasestr(buff,"none") != NULL) {
+         decoding_setmode(MODE_DECODE_NONE);
+      } else {
+          prnt("%s: wrong setmod parameter...\n",buff);
+      }
+   prnt("Coding and decoding current mode: %s\n",modedesc[curmode]);
+   return 0;
+}

openair1/PHY/CODING/crc_byte.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -31,13 +31,6 @@
 */
 
 
-#ifndef USER_MODE
-#define __NO_VERSION__
-
-#endif
-
-//#include "PHY/types.h"
-
 #include "defs.h"
 
 
@@ -116,7 +109,7 @@ crc24a (unsigned char * inptr, int bitlen)
   resbit = (bitlen % 8);
 
   while (octetlen-- > 0) {
-    //    printf("in %x => crc %x\n",crc,*inptr);
+    //   printf("crc24a: in %x => crc %x\n",crc,*inptr);
     crc = (crc << 8) ^ crc24aTable[(*inptr++) ^ (crc >> 24)];
   }
 
@@ -135,6 +128,7 @@ unsigned int crc24b (unsigned char * inptr, int bitlen)
   resbit = (bitlen % 8);
 
   while (octetlen-- > 0) {
+    //    printf("crc24b: in %x => crc %x (%x)\n",crc,*inptr,crc24bTable[(*inptr) ^ (crc >> 24)]);
     crc = (crc << 8) ^ crc24bTable[(*inptr++) ^ (crc >> 24)];
   }
 

openair1/PHY/CODING/defs.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -29,11 +29,7 @@
 
 #include <stdint.h>
 
-#ifndef NO_OPENAIR1
 #include "PHY/defs.h"
-#else
-#include "PHY/TOOLS/time_meas.h"
-#endif
 
 #define CRC24_A 0
 #define CRC24_B 1
@@ -41,7 +37,7 @@
 #define CRC8 3
 
 #define MAX_TURBO_ITERATIONS_MBSFN 8
-#define MAX_TURBO_ITERATIONS 4
+#define MAX_TURBO_ITERATIONS max_turbo_iterations
 
 #define LTE_NULL 2
 
@@ -296,25 +292,9 @@ void ccodedot11_init(void);
 \brief This function initializes the trellis structure for decoding an 802.11 convolutional code.*/
 void ccodedot11_init_inv(void);
 
-/*!\fn void teillis_table_init(void)
-\brief This function initializes the trellis structure for 3GPP LTE Turbo code.*/
-void treillis_table_init(void);
 
-/*\fn void threegpplte_turbo_encoder(uint8_t *input,uint16_t input_length_bytes,uint8_t *output,uint8_t F,uint16_t interleaver_f1,uint16_t interleaver_f2)
-\brief This function implements a rate 1/3 8-state parralel concatenated turbo code (3GPP-LTE).
-@param input Pointer to input buffer
-@param input_length_bytes Number of bytes to encode
-@param output Pointer to output buffer
-@param F Number of filler bits at input
-@param interleaver_f1 F1 generator
-@param interleaver_f2 F2 generator
-*/
-void threegpplte_turbo_encoder(uint8_t *input,
-                               uint16_t input_length_bytes,
-                               uint8_t *output,
-                               uint8_t F,
-                               uint16_t interleaver_f1,
-                               uint16_t interleaver_f2);
+
+
 
 
 /** \fn void ccodelte_encode(int32_t numbits,uint8_t add_crc, uint8_t *inPtr,uint8_t *outPtr,uint16_t rnti)
@@ -356,26 +336,8 @@ void ccodedab_init_inv(void);
 \brief This function initializes the different crc tables.*/
 void crcTableInit (void);
 
-/*!\fn void init_td8(void)
-\brief This function initializes the tables for 8-bit LLR Turbo decoder.*/
-void init_td8 (void);
 
 
-/*!\fn void init_td16(void)
-\brief This function initializes the tables for 16-bit LLR Turbo decoder.*/
-void init_td16 (void);
-
-#ifdef __AVX2__
-/*!\fn void init_td8(void)
-\brief This function initializes the tables for 8-bit LLR Turbo decoder (AVX2).*/
-void init_td8avx2 (void);
-
-
-/*!\fn void init_td16(void)
-\brief This function initializes the tables for 16-bit LLR Turbo decoder (AVX2).*/
-void init_td16avx2 (void);
-#endif
-
 /*!\fn uint32_t crc24a(uint8_t *inPtr, int32_t bitlen)
 \brief This computes a 24-bit crc ('a' variant for overall transport block)
 based on 3GPP UMTS/LTE specifications.
@@ -464,95 +426,7 @@ int32_t rate_matching_lte(uint32_t N_coded,
                           uint32_t off);
 
 
-/*!
-\brief This routine performs max-logmap detection for the 3GPP turbo code (with termination).  It is optimized for SIMD processing and 16-bit
-LLR arithmetic, and requires SSE2,SSSE3 and SSE4.1 (gcc >=4.3 and appropriate CPU)
-@param y LLR input (16-bit precision)
-@param decoded_bytes Pointer to decoded output
-@param n number of coded bits (including tail bits)
-@param max_iterations The maximum number of iterations to perform
-@param interleaver_f1 F1 generator
-@param interleaver_f2 F2 generator
-@param crc_type Length of 3GPPLTE crc (CRC24a,CRC24b,CRC16,CRC8)
-@param F Number of filler bits at start of packet
-@returns number of iterations used (this is 1+max if incorrect crc or if crc_len=0)
-*/
-uint8_t phy_threegpplte_turbo_decoder16(int16_t *y,
-                                        uint8_t *decoded_bytes,
-                                        uint16_t n,
-                                        uint16_t interleaver_f1,
-                                        uint16_t interleaver_f2,
-                                        uint8_t max_iterations,
-                                        uint8_t crc_type,
-                                        uint8_t F,
-                                        time_stats_t *init_stats,
-                                        time_stats_t *alpha_stats,
-                                        time_stats_t *beta_stats,
-                                        time_stats_t *gamma_stats,
-                                        time_stats_t *ext_stats,
-                                        time_stats_t *intl1_stats,
-                                        time_stats_t *intl2_stats);
 
-uint8_t phy_threegpplte_turbo_decoder16avx2(int16_t *y,
-					    int16_t *y2,
-					    uint8_t *decoded_bytes,
-					    uint8_t *decoded_bytes2,
-					    uint16_t n,
-					    uint16_t interleaver_f1,
-					    uint16_t interleaver_f2,
-					    uint8_t max_iterations,
-					    uint8_t crc_type,
-					    uint8_t F,
-					    time_stats_t *init_stats,
-					    time_stats_t *alpha_stats,
-					    time_stats_t *beta_stats,
-					    time_stats_t *gamma_stats,
-					    time_stats_t *ext_stats,
-					    time_stats_t *intl1_stats,
-					    time_stats_t *intl2_stats);
-
-/*!
-\brief This routine performs max-logmap detection for the 3GPP turbo code (with termination).  It is optimized for SIMD processing and 8-bit
-LLR arithmetic, and requires SSE2,SSSE3 and SSE4.1 (gcc >=4.3 and appropriate CPU)
-@param y LLR input (16-bit precision)
-@param decoded_bytes Pointer to decoded output
-@param n number of coded bits (including tail bits)
-@param max_iterations The maximum number of iterations to perform
-@param interleaver_f1 F1 generator
-@param interleaver_f2 F2 generator
-@param crc_type Length of 3GPPLTE crc (CRC24a,CRC24b,CRC16,CRC8)
-@param F Number of filler bits at start of packet
-@returns number of iterations used (this is 1+max if incorrect crc or if crc_len=0)
-*/
-uint8_t phy_threegpplte_turbo_decoder8(int16_t *y,
-                                       uint8_t *decoded_bytes,
-                                       uint16_t n,
-                                       uint16_t interleaver_f1,
-                                       uint16_t interleaver_f2,
-                                       uint8_t max_iterations,
-                                       uint8_t crc_type,
-                                       uint8_t F,
-                                       time_stats_t *init_stats,
-                                       time_stats_t *alpha_stats,
-                                       time_stats_t *beta_stats,
-                                       time_stats_t *gamma_stats,
-                                       time_stats_t *ext_stats,
-                                       time_stats_t *intl1_stats,
-                                       time_stats_t *intl2_stats);
-
-uint8_t phy_threegpplte_turbo_decoder_scalar(int16_t *y,
-    uint8_t *decoded_bytes,
-    uint16_t n,
-    uint16_t interleaver_f1,
-    uint16_t interleaver_f2,
-    uint8_t max_iterations,
-    uint8_t crc_type,
-    uint8_t F,
-    uint8_t inst);
-
-
-
-/** @} */
 
 uint32_t crcbit (uint8_t * ,
                  int32_t,

openair1/PHY/CODING/defs_NB_IoT.h

@@ -0,0 +1,275 @@
+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+/* file: PHY/CODING/defs_NB_IoT.h
+   purpose: Top-level definitions, data types and function prototypes for openairinterface coding blocks for NB-IoT
+   author: matthieu.kanj@b-com.com, raymond.knopp@eurecom.fr, michele.paffetti@studio.unibo.it
+   date: 29.06.2017
+*/
+
+#ifndef OPENAIR1_PHY_CODING_DEFS_NB_IOT_H_
+#define OPENAIR1_PHY_CODING_DEFS_NB_IOT_H_
+
+#include <stdint.h>  // for uint8/16/32_t
+
+/* check if this ifndef is required for NB-IoT ?!
+//#ifndef NO_OPENAIR1
+//#include "PHY/defs_NB_IoT.h"
+//#else
+//#include "PHY/TOOLS/time_meas.h"
+//#endif
+*/
+
+#define CRC24_A_NB_IoT 0
+#define CRC24_B_NB_IoT 1
+#define CRC16_NB_IoT 2
+#define CRC8_NB_IoT 3
+
+//#define MAX_TURBO_ITERATIONS_MBSFN 8  // no MBSFN
+#define MAX_TURBO_ITERATIONS_NB_IoT 4
+
+#define LTE_NULL_NB_IoT 2  // defined also in PHY/LTE_TRANSPORT/defs_NB_IoT.h
+
+/** \fn uint32_t sub_block_interleaving_cc(uint32_t D, uint8_t *d,uint8_t *w)
+\brief This is the subblock interleaving algorithm for convolutionally coded blocks from 36-212 (Release 13.4, 2017).
+This function takes the d-sequence and generates the w-sequence.  The nu-sequence from 36-212 is implicit.
+\param D Number of input bits
+\param d Pointer to input (d-sequence, convolutional code output)
+\param w Pointer to output (w-sequence, interleaver output)
+\returns Interleaving matrix cardinality (\f$K_{\pi}\f$  from 36-212)
+*/
+uint32_t sub_block_interleaving_cc_NB_IoT(uint32_t D, uint8_t *d,uint8_t *w);
+
+/**
+\brief This is the NB-IoT rate matching algorithm for Convolutionally-coded channels (e.g. BCH,DCI,UCI).  It is taken directly from 36-212 (Rel 8 8.6, 2009-03), pages 16-18 )
+\param RCC R^CC_subblock from subblock interleaver (number of rows in interleaving matrix) for up to 8 segments
+\param E Number of coded channel bits
+\param w This is a pointer to the w-sequence (second interleaver output)
+\param e This is a pointer to the e-sequence (rate matching output, channel input/output bits)
+\returns \f$E\f$, the number of coded bits per segment */
+
+uint32_t lte_rate_matching_cc_NB_IoT(uint32_t RCC,      // RRC = 2
+				     				 uint16_t E,        // E = 1600
+				     				 uint8_t *w,	// length
+				    				 uint8_t *e);	// length 1600
+
+/** \fn void ccodelte_encode(int32_t numbits,uint8_t add_crc, uint8_t *inPtr,uint8_t *outPtr,uint16_t rnti)
+\brief This function implements the LTE convolutional code of rate 1/3
+  with a constraint length of 7 bits. The inputs are bit packed in octets
+(from MSB to LSB). Trellis tail-biting is included here.
+@param numbits Number of bits to encode
+@param add_crc crc to be appended (8 bits) if add_crc = 1
+@param inPtr Pointer to input buffer
+@param outPtr Pointer to output buffer
+@param rnti RNTI for CRC scrambling
+*/
+
+void ccode_encode_NB_IoT (int32_t numbits,
+						  uint8_t add_crc,
+						  uint8_t *inPtr,
+						  uint8_t *outPtr,
+						  uint16_t rnti);
+
+/*!\fn void ccodelte_init(void)
+\brief This function initializes the generator polynomials for an LTE convolutional code.*/
+void ccodelte_init_NB_IoT(void);
+
+/*!\fn void crcTableInit(void)
+\brief This function initializes the different crc tables.*/
+void crcTableInit_NB_IoT (void);
+
+
+/*!\fn uint32_t crc24a(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 24-bit crc ('a' variant for overall transport block)
+based on 3GPP UMTS/LTE specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits
+*/
+uint32_t crc24a_NB_IoT (uint8_t *inPtr, int32_t bitlen);
+
+/*!\fn uint32_t crc24b(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 24-bit crc ('b' variant for transport-block segments)
+based on 3GPP UMTS/LTE specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits
+*/
+uint32_t crc24b_NB_IoT (uint8_t *inPtr, int32_t bitlen);
+
+/*!\fn uint32_t crc16(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 16-bit crc based on 3GPP UMTS specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits*/
+uint32_t crc16_NB_IoT (uint8_t *inPtr, int32_t bitlen);
+
+/*!\fn uint32_t crc8(uint8_t *inPtr, int32_t bitlen)
+\brief This computes a 8-bit crc based on 3GPP UMTS specifications.
+@param inPtr Pointer to input byte stream
+@param bitlen length of inputs in bits*/
+uint32_t crc8_NB_IoT  (uint8_t *inPtr, int32_t bitlen);
+
+
+
+
+
+
+uint32_t crcbit_NB_IoT (uint8_t * ,
+                 		int32_t,
+                 		uint32_t);
+
+
+/*!\fn void phy_viterbi_lte_sse2(int8_t *y, uint8_t *decoded_bytes, uint16_t n)
+\brief This routine performs a SIMD optmized Viterbi decoder for the LTE 64-state tail-biting convolutional code.
+@param y Pointer to soft input (coded on 8-bits but should be limited to 4-bit precision to avoid overflow)
+@param decoded_bytes Pointer to decoded output
+@param n Length of input/trellis depth in bits*/
+//void phy_viterbi_lte_sse2(int8_t *y,uint8_t *decoded_bytes,uint16_t n);
+void phy_viterbi_lte_sse2_NB_IoT(int8_t *y,uint8_t *decoded_bytes,uint16_t n);
+
+/** \fn void sub_block_deinterleaving_cc(uint32_t D, int8_t *d,int8_t *w)
+\brief This is the subblock deinterleaving algorithm for convolutionally-coded data from 36-212 (Release 8, 8.6 2009-03), pages 15-16.
+This function takes the w-sequence and generates the d-sequence.  The nu-sequence from 36-212 is implicit.
+\param D Number of input bits
+\param d Pointer to output (d-sequence, turbo code output)
+\param w Pointer to input (w-sequence, interleaver output)
+*/
+void sub_block_deinterleaving_cc_NB_IoT(uint32_t D,int8_t *d,int8_t *w);
+
+
+/*
+\brief This is the LTE rate matching algorithm for Convolutionally-coded channels (e.g. BCH,DCI,UCI).  It is taken directly from 36-212 (Rel 8 8.6, 2009-03), pages 16-18 )
+\param RCC R^CC_subblock from subblock interleaver (number of rows in interleaving matrix)
+\param E This the number of coded bits allocated for channel
+\param w This is a pointer to the soft w-sequence (second interleaver output) with soft-combined outputs from successive HARQ rounds
+\param dummy_w This is the first row of the interleaver matrix for identifying/discarding the "LTE-NULL" positions
+\param soft_input This is a pointer to the soft channel output
+\returns \f$E\f$, the number of coded bits per segment
+*/
+void lte_rate_matching_cc_rx_NB_IoT(uint32_t RCC,
+                             		uint16_t E,
+                             		int8_t *w,
+                             		uint8_t *dummy_w,
+                             		int8_t *soft_input);
+
+/** \fn generate_dummy_w_cc(uint32_t D, uint8_t *w)
+\brief This function generates a dummy interleaved sequence (first row) for receiver (convolutionally-coded data), in order to identify the NULL positions used to make the matrix complete.
+\param D Number of systematic bits plus 4 (plus 4 for termination)
+\param w This is the dummy sequence (first row), it will contain zeros and at most 31 "LTE_NULL" values
+\returns Interleaving matrix cardinality (\f$K_{\pi}\f$ from 36-212)
+*/
+uint32_t generate_dummy_w_cc_NB_IoT(uint32_t D, uint8_t *w);
+
+/** \fn lte_segmentation(uint8_t *input_buffer,
+              uint8_t **output_buffers,
+            uint32_t B,
+            uint32_t *C,
+            uint32_t *Cplus,
+            uint32_t *Cminus,
+            uint32_t *Kplus,
+            uint32_t *Kminus,
+            uint32_t *F)
+\brief This function implements the LTE transport block segmentation algorithm from 36-212, V8.6 2009-03.
+@param input_buffer
+@param output_buffers
+@param B
+@param C
+@param Cplus
+@param Cminus
+@param Kplus
+@param Kminus
+@param F
+*/
+int32_t lte_segmentation_NB_IoT(uint8_t *input_buffer,
+                         		uint8_t **output_buffers,
+                         		uint32_t B,
+                         		uint32_t *C,
+                         		uint32_t *Cplus,
+                         		uint32_t *Cminus,
+                         		uint32_t *Kplus,
+                         		uint32_t *Kminus,
+                         		uint32_t *F);
+
+/** \fn void sub_block_deinterleaving_turbo(uint32_t D, int16_t *d,int16_t *w)
+\brief This is the subblock deinterleaving algorithm from 36-212 (Release 8, 8.6 2009-03), pages 15-16.
+This function takes the w-sequence and generates the d-sequence.  The nu-sequence from 36-212 is implicit.
+\param D Number of systematic bits plus 4 (plus 4 for termination)
+\param d Pointer to output (d-sequence, turbo code output)
+\param w Pointer to input (w-sequence, interleaver output)
+*/
+//*****************void sub_block_deinterleaving_turbo(uint32_t D, int16_t *d,int16_t *w);
+
+/**
+\brief This is the LTE rate matching algorithm for Turbo-coded channels (e.g. DLSCH,ULSCH).  It is taken directly from 36-212 (Rel 8 8.6, 2009-03), pages 16-18 )
+\param RTC R^TC_subblock from subblock interleaver (number of rows in interleaving matrix)
+\param G This the number of coded transport bits allocated in sub-frame
+\param w This is a pointer to the soft w-sequence (second interleaver output) with soft-combined outputs from successive HARQ rounds
+\param dummy_w This is the first row of the interleaver matrix for identifying/discarding the "LTE-NULL" positions
+\param soft_input This is a pointer to the soft channel output
+\param C Number of segments (codewords) in the sub-frame
+\param Nsoft Total number of soft bits (from UE capabilities in 36-306)
+\param Mdlharq Number of HARQ rounds
+\param Kmimo MIMO capability for this DLSCH (0 = no MIMO)
+\param rvidx round index (0-3)
+\param clear 1 means clear soft buffer (start of HARQ round)
+\param Qm modulation order (2,4,6)
+\param Nl number of layers (1,2)
+\param r segment number
+\param E_out the number of coded bits per segment
+\returns 0 on success, -1 on failure
+*/
+
+// int lte_rate_matching_turbo_rx(uint32_t RTC,
+//                                uint32_t G,
+//                                int16_t *w,
+//                                uint8_t *dummy_w,
+//                                int16_t *soft_input,
+//                                uint8_t C,
+//                                uint32_t Nsoft,
+//                                uint8_t Mdlharq,
+//                                uint8_t Kmimo,
+//                                uint8_t rvidx,
+//                                uint8_t clear,
+//                                uint8_t Qm,
+//                                uint8_t Nl,
+//                                uint8_t r,
+//                                uint32_t *E_out);
+
+// uint32_t lte_rate_matching_turbo_rx_abs(uint32_t RTC,
+//                                         uint32_t G,
+//                                         double *w,
+//                                         uint8_t *dummy_w,
+//                                         double *soft_input,
+//                                         uint8_t C,
+//                                         uint32_t Nsoft,
+//                                         uint8_t Mdlharq,
+//                                         uint8_t Kmimo,
+//                                         uint8_t rvidx,
+//                                         uint8_t clear,
+//                                         uint8_t Qm,
+//                                         uint8_t Nl,
+//                                         uint8_t r,
+//                                         uint32_t *E_out);
+
+void ccode_encode_npdsch_NB_IoT (int32_t   numbits,
+								 uint8_t   *inPtr,
+								 uint8_t   *outPtr,
+								 uint32_t  crc);
+
+#endif /* OPENAIR1_PHY_CODING_DEFS_NB_IOT_H_ */

openair1/PHY/CODING/extern.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -20,5 +20,9 @@
  */
 
 extern unsigned short f1f2mat_old[2*188];
-
-
+extern double cpuf;
+extern decoder_if_t decoder16;
+extern decoder_if_t decoder8;
+extern encoder_if_t encoder;
+extern int load_codinglib(void);
+extern int free_codinglib(void);

openair1/PHY/CODING/extern_3GPPinterleaver.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/lte_interleaver.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/lte_interleaver2.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/lte_interleaver_inline.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/lte_rate_matching.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -463,7 +463,7 @@ uint32_t lte_rate_matching_turbo(uint32_t RTC,
                                  uint8_t Qm,
                                  uint8_t Nl,
                                  uint8_t r,
-                                 uint8_t nb_rb) 
+                                 uint8_t nb_rb)
 //                                 uint8_t m)
 {
 
@@ -513,7 +513,7 @@ uint32_t lte_rate_matching_turbo(uint32_t RTC,
   //    counter_buffer[rvidx][cnt]=0;
   if (Ncb>(3*(RTC<<5)))
     AssertFatal(1==0,"Exiting, RM condition (Ncb %d, RTC %d, Nir/C %d, Nsoft %d, Kw %d)\n",Ncb,RTC,Nir/C,Nsoft,3*(RTC<<5));
-  
+
   AssertFatal(Nl>0,"Nl is 0\n");
   AssertFatal(Qm>0,"Qm is 0\n");
   Gp = G/Nl/Qm;
@@ -749,6 +749,10 @@ int lte_rate_matching_turbo_rx(uint32_t RTC,
 
   for (; (ind<Ncb)&&(k<E); ind++) {
     if (dummy_w[ind] != LTE_NULL) {
+      /*
+      if ((w[ind]>0 && soft_input2[k]<0) ||
+	  (w[ind]<0 && soft_input2[k]>0))
+	  printf("ind %d: w %d => soft_in %d\n",ind,w[ind],soft_input2[k]);*/
       w[ind] += soft_input2[k++];
 #ifdef RM_DEBUG
       printf("RM_RX k%d Ind: %d (%d)\n",k-1,ind,w[ind]);

openair1/PHY/CODING/lte_segmentation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/scrambler.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/vars.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/viterbi.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/CODING/viterbi_lte.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -28,10 +28,6 @@
    date: 21.10.2009
 */
 
-#ifdef USER_MODE
-#include <stdio.h>
-#endif
-
 #ifndef TEST_DEBUG
 #include "PHY/defs.h"
 #include "PHY/extern.h"
@@ -126,7 +122,7 @@ void print_shorts(__m128i x,char *s) {
 
 }
 */
-#endif // USER_MODE
+#endif // DEBUG_VITERBI
 
 
 

openair1/PHY/INIT/defs.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -65,7 +65,7 @@ int phy_init_top(LTE_DL_FRAME_PARMS *frame_parms);
 @returns -1 if any memory allocation failed
 @note The current implementation will never return -1, but segfault.
  */
-int phy_init_lte_ue_signal(PHY_VARS_UE *phy_vars_ue,
+int init_lte_ue_signal(PHY_VARS_UE *phy_vars_ue,
 			   int          nb_connected_eNB,
 			   uint8_t         abstraction_flag);
 
@@ -90,6 +90,13 @@ int phy_init_lte_eNB(PHY_VARS_eNB *phy_vars_eNb,
                      unsigned char is_secondary_eNb,
                      unsigned char abstraction_flag);
 
+/*!
+\brief Free the PHY variables relevant to the LTE implementation (eNB).
+\details Only a subset of phy_vars_eNb is freed (those who have been allocated with phy_init_lte_eNB()).
+@param[in] phy_vars_eNb Pointer to eNB Variables
+ */
+void phy_free_lte_eNB(PHY_VARS_eNB *phy_vars_eNb);
+
 /** \brief Configure LTE_DL_FRAME_PARMS with components derived after initial synchronization (MIB decoding + primary/secondary synch).
 \details The basically allows configuration of \f$N_{\mathrm{RB}}^{\mathrm{DL}}\f$, the cell id  \f$N_{\mathrm{ID}}^{\mathrm{cell}}\f$, the normal/extended prefix mode, the frame type (FDD/TDD), \f$N_{\mathrm{cp}}\f$, the number of TX antennas at eNB (\f$p\f$) and the number of PHICH groups, \f$N_{\mathrm{group}}^{\mathrm{PHICH}}\f$
 @param lte_frame_parms pointer to LTE parameter structure
@@ -317,24 +324,31 @@ void phy_config_dedicated_eNB_step2(PHY_VARS_eNB *phy_vars_eNB);
  */
 int phy_init_secsys_eNB(PHY_VARS_eNB *phy_vars_eNb);
 
+void free_lte_top(void);
 
 void init_lte_top(LTE_DL_FRAME_PARMS *lte_frame_parms);
 
 //void copy_lte_parms_to_phy_framing(LTE_DL_FRAME_PARMS *frame_parm, PHY_FRAMING *phy_framing);
 
-void lte_param_init(unsigned char N_tx_port_eNB,
-		    unsigned char N_tx, 
-		    unsigned char N_rx,
+void lte_param_init(PHY_VARS_eNB **eNBp,
+		    PHY_VARS_UE **UEp,
+		    RU_t **rup,
+		    unsigned char N_tx_port_eNB,
+                    unsigned char N_tx_phy,
+		    unsigned char N_rx_ru,
+		    unsigned char N_rx_ue,
 		    unsigned char transmission_mode,
 		    uint8_t extended_prefix_flag,
-		    frame_t frame_type, 
+		    frame_t frame_type,
 		    uint16_t Nid_cell,
 		    uint8_t tdd_config,
 		    uint8_t N_RB_DL,
+		    uint8_t pa,
 		    uint8_t threequarter_fs,
                     uint8_t osf,
 		    uint32_t perfect_ce);
 
+
 #if defined(Rel10) || defined(Rel14)
 void phy_config_dedicated_scell_ue(uint8_t Mod_id,
                                    uint8_t eNB_index,
@@ -359,18 +373,6 @@ void phy_config_request(PHY_Config_t *phy_config);
 int init_frame_parms(LTE_DL_FRAME_PARMS *frame_parms,uint8_t osf);
 void dump_frame_parms(LTE_DL_FRAME_PARMS *frame_parms);
 
-void lte_param_init(unsigned char N_tx_port_eNB, 
-                    unsigned char N_tx_phy,
-		    unsigned char N_rx,
-		    unsigned char transmission_mode,
-		    uint8_t extended_prefix_flag,
-		    frame_t frame_type, 
-		    uint16_t Nid_cell,
-		    uint8_t tdd_config,
-		    uint8_t N_RB_DL,
-		    uint8_t threequarter_fs,
-                    uint8_t osf,
-		    uint32_t perfect_ce);
 /** @} */
 #endif
 

openair1/PHY/INIT/defs_NB_IoT.h

@@ -0,0 +1,77 @@
+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+
+#ifndef __INIT_DEFS_NB_IOT__H__
+#define __INIT_DEFS_NB_IOT__H__
+
+//#include "PHY/defs_NB_IoT.h"
+#include "openair2/PHY_INTERFACE/IF_Module_NB_IoT.h"  
+#include "nfapi_interface.h"  
+
+//#include "SystemInformationBlockType2.h"
+//#include "RadioResourceConfigCommonSIB.h"
+//#include "RadioResourceConfigDedicated.h"
+//#include "TDD-Config.h"
+//#include "MBSFN-SubframeConfigList.h"
+//#include "MobilityControlInfo.h"
+//#if defined(Rel10) || defined(Rel14)
+//#include "SCellToAddMod-r10.h"
+//#endif
+
+/*brief Configure LTE_DL_FRAME_PARMS with components derived after initial synchronization (MIB-NB decoding + primary/secondary synch).*/
+void phy_config_mib_eNB_NB_IoT(int  		Mod_id,
+						   	   int          eutra_band,
+						       int          Nid_cell,
+						       int          Ncp,
+						       int			Ncp_UL,
+						       int          p_eNB,
+						       uint16_t		EARFCN,
+						       uint16_t		prb_index, // NB_IoT_RB_ID,
+						       uint16_t 	operating_mode,
+						       uint16_t		control_region_size,
+						       uint16_t		eutra_NumCRS_ports);
+
+/*NB_phy_config_sib1_eNB is not needed since NB-IoT use only FDD mode*/
+
+/*brief Configure LTE_DL_FRAME_PARMS with components of SIB2-NB (at eNB).*/
+
+//void NB_phy_config_sib2_eNB(module_id_t                            Mod_id,
+//                         int                                		CC_id,
+//                         RadioResourceConfigCommonSIB_NB_r13_t      *radioResourceConfigCommon
+//                         );
+
+void phy_config_sib2_eNB_NB_IoT(uint8_t Mod_id,
+				nfapi_nb_iot_config_t *config,
+				nfapi_rf_config_t *rf_config,
+				nfapi_uplink_reference_signal_config_t* ul_nrs_config,
+				extra_phyConfig_t* extra_phy_parms);
+
+void phy_config_dedicated_eNB_NB_IoT(module_id_t Mod_id,
+				     rnti_t rnti,
+				     extra_phyConfig_t* extra_phy_parms); 
+
+// void phy_init_lte_top_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms); 
+void phy_init_nb_iot_eNB(PHY_VARS_eNB_NB_IoT *phyvar);
+int l1_north_init_NB_IoT(void);
+
+#endif
+

openair1/PHY/INIT/extern.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/INIT/init_top.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -20,25 +20,49 @@
  */
 
 /*!\brief Initilization and reconfiguration routines for LTE PHY */
-#ifndef USER_MODE
-#define __NO_VERSION__
-#endif
-
 #include "defs.h"
 #include "PHY/extern.h"
-#include "MAC_INTERFACE/extern.h"
-//#include "ARCH/CBMIMO1/DEVICE_DRIVER/extern.h"
+#include "PHY/CODING/extern.h"
+void init_lte_top(LTE_DL_FRAME_PARMS *frame_parms)
+{
 
-/*!
-* @addtogroup _PHY_STRUCTURES_
-* Memory Initializaion and Cleanup for LTE MODEM.
-* @{
-\section _Memory_init_ Memory Initialization for LTE MODEM
+  crcTableInit();
 
-*/
+  ccodedot11_init();
+  ccodedot11_init_inv();
 
-//#define DEBUG_PHY
-t
+  ccodelte_init();
+  ccodelte_init_inv();
+
+
+
+  phy_generate_viterbi_tables();
+  phy_generate_viterbi_tables_lte();
+
+  load_codinglib();
+  lte_sync_time_init(frame_parms);
+
+  generate_ul_ref_sigs();
+  generate_ul_ref_sigs_rx();
+
+  generate_64qam_table();
+  generate_16qam_table();
+  generate_RIV_tables();
+
+  init_unscrambling_lut();
+  init_scrambling_lut();
+  //set_taus_seed(1328);
+
+
+}
+
+void free_lte_top(void)
+{
+  free_codinglib();
+  lte_sync_time_free();
+
+  /* free_ul_ref_sigs() is called in phy_free_lte_eNB() */
+}
 
 
 /*

openair1/PHY/INIT/lte_init_ru.c

@@ -0,0 +1,198 @@
+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#include "defs.h"
+#include "SCHED/defs.h"
+#include "PHY/extern.h"
+#include "SIMULATION/TOOLS/defs.h"
+#include "RadioResourceConfigCommonSIB.h"
+#include "RadioResourceConfigDedicated.h"
+#include "TDD-Config.h"
+#include "LAYER2/MAC/extern.h"
+#include "MBSFN-SubframeConfigList.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+#include "assertions.h"
+#include <math.h>
+
+int phy_init_RU(RU_t *ru) {
+
+  LTE_DL_FRAME_PARMS *fp = &ru->frame_parms;
+  int i,j;
+  int p;
+  int re;
+
+  LOG_I(PHY,"Initializing RU signal buffers (if_south %s) nb_tx %d\n",ru_if_types[ru->if_south],ru->nb_tx);
+
+  if (ru->if_south <= REMOTE_IF5) { // this means REMOTE_IF5 or LOCAL_RF, so allocate memory for time-domain signals 
+    // Time-domain signals
+    ru->common.txdata        = (int32_t**)malloc16(ru->nb_tx*sizeof(int32_t*));
+    ru->common.rxdata        = (int32_t**)malloc16(ru->nb_rx*sizeof(int32_t*) );
+
+
+    for (i=0; i<ru->nb_tx; i++) {
+      // Allocate 10 subframes of I/Q TX signal data (time) if not
+      ru->common.txdata[i]  = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) );
+
+      LOG_I(PHY,"[INIT] common.txdata[%d] = %p (%lu bytes)\n",i,ru->common.txdata[i],
+	     fp->samples_per_tti*10*sizeof(int32_t));
+
+    }
+    for (i=0;i<ru->nb_rx;i++) {
+      ru->common.rxdata[i] = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) );
+    }
+  } // IF5 or local RF
+  else {
+    //    LOG_I(PHY,"No rxdata/txdata for RU\n");
+    ru->common.txdata        = (int32_t**)NULL;
+    ru->common.rxdata        = (int32_t**)NULL;
+
+  }
+  if (ru->function != NGFI_RRU_IF5) { // we need to do RX/TX RU processing
+    LOG_I(PHY,"nb_tx %d\n",ru->nb_tx);
+    ru->common.rxdata_7_5kHz = (int32_t**)malloc16(ru->nb_rx*sizeof(int32_t*) );
+    for (i=0;i<ru->nb_rx;i++) {
+      ru->common.rxdata_7_5kHz[i] = (int32_t*)malloc16_clear( 2*fp->samples_per_tti*2*sizeof(int32_t) );
+      LOG_I(PHY,"rxdata_7_5kHz[%d] %p for RU %d\n",i,ru->common.rxdata_7_5kHz[i],ru->idx);
+    }
+  
+
+    // allocate IFFT input buffers (TX)
+    ru->common.txdataF_BF = (int32_t **)malloc16(ru->nb_tx*sizeof(int32_t*));
+    LOG_I(PHY,"[INIT] common.txdata_BF= %p (%lu bytes)\n",ru->common.txdataF_BF,
+	  ru->nb_tx*sizeof(int32_t*));
+    for (i=0; i<ru->nb_tx; i++) {
+      ru->common.txdataF_BF[i] = (int32_t*)malloc16_clear(fp->symbols_per_tti*fp->ofdm_symbol_size*sizeof(int32_t) );
+      LOG_I(PHY,"txdataF_BF[%d] %p for RU %d\n",i,ru->common.txdataF_BF[i],ru->idx);
+    }
+    // allocate FFT output buffers (RX)
+    ru->common.rxdataF     = (int32_t**)malloc16(ru->nb_rx*sizeof(int32_t*) );
+    for (i=0; i<ru->nb_rx; i++) {    
+      // allocate 2 subframes of I/Q signal data (frequency)
+      ru->common.rxdataF[i] = (int32_t*)malloc16_clear(sizeof(int32_t)*(2*fp->ofdm_symbol_size*fp->symbols_per_tti) ); 
+      LOG_I(PHY,"rxdataF[%d] %p for RU %d\n",i,ru->common.rxdataF[i],ru->idx);
+    }
+
+    /* number of elements of an array X is computed as sizeof(X) / sizeof(X[0]) */
+    //    AssertFatal(ru->nb_rx <= sizeof(ru->prach_rxsigF) / sizeof(ru->prach_rxsigF[0]),
+    //		"nb_antennas_rx too large");
+    ru->prach_rxsigF = (int16_t**)malloc(ru->nb_rx * sizeof(int16_t*));
+    for (j=0;j<4;j++) ru->prach_rxsigF_br[j] = (int16_t**)malloc(ru->nb_rx * sizeof(int16_t*));
+
+    for (i=0; i<ru->nb_rx; i++) {
+      ru->prach_rxsigF[i] = (int16_t*)malloc16_clear( fp->ofdm_symbol_size*12*2*sizeof(int16_t) );
+      LOG_D(PHY,"[INIT] prach_vars->rxsigF[%d] = %p\n",i,ru->prach_rxsigF[i]);
+#ifdef Rel14
+      for (j=0;j<4;j++) {
+	ru->prach_rxsigF_br[j][i] = (int16_t*)malloc16_clear( fp->ofdm_symbol_size*12*2*sizeof(int16_t) );
+	LOG_D(PHY,"[INIT] prach_vars_br->rxsigF[%d] = %p\n",i,ru->prach_rxsigF_br[j][i]);
+      }
+#endif
+    }
+    
+    AssertFatal(RC.nb_L1_inst <= NUMBER_OF_eNB_MAX,"eNB instances %d > %d\n",
+		RC.nb_L1_inst,NUMBER_OF_eNB_MAX);
+
+    LOG_E(PHY,"[INIT] %s() RC.nb_L1_inst:%d \n", __FUNCTION__, RC.nb_L1_inst);
+
+    for (i=0; i<RC.nb_L1_inst; i++) {
+      for (p=0;p<15;p++) {
+        LOG_D(PHY,"[INIT] %s() nb_antenna_ports_eNB:%d \n", __FUNCTION__, ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB);
+	if (p<ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB || p==5) {
+          LOG_D(PHY,"[INIT] %s() DO BEAM WEIGHTS nb_antenna_ports_eNB:%d nb_tx:%d\n", __FUNCTION__, ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB, ru->nb_tx);
+	  ru->beam_weights[i][p] = (int32_t **)malloc16_clear(ru->nb_tx*sizeof(int32_t*));
+	  for (j=0; j<ru->nb_tx; j++) {
+	    ru->beam_weights[i][p][j] = (int32_t *)malloc16_clear(fp->ofdm_symbol_size*sizeof(int32_t));
+	    // antenna ports 0-3 are mapped on antennas 0-3
+	    // antenna port 4 is mapped on antenna 0
+	    // antenna ports 5-14 are mapped on all antennas 
+	    if (((p<4) && (p==j)) || ((p==4) && (j==0))) {
+	      for (re=0; re<fp->ofdm_symbol_size; re++) 
+              {
+		ru->beam_weights[i][p][j][re] = 0x00007fff; 
+
+                //LOG_D(PHY,"[INIT] lte_common_vars->beam_weights[%d][%d][%d][%d] = %d\n", i,p,j,re,ru->beam_weights[i][p][j][re]);
+              }
+	    }
+	    else if (p>4) {
+	      for (re=0; re<fp->ofdm_symbol_size; re++) 
+              {
+		ru->beam_weights[i][p][j][re] = 0x00007fff/ru->nb_tx; 
+                //LOG_D(PHY,"[INIT] lte_common_vars->beam_weights[%d][%d][%d][%d] = %d\n", i,p,j,re,ru->beam_weights[i][p][j][re]);
+              }
+	    }  
+	    //LOG_D(PHY,"[INIT] lte_common_vars->beam_weights[%d][%d] = %p (%lu bytes)\n", i,j,ru->beam_weights[i][p][j], fp->ofdm_symbol_size*sizeof(int32_t)); 
+	  } // for (j=0
+	} // if (p<ru
+      } // for p
+    } //for i
+  } // !=IF5
+  ru->common.sync_corr = (uint32_t*)malloc16_clear( LTE_NUMBER_OF_SUBFRAMES_PER_FRAME*sizeof(uint32_t)*fp->samples_per_tti );
+
+  return(0);
+}
+
+void phy_free_RU(RU_t *ru)
+{
+  int i,j;
+  int p;
+
+  LOG_I(PHY, "Feeing RU signal buffers (if_south %s) nb_tx %d\n", ru_if_types[ru->if_south], ru->nb_tx);
+
+  if (ru->if_south <= REMOTE_IF5) { // this means REMOTE_IF5 or LOCAL_RF, so free memory for time-domain signals
+    for (i = 0; i < ru->nb_tx; i++) free_and_zero(ru->common.txdata[i]);
+    for (i = 0; i < ru->nb_rx; i++) free_and_zero(ru->common.rxdata[i]);
+    free_and_zero(ru->common.txdata);
+    free_and_zero(ru->common.rxdata);
+  } // else: IF5 or local RF -> nothing to free()
+
+  if (ru->function != NGFI_RRU_IF5) { // we need to do RX/TX RU processing
+    for (i = 0; i < ru->nb_rx; i++) free_and_zero(ru->common.rxdata_7_5kHz[i]);
+    free_and_zero(ru->common.rxdata_7_5kHz);
+
+    // free IFFT input buffers (TX)
+    for (i = 0; i < ru->nb_tx; i++) free_and_zero(ru->common.txdataF_BF[i]);
+    free_and_zero(ru->common.txdataF_BF);
+
+    // free FFT output buffers (RX)
+    for (i = 0; i < ru->nb_rx; i++) free_and_zero(ru->common.rxdataF[i]);
+    free_and_zero(ru->common.rxdataF);
+
+    for (i = 0; i < ru->nb_rx; i++) {
+      free_and_zero(ru->prach_rxsigF[i]);
+#ifdef Rel14
+      for (j = 0; j < 4; j++) free_and_zero(ru->prach_rxsigF_br[j][i]);
+#endif
+    }
+    for (j = 0; j < 4; j++) free_and_zero(ru->prach_rxsigF_br[j]);
+    free_and_zero(ru->prach_rxsigF);
+    /* ru->prach_rxsigF_br is not allocated -> don't free */
+
+    for (i = 0; i < RC.nb_L1_inst; i++) {
+      for (p = 0; p < 15; p++) {
+	if (p < ru->eNB_list[i]->frame_parms.nb_antenna_ports_eNB || p == 5) {
+	  for (j=0; j<ru->nb_tx; j++) free_and_zero(ru->beam_weights[i][p][j]);
+	  free_and_zero(ru->beam_weights[i][p]);
+	}
+      }
+    }
+  }
+  free_and_zero(ru->common.sync_corr);
+}

openair1/PHY/INIT/lte_init_ue.c

@@ -0,0 +1,963 @@
+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+#include "defs.h"
+#include "SCHED/defs.h"
+#include "PHY/extern.h"
+#include "SIMULATION/TOOLS/defs.h"
+#include "RadioResourceConfigCommonSIB.h"
+#include "RadioResourceConfigDedicated.h"
+#include "TDD-Config.h"
+#include "LAYER2/MAC/extern.h"
+#include "MBSFN-SubframeConfigList.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
+#include "assertions.h"
+#include <math.h>
+
+
+uint8_t dmrs1_tab_ue[8] = {0,2,3,4,6,8,9,10};
+
+void phy_config_sib1_ue(uint8_t Mod_id,int CC_id,
+                        uint8_t eNB_id,
+                        TDD_Config_t *tdd_Config,
+                        uint8_t SIwindowsize,
+                        uint16_t SIperiod)
+{
+
+  LTE_DL_FRAME_PARMS *fp = &PHY_vars_UE_g[Mod_id][CC_id]->frame_parms;
+
+  if (tdd_Config) {
+    fp->tdd_config    = tdd_Config->subframeAssignment;
+    fp->tdd_config_S  = tdd_Config->specialSubframePatterns;
+  }
+
+  fp->SIwindowsize  = SIwindowsize;
+  fp->SIPeriod      = SIperiod;
+}
+
+void phy_config_sib2_ue(uint8_t Mod_id,int CC_id,
+                        uint8_t eNB_id,
+                        RadioResourceConfigCommonSIB_t *radioResourceConfigCommon,
+                        ARFCN_ValueEUTRA_t *ul_CarrierFreq,
+                        long *ul_Bandwidth,
+                        AdditionalSpectrumEmission_t *additionalSpectrumEmission,
+                        struct MBSFN_SubframeConfigList *mbsfn_SubframeConfigList)
+{
+
+  PHY_VARS_UE *ue        = PHY_vars_UE_g[Mod_id][CC_id];
+  LTE_DL_FRAME_PARMS *fp = &ue->frame_parms;
+  int i;
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_UE_CONFIG_SIB2, VCD_FUNCTION_IN);
+
+  LOG_I(PHY,"[UE%d] Applying radioResourceConfigCommon from eNB%d\n",Mod_id,eNB_id);
+
+  fp->prach_config_common.rootSequenceIndex                           =radioResourceConfigCommon->prach_Config.rootSequenceIndex;
+
+  fp->prach_config_common.prach_Config_enabled=1;
+  fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex          =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.prach_ConfigIndex;
+  fp->prach_config_common.prach_ConfigInfo.highSpeedFlag              =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.highSpeedFlag;
+  fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig  =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.zeroCorrelationZoneConfig;
+  fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset           =radioResourceConfigCommon->prach_Config.prach_ConfigInfo.prach_FreqOffset;
+
+  compute_prach_seq(fp->prach_config_common.rootSequenceIndex,
+		    fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex,
+		    fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
+		    fp->prach_config_common.prach_ConfigInfo.highSpeedFlag,
+		    fp->frame_type,ue->X_u);
+
+
+
+  fp->pucch_config_common.deltaPUCCH_Shift = 1+radioResourceConfigCommon->pucch_ConfigCommon.deltaPUCCH_Shift;
+  fp->pucch_config_common.nRB_CQI          = radioResourceConfigCommon->pucch_ConfigCommon.nRB_CQI;
+  fp->pucch_config_common.nCS_AN           = radioResourceConfigCommon->pucch_ConfigCommon.nCS_AN;
+  fp->pucch_config_common.n1PUCCH_AN       = radioResourceConfigCommon->pucch_ConfigCommon.n1PUCCH_AN;
+
+
+
+  fp->pdsch_config_common.referenceSignalPower = radioResourceConfigCommon->pdsch_ConfigCommon.referenceSignalPower;
+  fp->pdsch_config_common.p_b                  = radioResourceConfigCommon->pdsch_ConfigCommon.p_b;
+
+
+  fp->pusch_config_common.n_SB                                         = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.n_SB;
+  fp->pusch_config_common.hoppingMode                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode;
+  fp->pusch_config_common.pusch_HoppingOffset                          = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset;
+  fp->pusch_config_common.enable64QAM                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled    = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH   = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled;
+  fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift            = dmrs1_tab_ue[radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift];
+
+
+  init_ul_hopping(fp);
+  fp->soundingrs_ul_config_common.enabled_flag                        = 0;
+
+  if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.present==SoundingRS_UL_ConfigCommon_PR_setup) {
+    fp->soundingrs_ul_config_common.enabled_flag                        = 1;
+    fp->soundingrs_ul_config_common.srs_BandwidthConfig                 = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_BandwidthConfig;
+    fp->soundingrs_ul_config_common.srs_SubframeConfig                  = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_SubframeConfig;
+    fp->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission = radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.ackNackSRS_SimultaneousTransmission;
+
+    if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon.choice.setup.srs_MaxUpPts)
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 1;
+    else
+      fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 0;
+  }
+
+
+
+  fp->ul_power_control_config_common.p0_NominalPUSCH   = radioResourceConfigCommon->uplinkPowerControlCommon.p0_NominalPUSCH;
+  fp->ul_power_control_config_common.alpha             = radioResourceConfigCommon->uplinkPowerControlCommon.alpha;
+  fp->ul_power_control_config_common.p0_NominalPUCCH   = radioResourceConfigCommon->uplinkPowerControlCommon.p0_NominalPUCCH;
+  fp->ul_power_control_config_common.deltaPreambleMsg3 = radioResourceConfigCommon->uplinkPowerControlCommon.deltaPreambleMsg3;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format1  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format1b  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format1b;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2a  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2a;
+  fp->ul_power_control_config_common.deltaF_PUCCH_Format2b  = radioResourceConfigCommon->uplinkPowerControlCommon.deltaFList_PUCCH.deltaF_PUCCH_Format2b;
+
+  fp->maxHARQ_Msg3Tx = radioResourceConfigCommon->rach_ConfigCommon.maxHARQ_Msg3Tx;
+
+  // Now configure some of the Physical Channels
+
+  // PUCCH
+  init_ncs_cell(fp,ue->ncs_cell);
+
+  init_ul_hopping(fp);
+
+  // PCH
+  init_ue_paging_info(ue,radioResourceConfigCommon->pcch_Config.defaultPagingCycle,radioResourceConfigCommon->pcch_Config.nB);
+
+  // MBSFN
+
+  if (mbsfn_SubframeConfigList != NULL) {
+    fp->num_MBSFN_config = mbsfn_SubframeConfigList->list.count;
+
+    for (i=0; i<mbsfn_SubframeConfigList->list.count; i++) {
+      fp->MBSFN_config[i].radioframeAllocationPeriod = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationPeriod;
+      fp->MBSFN_config[i].radioframeAllocationOffset = mbsfn_SubframeConfigList->list.array[i]->radioframeAllocationOffset;
+
+      if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_oneFrame) {
+        fp->MBSFN_config[i].fourFrames_flag = 0;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig = mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]; // 6-bit subframe configuration
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      } else if (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.present == MBSFN_SubframeConfig__subframeAllocation_PR_fourFrames) { // 24-bit subframe configuration
+        fp->MBSFN_config[i].fourFrames_flag = 1;
+        fp->MBSFN_config[i].mbsfn_SubframeConfig =
+          mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[0]|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[1]<<8)|
+          (mbsfn_SubframeConfigList->list.array[i]->subframeAllocation.choice.oneFrame.buf[2]<<16);
+
+        LOG_I(PHY, "[CONFIG] MBSFN_SubframeConfig[%d] pattern is  %d\n", i,
+              fp->MBSFN_config[i].mbsfn_SubframeConfig);
+      }
+    }
+  }
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_UE_CONFIG_SIB2, VCD_FUNCTION_OUT);
+
+}
+
+void phy_config_sib13_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,int mbsfn_Area_idx,
+                         long mbsfn_AreaId_r9)
+{
+
+  LTE_DL_FRAME_PARMS *fp = &PHY_vars_UE_g[Mod_id][CC_id]->frame_parms;
+
+
+  LOG_I(PHY,"[UE%d] Applying MBSFN_Area_id %ld for index %d\n",Mod_id,mbsfn_AreaId_r9,mbsfn_Area_idx);
+
+  if (mbsfn_Area_idx == 0) {
+    fp->Nid_cell_mbsfn = (uint16_t)mbsfn_AreaId_r9;
+    LOG_N(PHY,"Fix me: only called when mbsfn_Area_idx == 0)\n");
+  }
+
+  lte_gold_mbsfn(fp,PHY_vars_UE_g[Mod_id][CC_id]->lte_gold_mbsfn_table,fp->Nid_cell_mbsfn);
+
+}
+
+
+/*
+ * Configures UE MAC and PHY with radioResourceCommon received in mobilityControlInfo IE during Handover
+ */
+void phy_config_afterHO_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_id, MobilityControlInfo_t *mobilityControlInfo, uint8_t ho_failed)
+{
+
+  if(mobilityControlInfo!=NULL) {
+    RadioResourceConfigCommon_t *radioResourceConfigCommon = &mobilityControlInfo->radioResourceConfigCommon;
+    LOG_I(PHY,"radioResourceConfigCommon %p\n", radioResourceConfigCommon);
+    memcpy((void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms_before_ho,
+           (void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms,
+           sizeof(LTE_DL_FRAME_PARMS));
+    PHY_vars_UE_g[Mod_id][CC_id]->ho_triggered = 1;
+    //PHY_vars_UE_g[UE_id]->UE_mode[0] = PRACH;
+
+    LTE_DL_FRAME_PARMS *fp = &PHY_vars_UE_g[Mod_id][CC_id]->frame_parms;
+    //     int N_ZC;
+    //     uint8_t prach_fmt;
+    //     int u;
+
+    LOG_I(PHY,"[UE%d] Handover triggered: Applying radioResourceConfigCommon from eNB %d\n",
+          Mod_id,eNB_id);
+
+    fp->prach_config_common.rootSequenceIndex                           =radioResourceConfigCommon->prach_Config.rootSequenceIndex;
+    fp->prach_config_common.prach_Config_enabled=1;
+    fp->prach_config_common.prach_ConfigInfo.prach_ConfigIndex          =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->prach_ConfigIndex;
+    fp->prach_config_common.prach_ConfigInfo.highSpeedFlag              =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->highSpeedFlag;
+    fp->prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig  =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->zeroCorrelationZoneConfig;
+    fp->prach_config_common.prach_ConfigInfo.prach_FreqOffset           =radioResourceConfigCommon->prach_Config.prach_ConfigInfo->prach_FreqOffset;
+
+    //     prach_fmt = get_prach_fmt(radioResourceConfigCommon->prach_Config.prach_ConfigInfo->prach_ConfigIndex,fp->frame_type);
+    //     N_ZC = (prach_fmt <4)?839:139;
+    //     u = (prach_fmt < 4) ? prach_root_sequence_map0_3[fp->prach_config_common.rootSequenceIndex] :
+    //       prach_root_sequence_map4[fp->prach_config_common.rootSequenceIndex];
+
+    //compute_prach_seq(u,N_ZC, PHY_vars_UE_g[Mod_id]->X_u);
+    compute_prach_seq(PHY_vars_UE_g[Mod_id][CC_id]->frame_parms.prach_config_common.rootSequenceIndex,
+		      PHY_vars_UE_g[Mod_id][CC_id]->frame_parms.prach_config_common.prach_ConfigInfo.prach_ConfigIndex,
+		      PHY_vars_UE_g[Mod_id][CC_id]->frame_parms.prach_config_common.prach_ConfigInfo.zeroCorrelationZoneConfig,
+		      PHY_vars_UE_g[Mod_id][CC_id]->frame_parms.prach_config_common.prach_ConfigInfo.highSpeedFlag,
+                      fp->frame_type,
+                      PHY_vars_UE_g[Mod_id][CC_id]->X_u);
+
+
+    fp->pucch_config_common.deltaPUCCH_Shift = 1+radioResourceConfigCommon->pucch_ConfigCommon->deltaPUCCH_Shift;
+    fp->pucch_config_common.nRB_CQI          = radioResourceConfigCommon->pucch_ConfigCommon->nRB_CQI;
+    fp->pucch_config_common.nCS_AN           = radioResourceConfigCommon->pucch_ConfigCommon->nCS_AN;
+    fp->pucch_config_common.n1PUCCH_AN       = radioResourceConfigCommon->pucch_ConfigCommon->n1PUCCH_AN;
+    fp->pdsch_config_common.referenceSignalPower = radioResourceConfigCommon->pdsch_ConfigCommon->referenceSignalPower;
+    fp->pdsch_config_common.p_b                  = radioResourceConfigCommon->pdsch_ConfigCommon->p_b;
+
+
+    fp->pusch_config_common.n_SB                                         = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.n_SB;
+    fp->pusch_config_common.hoppingMode                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.hoppingMode;
+    fp->pusch_config_common.pusch_HoppingOffset                          = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.pusch_HoppingOffset;
+    fp->pusch_config_common.enable64QAM                                  = radioResourceConfigCommon->pusch_ConfigCommon.pusch_ConfigBasic.enable64QAM;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupHoppingEnabled    = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupHoppingEnabled;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH   = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.groupAssignmentPUSCH;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.sequenceHoppingEnabled;
+    fp->pusch_config_common.ul_ReferenceSignalsPUSCH.cyclicShift            = radioResourceConfigCommon->pusch_ConfigCommon.ul_ReferenceSignalsPUSCH.cyclicShift;
+
+    init_ul_hopping(fp);
+    fp->soundingrs_ul_config_common.enabled_flag                        = 0;
+
+    if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon->present==SoundingRS_UL_ConfigCommon_PR_setup) {
+      fp->soundingrs_ul_config_common.enabled_flag                        = 1;
+      fp->soundingrs_ul_config_common.srs_BandwidthConfig                 = radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.srs_BandwidthConfig;
+      fp->soundingrs_ul_config_common.srs_SubframeConfig                  = radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.srs_SubframeConfig;
+      fp->soundingrs_ul_config_common.ackNackSRS_SimultaneousTransmission = radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.ackNackSRS_SimultaneousTransmission;
+
+      if (radioResourceConfigCommon->soundingRS_UL_ConfigCommon->choice.setup.srs_MaxUpPts)
+        fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 1;
+      else
+        fp->soundingrs_ul_config_common.srs_MaxUpPts                      = 0;
+    }
+
+    fp->ul_power_control_config_common.p0_NominalPUSCH   = radioResourceConfigCommon->uplinkPowerControlCommon->p0_NominalPUSCH;
+    fp->ul_power_control_config_common.alpha             = radioResourceConfigCommon->uplinkPowerControlCommon->alpha;
+    fp->ul_power_control_config_common.p0_NominalPUCCH   = radioResourceConfigCommon->uplinkPowerControlCommon->p0_NominalPUCCH;
+    fp->ul_power_control_config_common.deltaPreambleMsg3 = radioResourceConfigCommon->uplinkPowerControlCommon->deltaPreambleMsg3;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format1  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format1;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format1b  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format1b;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format2  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format2;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format2a  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format2a;
+    fp->ul_power_control_config_common.deltaF_PUCCH_Format2b  = radioResourceConfigCommon->uplinkPowerControlCommon->deltaFList_PUCCH.deltaF_PUCCH_Format2b;
+
+    fp->maxHARQ_Msg3Tx = radioResourceConfigCommon->rach_ConfigCommon->maxHARQ_Msg3Tx;
+
+    // Now configure some of the Physical Channels
+    if (radioResourceConfigCommon->antennaInfoCommon)
+      fp->nb_antennas_tx                     = (1<<radioResourceConfigCommon->antennaInfoCommon->antennaPortsCount);
+    else
+      fp->nb_antennas_tx                     = 1;
+
+    //PHICH
+    if (radioResourceConfigCommon->antennaInfoCommon) {
+      fp->phich_config_common.phich_resource = radioResourceConfigCommon->phich_Config->phich_Resource;
+      fp->phich_config_common.phich_duration = radioResourceConfigCommon->phich_Config->phich_Duration;
+    }
+
+    //Target CellId
+    fp->Nid_cell = mobilityControlInfo->targetPhysCellId;
+    fp->nushift  = fp->Nid_cell%6;
+
+    // PUCCH
+    init_ncs_cell(fp,PHY_vars_UE_g[Mod_id][CC_id]->ncs_cell);
+
+    init_ul_hopping(fp);
+
+    // RNTI
+
+
+    PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_id]->crnti = mobilityControlInfo->newUE_Identity.buf[0]|(mobilityControlInfo->newUE_Identity.buf[1]<<8);
+    PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_id]->crnti = mobilityControlInfo->newUE_Identity.buf[0]|(mobilityControlInfo->newUE_Identity.buf[1]<<8);
+
+    LOG_I(PHY,"SET C-RNTI %x %x\n",PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[0][eNB_id]->crnti,
+                                   PHY_vars_UE_g[Mod_id][CC_id]->pdcch_vars[1][eNB_id]->crnti);
+  }
+
+  if(ho_failed) {
+    LOG_D(PHY,"[UE%d] Handover failed, triggering RACH procedure\n",Mod_id);
+    memcpy((void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms,(void *)&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms_before_ho, sizeof(LTE_DL_FRAME_PARMS));
+    PHY_vars_UE_g[Mod_id][CC_id]->UE_mode[eNB_id] = PRACH;
+  }
+}
+
+void phy_config_meas_ue(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index,uint8_t n_adj_cells,unsigned int *adj_cell_id)
+{
+
+  PHY_MEASUREMENTS *phy_meas = &PHY_vars_UE_g[Mod_id][CC_id]->measurements;
+  int i;
+
+  LOG_I(PHY,"Configuring inter-cell measurements for %d cells, ids: \n",n_adj_cells);
+
+  for (i=0; i<n_adj_cells; i++) {
+    LOG_I(PHY,"%d\n",adj_cell_id[i]);
+    lte_gold(&PHY_vars_UE_g[Mod_id][CC_id]->frame_parms,PHY_vars_UE_g[Mod_id][CC_id]->lte_gold_table[i+1],adj_cell_id[i]);
+  }
+
+  phy_meas->n_adj_cells = n_adj_cells;
+  memcpy((void*)phy_meas->adj_cell_id,(void *)adj_cell_id,n_adj_cells*sizeof(unsigned int));
+
+}
+
+#if defined(Rel10) || defined(Rel14)
+void phy_config_dedicated_scell_ue(uint8_t Mod_id,
+                                   uint8_t eNB_index,
+                                   SCellToAddMod_r10_t *sCellToAddMod_r10,
+                                   int CC_id)
+{
+
+}
+#endif
+
+
+void phy_config_harq_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
+                        uint16_t max_harq_tx )
+{
+
+  PHY_VARS_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
+  phy_vars_ue->ulsch[eNB_id]->Mlimit = max_harq_tx;
+}
+
+extern uint16_t beta_cqi[16];
+
+void phy_config_dedicated_ue(uint8_t Mod_id,int CC_id,uint8_t eNB_id,
+                             struct PhysicalConfigDedicated *physicalConfigDedicated )
+{
+
+  static uint8_t first_dedicated_configuration = 0;
+  PHY_VARS_UE *phy_vars_ue = PHY_vars_UE_g[Mod_id][CC_id];
+
+  phy_vars_ue->total_TBS[eNB_id]=0;
+  phy_vars_ue->total_TBS_last[eNB_id]=0;
+  phy_vars_ue->bitrate[eNB_id]=0;
+  phy_vars_ue->total_received_bits[eNB_id]=0;
+  phy_vars_ue->dlsch_errors[eNB_id]=0;
+  phy_vars_ue->dlsch_errors_last[eNB_id]=0;
+  phy_vars_ue->dlsch_received[eNB_id]=0;
+  phy_vars_ue->dlsch_received_last[eNB_id]=0;
+  phy_vars_ue->dlsch_fer[eNB_id]=0;
+
+  phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex = -1;
+  phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex = -1;
+
+  if (physicalConfigDedicated) {
+    LOG_D(PHY,"[UE %d] Received physicalConfigDedicated from eNB %d\n",Mod_id, eNB_id);
+    LOG_D(PHY,"------------------------------------------------------------------------\n");
+
+    if (physicalConfigDedicated->pdsch_ConfigDedicated) {
+      phy_vars_ue->pdsch_config_dedicated[eNB_id].p_a=physicalConfigDedicated->pdsch_ConfigDedicated->p_a;
+      LOG_D(PHY,"pdsch_config_dedicated.p_a %d\n",phy_vars_ue->pdsch_config_dedicated[eNB_id].p_a);
+      LOG_D(PHY,"\n");
+    }
+
+    if (physicalConfigDedicated->pucch_ConfigDedicated) {
+      if (physicalConfigDedicated->pucch_ConfigDedicated->ackNackRepetition.present==PUCCH_ConfigDedicated__ackNackRepetition_PR_release)
+        phy_vars_ue->pucch_config_dedicated[eNB_id].ackNackRepetition=0;
+      else {
+        phy_vars_ue->pucch_config_dedicated[eNB_id].ackNackRepetition=1;
+      }
+
+      if (physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode)
+        phy_vars_ue->pucch_config_dedicated[eNB_id].tdd_AckNackFeedbackMode = *physicalConfigDedicated->pucch_ConfigDedicated->tdd_AckNackFeedbackMode;
+      else
+        phy_vars_ue->pucch_config_dedicated[eNB_id].tdd_AckNackFeedbackMode = bundling;
+
+      if ( phy_vars_ue->pucch_config_dedicated[eNB_id].tdd_AckNackFeedbackMode == multiplexing)
+        LOG_D(PHY,"pucch_config_dedicated.tdd_AckNackFeedbackMode = multiplexing\n");
+      else
+        LOG_D(PHY,"pucch_config_dedicated.tdd_AckNackFeedbackMode = bundling\n");
+    }
+
+    if (physicalConfigDedicated->pusch_ConfigDedicated) {
+      phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_ACK_Index;
+      phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_RI_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_RI_Index;
+      phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index = physicalConfigDedicated->pusch_ConfigDedicated->betaOffset_CQI_Index;
+
+
+      LOG_D(PHY,"pusch_config_dedicated.betaOffset_ACK_Index %d\n",phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_ACK_Index);
+      LOG_D(PHY,"pusch_config_dedicated.betaOffset_RI_Index %d\n",phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_RI_Index);
+      LOG_D(PHY,"pusch_config_dedicated.betaOffset_CQI_Index %d => %d)\n",phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index,beta_cqi[phy_vars_ue->pusch_config_dedicated[eNB_id].betaOffset_CQI_Index]);
+      LOG_D(PHY,"\n");
+
+
+    }
+
+    if (physicalConfigDedicated->uplinkPowerControlDedicated) {
+
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUSCH = physicalConfigDedicated->uplinkPowerControlDedicated->p0_UE_PUSCH;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].deltaMCS_Enabled= physicalConfigDedicated->uplinkPowerControlDedicated->deltaMCS_Enabled;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].accumulationEnabled= physicalConfigDedicated->uplinkPowerControlDedicated->accumulationEnabled;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUCCH= physicalConfigDedicated->uplinkPowerControlDedicated->p0_UE_PUCCH;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].pSRS_Offset= physicalConfigDedicated->uplinkPowerControlDedicated->pSRS_Offset;
+      phy_vars_ue->ul_power_control_dedicated[eNB_id].filterCoefficient= *physicalConfigDedicated->uplinkPowerControlDedicated->filterCoefficient;
+      LOG_D(PHY,"ul_power_control_dedicated.p0_UE_PUSCH %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUSCH);
+      LOG_D(PHY,"ul_power_control_dedicated.deltaMCS_Enabled %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].deltaMCS_Enabled);
+      LOG_D(PHY,"ul_power_control_dedicated.accumulationEnabled %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].accumulationEnabled);
+      LOG_D(PHY,"ul_power_control_dedicated.p0_UE_PUCCH %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].p0_UE_PUCCH);
+      LOG_D(PHY,"ul_power_control_dedicated.pSRS_Offset %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].pSRS_Offset);
+      LOG_D(PHY,"ul_power_control_dedicated.filterCoefficient %d\n",phy_vars_ue->ul_power_control_dedicated[eNB_id].filterCoefficient);
+      LOG_D(PHY,"\n");
+    }
+
+    if (physicalConfigDedicated->antennaInfo) {
+      phy_vars_ue->transmission_mode[eNB_id] = 1+(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode);
+      LOG_I(PHY,"Transmission Mode %d\n",phy_vars_ue->transmission_mode[eNB_id]);
+      switch(physicalConfigDedicated->antennaInfo->choice.explicitValue.transmissionMode) {
+      case AntennaInfoDedicated__transmissionMode_tm1:
+        phy_vars_ue->transmission_mode[eNB_id] = 1;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm2:
+        phy_vars_ue->transmission_mode[eNB_id] = 2;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm3:
+        phy_vars_ue->transmission_mode[eNB_id] = 3;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm4:
+        phy_vars_ue->transmission_mode[eNB_id] = 4;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm5:
+        phy_vars_ue->transmission_mode[eNB_id] = 5;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm6:
+        phy_vars_ue->transmission_mode[eNB_id] = 6;
+        break;
+      case AntennaInfoDedicated__transmissionMode_tm7:
+        lte_gold_ue_spec_port5(phy_vars_ue->lte_gold_uespec_port5_table, phy_vars_ue->frame_parms.Nid_cell, phy_vars_ue->pdcch_vars[0][eNB_id]->crnti);
+        phy_vars_ue->transmission_mode[eNB_id] = 7;
+        break;
+      default:
+        LOG_E(PHY,"Unknown transmission mode!\n");
+        break;
+      }
+    } else {
+      LOG_D(PHY,"[UE %d] Received NULL physicalConfigDedicated->antennaInfo from eNB %d\n",Mod_id, eNB_id);
+    }
+
+    if (physicalConfigDedicated->schedulingRequestConfig) {
+      if (physicalConfigDedicated->schedulingRequestConfig->present == SchedulingRequestConfig_PR_setup) {
+        phy_vars_ue->scheduling_request_config[eNB_id].sr_PUCCH_ResourceIndex = physicalConfigDedicated->schedulingRequestConfig->choice.setup.sr_PUCCH_ResourceIndex;
+        phy_vars_ue->scheduling_request_config[eNB_id].sr_ConfigIndex=physicalConfigDedicated->schedulingRequestConfig->choice.setup.sr_ConfigIndex;
+        phy_vars_ue->scheduling_request_config[eNB_id].dsr_TransMax=physicalConfigDedicated->schedulingRequestConfig->choice.setup.dsr_TransMax;
+
+        LOG_D(PHY,"scheduling_request_config.sr_PUCCH_ResourceIndex %d\n",phy_vars_ue->scheduling_request_config[eNB_id].sr_PUCCH_ResourceIndex);
+        LOG_D(PHY,"scheduling_request_config.sr_ConfigIndex %d\n",phy_vars_ue->scheduling_request_config[eNB_id].sr_ConfigIndex);
+        LOG_D(PHY,"scheduling_request_config.dsr_TransMax %d\n",phy_vars_ue->scheduling_request_config[eNB_id].dsr_TransMax);
+      }
+
+      LOG_D(PHY,"------------------------------------------------------------\n");
+
+    }
+
+    if (physicalConfigDedicated->soundingRS_UL_ConfigDedicated) {
+
+      phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srsConfigDedicatedSetup = 0;
+      if (physicalConfigDedicated->soundingRS_UL_ConfigDedicated->present == SoundingRS_UL_ConfigDedicated_PR_setup) {
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srsConfigDedicatedSetup = 1;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].duration             = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.duration;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].cyclicShift          = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.cyclicShift;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].freqDomainPosition   = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.freqDomainPosition;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_Bandwidth        = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_Bandwidth;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_ConfigIndex      = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_ConfigIndex;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_HoppingBandwidth = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.srs_HoppingBandwidth;
+        phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].transmissionComb     = physicalConfigDedicated->soundingRS_UL_ConfigDedicated->choice.setup.transmissionComb;
+
+
+        LOG_D(PHY,"soundingrs_ul_config_dedicated.srs_ConfigIndex %d\n",phy_vars_ue->soundingrs_ul_config_dedicated[eNB_id].srs_ConfigIndex);
+      }
+
+      LOG_D(PHY,"------------------------------------------------------------\n");
+
+    }
+
+
+    if (physicalConfigDedicated->cqi_ReportConfig) {
+      if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportModeAperiodic) {
+        // configure PUSCH CQI reporting
+        phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic = *physicalConfigDedicated->cqi_ReportConfig->cqi_ReportModeAperiodic;
+        if ((phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic != rm12) &&
+            (phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic != rm30) &&
+            (phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic != rm31))
+          LOG_E(PHY,"Unsupported Aperiodic CQI Feedback Mode : %d\n",phy_vars_ue->cqi_report_config[eNB_id].cqi_ReportModeAperiodic);
+      }
+      if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic) {
+        if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->present == CQI_ReportPeriodic_PR_setup) {
+        // configure PUCCH CQI reporting
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PUCCH_ResourceIndex = physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.cqi_PUCCH_ResourceIndex;
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex     = physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.cqi_pmi_ConfigIndex;
+          if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.ri_ConfigIndex)
+            phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex = *physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->choice.setup.ri_ConfigIndex;
+        }
+        else if (physicalConfigDedicated->cqi_ReportConfig->cqi_ReportPeriodic->present == CQI_ReportPeriodic_PR_release) {
+          // handle release
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.ri_ConfigIndex = -1;
+          phy_vars_ue->cqi_report_config[eNB_id].CQI_ReportPeriodic.cqi_PMI_ConfigIndex = -1;
+        }
+      }
+    }
+
+#ifdef CBA
+
+    if (physicalConfigDedicated->pusch_CBAConfigDedicated_vlola) {
+      phy_vars_ue->pusch_ca_config_dedicated[eNB_id].betaOffset_CA_Index = (uint16_t) *physicalConfigDedicated->pusch_CBAConfigDedicated_vlola->betaOffset_CBA_Index;
+      phy_vars_ue->pusch_ca_config_dedicated[eNB_id].cShift = (uint16_t) *physicalConfigDedicated->pusch_CBAConfigDedicated_vlola->cShift_CBA;
+      LOG_D(PHY,"[UE %d ] physicalConfigDedicated pusch CBA config dedicated: beta offset %d cshift %d \n",Mod_id,
+            phy_vars_ue->pusch_ca_config_dedicated[eNB_id].betaOffset_CA_Index,
+            phy_vars_ue->pusch_ca_config_dedicated[eNB_id].cShift);
+    }
+
+#endif
+  } else {
+    LOG_D(PHY,"[PHY][UE %d] Received NULL radioResourceConfigDedicated from eNB %d\n",Mod_id,eNB_id);
+    return;
+  }
+
+  // fill cqi parameters for periodic CQI reporting
+  get_cqipmiri_params(phy_vars_ue,eNB_id);
+
+  // disable MIB SIB decoding once we are on connected mode
+  first_dedicated_configuration ++;
+  if(first_dedicated_configuration > 1)
+  {
+  	LOG_I(PHY,"Disable SIB MIB decoding \n");
+  	phy_vars_ue->decode_SIB = 0;
+  	phy_vars_ue->decode_MIB = 0;
+  }
+  //phy_vars_ue->pdcch_vars[1][eNB_id]->crnti = phy_vars_ue->pdcch_vars[0][eNB_id]->crnti;
+  if(phy_vars_ue->pdcch_vars[0][eNB_id]->crnti == 0x1234)
+      phy_vars_ue->pdcch_vars[0][eNB_id]->crnti = phy_vars_ue->pdcch_vars[1][eNB_id]->crnti;
+  else
+      phy_vars_ue->pdcch_vars[1][eNB_id]->crnti = phy_vars_ue->pdcch_vars[0][eNB_id]->crnti;
+
+  LOG_I(PHY,"C-RNTI %x %x \n", phy_vars_ue->pdcch_vars[0][eNB_id]->crnti,
+                               phy_vars_ue->pdcch_vars[1][eNB_id]->crnti);
+
+
+}
+
+/*! \brief Helper function to allocate memory for DLSCH data structures.
+ * \param[out] pdsch Pointer to the LTE_UE_PDSCH structure to initialize.
+ * \param[in] frame_parms LTE_DL_FRAME_PARMS structure.
+ * \note This function is optimistic in that it expects malloc() to succeed.
+ */
+void phy_init_lte_ue__PDSCH( LTE_UE_PDSCH* const pdsch, const LTE_DL_FRAME_PARMS* const fp )
+{
+  AssertFatal( pdsch, "pdsch==0" );
+
+  pdsch->pmi_ext = (uint8_t*)malloc16_clear( fp->N_RB_DL );
+  pdsch->llr[0] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+  pdsch->llr128 = (int16_t**)malloc16_clear( sizeof(int16_t*) );
+  // FIXME! no further allocation for (int16_t*)pdsch->llr128 !!! expect SIGSEGV
+  // FK, 11-3-2015: this is only as a temporary pointer, no memory is stored there
+
+
+  pdsch->rxdataF_ext            = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->rxdataF_uespec_pilots  = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->rxdataF_comp0          = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->rho                    = (int32_t**)malloc16_clear( fp->nb_antennas_rx*sizeof(int32_t*) );
+  pdsch->dl_ch_estimates_ext    = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_bf_ch_estimates     = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_bf_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  //pdsch->dl_ch_rho_ext          = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  //pdsch->dl_ch_rho2_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_ch_mag0             = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_ch_magb0            = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+
+
+  // the allocated memory size is fixed:
+  AssertFatal( fp->nb_antennas_rx <= 2, "nb_antennas_rx > 2" );
+
+  for (int i=0; i<fp->nb_antennas_rx; i++) {
+    pdsch->rho[i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*7*2) );
+
+    for (int j=0; j<4; j++) { //fp->nb_antennas_tx; j++)
+      const int idx = (j<<1)+i;
+      const size_t num = 7*2*fp->N_RB_DL*12;
+      pdsch->rxdataF_ext[idx]             = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->rxdataF_uespec_pilots[idx]   = (int32_t*)malloc16_clear( sizeof(int32_t) * fp->N_RB_DL*12);
+      pdsch->rxdataF_comp0[idx]           = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_estimates_ext[idx]     = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_bf_ch_estimates[idx]      = (int32_t*)malloc16_clear( sizeof(int32_t) * fp->ofdm_symbol_size*7*2);
+      pdsch->dl_bf_ch_estimates_ext[idx]  = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      //pdsch->dl_ch_rho_ext[idx]           = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      //pdsch->dl_ch_rho2_ext[idx]          = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_mag0[idx]              = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_magb0[idx]             = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+    }
+  }
+}
+
+int init_lte_ue_signal(PHY_VARS_UE *ue,
+		       int nb_connected_eNB,
+		       uint8_t abstraction_flag)
+{
+
+  // create shortcuts
+  LTE_DL_FRAME_PARMS* const fp            = &ue->frame_parms;
+  LTE_UE_COMMON* const common_vars        = &ue->common_vars;
+  LTE_UE_PDSCH** const pdsch_vars_SI      = ue->pdsch_vars_SI;
+  LTE_UE_PDSCH** const pdsch_vars_ra      = ue->pdsch_vars_ra;
+  LTE_UE_PDSCH** const pdsch_vars_p       = ue->pdsch_vars_p;
+  LTE_UE_PDSCH** const pdsch_vars_mch     = ue->pdsch_vars_MCH;
+  LTE_UE_PDSCH* (*pdsch_vars_th)[][NUMBER_OF_CONNECTED_eNB_MAX+1] = &ue->pdsch_vars;
+  LTE_UE_PDCCH* (*pdcch_vars_th)[][NUMBER_OF_CONNECTED_eNB_MAX]   = &ue->pdcch_vars;
+  LTE_UE_PBCH** const pbch_vars           = ue->pbch_vars;
+  LTE_UE_PRACH** const prach_vars         = ue->prach_vars;
+
+
+
+  int i,j,k,l;
+  int eNB_id;
+  int th_id;
+
+  LOG_D(PHY,"Initializing UE vars (abstraction %"PRIu8") for eNB TXant %"PRIu8", UE RXant %"PRIu8"\n",abstraction_flag,fp->nb_antennas_tx,fp->nb_antennas_rx);
+  LOG_D(PHY,"[MSC_NEW][FRAME 00000][PHY_UE][MOD %02u][]\n", ue->Mod_id+NB_eNB_INST);
+
+
+
+  init_frame_parms(&ue->frame_parms,1);
+  init_lte_top(&ue->frame_parms);
+  init_ul_hopping(&ue->frame_parms);
+
+
+  // many memory allocation sizes are hard coded
+  AssertFatal( fp->nb_antennas_rx <= 2, "hard coded allocation for ue_common_vars->dl_ch_estimates[eNB_id]" );
+  AssertFatal( ue->n_connected_eNB <= NUMBER_OF_CONNECTED_eNB_MAX, "n_connected_eNB is too large" );
+  // init phy_vars_ue
+
+  for (i=0; i<4; i++) {
+    ue->rx_gain_max[i] = 135;
+    ue->rx_gain_med[i] = 128;
+    ue->rx_gain_byp[i] = 120;
+  }
+
+  ue->n_connected_eNB = nb_connected_eNB;
+
+  for(eNB_id = 0; eNB_id < ue->n_connected_eNB; eNB_id++) {
+    ue->total_TBS[eNB_id] = 0;
+    ue->total_TBS_last[eNB_id] = 0;
+    ue->bitrate[eNB_id] = 0;
+    ue->total_received_bits[eNB_id] = 0;
+  }
+
+  for (i=0;i<10;i++)
+    ue->tx_power_dBm[i]=-127;
+
+
+
+  // init TX buffers
+  
+  common_vars->txdata  = (int32_t**)malloc16( fp->nb_antennas_tx*sizeof(int32_t*) );
+  common_vars->txdataF = (int32_t **)malloc16( fp->nb_antennas_tx*sizeof(int32_t*) );
+  
+  for (i=0; i<fp->nb_antennas_tx; i++) {
+    
+    common_vars->txdata[i]  = (int32_t*)malloc16_clear( fp->samples_per_tti*10*sizeof(int32_t) );
+    common_vars->txdataF[i] = (int32_t *)malloc16_clear( fp->ofdm_symbol_size*fp->symbols_per_tti*10*sizeof(int32_t) );
+  }
+  
+  // init RX buffers
+  
+  common_vars->rxdata   = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+  common_vars->common_vars_rx_data_per_thread[0].rxdataF  = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+  common_vars->common_vars_rx_data_per_thread[1].rxdataF  = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+  
+  for (i=0; i<fp->nb_antennas_rx; i++) {
+    common_vars->rxdata[i] = (int32_t*) malloc16_clear( (fp->samples_per_tti*10+2048)*sizeof(int32_t) );
+    common_vars->common_vars_rx_data_per_thread[0].rxdataF[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*14) );
+    common_vars->common_vars_rx_data_per_thread[1].rxdataF[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->ofdm_symbol_size*14) );
+  }
+
+
+  // Channel estimates
+  for (eNB_id=0; eNB_id<7; eNB_id++) {
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+        common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates[eNB_id]      = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+        common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates_time[eNB_id] = (int32_t**)malloc16_clear(8*sizeof(int32_t*));
+    }
+
+    for (i=0; i<fp->nb_antennas_rx; i++)
+      for (j=0; j<4; j++) {
+        int idx = (j<<1) + i;
+        for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+            common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->symbols_per_tti*(fp->ofdm_symbol_size+LTE_CE_FILTER_LENGTH) );
+            common_vars->common_vars_rx_data_per_thread[th_id].dl_ch_estimates_time[eNB_id][idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*fp->ofdm_symbol_size*2 );
+        }
+      }
+  }
+
+  // DLSCH
+  for (eNB_id=0; eNB_id<ue->n_connected_eNB; eNB_id++) {
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+        (*pdsch_vars_th)[th_id][eNB_id]     = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    }
+
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+        (*pdcch_vars_th)[th_id][eNB_id] = (LTE_UE_PDCCH *)malloc16_clear(sizeof(LTE_UE_PDCCH));
+    }
+
+    pdsch_vars_SI[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdsch_vars_ra[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdsch_vars_p[eNB_id]   = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    pdsch_vars_mch[eNB_id] = (LTE_UE_PDSCH *)malloc16_clear(sizeof(LTE_UE_PDSCH));
+    prach_vars[eNB_id]     = (LTE_UE_PRACH *)malloc16_clear(sizeof(LTE_UE_PRACH));
+    pbch_vars[eNB_id]      = (LTE_UE_PBCH *)malloc16_clear(sizeof(LTE_UE_PBCH));
+
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      phy_init_lte_ue__PDSCH( (*pdsch_vars_th)[th_id][eNB_id], fp );
+    }
+
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      (*pdsch_vars_th)[th_id][eNB_id]->llr_shifts      = (uint8_t*)malloc16_clear(7*2*fp->N_RB_DL*12);
+      (*pdsch_vars_th)[th_id][eNB_id]->llr_shifts_p        = (*pdsch_vars_th)[0][eNB_id]->llr_shifts;
+      (*pdsch_vars_th)[th_id][eNB_id]->llr[1]              = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+      (*pdsch_vars_th)[th_id][eNB_id]->llr128_2ndstream    = (int16_t**)malloc16_clear( sizeof(int16_t*) );
+      (*pdsch_vars_th)[th_id][eNB_id]->rho                 = (int32_t**)malloc16_clear( fp->nb_antennas_rx*sizeof(int32_t*) );
+    }
+    
+    for (int i=0; i<fp->nb_antennas_rx; i++){
+      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	(*pdsch_vars_th)[th_id][eNB_id]->rho[i]     = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+      }
+      
+    }
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_rho2_ext      = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+    }
+    
+    for (i=0; i<fp->nb_antennas_rx; i++)
+      for (j=0; j<4; j++) {
+	const int idx = (j<<1)+i;
+	const size_t num = 7*2*fp->N_RB_DL*12+4;
+	for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	  (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_rho2_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	}
+	
+      }
+    
+    //const size_t num = 7*2*fp->N_RB_DL*12+4;
+    for (k=0;k<8;k++) { //harq_pid
+      for (l=0;l<8;l++) { //round
+	for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	  (*pdsch_vars_th)[th_id][eNB_id]->rxdataF_comp1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+	  (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_rho_ext[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+	  (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_mag1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+	  (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_magb1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+	}
+	
+	
+	for (int i=0; i<fp->nb_antennas_rx; i++)
+	  for (int j=0; j<4; j++) { //frame_parms->nb_antennas_tx; j++)
+	    const int idx = (j<<1)+i;
+	    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	      (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_rho_ext[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+	      (*pdsch_vars_th)[th_id][eNB_id]->rxdataF_comp1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+	      (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_mag1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+	      (*pdsch_vars_th)[th_id][eNB_id]->dl_ch_magb1[k][l][idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(fp->N_RB_DL*12) );
+	    }
+	    
+	  }
+      }
+    }
+    phy_init_lte_ue__PDSCH( pdsch_vars_SI[eNB_id], fp );
+    phy_init_lte_ue__PDSCH( pdsch_vars_ra[eNB_id], fp );
+    phy_init_lte_ue__PDSCH( pdsch_vars_p[eNB_id], fp );
+    phy_init_lte_ue__PDSCH( pdsch_vars_mch[eNB_id], fp );
+    
+    // 100 PRBs * 12 REs/PRB * 4 PDCCH SYMBOLS * 2 LLRs/RE
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      (*pdcch_vars_th)[th_id][eNB_id]->llr   = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      (*pdcch_vars_th)[th_id][eNB_id]->llr16 = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      (*pdcch_vars_th)[th_id][eNB_id]->wbar  = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      (*pdcch_vars_th)[th_id][eNB_id]->e_rx  = (int8_t*)malloc16_clear( 4*2*100*12 );
+      
+      (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_comp        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_rho_ext       = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->rho                 = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+    }
+    
+    for (i=0; i<fp->nb_antennas_rx; i++) {
+      //ue_pdcch_vars[eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*7*2) );
+      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	(*pdcch_vars_th)[th_id][eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(100*12*4) );
+      }
+      
+      for (j=0; j<4; j++) { //fp->nb_antennas_tx; j++)
+	int idx = (j<<1)+i;
+	//  size_t num = 7*2*fp->N_RB_DL*12;
+	size_t num = 4*100*12;  // 4 symbols, 100 PRBs, 12 REs per PRB
+	for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	  (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	  (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_rho_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	  (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+              (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	}
+      }
+    }
+    phy_init_lte_ue__PDSCH( pdsch_vars_SI[eNB_id], fp );
+    phy_init_lte_ue__PDSCH( pdsch_vars_ra[eNB_id], fp );
+    phy_init_lte_ue__PDSCH( pdsch_vars_p[eNB_id], fp );
+    phy_init_lte_ue__PDSCH( pdsch_vars_mch[eNB_id], fp );
+    
+    // 100 PRBs * 12 REs/PRB * 4 PDCCH SYMBOLS * 2 LLRs/RE
+    for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      (*pdcch_vars_th)[th_id][eNB_id]->llr   = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      (*pdcch_vars_th)[th_id][eNB_id]->llr16 = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      (*pdcch_vars_th)[th_id][eNB_id]->wbar  = (uint16_t*)malloc16_clear( 2*4*100*12*sizeof(uint16_t) );
+      (*pdcch_vars_th)[th_id][eNB_id]->e_rx  = (int8_t*)malloc16_clear( 4*2*100*12 );
+      
+      (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_comp        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_rho_ext       = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->rho                 = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+    }
+    
+    for (i=0; i<fp->nb_antennas_rx; i++) {
+      //ue_pdcch_vars[eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(fp->N_RB_DL*12*7*2) );
+
+      for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	(*pdcch_vars_th)[th_id][eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(100*12*4) );
+      }
+      
+      for (j=0; j<4; j++) { //fp->nb_antennas_tx; j++)
+	int idx = (j<<1)+i;
+	//  size_t num = 7*2*fp->N_RB_DL*12;
+	size_t num = 4*100*12;  // 4 symbols, 100 PRBs, 12 REs per PRB
+	for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+	  (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	  (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_rho_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	  (*pdcch_vars_th)[th_id][eNB_id]->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	  (*pdcch_vars_th)[th_id][eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	}
+      }
+    }
+    
+    // PBCH
+    pbch_vars[eNB_id]->rxdataF_ext         = (int32_t**)malloc16( fp->nb_antennas_rx*sizeof(int32_t*) );
+    pbch_vars[eNB_id]->rxdataF_comp        = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+    pbch_vars[eNB_id]->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+    pbch_vars[eNB_id]->llr                 = (int8_t*)malloc16_clear( 1920 );
+    prach_vars[eNB_id]->prachF             = (int16_t*)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
+    prach_vars[eNB_id]->prach              = (int16_t*)malloc16_clear( sizeof(int)*(7*2*sizeof(int)*(fp->ofdm_symbol_size*12)) );
+    
+    for (i=0; i<fp->nb_antennas_rx; i++) {
+      pbch_vars[eNB_id]->rxdataF_ext[i]    = (int32_t*)malloc16_clear( sizeof(int32_t)*6*12*4 );
+      
+      for (j=0; j<4; j++) {//fp->nb_antennas_tx;j++) {
+	int idx = (j<<1)+i;
+	pbch_vars[eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t)*6*12*4 );
+	pbch_vars[eNB_id]->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t)*6*12*4 );
+      }
+    }
+  
+    
+    pbch_vars[eNB_id]->decoded_output = (uint8_t*)malloc16_clear( 64 );
+  }
+
+  // initialization for the last instance of pdsch_vars (used for MU-MIMO)
+  for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+      (*pdsch_vars_th)[th_id][eNB_id]     = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+  }
+
+  pdsch_vars_SI[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+  pdsch_vars_ra[eNB_id]  = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+  pdsch_vars_p[eNB_id]   = (LTE_UE_PDSCH *)malloc16_clear( sizeof(LTE_UE_PDSCH) );
+
+  for (th_id=0; th_id<RX_NB_TH_MAX; th_id++) {
+    phy_init_lte_ue__PDSCH( (*pdsch_vars_th)[th_id][eNB_id], fp );
+    (*pdsch_vars_th)[th_id][eNB_id]->llr[1] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+  }
+
+
+  ue->sinr_CQI_dB = (double*) malloc16_clear( fp->N_RB_DL*12*sizeof(double) );
+
+  ue->init_averaging = 1;
+  // default value until overwritten by RRCConnectionReconfiguration
+  if (fp->nb_antenna_ports_eNB==2)
+    ue->pdsch_config_dedicated->p_a = dBm3;
+  else
+    ue->pdsch_config_dedicated->p_a = dB0;
+
+  // set channel estimation to do linear interpolation in time
+  ue->high_speed_flag = 1;
+  ue->ch_est_alpha    = 24576;
+
+  // enable MIB/SIB decoding by default
+  ue->decode_MIB = 1;
+  ue->decode_SIB = 1;
+
+  init_prach_tables(839);
+
+
+  return 0;
+}
+
+void init_lte_ue_transport(PHY_VARS_UE *ue,int abstraction_flag) {
+
+  int i,j,k;
+
+  for (i=0; i<NUMBER_OF_CONNECTED_eNB_MAX; i++) {
+    for (j=0; j<2; j++) {
+      for (k=0; k<2; k++) {
+	AssertFatal((ue->dlsch[k][i][j]  = new_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_TURBO_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag))!=NULL,"Can't get ue dlsch structures\n");
+
+	LOG_D(PHY,"dlsch[%d][%d][%d] => %p\n",k,i,j,ue->dlsch[i][j]);
+      }
+    }
+
+    AssertFatal((ue->ulsch[i]  = new_ue_ulsch(ue->frame_parms.N_RB_UL, abstraction_flag))!=NULL,"Can't get ue ulsch structures\n");
+
+    ue->dlsch_SI[i]  = new_ue_dlsch(1,1,NSOFT,MAX_TURBO_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
+    ue->dlsch_ra[i]  = new_ue_dlsch(1,1,NSOFT,MAX_TURBO_ITERATIONS,ue->frame_parms.N_RB_DL, abstraction_flag);
+
+    ue->transmission_mode[i] = ue->frame_parms.nb_antenna_ports_eNB==1 ? 1 : 2;
+  }
+
+  ue->frame_parms.pucch_config_common.deltaPUCCH_Shift = 1;
+
+  ue->dlsch_MCH[0]  = new_ue_dlsch(1,NUMBER_OF_HARQ_PID_MAX,NSOFT,MAX_TURBO_ITERATIONS_MBSFN,ue->frame_parms.N_RB_DL,0);
+
+}

openair1/PHY/INIT/lte_param_init.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -32,16 +32,23 @@
 
 extern PHY_VARS_eNB *eNB;
 extern PHY_VARS_UE *UE;
+extern RU_t *ru;
+extern void  phy_init_RU(RU_t*);
 
-void lte_param_init(unsigned char N_tx_port_eNB, 
+void lte_param_init(PHY_VARS_eNB **eNBp,
+		    PHY_VARS_UE **UEp,
+		    RU_t **rup,
+		    unsigned char N_tx_port_eNB,
                     unsigned char N_tx_phy,
-		    unsigned char N_rx,
+		    unsigned char N_rx_ru,
+                    unsigned char N_rx_ue,
 		    unsigned char transmission_mode,
 		    uint8_t extended_prefix_flag,
-		    frame_t frame_type, 
+		    frame_t frame_type,
 		    uint16_t Nid_cell,
 		    uint8_t tdd_config,
 		    uint8_t N_RB_DL,
+		    uint8_t pa,
 		    uint8_t threequarter_fs,
                     uint8_t osf,
 		    uint32_t perfect_ce)
@@ -49,13 +56,27 @@ void lte_param_init(unsigned char N_tx_port_eNB,
 
   LTE_DL_FRAME_PARMS *frame_parms;
   int i;
-
+  PHY_VARS_eNB *eNB;
+  PHY_VARS_UE  *UE;
+  RU_t         *ru;
   printf("Start lte_param_init\n");
-  eNB = malloc(sizeof(PHY_VARS_eNB));
-  UE = malloc(sizeof(PHY_VARS_UE));
+  *eNBp = malloc(sizeof(PHY_VARS_eNB));
+  *UEp = malloc(sizeof(PHY_VARS_UE));
+  *rup = malloc(sizeof(RU_t));
+  eNB = *eNBp;
+  UE  = *UEp;
+  ru  = *rup;
+  printf("eNB %p, UE %p, ru %p\n",eNB,UE,ru);
+
+
+
   memset((void*)eNB,0,sizeof(PHY_VARS_eNB));
   memset((void*)UE,0,sizeof(PHY_VARS_UE));
+  memset((void*)ru,0,sizeof(RU_t));
 
+  ru->eNB_list[0] = eNB;
+  eNB->RU_list[0] = ru;
+  ru->num_eNB=1;
 
   srand(0);
   randominit(0);
@@ -71,7 +92,7 @@ void lte_param_init(unsigned char N_tx_port_eNB,
   frame_parms->Nid_cell           = Nid_cell;
   frame_parms->nushift            = Nid_cell%6;
   frame_parms->nb_antennas_tx     = N_tx_phy;
-  frame_parms->nb_antennas_rx     = N_rx;
+  frame_parms->nb_antennas_rx     = N_rx_ru;
   frame_parms->nb_antenna_ports_eNB = N_tx_port_eNB;
   frame_parms->phich_config_common.phich_resource         = oneSixth;
   frame_parms->phich_config_common.phich_duration         = normal;
@@ -90,12 +111,18 @@ void lte_param_init(unsigned char N_tx_port_eNB,
 
   UE->is_secondary_ue = 0;
   UE->frame_parms = *frame_parms;
-  eNB->frame_parms = *frame_parms;
+  UE->frame_parms.nb_antennas_rx=N_rx_ue;
+  //  eNB->frame_parms = *frame_parms;
+  ru->frame_parms = *frame_parms;
+  ru->nb_tx = N_tx_phy;
+  ru->nb_rx = N_rx_ru;
+  ru->if_south = LOCAL_RF;
+
+  eNB->configured=1;
 
   eNB->transmission_mode[0] = transmission_mode;
   UE->transmission_mode[0] = transmission_mode;
 
-  init_lte_top(frame_parms);
   dump_frame_parms(frame_parms);
 
   UE->measurements.n_adj_cells=0;
@@ -105,23 +132,24 @@ void lte_param_init(unsigned char N_tx_port_eNB,
   for (i=0; i<3; i++)
     lte_gold(frame_parms,UE->lte_gold_table[i],Nid_cell+i);
 
-  init_lte_ue(UE,1,0);
+  printf("Calling init_lte_ue_signal\n");
+  init_lte_ue_signal(UE,1,0);
+  printf("Calling phy_init_lte_eNB\n");
   phy_init_lte_eNB(eNB,0,0);
-
+  printf("Calling phy_init_RU (%p)\n",ru);
+  phy_init_RU(ru);
   generate_pcfich_reg_mapping(&UE->frame_parms);
   generate_phich_reg_mapping(&UE->frame_parms);
 
   // DL power control init
   //if (transmission_mode == 1) {
+  UE->pdsch_config_dedicated->p_a  = pa;
+
   if (transmission_mode == 1 || transmission_mode ==7) {
-    eNB->pdsch_config_dedicated->p_a  = dB0; // 4 = 0dB
     ((eNB->frame_parms).pdsch_config_common).p_b = 0;
-    UE->pdsch_config_dedicated->p_a  = dB0; // 4 = 0dB
     ((UE->frame_parms).pdsch_config_common).p_b = 0;
   } else { // rho_a = rhob
-    eNB->pdsch_config_dedicated->p_a  = dBm3; // 4 = 0dB
     ((eNB->frame_parms).pdsch_config_common).p_b = 1;
-    UE->pdsch_config_dedicated->p_a  = dBm3; // 4 = 0dB
     ((UE->frame_parms).pdsch_config_common).p_b = 1;
   }
 
@@ -130,6 +158,13 @@ void lte_param_init(unsigned char N_tx_port_eNB,
   /* the UE code is multi-thread "aware", we need to setup this array */
   for (i = 0; i < 10; i++) UE->current_thread_id[i] = i % 2;
 
+  if (eNB->frame_parms.frame_type == TDD) {
+    if      (eNB->frame_parms.N_RB_DL == 100) ru->N_TA_offset = 624;
+    else if (eNB->frame_parms.N_RB_DL == 50)  ru->N_TA_offset = 624/2;
+    else if (eNB->frame_parms.N_RB_DL == 25)  ru->N_TA_offset = 624/4;
+  }
+  else ru->N_TA_offset=0;
+
   printf("Done lte_param_init\n");
 
 

openair1/PHY/INIT/lte_parms.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/INIT/vars.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/adjust_gain.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/defs.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -23,12 +23,6 @@
 #define __LTE_ESTIMATION_DEFS__H__
 
 #include "PHY/defs.h"
-/*
-#ifdef EMOS
-#include "SCHED/phy_procedures_emos.h"
-#endif
- */
-
 /** @addtogroup _PHY_PARAMETER_ESTIMATION_BLOCKS_
  * @{
  */
@@ -136,18 +130,6 @@ int lte_dl_mbsfn_channel_estimation(PHY_VARS_UE *phy_vars_ue,
                                     int subframe,
                                     unsigned char l);
 
-/*
-#ifdef EMOS
-int lte_dl_channel_estimation_emos(int dl_ch_estimates_emos[NB_ANTENNAS_RX*NB_ANTENNAS_TX][N_RB_DL_EMOS*N_PILOTS_PER_RB*N_SLOTS_EMOS],
-           int **rxdataF,
-           LTE_DL_FRAME_PARMS *frame_parms,
-           unsigned char Ns,
-           unsigned char p,
-           unsigned char l,
-           unsigned char sector);
-#endif
- */
-
 /*!
 \brief Frequency offset estimation for LTE
 We estimate the frequency offset by calculating the phase difference between channel estimates for symbols carrying pilots (l==0 or l==3/4). We take a moving average of the phase difference.

openair1/PHY/LTE_ESTIMATION/extern.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/filt96_32.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/freq_equalization.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -306,7 +306,7 @@ void freq_equalization(LTE_DL_FRAME_PARMS *frame_parms,
 
   AssertFatal(symbol<frame_parms->symbols_per_tti,"symbol %d >= %d\n",
 	      symbol,frame_parms->symbols_per_tti);
-  AssertFatal(Msc_RS<frame_parms->N_RB_UL*12,"Msc_RS %d >= %d\n",
+  AssertFatal(Msc_RS<=frame_parms->N_RB_UL*12,"Msc_RS %d >= %d\n",
 	      Msc_RS,frame_parms->N_RB_UL*12);
 
   for (re=0; re<(Msc_RS>>2); re++) {

openair1/PHY/LTE_ESTIMATION/lte_adjust_sync.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -149,10 +149,8 @@ int lte_est_timing_advance(LTE_DL_FRAME_PARMS *frame_parms,
   int temp, i, aa, max_pos = 0,ind;
   int max_val=0;
   short Re,Im,ncoef;
-#ifdef USER_MODE
 #ifdef DEBUG_PHY
   char fname[100],vname[100];
-#endif
 #endif
 
   ncoef = 32768 - coef;
@@ -187,12 +185,10 @@ int lte_est_timing_advance(LTE_DL_FRAME_PARMS *frame_parms,
 	       1);
 	break;
       }
-#ifdef USER_MODE
 #ifdef DEBUG_PHY
       sprintf(fname,"srs_ch_estimates_time_%d%d.m",ind,aa);
       sprintf(vname,"srs_time_%d%d",ind,aa);
       write_output(fname,vname,lte_eNB_srs->srs_ch_estimates_time[aa],frame_parms->ofdm_symbol_size*2,2,1);
-#endif
 #endif
     }
 
@@ -227,11 +223,8 @@ int lte_est_timing_advance(LTE_DL_FRAME_PARMS *frame_parms,
 
 int lte_est_timing_advance_pusch(PHY_VARS_eNB* eNB,uint8_t UE_id)
 {
-  static int first_run=1;
-  static int max_pos_fil2=0;
   int temp, i, aa, max_pos=0, max_val=0;
-  short Re,Im,coef=24576;
-  short ncoef = 32768 - coef;
+  short Re,Im;
 
   LTE_DL_FRAME_PARMS *frame_parms = &eNB->frame_parms;
   LTE_eNB_PUSCH *eNB_pusch_vars = eNB->pusch_vars[UE_id];
@@ -260,16 +253,9 @@ int lte_est_timing_advance_pusch(PHY_VARS_eNB* eNB,uint8_t UE_id)
   if (max_pos>frame_parms->ofdm_symbol_size/2)
     max_pos = max_pos-frame_parms->ofdm_symbol_size;
 
-  // filter position to reduce jitter
-  if (first_run == 1) {
-    first_run=0;
-    max_pos_fil2 = max_pos;
-  } else
-    max_pos_fil2 = ((max_pos_fil2 * coef) + (max_pos * ncoef)) >> 15;
-
   //#ifdef DEBUG_PHY
-  LOG_D(PHY,"frame %d: max_pos = %d, max_pos_fil = %d, sync_pos=%d\n",eNB->proc.frame_rx,max_pos,max_pos_fil2,sync_pos);
+  LOG_D(PHY,"frame %d: max_pos = %d, sync_pos=%d\n",eNB->proc.frame_rx,max_pos,sync_pos);
   //#endif //DEBUG_PHY
 
-  return(max_pos_fil2-sync_pos);
+  return max_pos - sync_pos;
 }

openair1/PHY/LTE_ESTIMATION/lte_dl_bf_channel_estimation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -19,9 +19,7 @@
  *      contact@openairinterface.org
  */
 
-#ifdef USER_MODE
 #include <string.h>
-#endif
 #include "defs.h"
 #include "PHY/defs.h"
 #include "filt16_32.h"

openair1/PHY/LTE_ESTIMATION/lte_dl_channel_estimation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -19,9 +19,7 @@
  *      contact@openairinterface.org
  */
 
-#ifdef USER_MODE
 #include <string.h>
-#endif
 #include "defs.h"
 #include "SCHED/defs.h"
 #include "PHY/defs.h"

openair1/PHY/LTE_ESTIMATION/lte_dl_channel_estimation_emos.c

@@ -1,151 +0,0 @@
-/*
- * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
- * 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
- */
-
-#ifdef USER_MODE
-#include <string.h>
-#endif
-#include "defs.h"
-#include "PHY/defs.h"
-#include "SCHED/phy_procedures_emos.h"
-
-// TODO: make channel estimation possible for multiple sectors (Gold sequences for pilots)
-
-//#define DEBUG_CH
-int lte_dl_channel_estimation_emos(int dl_ch_estimates_emos[NB_ANTENNAS_RX*NB_ANTENNAS_TX][N_RB_DL_EMOS*N_PILOTS_PER_RB*N_SLOTS_EMOS],
-                                   int **rxdataF,
-                                   LTE_DL_FRAME_PARMS *frame_parms,
-                                   unsigned char Ns,
-                                   unsigned char p,
-                                   unsigned char l,
-                                   unsigned char sector)
-{
-
-  int pilot[2][200] __attribute__((aligned(16)));
-  unsigned char nu,aarx;
-  unsigned short k;
-  unsigned int rb,pilot_cnt;
-  short ch[2],*pil,*rxF,*dl_ch,*dl_ch_prev; //*f,*f2,*fl,*f2l2,*fr,*f2r2;
-  int ch_offset,symbol_offset;
-  unsigned int n;
-  int i;
-
-  unsigned char symbol = l+((7-frame_parms->Ncp)*(Ns&1)); ///symbol within sub-frame
-
-  if ((p==0) && (l==0) )
-    nu = 0;
-  else if ((p==0) && (l>0))
-    nu = 3;
-  else if ((p==1) && (l==0))
-    nu = 3;
-  else if ((p==1) && (l>0))
-    nu = 0;
-  else {
-    msg("lte_dl_channel_estimation_emos: p %d, l %d -> ERROR\n",p,l);
-    return(-1);
-  }
-
-  if (sector > 2) {
-    msg("lte_dl_channel_estimation_emos: sector must be 0,1, or 2\n");
-    return(-1);
-  }
-
-  switch (Ns) {
-  case 0:
-    ch_offset = ((l==0)?0:1)*2*frame_parms->N_RB_DL;
-    break;
-
-  case 1:
-    ch_offset = ((l==0)?2:3)*2*frame_parms->N_RB_DL;
-    break;
-
-  case 12:
-    ch_offset = ((l==0)?4:5)*2*frame_parms->N_RB_DL;
-    break;
-
-  case 13:
-    ch_offset = ((l==0)?6:7)*2*frame_parms->N_RB_DL;
-    break;
-
-  default:
-    msg("lte_dl_channel_estimation_emos: Ns must be  0, 1, 12, or 13\n");
-    return(-1);
-    break;
-
-  }
-
-  symbol_offset = symbol*frame_parms->ofdm_symbol_size; // offset within rxdataF
-
-  k = nu + sector;
-
-  if (k > 6)
-    k -=6;
-
-#ifdef DEBUG_CH
-  printf("Channel Estimation : ch_offset %d, OFDM size %d, Ncp=%d, l=%d, Ns=%d, k=%d, symbol=%d\n",ch_offset,frame_parms->ofdm_symbol_size,frame_parms->Ncp,l,Ns,k,symbol);
-#endif
-
-  // generate pilot
-  lte_dl_cell_spec_rx(&pilot[p][0],
-                      frame_parms,
-                      Ns,
-                      (l==0)?0:1,
-                      p);
-
-
-  for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
-
-    pil   = (short *)&pilot[p][0];
-    rxF   = (short *)&rxdataF[aarx][((symbol_offset+k+frame_parms->first_carrier_offset)<<1)];
-    dl_ch = (short *)&dl_ch_estimates_emos[(p<<1)+aarx][ch_offset];
-    memset(dl_ch,0,frame_parms->N_RB_DL);
-
-    for (pilot_cnt=0; pilot_cnt<frame_parms->N_RB_DL; pilot_cnt++) {
-
-      dl_ch[0] = (short)(((int)pil[0]*rxF[0] - (int)pil[1]*rxF[1])>>15);
-      dl_ch[1] = (short)(((int)pil[0]*rxF[1] + (int)pil[1]*rxF[0])>>15);
-
-      pil+=2;    // Re Im
-      rxF+=24;   // remember replicated format (Re0 Im0 Re0 Im0) !!!
-      dl_ch+=2;
-
-    }
-
-    // printf("Second half\n");
-    // Second half of RBs
-    rxF   = (short *)&rxdataF[aarx][((symbol_offset+1+k)<<1)];
-
-    for (pilot_cnt=0; pilot_cnt<frame_parms->N_RB_DL; pilot_cnt++) {
-
-
-      dl_ch[0] = (short)(((int)pil[0]*rxF[0] - (int)pil[1]*rxF[1])>>15);
-      dl_ch[1] = (short)(((int)pil[0]*rxF[1] + (int)pil[1]*rxF[0])>>15);
-
-      pil+=2;
-      rxF+=24;
-      dl_ch+=2;
-
-    }
-
-  }
-
-  return(0);
-}
-

openair1/PHY/LTE_ESTIMATION/lte_dl_mbsfn_channel_estimation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -19,9 +19,7 @@
  *      contact@openairinterface.org
  */
 
-#ifdef USER_MODE
 #include <string.h>
-#endif
 #include "defs.h"
 #include "PHY/defs.h"
 

openair1/PHY/LTE_ESTIMATION/lte_eNB_measurements.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/lte_est_freq_offset.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/lte_sync_time.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -465,7 +465,7 @@ int lte_sync_time(int **rxdata, ///rx data in time domain
 
   *eNB_id = sync_source;
 
-  LOG_D(PHY,"[UE] lte_sync_time: Sync source = %d, Peak found at pos %d, val = %d (%d dB)\n",sync_source,peak_pos,peak_val,dB_fixed(peak_val)/2);
+  LOG_I(PHY,"[UE] lte_sync_time: Sync source = %d, Peak found at pos %d, val = %d (%d dB)\n",sync_source,peak_pos,peak_val,dB_fixed(peak_val)/2);
 
 
 #ifdef DEBUG_PHY
@@ -578,30 +578,3 @@ int lte_sync_time_eNB(int32_t **rxdata, ///rx data in time domain
 
 }
 
-#ifdef PHY_ABSTRACTION
-#include "SIMULATION/TOOLS/defs.h"
-#include "SIMULATION/RF/defs.h"
-//extern channel_desc_t *UE2eNB[NUMBER_OF_UE_MAX][NUMBER_OF_eNB_MAX];
-
-int lte_sync_time_eNB_emul(PHY_VARS_eNB *phy_vars_eNB,
-                           uint8_t sect_id,
-                           int32_t *sync_val)
-{
-
-  uint8_t UE_id;
-  uint8_t CC_id = phy_vars_eNB->CC_id;
-
-  LOG_E(PHY,"[PHY] EMUL lte_sync_time_eNB_emul eNB %d, sect_id %d\n",phy_vars_eNB->Mod_id,sect_id);
-  *sync_val = 0;
-
-  for (UE_id=0; UE_id<NB_UE_INST; UE_id++) {
-    //LOG_E(PHY,"[PHY] EMUL : eNB %d checking UE %d (PRACH %d) PL %d dB\n",phy_vars_eNB->Mod_id,UE_id,PHY_vars_UE_g[UE_id]->generate_prach,UE2eNB[UE_id][phy_vars_eNB->Mod_id]->path_loss_dB);
-    if ((PHY_vars_UE_g[UE_id][CC_id]->generate_prach == 1) && (phy_vars_eNB->Mod_id == (UE_id % NB_eNB_INST))) {
-      *sync_val = 1;
-      return(0);
-    }
-  }
-
-  return(-1);
-}
-#endif

openair1/PHY/LTE_ESTIMATION/lte_sync_timefreq.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/lte_ue_measurements.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -38,7 +38,6 @@
 
 int16_t cond_num_threshold = 0;
 
-#ifdef USER_MODE
 void print_shorts(char *s,short *x)
 {
 
@@ -57,8 +56,6 @@ void print_ints(char *s,int *x)
         );
 
 }
-#endif
-
 
 int16_t get_PL(uint8_t Mod_id,uint8_t CC_id,uint8_t eNB_index)
 {
@@ -210,10 +207,8 @@ void ue_rrc_measurements(PHY_VARS_UE *ue,
              ((ue->frame_parms.frame_type == TDD) && ((subframe == 1) || (subframe == 6)))
                 )
         {  // FDD PSS/SSS, compute noise in DTX REs
-
-          if (ue->frame_parms.Ncp==NORMAL) {
+          if (ue->frame_parms.Ncp == NORMAL) {
             for (aarx=0; aarx<ue->frame_parms.nb_antennas_rx; aarx++) {
-
           if(ue->frame_parms.frame_type == FDD)
           {
 	      rxF_sss = (int16_t *)&ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF[aarx][(5*ue->frame_parms.ofdm_symbol_size)];
@@ -269,7 +264,7 @@ void ue_rrc_measurements(PHY_VARS_UE *ue,
         ue->measurements.n0_power_tot_dB = (unsigned short) dB_fixed(ue->measurements.n0_power_tot/(12*aarx));
         ue->measurements.n0_power_tot_dBm = ue->measurements.n0_power_tot_dB - ue->rx_total_gain_dB - dB_fixed(ue->frame_parms.ofdm_symbol_size);
         } else {
-            LOG_E(PHY, "Not yet implemented: noise power calculation when prefix length = EXTENDED\n");
+            LOG_E(PHY, "Not yet implemented: noise power calculation when prefix length == EXTENDED\n");
         }
         }
         else if ((ue->frame_parms.frame_type == TDD) &&

openair1/PHY/LTE_ESTIMATION/lte_ul_channel_estimation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -91,7 +91,6 @@ int32_t temp_in_ifft_0[2048*2] __attribute__((aligned(32)));
                   eNB->ulsch[UE_id]->harq_processes[harq_pid]->n_DMRS2 +
                   frame_parms->pusch_config_common.ul_ReferenceSignalsPUSCH.nPRS[(subframe<<1)+Ns]) % 12;
 
-#if defined(USER_MODE)
   Msc_idx_ptr = (uint16_t*) bsearch(&Msc_RS, dftsizes, 33, sizeof(uint16_t), compareints);
 
   if (Msc_idx_ptr)
@@ -101,26 +100,14 @@ int32_t temp_in_ifft_0[2048*2] __attribute__((aligned(32)));
     return(-1);
   }
 
-#else
-  uint8_t b;
-
-  for (b=0; b<33; b++)
-    if (Msc_RS==dftsizes[b])
-      Msc_RS_idx = b;
-
-#endif
-
-  //  LOG_I(PHY,"subframe %d, Ns %d, l %d, Msc_RS = %d, Msc_RS_idx = %d, u %d, v %d, cyclic_shift %d\n",subframe,Ns,l,Msc_RS, Msc_RS_idx,u,v,cyclic_shift);
+  LOG_D(PHY,"subframe %d, Ns %d, l %d, Msc_RS = %d, Msc_RS_idx = %d, u %d, v %d, cyclic_shift %d\n",subframe,Ns,l,Msc_RS, Msc_RS_idx,u,v,cyclic_shift);
 #ifdef DEBUG_CH
 
-#ifdef USER_MODE
-
   if (Ns==0)
     write_output("drs_seq0.m","drsseq0",ul_ref_sigs_rx[u][v][Msc_RS_idx],2*Msc_RS,2,1);
   else
     write_output("drs_seq1.m","drsseq1",ul_ref_sigs_rx[u][v][Msc_RS_idx],2*Msc_RS,2,1);
 
-#endif
 #endif
 
 
@@ -304,7 +291,7 @@ int32_t temp_in_ifft_0[2048*2] __attribute__((aligned(32)));
 
 #ifdef DEBUG_CH
 
-      if (aa==0) {
+      if (aa==1) {
         if (Ns == 0) {
           write_output("rxdataF_ext.m","rxF_ext",&rxdataF_ext[aa][symbol_offset],512*2,2,1);
           write_output("tmpin_ifft.m","drs_in",temp_in_ifft_0,512,1,1);
@@ -489,12 +476,10 @@ int32_t lte_srs_channel_estimation(LTE_DL_FRAME_PARMS *frame_parms,
 			   15,
 			   0);
 
-#ifdef USER_MODE
 #ifdef DEBUG_SRS
       sprintf(fname,"srs_ch_est%d.m",aa);
       sprintf(vname,"srs_est%d",aa);
       write_output(fname,vname,srs_vars->srs_ch_estimates[aa],frame_parms->ofdm_symbol_size,1,1);
-#endif
 #endif
     }
 

openair1/PHY/LTE_ESTIMATION/pss6144.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_ESTIMATION/vars.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_REFSIG/defs.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_REFSIG/defs_NB_IoT.h

@@ -0,0 +1,60 @@
+/*******************************************************************************
+
+ *******************************************************************************/
+/*! \file PHY/LTE_REFSIG/defs_NB_IoT.c
+* \function called by lte_dl_cell_spec_NB_IoT.c ,	 TS 36-211, V13.4.0 2017-02
+* \author M. KANJ
+* \date 2017
+* \version 0.0
+* \company bcom
+* \email: matthieu.kanj@b-com.com
+* \note
+* \warning
+*/
+
+/* Definitions for NB_IoT Reference signals */
+
+#ifndef __LTE_REFSIG_DEFS_NB_IOT__H__
+#define __LTE_REFSIG_DEFS_NB_IOT__H__
+
+#include "PHY/defs_L1_NB_IoT.h"
+
+/** @ingroup _PHY_REF_SIG
+ * @{
+*/
+/*!\brief This function generates the LTE Gold sequence (36-211, Sec 7.2), specifically for DL reference signals.
+@param frame_parms LTE DL Frame parameters
+@param lte_gold_table pointer to table where sequences are stored
+@param Nid_cell Cell Id for NB_IoT (to compute sequences for local and adjacent cells) */
+
+void lte_gold_NB_IoT(NB_IoT_DL_FRAME_PARMS  *frame_parms,
+					 uint32_t 				lte_gold_table_NB_IoT[20][2][14],
+					 uint16_t 				Nid_cell);
+
+/*! \brief This function generates the Narrowband reference signal (NRS) sequence (36-211, Sec 6.10.1.1)
+@param phy_vars_eNB Pointer to eNB variables
+@param output Output vector for OFDM symbol (Frequency Domain)
+@param amp Q15 amplitude
+@param Ns Slot number (0..19)
+@param l symbol (0,1) - Note 1 means 3!
+@param p antenna index
+@param RB_IoT_ID the ID of the RB dedicated for NB_IoT
+*/
+int lte_dl_cell_spec_NB_IoT(PHY_VARS_eNB_NB_IoT  *phy_vars_eNB,
+                     		int32_t 			 *output,
+                     		short 				 amp,
+                     		unsigned char 		 Ns,
+                     		unsigned char 		 l,
+                     		unsigned char 		 p,
+					 		unsigned short 		 RB_IoT_ID); 
+
+
+unsigned int lte_gold_generic_NB_IoT(unsigned int  *x1,
+									 unsigned int  *x2,
+									 unsigned char reset);
+		
+void generate_ul_ref_sigs_rx_NB_IoT(void);
+
+void free_ul_ref_sigs_NB_IoT(void);
+			 
+#endif

openair1/PHY/LTE_REFSIG/lte_dl_cell_spec.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -19,10 +19,8 @@
  *      contact@openairinterface.org
  */
 
-#ifdef USER_MODE
 #include <stdio.h>
 #include <stdlib.h>
-#endif
 
 #include "defs.h"
 #include "PHY/defs.h"

openair1/PHY/LTE_REFSIG/lte_dl_mbsfn.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -21,10 +21,8 @@
 
 // 6.10.2.2 MBSFN reference signals Mapping to resource elements
 
-#ifdef USER_MODE
 #include <stdio.h>
 #include <stdlib.h>
-#endif
 
 #include "defs.h"
 #include "PHY/defs.h"

openair1/PHY/LTE_REFSIG/lte_dl_uespec.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -30,10 +30,8 @@
 * \warning
 */
 
-#ifdef USER_MODE
 #include <stdio.h>
 #include <stdlib.h>
-#endif
 
 #include "defs.h"
 #include "PHY/defs.h"

openair1/PHY/LTE_REFSIG/lte_gold.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_REFSIG/lte_gold_mbsfn.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_REFSIG/lte_ul_ref.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -185,14 +185,18 @@ void free_ul_ref_sigs(void)
 
   unsigned int u,v,Msc_RS;
 
-  for (Msc_RS=2; Msc_RS<33; Msc_RS++) {
+  for (Msc_RS=0; Msc_RS<33; Msc_RS++) {
     for (u=0; u<30; u++) {
       for (v=0; v<2; v++) {
-        if (ul_ref_sigs[u][v][Msc_RS])
+        if (ul_ref_sigs[u][v][Msc_RS]) {
           free16(ul_ref_sigs[u][v][Msc_RS],2*sizeof(int16_t)*dftsizes[Msc_RS]);
+          ul_ref_sigs[u][v][Msc_RS] = NULL;
+        }
 
-        if (ul_ref_sigs_rx[u][v][Msc_RS])
+        if (ul_ref_sigs_rx[u][v][Msc_RS]) {
           free16(ul_ref_sigs_rx[u][v][Msc_RS],4*sizeof(int16_t)*dftsizes[Msc_RS]);
+          ul_ref_sigs_rx[u][v][Msc_RS] = NULL;
+        }
       }
     }
   }

openair1/PHY/LTE_REFSIG/mod_table.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_REFSIG/primary_synch.h

@@ -1,3 +1,24 @@
+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
 short primary_synch0[144] = {0,0,0,0,0,0,0,0,0,0,32767,0,-26120,-19785,11971,-30502,-24020,-22288,32117,6492,31311,9658,-16384,-28378,25100,-21063,-7292,-31946,20429,25618,14948,29158,11971,-30502,31311,9658,25100,-21063,-16384,28377,-24020,22287,32117,6492,-7292,31945,20429,25618,-26120,-19785,-16384,-28378,-16384,28377,-26120,-19785,-32402,4883,31311,-9659,32117,6492,-7292,-31946,32767,-1,25100,-21063,-24020,22287,-32402,4883,-32402,4883,-24020,22287,25100,-21063,32767,-1,-7292,-31946,32117,6492,31311,-9659,-32402,4883,-26120,-19785,-16384,28377,-16384,-28378,-26120,-19785,20429,25618,-7292,31945,32117,6492,-24020,22287,-16384,28377,25100,-21063,31311,9658,11971,-30502,14948,29158,20429,25618,-7292,-31946,25100,-21063,-16384,-28378,31311,9658,32117,6492,-24020,-22288,11971,-30502,-26120,-19785,32767,0,0,0,0,0,0,0,0,0,0,0};
 short primary_synch1[144] = {0,0,0,0,0,0,0,0,0,0,32767,0,-31754,-8086,-24020,-22288,2448,32675,-26120,19784,27073,18458,-16384,28377,25100,21062,-29523,14217,-7292,31945,-13477,-29868,-24020,-22288,27073,18458,25100,21062,-16384,-28378,2448,-32676,-26120,19784,-29523,-14218,-7292,31945,-31754,-8086,-16384,28377,-16384,-28378,-31754,-8086,31311,-9659,27073,-18459,-26120,19784,-29523,14217,32767,-1,25100,21062,2448,-32676,31311,-9659,31311,-9659,2448,-32676,25100,21062,32767,0,-29523,14217,-26120,19784,27073,-18459,31311,-9659,-31754,-8086,-16384,-28378,-16384,28377,-31754,-8086,-7292,31945,-29523,-14218,-26120,19784,2448,-32676,-16384,-28378,25100,21062,27073,18458,-24020,-22288,-13477,-29868,-7292,31945,-29523,14217,25100,21062,-16384,28377,27073,18458,-26120,19784,2448,32675,-24020,-22288,-31754,-8086,32767,0,0,0,0,0,0,0,0,0,0,0};
 short primary_synch2[144] = {0,0,0,0,0,0,0,0,0,0,32767,0,-31754,8085,-24020,22287,2448,-32676,-26120,-19785,27073,-18459,-16384,-28378,25100,-21063,-29523,-14218,-7292,-31946,-13477,29867,-24020,22287,27073,-18459,25100,-21063,-16384,28377,2448,32675,-26120,-19785,-29523,14217,-7292,-31946,-31754,8085,-16384,-28378,-16384,28377,-31754,8085,31311,9658,27073,18458,-26120,-19785,-29523,-14218,32767,0,25100,-21063,2448,32675,31311,9658,31311,9658,2448,32675,25100,-21063,32767,0,-29523,-14218,-26120,-19785,27073,18458,31311,9658,-31754,8085,-16384,28377,-16384,-28378,-31754,8085,-7292,-31946,-29523,14217,-26120,-19785,2448,32675,-16384,28377,25100,-21063,27073,-18459,-24020,22287,-13477,29867,-7292,-31946,-29523,-14218,25100,-21063,-16384,-28378,27073,-18459,-26120,-19785,2448,-32676,-24020,22287,-31754,8085,32767,-1,0,0,0,0,0,0,0,0,0,0};

openair1/PHY/LTE_TRANSPORT/dci.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -29,20 +29,19 @@
 * \note
 * \warning
 */
-#ifdef USER_MODE
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#endif
 #include "PHY/defs.h"
 #include "PHY/extern.h"
 #include "SCHED/defs.h"
-#include "SIMULATION/TOOLS/defs.h" // for taus 
+#include "SIMULATION/TOOLS/defs.h" // for taus
 #include "PHY/sse_intrin.h"
 
-#include "assertions.h" 
+#include "assertions.h"
 #include "T.h"
 #include "UTIL/LOG/log.h"
+#include "UTIL/LOG/vcd_signal_dumper.h"
 
 //#define DEBUG_DCI_ENCODING 1
 //#define DEBUG_DCI_DECODING 1
@@ -153,7 +152,7 @@ uint16_t extract_crc(uint8_t *dci,uint8_t dci_len)
   //  dci[(dci_len>>3)+1] = 0;
   //  dci[(dci_len>>3)+2] = 0;
   return((uint16_t)crc16);
-  
+
 }
 
 
@@ -178,7 +177,7 @@ void dci_encoding(uint8_t *a,
   // encode dci
 
 #ifdef DEBUG_DCI_ENCODING
-  printf("Doing DCI encoding for %d bits, e %p, rnti %x\n",A,e,rnti);
+  printf("Doing DCI encoding for %d bits, e %p, rnti %x, E %d\n",A,e,rnti,E);
 #endif
 
   memset((void *)d,LTE_NULL,96);
@@ -216,10 +215,10 @@ uint8_t *generate_dci0(uint8_t *dci,
   uint16_t coded_bits;
   uint8_t dci_flip[8];
 
-  AssertFatal((aggregation_level==1) || 
-	      (aggregation_level==2) || 
-	      (aggregation_level==4) || 
-	      (aggregation_level==8) 
+  AssertFatal((aggregation_level==1) ||
+	      (aggregation_level==2) ||
+	      (aggregation_level==4) ||
+	      (aggregation_level==8)
 #ifdef Rel14 // Added for EPDCCH/MPDCCH
 	      ||
 	      (aggregation_level==16) ||
@@ -228,22 +227,27 @@ uint8_t *generate_dci0(uint8_t *dci,
 #endif
 	      ,
 	      "generate_dci FATAL, illegal aggregation_level %d\n",aggregation_level);
-  
+
 
   coded_bits = 72 * aggregation_level;
 
-  /*
+
 
   #ifdef DEBUG_DCI_ENCODING
-  for (i=0;i<1+((DCI_LENGTH+16)/8);i++)
+  for (int i=0;i<1+((DCI_LENGTH+16)/8);i++)
     printf("i %d : %x\n",i,dci[i]);
   #endif
-  */
+
   if (DCI_LENGTH<=32) {
     dci_flip[0] = dci[3];
     dci_flip[1] = dci[2];
     dci_flip[2] = dci[1];
     dci_flip[3] = dci[0];
+#ifdef DEBUG_DCI_ENCODING
+    printf("DCI => %x,%x,%x,%x\n",
+	   dci_flip[0],dci_flip[1],dci_flip[2],dci_flip[3]);
+
+#endif
   } else {
     dci_flip[0] = dci[7];
     dci_flip[1] = dci[6];
@@ -473,7 +477,7 @@ void pdcch_deinterleaving(LTE_DL_FRAME_PARMS *frame_parms,uint16_t *z, uint16_t
     wptr[1] = wptr2[1];
     wptr[2] = wptr2[2];
     wptr[3] = wptr2[3];
-    /*    
+    /*
     printf("pdcch_deinterleaving (%p,%p): quad %d (%d) -> (%d,%d %d,%d %d,%d %d,%d)\n",wptr,wptr2,i,(i+frame_parms->Nid_cell)%Mquad,
 	   ((char*)wptr2)[0],
 	   ((char*)wptr2)[1],
@@ -512,7 +516,7 @@ void pdcch_deinterleaving(LTE_DL_FRAME_PARMS *frame_parms,uint16_t *z, uint16_t
         zptr[2] = wptr[2];
         zptr[3] = wptr[3];
 
-	/*        
+	/*
         printf("deinterleaving ; k %d, index-Nd %d  => (%d,%d,%d,%d,%d,%d,%d,%d)\n",k,(index-ND),
                ((int8_t *)wptr)[0],
                ((int8_t *)wptr)[1],
@@ -533,7 +537,7 @@ void pdcch_deinterleaving(LTE_DL_FRAME_PARMS *frame_parms,uint16_t *z, uint16_t
 
   for (i=0; i<Mquad; i++) {
     zptr = &z[i<<2];
-    /*    
+    /*
     printf("deinterleaving ; quad %d  => (%d,%d,%d,%d,%d,%d,%d,%d)\n",i,
      ((int8_t *)zptr)[0],
      ((int8_t *)zptr)[1],
@@ -543,7 +547,7 @@ void pdcch_deinterleaving(LTE_DL_FRAME_PARMS *frame_parms,uint16_t *z, uint16_t
      ((int8_t *)zptr)[5],
      ((int8_t *)zptr)[6],
      ((int8_t *)zptr)[7]);
-    */  
+    */
   }
 
 }
@@ -1506,7 +1510,7 @@ void pdcch_channel_compensation(int32_t **rxdataF_ext,
       dl_ch128_2    = (__m128i *)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12];
 
 #elif defined(__arm__)
-      
+
 #endif
       for (rb=0; rb<frame_parms->N_RB_DL; rb++) {
 #if defined(__x86_64__) || defined(__i386__)
@@ -1870,12 +1874,6 @@ int32_t rx_pdcch(PHY_VARS_UE *ue,
 #endif //MU_RECEIVER
 
 
-#if T_TRACER
-  T(T_UE_PHY_PDCCH_IQ, T_INT(frame_parms->N_RB_DL), T_INT(frame_parms->N_RB_DL),
-    T_INT(n_pdcch_symbols),
-    T_BUFFER(pdcch_vars[eNB_id]->rxdataF_comp, frame_parms->N_RB_DL*12*n_pdcch_symbols* 4));
-#endif
-
   // decode pcfich here and find out pdcch ofdm symbol number
   n_pdcch_symbols = rx_pcfich(frame_parms,
                               subframe,
@@ -1886,6 +1884,12 @@ int32_t rx_pdcch(PHY_VARS_UE *ue,
   if (n_pdcch_symbols>3)
     n_pdcch_symbols=1;
 
+#if T_TRACER
+  T(T_UE_PHY_PDCCH_IQ, T_INT(frame_parms->N_RB_DL), T_INT(frame_parms->N_RB_DL),
+    T_INT(n_pdcch_symbols),
+    T_BUFFER(pdcch_vars[eNB_id]->rxdataF_comp, frame_parms->N_RB_DL*12*n_pdcch_symbols* 4));
+#endif
+
 
 #ifdef DEBUG_DCI_DECODING
 
@@ -2065,6 +2069,8 @@ void pdcch_scrambling(LTE_DL_FRAME_PARMS *frame_parms,
   uint8_t reset;
   uint32_t x1, x2, s=0;
 
+  //LOG_D(PHY, "%s(fp, subframe:%d, e, length:%d)\n", __FUNCTION__, subframe, length);
+
   reset = 1;
   // x1 is set in lte_gold_generic
 
@@ -2105,7 +2111,7 @@ void pdcch_unscrambling(LTE_DL_FRAME_PARMS *frame_parms,
       reset = 0;
     }
 
-    
+
     //    printf("unscrambling %d : e %d, c %d => ",i,llr[i],((s>>(i&0x1f))&1));
     if (((s>>(i%32))&1)==0)
       llr[i] = -llr[i];
@@ -2247,24 +2253,34 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
   }
 
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_PCFICH,1);
   generate_pcfich(num_pdcch_symbols,
                   amp,
                   frame_parms,
                   txdataF,
                   subframe);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_PCFICH,0);
   wbar[0] = &wbar0[0];
   wbar[1] = &wbar1[0];
   y[0] = &yseq0[0];
   y[1] = &yseq1[0];
 
+#if 1
   // reset all bits to <NIL>, here we set <NIL> elements as 2
   // memset(e, 2, DCI_BITS_MAX);
   // here we interpret NIL as a random QPSK sequence. That makes power estimation easier.
-  /*for (i=0; i<DCI_BITS_MAX; i++)
-    e[i]=taus()&1;*/
+  for (i=0; i<DCI_BITS_MAX; i++)
+    e[i]=taus()&1;
+#endif
+
+  /* clear all bits, the above code may generate too much false detections
+   * (not sure about this, to be checked somehow)
+   */
+  // memset(e, 0, DCI_BITS_MAX);
 
   e_ptr = e;
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DCI0,1);
 
   // generate DCIs in order of decreasing aggregation level, then common/ue spec
   // MAC is assumed to have ordered the UE spec DCI according to the RNTI-based randomization
@@ -2274,11 +2290,11 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
       if (dci_alloc[i].L == (uint8_t)L) {
 
 	#ifdef DEBUG_DCI_ENCODING
-	if (dci_alloc[i].rnti==0x02)
-	  LOG_I(PHY,"Generating DCI %d/%d (nCCE %d) of length %d, aggregation %d (%x), rnti %x\n",i,num_dci,dci_alloc[i].firstCCE,dci_alloc[i].dci_length,dci_alloc[i].L,
+	if (dci_alloc[i].rnti==0x1234)
+	  LOG_D(PHY,"Generating DCI %d/%d (nCCE %d) of length %d, aggregation %d (%x), rnti %x\n",i,num_dci,dci_alloc[i].firstCCE,dci_alloc[i].dci_length,dci_alloc[i].L,
 		*(unsigned int*)dci_alloc[i].dci_pdu,
 		dci_alloc[i].rnti);
-       //dump_dci(frame_parms,&dci_alloc[i]);
+       dump_dci(frame_parms,&dci_alloc[i]);
 	#endif
 
         if (dci_alloc[i].firstCCE>=0) {
@@ -2291,18 +2307,26 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
       }
     }
   }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_GENERATE_DCI0,0);
 
   // Scrambling
-  //  printf("pdcch scrambling\n");
+#ifdef DEBUG_DCI_ENCODING
+  printf("pdcch scrambling\n");
+#endif
+  //LOG_D(PHY, "num_pdcch_symbols:%d mi:%d nquad:%d\n", num_pdcch_symbols, mi, get_nquad(num_pdcch_symbols, frame_parms, mi));
+
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_SCRAMBLING,1);
   pdcch_scrambling(frame_parms,
                    subframe,
                    e,
                    8*get_nquad(num_pdcch_symbols, frame_parms, mi));
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_SCRAMBLING,0);
   //72*get_nCCE(num_pdcch_symbols,frame_parms,mi));
 
 
 
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_MODULATION,1);
   // Now do modulation
   if (frame_parms->nb_antenna_ports_eNB==1)
     gain_lin_QPSK = (int16_t)((amp*ONE_OVER_SQRT2_Q15)>>15);
@@ -2315,12 +2339,13 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
   printf(" PDCCH Modulation, Msymb %d, Msymb2 %d,gain_lin_QPSK %d\n",Msymb,Msymb2,gain_lin_QPSK);
 #endif
 
+  //LOG_D(PHY,"%s() Msymb2:%d\n", __FUNCTION__, Msymb2);
 
   if (frame_parms->nb_antenna_ports_eNB==1) { //SISO
 
 
     for (i=0; i<Msymb2; i++) {
-      
+
       //((int16_t*)(&(y[0][i])))[0] = (*e_ptr == 1) ? -gain_lin_QPSK : gain_lin_QPSK;
       //((int16_t*)(&(y[1][i])))[0] = (*e_ptr == 1) ? -gain_lin_QPSK : gain_lin_QPSK;
       ((int16_t*)(&(y[0][i])))[0] = (*e_ptr == 2) ? 0 : (*e_ptr == 1) ? -gain_lin_QPSK : gain_lin_QPSK;
@@ -2361,22 +2386,38 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
 
     }
   }
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_MODULATION,0);
 
 
 #ifdef DEBUG_DCI_ENCODING
   printf(" PDCCH Interleaving\n");
 #endif
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_INTERLEAVING,1);
   //  printf("y %p (%p,%p), wbar %p (%p,%p)\n",y,y[0],y[1],wbar,wbar[0],wbar[1]);
   // This is the interleaving procedure defined in 36-211, first part of Section 6.8.5
   pdcch_interleaving(frame_parms,&y[0],&wbar[0],num_pdcch_symbols,mi);
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_INTERLEAVING,0);
 
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_TX,1);
   mprime=0;
   nsymb = (frame_parms->Ncp==0) ? 14:12;
   re_offset = frame_parms->first_carrier_offset;
 
   // This is the REG allocation algorithm from 36-211, second part of Section 6.8.5
   //  printf("DCI (SF %d) : txdataF %p (0 %p)\n",subframe,&txdataF[0][512*14*subframe],&txdataF[0][0]);
+#ifdef DEBUG_DCI_ENCODING
+  printf("kprime loop - N_RB_DL:%d lprime:num_pdcch_symbols:%d Ncp:%d pcfich:%02x,%02x,%02x,%02x ofdm_symbol_size:%d first_carrier_offset:%d nb_antenna_ports_eNB:%d\n",
+  frame_parms->N_RB_DL, num_pdcch_symbols,frame_parms->Ncp,
+  frame_parms->pcfich_reg[0],
+  frame_parms->pcfich_reg[1],
+  frame_parms->pcfich_reg[2],
+  frame_parms->pcfich_reg[3],
+  frame_parms->ofdm_symbol_size,
+  frame_parms->first_carrier_offset,
+  frame_parms->nb_antenna_ports_eNB
+  );
+#endif
   for (kprime=0; kprime<frame_parms->N_RB_DL*12; kprime++) {
     for (lprime=0; lprime<num_pdcch_symbols; lprime++) {
 
@@ -2493,6 +2534,7 @@ uint8_t generate_dci_top(uint8_t num_pdcch_symbols,
     if (re_offset == (frame_parms->ofdm_symbol_size))
       re_offset = 1;
   } // kprime loop
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PDCCH_TX,0);
 
   return(num_pdcch_symbols);
 }
@@ -2617,15 +2659,15 @@ uint16_t get_nCCE_mac(uint8_t Mod_id,uint8_t CC_id,int num_pdcch_symbols,int sub
   // check for eNB only !
   return(get_nCCE(num_pdcch_symbols,
 		  &RC.eNB[Mod_id][CC_id]->frame_parms,
-		  get_mi(&RC.eNB[Mod_id][CC_id]->frame_parms,subframe))); 
+		  get_mi(&RC.eNB[Mod_id][CC_id]->frame_parms,subframe)));
 }
 
 
 int get_nCCE_offset_l1(int *CCE_table,
-		       const unsigned char L, 
-		       const int nCCE, 
-		       const int common_dci, 
-		       const unsigned short rnti, 
+		       const unsigned char L,
+		       const int nCCE,
+		       const int common_dci,
+		       const unsigned short rnti,
 		       const unsigned char subframe)
 {
 
@@ -2655,7 +2697,7 @@ int get_nCCE_offset_l1(int *CCE_table,
           break;
         }
       }
-     
+
       if (search_space_free == 1) {
 
 	//	printf("returning %d\n",m*L);
@@ -2857,17 +2899,17 @@ void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars,
         LOG_D(PHY,"[DCI search nPdcch %d - common] Attempting candidate %d Aggregation Level %d DCI length %d at CCE %d/%d (CCEmap %x,CCEmap_cand %x)\n",
                 pdcch_vars[eNB_id]->num_pdcch_symbols,m,L2,sizeof_bits,CCEind,nCCE,*CCEmap,CCEmap_mask);
       else
-        LOG_D(PHY,"[DCI search nPdcch %d - ue spec] Attempting candidate %d Aggregation Level %d DCI length %d at CCE %d/%d (CCEmap %x,CCEmap_cand %x) format %d\n",
-                pdcch_vars[eNB_id]->num_pdcch_symbols,m,L2,sizeof_bits,CCEind,nCCE,*CCEmap,CCEmap_mask,format_c);
+        LOG_D(PHY,"[DCI search nPdcch %d - ue spec %x] Attempting candidate %d Aggregation Level %d DCI length %d at CCE %d/%d (CCEmap %x,CCEmap_cand %x) format %d\n",
+	      pdcch_vars[eNB_id]->num_pdcch_symbols,pdcch_vars[eNB_id]->crnti,m,L2,sizeof_bits,CCEind,nCCE,*CCEmap,CCEmap_mask,format_c);
 
        dci_decoding(sizeof_bits,
                    L,
                    &pdcch_vars[eNB_id]->e_rx[CCEind*72],
                    &dci_decoded_output[current_thread_id][0]);
-      /*
+       /*
         for (i=0;i<3+(sizeof_bits>>3);i++)
-        printf("dci_decoded_output[%d] => %x\n",i,dci_decoded_output[i]);
-      */
+	  printf("dci_decoded_output[%d][%d] => %x\n",current_thread_id,i,dci_decoded_output[current_thread_id][i]);
+       */
 
       crc = (crc16(&dci_decoded_output[current_thread_id][0],sizeof_bits)>>16) ^ extract_crc(&dci_decoded_output[current_thread_id][0],sizeof_bits);
 #ifdef DEBUG_DCI_DECODING
@@ -2978,7 +3020,7 @@ void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars,
          return;
       } // rnti match
     }  // CCEmap_cand == 0
-/*    
+/*
 	if ( agregationLevel != 0xFF &&
         (format_c == format0 && m==0 && si_rnti != SI_RNTI))
     {
@@ -3088,8 +3130,8 @@ uint16_t dci_CRNTI_decoding_procedure(PHY_VARS_UE *ue,
                           mi,
                           ((ue->decode_SIB == 1) ? SI_RNTI : 0),
                           ra_rnti,
-              P_RNTI,
-              agregationLevel,
+			  P_RNTI,
+			  agregationLevel,
                           format1A,
                           format1A,
                           format1A,
@@ -3107,7 +3149,7 @@ uint16_t dci_CRNTI_decoding_procedure(PHY_VARS_UE *ue,
       ((format0_found==1)&&(format_c_found==1)))
     return(dci_cnt);
 
-  if (DCIFormat == 1)
+  if (DCIFormat == format1)
   {
       if ((tmode < 3) || (tmode == 7)) {
           //printf("Crnti decoding frame param agregation %d DCI %d \n",agregationLevel,DCIFormat);
@@ -3150,14 +3192,14 @@ uint16_t dci_CRNTI_decoding_procedure(PHY_VARS_UE *ue,
           //printf("Crnti 1 decoding frame param agregation %d DCI %d \n",agregationLevel,DCIFormat);
 
       }
-      else
+      else if (DCIFormat == format1A)
       {
           AssertFatal(0,"Other Transmission mode not yet coded\n");
       }
   }
   else
   {
-     AssertFatal(0,"DCI format %d not yet implemented \n",DCIFormat);
+     LOG_W(PHY,"DCI format %d wrong or not yet implemented \n",DCIFormat);
   }
 
   return(dci_cnt);
@@ -3381,7 +3423,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
 
   if (do_common == 1) {
 #ifdef DEBUG_DCI_DECODING
-    printf("[DCI search] doing common search/format0 aggregation 4\n");
+    printf("[DCI search] subframe %d: doing common search/format0 aggregation 4\n",subframe);
 #endif
 
     if (ue->prach_resources[eNB_id])
@@ -3786,7 +3828,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
   } else if (tmode == 3) {
 
 
-    LOG_D(PHY," Now check UE_SPEC format 2A_2A search aggregation 1 dci length: %d[bits] %d[bytes]\n",format2A_size_bits,format2A_size_bytes);
+    //    LOG_D(PHY," Now check UE_SPEC format 2A_2A search aggregation 1 dci length: %d[bits] %d[bytes]\n",format2A_size_bits,format2A_size_bytes);
     // Now check UE_SPEC format 2A_2A search spaces at aggregation 1
     old_dci_cnt=dci_cnt;
     dci_decoding_procedure0(pdcch_vars,0,mode,
@@ -3858,7 +3900,7 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
       return(dci_cnt);
 
     // Now check UE_SPEC format 2_2A search spaces at aggregation 4
-    LOG_D(PHY," Now check UE_SPEC format 2_2A search spaces at aggregation 4 \n");
+    //    LOG_D(PHY," Now check UE_SPEC format 2_2A search spaces at aggregation 4 \n");
     old_dci_cnt=dci_cnt;
     dci_decoding_procedure0(pdcch_vars,0,mode,
                             subframe,
@@ -4201,33 +4243,3 @@ uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
 
   return(dci_cnt);
 }
-
-#ifdef PHY_ABSTRACTION
-uint16_t dci_decoding_procedure_emul(LTE_UE_PDCCH **pdcch_vars,
-                                     uint8_t num_ue_spec_dci,
-                                     uint8_t num_common_dci,
-                                     DCI_ALLOC_t *dci_alloc_tx,
-                                     DCI_ALLOC_t *dci_alloc_rx,
-                                     int16_t eNB_id)
-{
-
-  uint8_t  dci_cnt=0,i;
-
-  memcpy(dci_alloc_rx,dci_alloc_tx,num_common_dci*sizeof(DCI_ALLOC_t));
-  dci_cnt = num_common_dci;
-  LOG_D(PHY,"[DCI][EMUL] : num_common_dci %d\n",num_common_dci);
-
-  for (i=num_common_dci; i<(num_ue_spec_dci+num_common_dci); i++) {
-    LOG_D(PHY,"[DCI][EMUL] Checking dci %d => %x format %d (bit 0 %d)\n",i,pdcch_vars[eNB_id]->crnti,dci_alloc_tx[i].format,
-          dci_alloc_tx[i].dci_pdu[0]&0x80);
-
-    if (dci_alloc_tx[i].rnti == pdcch_vars[eNB_id]->crnti) {
-      memcpy(dci_alloc_rx+dci_cnt,dci_alloc_tx+i,sizeof(DCI_ALLOC_t));
-      dci_cnt++;
-    }
-  }
-
-
-  return(dci_cnt);
-}
-#endif

openair1/PHY/LTE_TRANSPORT/dci.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -482,8 +482,8 @@ typedef struct DCI1A_20MHz_FDD DCI1A_20MHz_FDD_t;
 
 /// DCI Format Type 1 (1.5 MHz, TDD, 23 bits)
 struct DCI1_1_5MHz_TDD {
-  /// Dummy bits to align to 32-bits
-  uint32_t dummy:9;
+  /// padding bits to align to 32-bits
+  uint32_t padding:9;
   /// DAI (TDD)
   uint32_t dai:2;
   /// Power Control
@@ -507,8 +507,8 @@ typedef struct DCI1_1_5MHz_TDD DCI1_1_5MHz_TDD_t;
 
 /// DCI Format Type 1 (5 MHz, TDD, 30 bits)
 struct DCI1_5MHz_TDD {
-  /// Dummy bits to align to 32-bits
-  uint32_t dummy:2;
+  /// padding bits to align to 32-bits
+  uint32_t padding:2;
   /// DAI (TDD)
   uint32_t dai:2;
   /// Power Control
@@ -532,8 +532,8 @@ typedef struct DCI1_5MHz_TDD DCI1_5MHz_TDD_t;
 
 /// DCI Format Type 1 (10 MHz, TDD, 34 bits)
 struct DCI1_10MHz_TDD {
-  /// Dummy bits to align to 64-bits
-  uint64_t dummy:30;
+  /// padding bits to align to 64-bits
+  uint64_t padding:30;
   /// DAI (TDD)
   uint64_t dai:2;
   /// Power Control
@@ -557,8 +557,8 @@ typedef struct DCI1_10MHz_TDD DCI1_10MHz_TDD_t;
 
 /// DCI Format Type 1 (20 MHz, TDD, 42 bits)
 struct DCI1_20MHz_TDD {
-  /// Dummy bits to align to 64-bits
-  uint64_t dummy:22;
+  /// padding bits to align to 64-bits
+  uint64_t padding:22;
   /// DAI (TDD)
   uint64_t dai:2;
   /// Power Control
@@ -582,8 +582,8 @@ typedef struct DCI1_20MHz_TDD DCI1_20MHz_TDD_t;
 
 /// DCI Format Type 1 (1.5 MHz, FDD, 21 bits)
 struct DCI1_1_5MHz_FDD {
-  /// Dummy bits to align to 32-bits
-  uint32_t dummy:11;
+  /// padding bits to align to 32-bits
+  uint32_t padding:11;
   /// Power Control
   uint32_t TPC:2;
   /// Redundancy version
@@ -605,8 +605,8 @@ typedef struct DCI1_1_5MHz_FDD DCI1_1_5MHz_FDD_t;
 
 /// DCI Format Type 1 (5 MHz, FDD, 27 bits)
 struct DCI1_5MHz_FDD {
-  /// dummy bits (not transmitted)
-  uint32_t dummy:5;
+  /// padding its (not transmitted)
+  uint32_t padding:5;
   /// Power Control
   uint32_t TPC:2;
   /// Redundancy version
@@ -628,8 +628,8 @@ typedef struct DCI1_5MHz_FDD DCI1_5MHz_FDD_t;
 
 /// DCI Format Type 1 (10 MHz, FDD, 31 bits)
 struct DCI1_10MHz_FDD {
-  /// dummy bits (not transmitted)
-  uint32_t dummy:1;
+  /// padding bits (not transmitted)
+  uint32_t padding:1;
   /// Power Control
   uint32_t TPC:2;
   /// Redundancy version
@@ -651,8 +651,8 @@ typedef struct DCI1_10MHz_FDD DCI1_10MHz_FDD_t;
 
 /// DCI Format Type 1 (20 MHz, FDD, 39 bits)
 struct DCI1_20MHz_FDD {
-  /// dummy bits (not transmitted)
-  uint64_t dummy:25;
+  /// padding bits (not transmitted)
+  uint64_t padding:25;
   /// Power Control
   uint64_t TPC:2;
   /// Redundancy version
@@ -674,10 +674,8 @@ typedef struct DCI1_20MHz_FDD DCI1_20MHz_FDD_t;
 
 /// DCI Format Type 1A (5 MHz, TDD, frame 1-6, 27 bits)
 struct DCI1A_RA_5MHz_TDD_1_6 {
-  /// Dummy bits to align to 32-bits
-  uint32_t dummy:5;
-  /// Padding
-  uint32_t padding:6;
+  /// padding bits to align to 32-bits
+  uint32_t padding:11;
   /// PRACH mask index
   uint32_t prach_mask_index:4;
   /// Preamble Index
@@ -822,7 +820,7 @@ typedef struct DCI1B_5MHz_4A_TDD DCI1B_5MHz_4A_TDD_t;
 struct DCI1C_1_5MHz
 {
   /// padding to 32bits
-  uint32_t padding32:24;
+  uint32_t padding:24;
   uint32_t mcs:5;
   uint32_t rballoc:3;  // N_RB_step = 2, Ngap=Ngap1=3, NDLVRBGap = 6, ceil(log2((3*4)/2)) = 3
 } __attribute__ ((__packed__));
@@ -836,7 +834,7 @@ typedef struct DCI1C_1_5MHz DCI1C_1_5MHz_t;
 struct DCI1C_5MHz
 {
   /// padding to 32bits
-  uint32_t padding32:20;
+  uint32_t padding:20;
   uint32_t mcs:5;
   uint32_t rballoc:7;   // N_RB_step = 2, Ngap1=Ngap2=12, NDLVRBGap = 24, ceil(log2((12*13)/2)) = 7
 } __attribute__ ((__packed__));
@@ -848,7 +846,7 @@ typedef struct DCI1C_5MHz DCI1C_5MHz_t;
 struct DCI1C_10MHz
 {
   /// padding to 32bits
-  uint32_t padding32:19;
+  uint32_t padding:19;
   uint32_t mcs:5;
   uint32_t rballoc:7;  // N_RB_step = 4, Ngap1=27, NDLVRBGap = 46, ceil(log2(((11*12)/2)) = 7
   uint32_t Ngap:1;
@@ -861,7 +859,7 @@ typedef struct DCI1C_10MHz DCI1C_10MHz_t;
 struct DCI1C_15MHz
 {
   /// padding to 32bits
-  uint32_t padding32:18;
+  uint32_t padding:18;
   uint32_t mcs:5;
   uint32_t rballoc:8; // N_RB_step = 4, Ngap1=64, ceil(log2((16*17)/2)) = 8
   uint32_t Ngap:1;
@@ -874,7 +872,7 @@ typedef struct DCI1C_15MHz DCI1C_15MHz_t;
 struct DCI1C_20MHz
 {
   /// padding to 32bits
-  uint32_t padding32:17;
+  uint32_t padding:17;
   uint32_t mcs:5;
   uint32_t rballoc:9; // N_RB_step = 4, Ngap1=48, ceil(log2((24*25)/2)) = 9
   uint32_t Ngap:1;
@@ -1006,7 +1004,7 @@ typedef struct DCI1D_5MHz_4A_TDD DCI1D_5MHz_4A_TDD_t;
 /// DCI Format Type 1E (5 MHz, TDD, 2 Antenna Ports, more than 10 PRBs, 34 bits)
 struct DCI1E_5MHz_2A_M10PRB_TDD {
   /// padding to 64bits
-  uint64_t padding64:30;
+  uint64_t padding:30;
   /// Redundancy version 2
   ///uint64_t rv2:2;
   /// New Data Indicator 2
@@ -1045,7 +1043,7 @@ typedef struct DCI1E_5MHz_2A_M10PRB_TDD DCI1E_5MHz_2A_M10PRB_TDD_t;
 /// DCI Format Type 2 (1.5 MHz, TDD, 2 Antenna Ports, 34 bits)
 struct DCI2_1_5MHz_2A_TDD {
   /// padding to 64bits
-  uint64_t padding64:30;
+  uint64_t padding:30;
   /// TPMI information for precoding
   uint64_t tpmi:3;
   /// Redundancy version 2
@@ -1078,7 +1076,7 @@ typedef struct DCI2_1_5MHz_2A_TDD DCI2_1_5MHz_2A_TDD_t;
 /// DCI Format Type 2 (1.5 MHz, TDD, 4 Antenna Ports, 37 bits)
 struct DCI2_1_5MHz_4A_TDD {
   /// padding for 64-bit
-  uint64_t padding64:27;
+  uint64_t padding:27;
   /// TPMI information for precoding
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -1111,7 +1109,7 @@ typedef struct DCI2_1_5MHz_4A_TDD DCI2_1_5MHz_4A_TDD_t;
 /// DCI Format Type 2 (5 MHz, TDD, 2 Antenna Ports, 42 bits)
 struct DCI2_5MHz_2A_TDD {
   /// padding to 64bits
-  uint64_t padding64:22;
+  uint64_t padding:22;
   /// TPMI information for precoding
   uint64_t tpmi:3;
   /// Redundancy version 2
@@ -1146,7 +1144,7 @@ typedef struct DCI2_5MHz_2A_TDD DCI2_5MHz_2A_TDD_t;
 /// DCI Format Type 2 (5 MHz, TDD, 4 Antenna Ports, 45 bits)
 struct DCI2_5MHz_4A_TDD {
   /// padding for 64-bit
-  uint64_t padding64:19;
+  uint64_t padding:19;
   /// TPMI information for precoding
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -1181,7 +1179,7 @@ typedef struct DCI2_5MHz_4A_TDD DCI2_5MHz_4A_TDD_t;
 /// DCI Format Type 2 (10 MHz, TDD, 2 Antenna Ports, 46 bits)
 struct DCI2_10MHz_2A_TDD {
   /// padding to 64bits
-  uint64_t padding64:18;
+  uint64_t padding:18;
   /// TPMI information for precoding
   uint64_t tpmi:3;
   /// Redundancy version 2
@@ -1216,7 +1214,7 @@ typedef struct DCI2_10MHz_2A_TDD DCI2_10MHz_2A_TDD_t;
 /// DCI Format Type 2 (10 MHz, TDD, 4 Antenna Ports, 49 bits)
 struct DCI2_10MHz_4A_TDD {
   /// padding for 64-bit
-  uint64_t padding64:15;
+  uint64_t padding:15;
   /// TPMI information for precoding
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -1251,7 +1249,7 @@ typedef struct DCI2_10MHz_4A_TDD DCI2_10MHz_4A_TDD_t;
 /// DCI Format Type 2 (20 MHz, TDD, 2 Antenna Ports, 54 bits)
 struct DCI2_20MHz_2A_TDD {
   /// padding to 64bits
-  uint64_t padding64:10;
+  uint64_t padding:10;
   /// TPMI information for precoding
   uint64_t tpmi:3;
   /// Redundancy version 2
@@ -1286,7 +1284,7 @@ typedef struct DCI2_20MHz_2A_TDD DCI2_20MHz_2A_TDD_t;
 /// DCI Format Type 2 (20 MHz, TDD, 4 Antenna Ports, 57 bits)
 struct DCI2_20MHz_4A_TDD {
   /// padding for 64-bit
-  uint64_t padding64:7;
+  uint64_t padding:7;
   /// TPMI information for precoding
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -1321,7 +1319,7 @@ typedef struct DCI2_20MHz_4A_TDD DCI2_20MHz_4A_TDD_t;
 /// DCI Format Type 2 (1.5 MHz, FDD, 2 Antenna Ports, 31 bits)
 struct DCI2_1_5MHz_2A_FDD {
   //padding for 32 bits
-  uint32_t padding32:1;
+  uint32_t padding:1;
   /// precoding bits
   uint32_t tpmi:3;
   /// Redundancy version 2
@@ -1352,7 +1350,7 @@ typedef struct DCI2_1_5MHz_2A_FDD DCI2_1_5MHz_2A_FDD_t;
 /// DCI Format Type 2 (1.5 MHz, FDD, 4 Antenna Ports, 34 bits)
 struct DCI2_1_5MHz_4A_FDD {
   /// padding for 32 bits
-  uint64_t padding64:30;
+  uint64_t padding:30;
   /// precoding bits
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -1383,7 +1381,7 @@ typedef struct DCI2_1_5MHz_4A_FDD DCI2_1_5MHz_4A_FDD_t;
 /// DCI Format Type 2 (5 MHz, FDD, 2 Antenna Ports, 39 bits)
 struct DCI2_5MHz_2A_FDD {
   /// padding for 64-bit
-  uint64_t padding64:25;
+  uint64_t padding:25;
   /// TPMI information for precoding
   uint64_t tpmi:3;
   /// Redundancy version 2
@@ -1416,7 +1414,7 @@ typedef struct DCI2_5MHz_2A_FDD DCI2_5MHz_2A_FDD_t;
 /// DCI Format Type 2 (5 MHz, TDD, 4 Antenna Ports, 42 bits)
 struct DCI2_5MHz_4A_FDD {
   /// padding for 64-bit
-  uint64_t padding64:21;
+  uint64_t padding:21;
   /// TPMI information for precoding
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -1448,7 +1446,7 @@ typedef struct DCI2_5MHz_4A_FDD DCI2_5MHz_4A_FDD_t;
 /// DCI Format Type 2 (10 MHz, FDD, 2 Antenna Ports, 43 bits)
 struct DCI2_10MHz_2A_FDD {
   /// padding for 64-bit
-  uint64_t padding64:21;
+  uint64_t padding:21;
   /// TPMI information for precoding
   uint64_t tpmi:3;
   /// Redundancy version 2
@@ -1481,7 +1479,7 @@ typedef struct DCI2_10MHz_2A_FDD DCI2_10MHz_2A_FDD_t;
 /// DCI Format Type 2 (5 MHz, TDD, 4 Antenna Ports, 46 bits)
 struct DCI2_10MHz_4A_FDD {
   /// padding for 64-bit
-  uint64_t padding64:18;
+  uint64_t padding:18;
   /// TPMI information for precoding
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -1513,7 +1511,7 @@ typedef struct DCI2_10MHz_4A_FDD DCI2_10MHz_4A_FDD_t;
 /// DCI Format Type 2 (20 MHz, FDD, 2 Antenna Ports, 51 bits)
 struct DCI2_20MHz_2A_FDD {
   /// padding for 64-bit
-  uint64_t padding64:13;
+  uint64_t padding:13;
   /// TPMI information for precoding
   uint64_t tpmi:3;
   /// Redundancy version 2
@@ -1546,7 +1544,7 @@ typedef struct DCI2_20MHz_2A_FDD DCI2_20MHz_2A_FDD_t;
 /// DCI Format Type 2 (20 MHz, FDD, 4 Antenna Ports, 54 bits)
 struct DCI2_20MHz_4A_FDD {
   /// padding for 64-bit
-  uint64_t padding64:10;
+  uint64_t padding:10;
   /// TPMI information for precoding
   uint64_t tpmi:6;
   /// Redundancy version 2
@@ -2083,7 +2081,7 @@ typedef struct DCI2A_20MHz_4A_FDD DCI2A_20MHz_4A_FDD_t;
 // *******************************************************************
 /// DCI Format Type 2B (1.5 MHz, TDD,  33 bits)
 struct DCI2B_1_5MHz_TDD {
-  uint64_t padding64:31;
+  uint64_t padding:31;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2109,7 +2107,7 @@ struct DCI2B_1_5MHz_TDD {
   /// RB Assignment (ceil(log2(N_RB_DL/P)) bits)
   uint64_t rballoc:6;
   /// Padding for ambiguity
-  uint64_t padding:1;
+  uint64_t padding0:1;
 } __attribute__ ((__packed__));
 
 typedef struct DCI2B_1_5MHz_TDD DCI2B_1_5MHz_TDD_t;
@@ -2118,7 +2116,7 @@ typedef struct DCI2B_1_5MHz_TDD DCI2B_1_5MHz_TDD_t;
 /// DCI Format Type 2B (5 MHz, TDD,  39 bits)
 struct DCI2B_5MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:25;
+  uint64_t padding:25;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2153,7 +2151,7 @@ typedef struct DCI2B_5MHz_TDD DCI2B_5MHz_TDD_t;
 /// DCI Format Type 2B (10 MHz, TDD,  43 bits)
 struct DCI2B_10MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:21;
+  uint64_t padding:21;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2188,7 +2186,7 @@ typedef struct DCI2B_10MHz_TDD DCI2B_10MHz_TDD_t;
 /// DCI Format Type 2B (20 MHz, TDD,  51 bits)
 struct DCI2B_20MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:13;
+  uint64_t padding:13;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2223,7 +2221,7 @@ typedef struct DCI2B_20MHz_TDD DCI2B_20MHz_TDD_t;
 /// DCI Format Type 2B (1.5 MHz, FDD,  28 bits)
 struct DCI2B_1_5MHz_FDD {
   //padding for 32 bits
-  uint32_t padding32:4;
+  uint32_t padding:4;
   /// Redundancy version 2
   uint32_t rv2:2;
   /// New Data Indicator 2
@@ -2252,7 +2250,7 @@ typedef struct DCI2B_1_5MHz_FDD DCI2B_1_5MHz_FDD_t;
 /// DCI Format Type 2B (5 MHz, FDD,  36 bits)
 struct DCI2B_5MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:28;
+  uint64_t padding:28;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2283,7 +2281,7 @@ typedef struct DCI2B_5MHz_FDD DCI2B_5MHz_FDD_t;
 /// DCI Format Type 2B (10 MHz, FDD,  41 bits)
 struct DCI2B_10MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:23;
+  uint64_t padding:23;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2307,7 +2305,7 @@ struct DCI2B_10MHz_FDD {
   /// Resource Allocation Header
   uint64_t rah:1;
   /// Padding for ambiguity
-  uint64_t padding:1;
+  uint64_t padding0:1;
 } __attribute__ ((__packed__));
 
 #define sizeof_DCI2B_10MHz_FDD_t 41
@@ -2316,7 +2314,7 @@ typedef struct DCI2B_10MHz_FDD DCI2B_10MHz_FDD_t;
 /// DCI Format Type 2B (20 MHz, FDD,  48 bits)
 struct DCI2B_20MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:16;
+  uint64_t padding:16;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2350,7 +2348,7 @@ typedef struct DCI2B_20MHz_FDD DCI2B_20MHz_FDD_t;
 
 /// DCI Format Type 2C (1.5 MHz, TDD,  34 bits)
 struct DCI2C_1_5MHz_TDD {
-  uint64_t padding64:30;
+  uint64_t padding:30;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2383,7 +2381,7 @@ typedef struct DCI2C_1_5MHz_TDD DCI2C_1_5MHz_TDD_t;
 /// DCI Format Type 2C (5 MHz, TDD,  41 bits)
 struct DCI2C_5MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:23;
+  uint64_t padding:23;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2418,7 +2416,7 @@ typedef struct DCI2C_5MHz_TDD DCI2C_5MHz_TDD_t;
 /// DCI Format Type 2C (10 MHz, TDD,  45 bits)
 struct DCI2C_10MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:19;
+  uint64_t padding:19;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2453,7 +2451,7 @@ typedef struct DCI2C_10MHz_TDD DCI2C_10MHz_TDD_t;
 /// DCI Format Type 2C (20 MHz, TDD,  53 bits)
 struct DCI2C_20MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:11;
+  uint64_t padding:11;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2488,7 +2486,7 @@ typedef struct DCI2C_20MHz_TDD DCI2C_20MHz_TDD_t;
 /// DCI Format Type 2C (1.5 MHz, FDD,  30 bits)
 struct DCI2C_1_5MHz_FDD {
   //padding for 32 bits
-  uint32_t padding32:2;
+  uint32_t padding:2;
   /// Redundancy version 2
   uint32_t rv2:2;
   /// New Data Indicator 2
@@ -2517,7 +2515,7 @@ typedef struct DCI2C_1_5MHz_FDD DCI2C_1_5MHz_FDD_t;
 /// DCI Format Type 2C (5 MHz, FDD,  38 bits)
 struct DCI2C_5MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:26;
+  uint64_t padding:26;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2548,7 +2546,7 @@ typedef struct DCI2C_5MHz_FDD DCI2C_5MHz_FDD_t;
 /// DCI Format Type 2C (10 MHz, FDD,  42 bits)
 struct DCI2C_10MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:22;
+  uint64_t padding:22;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2579,7 +2577,7 @@ typedef struct DCI2C_10MHz_FDD DCI2C_10MHz_FDD_t;
 /// DCI Format Type 2C (20 MHz, FDD,  50 bits)
 struct DCI2C_20MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:14;
+  uint64_t padding:14;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2
@@ -2613,7 +2611,7 @@ typedef struct DCI2C_20MHz_FDD DCI2C_20MHz_FDD_t;
 
 /// DCI Format Type 2D (1.5 MHz, TDD,  36 bits)
 struct DCI2D_1_5MHz_TDD {
-  uint64_t padding64:28;
+  uint64_t padding:28;
   /// PDSCH REsource Mapping and Quasi-Co-Location Indicator
   uint64_t REMQCL:2;
   /// Redundancy version 2
@@ -2648,7 +2646,7 @@ typedef struct DCI2D_1_5MHz_TDD DCI2D_1_5MHz_TDD_t;
 /// DCI Format Type 2D (5 MHz, TDD,  43 bits)
 struct DCI2D_5MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:21;
+  uint64_t padding:21;
   /// PDSCH REsource Mapping and Quasi-Co-Location Indicator
   uint64_t REMQCL:2;
   /// Redundancy version 2
@@ -2685,7 +2683,7 @@ typedef struct DCI2D_5MHz_TDD DCI2D_5MHz_TDD_t;
 /// DCI Format Type 2D (10 MHz, TDD,  47 bits)
 struct DCI2D_10MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:17;
+  uint64_t padding:17;
   /// PDSCH REsource Mapping and Quasi-Co-Location Indicator
   uint64_t REMQCL:2;
   /// Redundancy version 2
@@ -2722,7 +2720,7 @@ typedef struct DCI2D_10MHz_TDD DCI2D_10MHz_TDD_t;
 /// DCI Format Type 2D (20 MHz, TDD,  55 bits)
 struct DCI2D_20MHz_TDD {
   /// padding to 64bits
-  uint64_t padding64:9;
+  uint64_t padding:9;
   /// PDSCH REsource Mapping and Quasi-Co-Location Indicator
   uint64_t REMQCL:2;
   /// Redundancy version 2
@@ -2759,7 +2757,7 @@ typedef struct DCI2D_20MHz_TDD DCI2D_20MHz_TDD_t;
 /// DCI Format Type 2D (1.5 MHz, FDD,  33 bits)
 struct DCI2D_1_5MHz_FDD {
   //padding for 33 bits
-  uint64_t padding64:31;
+  uint64_t padding:31;
   /// PDSCH REsource Mapping and Quasi-Co-Location Indicator
   uint64_t REMQCL:2;
   /// Redundancy version 2
@@ -2783,7 +2781,7 @@ struct DCI2D_1_5MHz_FDD {
   /// RB Assignment (ceil(log2(N_RB_DL/P)) bits)
   uint64_t rballoc:6;
   /// padding for ambiguity
-  uint64_t padding;
+  uint64_t padding0;
 } __attribute__ ((__packed__));
 
 typedef struct DCI2D_1_5MHz_FDD DCI2D_1_5MHz_FDD_t;
@@ -2792,7 +2790,7 @@ typedef struct DCI2D_1_5MHz_FDD DCI2D_1_5MHz_FDD_t;
 /// DCI Format Type 2D (5 MHz, FDD,  41 bits)
 struct DCI2D_5MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:23;
+  uint64_t padding:23;
   /// PDSCH REsource Mapping and Quasi-Co-Location Indicator
   uint64_t REMQCL:2;
   /// Redundancy version 2
@@ -2818,7 +2816,7 @@ struct DCI2D_5MHz_FDD {
   /// Resource Allocation Header
   uint64_t rah:1;
   /// padding for ambiguity
-  uint64_t padding:1;
+  uint64_t padding0:1;
 } __attribute__ ((__packed__));
 
 #define sizeof_DCI2D_5MHz_FDD_t 41
@@ -2827,7 +2825,7 @@ typedef struct DCI2D_5MHz_FDD DCI2D_5MHz_FDD_t;
 /// DCI Format Type 2D (10 MHz, FDD,  45 bits)
 struct DCI2D_10MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:19;
+  uint64_t padding:19;
   /// PDSCH REsource Mapping and Quasi-Co-Location Indicator
   uint64_t REMQCL:2;
   /// Redundancy version 2
@@ -2853,7 +2851,7 @@ struct DCI2D_10MHz_FDD {
   /// Resource Allocation Header
   uint64_t rah:1;
   /// padding for ambiguity
-  uint64_t padding:1;
+  uint64_t padding0:1;
 } __attribute__ ((__packed__));
 
 #define sizeof_DCI2D_10MHz_FDD_t 45
@@ -2862,7 +2860,7 @@ typedef struct DCI2D_10MHz_FDD DCI2D_10MHz_FDD_t;
 /// DCI Format Type 2D (20 MHz, FDD,  52 bits)
 struct DCI2D_20MHz_FDD {
   /// padding for 64-bit
-  uint64_t padding64:12;
+  uint64_t padding:12;
   /// Redundancy version 2
   uint64_t rv2:2;
   /// New Data Indicator 2

openair1/PHY/LTE_TRANSPORT/dci_NB_IoT.h

@@ -0,0 +1,292 @@
+/*
+ * 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
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
+ * 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
+ */
+
+/*! \file PHY/LTE_TRANSPORT/dci.h
+* \brief typedefs for LTE DCI structures from 36-212, V8.6 2009-03.  Limited to 5 MHz formats for the moment.Current LTE compliance V8.6 2009-03.
+* \author R. Knopp
+* \date 2011
+* \version 0.1
+* \company Eurecom
+* \email: knopp@eurecom.fr
+* \note
+* \warning
+*/
+#ifndef __DCI_NB_IOT_H__
+#define __DCI_NB_IOT_H__
+
+//#ifndef USER_MODE
+//#include "PHY/types.h"
+//#else
+#include <stdint.h>
+//#endif
+
+typedef enum 
+{
+  DCIFormatN0 = 0,
+  DCIFormatN1,
+  DCIFormatN1_RA,//is for initial RA procedure (semi-static information) so maybe is not needed
+  DCIFormatN1_RAR,
+  DCIFormatN2,
+  DCIFormatN2_Ind,
+  DCIFormatN2_Pag,
+}DCI_format_NB_IoT_t;
+
+///  DCI Format Type 0 (180 kHz, 23 bits)
+struct DCIFormatN0{
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type;
+  /// Subcarrier indication, 6 bits
+  uint8_t scind;
+  /// Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign;
+  /// Modulation and Coding Scheme, 4 bits
+  uint8_t mcs;
+  /// New Data Indicator, 1 bits
+  uint8_t ndi;
+  /// Scheduling Delay, 2 bits
+  uint8_t Scheddly;
+  /// Repetition Number, 3 bits
+  uint8_t RepNum;
+  /// Redundancy version for HARQ (only use 0 and 2), 1 bits
+  uint8_t rv;
+  /// DCI subframe repetition Number, 2 bits
+  uint8_t DCIRep;
+};
+
+typedef struct DCIFormatN0 DCIFormatN0_t;
+
+///  DCI Format Type N1 for User data
+struct DCIFormatN1{
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1,1bits
+  uint8_t type;
+  //NPDCCH order indicator (set to 0), 1 bits
+  uint8_t orderIndicator;
+  // Scheduling Delay,3 bits
+  uint8_t Scheddly;
+  // Resourse Assignment (RU Assignment),3 bits
+  uint8_t ResAssign;
+  // Modulation and Coding Scheme,4 bits
+  uint8_t mcs;
+  // Repetition Number,4 bits
+  uint8_t RepNum;
+  // New Data Indicator,1 bits
+  uint8_t ndi;
+  // HARQ-ACK resource,4 bits
+  uint8_t HARQackRes;
+  // DCI subframe repetition Number,2 bits
+  uint8_t DCIRep;
+};
+
+
+typedef struct DCIFormatN1 DCIFormatN1_t;
+
+///  DCI Format Type N1 for initial RA
+struct DCIFormatN1_RA{
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type;
+  //NPDCCH order indicator (set to 0),1 bits
+  uint8_t orderIndicator;
+  // Start number of NPRACH repetiiton, 2 bits
+  uint8_t Scheddly;
+  // Subcarrier indication of NPRACH, 6 bits
+  uint8_t scind;
+  // All the remainging bits, 13 bits
+  uint8_t remaingingBits;
+};
+
+typedef struct DCIFormatN1_RA DCIFormatN1_RA_t;
+
+///  DCI Format Type N1 for User data
+struct DCIFormatN1_RAR{
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1,1bits
+  uint8_t type;
+  //NPDCCH order indicator (set to 0), 1 bits
+  uint8_t orderIndicator;
+  // Scheduling Delay,3 bits
+  uint8_t Scheddly;
+  // Resourse Assignment (RU Assignment),3 bits
+  uint8_t ResAssign;
+  // Modulation and Coding Scheme,4 bits
+  uint8_t mcs;
+  // Repetition Number,4 bits
+  uint8_t RepNum;
+  // New Data Indicator,1 bits,reserved in the RAR
+  uint8_t ndi;
+  // HARQ-ACK resource,4 bits,reserved in the RAR
+  uint8_t HARQackRes;
+  // DCI subframe repetition Number,2 bits
+  uint8_t DCIRep;
+};
+
+typedef struct DCIFormatN1_RAR DCIFormatN1_RAR_t;
+
+//  DCI Format Type N2 for direct indication, 15 bits
+struct DCIFormatN2_Ind{
+  //Flag for paging(1)/direct indication(0), set to 0,1 bits
+  uint8_t type;
+  //Direct indication information, 8 bits
+  uint8_t directIndInf;
+  // Reserved information bits, 6 bits
+  uint8_t resInfoBits;
+};
+
+typedef struct DCIFormatN2_Ind DCIFormatN2_Ind_t;
+
+//  DCI Format Type N2 for Paging, 15 bits
+struct DCIFormatN2_Pag{
+  //Flag for paging(1)/direct indication(0), set to 1,1 bits
+  uint8_t type;
+  // Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign;
+  // Modulation and Coding Scheme, 4 bits
+  uint8_t mcs;
+  // Repetition Number, 4 bits
+  uint8_t RepNum;
+  // Reserved 3 bits
+  uint8_t DCIRep;
+};
+
+typedef struct DCIFormatN2_Pag DCIFormatN2_Pag_t;
+
+typedef union DCI_CONTENT {
+ // 
+ DCIFormatN0_t DCIN0;
+ //
+ DCIFormatN1_t DCIN1;
+ //
+ DCIFormatN1_RA_t DCIN1_RA;
+ //
+ DCIFormatN1_RAR_t DCIN1_RAR;
+ //
+ DCIFormatN2_Ind_t DCIN2_Ind;
+ //
+ DCIFormatN2_Pag_t DCIN2_Pag;
+
+ }DCI_CONTENT;
+
+ /*Structure for packing*/
+
+ struct DCIN0{
+  /// DCI subframe repetition Number, 2 bits
+  uint8_t DCIRep:2;
+  /// New Data Indicator, 1 bits
+  uint8_t ndi:1;
+  /// Repetition Number, 3 bits
+  uint8_t RepNum:3;
+  /// Redundancy version for HARQ (only use 0 and 2), 1 bits
+  uint8_t rv:1;
+  /// Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  /// Scheduling Delay, 2 bits
+  uint8_t Scheddly:2;
+  /// Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  /// Subcarrier indication, 6 bits
+  uint8_t scind:6;
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type:1;
+ } __attribute__ ((__packed__));
+
+ typedef struct DCIN0 DCIN0_t;
+#define sizeof_DCIN0_t 23
+
+struct DCIN1_RAR{
+  // DCI subframe repetition Number, 2 bits
+  uint8_t DCIRep:2;
+  // HARQ-ACK resource,4 bits
+  uint8_t HARQackRes:4; 
+  // New Data Indicator,1 bits
+  uint8_t ndi:1;
+  // Repetition Number, 4 bits
+  uint8_t RepNum:4;
+  // Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  // Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  // Scheduling Delay, 3 bits
+  uint8_t Scheddly:3;
+  //NPDCCH order indicator (set to 0),1 bits
+  uint8_t orderIndicator:1;
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type:1;
+ } __attribute__ ((__packed__));
+
+ typedef struct DCIN1_RAR DCIN1_RAR_t;
+#define sizeof_DCIN1_RAR_t 23
+
+struct DCIN1{
+  // DCI subframe repetition Number, 2 bits
+  uint8_t DCIRep:2;
+  // HARQ-ACK resource,4 bits
+  uint8_t HARQackRes:4; 
+  // New Data Indicator,1 bits
+  uint8_t ndi:1;
+  // Repetition Number, 4 bits
+  uint8_t RepNum:4;
+  // Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  // Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  // Scheduling Delay, 3 bits
+  uint8_t Scheddly:3;
+  //NPDCCH order indicator (set to 0),1 bits
+  uint8_t orderIndicator:1;
+  /// type = 0 => DCI Format N0, type = 1 => DCI Format N1, 1 bits
+  uint8_t type:1;
+ } __attribute__ ((__packed__));
+
+ typedef struct DCIN1 DCIN1_t;
+#define sizeof_DCIN1_t 23
+
+//  DCI Format Type N2 for direct indication, 15 bits
+struct DCIN2_Ind{
+  // Reserved information bits, 6 bits
+  uint8_t resInfoBits:6;
+  //Direct indication information, 8 bits
+  uint8_t directIndInf:8;
+  //Flag for paging(1)/direct indication(0), set to 0,1 bits
+  uint8_t type:1;
+} __attribute__ ((__packed__));;
+
+typedef struct DCIN2_Ind DCIN2_Ind_t;
+#define sizeof_DCIN2_Ind_t 15
+
+//  DCI Format Type N2 for Paging, 15 bits
+struct DCIN2_Pag{
+  // Reserved 3 bits
+  uint8_t DCIRep:3;
+  // Repetition Number, 4 bits
+  uint8_t RepNum:4;
+  // Modulation and Coding Scheme, 4 bits
+  uint8_t mcs:4;
+  // Resourse Assignment (RU Assignment), 3 bits
+  uint8_t ResAssign:3;
+  //Flag for paging(1)/direct indication(0), set to 1,1 bits
+  uint8_t type:1;
+} __attribute__ ((__packed__));;
+
+typedef struct DCIN2_Pag DCIN2_Pag_t;
+
+#define sizeof_DCIN2_Pag_t 15
+
+#define MAX_DCI_SIZE_BITS_NB_IoT 23
+
+#endif

openair1/PHY/LTE_TRANSPORT/defs.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/defs_NB_IoT.h

@@ -0,0 +1,787 @@
+/*******************************************************************************
+ 
+ *******************************************************************************/
+/*! \file PHY/LTE_TRANSPORT/defs_NB_IoT.h
+* \brief data structures for NPDSCH/NDLSCH/NPUSCH/NULSCH physical and transport channel descriptors (TX/RX) of NB-IoT
+* \author M. KANJ
+* \date 2017
+* \version 0.0
+* \company bcom
+* \email: matthieu.kanj@b-com.com
+* \note
+* \warning
+*/
+#ifndef __LTE_TRANSPORT_DEFS_NB_IOT__H__
+#define __LTE_TRANSPORT_DEFS_NB_IOT__H__
+////#include "PHY/defs.h"
+//#include "PHY/defs_nb_iot.h"
+#include "PHY/LTE_TRANSPORT/dci_NB_IoT.h"
+#include "PHY/impl_defs_lte_NB_IoT.h"
+#include "openair2/COMMON/platform_types.h"
+//#include "dci.h"
+#include "PHY/LTE_TRANSPORT/uci_NB_IoT.h"
+//#include "dci.h"
+//#include "uci.h"
+//#ifndef STANDALONE_COMPILE
+//#include "UTIL/LISTS/list.h"
+//#endif
+ 
+//#include "dci_nb_iot.h"
+
+//#define MOD_TABLE_QPSK_OFFSET 1
+//#define MOD_TABLE_16QAM_OFFSET 5
+//#define MOD_TABLE_64QAM_OFFSET 21
+//#define MOD_TABLE_PSS_OFFSET 85
+//
+//// structures below implement 36-211 and 36-212
+//
+//#define NSOFT 1827072
+#define LTE_NULL_NB_IoT 2
+//
+//// maximum of 3 segments before each coding block if data length exceeds 6144 bits.
+//
+#define MAX_NUM_DLSCH_SEGMENTS_NB_IoT 16
+//#define MAX_NUM_ULSCH_SEGMENTS MAX_NUM_DLSCH_SEGMENTS
+//#define MAX_DLSCH_PAYLOAD_BYTES (MAX_NUM_DLSCH_SEGMENTS*768)
+//#define MAX_ULSCH_PAYLOAD_BYTES (MAX_NUM_ULSCH_SEGMENTS*768)
+//
+//#define MAX_NUM_CHANNEL_BITS_NB_IOT (14*1200*6)  // 14 symbols, 1200 REs, 12 bits/RE
+//#define MAX_NUM_RE (14*1200)
+//
+//#if !defined(SI_RNTI)
+//#define SI_RNTI  (rnti_t)0xffff
+//#endif
+//#if !defined(M_RNTI)
+//#define M_RNTI   (rnti_t)0xfffd
+//#endif
+//#if !defined(P_RNTI)
+//#define P_RNTI   (rnti_t)0xfffe
+//#endif
+//#if !defined(CBA_RNTI)
+//#define CBA_RNTI (rnti_t)0xfff4
+//#endif
+//#if !defined(C_RNTI)
+//#define C_RNTI   (rnti_t)0x1234
+//#endif
+//
+//#define PMI_2A_11 0
+//#define PMI_2A_1m1 1
+//#define PMI_2A_1j 2
+//#define PMI_2A_1mj 3
+//
+//// for NB-IoT
+#define MAX_NUM_CHANNEL_BITS_NB_IoT 3360 			//14 symbols * 12 sub-carriers * 10 SF * 2bits/RE  // to check during real tests
+#define MAX_DL_SIZE_BITS_NB_IoT 680 				// in release 13 // in release 14 = 2048      // ??? **** not sure
+////#define MAX_NUM_CHANNEL_BITS_NB_IOT 3*680  			/// ??? ****not sure
+//
+//// to be created LTE_eNB_DLSCH_t --> is duplicated for each number of UE and then indexed in the table
+//
+//typedef struct {                              // LTE_DL_eNB_HARQ_t
+//  /// Status Flag indicating for this DLSCH (idle,active,disabled)
+//  SCH_status_t status;
+//  /// Transport block size
+//  uint32_t TBS;
+//  /// The payload + CRC size in bits, "B" from 36-212
+//  uint32_t B;        // keep this parameter
+//  /// Pointer to the payload
+//  uint8_t *b;   // keep this parameter
+//  /// Pointers to transport block segments
+//  //uint8_t *c[MAX_NUM_DLSCH_SEGMENTS];
+//  /// RTC values for each segment (for definition see 36-212 V8.6 2009-03, p.15)
+// // uint32_t RTC[MAX_NUM_DLSCH_SEGMENTS];
+//  /// Frame where current HARQ round was sent
+//  uint32_t frame;
+//  /// Subframe where current HARQ round was sent
+//  uint32_t subframe;
+//  /// Index of current HARQ round for this DLSCH
+//  uint8_t round;
+//  /// MCS format for this DLSCH
+//  uint8_t mcs;
+//  /// Redundancy-version of the current sub-frame
+//  uint8_t rvidx;
+//  /// MIMO mode for this DLSCH
+//  MIMO_mode_t mimo_mode;
+//  /// Current RB allocation
+//  uint32_t rb_alloc[4];
+//  /// distributed/localized flag
+//  vrb_t vrb_type;
+//  /// Current subband PMI allocation
+//  uint16_t pmi_alloc;
+//  /// Current subband RI allocation
+//  uint32_t ri_alloc;
+//  /// Current subband CQI1 allocation
+//  uint32_t cqi_alloc1;
+//  /// Current subband CQI2 allocation
+//  uint32_t cqi_alloc2;
+//  /// Current Number of RBs
+//  uint16_t nb_rb;
+//  /// downlink power offset field
+//  uint8_t dl_power_off;
+//  /// Concatenated "e"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
+//  uint8_t e[MAX_NUM_CHANNEL_BITS_NB_IOT];
+//  /// data after scrambling
+//  uint8_t s_e[MAX_NUM_CHANNEL_BITS_NB_IOT];
+//  /// length of the table e
+//  uint16_t length_e                 // new parameter
+//  /// Tail-biting convolutional coding outputs
+//  uint8_t d[96+(3*(24+MAX_DL_SIZE_BITS_NB_IOT))];  // new parameter
+//  /// Sub-block interleaver outputs
+//  uint8_t w[3*3*(MAX_DL_SIZE_BITS_NB_IOT+24)];      // new parameter
+//  /// Number of MIMO layers (streams) (for definition see 36-212 V8.6 2009-03, p.17, TM3-4)
+//  uint8_t Nl;
+//  /// Number of layers for this PDSCH transmission (TM8-10)
+//  uint8_t Nlayers;
+//  /// First layer for this PSCH transmission
+//  uint8_t first_layer;
+//} NB_IoT_DL_eNB_HARQ_t;
+
+typedef enum {
+
+  SCH_IDLE_NB_IoT,
+  ACTIVE_NB_IoT,
+  CBA_ACTIVE_NB_IoT,
+  DISABLED_NB_IoT
+
+} SCH_status_NB_IoT_t;
+
+
+typedef struct {
+  /// NB-IoT
+  SCH_status_NB_IoT_t   status;
+  /// The scheduling the NPDCCH and the NPDSCH transmission TS 36.213 Table 16.4.1-1
+  uint8_t               scheduling_delay;
+  /// The number of the subframe to transmit the NPDSCH Table TS 36.213 Table 16.4.1.3-1  (Nsf) (NB. in this case is not the index Isf)
+  uint8_t               resource_assignment;
+  /// is the index that determined the repeat number of NPDSCH through table TS 36.213 Table 16.4.1.3-2 / for SIB1-NB Table 16.4.1.3-3
+  uint8_t               repetition_number;
+  /// Determined the ACK/NACK delay and the subcarrier allocation TS 36.213 Table 16.4.2
+  uint8_t               HARQ_ACK_resource;
+  /// Determined the repetition number value 0-3 (2 biut carried by the FAPI NPDCCH)
+  uint8_t               dci_subframe_repetitions;
+  /// modulation always QPSK Qm = 2 
+  uint8_t               modulation;
+  /// Concatenated "e"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
+  uint8_t               e[MAX_NUM_CHANNEL_BITS_NB_IoT];
+  /// data after scrambling
+  uint8_t               s_e[MAX_NUM_CHANNEL_BITS_NB_IoT];
+  //length of the table e
+  uint16_t              length_e;                // new parameter
+  /// Tail-biting convolutional coding outputs
+  uint8_t               d[96+(3*(24+MAX_DL_SIZE_BITS_NB_IoT))];  // new parameter
+  /// Sub-block interleaver outputs
+  uint8_t               w[3*3*(MAX_DL_SIZE_BITS_NB_IoT+24)];      // new parameter
+
+  /// Status Flag indicating for this DLSCH (idle,active,disabled)
+  //SCH_status_t status;
+  /// Transport block size
+  uint32_t              TBS;
+  /// The payload + CRC size in bits, "B" from 36-212
+  uint32_t              B;
+  /// Pointer to the payload
+  uint8_t               *b;
+  ///pdu of the ndlsch message
+  uint8_t               *pdu;
+  /// Frame where current HARQ round was sent
+  uint32_t              frame;
+  /// Subframe where current HARQ round was sent
+  uint32_t              subframe;
+  /// Index of current HARQ round for this DLSCH
+  uint8_t               round;
+  /// MCS format for this NDLSCH , TS 36.213 Table 16.4.1.5
+  uint8_t               mcs;
+  // we don't have code block segmentation / crc attachment / concatenation in NB-IoT R13 36.212 6.4.2
+  // we don't have beamforming in NB-IoT
+  //this index will be used mainly for SI message buffer
+   uint8_t               pdu_buffer_index;
+
+} NB_IoT_DL_eNB_HARQ_t;
+
+
+typedef struct {                                        // LTE_eNB_DLSCH_t
+ /// TX buffers for UE-spec transmission (antenna ports 5 or 7..14, prior to precoding)
+ uint32_t               *txdataF[8];
+ /// Allocated RNTI (0 means DLSCH_t is not currently used)
+ uint16_t               rnti;
+ /// Active flag for baseband transmitter processing
+ uint8_t                active;
+ /// Indicator of TX activation per subframe.  Used during PUCCH detection for ACK/NAK.
+ uint8_t                subframe_tx[10];
+ /// First CCE of last PDSCH scheduling per subframe.  Again used during PUCCH detection for ACK/NAK.
+ uint8_t                nCCE[10];
+ /// Current HARQ process id
+ uint8_t                current_harq_pid;
+ /// Process ID's per subframe.  Used to associate received ACKs on PUSCH/PUCCH to DLSCH harq process ids
+ uint8_t                harq_ids[10];
+ /// Window size (in outgoing transport blocks) for fine-grain rate adaptation
+ uint8_t                ra_window_size;
+ /// First-round error threshold for fine-grain rate adaptation
+ uint8_t                error_threshold;
+ /// Pointers to 8 HARQ processes for the DLSCH
+ NB_IoT_DL_eNB_HARQ_t   harq_process;
+ /// circular list of free harq PIDs (the oldest come first)
+ /// (10 is arbitrary value, must be > to max number of DL HARQ processes in LTE)
+ int                    harq_pid_freelist[10];
+ /// the head position of the free list (if list is free then head=tail)
+ int                    head_freelist;
+ /// the tail position of the free list
+ int                    tail_freelist;
+ /// Number of soft channel bits
+ uint32_t               G;
+ /// Codebook index for this dlsch (0,1,2,3)
+ uint8_t                codebook_index;
+ /// Maximum number of HARQ processes (for definition see 36-212 V8.6 2009-03, p.17)
+ uint8_t                Mdlharq;
+ /// Maximum number of HARQ rounds
+ uint8_t                Mlimit;
+ /// MIMO transmission mode indicator for this sub-frame (for definition see 36-212 V8.6 2009-03, p.17)
+ uint8_t                Kmimo;
+ /// Nsoft parameter related to UE Category
+ uint32_t               Nsoft;
+ /// amplitude of PDSCH (compared to RS) in symbols without pilots
+ int16_t                sqrt_rho_a;
+ /// amplitude of PDSCH (compared to RS) in symbols containing pilots
+ int16_t                sqrt_rho_b;
+
+} NB_IoT_eNB_DLSCH_t;
+
+
+typedef struct {
+  /// HARQ process id
+  uint8_t   harq_id;
+  /// ACK bits (after decoding) 0:NACK / 1:ACK / 2:DTX
+  uint8_t   ack;
+  /// send status (for PUCCH)
+  uint8_t   send_harq_status;
+  /// nCCE (for PUCCH)
+  uint8_t   nCCE;
+  /// DAI value detected from DCI1/1a/1b/1d/2/2a/2b/2c. 0xff indicates not touched
+  uint8_t   vDAI_DL;
+  /// DAI value detected from DCI0/4. 0xff indicates not touched
+  uint8_t   vDAI_UL;
+} harq_status_NB_IoT_t;
+
+typedef struct {
+  /// UL RSSI per receive antenna
+  int32_t             UL_rssi[NB_ANTENNAS_RX];
+  /// PUCCH1a/b power (digital linear)
+  uint32_t            Po_PUCCH;
+  /// PUCCH1a/b power (dBm)
+  int32_t             Po_PUCCH_dBm;
+  /// PUCCH1 power (digital linear), conditioned on below threshold
+  uint32_t            Po_PUCCH1_below;
+  /// PUCCH1 power (digital linear), conditioned on above threshold
+  uint32_t            Po_PUCCH1_above;
+  /// Indicator that Po_PUCCH has been updated by PHY
+  int32_t             Po_PUCCH_update;
+  /// DL Wideband CQI index (2 TBs)
+  uint8_t             DL_cqi[2];
+  /// DL Subband CQI index (from HLC feedback)
+  uint8_t             DL_subband_cqi[2][13];
+  /// DL PMI Single Stream
+  uint16_t            DL_pmi_single;
+  /// DL PMI Dual Stream
+  uint16_t            DL_pmi_dual;
+  /// Current RI
+  uint8_t             rank;
+  /// CRNTI of UE
+  uint16_t            crnti; ///user id (rnti) of connected UEs
+  /// Initial timing offset estimate from PRACH for RAR
+  int32_t             UE_timing_offset;
+  /// Timing advance estimate from PUSCH for MAC timing advance signalling
+  int32_t             timing_advance_update;
+  /// Current mode of UE (NOT SYCHED, RAR, PUSCH)
+  UE_MODE_NB_IoT_t    mode;
+  /// Current sector where UE is attached
+  uint8_t             sector;
+
+  /// dlsch l2 errors
+  uint32_t            dlsch_l2_errors[8];
+  /// dlsch trials per harq and round
+  uint32_t            dlsch_trials[8][8];
+  /// dlsch ACK/NACK per hard_pid and round
+  uint32_t            dlsch_ACK[8][8];
+  uint32_t            dlsch_NAK[8][8];
+
+  /// ulsch l2 errors per harq_pid
+  uint32_t            ulsch_errors[8];
+  /// ulsch l2 consecutive errors per harq_pid
+  uint32_t            ulsch_consecutive_errors; //[8];
+  /// ulsch trials/errors/fer per harq and round
+  uint32_t            nulsch_decoding_attempts[8][8];
+  uint32_t            ulsch_round_errors[8][8];
+  uint32_t            ulsch_decoding_attempts_last[8][8];
+  uint32_t            ulsch_round_errors_last[8][8];
+  uint32_t            ulsch_round_fer[8][8];
+  uint32_t            sr_received;
+  uint32_t            sr_total;
+
+  /// dlsch sliding count and total errors in round 0 are used to compute the dlsch_mcs_offset
+  uint32_t            dlsch_sliding_cnt;
+  uint32_t            dlsch_NAK_round0;
+  int8_t              dlsch_mcs_offset;
+
+  /// Target mcs1 after rate-adaptation (used by MAC layer scheduler)
+  uint8_t             dlsch_mcs1;
+  /// Target mcs2 after rate-adaptation (used by MAC layer scheduler)
+  uint8_t             dlsch_mcs2;
+  /// Total bits received from MAC on PDSCH
+  int                 total_TBS_MAC;
+  /// Total bits acknowledged on PDSCH
+  int                 total_TBS;
+  /// Total bits acknowledged on PDSCH (last interval)
+  int                 total_TBS_last;
+  /// Bitrate on the PDSCH [bps]
+  unsigned int        dlsch_bitrate;
+  //  unsigned int total_transmitted_bits;
+
+} NB_IoT_eNB_UE_stats;
+
+typedef struct {
+  /// Indicator of first transmission
+  uint8_t     first_tx;
+  /// Last Ndi received for this process on DCI (used for C-RNTI only)
+  uint8_t     DCINdi;
+  /// DLSCH status flag indicating
+  //SCH_status_t status;
+  /// Transport block size
+  uint32_t    TBS;
+  /// The payload + CRC size in bits
+  uint32_t    B;
+  /// Pointer to the payload
+  uint8_t     *b;
+  /// Pointers to transport block segments
+  uint8_t     *c[MAX_NUM_DLSCH_SEGMENTS_NB_IoT];
+  /// RTC values for each segment (for definition see 36-212 V8.6 2009-03, p.15)
+  uint32_t    RTC[MAX_NUM_DLSCH_SEGMENTS_NB_IoT];
+  /// Index of current HARQ round for this DLSCH
+  uint8_t     round;
+  /// MCS format for this DLSCH
+  uint8_t     mcs;
+  /// Qm (modulation order) for this DLSCH
+  uint8_t     Qm;
+  /// Redundancy-version of the current sub-frame
+  uint8_t     rvidx;
+  /// MIMO mode for this DLSCH
+ // MIMO_mode_t mimo_mode;
+  /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
+  int16_t     w[MAX_NUM_DLSCH_SEGMENTS_NB_IoT][3*(6144+64)];
+  /// for abstraction soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
+  double      w_abs[MAX_NUM_DLSCH_SEGMENTS_NB_IoT][3*(6144+64)];
+  /// soft bits for each received segment ("d"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
+  int16_t     *d[MAX_NUM_DLSCH_SEGMENTS_NB_IoT];
+  /// Number of code segments (for definition see 36-212 V8.6 2009-03, p.9)
+  uint32_t    C;
+  /// Number of "small" code segments (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t    Cminus;
+  /// Number of "large" code segments (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t    Cplus;
+  /// Number of bits in "small" code segments (<6144) (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t    Kminus;
+  /// Number of bits in "large" code segments (<6144) (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t    Kplus;
+  /// Number of "Filler" bits (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t    F;
+  /// Number of MIMO layers (streams) (for definition see 36-212 V8.6 2009-03, p.17)
+  uint8_t     Nl;
+  /// current delta_pucch
+  int8_t      delta_PUCCH;
+  /// Number of soft channel bits
+  uint32_t    G;
+  /// Current Number of RBs
+  uint16_t    nb_rb;
+  /// Current subband PMI allocation
+  uint16_t    pmi_alloc;
+  /// Current RB allocation (even slots)
+  uint32_t    rb_alloc_even[4];
+  /// Current RB allocation (odd slots)
+  uint32_t    rb_alloc_odd[4];
+  /// distributed/localized flag
+  //vrb_t vrb_type;
+  /// downlink power offset field
+  uint8_t     dl_power_off;
+  /// trials per round statistics
+  uint32_t    trials[8];
+  /// error statistics per round
+  uint32_t    errors[8];
+  /// codeword this transport block is mapped to
+  uint8_t     codeword;
+
+} NB_IoT_DL_UE_HARQ_t;
+
+typedef struct {
+  /// RNTI
+  uint16_t              rnti;
+  /// Active flag for DLSCH demodulation
+  uint8_t               active;
+  /// Transmission mode
+  uint8_t               mode1_flag;
+  /// amplitude of PDSCH (compared to RS) in symbols without pilots
+  int16_t               sqrt_rho_a;
+  /// amplitude of PDSCH (compared to RS) in symbols containing pilots
+  int16_t               sqrt_rho_b;
+  /// Current HARQ process id threadRx Odd and threadRx Even
+  uint8_t               current_harq_pid;
+  /// Current subband antenna selection
+  uint32_t              antenna_alloc;
+  /// Current subband RI allocation
+  uint32_t              ri_alloc;
+  /// Current subband CQI1 allocation
+  uint32_t              cqi_alloc1;
+  /// Current subband CQI2 allocation
+  uint32_t              cqi_alloc2;
+  /// saved subband PMI allocation from last PUSCH/PUCCH report
+  uint16_t              pmi_alloc;
+  /// HARQ-ACKs
+  harq_status_NB_IoT_t  harq_ack;
+  /// Pointers to up to 8 HARQ processes
+  NB_IoT_DL_UE_HARQ_t   *harq_process;
+  /// Maximum number of HARQ processes(for definition see 36-212 V8.6 2009-03, p.17
+  uint8_t               Mdlharq;
+  /// MIMO transmission mode indicator for this sub-frame (for definition see 36-212 V8.6 2009-03, p.17)
+  uint8_t               Kmimo;
+  /// Nsoft parameter related to UE Category
+  uint32_t              Nsoft;
+  /// Maximum number of Turbo iterations
+  uint8_t               max_turbo_iterations;
+  /// number of iterations used in last turbo decoding
+  uint8_t               last_iteration_cnt;
+  /// accumulated tx power adjustment for PUCCH
+  int8_t                g_pucch;
+
+} NB_IoT_UE_DLSCH_t;
+
+//----------------------------------------------------------------------------------------------------------
+// NB-IoT
+//----------------------------------------------------------------------------------------------------
+
+//enum for distinguish the different type of ndlsch (may in the future will be not needed)
+typedef enum
+{
+
+  SIB1,
+  SI_Message,
+  RAR,
+  UE_Data
+
+}ndlsch_flag_t;
+
+
+
+typedef struct {
+  rnti_t          rnti;
+  //array containing the pdus of DCI
+  uint8_t         *a[2];
+  //Array containing encoded DCI data
+  uint8_t         *e[2];
+
+  //UE specific parameters
+  uint16_t        npdcch_NumRepetitions;
+
+  uint16_t        repetition_number;
+  //indicate the corresponding subframe within the repetition (set to 0 when a new NPDCCH pdu is received)
+  uint16_t        repetition_idx;
+
+  //  uint16_t npdcch_Offset_USS;
+  //  uint16_t npdcch_StartSF_USS;
+
+
+}NB_IoT_eNB_NPDCCH_t;
+
+
+typedef struct{
+
+  //Number of repetitions (R) for common search space (RAR and PAGING)
+  uint16_t    number_repetition_RA;
+  uint16_t    number_repetition_PAg;
+  //index of the current subframe among the repetition (set to 0 when we receive the new NPDCCH)
+  uint16_t    repetition_idx_RA;
+  uint16_t    repetition_idx_Pag;
+
+}NB_IoT_eNB_COMMON_NPDCCH_t;
+
+
+typedef struct {
+
+  /// Length of DCI in bits
+  uint8_t               dci_length;
+  /// Aggregation level only 1,2 in NB-IoT
+  uint8_t               L;
+  /// Position of first CCE of the dci
+  int                   firstCCE;
+  /// flag to indicate that this is a RA response
+  boolean_t      ra_flag;
+  /// rnti
+  rnti_t                rnti;
+  /// Format
+  DCI_format_NB_IoT_t   format;
+  /// DCI pdu
+  uint8_t               dci_pdu[8];
+
+} DCI_ALLOC_NB_IoT_t;
+
+
+typedef struct {
+  //delete the count for the DCI numbers,NUM_DCI_MAX should set to 2
+  uint32_t              num_npdcch_symbols;
+  ///indicates the starting OFDM symbol in the first slot of a subframe k for the NPDCCH transmission
+  /// see FAPI/NFAPI specs Table 4-45
+  uint8_t               npdcch_start_symbol;
+  uint8_t               Num_dci;
+  DCI_ALLOC_NB_IoT_t    dci_alloc[2] ;
+
+} DCI_PDU_NB_IoT;
+
+
+
+
+typedef struct {
+  /// TX buffers for UE-spec transmission (antenna ports 5 or 7..14, prior to precoding)
+  int32_t                 *txdataF[8];
+  /// dl channel estimates (estimated from ul channel estimates)
+  int32_t                 **calib_dl_ch_estimates;
+  /// Allocated RNTI (0 means DLSCH_t is not currently used)
+  uint16_t                rnti;
+  /// Active flag for baseband transmitter processing
+  uint8_t                 active;
+  /// Indicator of TX activation per subframe.  Used during PUCCH detection for ACK/NAK.
+  uint8_t                 subframe_tx[10];
+  /// First CCE of last PDSCH scheduling per subframe.  Again used during PUCCH detection for ACK/NAK.
+  uint8_t                 nCCE[10];
+  /*in NB-IoT there is only 1 HARQ process for each UE therefore no pid is required*/
+  /// The only HARQ process for the DLSCH
+  NB_IoT_DL_eNB_HARQ_t    *harq_process;
+  /// Number of soft channel bits
+  uint32_t                G;
+  /// Maximum number of HARQ rounds
+  uint8_t                 Mlimit;
+  /// Nsoft parameter related to UE Category
+  uint32_t                Nsoft;
+  /// amplitude of PDSCH (compared to RS) in symbols without pilots
+  int16_t                 sqrt_rho_a;
+  /// amplitude of PDSCH (compared to RS) in symbols containing pilots
+  int16_t                 sqrt_rho_b;
+  ///NB-IoT
+  /// may use in the npdsch_procedures
+  uint16_t                scrambling_sequence_intialization;
+  /// number of cell specific TX antenna ports assumed by the UE
+  uint8_t                 nrs_antenna_ports;
+
+  //This indicate the current subframe within the subframe interval between the NPDSCH transmission (Nsf*Nrep)
+  uint16_t                sf_index;
+  ///indicates the starting OFDM symbol in the first slot of a subframe k for the NPDSCH transmission
+  /// see FAPI/NFAPI specs Table 4-47
+  uint8_t                 npdsch_start_symbol;
+  /*SIB1-NB related parameters*/
+  ///flag for indicate if the current frame is the start of a new SIB1-NB repetition within the SIB1-NB period (0 = FALSE, 1 = TRUE)
+  uint8_t                 sib1_rep_start;
+  ///the number of the frame within the 16 continuous frame in which sib1-NB is transmitted (1-8 = 1st, 2nd ecc..) (0 = not foresees a transmission)
+  uint8_t                 relative_sib1_frame;
+  //Flag  used to discern among different NDLSCH structures (SIB1,SI,RA,UE-spec)
+  //(used inside the ndlsch procedure for distinguish the different type of data to manage also in term of repetitions and transmission over more subframes
+  ndlsch_flag_t           ndlsch_type;
+
+} NB_IoT_eNB_NDLSCH_t;
+
+typedef struct {
+  /// Length of CQI data under RI=1 assumption(bits)
+  uint8_t               Or1;
+  /// Rank information
+  uint8_t               o_RI[2];
+  /// Format of CQI data
+  UCI_format_NB_IoT_t   uci_format;
+  /// The value of DAI in DCI format 0
+  uint8_t               V_UL_DAI;
+  /// Pointer to CQI data
+  uint8_t               o[MAX_CQI_BYTES_NB_IoT];
+  /// CQI CRC status
+  uint8_t               cqi_crc_status;
+  /// PHICH active flag
+  uint8_t               phich_active;
+  /// PHICH ACK
+  uint8_t               phich_ACK;
+  /// Length of rank information (bits)
+  uint8_t               O_RI;
+  /// First Allocated RB
+  uint16_t              first_rb;
+  /// Current Number of RBs
+  uint16_t              nb_rb;
+  /// Determined the subcarrier allocation for the NPUSCH.(15, 3.75 KHz)
+  uint8_t               subcarrier_indication;
+  /// Determined the number of resource unit for the NPUSCH
+  uint8_t               resource_assignment;
+  /// Determined the scheduling delay for NPUSCH
+  uint8_t               scheduling_delay;
+  /// The number of the repetition number for NPUSCH Transport block
+  uint8_t               repetition_number;
+  /// Determined the repetition number value 0-3
+  uint8_t               dci_subframe_repetitions;
+  /// Flag indicating that this ULSCH has been allocated by a DCI (otherwise it is a retransmission based on PHICH NAK)
+  uint8_t               dci_alloc;
+  /// Flag indicating that this ULSCH has been allocated by a RAR (otherwise it is a retransmission based on PHICH NAK or DCI)
+  uint8_t               rar_alloc;
+  /// Status Flag indicating for this ULSCH (idle,active,disabled)
+  SCH_status_NB_IoT_t   status;
+  /// Subframe scheduling indicator (i.e. Transmission opportunity indicator)
+  uint8_t               subframe_scheduling_flag;
+  /// Transport block size
+  uint32_t              TBS;
+  /// The payload + CRC size in bits
+  uint32_t              B;
+  /// Number of soft channel bits
+  uint32_t              G;
+  /// Pointer to ACK
+  uint8_t               o_ACK[4];
+  /// Length of ACK information (bits)
+  uint8_t               O_ACK;
+  /// coded ACK bits
+  int16_t               q_ACK[MAX_ACK_PAYLOAD_NB_IoT];
+  /// Number of code segments (for definition see 36-212 V8.6 2009-03, p.9)
+  /// Concatenated "e"-sequences (for definition see 36-212 V8.6 2009-03, p.17-18)
+  int16_t               e[MAX_NUM_CHANNEL_BITS_NB_IoT] __attribute__((aligned(32)));
+  /// coded RI bits
+  int16_t               q_RI[MAX_RI_PAYLOAD_NB_IoT];
+  /// "q" sequences for CQI/PMI (for definition see 36-212 V8.6 2009-03, p.27)
+  int8_t                q[MAX_CQI_PAYLOAD_NB_IoT];
+  /// number of coded CQI bits after interleaving
+  uint8_t               o_RCC;
+  /// coded and interleaved CQI bits
+  int8_t                o_w[(MAX_CQI_BITS_NB_IoT+8)*3];
+  /// coded CQI bits
+  int8_t                o_d[96+((MAX_CQI_BITS_NB_IoT+8)*3)];
+  ///
+  uint32_t              C;
+  /// Number of "small" code segments (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t              Cminus;
+  /// Number of "large" code segments (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t              Cplus;
+  /// Number of bits in "small" code segments (<6144) (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t              Kminus;
+  /// Number of bits in "large" code segments (<6144) (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t              Kplus;
+  /// Number of "Filler" bits (for definition see 36-212 V8.6 2009-03, p.10)
+  uint32_t              F;
+  /// Temporary h sequence to flag PUSCH_x/PUSCH_y symbols which are not scrambled
+  //uint8_t h[MAX_NUM_CHANNEL_BITS];
+  /// SRS active flag
+  uint8_t               srs_active;
+  /// Pointer to the payload
+  uint8_t               *b;
+  /// Current Number of Symbols
+  uint8_t               Nsymb_pusch;
+  /// Index of current HARQ round for this ULSCH
+  uint8_t               round;
+  /// MCS format for this ULSCH
+  uint8_t               mcs;
+  /// Redundancy-version of the current sub-frame (value 0->RV0,value 1 ->RV2)
+  uint8_t               rvidx;
+  /// Msc_initial, Initial number of subcarriers for ULSCH (36-212, v8.6 2009-03, p.26-27)
+  uint16_t              Msc_initial;
+  /// Nsymb_initial, Initial number of symbols for ULSCH (36-212, v8.6 2009-03, p.26-27)
+  uint8_t               Nsymb_initial;
+  /// n_DMRS  for cyclic shift of DMRS (36.213 Table 9.1.2-2)
+  uint8_t               n_DMRS;
+  /// n_DMRS  for cyclic shift of DMRS (36.213 Table 9.1.2-2) - previous scheduling
+  /// This is needed for PHICH generation which
+  /// is done after a new scheduling
+  uint8_t               previous_n_DMRS;
+  /// n_DMRS 2 for cyclic shift of DMRS (36.211 Table 5.5.1.1.-1)
+  uint8_t               n_DMRS2;
+  /// Flag to indicate that this ULSCH is for calibration information sent from UE (i.e. no MAC SDU to pass up)
+  //  int calibration_flag;
+  /// delta_TF for power control
+  int32_t               delta_TF;
+  ///////////////////////////////////////////// 4 parameter added by vincent ///////////////////////////////////////////////
+  // NB_IoT: Nsymb_UL and Nslot_UL are defined in 36.211, Section 10.1.2.3, Table 10.1.2.3-1
+  // The number of symbol in a resource unit is given by Nsymb_UL*Nslot_UL
+  uint8_t               Nsymb_UL; 
+  // Number of NPUSCH slots
+  uint8_t               Nslot_UL; 
+  // Number of subcarrier for NPUSH, can be 1, 3, 6, 12
+  uint8_t               N_sc_RU; 
+  // Index of UL NB_IoT resource block
+  uint32_t              UL_RB_ID_NB_IoT; 
+  // Subcarrier indication fields, obtained through DCI, Section 16.5.1.1 in 36.213
+  uint16_t              I_sc; 
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+} NB_IoT_UL_eNB_HARQ_t;
+
+
+typedef struct {
+  /// Pointers to the HARQ processes for the NULSCH
+  NB_IoT_UL_eNB_HARQ_t    *harq_process;
+  /// Maximum number of HARQ rounds
+  uint8_t                 Mlimit;
+  /// Value 0 = npush format 1 (data) value 1 = npusch format 2 (ACK/NAK)
+  uint8_t                 npusch_format;
+  /// Flag to indicate that eNB awaits UE Msg3
+  uint8_t                 Msg3_active;
+  /// Flag to indicate that eNB should decode UE Msg3
+  uint8_t                 Msg3_flag;
+  /// Subframe for Msg3
+  uint8_t                 Msg3_subframe;
+  /// Frame for Msg3
+  uint32_t                Msg3_frame;
+  /// RNTI attributed to this ULSCH
+  uint16_t                rnti;
+  /// cyclic shift for DM RS
+  uint8_t                 cyclicShift;
+  /// cooperation flag
+  uint8_t                 cooperation_flag;
+  /// (only in-band mode), indicate the resource block overlap the SRS configuration of LTE
+  uint8_t                 N_srs;
+  ///
+  uint8_t                 scrambling_re_intialization_batch_index;
+  /// number of cell specific TX antenna ports assumed by the UE
+  uint8_t                 nrs_antenna_ports;
+  ///
+  uint16_t                scrambling_sequence_intialization;
+  ///
+  uint16_t                sf_index;
+  /// Determined the ACK/NACK delay and the subcarrier allocation TS 36.213 Table 16.4.2
+  uint8_t                 HARQ_ACK_resource;
+
+  ///////////// kept from LTE ///////////////////////////////////////////////////
+
+  /// Maximum number of iterations used in eNB turbo decoder
+  uint8_t                 max_turbo_iterations;
+  /// ACK/NAK Bundling flag
+  uint8_t                 bundling;
+  /// beta_offset_cqi times 8
+  uint16_t                beta_offset_cqi_times8;
+  /// beta_offset_ri times 8
+  uint16_t                beta_offset_ri_times8;
+  /// beta_offset_harqack times 8
+  uint16_t                beta_offset_harqack_times8;
+  /// num active cba group
+  uint8_t                 num_active_cba_groups;
+  /// allocated CBA RNTI for this ulsch
+  uint16_t                cba_rnti[4];//NUM_MAX_CBA_GROUP];
+  #ifdef LOCALIZATION
+  /// epoch timestamp in millisecond
+  int32_t                 reference_timestamp_ms;
+  /// aggregate physical states every n millisecond
+  int32_t                 aggregation_period_ms;
+  /// a set of lists used for localization
+  struct                  list loc_rss_list[10], loc_rssi_list[10], loc_subcarrier_rss_list[10], loc_timing_advance_list[10], loc_timing_update_list[10];
+  struct                  list tot_loc_rss_list, tot_loc_rssi_list, tot_loc_subcarrier_rss_list, tot_loc_timing_advance_list, tot_loc_timing_update_list;
+  #endif
+
+} NB_IoT_eNB_NULSCH_t;
+
+#define NPBCH_A 34
+
+typedef struct {
+  //the 2 LSB of the hsfn (the MSB are indicated by the SIB1-NB)
+  uint16_t  h_sfn_lsb;
+
+  uint8_t   npbch_d[96+(3*(16+NPBCH_A))];
+  uint8_t   npbch_w[3*3*(16+NPBCH_A)];
+  uint8_t   npbch_e[1600];
+  ///pdu of the npbch message
+  uint8_t   *pdu;
+
+} NB_IoT_eNB_NPBCH_t;
+
+
+#endif

openair1/PHY/LTE_TRANSPORT/dlsch_coding.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -63,42 +63,20 @@ extern int codingw;
 
 void free_eNB_dlsch(LTE_eNB_DLSCH_t *dlsch)
 {
-  int i;
-  int r;
+  int i, r, aa, layer;
 
   if (dlsch) {
-#ifdef DEBUG_DLSCH_FREE
-    printf("Freeing dlsch %p\n",dlsch);
-#endif
-
+    for (layer=0; layer<4; layer++) {
+      for (aa=0; aa<64; aa++) free16(dlsch->ue_spec_bf_weights[layer][aa], OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES*sizeof(int32_t));
+      free16(dlsch->ue_spec_bf_weights[layer], 64*sizeof(int32_t*));
+    }
     for (i=0; i<dlsch->Mdlharq; i++) {
-#ifdef DEBUG_DLSCH_FREE
-      printf("Freeing dlsch process %d\n",i);
-#endif
-
       if (dlsch->harq_processes[i]) {
-#ifdef DEBUG_DLSCH_FREE
-        printf("Freeing dlsch process %d (%p)\n",i,dlsch->harq_processes[i]);
-#endif
-
         if (dlsch->harq_processes[i]->b) {
           free16(dlsch->harq_processes[i]->b,MAX_DLSCH_PAYLOAD_BYTES);
           dlsch->harq_processes[i]->b = NULL;
-#ifdef DEBUG_DLSCH_FREE
-          printf("Freeing dlsch process %d b (%p)\n",i,dlsch->harq_processes[i]->b);
-#endif
         }
-
-#ifdef DEBUG_DLSCH_FREE
-        printf("Freeing dlsch process %d c (%p)\n",i,dlsch->harq_processes[i]->c);
-#endif
-
         for (r=0; r<MAX_NUM_DLSCH_SEGMENTS; r++) {
-
-#ifdef DEBUG_DLSCH_FREE
-          printf("Freeing dlsch process %d c[%d] (%p)\n",i,r,dlsch->harq_processes[i]->c[r]);
-#endif
-
           if (dlsch->harq_processes[i]->c[r]) {
             free16(dlsch->harq_processes[i]->c[r],((r==0)?8:0) + 3+768);
             dlsch->harq_processes[i]->c[r] = NULL;
@@ -107,17 +85,14 @@ void free_eNB_dlsch(LTE_eNB_DLSCH_t *dlsch)
             free16(dlsch->harq_processes[i]->d[r],(96+12+3+(3*6144)));
             dlsch->harq_processes[i]->d[r] = NULL;
           }
-
 	}
 	free16(dlsch->harq_processes[i],sizeof(LTE_DL_eNB_HARQ_t));
 	dlsch->harq_processes[i] = NULL;
       }
     }
-
     free16(dlsch,sizeof(LTE_eNB_DLSCH_t));
     dlsch = NULL;
-    }
-
+  }
 }
 
 LTE_eNB_DLSCH_t *new_eNB_dlsch(unsigned char Kmimo,unsigned char Mdlharq,uint32_t Nsoft,unsigned char N_RB_DL, uint8_t abstraction_flag, LTE_DL_FRAME_PARMS* frame_parms)
@@ -254,6 +229,7 @@ void clean_eNb_dlsch(LTE_eNB_DLSCH_t *dlsch)
     Mdlharq = dlsch->Mdlharq;
     dlsch->rnti = 0;
     dlsch->active = 0;
+    dlsch->harq_mask = 0;
 
     for (i=0; i<10; i++)
       dlsch->harq_ids[i] = Mdlharq;
@@ -321,13 +297,13 @@ int dlsch_encoding_2threads0(te_params *tep) {
 
 
 
-      threegpplte_turbo_encoder(dlsch->harq_processes[harq_pid]->c[r],
-                                Kr>>3,
-                                &dlsch->harq_processes[harq_pid]->d[r][96],
-                                (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
-                                f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
-                                f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
-                               );
+      encoder(dlsch->harq_processes[harq_pid]->c[r],
+              Kr>>3,
+              &dlsch->harq_processes[harq_pid]->d[r][96],
+              (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
+              f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
+              f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
+             );
       dlsch->harq_processes[harq_pid]->RTC[r] =
         sub_block_interleaving_turbo(4+(Kr_bytes*8),
                                      &dlsch->harq_processes[harq_pid]->d[r][96],
@@ -536,13 +512,13 @@ int dlsch_encoding_2threads(PHY_VARS_eNB *eNB,
 
 
       start_meas(te_stats);
-      threegpplte_turbo_encoder(dlsch->harq_processes[harq_pid]->c[r],
-                                Kr>>3,
-                                &dlsch->harq_processes[harq_pid]->d[r][96],
-                                (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
-                                f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
-                                f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
-                               );
+      encoder(dlsch->harq_processes[harq_pid]->c[r],
+              Kr>>3,
+              &dlsch->harq_processes[harq_pid]->d[r][96],
+              (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
+              f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
+              f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
+             );
       stop_meas(te_stats);
 
       start_meas(i_stats);
@@ -782,7 +758,7 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
   //  if (dlsch->harq_processes[harq_pid]->Ndi == 1) {  // this is a new packet
   if (dlsch->harq_processes[harq_pid]->round == 0) {  // this is a new packet
 #ifdef DEBUG_DLSCH_CODING
-  printf("encoding thinks this is a new packet \n");
+    printf("encoding thinks this is a new packet for harq_pid %d (%p) \n",harq_pid,dlsch->harq_processes[harq_pid]->b);
 #endif
     /*
     int i;
@@ -792,6 +768,7 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
     printf("\n");
     */
     // Add 24-bit crc (polynomial A) to payload
+
     crc = crc24a(a,
                  A)>>8;
     a[A>>3] = ((uint8_t*)&crc)[2];
@@ -853,13 +830,13 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
       printf("Encoding ... iind %d f1 %d, f2 %d\n",iind,f1f2mat_old[iind*2],f1f2mat_old[(iind*2)+1]);
 #endif
       start_meas(te_stats);
-      threegpplte_turbo_encoder(dlsch->harq_processes[harq_pid]->c[r],
-                                Kr>>3,
-                                &dlsch->harq_processes[harq_pid]->d[r][96],
-                                (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
-                                f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
-                                f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
-                               );
+      encoder(dlsch->harq_processes[harq_pid]->c[r],
+              Kr>>3,
+              &dlsch->harq_processes[harq_pid]->d[r][96],
+              (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
+              f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
+              f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
+             );
       stop_meas(te_stats);
 #ifdef DEBUG_DLSCH_CODING
 
@@ -1035,13 +1012,13 @@ int dlsch_encoding_SIC(PHY_VARS_UE *ue,
       printf("Encoding ... iind %d f1 %d, f2 %d\n",iind,f1f2mat_old[iind*2],f1f2mat_old[(iind*2)+1]);
 #endif
       start_meas(te_stats);
-      threegpplte_turbo_encoder(dlsch->harq_processes[harq_pid]->c[r],
-                                Kr>>3,
-                                &dlsch->harq_processes[harq_pid]->d[r][96],
-                                (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
-                                f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
-                                f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
-                               );
+      encoder(dlsch->harq_processes[harq_pid]->c[r],
+              Kr>>3,
+              &dlsch->harq_processes[harq_pid]->d[r][96],
+              (r==0) ? dlsch->harq_processes[harq_pid]->F : 0,
+              f1f2mat_old[iind*2],   // f1 (see 36121-820, page 14)
+              f1f2mat_old[(iind*2)+1]  // f2 (see 36121-820, page 14)
+             );
       stop_meas(te_stats);
 #ifdef DEBUG_DLSCH_CODING
 

openair1/PHY/LTE_TRANSPORT/dlsch_decoding.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -37,8 +37,8 @@
 #include "SCHED/extern.h"
 #include "SIMULATION/TOOLS/defs.h"
 //#define DEBUG_DLSCH_DECODING
+//#define UE_DEBUG_TRACE 1
 
-extern double cpuf;
 
 void free_ue_dlsch(LTE_UE_DLSCH_t *dlsch)
 {
@@ -205,21 +205,7 @@ uint32_t  dlsch_decoding(PHY_VARS_UE *phy_vars_ue,
 		    time_stats_t *);
 
 #endif
-  uint8_t (*tc)(int16_t *y,
-                uint8_t *,
-                uint16_t,
-                uint16_t,
-                uint16_t,
-                uint8_t,
-                uint8_t,
-                uint8_t,
-                time_stats_t *,
-                time_stats_t *,
-                time_stats_t *,
-                time_stats_t *,
-                time_stats_t *,
-                time_stats_t *,
-                time_stats_t *);
+decoder_if_t tc;
 
 
 
@@ -254,13 +240,13 @@ uint32_t  dlsch_decoding(PHY_VARS_UE *phy_vars_ue,
 #if 0
     tc_2cw = phy_threegpplte_turbo_decoder16avx2;
 #endif
-    tc = phy_threegpplte_turbo_decoder16;
+    tc = decoder16;
   }
   else
   {
 	  AssertFatal (harq_process->TBS >= 256 , "Mismatch flag nbRB=%d TBS=%d mcs=%d Qm=%d RIV=%d round=%d \n",
 			  harq_process->nb_rb, harq_process->TBS,harq_process->mcs,harq_process->Qm,harq_process->rvidx,harq_process->round);
-	    tc = phy_threegpplte_turbo_decoder8;
+	    tc = decoder8;
   }
 
 
@@ -489,7 +475,9 @@ uint32_t  dlsch_decoding(PHY_VARS_UE *phy_vars_ue,
       LOG_D(PHY,"AbsSubframe %d.%d Start turbo segment %d/%d \n",frame%1024,subframe,r,harq_process->C-1);
       ret = tc
             (&harq_process->d[r][96],
+             NULL,
              harq_process->c[r],
+             NULL,
              Kr,
              f1f2mat_old[iind*2],
              f1f2mat_old[(iind*2)+1],
@@ -758,318 +746,3 @@ uint32_t  dlsch_decoding(PHY_VARS_UE *phy_vars_ue,
   return(ret);
 }
 
-#ifdef PHY_ABSTRACTION
-#include "SIMULATION/TOOLS/defs.h"
-#ifdef OPENAIR2
-#include "LAYER2/MAC/extern.h"
-#include "LAYER2/MAC/defs.h"
-#endif
-
-int dlsch_abstraction_EESM(double* sinr_dB, uint8_t TM, uint32_t rb_alloc[4], uint8_t mcs, uint8_t dl_power_off)
-{
-
-  int ii;
-  double sinr_eff = 0;
-  int rb_count = 0;
-  int offset;
-  double bler = 0;
-
-  if(TM==5 && dl_power_off==1) {
-    //do nothing -- means there is no second UE and TM 5 is behaving like TM 6 for a singal user
-  } else
-    TM = TM-1;
-
-  for (offset = 0; offset <= 24; offset++) {
-    if (rb_alloc[0] & (1<<offset)) {
-      rb_count++;
-
-      for(ii=0; ii<12; ii++) {
-        sinr_eff += exp(-(pow(10, 0.1*(sinr_dB[(offset*12)+ii])))/beta1_dlsch[TM][mcs]);
-        //printf("sinr_eff1 = %f, power %lf\n",sinr_eff, exp(-pow(10,6.8)));
-
-        //  sinr_eff += exp(-(pow(10, (sinr_dB[offset*2+1])/10))/beta1_dlsch[TM][mcs]);
-        //printf("sinr_dB[%d]=%f\n",offset,sinr_dB[offset*2]);
-      }
-    }
-  }
-
-  LOG_D(OCM,"sinr_eff (lin, unweighted) = %f\n",sinr_eff);
-  sinr_eff =  -beta2_dlsch[TM][mcs]*log((sinr_eff)/(12*rb_count));
-  LOG_D(OCM,"sinr_eff (lin, weighted) = %f\n",sinr_eff);
-  sinr_eff = 10 * log10(sinr_eff);
-  LOG_D(OCM,"sinr_eff (dB) = %f\n",sinr_eff);
-
-  bler = interp(sinr_eff,&sinr_bler_map[mcs][0][0],&sinr_bler_map[mcs][1][0],table_length[mcs]);
-
-#ifdef USER_MODE // need to be adapted for the emulation in the kernel space
-
-  if (uniformrandom() < bler) {
-    LOG_I(OCM,"abstraction_decoding failed (mcs=%d, sinr_eff=%f, bler=%f, TM %d)\n",mcs,sinr_eff,bler, TM);
-    return(1);
-  } else {
-    LOG_I(OCM,"abstraction_decoding successful (mcs=%d, sinr_eff=%f, bler=%f, TM %d)\n",mcs,sinr_eff,bler, TM);
-    return(1);
-  }
-
-#endif
-}
-
-int dlsch_abstraction_MIESM(double* sinr_dB,uint8_t TM, uint32_t rb_alloc[4], uint8_t mcs,uint8_t dl_power_off)
-{
-  int ii;
-  double sinr_eff = 0;
-  double x = 0;
-  double I =0;
-  double qpsk_max=12.2;
-  double qam16_max=19.2;
-  double qam64_max=25.2;
-  double sinr_min = -20;
-  int rb_count = 0;
-  int offset=0;
-  double bler = 0;
-
-  if(TM==5 && dl_power_off==1) {
-    //do nothing -- means there is no second UE and TM 5 is behaving like TM 6 for a singal user
-  } else
-    TM = TM-1;
-
-
-  for (offset = 0; offset <= 24; offset++) {
-    if (rb_alloc[0] & (1<<offset)) {
-      rb_count++;
-
-      for(ii=0; ii<12; ii++) {
-        //x is the sinr_dB in dB
-        x = sinr_dB[(offset*12)+ii] - 10*log10(beta1_dlsch_MI[TM][mcs]);
-
-        if(x<sinr_min)
-          I +=0;
-        else {
-          if(mcs<10) {
-            if(x>qpsk_max)
-              I += 1;
-            else
-              I += (q_qpsk[0]*pow(x,7) + q_qpsk[1]*pow(x,6) + q_qpsk[2]*pow(x,5) + q_qpsk[3]*pow(x,4) + q_qpsk[4]*pow(x,3) + q_qpsk[5]*pow(x,2) + q_qpsk[6]*x + q_qpsk[7]);
-          } else if(mcs>9 && mcs<17) {
-            if(x>qam16_max)
-              I += 1;
-            else
-              I += (q_qam16[0]*pow(x,7) + q_qam16[1]*pow(x,6) + q_qam16[2]*pow(x,5) + q_qam16[3]*pow(x,4) + q_qam16[4]*pow(x,3) + q_qam16[5]*pow(x,2) + q_qam16[6]*x + q_qam16[7]);
-          } else if(mcs>16 && mcs<23) {
-
-            if(x>qam64_max)
-              I += 1;
-            else
-              I += (q_qam64[0]*pow(x,7) + q_qam64[1]*pow(x,6) + q_qam64[2]*pow(x,5) + q_qam64[3]*pow(x,4) + q_qam64[4]*pow(x,3) + q_qam64[5]*pow(x,2) + q_qam64[6]*x + q_qam64[7]);
-          }
-        }
-      }
-    }
-  }
-
-  // averaging of accumulated MI
-  I = I/(12*rb_count);
-  //Now  I->SINR_effective Mapping
-
-  if(mcs<10) {
-    sinr_eff = (p_qpsk[0]*pow(I,7) + p_qpsk[1]*pow(I,6) + p_qpsk[2]*pow(I,5) + p_qpsk[3]*pow(I,4) + p_qpsk[4]*pow(I,3) + p_qpsk[5]*pow(I,2) + p_qpsk[6]*I + p_qpsk[7]);
-  } else if(mcs>9 && mcs<17) {
-    sinr_eff = (p_qam16[0]*pow(I,7) + p_qam16[1]*pow(I,6) + p_qam16[2]*pow(I,5) + p_qam16[3]*pow(I,4) + p_qam16[4]*pow(I,3) + p_qam16[5]*pow(I,2) + p_qam16[6]*I + p_qam16[7]);
-  } else if(mcs>16 && mcs<23) {
-    sinr_eff = (p_qam64[0]*pow(I,7) + p_qam64[1]*pow(I,6) + p_qam64[2]*pow(I,5) + p_qam64[3]*pow(I,4) + p_qam64[4]*pow(I,3) + p_qam64[5]*pow(I,2) + p_qam64[6]*I + p_qam64[7]);
-  }
-
-  //sinr_eff = sinr_eff + 10*log10(beta2_dlsch_MI[TM][mcs]);
-  LOG_D(OCM,"SINR_Eff = %e\n",sinr_eff);
-
-  bler = interp(sinr_eff,&sinr_bler_map[mcs][0][0],&sinr_bler_map[mcs][1][0],table_length[mcs]);
-
-#ifdef USER_MODE // need to be adapted for the emulation in the kernel space
-
-  if (uniformrandom() < bler) {
-    LOG_N(OCM,"abstraction_decoding failed (mcs=%d, sinr_eff=%f, bler=%f)\n",mcs,sinr_eff,bler);
-    return(0);
-  } else {
-    LOG_I(OCM,"abstraction_decoding successful (mcs=%d, sinr_eff=%f, bler=%f)\n",mcs,sinr_eff,bler);
-    return(1);
-  }
-
-#endif
-}
-
-/*
-uint32_t dlsch_decoding_emul(PHY_VARS_UE *phy_vars_ue,
-                             uint8_t subframe,
-                             PDSCH_t dlsch_id,
-                             uint8_t eNB_id)
-{
-
-  LTE_UE_DLSCH_t *dlsch_ue;
-  LTE_eNB_DLSCH_t *dlsch_eNB;
-  uint8_t harq_pid;
-  uint32_t eNB_id2;
-  uint32_t ue_id;
-#ifdef DEBUG_DLSCH_DECODING
-  uint16_t i;
-#endif
-  uint8_t CC_id = phy_vars_ue->CC_id;
-
-  // may not be necessary for PMCH??
-  for (eNB_id2=0; eNB_id2<NB_eNB_INST; eNB_id2++) {
-    if (RC.eNB[eNB_id2][CC_id]->frame_parms.Nid_cell == phy_vars_ue->frame_parms.Nid_cell)
-      break;
-  }
-
-  AssertFatal(eNB_id2!=NB_eNB_INST,
-              "FATAL : Could not find attached eNB for DLSCH emulation !!!!\n");
-
-  LOG_D(PHY,"[UE] dlsch_decoding_emul : subframe %d, eNB_id %d, dlsch_id %d\n",subframe,eNB_id2,dlsch_id);
-
-  //  printf("dlsch_eNB_ra->harq_processes[0] %p\n",PHY_vars_eNB_g[eNB_id]->dlsch_eNB_ra->harq_processes[0]);
-
-
-  switch (dlsch_id) {
-  case SI_PDSCH: // SI
-    dlsch_ue = phy_vars_ue->dlsch_SI[eNB_id];
-    dlsch_eNB = RC.eNB[eNB_id2][CC_id]->dlsch_SI;
-    //    printf("Doing SI: TBS %d\n",dlsch_ue->harq_processes[0]->TBS>>3);
-    memcpy(dlsch_ue->harq_processes[0]->b,dlsch_eNB->harq_processes[0]->b,dlsch_ue->harq_processes[0]->TBS>>3);
-#ifdef DEBUG_DLSCH_DECODING
-    LOG_D(PHY,"SI Decoded\n");
-
-    for (i=0; i<dlsch_ue->harq_processes[0]->TBS>>3; i++)
-      LOG_T(PHY,"%x.",dlsch_eNB->harq_processes[0]->b[i]);
-
-    LOG_T(PHY,"\n");
-#endif
-    return(1);
-    break;
-
-  case RA_PDSCH: // RA
-    dlsch_ue  = phy_vars_ue->dlsch_ra[eNB_id];
-    dlsch_eNB = RC.eNB[eNB_id2][CC_id]->dlsch_ra;
-    memcpy(dlsch_ue->harq_processes[0]->b,dlsch_eNB->harq_processes[0]->b,dlsch_ue->harq_processes[0]->TBS>>3);
-#ifdef DEBUG_DLSCH_DECODING
-    LOG_D(PHY,"RA Decoded\n");
-
-    for (i=0; i<dlsch_ue->harq_processes[0]->TBS>>3; i++)
-      LOG_T(PHY,"%x.",dlsch_eNB->harq_processes[0]->b[i]);
-
-    LOG_T(PHY,"\n");
-#endif
-    return(1);
-    break;
-
-  case PDSCH: // TB0
-    dlsch_ue  = phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0];
-    harq_pid = dlsch_ue->current_harq_pid;
-    ue_id= (uint32_t)find_ue((int16_t)phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][(uint32_t)eNB_id]->crnti,RC.eNB[eNB_id2][CC_id]);
-    DevAssert( ue_id != (uint32_t)-1 );
-    dlsch_eNB = RC.eNB[eNB_id2][CC_id]->dlsch[ue_id][0];
-
-#ifdef DEBUG_DLSCH_DECODING
-
-    for (i=0; i<dlsch_ue->harq_processes[harq_pid]->TBS>>3; i++)
-      LOG_T(PHY,"%x.",dlsch_eNB->harq_processes[harq_pid]->b[i]);
-
-    LOG_T(PHY,"\n current harq pid is %d ue id %d \n", harq_pid, ue_id);
-#endif
-
-    if (dlsch_abstraction_MIESM(phy_vars_ue->sinr_dB,
-                                phy_vars_ue->transmission_mode[eNB_id],
-                                dlsch_eNB->harq_processes[harq_pid]->rb_alloc,
-                                dlsch_eNB->harq_processes[harq_pid]->mcs,
-                                RC.eNB[eNB_id][CC_id]->mu_mimo_mode[ue_id].dl_pow_off) == 1) {
-      // reset HARQ
-      dlsch_ue->harq_processes[harq_pid]->status = SCH_IDLE;
-      dlsch_ue->harq_processes[harq_pid]->round  = 0;
-      dlsch_ue->harq_ack[subframe].ack = 1;
-      dlsch_ue->harq_ack[subframe].harq_id = harq_pid;
-      dlsch_ue->harq_ack[subframe].send_harq_status = 1;
-
-      if (dlsch_ue->harq_processes[harq_pid]->round == 0)
-        memcpy(dlsch_ue->harq_processes[harq_pid]->b,
-               dlsch_eNB->harq_processes[harq_pid]->b,
-               dlsch_ue->harq_processes[harq_pid]->TBS>>3);
-
-      return(1);
-    } else {
-      // retransmission
-      dlsch_ue->harq_processes[harq_pid]->status = ACTIVE;
-      dlsch_ue->harq_processes[harq_pid]->round++;
-      dlsch_ue->harq_ack[subframe].ack = 0;
-      dlsch_ue->harq_ack[subframe].harq_id = harq_pid;
-      dlsch_ue->harq_ack[subframe].send_harq_status = 1;
-      dlsch_ue->last_iteration_cnt = 1+dlsch_ue->max_turbo_iterations;
-      return(1+dlsch_ue->max_turbo_iterations);
-    }
-
-    break;
-
-  case PDSCH1: { // TB1
-    dlsch_ue = phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][1];
-    harq_pid = dlsch_ue->current_harq_pid;
-    int8_t UE_id = find_ue( phy_vars_ue->pdcch_vars[phy_vars_ue->current_thread_id[subframe]][eNB_id]->crnti, RC.eNB[eNB_id2][CC_id] );
-
-    DevAssert( UE_id != -1 );
-    dlsch_eNB = RC.eNB[eNB_id2][CC_id]->dlsch[UE_id][1];
-    // reset HARQ
-    dlsch_ue->harq_processes[harq_pid]->status = SCH_IDLE;
-    dlsch_ue->harq_processes[harq_pid]->round  = 0;
-    dlsch_ue->harq_ack[subframe].ack = 1;
-    dlsch_ue->harq_ack[subframe].harq_id = harq_pid;
-    dlsch_ue->harq_ack[subframe].send_harq_status = 1;
-
-    if (dlsch_ue->harq_processes[harq_pid]->round == 0)
-      memcpy(dlsch_eNB->harq_processes[harq_pid]->b,dlsch_ue->harq_processes[harq_pid]->b,dlsch_ue->harq_processes[harq_pid]->TBS>>3);
-
-    break;
-  }
-
-  case PMCH: // PMCH
-
-    dlsch_ue  = phy_vars_ue->dlsch_MCH[eNB_id];
-    dlsch_eNB = RC.eNB[eNB_id2][CC_id]->dlsch_MCH;
-
-    LOG_D(PHY,"decoding pmch emul (size is %d, enb %d %d)\n",  dlsch_ue->harq_processes[0]->TBS>>3, eNB_id, eNB_id2);
-#ifdef DEBUG_DLSCH_DECODING
-
-    for (i=0; i<dlsch_ue->harq_processes[0]->TBS>>3; i++)
-      printf("%x.",dlsch_eNB->harq_processes[0]->b[i]);
-
-    printf("\n");
-#endif
-
-    
-    //  if (dlsch_abstraction_MIESM(phy_vars_ue->sinr_dB, phy_vars_ue->transmission_mode[eNB_id], dlsch_eNB->rb_alloc,
-    //    dlsch_eNB->harq_processes[0]->mcs,RC.eNB[eNB_id]->mu_mimo_mode[ue_id].dl_pow_off) == 1) {
-    
-    if (1) {
-      // reset HARQ
-      dlsch_ue->harq_processes[0]->status = SCH_IDLE;
-      dlsch_ue->harq_processes[0]->round  = 0;
-      memcpy(dlsch_ue->harq_processes[0]->b,
-             dlsch_eNB->harq_processes[0]->b,
-             dlsch_ue->harq_processes[0]->TBS>>3);
-      dlsch_ue->last_iteration_cnt = 1;
-      return(1);
-    } else {
-      // retransmission
-      dlsch_ue->last_iteration_cnt = 1+dlsch_ue->max_turbo_iterations;
-      return(1+dlsch_ue->max_turbo_iterations);
-    }
-
-    break;
-
-  default:
-    dlsch_ue = phy_vars_ue->dlsch[phy_vars_ue->current_thread_id[subframe]][eNB_id][0];
-    LOG_E(PHY,"dlsch_decoding_emul: FATAL, unknown DLSCH_id %d\n",dlsch_id);
-    dlsch_ue->last_iteration_cnt = 1+dlsch_ue->max_turbo_iterations;
-    return(1+dlsch_ue->max_turbo_iterations);
-  }
-
-  LOG_E(PHY,"[FATAL] dlsch_decoding.c: Should never exit here ...\n");
-  return(0);
-  }*/
-#endif
-

openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -37,11 +37,7 @@
 #include "PHY/sse_intrin.h"
 #include "T.h"
 
-#ifndef USER_MODE
-#define NOCYGWIN_STATIC static
-#else
 #define NOCYGWIN_STATIC
-#endif
 
 /* dynamic shift for LLR computation for TM3/4
  * set as command line argument, see lte-softmodem.c
@@ -52,13 +48,10 @@ int16_t interf_unaw_shift = 13;
 
 //#define DEBUG_HARQ
 
-//#undef LOG_D
-//#define LOG_D LOG_I
-
-//#define DEBUG_PHY 1
+#define DEBUG_PHY 1
 //#define DEBUG_DLSCH_DEMOD 1
 
-
+//#define DISABLE_LOG_X
 
 // [MCS][i_mod (0,1,2) = (2,4,6)]
 unsigned char offset_mumimo_llr_drange_fix=0;
@@ -374,7 +367,7 @@ int rx_pdsch(PHY_VARS_UE *ue,
 
   //printf("nb_rb = %d, eNB_id %d\n",nb_rb,eNB_id);
   if (nb_rb==0) {
-    LOG_D(PHY,"dlsch_demodulation.c: nb_rb=0\n");
+    //    LOG_D(PHY,"dlsch_demodulation.c: nb_rb=0\n");
     return(-1);
   }
 
@@ -850,17 +843,19 @@ int rx_pdsch(PHY_VARS_UE *ue,
   pllr_symbol_cw0 += llr_offset_symbol;
   pllr_symbol_cw1 += llr_offset_symbol;
 
-  /*LOG_I(PHY,"compute LLRs [AbsSubframe %d.%d-%d] NbRB %d Qm %d LLRs-Length %d LLR-Offset %d @LLR Buff %x @LLR Buff(symb) %x\n",
-             proc->frame_rx, proc->subframe_rx,symbol,
+  LOG_I(PHY,"compute LLRs [AbsSubframe %d.%d-%d] NbRB %d Qm %d LLRs-Length %d LLR-Offset %d @LLR Buff %p @LLR Buff(symb) %p\n",
+             frame, subframe,symbol,
              nb_rb,dlsch0_harq->Qm,
              pdsch_vars[eNB_id]->llr_length[symbol],
              pdsch_vars[eNB_id]->llr_offset[symbol],
              (int16_t*)pdsch_vars[eNB_id]->llr[0],
-             pllr_symbol);*/
+             pllr_symbol_cw0);
 
   switch (dlsch0_harq->Qm) {
   case 2 :
     if ((rx_type==rx_standard) || (codeword_TB1 == -1)) {
+
+
         dlsch_qpsk_llr(frame_parms,
                        pdsch_vars[eNB_id]->rxdataF_comp0,
                        (int16_t*)pllr_symbol_cw0,
@@ -6027,9 +6022,6 @@ unsigned short dlsch_extract_rbs_TM7(int **rxdataF,
 
 //==============================================================================================
 
-#ifdef USER_MODE
-
-
 void dump_dlsch2(PHY_VARS_UE *ue,uint8_t eNB_id,uint8_t subframe,unsigned int *coded_bits_per_codeword,int round,  unsigned char harq_pid)
 {
   unsigned int nsymb = (ue->frame_parms.Ncp == 0) ? 14 : 12;
@@ -6119,7 +6111,6 @@ void dump_dlsch2(PHY_VARS_UE *ue,uint8_t eNB_id,uint8_t subframe,unsigned int *c
 
   //  printf("log2_maxh = %d\n",ue->pdsch_vars[eNB_id]->log2_maxh);
 }
-#endif
 
 #ifdef DEBUG_DLSCH_DEMOD
 /*

openair1/PHY/LTE_TRANSPORT/dlsch_llr_computation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -40,7 +40,7 @@
 //#define DEBUG_LLR_SIC
 
 
-int16_t zero[8] __attribute__ ((aligned(16))) = {0,0,0,0,0,0,0,0};
+int16_t zeros[8] __attribute__ ((aligned(16))) = {0,0,0,0,0,0,0,0};
 int16_t ones[8] __attribute__ ((aligned(16))) = {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff};
 #if defined(__x86_64__) || defined(__i386__)
 __m128i rho_rpi __attribute__ ((aligned(16)));
@@ -672,14 +672,14 @@ int dlsch_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
   }
 
 
-  //printf("dlsch_qpsk_llr: symbol %d,nb_rb %d, len %d,pbch_pss_sss_adjust %d\n",symbol,nb_rb,len,pbch_pss_sss_adjust);
-  /*LOG_I(PHY,"dlsch_qpsk_llr: [symb %d / FirstSym %d / Length %d]: @LLR Buff %x, @LLR Buff(symb) %x \n",
+  /*
+  LOG_I(PHY,"dlsch_qpsk_llr: [symb %d / FirstSym %d / Length %d]: @LLR Buff %x, @LLR Buff(symb) %x \n",
              symbol,
              first_symbol_flag,
              len,
              dlsch_llr,
-             llr32);*/
-
+             llr32);
+  */
   //printf("ll32p=%p , dlsch_llr=%p, symbol=%d, flag=%d \n", llr32, dlsch_llr, symbol, first_symbol_flag);
   for (i=0; i<len; i++) {
     *llr32 = *rxF;

openair1/PHY/LTE_TRANSPORT/dlsch_llr_computation_avx2.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -79,7 +79,7 @@ uint8_t is_not_UEspecRS(int8_t lprime, uint8_t re, uint8_t nushift, uint8_t Ncp,
         if ((re!=nushift+offset) && (re!=((nushift+4+offset)%12)) &&  (re!=((nushift+8+offset)%12)))
           return(1);
         /*else{
-          printf("(is_no_UEspec_RS):lprime=%d, re=%d, nushift=%d, offset=%d\n",lprime, re,nushift,offset);
+          LOG_I(PHY,"(is_no_UEspec_RS):lprime=%d, re=%d, nushift=%d, offset=%d\n",lprime, re,nushift,offset);
         }*/
       } else {
         if ((re!=nushift+offset) && (re!=((nushift+3+offset)%12)) && (re!=((nushift+6+offset)%12)) && (re!=((nushift+9+offset)%12)))
@@ -434,7 +434,7 @@ int allocate_REs_in_RB_pilots_16QAM_siso(PHY_VARS_eNB* phy_vars_eNB,
 
 
   if (skip_dc == 0) {
-    //    printf("pilots: P1_SHIFT[0] %d\n",P1_SHIFT[0]);
+    //    LOG_I(PHY,"pilots: P1_SHIFT[0] %d\n",P1_SHIFT[0]);
     for (x0p=&x0[*jj],tti_offset=symbol_offset+re_offset+P1_SHIFT[0],re=P1_SHIFT[0];
          re<12;
          x0p+=4) {
@@ -445,7 +445,7 @@ int allocate_REs_in_RB_pilots_16QAM_siso(PHY_VARS_eNB* phy_vars_eNB,
       qam16_table_offset_im+=x0p[3];
       ((int16_t *)&txdataF[0][tti_offset])[0]=qam_table_s0[qam16_table_offset_re];
       ((int16_t *)&txdataF[0][tti_offset])[1]=qam_table_s0[qam16_table_offset_im];
-      //      printf("pilots: re %d, tti_offset %d, P1_SHIFT %d\n",re,tti_offset,P1_SHIFT[re+1]);
+      //      LOG_I(PHY,"pilots: re %d, tti_offset %d, P1_SHIFT %d\n",re,tti_offset,P1_SHIFT[re+1]);
       tti_offset+=P1_SHIFT[re+1];
       re+=P1_SHIFT[re+1];
     }
@@ -661,7 +661,7 @@ int allocate_REs_in_RB_pilots_64QAM_siso(PHY_VARS_eNB* phy_vars_eNB,
 
 
   if (skip_dc == 0) {
-    //    printf("pilots: P1_SHIFT[0] %d\n",P1_SHIFT[0]);
+    //    LOG_I(PHY,"pilots: P1_SHIFT[0] %d\n",P1_SHIFT[0]);
     for (x0p=&x0[*jj],tti_offset=symbol_offset+re_offset+P1_SHIFT[0],re=P1_SHIFT[0];
          re<12;
          x0p+=6) {
@@ -674,7 +674,7 @@ int allocate_REs_in_RB_pilots_64QAM_siso(PHY_VARS_eNB* phy_vars_eNB,
       qam64_table_offset_im+=x0p[5];
       ((int16_t *)&txdataF[0][tti_offset])[0]=qam_table_s0[qam64_table_offset_re];
       ((int16_t *)&txdataF[0][tti_offset])[1]=qam_table_s0[qam64_table_offset_im];
-      //      printf("pilots: re %d, tti_offset %d, P1_SHIFT %d\n",re,tti_offset,P1_SHIFT[re+1]);
+      //      LOG_I(PHY,"pilots: re %d, tti_offset %d, P1_SHIFT %d\n",re,tti_offset,P1_SHIFT[re+1]);
       tti_offset+=P1_SHIFT[re+1];
       re+=P1_SHIFT[re+1];
     }
@@ -831,11 +831,11 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
 
   if (dlsch0_harq != NULL){
     #ifdef DEBUG_DLSCH_MODULATION
-      printf("allocate_re (mod %d): symbol_offset %d re_offset %d (%d,%d), jj %d -> %d,%d\n",mod_order0,symbol_offset,re_offset,skip_dc,skip_half,*jj, x0[*jj], x0[1+*jj]);
+      LOG_I(PHY,"allocate_re (mod %d): symbol_offset %d re_offset %d (%d,%d), jj %d -> %d,%d\n",mod_order0,symbol_offset,re_offset,skip_dc,skip_half,*jj, x0[*jj], x0[1+*jj]);
     #endif
   } else{
     #ifdef DEBUG_DLSCH_MODULATION
-      printf("allocate_re (mod %d): symbol_offset %d re_offset %d (%d,%d), jj %d -> %d,%d\n",mod_order0,symbol_offset,re_offset,skip_dc,skip_half,*jj, x0[*jj], x0[1+*jj]);
+      LOG_I(PHY,"allocate_re (mod %d): symbol_offset %d re_offset %d (%d,%d), jj %d -> %d,%d\n",mod_order0,symbol_offset,re_offset,skip_dc,skip_half,*jj, x0[*jj], x0[1+*jj]);
     #endif
   }
 
@@ -849,7 +849,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
 
 
   for (re=first_re; re<last_re; re++) {
-  // printf("element %d precoder_index for allocation %d\n",re, precoder_index );
+  // LOG_I(PHY,"element %d precoder_index for allocation %d\n",re, precoder_index );
 
     if ((skip_dc == 1) && (re==6))
       re_off=re_off - frame_parms->ofdm_symbol_size+1;
@@ -859,7 +859,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
       //check that RE is not from Cell-specific RS
 
     if (is_not_pilot(pilots,re,frame_parms->nushift,use2ndpilots)==1) {
-      //printf("re %d (jj %d)\n",re,*jj);
+      //LOG_I(PHY,"re %d (jj %d)\n",re,*jj);
 
 
       if (mimo_mode == SISO) {  //SISO mapping
@@ -869,7 +869,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
         case 2:  //QPSK
 
 
-          //printf("re %d %d(%d) : %d,%d => ",re,tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+          //LOG_I(PHY,"re %d %d(%d) : %d,%d => ",re,tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
           ((int16_t*)&txdataF[0][tti_offset])[0] += (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; //I //b_i
 
           *jj = *jj + 1;
@@ -1135,12 +1135,12 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
             break;
 
           case 2:  //QPSK
-            //printf("%d(%d) : %d,%d => ",tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+            //LOG_I(PHY,"%d(%d) : %d,%d => ",tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
             xx0_re = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
             *jj = *jj + 1;
             xx0_im = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
             *jj = *jj + 1;
-            //printf("%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+            //LOG_I(PHY,"%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
             break;
 
           case 4:  //16QAM
@@ -1206,12 +1206,12 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
             break;
 
           case 2:  //QPSK
-            //printf("%d(%d) : %d,%d => ",tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+            //LOG_I(PHY,"%d(%d) : %d,%d => ",tti_offset,*jj,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
             xx1_re = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
             *jj2 = *jj2 + 1;
             xx1_im = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
             *jj2 = *jj2 + 1;
-            //printf("%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+            //LOG_I(PHY,"%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
             break;
 
           case 4:  //16QAM
@@ -1278,7 +1278,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
           ((int16_t *)&txdataF[0][tti_offset])[1]+=((xx0_im+xx1_im)>>1);
           ((int16_t *)&txdataF[1][tti_offset])[1]+=(s*((xx0_im-xx1_im)>>1));
           /*
-          printf("CDD: xx0 (%d,%d), xx1(%d,%d), s(%d), txF[0] (%d,%d), txF[1] (%d,%d)\n",
+          LOG_I(PHY,"CDD: xx0 (%d,%d), xx1(%d,%d), s(%d), txF[0] (%d,%d), txF[1] (%d,%d)\n",
            xx0_re,xx0_im,xx1_re,xx1_im, s, ((int16_t *)&txdataF[0][tti_offset])[0],((int16_t *)&txdataF[0][tti_offset])[1],
            ((int16_t *)&txdataF[1][tti_offset])[0],((int16_t *)&txdataF[1][tti_offset])[1]);
           */
@@ -1408,7 +1408,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
           precoder_index1 = 3; //[1 -j]
         }
         else {
-         printf("problem with precoder in TM4\n");
+         LOG_I(PHY,"problem with precoder in TM4\n");
           return(-1);
         }
 
@@ -1427,7 +1427,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
           ((int16_t*)&txdataF[0][tti_offset])[0] += (int16_t)((((int16_t*)&tmp_sample1)[0]*ONE_OVER_SQRT2_Q15)>>15);
           ((int16_t*)&txdataF[0][tti_offset])[1] += (int16_t)((((int16_t*)&tmp_sample1)[1]*ONE_OVER_SQRT2_Q15)>>15);
 
-          //printf("%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+          //LOG_I(PHY,"%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
 
           if (frame_parms->nb_antenna_ports_eNB == 2) {
             layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index0);
@@ -1630,7 +1630,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
               ((int16_t*)&txdataF[5][tti_offset])[1] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
               *jj = *jj + 1;
 
-              //printf("%d(%d) : %d,%d =>
+              //LOG_I(PHY,"%d(%d) : %d,%d =>
               //",tti_offset,*jj,((int16_t*)&tmp_sample1)[0],((int16_t*)&tmp_sample1)[1]);
               break;
 
@@ -1709,7 +1709,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
           }
         } else {
           //precoding UE spec RS
-          //printf("precoding UE spec RS\n");
+          //LOG_I(PHY,"precoding UE spec RS\n");
 
           ind = 3*lprime*dlsch0_harq->nb_rb+mprime2;
           ind_dword = ind>>4;
@@ -1727,7 +1727,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
           switch (mod_order0) {
           case 2:  //QPSK
 
-            //    printf("%d : %d,%d => ",tti_offset,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+            //    LOG_I(PHY,"%d : %d,%d => ",tti_offset,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
             for (int layer=first_layer0; layer<=(first_layer0+Nlayers0); layer++) {
               ((int16_t*)&txdataF[layer][tti_offset])[0] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; //I //b_i
               *jj = *jj + 1;
@@ -1815,7 +1815,7 @@ int allocate_REs_in_RB(PHY_VARS_eNB* phy_vars_eNB,
           }
         }
       } else if (mimo_mode>=TM9_10) {
-        printf("allocate_REs_in_RB() [dlsch.c] : ERROR, unknown mimo_mode %d\n",mimo_mode);
+        LOG_I(PHY,"allocate_REs_in_RB() [dlsch.c] : ERROR, unknown mimo_mode %d\n",mimo_mode);
         return(-1);
       }
     }
@@ -1850,7 +1850,7 @@ int allocate_REs_in_RB_MCH(int32_t **txdataF,
   uint8_t first_re,last_re;
   int inc;
 #ifdef DEBUG_DLSCH_MODULATION
-  printf("allocate_re_MCH (mod %d): symbol_offset %d re_offset %d (%d), jj %d -> %d,%d, gain_lin_QPSK %d,txdataF %p\n",mod_order,symbol_offset,re_offset,skip_dc,*jj, x0[*jj], x0[1+*jj],gain_lin_QPSK,&txdataF[0][symbol_offset]);
+  LOG_I(PHY,"allocate_re_MCH (mod %d): symbol_offset %d re_offset %d (%d), jj %d -> %d,%d, gain_lin_QPSK %d,txdataF %p\n",mod_order,symbol_offset,re_offset,skip_dc,*jj, x0[*jj], x0[1+*jj],gain_lin_QPSK,&txdataF[0][symbol_offset]);
 #endif
 
   last_re=12;
@@ -1871,7 +1871,7 @@ int allocate_REs_in_RB_MCH(int32_t **txdataF,
 
     tti_offset = symbol_offset + re_off + re;
 
-    //printf("re %d (jj %d)\n",re,*jj);
+    //LOG_I(PHY,"re %d (jj %d)\n",re,*jj);
     *re_allocated = *re_allocated + 1;
 
 
@@ -1879,7 +1879,7 @@ int allocate_REs_in_RB_MCH(int32_t **txdataF,
 
       case 2:  //QPSK
 
-      //            printf("%d : %d,%d => ",tti_offset,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+      //            LOG_I(PHY,"%d : %d,%d => ",tti_offset,((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
       ((int16_t*)&txdataF[4][tti_offset])[0] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK; //I //b_i
 
       *jj = *jj + 1;
@@ -1888,7 +1888,7 @@ int allocate_REs_in_RB_MCH(int32_t **txdataF,
 
       *jj = *jj + 1;
 
-      //printf("%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
+      //LOG_I(PHY,"%d,%d\n",((int16_t*)&txdataF[0][tti_offset])[0],((int16_t*)&txdataF[0][tti_offset])[1]);
       break;
 
 
@@ -2095,7 +2095,7 @@ inline int check_skip(int rb,int subframe_offset,LTE_DL_FRAME_PARMS *frame_parms
 inline int check_skiphalf(int rb,int subframe_offset,LTE_DL_FRAME_PARMS *frame_parms,int l,int nsymb) __attribute__((always_inline));
 inline int check_skiphalf(int rb,int subframe_offset,LTE_DL_FRAME_PARMS *frame_parms,int l,int nsymb) {
 
-  //  printf("check_skiphalf : rb %d, subframe_offset %d,l %d, nsymb %d\n",rb,subframe_offset,l,nsymb);
+  //  LOG_I(PHY,"check_skiphalf : rb %d, subframe_offset %d,l %d, nsymb %d\n",rb,subframe_offset,l,nsymb);
 
   if ((frame_parms->N_RB_DL&1) == 1) { // ODD N_RB_DL
 
@@ -2333,19 +2333,19 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
   re_allocated=0;
 
 
-  //  printf("num_pdcch_symbols %d, nsymb %d\n",num_pdcch_symbols,nsymb);
+  //  LOG_I(PHY,"num_pdcch_symbols %d, nsymb %d\n",num_pdcch_symbols,nsymb);
   for (l=num_pdcch_symbols; l<nsymb; l++) {
 
   if (dlsch0 != NULL ) {
 #ifdef DEBUG_DLSCH_MODULATION
-    printf("Generating DLSCH (harq_pid %d,mimo %d, pmi_alloc0 %lx, mod0 %d, mod1 %d, rb_alloc[0] %d) in %d\n",
+    LOG_I(PHY,"Generating DLSCH (harq_pid %d,mimo %d, pmi_alloc0 %lx, mod0 %d, mod1 %d, rb_alloc[0] %d)\n",
             harq_pid,
             dlsch0_harq->mimo_mode,
             pmi2hex_2Ar2(dlsch0_harq->pmi_alloc),
             mod_order0,
             mod_order1,
-            rb_alloc[0],
-            len);
+            rb_alloc[0]
+            );
 #endif
   }
 
@@ -2395,6 +2395,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 	for (eNB_id=0;eNB_id<ru->num_eNB;eNB_id++){
 	  if (phy_vars_eNB == ru->eNB_list[eNB_id]) {
 	    for (aa=0;aa<ru->nb_tx;aa++){
+              LOG_I(PHY,"ru_id:%d eNB_id:%d aa:%d memcpy(ru->beam_weights, dlsch0->ue_spec_bf_weights[ru_id][0],)\n", ru_id, eNB_id, aa);
 	      memcpy(ru->beam_weights[eNB_id][5][aa],
 		     dlsch0->ue_spec_bf_weights[ru_id][0],
 		     frame_parms->ofdm_symbol_size*sizeof(int32_t));
@@ -2412,7 +2413,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 
     if (pilots>0) {  // compute pilot arrays, could be done statically if performance suffers
       if (frame_parms->nb_antenna_ports_eNB == 1) {
-	//	printf("l %d, nushift %d, offset %d\n",l,frame_parms->nushift,offset);
+	//	LOG_I(PHY,"l %d, nushift %d, offset %d\n",l,frame_parms->nushift,offset);
 	for (i=0,i2=0;i<12;i++) {
 	  if ((i!=(frame_parms->nushift+offset)) && (i!=((frame_parms->nushift+6+offset)%12)))
 	    P1_SHIFT[i2++]=1;
@@ -2539,7 +2540,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 
     //for (aa=0;aa<frame_parms->nb_antennas_tx;aa++)
     //memset(&txdataF[aa][symbol_offset],0,frame_parms->ofdm_symbol_size<<2);
-    //printf("symbol_offset %d,subframe offset %d : pilots %d\n",symbol_offset,subframe_offset,pilots);
+    //LOG_I(PHY,"symbol_offset %d,subframe offset %d : pilots %d\n",symbol_offset,subframe_offset,pilots);
     for (rb=0; rb<frame_parms->N_RB_DL; rb++) {
 
       if (rb < 32)
@@ -2570,7 +2571,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 
       if (dlsch1) {
         if (dlsch1_harq->Nlayers>1) {
-          printf("Nlayers %d: re_offset %d, symbol %d offset %d\n",dlsch0_harq->Nlayers,re_offset,l,symbol_offset);
+          LOG_I(PHY,"Nlayers %d: re_offset %d, symbol %d offset %d\n",dlsch0_harq->Nlayers,re_offset,l,symbol_offset);
           return(-1);
         }
       }
@@ -2578,7 +2579,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 
 
       if (rb_alloc_ind > 0) {
-        //    printf("Allocated rb %d/symbol %d, skip_half %d, subframe_offset %d, symbol_offset %d, re_offset %d, jj %d\n",rb,l,skip_half,subframe_offset,symbol_offset,re_offset,jj);
+        //    LOG_I(PHY,"Allocated rb %d/symbol %d, skip_half %d, subframe_offset %d, symbol_offset %d, re_offset %d, jj %d\n",rb,l,skip_half,subframe_offset,symbol_offset,re_offset,jj);
 
       if (dlsch0 != NULL) {
         get_pmi_temp = get_pmi(frame_parms->N_RB_DL,
@@ -2618,7 +2619,7 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
             mprime +=3+frame_parms->Ncp;
       }
       else {
-        //      printf("Unallocated rb %d/symbol %d, re_offset %d, jj %d\n",rb,l,re_offset,jj);
+        //      LOG_I(PHY,"Unallocated rb %d/symbol %d, re_offset %d, jj %d\n",rb,l,re_offset,jj);
       }
       re_offset+=12; // go to next RB
 
@@ -2635,9 +2636,9 @@ int dlsch_modulation(PHY_VARS_eNB* phy_vars_eNB,
 
 #ifdef DEBUG_DLSCH_MODULATION
   if (dlsch0 != NULL){
-    printf("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset));
+    LOG_I(PHY,"generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset,1));
   }else{
-    printf("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch1_harq->nb_rb,dlsch1_harq->rb_alloc,mod_order1,Nl1,2,0,subframe_offset));
+    LOG_I(PHY,"generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch1_harq->nb_rb,dlsch1_harq->rb_alloc,mod_order1,Nl1,2,0,subframe_offset,1));
   }
 #endif
 
@@ -2692,7 +2693,7 @@ int dlsch_modulation_SIC(int32_t **sic_buffer,
 
       jj = jj + 1;
 
-      //printf("recon %d,%d\n",((int16_t*)&sic_buffer[0][i])[0],((int16_t*)&sic_buffer[0][i])[1]);
+      //LOG_I(PHY,"recon %d,%d\n",((int16_t*)&sic_buffer[0][i])[0],((int16_t*)&sic_buffer[0][i])[1]);
       i++;
 
       break;
@@ -2779,7 +2780,7 @@ int dlsch_modulation_SIC(int32_t **sic_buffer,
 
 
 #ifdef DEBUG_DLSCH_MODULATION
-  printf("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset,1/*transmission mode*/));
+  LOG_I(PHY,"generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset,1/*transmission mode*/));
 #endif
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_MODULATION, VCD_FUNCTION_OUT);
@@ -2817,11 +2818,11 @@ int mch_modulation(int32_t **txdataF,
   jj=0;
   re_allocated=0;
 
-  //  printf("num_pdcch_symbols %d, nsymb %d\n",num_pdcch_symbols,nsymb);
+  //  LOG_I(PHY,"num_pdcch_symbols %d, nsymb %d\n",num_pdcch_symbols,nsymb);
   for (l=2; l<nsymb_pmch; l++) {
 
 #ifdef DEBUG_DLSCH_MODULATION
-    printf("Generating MCH (mod %d) in subframe %d for symbol %d\n",mod_order, subframe_offset,l);
+    LOG_I(PHY,"Generating MCH (mod %d) in subframe %d for symbol %d\n",mod_order, subframe_offset,l);
 #endif
 
     re_offset = frame_parms->first_carrier_offset;
@@ -2846,7 +2847,7 @@ int mch_modulation(int32_t **txdataF,
       else
         qam_table_s = NULL;
 
-      //printf("Allocated rb %d, subframe_offset %d,amp %d\n",rb,subframe_offset,amp);
+      //LOG_I(PHY,"Allocated rb %d, subframe_offset %d,amp %d\n",rb,subframe_offset,amp);
       allocate_REs_in_RB_MCH(txdataF,
                              &jj,
                              re_offset,
@@ -2873,7 +2874,7 @@ int mch_modulation(int32_t **txdataF,
   }
 
 #ifdef DEBUG_DLSCH_MODULATION
-  printf("generate_dlsch(MCH) : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch->harq_processes[0]->nb_rb,dlsch->harq_processes[0]->rb_alloc,mod_order,1,2,0,subframe_offset,1/*transmission mode*/));
+  LOG_I(PHY,"generate_dlsch(MCH) : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch->harq_processes[0]->nb_rb,dlsch->harq_processes[0]->rb_alloc,mod_order,1,2,0,subframe_offset,1/*transmission mode*/));
 #endif
 
   return (re_allocated);

openair1/PHY/LTE_TRANSPORT/dlsch_scrambling.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -124,14 +124,18 @@ void dlsch_scrambling(LTE_DL_FRAME_PARMS *frame_parms,
   }
 
 #ifdef DEBUG_SCRAMBLING
+#ifdef Rel14
   printf("scrambling: i0 %d rnti %x, q %d, Ns %d, Nid_cell %d, G %d x2 %x\n",dlsch->i0,dlsch->rnti,q,Ns,frame_parms->Nid_cell, G, x2);
+#else
+  printf("scrambling: rnti %x, q %d, Ns %d, Nid_cell %d, G %d x2 %x\n",dlsch->rnti,q,Ns,frame_parms->Nid_cell, G, x2);
+#endif
 #endif
   s = lte_gold_scram(&x1, &x2, 1);
 
   for (n=0; n<(1+(G>>5)); n++) {
 
 #ifdef DEBUG_SCRAMBLING
-    printf("scrambling %d : %d => ",k,e[k]);
+    for (int k=0;k<32;k++) printf("scrambling %d : %d xor %d = %d\n",k+(n<<5),e[k],(s>>k)&1,e[k]^((s>>k)&1));
 #endif
 
                 
@@ -171,9 +175,8 @@ void dlsch_scrambling(LTE_DL_FRAME_PARMS *frame_parms,
     // This is not faster for some unknown reason
     //    ((__m128i *)e)[0] = _mm_xor_si128(((__m128i *)e)[0],((__m128i *)scrambling_lut)[s&65535]);
     //    ((__m128i *)e)[1] = _mm_xor_si128(((__m128i *)e)[1],((__m128i *)scrambling_lut)[s>>16]);
-#ifdef DEBUG_SCRAMBLING
-    printf("%d\n",e[k]);
-#endif
+
+
     
     
     s = lte_gold_scram(&x1, &x2, 0);
@@ -213,7 +216,7 @@ void dlsch_unscrambling(LTE_DL_FRAME_PARMS *frame_parms,
   for (i=0; i<(1+(G>>5)); i++) {
     for (j=0; j<32; j++,k++) {
 #ifdef DEBUG_SCRAMBLING
-      printf("unscrambling %d : %d => ",k,llr[k]);
+    printf("unscrambling %d : %d xor %d =",k,llr[k],(s>>j)&1);
 #endif
       llr[k] = ((2*((s>>j)&1))-1)*llr[k];
 #ifdef DEBUG_SCRAMBLING

openair1/PHY/LTE_TRANSPORT/dlsch_tbs.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/dlsch_tbs_full.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/drs_modulation.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -81,7 +81,6 @@ int generate_drs_pusch(PHY_VARS_UE *ue,
   //        cyclic_shift1 = 0;
   Msc_RS = 12*nb_rb;
 
-#ifdef USER_MODE
   Msc_idx_ptr = (uint16_t*) bsearch(&Msc_RS, dftsizes, 33, sizeof(uint16_t), compareints);
 
   if (Msc_idx_ptr)
@@ -91,26 +90,14 @@ int generate_drs_pusch(PHY_VARS_UE *ue,
     return(-1);
   }
 
-#else
-  uint8_t b;
-
-  for (b=0; b<33; b++)
-    if (Msc_RS==dftsizes[b])
-      Msc_RS_idx = b;
-
-#endif
-#ifdef DEBUG_DRS
-  printf("[PHY] drs_modulation: Msc_RS = %d, Msc_RS_idx = %d,cyclic_shift %d, u0 %d, v0 %d, u1 %d, v1 %d,cshift0 %d,cshift1 %d\n",Msc_RS, Msc_RS_idx,cyclic_shift,u0,v0,u1,v1,cyclic_shift0,cyclic_shift1);
-
-#endif
-
-
   for (l = (3 - frame_parms->Ncp),u=u0,v=v0,cyclic_shift=cyclic_shift0;
        l<frame_parms->symbols_per_tti;
        l += (7 - frame_parms->Ncp),u=u1,v=v1,cyclic_shift=cyclic_shift1) {
 
-    drs_offset = 0;  //  printf("drs_modulation: Msc_RS = %d, Msc_RS_idx = %d\n",Msc_RS, Msc_RS_idx);
-
+    drs_offset = 0;
+#ifdef DEBUG_DRS
+    printf("drs_modulation: Msc_RS = %d, Msc_RS_idx = %d, u=%d,v=%d\n",Msc_RS, Msc_RS_idx,u,v);
+#endif
 
 
     re_offset = frame_parms->first_carrier_offset;

openair1/PHY/LTE_TRANSPORT/edci.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -29,11 +29,9 @@
 * \note
 * \warning
 */
-#ifdef USER_MODE
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#endif
 #include "PHY/defs.h"
 #include "PHY/extern.h"
 #include "SCHED/defs.h"

openair1/PHY/LTE_TRANSPORT/extern.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/group_hopping.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/if4_tools.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -58,7 +58,7 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
   uint16_t db_fulllength, db_halflength; 
   int slotoffsetF=0, blockoffsetF=0; 
 
-  uint16_t *data_block=NULL, *i=NULL;
+  uint16_t *data_block=NULL, *i=NULL, *d=NULL;
 
   IF4p5_header_t *packet_header=NULL;
   eth_state_t *eth = (eth_state_t*) (ru->ifdevice.priv);
@@ -67,11 +67,12 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
   if (ru->idx==0) VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_SEND_IF4, 1 );   
 
   if (packet_type == IF4p5_PDLFFT) {
-    LOG_D(PHY,"send DL_IF4p5: RU %d frame %d, subframe %d\n",ru->idx,frame,subframe);
+    //LOG_D(PHY,"send DL_IF4p5: RU %d frame %d, subframe %d\n",ru->idx,frame,subframe);
 
     if (subframe_select(fp,subframe)==SF_S)
       nsym=fp->dl_symbols_in_S_subframe;
 
+
     db_fulllength = 12*fp->N_RB_DL;
     db_halflength = (db_fulllength)>>1;
     slotoffsetF = 1;//(subframe)*(fp->ofdm_symbol_size)*((fp->Ncp==1) ? 12 : 14) + 1;
@@ -104,7 +105,7 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
       if ((ru->ifdevice.trx_write_func(&ru->ifdevice,
 				       symbol_id,
 				       &tx_buffer,
-				       db_fulllength,
+				       db_fulllength, 
 				       1,
 				       IF4p5_PDLFFT)) < 0) {
         perror("ETHERNET write for IF4p5_PDLFFT\n");
@@ -137,24 +138,47 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
 
     if (packet_type == IF4p5_PULFFT) {
 
-      for (symbol_id=fp->symbols_per_tti-nsym; symbol_id<fp->symbols_per_tti; symbol_id++) {	     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SEND_IF4_SYMBOL, symbol_id );
-	VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_COMPR_IF, 1 );		
-	LOG_D(PHY,"IF4p5_PULFFT: frame %d, subframe %d, symbol %d: %d dB\n",frame,subframe,symbol_id,
-	      dB_fixed(signal_energy((int32_t*)&rxdataF[0][blockoffsetF],db_halflength)));
+      for (symbol_id=fp->symbols_per_tti-nsym; symbol_id<fp->symbols_per_tti; symbol_id++) {
 
-	for (element_id=0; element_id<db_halflength; element_id++) {
-	  i = (uint16_t*) &rxdataF[0][blockoffsetF+element_id];
-	  data_block[element_id] = ((uint16_t) lin2alaw_if4p5[*i]) | ((uint16_t)(lin2alaw_if4p5[*(i+1)]<<8));
-	  
-	  i = (uint16_t*) &rxdataF[0][slotoffsetF+element_id];
-	  data_block[element_id+db_halflength] = ((uint16_t) lin2alaw_if4p5[*i]) | ((uint16_t)(lin2alaw_if4p5[*(i+1)]<<8));
-	  //if (element_id==0) LOG_I(PHY,"send_if4p5: symbol %d rxdata0 = (%d,%d)\n",symbol_id,*i,*(i+1));
-		
-	}
-	VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_COMPR_IF, 0 );   	
+	uint32_t *rx0 = (uint32_t*) &rxdataF[0][blockoffsetF];
+	uint32_t *rx1 = (uint32_t*) &rxdataF[0][slotoffsetF];
+
+	VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_SEND_IF4_SYMBOL, symbol_id );
+	VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_COMPR_IF, 1 );		
+
+	start_meas(&ru->compression);
+
+	for (element_id=0; element_id<db_halflength; element_id+=8) {
+	  i = (uint16_t*) &rx0[element_id];
+          d = (uint16_t*) &data_block[element_id];
+          d[0] = ((uint16_t) lin2alaw_if4p5[i[0]])  | ((uint16_t)(lin2alaw_if4p5[i[1]]<<8));
+          d[1] = ((uint16_t) lin2alaw_if4p5[i[2]])  | ((uint16_t)(lin2alaw_if4p5[i[3]]<<8));
+          d[2] = ((uint16_t) lin2alaw_if4p5[i[4]])  | ((uint16_t)(lin2alaw_if4p5[i[5]]<<8));
+          d[3] = ((uint16_t) lin2alaw_if4p5[i[6]])  | ((uint16_t)(lin2alaw_if4p5[i[7]]<<8));
+          d[4] = ((uint16_t) lin2alaw_if4p5[i[8]])  | ((uint16_t)(lin2alaw_if4p5[i[9]]<<8));
+          d[5] = ((uint16_t) lin2alaw_if4p5[i[10]]) | ((uint16_t)(lin2alaw_if4p5[i[11]]<<8));
+          d[6] = ((uint16_t) lin2alaw_if4p5[i[12]]) | ((uint16_t)(lin2alaw_if4p5[i[13]]<<8));
+          d[7] = ((uint16_t) lin2alaw_if4p5[i[14]]) | ((uint16_t)(lin2alaw_if4p5[i[15]]<<8));
+
+          i = (uint16_t*) &rx1[element_id];
+          d = (uint16_t*) &data_block[element_id+db_halflength];
+          d[0] = ((uint16_t) lin2alaw_if4p5[i[0]])  | ((uint16_t)(lin2alaw_if4p5[i[1]]<<8));
+          d[1] = ((uint16_t) lin2alaw_if4p5[i[2]])  | ((uint16_t)(lin2alaw_if4p5[i[3]]<<8));
+          d[2] = ((uint16_t) lin2alaw_if4p5[i[4]])  | ((uint16_t)(lin2alaw_if4p5[i[5]]<<8));
+          d[3] = ((uint16_t) lin2alaw_if4p5[i[6]])  | ((uint16_t)(lin2alaw_if4p5[i[7]]<<8));
+          d[4] = ((uint16_t) lin2alaw_if4p5[i[8]])  | ((uint16_t)(lin2alaw_if4p5[i[9]]<<8));
+          d[5] = ((uint16_t) lin2alaw_if4p5[i[10]]) | ((uint16_t)(lin2alaw_if4p5[i[11]]<<8));
+          d[6] = ((uint16_t) lin2alaw_if4p5[i[12]]) | ((uint16_t)(lin2alaw_if4p5[i[13]]<<8));
+          d[7] = ((uint16_t) lin2alaw_if4p5[i[14]]) | ((uint16_t)(lin2alaw_if4p5[i[15]]<<8));
+
+        }
+
+        stop_meas(&ru->compression);
+        VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_COMPR_IF, 0 );   	
 	packet_header->frame_status &= ~(0x000f<<26);
 	packet_header->frame_status |= (symbol_id&0x000f)<<26; 
 	VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_IF, 1 );  
+	start_meas(&ru->transport);
 	if ((ru->ifdevice.trx_write_func(&ru->ifdevice,
 					 symbol_id,
 					 &tx_buffer,
@@ -163,6 +187,7 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
 					 IF4p5_PULFFT)) < 0) {
 	  perror("ETHERNET write for IF4p5_PULFFT\n");
 	}
+	stop_meas(&ru->transport);
 	VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_IF, 0 );
 	slotoffsetF  += fp->ofdm_symbol_size;
 	blockoffsetF += fp->ofdm_symbol_size;
@@ -181,7 +206,7 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
   } else if (packet_type >= IF4p5_PRACH && 
 	     packet_type <= IF4p5_PRACH+4) {
     // FIX: hard coded prach samples length
-    LOG_D(PHY,"IF4p5_PRACH: frame %d, subframe %d\n",frame,subframe);
+    LOG_D(PHY,"IF4p5_PRACH: frame %d, subframe %d,packet type %x\n",frame,subframe,packet_type);
     db_fulllength = PRACH_NUM_SAMPLES;
     
     if (eth->flags == ETH_RAW_IF4p5_MODE) {
@@ -222,6 +247,7 @@ void send_IF4p5(RU_t *ru, int frame, int subframe, uint16_t packet_type) {
 				     packet_type)) < 0) {
       perror("ETHERNET write for IF4p5_PRACH\n");
     }
+
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_WRITE_IF, 0 );      
   } else {    
     AssertFatal(1==0, "send_IF4p5 - Unknown packet_type %x", packet_type);     
@@ -283,7 +309,7 @@ void recv_IF4p5(RU_t *ru, int *frame, int *subframe, uint16_t *packet_type, uint
   *subframe = ((packet_header->frame_status)>>22)&0x000f;
 
   *packet_type = packet_header->sub_type; 
-
+  LOG_D(PHY,"recv_IF4p5: Frame %d, Subframe %d: packet_type %x\n",*frame,*subframe,*packet_type);
   if (*packet_type == IF4p5_PDLFFT) {          
     *symbol_number = ((packet_header->frame_status)>>26)&0x000f;         
     VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME( VCD_SIGNAL_DUMPER_VARIABLES_RECV_IF4_SYMBOL, *symbol_number );
@@ -313,7 +339,6 @@ void recv_IF4p5(RU_t *ru, int *frame, int *subframe, uint16_t *packet_type, uint
     slotoffsetF = (*symbol_number)*(fp->ofdm_symbol_size);
     blockoffsetF = slotoffsetF + fp->ofdm_symbol_size - db_halflength; 
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_DECOMPR_IF, 1 );  
-    if (ru->idx==0) LOG_D(PHY,"UL_IF4p5: CC_id %d : frame %d, subframe %d, symbol %d\n",ru->idx,*frame,*subframe,*symbol_number);
     for (element_id=0; element_id<db_halflength; element_id++) {
       i = (uint16_t*) &rxdataF[0][blockoffsetF+element_id];
       *i = alaw2lin_if4p5[ (data_block[element_id] & 0xff) ]; 
@@ -325,6 +350,9 @@ void recv_IF4p5(RU_t *ru, int *frame, int *subframe, uint16_t *packet_type, uint
 
 	//if (element_id==0) LOG_I(PHY,"recv_if4p5: symbol %d rxdata0 = (%u,%u)\n",*symbol_number,*i,*(i+1));
     }
+    LOG_D(PHY,"PULFFT_IF4p5: CC_id %d : frame %d, subframe %d (symbol %d)=> %d dB\n",ru->idx,*frame,*subframe,*symbol_number,
+	  dB_fixed(signal_energy((int*)&rxdataF[0][slotoffsetF],db_halflength)+
+		   signal_energy((int*)&rxdataF[0][blockoffsetF],db_halflength)));
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_TRX_DECOMPR_IF, 0 );		
   } else if (*packet_type >= IF4p5_PRACH &&
 	     *packet_type <= IF4p5_PRACH + 4) {  

openair1/PHY/LTE_TRANSPORT/if4_tools.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -39,11 +39,11 @@
 #define IF4p5_PULFFT 0x0019 
 #define IF4p5_PDLFFT 0x0020
 #define IF4p5_PRACH 0x0021
-#define IF4p5_PRACH_BR_CE0 0x0021
-#define IF4p5_PRACH_BR_CE1 0x0022
-#define IF4p5_PRACH_BR_CE2 0x0023
-#define IF4p5_PRACH_BR_CE3 0x0024
-#define IF4p5_PULTICK 0x0025
+#define IF4p5_PRACH_BR_CE0 0x0022
+#define IF4p5_PRACH_BR_CE1 0x0023
+#define IF4p5_PRACH_BR_CE2 0x0024
+#define IF4p5_PRACH_BR_CE3 0x0025
+#define IF4p5_PULTICK 0x0026
 
 struct IF4p5_header {  
   /// Type

openair1/PHY/LTE_TRANSPORT/if5_tools.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/if5_tools.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/initial_sync.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -237,10 +237,6 @@ int pbch_detection(PHY_VARS_UE *ue, runmode_t mode)
         ue->proc.proc_rxtx[i].frame_rx =   (((ue->pbch_vars[0]->decoded_output[2]&3)<<6) + (ue->pbch_vars[0]->decoded_output[1]>>2))<<2;
         ue->proc.proc_rxtx[i].frame_rx =   (((ue->pbch_vars[0]->decoded_output[2]&3)<<6) + (ue->pbch_vars[0]->decoded_output[1]>>2))<<2;
 
-#ifndef USER_MODE
-        // one frame delay
-        ue->proc.proc_rxtx[i].frame_rx ++;
-#endif
         ue->proc.proc_rxtx[i].frame_tx = ue->proc.proc_rxtx[0].frame_rx;
     }
 #ifdef DEBUG_INITIAL_SYNCH

openair1/PHY/LTE_TRANSPORT/lte_mcs.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/mcs_tbs_tools.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/mdci.h

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/pbch.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -37,11 +37,6 @@
 #include "PHY/extern.h"
 #include "PHY/sse_intrin.h"
 
-#ifdef PHY_ABSTRACTION
-#include "SIMULATION/TOOLS/defs.h"
-#endif
-
-
 //#define DEBUG_PBCH 1
 //#define DEBUG_PBCH_ENCODING
 //#define INTERFERENCE_MITIGATION 1
@@ -174,6 +169,8 @@ int generate_pbch(LTE_eNB_PBCH *eNB_pbch,
   pbch_E  = (frame_parms->Ncp==NORMAL) ? 1920 : 1728; //RE/RB * #RB * bits/RB (QPSK)
   //  pbch_E_bytes = pbch_coded_bits>>3;
 
+  LOG_D(PHY,"%s(eNB_pbch:%p txdataF:%p amp:%d frame_parms:%p pbch_pdu:%p frame_mod4:%d)\n", __FUNCTION__, eNB_pbch, txdataF, amp, frame_parms, pbch_pdu, frame_mod4==0);
+
   if (frame_mod4==0) {
     bzero(pbch_a,PBCH_A>>3);
     bzero(eNB_pbch->pbch_e,pbch_E);
@@ -258,13 +255,11 @@ int generate_pbch(LTE_eNB_PBCH *eNB_pbch,
       #endif
 
       #ifdef DEBUG_PBCH
-      #ifdef USER_MODE
       write_output("pbch_encoded_output2.m","pbch_encoded_out2",
       pbch_coded_data2,
       pbch_coded_bits,
       1,
       4);
-      #endif //USER_MODE
       #endif //DEBUG_PBCH
     */
 #ifdef DEBUG_PBCH_ENCODING
@@ -286,8 +281,6 @@ int generate_pbch(LTE_eNB_PBCH *eNB_pbch,
 
 
 #ifdef DEBUG_PBCH
-#ifdef USER_MODE
-
     if (frame_mod4==0) {
       write_output("pbch_e.m","pbch_e",
                    eNB_pbch->pbch_e,
@@ -298,8 +291,6 @@ int generate_pbch(LTE_eNB_PBCH *eNB_pbch,
       for (i=0; i<16; i++)
         printf("e[%d] %d\n",i,eNB_pbch->pbch_e[i]);
     }
-
-#endif //USER_MODE
 #endif //DEBUG_PBCH
     // scrambling
 
@@ -307,8 +298,6 @@ int generate_pbch(LTE_eNB_PBCH *eNB_pbch,
                     eNB_pbch->pbch_e,
                     pbch_E);
 #ifdef DEBUG_PBCH
-#ifdef USER_MODE
-
     if (frame_mod4==0) {
       write_output("pbch_e_s.m","pbch_e_s",
                    eNB_pbch->pbch_e,
@@ -319,8 +308,6 @@ int generate_pbch(LTE_eNB_PBCH *eNB_pbch,
       for (i=0; i<16; i++)
         printf("e_s[%d] %d\n",i,eNB_pbch->pbch_e[i]);
     }
-
-#endif //USER_MODE
 #endif //DEBUG_PBCH 
   } // frame_mod4==0
 
@@ -1026,44 +1013,3 @@ uint16_t rx_pbch(LTE_UE_COMMON *lte_ue_common_vars,
 
 
 }
-
-#ifdef PHY_ABSTRACTION
-uint16_t rx_pbch_emul(PHY_VARS_UE *phy_vars_ue,
-                      uint8_t eNB_id,
-                      uint8_t pbch_phase)
-{
-
-  double bler=0.0;//, x=0.0;
-  double sinr=0.0;
-  uint16_t nb_rb = phy_vars_ue->frame_parms.N_RB_DL;
-  int16_t f;
-  uint8_t CC_id=phy_vars_ue->CC_id;
-  int frame_rx = phy_vars_ue->proc.proc_rxtx[0].frame_rx;
-
-  // compute effective sinr
-  // TODO: adapt this to varible bandwidth
-  for (f=(nb_rb*6-3*12); f<(nb_rb*6+3*12); f++) {
-    if (f!=0) //skip DC
-      sinr += pow(10, 0.1*(phy_vars_ue->sinr_dB[f]));
-  }
-
-  sinr = 10*log10(sinr/(6*12));
-
-  bler = pbch_bler(sinr);
-
-  LOG_D(PHY,"EMUL UE rx_pbch_emul: eNB_id %d, pbch_phase %d, sinr %f dB, bler %f \n",
-        eNB_id,
-        pbch_phase,
-        sinr,
-        bler);
-
-  if (pbch_phase == (frame_rx % 4)) {
-    if (uniformrandom() >= bler) {
-      memcpy(phy_vars_ue->pbch_vars[eNB_id]->decoded_output,RC.eNB[eNB_id][CC_id]->pbch_pdu,PBCH_PDU_SIZE);
-      return(RC.eNB[eNB_id][CC_id]->frame_parms.nb_antenna_ports_eNB);
-    } else
-      return(-1);
-  } else
-    return(-1);
-}
-#endif

openair1/PHY/LTE_TRANSPORT/pcfich.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/pch.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *

openair1/PHY/LTE_TRANSPORT/phich.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -38,10 +38,6 @@
 #include "LAYER2/MAC/extern.h"
 #include "LAYER2/MAC/defs.h"
 
-#ifndef USER_MODE
-#include "ARCH/CBMIMO1/DEVICE_DRIVER/extern.h"
-#endif
-
 #include "T.h"
 
 //#define DEBUG_PHICH 1
@@ -162,7 +158,7 @@ int phich_frame2_pusch_frame(LTE_DL_FRAME_PARMS *frame_parms, int frame, int sub
     pusch_frame = (frame);
   }
 
-  LOG_D(PHY, "frame %d subframe %d: PUSCH frame = %d\n", frame, subframe, pusch_frame);
+  //LOG_D(PHY, "frame %d subframe %d: PUSCH frame = %d\n", frame, subframe, pusch_frame);
   return pusch_frame % 1024;
 }
 
@@ -184,8 +180,8 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     else if (subframe == 1)
       pusch_subframe = (7);
     else {
-      LOG_E(PHY, "phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
-            subframe,frame_parms->tdd_config);
+      AssertFatal(1==0,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
+		  subframe,frame_parms->tdd_config);
       pusch_subframe = (0);
     }
 
@@ -201,7 +197,7 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     else if (subframe == 4)
       pusch_subframe = (8);
     else {
-      LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
+      AssertFatal(1==0,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
             subframe,frame_parms->tdd_config);
       pusch_subframe = (0);
     }
@@ -214,7 +210,7 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     else if (subframe == 3)
       pusch_subframe = (7);
     else {
-      LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
+      AssertFatal(1==0,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
             subframe,frame_parms->tdd_config);
       pusch_subframe = (0);
     }
@@ -227,7 +223,7 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     } else if (subframe==0)
       pusch_subframe = (4);
     else {
-      LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
+      AssertFatal(1==0,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
             subframe,frame_parms->tdd_config);
       pusch_subframe = (0);
     }
@@ -238,7 +234,7 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     if ( (subframe == 8) || (subframe == 9) ) {
       pusch_subframe = (subframe-6);
     } else {
-      LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
+      AssertFatal(1==0,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
             subframe,frame_parms->tdd_config);
       pusch_subframe = (0);
     }
@@ -249,7 +245,7 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     if (subframe == 8) {
       pusch_subframe = (2);
     } else {
-      LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
+      AssertFatal(1==0,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
             subframe,frame_parms->tdd_config);
       pusch_subframe = (0);
     }
@@ -268,7 +264,7 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     } else if (subframe == 5) {
       pusch_subframe = (8);
     } else {
-      LOG_E(PHY,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
+      AssertFatal(1==0,"phich.c: phich_subframe2_pusch_subframe, illegal subframe %d for tdd_config %d\n",
             subframe,frame_parms->tdd_config);
       pusch_subframe = (0);
     }
@@ -276,7 +272,7 @@ uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t s
     break;
 
   default:
-    LOG_E(PHY, "no implementation for TDD UL/DL-config = %d!\n", frame_parms->tdd_config);
+    AssertFatal(1==0, "no implementation for TDD UL/DL-config = %d!\n", frame_parms->tdd_config);
     pusch_subframe = (0);
   }
 
@@ -560,7 +556,7 @@ void generate_phich(LTE_DL_FRAME_PARMS *frame_parms,
         break;
 
       default:
-        LOG_E(PHY,"phich_coding.c: Illegal PHICH Number\n");
+        AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
       } // nseq_PHICH
     }
 
@@ -858,7 +854,7 @@ void generate_phich(LTE_DL_FRAME_PARMS *frame_parms,
       break;
 
     default:
-      LOG_E(PHY,"phich_coding.c: Illegal PHICH Number\n");
+      AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
     }
 
 
@@ -1255,7 +1251,7 @@ void rx_phich(PHY_VARS_UE *ue,
         break;
 
       default:
-        LOG_E(PHY,"phich_coding.c: Illegal PHICH Number\n");
+        AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
       } // nseq_PHICH
     }
 
@@ -1342,7 +1338,7 @@ void rx_phich(PHY_VARS_UE *ue,
       break;
 
     default:
-      LOG_E(PHY,"phich_coding.c: Illegal PHICH Number\n");
+      AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
     }
   }
 
@@ -1527,9 +1523,11 @@ void generate_phich_top(PHY_VARS_eNB *eNB,
   if (frame_parms->Ncp == 1)
     NSF_PHICH = 2;
 
-  pusch_frame = phich_frame2_pusch_frame(frame_parms,proc->frame_tx,subframe);
-  pusch_subframe = phich_subframe2_pusch_subframe(frame_parms,subframe);
-  harq_pid = subframe2harq_pid(frame_parms,pusch_frame,pusch_subframe);
+  if (eNB->phich_vars[subframe&1].num_hi > 0) {
+    pusch_frame = phich_frame2_pusch_frame(frame_parms,proc->frame_tx,subframe);
+    pusch_subframe = phich_subframe2_pusch_subframe(frame_parms,subframe);
+    harq_pid = subframe2harq_pid(frame_parms,pusch_frame,pusch_subframe);
+  }
 
   for (i=0; i<eNB->phich_vars[subframe&1].num_hi; i++) {
 

openair1/PHY/LTE_TRANSPORT/pilots.c

@@ -3,7 +3,7 @@
  * 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
- * the OAI Public License, Version 1.0  (the "License"); you may not use this file
+ * the OAI Public License, Version 1.1  (the "License"); you may not use this file
  * except in compliance with the License.
  * You may obtain a copy of the License at
  *