diff --git a/openair1/PHY/LTE_UE_TRANSPORT/dci_ue.c b/openair1/PHY/LTE_UE_TRANSPORT/dci_ue.c
new file mode 100755
index 0000000000000000000000000000000000000000..70b5f735fff012c31e892a43d6946f9a190d1102
--- /dev/null
+++ b/openair1/PHY/LTE_UE_TRANSPORT/dci_ue.c
@@ -0,0 +1,3681 @@
+/*
+ * 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.c
+* \brief Implements PDCCH physical channel TX/RX procedures (36.211) and DCI encoding/decoding (36.212/36.213). Current LTE compliance V8.6 2009-03.
+* \author R. Knopp
+* \date 2011
+* \version 0.1
+* \company Eurecom
+* \email: knopp@eurecom.fr
+* \note
+* \warning
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "PHY/defs.h"
+#include "PHY/extern.h"
+#include "SCHED/defs.h"
+#include "SIMULATION/TOOLS/defs.h" // for taus
+#include "PHY/sse_intrin.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
+//#define DEBUG_PHY
+
+//#undef ALL_AGGREGATION
+
+//extern uint16_t phich_reg[MAX_NUM_PHICH_GROUPS][3];
+//extern uint16_t pcfich_reg[4];
+
+uint32_t check_phich_reg(LTE_DL_FRAME_PARMS *frame_parms,uint32_t kprime,uint8_t lprime,uint8_t mi)
+{
+
+ uint16_t i;
+ uint16_t Ngroup_PHICH = (frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)/48;
+ uint16_t mprime;
+ uint16_t *pcfich_reg = frame_parms->pcfich_reg;
+
+ if ((lprime>0) && (frame_parms->Ncp==0) )
+ return(0);
+
+ // printf("check_phich_reg : mi %d\n",mi);
+
+ // compute REG based on symbol
+ if ((lprime == 0)||
+ ((lprime==1)&&(frame_parms->nb_antenna_ports_eNB == 4)))
+ mprime = kprime/6;
+ else
+ mprime = kprime>>2;
+
+ // check if PCFICH uses mprime
+ if ((lprime==0) &&
+ ((mprime == pcfich_reg[0]) ||
+ (mprime == pcfich_reg[1]) ||
+ (mprime == pcfich_reg[2]) ||
+ (mprime == pcfich_reg[3]))) {
+#ifdef DEBUG_DCI_ENCODING
+ printf("[PHY] REG %d allocated to PCFICH\n",mprime);
+#endif
+ return(1);
+ }
+
+ // handle Special subframe case for TDD !!!
+
+ // printf("Checking phich_reg %d\n",mprime);
+ if (mi > 0) {
+ if (((frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)%48) > 0)
+ Ngroup_PHICH++;
+
+ if (frame_parms->Ncp == 1) {
+ Ngroup_PHICH<<=1;
+ }
+
+
+
+ for (i=0; i<Ngroup_PHICH; i++) {
+ if ((mprime == frame_parms->phich_reg[i][0]) ||
+ (mprime == frame_parms->phich_reg[i][1]) ||
+ (mprime == frame_parms->phich_reg[i][2])) {
+#ifdef DEBUG_DCI_ENCODING
+ printf("[PHY] REG %d (lprime %d) allocated to PHICH\n",mprime,lprime);
+#endif
+ return(1);
+ }
+ }
+ }
+
+ return(0);
+}
+
+uint16_t extract_crc(uint8_t *dci,uint8_t dci_len)
+{
+
+ uint16_t crc16;
+ // uint8_t i;
+
+ /*
+ uint8_t crc;
+ crc = ((uint16_t *)dci)[DCI_LENGTH>>4];
+ printf("crc1: %x, shift %d (DCI_LENGTH %d)\n",crc,DCI_LENGTH&0xf,DCI_LENGTH);
+ crc = (crc>>(DCI_LENGTH&0xf));
+ // clear crc bits
+ ((uint16_t *)dci)[DCI_LENGTH>>4] &= (0xffff>>(16-(DCI_LENGTH&0xf)));
+ printf("crc2: %x, dci0 %x\n",crc,((int16_t *)dci)[DCI_LENGTH>>4]);
+ crc |= (((uint16_t *)dci)[1+(DCI_LENGTH>>4)])<<(16-(DCI_LENGTH&0xf));
+ // clear crc bits
+ (((uint16_t *)dci)[1+(DCI_LENGTH>>4)]) = 0;
+ printf("extract_crc: crc %x\n",crc);
+ */
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY,"dci_crc (%x,%x,%x), dci_len&0x7=%d\n",dci[dci_len>>3],dci[1+(dci_len>>3)],dci[2+(dci_len>>3)],
+ dci_len&0x7);
+#endif
+
+ if ((dci_len&0x7) > 0) {
+ ((uint8_t *)&crc16)[0] = dci[1+(dci_len>>3)]<<(dci_len&0x7) | dci[2+(dci_len>>3)]>>(8-(dci_len&0x7));
+ ((uint8_t *)&crc16)[1] = dci[(dci_len>>3)]<<(dci_len&0x7) | dci[1+(dci_len>>3)]>>(8-(dci_len&0x7));
+ } else {
+ ((uint8_t *)&crc16)[0] = dci[1+(dci_len>>3)];
+ ((uint8_t *)&crc16)[1] = dci[(dci_len>>3)];
+ }
+
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY,"dci_crc =>%x\n",crc16);
+#endif
+
+ // dci[(dci_len>>3)]&=(0xffff<<(dci_len&0xf));
+ // dci[(dci_len>>3)+1] = 0;
+ // dci[(dci_len>>3)+2] = 0;
+ return((uint16_t)crc16);
+
+}
+
+
+
+void pdcch_demapping(uint16_t *llr,uint16_t *wbar,LTE_DL_FRAME_PARMS *frame_parms,uint8_t num_pdcch_symbols,uint8_t mi)
+{
+
+ uint32_t i, lprime;
+ uint16_t kprime,kprime_mod12,mprime,symbol_offset,tti_offset,tti_offset0;
+ int16_t re_offset,re_offset0;
+
+ // This is the REG allocation algorithm from 36-211, second part of Section 6.8.5
+
+ int Msymb2;
+
+ switch (frame_parms->N_RB_DL) {
+ case 100:
+ Msymb2 = Msymb;
+ break;
+
+ case 75:
+ Msymb2 = 3*Msymb/4;
+ break;
+
+ case 50:
+ Msymb2 = Msymb>>1;
+ break;
+
+ case 25:
+ Msymb2 = Msymb>>2;
+ break;
+
+ case 15:
+ Msymb2 = Msymb*15/100;
+ break;
+
+ case 6:
+ Msymb2 = Msymb*6/100;
+ break;
+
+ default:
+ Msymb2 = Msymb>>2;
+ break;
+ }
+
+ mprime=0;
+
+
+ re_offset = 0;
+ re_offset0 = 0; // counter for symbol with pilots (extracted outside!)
+
+ for (kprime=0; kprime<frame_parms->N_RB_DL*12; kprime++) {
+ for (lprime=0; lprime<num_pdcch_symbols; lprime++) {
+
+ symbol_offset = (uint32_t)frame_parms->N_RB_DL*12*lprime;
+
+ tti_offset = symbol_offset + re_offset;
+ tti_offset0 = symbol_offset + re_offset0;
+
+ // if REG is allocated to PHICH, skip it
+ if (check_phich_reg(frame_parms,kprime,lprime,mi) == 1) {
+ // printf("dci_demapping : skipping REG %d (RE %d)\n",(lprime==0)?kprime/6 : kprime>>2,kprime);
+ if ((lprime == 0)&&((kprime%6)==0))
+ re_offset0+=4;
+ } else { // not allocated to PHICH/PCFICH
+ // printf("dci_demapping: REG %d\n",(lprime==0)?kprime/6 : kprime>>2);
+ if (lprime == 0) {
+ // first symbol, or second symbol+4 TX antennas skip pilots
+ kprime_mod12 = kprime%12;
+
+ if ((kprime_mod12 == 0) || (kprime_mod12 == 6)) {
+ // kprime represents REG
+
+ for (i=0; i<4; i++) {
+ wbar[mprime] = llr[tti_offset0+i];
+#ifdef DEBUG_DCI_DECODING
+// LOG_I(PHY,"PDCCH demapping mprime %d.%d <= llr %d (symbol %d re %d) -> (%d,%d)\n",mprime/4,i,tti_offset0+i,symbol_offset,re_offset0,*(char*)&wbar[mprime],*(1+(char*)&wbar[mprime]));
+#endif
+ mprime++;
+ re_offset0++;
+ }
+ }
+ } else if ((lprime==1)&&(frame_parms->nb_antenna_ports_eNB == 4)) {
+ // LATER!!!!
+ } else { // no pilots in this symbol
+ kprime_mod12 = kprime%12;
+
+ if ((kprime_mod12 == 0) || (kprime_mod12 == 4) || (kprime_mod12 == 8)) {
+ // kprime represents REG
+ for (i=0; i<4; i++) {
+ wbar[mprime] = llr[tti_offset+i];
+#ifdef DEBUG_DCI_DECODING
+// LOG_I(PHY,"PDCCH demapping mprime %d.%d <= llr %d (symbol %d re %d) -> (%d,%d)\n",mprime/4,i,tti_offset+i,symbol_offset,re_offset+i,*(char*)&wbar[mprime],*(1+(char*)&wbar[mprime]));
+#endif
+ mprime++;
+ }
+ } // is representative
+ } // no pilots case
+ } // not allocated to PHICH/PCFICH
+
+ // Stop when all REGs are copied in
+ if (mprime>=Msymb2)
+ break;
+ } //lprime loop
+
+ re_offset++;
+
+ } // kprime loop
+}
+
+static uint16_t wtemp_rx[Msymb];
+void pdcch_deinterleaving(LTE_DL_FRAME_PARMS *frame_parms,uint16_t *z, uint16_t *wbar,uint8_t number_pdcch_symbols,uint8_t mi)
+{
+
+ uint16_t *wptr,*zptr,*wptr2;
+
+ uint16_t Mquad=get_nquad(number_pdcch_symbols,frame_parms,mi);
+ uint32_t RCC = (Mquad>>5), ND;
+ uint32_t row,col,Kpi,index;
+ int32_t i,k;
+
+
+ // printf("Mquad %d, RCC %d\n",Mquad,RCC);
+
+ AssertFatal(z!=NULL,"dci.c: pdcch_deinterleaving: FATAL z is Null\n");
+
+ // undo permutation
+ for (i=0; i<Mquad; i++) {
+ wptr = &wtemp_rx[((i+frame_parms->Nid_cell)%Mquad)<<2];
+ wptr2 = &wbar[i<<2];
+
+ wptr[0] = wptr2[0];
+ 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],
+ ((char*)wptr2)[2],
+ ((char*)wptr2)[3],
+ ((char*)wptr2)[4],
+ ((char*)wptr2)[5],
+ ((char*)wptr2)[6],
+ ((char*)wptr2)[7]);
+ */
+
+ }
+
+ if ((Mquad&0x1f) > 0)
+ RCC++;
+
+ Kpi = (RCC<<5);
+ ND = Kpi - Mquad;
+
+ k=0;
+
+ for (col=0; col<32; col++) {
+ index = bitrev_cc_dci[col];
+
+ for (row=0; row<RCC; row++) {
+ // printf("row %d, index %d, Nd %d\n",row,index,ND);
+ if (index>=ND) {
+
+
+
+ wptr = &wtemp_rx[k<<2];
+ zptr = &z[(index-ND)<<2];
+
+ zptr[0] = wptr[0];
+ zptr[1] = wptr[1];
+ 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],
+ ((int8_t *)wptr)[2],
+ ((int8_t *)wptr)[3],
+ ((int8_t *)wptr)[4],
+ ((int8_t *)wptr)[5],
+ ((int8_t *)wptr)[6],
+ ((int8_t *)wptr)[7]);
+ */
+ k++;
+ }
+
+ index+=32;
+
+ }
+ }
+
+ 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],
+ ((int8_t *)zptr)[2],
+ ((int8_t *)zptr)[3],
+ ((int8_t *)zptr)[4],
+ ((int8_t *)zptr)[5],
+ ((int8_t *)zptr)[6],
+ ((int8_t *)zptr)[7]);
+ */
+ }
+
+}
+
+
+int32_t pdcch_qpsk_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t **rxdataF_comp,
+ int32_t **rxdataF_comp_i,
+ int32_t **rho_i,
+ int16_t *pdcch_llr16,
+ int16_t *pdcch_llr8in,
+ uint8_t symbol)
+{
+
+ int16_t *rxF=(int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+ int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
+ int16_t *rho=(int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+ int16_t *llr128;
+ int32_t i;
+ char *pdcch_llr8;
+ int16_t *pdcch_llr;
+ pdcch_llr8 = (char *)&pdcch_llr8in[symbol*frame_parms->N_RB_DL*12];
+ pdcch_llr = &pdcch_llr16[symbol*frame_parms->N_RB_DL*12];
+
+ // printf("dlsch_qpsk_qpsk: symbol %d\n",symbol);
+
+ llr128 = (int16_t*)pdcch_llr;
+
+ if (!llr128) {
+ printf("dlsch_qpsk_qpsk_llr: llr is null, symbol %d\n",symbol);
+ return -1;
+ }
+
+ qpsk_qpsk(rxF,
+ rxF_i,
+ llr128,
+ rho,
+ frame_parms->N_RB_DL*12);
+
+ //prepare for Viterbi which accepts 8 bit, but prefers 4 bit, soft input.
+ for (i=0; i<(frame_parms->N_RB_DL*24); i++) {
+ if (*pdcch_llr>7)
+ *pdcch_llr8=7;
+ else if (*pdcch_llr<-8)
+ *pdcch_llr8=-8;
+ else
+ *pdcch_llr8 = (char)(*pdcch_llr);
+
+ pdcch_llr++;
+ pdcch_llr8++;
+ }
+
+ return(0);
+}
+
+
+int32_t pdcch_llr(LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t **rxdataF_comp,
+ char *pdcch_llr,
+ uint8_t symbol)
+{
+
+ int16_t *rxF= (int16_t*) &rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+ int32_t i;
+ char *pdcch_llr8;
+
+ pdcch_llr8 = &pdcch_llr[2*symbol*frame_parms->N_RB_DL*12];
+
+ if (!pdcch_llr8) {
+ printf("pdcch_qpsk_llr: llr is null, symbol %d\n",symbol);
+ return(-1);
+ }
+
+ // printf("pdcch qpsk llr for symbol %d (pos %d), llr offset %d\n",symbol,(symbol*frame_parms->N_RB_DL*12),pdcch_llr8-pdcch_llr);
+
+ for (i=0; i<(frame_parms->N_RB_DL*((symbol==0) ? 16 : 24)); i++) {
+
+ if (*rxF>31)
+ *pdcch_llr8=31;
+ else if (*rxF<-32)
+ *pdcch_llr8=-32;
+ else
+ *pdcch_llr8 = (char)(*rxF);
+
+ // printf("%d %d => %d\n",i,*rxF,*pdcch_llr8);
+ rxF++;
+ pdcch_llr8++;
+ }
+
+ return(0);
+
+}
+
+//__m128i avg128P;
+
+//compute average channel_level on each (TX,RX) antenna pair
+void pdcch_channel_level(int32_t **dl_ch_estimates_ext,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t *avg,
+ uint8_t nb_rb)
+{
+
+ int16_t rb;
+ uint8_t aatx,aarx;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *dl_ch128;
+ __m128i avg128P;
+#elif defined(__arm__)
+ int16x8_t *dl_ch128;
+ int32x4_t *avg128P;
+#endif
+ for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++)
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+ //clear average level
+#if defined(__x86_64__) || defined(__i386__)
+ avg128P = _mm_setzero_si128();
+ dl_ch128=(__m128i *)&dl_ch_estimates_ext[(aatx<<1)+aarx][0];
+#elif defined(__arm__)
+
+#endif
+ for (rb=0; rb<nb_rb; rb++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+ avg128P = _mm_add_epi32(avg128P,_mm_madd_epi16(dl_ch128[0],dl_ch128[0]));
+ avg128P = _mm_add_epi32(avg128P,_mm_madd_epi16(dl_ch128[1],dl_ch128[1]));
+ avg128P = _mm_add_epi32(avg128P,_mm_madd_epi16(dl_ch128[2],dl_ch128[2]));
+#elif defined(__arm__)
+
+#endif
+ dl_ch128+=3;
+ /*
+ if (rb==0) {
+ print_shorts("dl_ch128",&dl_ch128[0]);
+ print_shorts("dl_ch128",&dl_ch128[1]);
+ print_shorts("dl_ch128",&dl_ch128[2]);
+ }
+ */
+ }
+
+ DevAssert( nb_rb );
+ avg[(aatx<<1)+aarx] = (((int32_t*)&avg128P)[0] +
+ ((int32_t*)&avg128P)[1] +
+ ((int32_t*)&avg128P)[2] +
+ ((int32_t*)&avg128P)[3])/(nb_rb*12);
+
+ // printf("Channel level : %d\n",avg[(aatx<<1)+aarx]);
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+
+}
+
+#if defined(__x86_64) || defined(__i386__)
+__m128i mmtmpPD0,mmtmpPD1,mmtmpPD2,mmtmpPD3;
+#elif defined(__arm__)
+
+#endif
+void pdcch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t symbol,
+ int32_t **dl_ch_estimates_ext,
+ int32_t **dl_ch_estimates_ext_i,
+ int32_t **dl_ch_rho_ext,
+ uint8_t output_shift)
+{
+
+ uint16_t rb;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *dl_ch128,*dl_ch128i,*dl_ch_rho128;
+#elif defined(__arm__)
+
+#endif
+ uint8_t aarx;
+
+ // printf("dlsch_dual_stream_correlation: symbol %d\n",symbol);
+
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+ dl_ch128 = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
+ dl_ch128i = (__m128i *)&dl_ch_estimates_ext_i[aarx][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_rho128 = (__m128i *)&dl_ch_rho_ext[aarx][symbol*frame_parms->N_RB_DL*12];
+
+#elif defined(__arm__)
+
+#endif
+
+ for (rb=0; rb<frame_parms->N_RB_DL; rb++) {
+ // multiply by conjugated channel
+#if defined(__x86_64__) || defined(__i386__)
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128i[0]);
+ // print_ints("re",&mmtmpPD0);
+
+ // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)&conjugate[0]);
+ // print_ints("im",&mmtmpPD1);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,dl_ch128i[0]);
+ // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ // print_ints("re(shift)",&mmtmpPD0);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ // print_ints("im(shift)",&mmtmpPD1);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+ // print_ints("c0",&mmtmpPD2);
+ // print_ints("c1",&mmtmpPD3);
+ dl_ch_rho128[0] = _mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+
+ //print_shorts("rx:",dl_ch128_2);
+ //print_shorts("ch:",dl_ch128);
+ //print_shorts("pack:",rho128);
+
+ // multiply by conjugated channel
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[1],dl_ch128i[1]);
+ // mmtmpPD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)conjugate);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,dl_ch128i[1]);
+ // mmtmpPD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+
+
+ dl_ch_rho128[1] =_mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+ //print_shorts("rx:",dl_ch128_2+1);
+ //print_shorts("ch:",dl_ch128+1);
+ //print_shorts("pack:",rho128+1);
+ // multiply by conjugated channel
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128i[2]);
+ // mmtmpPD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)conjugate);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,dl_ch128i[2]);
+ // mmtmpPD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+
+ dl_ch_rho128[2] = _mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+ //print_shorts("rx:",dl_ch128_2+2);
+ //print_shorts("ch:",dl_ch128+2);
+ //print_shorts("pack:",rho128+2);
+
+ dl_ch128+=3;
+ dl_ch128i+=3;
+ dl_ch_rho128+=3;
+
+
+#elif defined(__arm__)
+
+#endif
+ }
+ }
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+
+}
+
+
+void pdcch_detection_mrc_i(LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t **rxdataF_comp,
+ int32_t **rxdataF_comp_i,
+ int32_t **rho,
+ int32_t **rho_i,
+ uint8_t symbol)
+{
+
+ uint8_t aatx;
+
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *rxdataF_comp128_0,*rxdataF_comp128_1,*rxdataF_comp128_i0,*rxdataF_comp128_i1,*rho128_0,*rho128_1,*rho128_i0,*rho128_i1;
+#elif defined(__arm__)
+ int16x8_t *rxdataF_comp128_0,*rxdataF_comp128_1,*rxdataF_comp128_i0,*rxdataF_comp128_i1,*rho128_0,*rho128_1,*rho128_i0,*rho128_i1;
+#endif
+ int32_t i;
+
+ if (frame_parms->nb_antennas_rx>1) {
+ for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++) {
+ //if (frame_parms->mode1_flag && (aatx>0)) break;
+
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_0 = (__m128i *)&rxdataF_comp[(aatx<<1)][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_1 = (__m128i *)&rxdataF_comp[(aatx<<1)+1][symbol*frame_parms->N_RB_DL*12];
+#elif defined(__arm__)
+ rxdataF_comp128_0 = (int16x8_t *)&rxdataF_comp[(aatx<<1)][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_1 = (int16x8_t *)&rxdataF_comp[(aatx<<1)+1][symbol*frame_parms->N_RB_DL*12];
+#endif
+ // MRC on each re of rb on MF output
+ for (i=0; i<frame_parms->N_RB_DL*3; i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+#elif defined(__arm__)
+ rxdataF_comp128_0[i] = vhaddq_s16(rxdataF_comp128_0[i],rxdataF_comp128_1[i]);
+#endif
+ }
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ rho128_0 = (__m128i *) &rho[0][symbol*frame_parms->N_RB_DL*12];
+ rho128_1 = (__m128i *) &rho[1][symbol*frame_parms->N_RB_DL*12];
+#elif defined(__arm__)
+ rho128_0 = (int16x8_t *) &rho[0][symbol*frame_parms->N_RB_DL*12];
+ rho128_1 = (int16x8_t *) &rho[1][symbol*frame_parms->N_RB_DL*12];
+#endif
+ for (i=0; i<frame_parms->N_RB_DL*3; i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rho128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_0[i],1),_mm_srai_epi16(rho128_1[i],1));
+#elif defined(__arm__)
+ rho128_0[i] = vhaddq_s16(rho128_0[i],rho128_1[i]);
+#endif
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ rho128_i0 = (__m128i *) &rho_i[0][symbol*frame_parms->N_RB_DL*12];
+ rho128_i1 = (__m128i *) &rho_i[1][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_i0 = (__m128i *)&rxdataF_comp_i[0][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_i1 = (__m128i *)&rxdataF_comp_i[1][symbol*frame_parms->N_RB_DL*12];
+#elif defined(__arm__)
+ rho128_i0 = (int16x8_t*) &rho_i[0][symbol*frame_parms->N_RB_DL*12];
+ rho128_i1 = (int16x8_t*) &rho_i[1][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_i0 = (int16x8_t *)&rxdataF_comp_i[0][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_i1 = (int16x8_t *)&rxdataF_comp_i[1][symbol*frame_parms->N_RB_DL*12];
+
+#endif
+ // MRC on each re of rb on MF and rho
+ for (i=0; i<frame_parms->N_RB_DL*3; i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_i0[i],1),_mm_srai_epi16(rxdataF_comp128_i1[i],1));
+ rho128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_i0[i],1),_mm_srai_epi16(rho128_i1[i],1));
+#elif defined(__arm__)
+ rxdataF_comp128_i0[i] = vhaddq_s16(rxdataF_comp128_i0[i],rxdataF_comp128_i1[i]);
+ rho128_i0[i] = vhaddq_s16(rho128_i0[i],rho128_i1[i]);
+
+#endif
+ }
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+
+void pdcch_extract_rbs_single(int32_t **rxdataF,
+ int32_t **dl_ch_estimates,
+ int32_t **rxdataF_ext,
+ int32_t **dl_ch_estimates_ext,
+ uint8_t symbol,
+ uint32_t high_speed_flag,
+ LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+
+ uint16_t rb,nb_rb=0;
+ uint8_t i,j,aarx;
+ int32_t *dl_ch0,*dl_ch0_ext,*rxF,*rxF_ext;
+
+
+ int nushiftmod3 = frame_parms->nushift%3;
+ uint8_t symbol_mod;
+
+ symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY, "extract_rbs_single: symbol_mod %d\n",symbol_mod);
+#endif
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+ if (high_speed_flag == 1)
+ dl_ch0 = &dl_ch_estimates[aarx][5+(symbol*(frame_parms->ofdm_symbol_size))];
+ else
+ dl_ch0 = &dl_ch_estimates[aarx][5];
+
+ dl_ch0_ext = &dl_ch_estimates_ext[aarx][symbol*(frame_parms->N_RB_DL*12)];
+
+ rxF_ext = &rxdataF_ext[aarx][symbol*(frame_parms->N_RB_DL*12)];
+
+ rxF = &rxdataF[aarx][(frame_parms->first_carrier_offset + (symbol*(frame_parms->ofdm_symbol_size)))];
+
+ if ((frame_parms->N_RB_DL&1) == 0) { // even number of RBs
+ for (rb=0; rb<frame_parms->N_RB_DL; rb++) {
+
+ // For second half of RBs skip DC carrier
+ if (rb==(frame_parms->N_RB_DL>>1)) {
+ rxF = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))];
+
+ //dl_ch0++;
+ }
+
+ if (symbol_mod>0) {
+ memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int32_t));
+
+ for (i=0; i<12; i++) {
+
+ rxF_ext[i]=rxF[i];
+
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ rxF_ext+=12;
+
+ dl_ch0+=12;
+ rxF+=12;
+ } else {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=(nushiftmod3+3)) &&
+ (i!=(nushiftmod3+6)) &&
+ (i!=(nushiftmod3+9))) {
+ rxF_ext[j]=rxF[i];
+ // printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+ dl_ch0_ext[j++]=dl_ch0[i];
+ // printf("ch %d => (%d,%d)\n",i,*(short *)&dl_ch0[i],*(1+(short*)&dl_ch0[i]));
+ }
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ rxF_ext+=8;
+
+ dl_ch0+=12;
+ rxF+=12;
+ }
+ }
+ } else { // Odd number of RBs
+ for (rb=0; rb<frame_parms->N_RB_DL>>1; rb++) {
+
+ if (symbol_mod>0) {
+ memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int32_t));
+
+ for (i=0; i<12; i++)
+ rxF_ext[i]=rxF[i];
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ rxF_ext+=12;
+
+ dl_ch0+=12;
+ rxF+=12;
+ } else {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=(nushiftmod3+3)) &&
+ (i!=(nushiftmod3+6)) &&
+ (i!=(nushiftmod3+9))) {
+ rxF_ext[j]=rxF[i];
+ // printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+ dl_ch0_ext[j++]=dl_ch0[i];
+ // printf("ch %d => (%d,%d)\n",i,*(short *)&dl_ch0[i],*(1+(short*)&dl_ch0[i]));
+ }
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ rxF_ext+=8;
+
+ dl_ch0+=12;
+ rxF+=12;
+ }
+ }
+
+ // Do middle RB (around DC)
+ // printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);
+
+ if (symbol_mod==0) {
+ j=0;
+
+ for (i=0; i<6; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=(nushiftmod3+3))) {
+ dl_ch0_ext[j]=dl_ch0[i];
+ rxF_ext[j++]=rxF[i];
+ // printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
+ }
+ }
+
+ rxF = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+
+ for (; i<12; i++) {
+ if ((i!=(nushiftmod3+6)) &&
+ (i!=(nushiftmod3+9))) {
+ dl_ch0_ext[j]=dl_ch0[i];
+ rxF_ext[j++]=rxF[(1+i-6)];
+ // printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
+ }
+ }
+
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ rxF_ext+=8;
+ dl_ch0+=12;
+ rxF+=7;
+ rb++;
+ } else {
+ for (i=0; i<6; i++) {
+ dl_ch0_ext[i]=dl_ch0[i];
+ rxF_ext[i]=rxF[i];
+ }
+
+ rxF = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+
+ for (; i<12; i++) {
+ dl_ch0_ext[i]=dl_ch0[i];
+ rxF_ext[i]=rxF[(1+i-6)];
+ }
+
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ rxF_ext+=12;
+ dl_ch0+=12;
+ rxF+=7;
+ rb++;
+ }
+
+ for (; rb<frame_parms->N_RB_DL; rb++) {
+ if (symbol_mod > 0) {
+ memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int32_t));
+
+ for (i=0; i<12; i++)
+ rxF_ext[i]=rxF[i];
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ rxF_ext+=12;
+
+ dl_ch0+=12;
+ rxF+=12;
+ } else {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=(nushiftmod3)) &&
+ (i!=(nushiftmod3+3)) &&
+ (i!=(nushiftmod3+6)) &&
+ (i!=(nushiftmod3+9))) {
+ rxF_ext[j]=rxF[i];
+ // printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+ dl_ch0_ext[j++]=dl_ch0[i];
+ }
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ rxF_ext+=8;
+
+ dl_ch0+=12;
+ rxF+=12;
+ }
+ }
+ }
+ }
+}
+
+void pdcch_extract_rbs_dual(int32_t **rxdataF,
+ int32_t **dl_ch_estimates,
+ int32_t **rxdataF_ext,
+ int32_t **dl_ch_estimates_ext,
+ uint8_t symbol,
+ uint32_t high_speed_flag,
+ LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+
+ uint16_t rb,nb_rb=0;
+ uint8_t i,aarx,j;
+ int32_t *dl_ch0,*dl_ch0_ext,*dl_ch1,*dl_ch1_ext,*rxF,*rxF_ext;
+ uint8_t symbol_mod;
+ int nushiftmod3 = frame_parms->nushift%3;
+
+ symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY, "extract_rbs_dual: symbol_mod %d\n",symbol_mod);
+#endif
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+ if (high_speed_flag==1) {
+ dl_ch0 = &dl_ch_estimates[aarx][5+(symbol*(frame_parms->ofdm_symbol_size))];
+ dl_ch1 = &dl_ch_estimates[2+aarx][5+(symbol*(frame_parms->ofdm_symbol_size))];
+ } else {
+ dl_ch0 = &dl_ch_estimates[aarx][5];
+ dl_ch1 = &dl_ch_estimates[2+aarx][5];
+ }
+
+ dl_ch0_ext = &dl_ch_estimates_ext[aarx][symbol*(frame_parms->N_RB_DL*12)];
+ dl_ch1_ext = &dl_ch_estimates_ext[2+aarx][symbol*(frame_parms->N_RB_DL*12)];
+
+ // printf("pdcch extract_rbs: rxF_ext pos %d\n",symbol*(frame_parms->N_RB_DL*12));
+ rxF_ext = &rxdataF_ext[aarx][symbol*(frame_parms->N_RB_DL*12)];
+
+ rxF = &rxdataF[aarx][(frame_parms->first_carrier_offset + (symbol*(frame_parms->ofdm_symbol_size)))];
+
+ if ((frame_parms->N_RB_DL&1) == 0) // even number of RBs
+ for (rb=0; rb<frame_parms->N_RB_DL; rb++) {
+
+ // For second half of RBs skip DC carrier
+ if (rb==(frame_parms->N_RB_DL>>1)) {
+ rxF = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))];
+ // dl_ch0++;
+ //dl_ch1++;
+ }
+
+ if (symbol_mod>0) {
+ memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int32_t));
+ memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int32_t));
+
+ /*
+ printf("rb %d\n",rb);
+ for (i=0;i<12;i++)
+ printf("(%d %d)",((int16_t *)dl_ch0)[i<<1],((int16_t*)dl_ch0)[1+(i<<1)]);
+ printf("\n");
+ */
+ for (i=0; i<12; i++) {
+ rxF_ext[i]=rxF[i];
+ // printf("%d : (%d,%d)\n",(rxF+(2*i)-&rxdataF[aarx][( (symbol*(frame_parms->ofdm_symbol_size)))*2])/2,
+ // ((int16_t*)&rxF[i<<1])[0],((int16_t*)&rxF[i<<1])[0]);
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ dl_ch1_ext+=12;
+ rxF_ext+=12;
+ } else {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=nushiftmod3+3) &&
+ (i!=nushiftmod3+6) &&
+ (i!=nushiftmod3+9)) {
+ rxF_ext[j]=rxF[i];
+ // printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+ dl_ch0_ext[j] =dl_ch0[i];
+ dl_ch1_ext[j++]=dl_ch1[i];
+ }
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ dl_ch1_ext+=8;
+ rxF_ext+=8;
+ }
+
+ dl_ch0+=12;
+ dl_ch1+=12;
+ rxF+=12;
+ }
+
+ else { // Odd number of RBs
+ for (rb=0; rb<frame_parms->N_RB_DL>>1; rb++) {
+
+ // printf("rb %d: %d\n",rb,rxF-&rxdataF[aarx][(symbol*(frame_parms->ofdm_symbol_size))*2]);
+
+ if (symbol_mod>0) {
+ memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int32_t));
+ memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int32_t));
+
+ for (i=0; i<12; i++)
+ rxF_ext[i]=rxF[i];
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ dl_ch1_ext+=12;
+ rxF_ext+=12;
+
+ dl_ch0+=12;
+ dl_ch1+=12;
+ rxF+=12;
+
+ } else {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=nushiftmod3+3) &&
+ (i!=nushiftmod3+6) &&
+ (i!=nushiftmod3+9)) {
+ rxF_ext[j]=rxF[i];
+ // printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+ dl_ch0_ext[j]=dl_ch0[i];
+ dl_ch1_ext[j++]=dl_ch1[i];
+ // printf("ch %d => (%d,%d)\n",i,*(short *)&dl_ch0[i],*(1+(short*)&dl_ch0[i]));
+ }
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ dl_ch1_ext+=8;
+ rxF_ext+=8;
+
+
+ dl_ch0+=12;
+ dl_ch1+=12;
+ rxF+=12;
+ }
+ }
+
+ // Do middle RB (around DC)
+
+ if (symbol_mod > 0) {
+ for (i=0; i<6; i++) {
+ dl_ch0_ext[i]=dl_ch0[i];
+ dl_ch1_ext[i]=dl_ch1[i];
+ rxF_ext[i]=rxF[i];
+ }
+
+ rxF = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+
+ for (; i<12; i++) {
+ dl_ch0_ext[i]=dl_ch0[i];
+ dl_ch1_ext[i]=dl_ch1[i];
+ rxF_ext[i]=rxF[(1+i)];
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ dl_ch1_ext+=12;
+ rxF_ext+=12;
+
+ dl_ch0+=12;
+ dl_ch1+=12;
+ rxF+=7;
+ rb++;
+ } else {
+ j=0;
+
+ for (i=0; i<6; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=nushiftmod3+3)) {
+ dl_ch0_ext[j]=dl_ch0[i];
+ dl_ch1_ext[j]=dl_ch1[i];
+ rxF_ext[j++]=rxF[i];
+ // printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
+ }
+ }
+
+ rxF = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+
+ for (; i<12; i++) {
+ if ((i!=nushiftmod3+6) &&
+ (i!=nushiftmod3+9)) {
+ dl_ch0_ext[j]=dl_ch0[i];
+ dl_ch1_ext[j]=dl_ch1[i];
+ rxF_ext[j++]=rxF[(1+i-6)];
+ // printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
+ }
+ }
+
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ dl_ch1_ext+=8;
+ rxF_ext+=8;
+ dl_ch0+=12;
+ dl_ch1+=12;
+ rxF+=7;
+ rb++;
+ }
+
+ for (; rb<frame_parms->N_RB_DL; rb++) {
+
+ if (symbol_mod>0) {
+ // printf("rb %d: %d\n",rb,rxF-&rxdataF[aarx][(symbol*(frame_parms->ofdm_symbol_size))*2]);
+ memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int32_t));
+ memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int32_t));
+
+ for (i=0; i<12; i++)
+ rxF_ext[i]=rxF[i];
+
+ nb_rb++;
+ dl_ch0_ext+=12;
+ dl_ch1_ext+=12;
+ rxF_ext+=12;
+
+ dl_ch0+=12;
+ dl_ch1+=12;
+ rxF+=12;
+ } else {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=nushiftmod3+3) &&
+ (i!=nushiftmod3+6) &&
+ (i!=nushiftmod3+9)) {
+ rxF_ext[j]=rxF[i];
+ // printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+ dl_ch0_ext[j]=dl_ch0[i];
+ dl_ch1_ext[j++]=dl_ch1[i];
+ }
+ }
+
+ nb_rb++;
+ dl_ch0_ext+=8;
+ dl_ch1_ext+=8;
+ rxF_ext+=8;
+
+ dl_ch0+=12;
+ dl_ch1+=12;
+ rxF+=12;
+ }
+ }
+ }
+ }
+}
+
+
+void pdcch_channel_compensation(int32_t **rxdataF_ext,
+ int32_t **dl_ch_estimates_ext,
+ int32_t **rxdataF_comp,
+ int32_t **rho,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t symbol,
+ uint8_t output_shift)
+{
+
+ uint16_t rb;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *dl_ch128,*rxdataF128,*rxdataF_comp128;
+ __m128i *dl_ch128_2, *rho128;
+#elif defined(__arm__)
+
+#endif
+ uint8_t aatx,aarx,pilots=0;
+
+
+
+
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY, "PDCCH comp: symbol %d\n",symbol);
+#endif
+
+ if (symbol==0)
+ pilots=1;
+
+ for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++) {
+ //if (frame_parms->mode1_flag && aatx>0) break; //if mode1_flag is set then there is only one stream to extract, independent of nb_antenna_ports_eNB
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+ dl_ch128 = (__m128i *)&dl_ch_estimates_ext[(aatx<<1)+aarx][symbol*frame_parms->N_RB_DL*12];
+ rxdataF128 = (__m128i *)&rxdataF_ext[aarx][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128 = (__m128i *)&rxdataF_comp[(aatx<<1)+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__)
+ // multiply by conjugated channel
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
+ // print_ints("re",&mmtmpPD0);
+
+ // mmtmpPD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)&conjugate[0]);
+ // print_ints("im",&mmtmpPD1);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,rxdataF128[0]);
+ // mmtmpPD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ // print_ints("re(shift)",&mmtmpPD0);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ // print_ints("im(shift)",&mmtmpPD1);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+ // print_ints("c0",&mmtmpPD2);
+ // print_ints("c1",&mmtmpPD3);
+ rxdataF_comp128[0] = _mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+ // print_shorts("rx:",rxdataF128);
+ // print_shorts("ch:",dl_ch128);
+ // print_shorts("pack:",rxdataF_comp128);
+
+ // multiply by conjugated channel
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
+ // mmtmpPD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)conjugate);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,rxdataF128[1]);
+ // mmtmpPD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+
+ rxdataF_comp128[1] = _mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+
+ // print_shorts("rx:",rxdataF128+1);
+ // print_shorts("ch:",dl_ch128+1);
+ // print_shorts("pack:",rxdataF_comp128+1);
+ // multiply by conjugated channel
+ if (pilots == 0) {
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[2],rxdataF128[2]);
+ // mmtmpPD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)conjugate);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,rxdataF128[2]);
+ // mmtmpPD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+
+ rxdataF_comp128[2] = _mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+ }
+
+ // print_shorts("rx:",rxdataF128+2);
+ // print_shorts("ch:",dl_ch128+2);
+ // print_shorts("pack:",rxdataF_comp128+2);
+
+ if (pilots==0) {
+ dl_ch128+=3;
+ rxdataF128+=3;
+ rxdataF_comp128+=3;
+ } else {
+ dl_ch128+=2;
+ rxdataF128+=2;
+ rxdataF_comp128+=2;
+ }
+#elif defined(__arm__)
+
+#endif
+ }
+ }
+ }
+
+
+ if (rho) {
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+ rho128 = (__m128i *)&rho[aarx][symbol*frame_parms->N_RB_DL*12];
+ dl_ch128 = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
+ 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__)
+
+ // multiply by conjugated channel
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128_2[0]);
+ // print_ints("re",&mmtmpD0);
+
+ // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)&conjugate[0]);
+ // print_ints("im",&mmtmpPD1);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,dl_ch128_2[0]);
+ // mmtmpPD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ // print_ints("re(shift)",&mmtmpD0);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ // print_ints("im(shift)",&mmtmpD1);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+ // print_ints("c0",&mmtmpPD2);
+ // print_ints("c1",&mmtmpPD3);
+ rho128[0] = _mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+
+ //print_shorts("rx:",dl_ch128_2);
+ //print_shorts("ch:",dl_ch128);
+ //print_shorts("pack:",rho128);
+
+ // multiply by conjugated channel
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[1],dl_ch128_2[1]);
+ // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)conjugate);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,dl_ch128_2[1]);
+ // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+
+
+ rho128[1] =_mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+ //print_shorts("rx:",dl_ch128_2+1);
+ //print_shorts("ch:",dl_ch128+1);
+ //print_shorts("pack:",rho128+1);
+ // multiply by conjugated channel
+ mmtmpPD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128_2[2]);
+ // mmtmpPD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpPD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_shufflehi_epi16(mmtmpPD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpPD1 = _mm_sign_epi16(mmtmpPD1,*(__m128i*)conjugate);
+ mmtmpPD1 = _mm_madd_epi16(mmtmpPD1,dl_ch128_2[2]);
+ // mmtmpPD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpPD0 = _mm_srai_epi32(mmtmpPD0,output_shift);
+ mmtmpPD1 = _mm_srai_epi32(mmtmpPD1,output_shift);
+ mmtmpPD2 = _mm_unpacklo_epi32(mmtmpPD0,mmtmpPD1);
+ mmtmpPD3 = _mm_unpackhi_epi32(mmtmpPD0,mmtmpPD1);
+
+ rho128[2] = _mm_packs_epi32(mmtmpPD2,mmtmpPD3);
+ //print_shorts("rx:",dl_ch128_2+2);
+ //print_shorts("ch:",dl_ch128+2);
+ //print_shorts("pack:",rho128+2);
+
+ dl_ch128+=3;
+ dl_ch128_2+=3;
+ rho128+=3;
+
+#elif defined(__arm_)
+
+
+#endif
+ }
+ }
+
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+void pdcch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t **rxdataF_comp,
+ uint8_t symbol)
+{
+
+ uint8_t aatx;
+
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *rxdataF_comp128_0,*rxdataF_comp128_1;
+#elif defined(__arm__)
+ int16x8_t *rxdataF_comp128_0,*rxdataF_comp128_1;
+#endif
+ int32_t i;
+
+ if (frame_parms->nb_antennas_rx>1) {
+ for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_0 = (__m128i *)&rxdataF_comp[(aatx<<1)][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_1 = (__m128i *)&rxdataF_comp[(aatx<<1)+1][symbol*frame_parms->N_RB_DL*12];
+#elif defined(__arm__)
+ rxdataF_comp128_0 = (int16x8_t *)&rxdataF_comp[(aatx<<1)][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_1 = (int16x8_t *)&rxdataF_comp[(aatx<<1)+1][symbol*frame_parms->N_RB_DL*12];
+#endif
+ // MRC on each re of rb
+ for (i=0; i<frame_parms->N_RB_DL*3; i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+#elif defined(__arm__)
+ rxdataF_comp128_0[i] = vhaddq_s16(rxdataF_comp128_0[i],rxdataF_comp128_1[i]);
+#endif
+ }
+ }
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+
+}
+
+void pdcch_siso(LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t **rxdataF_comp,
+ uint8_t l)
+{
+
+
+ uint8_t rb,re,jj,ii;
+
+ jj=0;
+ ii=0;
+
+ for (rb=0; rb<frame_parms->N_RB_DL; rb++) {
+
+ for (re=0; re<12; re++) {
+
+ rxdataF_comp[0][jj++] = rxdataF_comp[0][ii];
+ ii++;
+ }
+ }
+}
+
+
+void pdcch_alamouti(LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t **rxdataF_comp,
+ uint8_t symbol)
+{
+
+
+ int16_t *rxF0,*rxF1;
+ uint8_t rb,re;
+ int32_t jj=(symbol*frame_parms->N_RB_DL*12);
+
+ rxF0 = (int16_t*)&rxdataF_comp[0][jj]; //tx antenna 0 h0*y
+ rxF1 = (int16_t*)&rxdataF_comp[2][jj]; //tx antenna 1 h1*y
+
+ for (rb=0; rb<frame_parms->N_RB_DL; rb++) {
+
+ for (re=0; re<12; re+=2) {
+
+ // Alamouti RX combining
+
+ rxF0[0] = rxF0[0] + rxF1[2];
+ rxF0[1] = rxF0[1] - rxF1[3];
+
+ rxF0[2] = rxF0[2] - rxF1[0];
+ rxF0[3] = rxF0[3] + rxF1[1];
+
+ rxF0+=4;
+ rxF1+=4;
+ }
+ }
+
+
+}
+
+int32_t avgP[4];
+
+int32_t rx_pdcch(PHY_VARS_UE *ue,
+ uint32_t frame,
+ uint8_t subframe,
+ uint8_t eNB_id,
+ MIMO_mode_t mimo_mode,
+ uint32_t high_speed_flag,
+ uint8_t is_secondary_ue)
+{
+
+ LTE_UE_COMMON *common_vars = &ue->common_vars;
+ LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+ LTE_UE_PDCCH **pdcch_vars = ue->pdcch_vars[ue->current_thread_id[subframe]];
+
+ uint8_t log2_maxh,aatx,aarx;
+#ifdef MU_RECEIVER
+ uint8_t eNB_id_i=eNB_id+1;//add 1 to eNB_id to separate from wanted signal, chosen as the B/F'd pilots from the SeNB are shifted by 1
+#endif
+ int32_t avgs;
+ uint8_t n_pdcch_symbols;
+ uint8_t mi = get_mi(frame_parms,subframe);
+
+ //printf("In rx_pdcch, subframe %d, eNB_id %d, pdcch_vars %d \n",subframe,eNB_id,pdcch_vars);
+ // procress ofdm symbol 0
+ if (is_secondary_ue == 1) {
+ pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id+1], //add 1 to eNB_id to compensate for the shifted B/F'd pilots from the SeNB
+ pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ 0,
+ high_speed_flag,
+ frame_parms);
+#ifdef MU_RECEIVER
+ pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id_i - 1],//subtract 1 to eNB_id_i to compensate for the non-shifted pilots from the PeNB
+ pdcch_vars[eNB_id_i]->rxdataF_ext,//shift by two to simulate transmission from a second antenna
+ pdcch_vars[eNB_id_i]->dl_ch_estimates_ext,//shift by two to simulate transmission from a second antenna
+ 0,
+ high_speed_flag,
+ frame_parms);
+#endif //MU_RECEIVER
+ } else if (frame_parms->nb_antenna_ports_eNB>1) {
+ pdcch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
+ pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ 0,
+ high_speed_flag,
+ frame_parms);
+ } else {
+ pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
+ pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ 0,
+ high_speed_flag,
+ frame_parms);
+ }
+
+
+ // compute channel level based on ofdm symbol 0
+ pdcch_channel_level(pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ frame_parms,
+ avgP,
+ frame_parms->N_RB_DL);
+
+ avgs = 0;
+
+ for (aatx=0; aatx<frame_parms->nb_antenna_ports_eNB; aatx++)
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++)
+ avgs = cmax(avgs,avgP[(aarx<<1)+aatx]);
+
+ log2_maxh = (log2_approx(avgs)/2) + 5; //+frame_parms->nb_antennas_rx;
+#ifdef UE_DEBUG_TRACE
+ LOG_D(PHY,"subframe %d: pdcch log2_maxh = %d (%d,%d)\n",subframe,log2_maxh,avgP[0],avgs);
+#endif
+
+ T(T_UE_PHY_PDCCH_ENERGY, T_INT(eNB_id), T_INT(frame%1024), T_INT(subframe),
+ T_INT(avgP[0]), T_INT(avgP[1]), T_INT(avgP[2]), T_INT(avgP[3]));
+
+ // compute LLRs for ofdm symbol 0 only
+ pdcch_channel_compensation(pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ (aatx>1) ? pdcch_vars[eNB_id]->rho : NULL,
+ frame_parms,
+ 0,
+ log2_maxh); // log2_maxh+I0_shift
+
+
+#ifdef DEBUG_PHY
+
+ if (subframe==5)
+ write_output("rxF_comp_d.m","rxF_c_d",&pdcch_vars[eNB_id]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+
+#endif
+
+#ifdef MU_RECEIVER
+
+ if (is_secondary_ue) {
+ //get MF output for interfering stream
+ pdcch_channel_compensation(pdcch_vars[eNB_id_i]->rxdataF_ext,
+ pdcch_vars[eNB_id_i]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id_i]->rxdataF_comp,
+ (aatx>1) ? pdcch_vars[eNB_id_i]->rho : NULL,
+ frame_parms,
+ 0,
+ log2_maxh); // log2_maxh+I0_shift
+#ifdef DEBUG_PHY
+ write_output("rxF_comp_i.m","rxF_c_i",&pdcch_vars[eNB_id_i]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+#endif
+ pdcch_dual_stream_correlation(frame_parms,
+ 0,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id_i]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id]->dl_ch_rho_ext,
+ log2_maxh);
+ }
+
+#endif //MU_RECEIVER
+
+
+ if (frame_parms->nb_antennas_rx > 1) {
+#ifdef MU_RECEIVER
+
+ if (is_secondary_ue) {
+ pdcch_detection_mrc_i(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ pdcch_vars[eNB_id_i]->rxdataF_comp,
+ pdcch_vars[eNB_id]->rho,
+ pdcch_vars[eNB_id]->dl_ch_rho_ext,
+ 0);
+#ifdef DEBUG_PHY
+ write_output("rxF_comp_d.m","rxF_c_d",&pdcch_vars[eNB_id]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+ write_output("rxF_comp_i.m","rxF_c_i",&pdcch_vars[eNB_id_i]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+#endif
+ } else
+#endif //MU_RECEIVER
+ pdcch_detection_mrc(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ 0);
+ }
+
+ if (mimo_mode == SISO)
+ pdcch_siso(frame_parms,pdcch_vars[eNB_id]->rxdataF_comp,0);
+ else
+ pdcch_alamouti(frame_parms,pdcch_vars[eNB_id]->rxdataF_comp,0);
+
+
+#ifdef MU_RECEIVER
+
+ if (is_secondary_ue) {
+ pdcch_qpsk_qpsk_llr(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ pdcch_vars[eNB_id_i]->rxdataF_comp,
+ pdcch_vars[eNB_id]->dl_ch_rho_ext,
+ pdcch_vars[eNB_id]->llr16, //subsequent function require 16 bit llr, but output must be 8 bit (actually clipped to 4, because of the Viterbi decoder)
+ pdcch_vars[eNB_id]->llr,
+ 0);
+ /*
+ #ifdef DEBUG_PHY
+ if (subframe==5) {
+ write_output("llr8_seq.m","llr8",&pdcch_vars[eNB_id]->llr[s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,4);
+ write_output("llr16_seq.m","llr16",&pdcch_vars[eNB_id]->llr16[s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,4);
+ }
+ #endif*/
+ } else {
+#endif //MU_RECEIVER
+ pdcch_llr(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ (char *)pdcch_vars[eNB_id]->llr,
+ 0);
+ /*#ifdef DEBUG_PHY
+ write_output("llr8_seq.m","llr8",&pdcch_vars[eNB_id]->llr[s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,4);
+ #endif*/
+
+#ifdef MU_RECEIVER
+ }
+
+#endif //MU_RECEIVER
+
+
+ // decode pcfich here and find out pdcch ofdm symbol number
+ n_pdcch_symbols = rx_pcfich(frame_parms,
+ subframe,
+ pdcch_vars[eNB_id],
+ mimo_mode);
+
+
+ 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
+
+ LOG_I(PHY,"demapping: subframe %d, mi %d, tdd_config %d\n",subframe,get_mi(frame_parms,subframe),frame_parms->tdd_config);
+#endif
+
+ // process pdcch ofdm symbol 1 and 2 if necessary
+ for (int s=1; s<n_pdcch_symbols; s++){
+ if (is_secondary_ue == 1) {
+ pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id+1], //add 1 to eNB_id to compensate for the shifted B/F'd pilots from the SeNB
+ pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ s,
+ high_speed_flag,
+ frame_parms);
+#ifdef MU_RECEIVER
+pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id_i - 1],//subtract 1 to eNB_id_i to compensate for the non-shifted pilots from the PeNB
+ pdcch_vars[eNB_id_i]->rxdataF_ext,//shift by two to simulate transmission from a second antenna
+ pdcch_vars[eNB_id_i]->dl_ch_estimates_ext,//shift by two to simulate transmission from a second antenna
+ s,
+ high_speed_flag,
+ frame_parms);
+#endif //MU_RECEIVER
+ } else if (frame_parms->nb_antenna_ports_eNB>1) {
+ pdcch_extract_rbs_dual(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
+ pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ s,
+ high_speed_flag,
+ frame_parms);
+ } else {
+ pdcch_extract_rbs_single(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
+ pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ s,
+ high_speed_flag,
+ frame_parms);
+ }
+
+
+ pdcch_channel_compensation(pdcch_vars[eNB_id]->rxdataF_ext,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ (aatx>1) ? pdcch_vars[eNB_id]->rho : NULL,
+ frame_parms,
+ s,
+ log2_maxh); // log2_maxh+I0_shift
+
+
+#ifdef DEBUG_PHY
+
+if (subframe==5)
+ write_output("rxF_comp_d.m","rxF_c_d",&pdcch_vars[eNB_id]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+
+#endif
+
+#ifdef MU_RECEIVER
+
+if (is_secondary_ue) {
+ //get MF output for interfering stream
+ pdcch_channel_compensation(pdcch_vars[eNB_id_i]->rxdataF_ext,
+ pdcch_vars[eNB_id_i]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id_i]->rxdataF_comp,
+ (aatx>1) ? pdcch_vars[eNB_id_i]->rho : NULL,
+ frame_parms,
+ s,
+ log2_maxh); // log2_maxh+I0_shift
+#ifdef DEBUG_PHY
+write_output("rxF_comp_i.m","rxF_c_i",&pdcch_vars[eNB_id_i]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+#endif
+pdcch_dual_stream_correlation(frame_parms,
+ s,
+ pdcch_vars[eNB_id]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id_i]->dl_ch_estimates_ext,
+ pdcch_vars[eNB_id]->dl_ch_rho_ext,
+ log2_maxh);
+}
+
+#endif //MU_RECEIVER
+
+
+if (frame_parms->nb_antennas_rx > 1) {
+#ifdef MU_RECEIVER
+
+ if (is_secondary_ue) {
+ pdcch_detection_mrc_i(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ pdcch_vars[eNB_id_i]->rxdataF_comp,
+ pdcch_vars[eNB_id]->rho,
+ pdcch_vars[eNB_id]->dl_ch_rho_ext,
+ s);
+#ifdef DEBUG_PHY
+write_output("rxF_comp_d.m","rxF_c_d",&pdcch_vars[eNB_id]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+write_output("rxF_comp_i.m","rxF_c_i",&pdcch_vars[eNB_id_i]->rxdataF_comp[0][s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+#endif
+ } else
+#endif //MU_RECEIVER
+ pdcch_detection_mrc(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ s);
+
+}
+
+if (mimo_mode == SISO)
+ pdcch_siso(frame_parms,pdcch_vars[eNB_id]->rxdataF_comp,s);
+else
+ pdcch_alamouti(frame_parms,pdcch_vars[eNB_id]->rxdataF_comp,s);
+
+
+#ifdef MU_RECEIVER
+
+if (is_secondary_ue) {
+ pdcch_qpsk_qpsk_llr(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ pdcch_vars[eNB_id_i]->rxdataF_comp,
+ pdcch_vars[eNB_id]->dl_ch_rho_ext,
+ pdcch_vars[eNB_id]->llr16, //subsequent function require 16 bit llr, but output must be 8 bit (actually clipped to 4, because of the Viterbi decoder)
+ pdcch_vars[eNB_id]->llr,
+ s);
+ /*
+ #ifdef DEBUG_PHY
+ if (subframe==5) {
+ write_output("llr8_seq.m","llr8",&pdcch_vars[eNB_id]->llr[s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,4);
+ write_output("llr16_seq.m","llr16",&pdcch_vars[eNB_id]->llr16[s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,4);
+ }
+ #endif*/
+} else {
+#endif //MU_RECEIVER
+ pdcch_llr(frame_parms,
+ pdcch_vars[eNB_id]->rxdataF_comp,
+ (char *)pdcch_vars[eNB_id]->llr,
+ s);
+ /*#ifdef DEBUG_PHY
+ write_output("llr8_seq.m","llr8",&pdcch_vars[eNB_id]->llr[s*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,4);
+ #endif*/
+
+#ifdef MU_RECEIVER
+}
+
+#endif //MU_RECEIVER
+
+ }
+
+ pdcch_demapping(pdcch_vars[eNB_id]->llr,
+ pdcch_vars[eNB_id]->wbar,
+ frame_parms,
+ n_pdcch_symbols,
+ get_mi(frame_parms,subframe));
+
+ pdcch_deinterleaving(frame_parms,
+ (uint16_t*)pdcch_vars[eNB_id]->e_rx,
+ pdcch_vars[eNB_id]->wbar,
+ n_pdcch_symbols,
+ mi);
+
+ pdcch_unscrambling(frame_parms,
+ subframe,
+ pdcch_vars[eNB_id]->e_rx,
+ get_nCCE(n_pdcch_symbols,frame_parms,mi)*72);
+
+ pdcch_vars[eNB_id]->num_pdcch_symbols = n_pdcch_symbols;
+
+ return(0);
+}
+
+
+void pdcch_unscrambling(LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t subframe,
+ int8_t* llr,
+ uint32_t length)
+{
+
+ int i;
+ uint8_t reset;
+ uint32_t x1, x2, s=0;
+
+ reset = 1;
+ // x1 is set in first call to lte_gold_generic
+
+ x2 = (subframe<<9) + frame_parms->Nid_cell; //this is c_init in 36.211 Sec 6.8.2
+
+ for (i=0; i<length; i++) {
+ if ((i&0x1f)==0) {
+ s = lte_gold_generic(&x1, &x2, reset);
+ // printf("lte_gold[%d]=%x\n",i,s);
+ 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];
+ // printf("%d\n",llr[i]);
+
+ }
+}
+
+/*
+uint8_t get_num_pdcch_symbols(uint8_t num_dci,
+ DCI_ALLOC_t *dci_alloc,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t subframe)
+{
+
+ uint16_t numCCE = 0;
+ uint8_t i;
+ uint8_t nCCEmin = 0;
+ uint16_t CCE_max_used_index = 0;
+ uint16_t firstCCE_max = dci_alloc[0].firstCCE;
+ uint8_t L = dci_alloc[0].L;
+
+ // check pdcch duration imposed by PHICH duration (Section 6.9 of 36-211)
+ if (frame_parms->Ncp==1) { // extended prefix
+ if ((frame_parms->frame_type == TDD) &&
+ ((frame_parms->tdd_config<3)||(frame_parms->tdd_config==6)) &&
+ ((subframe==1) || (subframe==6))) // subframes 1 and 6 (S-subframes) for 5ms switching periodicity are 2 symbols
+ nCCEmin = 2;
+ else { // 10ms switching periodicity is always 3 symbols, any DL-only subframe is 3 symbols
+ nCCEmin = 3;
+ }
+ }
+
+ // compute numCCE
+ for (i=0; i<num_dci; i++) {
+ // printf("dci %d => %d\n",i,dci_alloc[i].L);
+ numCCE += (1<<(dci_alloc[i].L));
+
+ if(firstCCE_max < dci_alloc[i].firstCCE) {
+ firstCCE_max = dci_alloc[i].firstCCE;
+ L = dci_alloc[i].L;
+ }
+ }
+ CCE_max_used_index = firstCCE_max + (1<<L) - 1;
+
+ //if ((9*numCCE) <= (frame_parms->N_RB_DL*2))
+ if (CCE_max_used_index < get_nCCE(1, frame_parms, get_mi(frame_parms, subframe)))
+ return(cmax(1,nCCEmin));
+ //else if ((9*numCCE) <= (frame_parms->N_RB_DL*((frame_parms->nb_antenna_ports_eNB==4) ? 4 : 5)))
+ else if (CCE_max_used_index < get_nCCE(2, frame_parms, get_mi(frame_parms, subframe)))
+ return(cmax(2,nCCEmin));
+ //else if ((9*numCCE) <= (frame_parms->N_RB_DL*((frame_parms->nb_antenna_ports_eNB==4) ? 7 : 8)))
+ else if (CCE_max_used_index < get_nCCE(3, frame_parms, get_mi(frame_parms, subframe)))
+ return(cmax(3,nCCEmin));
+ else if (frame_parms->N_RB_DL<=10) {
+ if (frame_parms->Ncp == 0) { // normal CP
+ printf("numCCE %d, N_RB_DL = %d : should be returning 4 PDCCH symbols (%d,%d,%d)\n",numCCE,frame_parms->N_RB_DL,
+ get_nCCE(1, frame_parms, get_mi(frame_parms, subframe)),
+ get_nCCE(2, frame_parms, get_mi(frame_parms, subframe)),
+ get_nCCE(3, frame_parms, get_mi(frame_parms, subframe)));
+
+ if ((9*numCCE) <= (frame_parms->N_RB_DL*((frame_parms->nb_antenna_ports_eNB==4) ? 10 : 11)))
+ return(4);
+ } else { // extended CP
+ if ((9*numCCE) <= (frame_parms->N_RB_DL*((frame_parms->nb_antenna_ports_eNB==4) ? 9 : 10)))
+ return(4);
+ }
+ }
+
+
+
+ // LOG_I(PHY," dci.c: get_num_pdcch_symbols subframe %d FATAL, illegal numCCE %d (num_dci %d)\n",subframe,numCCE,num_dci);
+ //for (i=0;i<num_dci;i++) {
+ // printf("dci_alloc[%d].L = %d\n",i,dci_alloc[i].L);
+ //}
+ //exit(-1);
+exit(1);
+ return(0);
+}
+*/
+
+
+
+void dci_decoding(uint8_t DCI_LENGTH,
+ uint8_t aggregation_level,
+ int8_t *e,
+ uint8_t *decoded_output)
+{
+
+ uint8_t dummy_w_rx[3*(MAX_DCI_SIZE_BITS+16+64)];
+ int8_t w_rx[3*(MAX_DCI_SIZE_BITS+16+32)],d_rx[96+(3*(MAX_DCI_SIZE_BITS+16))];
+
+ uint16_t RCC;
+
+ uint16_t D=(DCI_LENGTH+16+64);
+ uint16_t coded_bits;
+#ifdef DEBUG_DCI_DECODING
+ int32_t i;
+#endif
+
+ AssertFatal(aggregation_level<4,
+ "dci_decoding FATAL, illegal aggregation_level %d\n",aggregation_level);
+
+ coded_bits = 72 * (1<<aggregation_level);
+
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY," Doing DCI decoding for %d bits, DCI_LENGTH %d,coded_bits %d, e %p\n",3*(DCI_LENGTH+16),DCI_LENGTH,coded_bits,e);
+#endif
+
+ // now do decoding
+ memset((void*)dummy_w_rx,0,3*D);
+ RCC = generate_dummy_w_cc(DCI_LENGTH+16,
+ dummy_w_rx);
+
+
+
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY," Doing DCI Rate Matching RCC %d, w %p\n",RCC,w);
+#endif
+
+ lte_rate_matching_cc_rx(RCC,coded_bits,w_rx,dummy_w_rx,e);
+
+ sub_block_deinterleaving_cc((uint32_t)(DCI_LENGTH+16),
+ &d_rx[96],
+ &w_rx[0]);
+
+#ifdef DEBUG_DCI_DECODING
+
+ for (i=0; i<16+DCI_LENGTH; i++)
+ LOG_I(PHY," DCI %d : (%d,%d,%d)\n",i,*(d_rx+96+(3*i)),*(d_rx+97+(3*i)),*(d_rx+98+(3*i)));
+
+#endif
+ memset(decoded_output,0,2+((16+DCI_LENGTH)>>3));
+
+#ifdef DEBUG_DCI_DECODING
+ printf("Before Viterbi\n");
+
+ for (i=0; i<16+DCI_LENGTH; i++)
+ printf("%d : (%d,%d,%d)\n",i,*(d_rx+96+(3*i)),*(d_rx+97+(3*i)),*(d_rx+98+(3*i)));
+
+#endif
+ //debug_printf("Doing DCI Viterbi \n");
+ phy_viterbi_lte_sse2(d_rx+96,decoded_output,16+DCI_LENGTH);
+ //debug_printf("Done DCI Viterbi \n");
+}
+
+
+static uint8_t dci_decoded_output[RX_NB_TH][(MAX_DCI_SIZE_BITS+64)/8];
+
+uint16_t get_nCCE(uint8_t num_pdcch_symbols,LTE_DL_FRAME_PARMS *frame_parms,uint8_t mi)
+{
+ return(get_nquad(num_pdcch_symbols,frame_parms,mi)/9);
+}
+
+uint16_t get_nquad(uint8_t num_pdcch_symbols,LTE_DL_FRAME_PARMS *frame_parms,uint8_t mi)
+{
+
+ uint16_t Nreg=0;
+ uint8_t Ngroup_PHICH = (frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)/48;
+
+ if (((frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)%48) > 0)
+ Ngroup_PHICH++;
+
+ if (frame_parms->Ncp == 1) {
+ Ngroup_PHICH<<=1;
+ }
+
+ Ngroup_PHICH*=mi;
+
+ if ((num_pdcch_symbols>0) && (num_pdcch_symbols<4))
+ switch (frame_parms->N_RB_DL) {
+ case 6:
+ Nreg=12+(num_pdcch_symbols-1)*18;
+ break;
+
+ case 25:
+ Nreg=50+(num_pdcch_symbols-1)*75;
+ break;
+
+ case 50:
+ Nreg=100+(num_pdcch_symbols-1)*150;
+ break;
+
+ case 100:
+ Nreg=200+(num_pdcch_symbols-1)*300;
+ break;
+
+ default:
+ return(0);
+ }
+
+ // printf("Nreg %d (%d)\n",Nreg,Nreg - 4 - (3*Ngroup_PHICH));
+ return(Nreg - 4 - (3*Ngroup_PHICH));
+}
+
+uint16_t get_nCCE_mac(uint8_t Mod_id,uint8_t CC_id,int num_pdcch_symbols,int subframe)
+{
+
+ // 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)));
+}
+
+
+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 subframe)
+{
+
+ int search_space_free,m,nb_candidates = 0,l,i;
+ unsigned int Yk;
+ /*
+ printf("CCE Allocation: ");
+ for (i=0;i<nCCE;i++)
+ printf("%d.",CCE_table[i]);
+ printf("\n");
+ */
+ if (common_dci == 1) {
+ // check CCE(0 ... L-1)
+ nb_candidates = (L==4) ? 4 : 2;
+ nb_candidates = min(nb_candidates,nCCE/L);
+
+ // printf("Common DCI nb_candidates %d, L %d\n",nb_candidates,L);
+
+ for (m = nb_candidates-1 ; m >=0 ; m--) {
+
+ search_space_free = 1;
+ for (l=0; l<L; l++) {
+
+ // printf("CCE_table[%d] %d\n",(m*L)+l,CCE_table[(m*L)+l]);
+ if (CCE_table[(m*L) + l] == 1) {
+ search_space_free = 0;
+ break;
+ }
+ }
+
+ if (search_space_free == 1) {
+
+ // printf("returning %d\n",m*L);
+
+ for (l=0; l<L; l++)
+ CCE_table[(m*L)+l]=1;
+ return(m*L);
+ }
+ }
+
+ return(-1);
+
+ } else { // Find first available in ue specific search space
+ // according to procedure in Section 9.1.1 of 36.213 (v. 8.6)
+ // compute Yk
+ Yk = (unsigned int)rnti;
+
+ for (i=0; i<=subframe; i++)
+ Yk = (Yk*39827)%65537;
+
+ Yk = Yk % (nCCE/L);
+
+
+ switch (L) {
+ case 1:
+ case 2:
+ nb_candidates = 6;
+ break;
+
+ case 4:
+ case 8:
+ nb_candidates = 2;
+ break;
+
+ default:
+ DevParam(L, nCCE, rnti);
+ break;
+ }
+
+
+ LOG_D(MAC,"rnti %x, Yk = %d, nCCE %d (nCCE/L %d),nb_cand %d\n",rnti,Yk,nCCE,nCCE/L,nb_candidates);
+
+ for (m = 0 ; m < nb_candidates ; m++) {
+ search_space_free = 1;
+
+ for (l=0; l<L; l++) {
+ int cce = (((Yk+m)%(nCCE/L))*L) + l;
+ if (cce >= nCCE || CCE_table[cce] == 1) {
+ search_space_free = 0;
+ break;
+ }
+ }
+
+ if (search_space_free == 1) {
+ for (l=0; l<L; l++)
+ CCE_table[(((Yk+m)%(nCCE/L))*L)+l]=1;
+
+ return(((Yk+m)%(nCCE/L))*L);
+ }
+ }
+
+ return(-1);
+ }
+}
+
+
+void dci_decoding_procedure0(LTE_UE_PDCCH **pdcch_vars,
+ int do_common,
+ dci_detect_mode_t mode,
+ uint8_t subframe,
+ DCI_ALLOC_t *dci_alloc,
+ int16_t eNB_id,
+ uint8_t current_thread_id,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t mi,
+ uint16_t si_rnti,
+ uint16_t ra_rnti,
+ uint16_t p_rnti,
+ uint8_t L,
+ uint8_t format_si,
+ uint8_t format_p,
+ uint8_t format_ra,
+ uint8_t format_c,
+ uint8_t sizeof_bits,
+ uint8_t sizeof_bytes,
+ uint8_t *dci_cnt,
+ uint8_t *format0_found,
+ uint8_t *format_c_found,
+ uint32_t *CCEmap0,
+ uint32_t *CCEmap1,
+ uint32_t *CCEmap2)
+{
+
+ uint16_t crc,CCEind,nCCE;
+ uint32_t *CCEmap=NULL,CCEmap_mask=0;
+ int L2=(1<<L);
+ unsigned int Yk,nb_candidates = 0,i,m;
+ unsigned int CCEmap_cand;
+
+ nCCE = get_nCCE(pdcch_vars[eNB_id]->num_pdcch_symbols,frame_parms,mi);
+
+ if (nCCE > get_nCCE(3,frame_parms,1)) {
+ LOG_D(PHY,"skip DCI decoding: nCCE=%d > get_nCCE(3,frame_parms,1)=%d\n", nCCE, get_nCCE(3,frame_parms,1));
+ return;
+ }
+
+ if (nCCE<L2) {
+ LOG_D(PHY,"skip DCI decoding: nCCE=%d < L2=%d\n", nCCE, L2);
+ return;
+ }
+
+ if (mode == NO_DCI) {
+ LOG_D(PHY, "skip DCI decoding: expect no DCIs at subframe %d\n", subframe);
+ return;
+ }
+
+ if (do_common == 1) {
+ nb_candidates = (L2==4) ? 4 : 2;
+ Yk=0;
+ } else {
+ // Find first available in ue specific search space
+ // according to procedure in Section 9.1.1 of 36.213 (v. 8.6)
+ // compute Yk
+ Yk = (unsigned int)pdcch_vars[eNB_id]->crnti;
+
+ for (i=0; i<=subframe; i++)
+ Yk = (Yk*39827)%65537;
+
+ Yk = Yk % (nCCE/L2);
+
+ switch (L2) {
+ case 1:
+ case 2:
+ nb_candidates = 6;
+ break;
+
+ case 4:
+ case 8:
+ nb_candidates = 2;
+ break;
+
+ default:
+ DevParam(L2, do_common, eNB_id);
+ break;
+ }
+ }
+
+ /* for (CCEind=0;
+ CCEind<nCCE2;
+ CCEind+=(1<<L)) {*/
+
+ if (nb_candidates*L2 > nCCE)
+ nb_candidates = nCCE/L2;
+
+ for (m=0; m<nb_candidates; m++) {
+
+ CCEind = (((Yk+m)%(nCCE/L2))*L2);
+
+ if (CCEind<32)
+ CCEmap = CCEmap0;
+ else if (CCEind<64)
+ CCEmap = CCEmap1;
+ else if (CCEind<96)
+ CCEmap = CCEmap2;
+ else {
+ AssertFatal(1==0,
+ "Illegal CCEind %d (Yk %d, m %d, nCCE %d, L2 %d\n",CCEind,Yk,m,nCCE,L2);
+ }
+
+ switch (L2) {
+ case 1:
+ CCEmap_mask = (1<<(CCEind&0x1f));
+ break;
+
+ case 2:
+ CCEmap_mask = (3<<(CCEind&0x1f));
+ break;
+
+ case 4:
+ CCEmap_mask = (0xf<<(CCEind&0x1f));
+ break;
+
+ case 8:
+ CCEmap_mask = (0xff<<(CCEind&0x1f));
+ break;
+
+ default:
+ AssertFatal(1==0,
+ "Illegal L2 value %d\n", L2 );
+ }
+
+ CCEmap_cand = (*CCEmap)&CCEmap_mask;
+
+ // CCE is not allocated yet
+
+ if (CCEmap_cand == 0) {
+
+ if (do_common == 1)
+ 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 %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][%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
+ printf("crc =>%x\n",crc);
+#endif
+
+ if (((L>1) && ((crc == si_rnti)||
+ (crc == p_rnti)||
+ (crc == ra_rnti)))||
+ (crc == pdcch_vars[eNB_id]->crnti)) {
+ dci_alloc[*dci_cnt].dci_length = sizeof_bits;
+ dci_alloc[*dci_cnt].rnti = crc;
+ dci_alloc[*dci_cnt].L = L;
+ dci_alloc[*dci_cnt].firstCCE = CCEind;
+
+ //printf("DCI FOUND !!! crc =>%x, sizeof_bits %d, sizeof_bytes %d \n",crc, sizeof_bits, sizeof_bytes);
+ if (sizeof_bytes<=4) {
+ dci_alloc[*dci_cnt].dci_pdu[3] = dci_decoded_output[current_thread_id][0];
+ dci_alloc[*dci_cnt].dci_pdu[2] = dci_decoded_output[current_thread_id][1];
+ dci_alloc[*dci_cnt].dci_pdu[1] = dci_decoded_output[current_thread_id][2];
+ dci_alloc[*dci_cnt].dci_pdu[0] = dci_decoded_output[current_thread_id][3];
+#ifdef DEBUG_DCI_DECODING
+ printf("DCI => %x,%x,%x,%x\n",dci_decoded_output[current_thread_id][0],
+ dci_decoded_output[current_thread_id][1],
+ dci_decoded_output[current_thread_id][2],
+ dci_decoded_output[current_thread_id][3]);
+#endif
+ } else {
+ dci_alloc[*dci_cnt].dci_pdu[7] = dci_decoded_output[current_thread_id][0];
+ dci_alloc[*dci_cnt].dci_pdu[6] = dci_decoded_output[current_thread_id][1];
+ dci_alloc[*dci_cnt].dci_pdu[5] = dci_decoded_output[current_thread_id][2];
+ dci_alloc[*dci_cnt].dci_pdu[4] = dci_decoded_output[current_thread_id][3];
+ dci_alloc[*dci_cnt].dci_pdu[3] = dci_decoded_output[current_thread_id][4];
+ dci_alloc[*dci_cnt].dci_pdu[2] = dci_decoded_output[current_thread_id][5];
+ dci_alloc[*dci_cnt].dci_pdu[1] = dci_decoded_output[current_thread_id][6];
+ dci_alloc[*dci_cnt].dci_pdu[0] = dci_decoded_output[current_thread_id][7];
+#ifdef DEBUG_DCI_DECODING
+ printf("DCI => %x,%x,%x,%x,%x,%x,%x,%x\n",
+ dci_decoded_output[current_thread_id][0],dci_decoded_output[current_thread_id][1],dci_decoded_output[current_thread_id][2],dci_decoded_output[current_thread_id][3],
+ dci_decoded_output[current_thread_id][4],dci_decoded_output[current_thread_id][5],dci_decoded_output[current_thread_id][6],dci_decoded_output[current_thread_id][7]);
+#endif
+ }
+
+ if (crc==si_rnti) {
+ dci_alloc[*dci_cnt].format = format_si;
+ *dci_cnt = *dci_cnt+1;
+ } else if (crc==p_rnti) {
+ dci_alloc[*dci_cnt].format = format_p;
+ *dci_cnt = *dci_cnt+1;
+ } else if (crc==ra_rnti) {
+ dci_alloc[*dci_cnt].format = format_ra;
+ // store first nCCE of group for PUCCH transmission of ACK/NAK
+ pdcch_vars[eNB_id]->nCCE[subframe]=CCEind;
+ *dci_cnt = *dci_cnt+1;
+ } else if (crc==pdcch_vars[eNB_id]->crnti) {
+
+ if ((mode&UL_DCI)&&(format_c == format0)&&((dci_decoded_output[current_thread_id][0]&0x80)==0)) {// check if pdu is format 0 or 1A
+ if (*format0_found == 0) {
+ dci_alloc[*dci_cnt].format = format0;
+ *format0_found = 1;
+ *dci_cnt = *dci_cnt+1;
+ pdcch_vars[eNB_id]->nCCE[subframe]=CCEind;
+ }
+ } else if (format_c == format0) { // this is a format 1A DCI
+ dci_alloc[*dci_cnt].format = format1A;
+ *dci_cnt = *dci_cnt+1;
+ pdcch_vars[eNB_id]->nCCE[subframe]=CCEind;
+ } else {
+ // store first nCCE of group for PUCCH transmission of ACK/NAK
+ if (*format_c_found == 0) {
+ dci_alloc[*dci_cnt].format = format_c;
+ *dci_cnt = *dci_cnt+1;
+ *format_c_found = 1;
+ pdcch_vars[eNB_id]->nCCE[subframe]=CCEind;
+ }
+ }
+ }
+
+ //LOG_I(PHY,"DCI decoding CRNTI [format: %d, nCCE[subframe: %d]: %d ], AggregationLevel %d \n",format_c, subframe, pdcch_vars[eNB_id]->nCCE[subframe],L2);
+ // memcpy(&dci_alloc[*dci_cnt].dci_pdu[0],dci_decoded_output,sizeof_bytes);
+
+
+
+ switch (1<<L) {
+ case 1:
+ *CCEmap|=(1<<(CCEind&0x1f));
+ break;
+
+ case 2:
+ *CCEmap|=(1<<(CCEind&0x1f));
+ break;
+
+ case 4:
+ *CCEmap|=(1<<(CCEind&0x1f));
+ break;
+
+ case 8:
+ *CCEmap|=(1<<(CCEind&0x1f));
+ break;
+ }
+
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY,"[DCI search] Found DCI %d rnti %x Aggregation %d length %d format %s in CCE %d (CCEmap %x) candidate %d / %d \n",
+ *dci_cnt,crc,1<<L,sizeof_bits,dci_format_strings[dci_alloc[*dci_cnt-1].format],CCEind,*CCEmap,m,nb_candidates );
+ dump_dci(frame_parms,&dci_alloc[*dci_cnt-1]);
+
+#endif
+ return;
+ } // rnti match
+ } // CCEmap_cand == 0
+/*
+ if ( agregationLevel != 0xFF &&
+ (format_c == format0 && m==0 && si_rnti != SI_RNTI))
+ {
+ //Only valid for OAI : Save some processing time when looking for DCI format0. From the log we see the DCI only on candidate 0.
+ return;
+ }
+*/
+ } // candidate loop
+}
+
+uint16_t dci_CRNTI_decoding_procedure(PHY_VARS_UE *ue,
+ DCI_ALLOC_t *dci_alloc,
+ uint8_t DCIFormat,
+ uint8_t agregationLevel,
+ int16_t eNB_id,
+ uint8_t subframe)
+{
+
+ uint8_t dci_cnt=0,old_dci_cnt=0;
+ uint32_t CCEmap0=0,CCEmap1=0,CCEmap2=0;
+ LTE_UE_PDCCH **pdcch_vars = ue->pdcch_vars[ue->current_thread_id[subframe]];
+ LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+ uint8_t mi = get_mi(&ue->frame_parms,subframe);
+ uint16_t ra_rnti=99;
+ uint8_t format0_found=0,format_c_found=0;
+ uint8_t tmode = ue->transmission_mode[eNB_id];
+ uint8_t frame_type = frame_parms->frame_type;
+ uint8_t format0_size_bits=0,format0_size_bytes=0;
+ uint8_t format1_size_bits=0,format1_size_bytes=0;
+ dci_detect_mode_t mode = dci_detect_mode_select(&ue->frame_parms,subframe);
+
+ switch (frame_parms->N_RB_DL) {
+ case 6:
+ if (frame_type == TDD) {
+ format0_size_bits = sizeof_DCI0_1_5MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_1_5MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_1_5MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_1_5MHz_TDD_t);
+
+ } else {
+ format0_size_bits = sizeof_DCI0_1_5MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_1_5MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_1_5MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_1_5MHz_FDD_t);
+ }
+
+ break;
+
+ case 25:
+ default:
+ if (frame_type == TDD) {
+ format0_size_bits = sizeof_DCI0_5MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_5MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_5MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_5MHz_TDD_t);
+ } else {
+ format0_size_bits = sizeof_DCI0_5MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_5MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_5MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_5MHz_FDD_t);
+ }
+
+ break;
+
+ case 50:
+ if (frame_type == TDD) {
+ format0_size_bits = sizeof_DCI0_10MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_10MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_10MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_10MHz_TDD_t);
+
+ } else {
+ format0_size_bits = sizeof_DCI0_10MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_10MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_10MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_10MHz_FDD_t);
+ }
+
+ break;
+
+ case 100:
+ if (frame_type == TDD) {
+ format0_size_bits = sizeof_DCI0_20MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_20MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_20MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_20MHz_TDD_t);
+ } else {
+ format0_size_bits = sizeof_DCI0_20MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_20MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_20MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_20MHz_FDD_t);
+ }
+
+ break;
+ }
+
+ if (ue->prach_resources[eNB_id])
+ ra_rnti = ue->prach_resources[eNB_id]->ra_RNTI;
+
+ // Now check UE_SPEC format0/1A ue_spec search spaces at aggregation 8
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ agregationLevel,
+ format1A,
+ format1A,
+ format1A,
+ format0,
+ format0_size_bits,
+ format0_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (DCIFormat == format1)
+ {
+ if ((tmode < 3) || (tmode == 7)) {
+ //printf("Crnti decoding frame param agregation %d DCI %d \n",agregationLevel,DCIFormat);
+
+ // Now check UE_SPEC format 1 search spaces at aggregation 1
+
+ //printf("[DCI search] Format 1/1A aggregation 1\n");
+
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 0,
+ format1A,
+ format1A,
+ format1A,
+ format1,
+ format1_size_bits,
+ format1_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff) ||
+ (format_c_found==1))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ //printf("Crnti 1 decoding frame param agregation %d DCI %d \n",agregationLevel,DCIFormat);
+
+ }
+ else if (DCIFormat == format1A)
+ {
+ AssertFatal(0,"Other Transmission mode not yet coded\n");
+ }
+ }
+ else
+ {
+ LOG_W(PHY,"DCI format %d wrong or not yet implemented \n",DCIFormat);
+ }
+
+ return(dci_cnt);
+
+}
+
+uint16_t dci_decoding_procedure(PHY_VARS_UE *ue,
+ DCI_ALLOC_t *dci_alloc,
+ int do_common,
+ int16_t eNB_id,
+ uint8_t subframe)
+{
+
+ uint8_t dci_cnt=0,old_dci_cnt=0;
+ uint32_t CCEmap0=0,CCEmap1=0,CCEmap2=0;
+ LTE_UE_PDCCH **pdcch_vars = ue->pdcch_vars[ue->current_thread_id[subframe]];
+ LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+ uint8_t mi = get_mi(&ue->frame_parms,subframe);
+ uint16_t ra_rnti=99;
+ uint8_t format0_found=0,format_c_found=0;
+ uint8_t tmode = ue->transmission_mode[eNB_id];
+ uint8_t frame_type = frame_parms->frame_type;
+ uint8_t format1A_size_bits=0,format1A_size_bytes=0;
+ uint8_t format1C_size_bits=0,format1C_size_bytes=0;
+ uint8_t format0_size_bits=0,format0_size_bytes=0;
+ uint8_t format1_size_bits=0,format1_size_bytes=0;
+ uint8_t format2_size_bits=0,format2_size_bytes=0;
+ uint8_t format2A_size_bits=0,format2A_size_bytes=0;
+ dci_detect_mode_t mode = dci_detect_mode_select(&ue->frame_parms,subframe);
+
+ switch (frame_parms->N_RB_DL) {
+ case 6:
+ if (frame_type == TDD) {
+ format1A_size_bits = sizeof_DCI1A_1_5MHz_TDD_1_6_t;
+ format1A_size_bytes = sizeof(DCI1A_1_5MHz_TDD_1_6_t);
+ format1C_size_bits = sizeof_DCI1C_1_5MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_1_5MHz_t);
+ format0_size_bits = sizeof_DCI0_1_5MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_1_5MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_1_5MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_1_5MHz_TDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_1_5MHz_2A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_1_5MHz_2A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_1_5MHz_2A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_1_5MHz_2A_TDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_1_5MHz_4A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_1_5MHz_4A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_1_5MHz_4A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_1_5MHz_4A_TDD_t);
+ }
+ } else {
+ format1A_size_bits = sizeof_DCI1A_1_5MHz_FDD_t;
+ format1A_size_bytes = sizeof(DCI1A_1_5MHz_FDD_t);
+ format1C_size_bits = sizeof_DCI1C_1_5MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_1_5MHz_t);
+ format0_size_bits = sizeof_DCI0_1_5MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_1_5MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_1_5MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_1_5MHz_FDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_1_5MHz_2A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_1_5MHz_2A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_1_5MHz_2A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_1_5MHz_2A_FDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_1_5MHz_4A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_1_5MHz_4A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_1_5MHz_4A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_1_5MHz_4A_FDD_t);
+ }
+ }
+
+ break;
+
+ case 25:
+ default:
+ if (frame_type == TDD) {
+ format1A_size_bits = sizeof_DCI1A_5MHz_TDD_1_6_t;
+ format1A_size_bytes = sizeof(DCI1A_5MHz_TDD_1_6_t);
+ format1C_size_bits = sizeof_DCI1C_5MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_5MHz_t);
+ format0_size_bits = sizeof_DCI0_5MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_5MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_5MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_5MHz_TDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_5MHz_2A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_5MHz_2A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_5MHz_2A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_5MHz_2A_TDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_5MHz_4A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_5MHz_4A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_5MHz_4A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_5MHz_4A_TDD_t);
+ }
+ } else {
+ format1A_size_bits = sizeof_DCI1A_5MHz_FDD_t;
+ format1A_size_bytes = sizeof(DCI1A_5MHz_FDD_t);
+ format1C_size_bits = sizeof_DCI1C_5MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_5MHz_t);
+ format0_size_bits = sizeof_DCI0_5MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_5MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_5MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_5MHz_FDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_5MHz_2A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_5MHz_2A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_5MHz_2A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_5MHz_2A_FDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_5MHz_4A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_5MHz_4A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_5MHz_4A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_5MHz_4A_FDD_t);
+ }
+ }
+
+ break;
+
+ case 50:
+ if (frame_type == TDD) {
+ format1A_size_bits = sizeof_DCI1A_10MHz_TDD_1_6_t;
+ format1A_size_bytes = sizeof(DCI1A_10MHz_TDD_1_6_t);
+ format1C_size_bits = sizeof_DCI1C_10MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_10MHz_t);
+ format0_size_bits = sizeof_DCI0_10MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_10MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_10MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_10MHz_TDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_10MHz_2A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_10MHz_2A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_10MHz_2A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_10MHz_2A_TDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_10MHz_4A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_10MHz_4A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_10MHz_4A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_10MHz_4A_TDD_t);
+ }
+ } else {
+ format1A_size_bits = sizeof_DCI1A_10MHz_FDD_t;
+ format1A_size_bytes = sizeof(DCI1A_10MHz_FDD_t);
+ format1C_size_bits = sizeof_DCI1C_10MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_10MHz_t);
+ format0_size_bits = sizeof_DCI0_10MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_10MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_10MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_10MHz_FDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_10MHz_2A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_10MHz_2A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_10MHz_2A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_10MHz_2A_FDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_10MHz_4A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_10MHz_4A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_10MHz_4A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_10MHz_4A_FDD_t);
+ }
+ }
+
+ break;
+
+ case 100:
+ if (frame_type == TDD) {
+ format1A_size_bits = sizeof_DCI1A_20MHz_TDD_1_6_t;
+ format1A_size_bytes = sizeof(DCI1A_20MHz_TDD_1_6_t);
+ format1C_size_bits = sizeof_DCI1C_20MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_20MHz_t);
+ format0_size_bits = sizeof_DCI0_20MHz_TDD_1_6_t;
+ format0_size_bytes = sizeof(DCI0_20MHz_TDD_1_6_t);
+ format1_size_bits = sizeof_DCI1_20MHz_TDD_t;
+ format1_size_bytes = sizeof(DCI1_20MHz_TDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_20MHz_2A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_20MHz_2A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_20MHz_2A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_20MHz_2A_TDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_20MHz_4A_TDD_t;
+ format2_size_bytes = sizeof(DCI2_20MHz_4A_TDD_t);
+ format2A_size_bits = sizeof_DCI2A_20MHz_4A_TDD_t;
+ format2A_size_bytes = sizeof(DCI2A_20MHz_4A_TDD_t);
+ }
+ } else {
+ format1A_size_bits = sizeof_DCI1A_20MHz_FDD_t;
+ format1A_size_bytes = sizeof(DCI1A_20MHz_FDD_t);
+ format1C_size_bits = sizeof_DCI1C_20MHz_t;
+ format1C_size_bytes = sizeof(DCI1C_20MHz_t);
+ format0_size_bits = sizeof_DCI0_20MHz_FDD_t;
+ format0_size_bytes = sizeof(DCI0_20MHz_FDD_t);
+ format1_size_bits = sizeof_DCI1_20MHz_FDD_t;
+ format1_size_bytes = sizeof(DCI1_20MHz_FDD_t);
+
+ if (frame_parms->nb_antenna_ports_eNB == 2) {
+ format2_size_bits = sizeof_DCI2_20MHz_2A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_20MHz_2A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_20MHz_2A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_20MHz_2A_FDD_t);
+ } else if (frame_parms->nb_antenna_ports_eNB == 4) {
+ format2_size_bits = sizeof_DCI2_20MHz_4A_FDD_t;
+ format2_size_bytes = sizeof(DCI2_20MHz_4A_FDD_t);
+ format2A_size_bits = sizeof_DCI2A_20MHz_4A_FDD_t;
+ format2A_size_bytes = sizeof(DCI2A_20MHz_4A_FDD_t);
+ }
+ }
+
+ break;
+ }
+
+ if (do_common == 1) {
+#ifdef DEBUG_DCI_DECODING
+ printf("[DCI search] subframe %d: doing common search/format0 aggregation 4\n",subframe);
+#endif
+
+ if (ue->prach_resources[eNB_id])
+ ra_rnti = ue->prach_resources[eNB_id]->ra_RNTI;
+
+ // First check common search spaces at aggregation 4 (SI_RNTI, P_RNTI and RA_RNTI format 0/1A),
+ // and UE_SPEC format0 (PUSCH) too while we're at it
+ dci_decoding_procedure0(pdcch_vars,1,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0) ,
+ ra_rnti,
+ P_RNTI,
+ 2,
+ format1A,
+ format1A,
+ format1A,
+ format0,
+ format1A_size_bits,
+ format1A_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff) ||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ // Now check common search spaces at aggregation 4 (SI_RNTI,P_RNTI and RA_RNTI and C-RNTI format 1C),
+ // and UE_SPEC format0 (PUSCH) too while we're at it
+ dci_decoding_procedure0(pdcch_vars,1,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 2,
+ format1C,
+ format1C,
+ format1C,
+ format1C,
+ format1C_size_bits,
+ format1C_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff) ||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ // Now check common search spaces at aggregation 8 (SI_RNTI,P_RNTI and RA_RNTI format 1A),
+ // and UE_SPEC format0 (PUSCH) too while we're at it
+ // printf("[DCI search] doing common search/format0 aggregation 3\n");
+#ifdef DEBUG_DCI_DECODING
+ printf("[DCI search] doing common search/format0 aggregation 8\n");
+#endif
+ dci_decoding_procedure0(pdcch_vars,1,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ P_RNTI,
+ ra_rnti,
+ 3,
+ format1A,
+ format1A,
+ format1A,
+ format0,
+ format1A_size_bits,
+ format1A_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ // Now check common search spaces at aggregation 8 (SI_RNTI and RA_RNTI and C-RNTI format 1C),
+ // and UE_SPEC format0 (PUSCH) too while we're at it
+ dci_decoding_procedure0(pdcch_vars,1,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 3,
+ format1C,
+ format1C,
+ format1C,
+ format1C,
+ format1C_size_bits,
+ format1C_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+ //#endif
+
+ }
+
+ if (ue->UE_mode[eNB_id] <= PRACH)
+ return(dci_cnt);
+
+ if (ue->prach_resources[eNB_id])
+ ra_rnti = ue->prach_resources[eNB_id]->ra_RNTI;
+
+ // Now check UE_SPEC format0/1A ue_spec search spaces at aggregation 8
+ // printf("[DCI search] Format 0/1A aggregation 8\n");
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 0,
+ format1A,
+ format1A,
+ format1A,
+ format0,
+ format0_size_bits,
+ format0_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ //printf("[DCI search] Format 0 aggregation 1 dci_cnt %d\n",dci_cnt);
+
+ if (dci_cnt == 0)
+ {
+ // Now check UE_SPEC format 0 search spaces at aggregation 4
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 1,
+ format1A,
+ format1A,
+ format1A,
+ format0,
+ format0_size_bits,
+ format0_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+
+ //printf("[DCI search] Format 0 aggregation 2 dci_cnt %d\n",dci_cnt);
+ }
+
+ if (dci_cnt == 0)
+ {
+ // Now check UE_SPEC format 0 search spaces at aggregation 2
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 2,
+ format1A,
+ format1A,
+ format1A,
+ format0,
+ format0_size_bits,
+ format0_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ //printf("[DCI search] Format 0 aggregation 4 dci_cnt %d\n",dci_cnt);
+ }
+
+ if (dci_cnt == 0)
+ {
+ // Now check UE_SPEC format 0 search spaces at aggregation 1
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 3,
+ format1A,
+ format1A,
+ format1A,
+ format0,
+ format0_size_bits,
+ format0_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ //printf("[DCI search] Format 0 aggregation 8 dci_cnt %d\n",dci_cnt);
+
+ }
+ // These are for CRNTI based on transmission mode
+ if ((tmode < 3) || (tmode == 7)) {
+ // Now check UE_SPEC format 1 search spaces at aggregation 1
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 0,
+ format1A,
+ format1A,
+ format1A,
+ format1,
+ format1_size_bits,
+ format1_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+ //printf("[DCI search] Format 1 aggregation 1 dci_cnt %d\n",dci_cnt);
+
+ if ((CCEmap0==0xffff) ||
+ (format_c_found==1))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ // Now check UE_SPEC format 1 search spaces at aggregation 2
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 1,
+ format1A,
+ format1A,
+ format1A,
+ format1,
+ format1_size_bits,
+ format1_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+ //printf("[DCI search] Format 1 aggregation 2 dci_cnt %d\n",dci_cnt);
+
+ if ((CCEmap0==0xffff)||
+ (format_c_found==1))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ // Now check UE_SPEC format 1 search spaces at aggregation 4
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 2,
+ format1A,
+ format1A,
+ format1A,
+ format1,
+ format1_size_bits,
+ format1_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+ //printf("[DCI search] Format 1 aggregation 4 dci_cnt %d\n",dci_cnt);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ //#ifdef ALL_AGGREGATION
+ // Now check UE_SPEC format 1 search spaces at aggregation 8
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 3,
+ format1A,
+ format1A,
+ format1A,
+ format1,
+ format1_size_bits,
+ format1_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+ //printf("[DCI search] Format 1 aggregation 8 dci_cnt %d\n",dci_cnt);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ //#endif //ALL_AGGREGATION
+ } 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);
+ // Now check UE_SPEC format 2A_2A search spaces at aggregation 1
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 0,
+ format1A,
+ format1A,
+ format1A,
+ format2A,
+ format2A_size_bits,
+ format2A_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ LOG_D(PHY," format 2A_2A search CCEmap0 %x, format0_found %d, format_c_found %d \n", CCEmap0, format0_found, format_c_found);
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ LOG_D(PHY," format 2A_2A search dci_cnt %d, old_dci_cn t%d \n", dci_cnt, old_dci_cnt);
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ // Now check UE_SPEC format 2 search spaces at aggregation 2
+ LOG_D(PHY," Now check UE_SPEC format 2A_2A search aggregation 2 dci length: %d[bits] %d[bytes]\n",format2A_size_bits,format2A_size_bytes);
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 1,
+ format1A,
+ format1A,
+ format1A,
+ format2A,
+ format2A_size_bits,
+ format2A_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ LOG_D(PHY," format 2A_2A search dci_cnt %d, old_dci_cn t%d \n", dci_cnt, old_dci_cnt);
+ if (dci_cnt>old_dci_cnt)
+ 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");
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 2,
+ format1A,
+ format1A,
+ format1A,
+ format2A,
+ format2A_size_bits,
+ format2A_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ LOG_D(PHY," format 2A_2A search dci_cnt %d, old_dci_cn t%d \n", dci_cnt, old_dci_cnt);
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ //#ifdef ALL_AGGREGATION
+ // Now check UE_SPEC format 2_2A search spaces at aggregation 8
+ LOG_D(PHY," Now check UE_SPEC format 2_2A search spaces at aggregation 8 dci length: %d[bits] %d[bytes]\n",format2A_size_bits,format2A_size_bytes);
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 3,
+ format1A,
+ format1A,
+ format1A,
+ format2A,
+ format2A_size_bits,
+ format2A_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+ //#endif
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ LOG_D(PHY," format 2A_2A search dci_cnt %d, old_dci_cn t%d \n", dci_cnt, old_dci_cnt);
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+ } else if (tmode == 4) {
+
+ // Now check UE_SPEC format 2_2A search spaces at aggregation 1
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 0,
+ format1A,
+ format1A,
+ format1A,
+ format2,
+ format2_size_bits,
+ format2_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ // Now check UE_SPEC format 2 search spaces at aggregation 2
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 1,
+ format1A,
+ format1A,
+ format1A,
+ format2,
+ format2_size_bits,
+ format2_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ // Now check UE_SPEC format 2_2A search spaces at aggregation 4
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 2,
+ format1A,
+ format1A,
+ format1A,
+ format2,
+ format2_size_bits,
+ format2_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ //#ifdef ALL_AGGREGATION
+ // Now check UE_SPEC format 2_2A search spaces at aggregation 8
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 3,
+ format1A,
+ format1A,
+ format1A,
+ format2,
+ format2_size_bits,
+ format2_size_bytes,
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+ //#endif
+ } else if ((tmode==5) || (tmode==6)) { // This is MU-MIMO
+
+ // Now check UE_SPEC format 1E_2A_M10PRB search spaces aggregation 1
+#ifdef DEBUG_DCI_DECODING
+ LOG_I(PHY," MU-MIMO check UE_SPEC format 1E_2A_M10PRB\n");
+#endif
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 0,
+ format1A,
+ format1A,
+ format1A,
+ format1E_2A_M10PRB,
+ sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
+ sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ // Now check UE_SPEC format 1E_2A_M10PRB search spaces aggregation 2
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 1,
+ format1A,
+ format1A,
+ format1A,
+ format1E_2A_M10PRB,
+ sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
+ sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ // Now check UE_SPEC format 1E_2A_M10PRB search spaces aggregation 4
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 2,
+ format1A,
+ format1A,
+ format1A,
+ format1E_2A_M10PRB,
+ sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
+ sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ //#ifdef ALL_AGGREGATION
+
+ // Now check UE_SPEC format 1E_2A_M10PRB search spaces at aggregation 8
+ old_dci_cnt=dci_cnt;
+ dci_decoding_procedure0(pdcch_vars,0,mode,
+ subframe,
+ dci_alloc,
+ eNB_id,
+ ue->current_thread_id[subframe],
+ frame_parms,
+ mi,
+ ((ue->decode_SIB == 1) ? SI_RNTI : 0),
+ ra_rnti,
+ P_RNTI,
+ 3,
+ format1A,
+ format1A,
+ format1A,
+ format1E_2A_M10PRB,
+ sizeof_DCI1E_5MHz_2A_M10PRB_TDD_t,
+ sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t),
+ &dci_cnt,
+ &format0_found,
+ &format_c_found,
+ &CCEmap0,
+ &CCEmap1,
+ &CCEmap2);
+
+ if ((CCEmap0==0xffff)||
+ ((format0_found==1)&&(format_c_found==1)))
+ return(dci_cnt);
+
+ if (dci_cnt>old_dci_cnt)
+ return(dci_cnt);
+
+ //#endif //ALL_AGGREGATION
+
+ }
+
+ return(dci_cnt);
+}
diff --git a/openair1/PHY/LTE_UE_TRANSPORT/pbch_ue.c b/openair1/PHY/LTE_UE_TRANSPORT/pbch_ue.c
new file mode 100644
index 0000000000000000000000000000000000000000..fe2c4e28c85d08152610a18e3b9a625d9fb3d9c9
--- /dev/null
+++ b/openair1/PHY/LTE_UE_TRANSPORT/pbch_ue.c
@@ -0,0 +1,631 @@
+/*
+ * 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/pbch.c
+* \brief Top-level routines for generating and decoding the PBCH/BCH physical/transport channel V8.6 2009-03
+* \author R. Knopp, F. Kaltenberger
+* \date 2011
+* \version 0.1
+* \company Eurecom
+* \email: knopp@eurecom.fr,florian.kaltenberger.fr
+* \note
+* \warning
+*/
+#include "PHY/defs.h"
+#include "PHY/CODING/extern.h"
+#include "PHY/CODING/lte_interleaver_inline.h"
+#include "defs.h"
+#include "extern.h"
+#include "PHY/extern.h"
+#include "PHY/sse_intrin.h"
+
+//#define DEBUG_PBCH 1
+//#define DEBUG_PBCH_ENCODING
+//#define INTERFERENCE_MITIGATION 1
+
+
+#define PBCH_A 24
+
+uint16_t pbch_extract(int **rxdataF,
+ int **dl_ch_estimates,
+ int **rxdataF_ext,
+ int **dl_ch_estimates_ext,
+ uint32_t symbol,
+ uint32_t high_speed_flag,
+ LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+
+ uint16_t rb,nb_rb=6;
+ uint8_t i,j,aarx,aatx;
+ int *dl_ch0,*dl_ch0_ext,*rxF,*rxF_ext;
+
+ uint32_t nsymb = (frame_parms->Ncp==0) ? 7:6;
+ uint32_t symbol_mod = symbol % nsymb;
+
+ int rx_offset = frame_parms->ofdm_symbol_size-3*12;
+ int ch_offset = frame_parms->N_RB_DL*6-3*12;
+ int nushiftmod3 = frame_parms->nushift%3;
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+ /*
+ printf("extract_rbs (nushift %d): symbol_mod=%d, rx_offset=%d, ch_offset=%d\n",frame_parms->nushift,symbol_mod,
+ (rx_offset + (symbol*(frame_parms->ofdm_symbol_size)))*2,
+ LTE_CE_OFFSET+ch_offset+(symbol_mod*(frame_parms->ofdm_symbol_size)));
+ */
+
+ rxF = &rxdataF[aarx][(rx_offset + (symbol*(frame_parms->ofdm_symbol_size)))];
+ rxF_ext = &rxdataF_ext[aarx][symbol_mod*(6*12)];
+
+ for (rb=0; rb<nb_rb; rb++) {
+ // skip DC carrier
+ if (rb==3) {
+ rxF = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))];
+ }
+
+ if ((symbol_mod==0) || (symbol_mod==1)) {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=(nushiftmod3+3)) &&
+ (i!=(nushiftmod3+6)) &&
+ (i!=(nushiftmod3+9))) {
+ rxF_ext[j++]=rxF[i];
+ }
+ }
+
+ rxF+=12;
+ rxF_ext+=8;
+ } else {
+ for (i=0; i<12; i++) {
+ rxF_ext[i]=rxF[i];
+ }
+
+ rxF+=12;
+ rxF_ext+=12;
+ }
+ }
+
+ for (aatx=0; aatx<4; aatx++) { //frame_parms->nb_antenna_ports_eNB;aatx++) {
+ if (high_speed_flag == 1)
+ dl_ch0 = &dl_ch_estimates[(aatx<<1)+aarx][LTE_CE_OFFSET+ch_offset+(symbol*(frame_parms->ofdm_symbol_size))];
+ else
+ dl_ch0 = &dl_ch_estimates[(aatx<<1)+aarx][LTE_CE_OFFSET+ch_offset];
+
+ dl_ch0_ext = &dl_ch_estimates_ext[(aatx<<1)+aarx][symbol_mod*(6*12)];
+
+ for (rb=0; rb<nb_rb; rb++) {
+ // skip DC carrier
+ // if (rb==3) dl_ch0++;
+ if (symbol_mod>1) {
+ memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+ dl_ch0+=12;
+ dl_ch0_ext+=12;
+ } else {
+ j=0;
+
+ for (i=0; i<12; i++) {
+ if ((i!=nushiftmod3) &&
+ (i!=(nushiftmod3+3)) &&
+ (i!=(nushiftmod3+6)) &&
+ (i!=(nushiftmod3+9))) {
+ // printf("PBCH extract i %d j %d => (%d,%d)\n",i,j,*(short *)&dl_ch0[i],*(1+(short*)&dl_ch0[i]));
+ dl_ch0_ext[j++]=dl_ch0[i];
+ }
+ }
+
+ dl_ch0+=12;
+ dl_ch0_ext+=8;
+ }
+ }
+ } //tx antenna loop
+
+ }
+
+ return(0);
+}
+
+//__m128i avg128;
+
+//compute average channel_level on each (TX,RX) antenna pair
+int pbch_channel_level(int **dl_ch_estimates_ext,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ uint32_t symbol)
+{
+
+ int16_t rb, nb_rb=6;
+ uint8_t aatx,aarx;
+
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i avg128;
+ __m128i *dl_ch128;
+#elif defined(__arm__)
+ int32x4_t avg128;
+ int16x8_t *dl_ch128;
+#endif
+ int avg1=0,avg2=0;
+
+ uint32_t nsymb = (frame_parms->Ncp==0) ? 7:6;
+ uint32_t symbol_mod = symbol % nsymb;
+
+ for (aatx=0; aatx<4; aatx++) //frame_parms->nb_antenna_ports_eNB;aatx++)
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+ //clear average level
+
+#if defined(__x86_64__) || defined(__i386__)
+ avg128 = _mm_setzero_si128();
+ dl_ch128=(__m128i *)&dl_ch_estimates_ext[(aatx<<1)+aarx][symbol_mod*6*12];
+#elif defined(__arm__)
+ avg128 = vdupq_n_s32(0);
+ dl_ch128=(int16x8_t *)&dl_ch_estimates_ext[(aatx<<1)+aarx][symbol_mod*6*12];
+
+#endif
+ for (rb=0; rb<nb_rb; rb++) {
+#if defined(__x86_64__) || defined(__i386__)
+ avg128 = _mm_add_epi32(avg128,_mm_madd_epi16(dl_ch128[0],dl_ch128[0]));
+ avg128 = _mm_add_epi32(avg128,_mm_madd_epi16(dl_ch128[1],dl_ch128[1]));
+ avg128 = _mm_add_epi32(avg128,_mm_madd_epi16(dl_ch128[2],dl_ch128[2]));
+#elif defined(__arm__)
+// to be filled in
+#endif
+ dl_ch128+=3;
+ /*
+ if (rb==0) {
+ print_shorts("dl_ch128",&dl_ch128[0]);
+ print_shorts("dl_ch128",&dl_ch128[1]);
+ print_shorts("dl_ch128",&dl_ch128[2]);
+ }
+ */
+ }
+
+ avg1 = (((int*)&avg128)[0] +
+ ((int*)&avg128)[1] +
+ ((int*)&avg128)[2] +
+ ((int*)&avg128)[3])/(nb_rb*12);
+
+ if (avg1>avg2)
+ avg2 = avg1;
+
+ //msg("Channel level : %d, %d\n",avg1, avg2);
+ }
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+ return(avg2);
+
+}
+
+#if defined(__x86_64__) || defined(__i386__)
+__m128i mmtmpP0,mmtmpP1,mmtmpP2,mmtmpP3;
+#elif defined(__arm__)
+int16x8_t mmtmpP0,mmtmpP1,mmtmpP2,mmtmpP3;
+#endif
+void pbch_channel_compensation(int **rxdataF_ext,
+ int **dl_ch_estimates_ext,
+ int **rxdataF_comp,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t symbol,
+ uint8_t output_shift)
+{
+
+ uint16_t rb,nb_rb=6;
+ uint8_t aatx,aarx,symbol_mod;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *dl_ch128,*rxdataF128,*rxdataF_comp128;
+#elif defined(__arm__)
+
+#endif
+ symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
+
+ for (aatx=0; aatx<4; aatx++) //frame_parms->nb_antenna_ports_eNB;aatx++)
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+ dl_ch128 = (__m128i *)&dl_ch_estimates_ext[(aatx<<1)+aarx][symbol_mod*6*12];
+ rxdataF128 = (__m128i *)&rxdataF_ext[aarx][symbol_mod*6*12];
+ rxdataF_comp128 = (__m128i *)&rxdataF_comp[(aatx<<1)+aarx][symbol_mod*6*12];
+
+#elif defined(__arm__)
+// to be filled in
+#endif
+
+ for (rb=0; rb<nb_rb; rb++) {
+ //printf("rb %d\n",rb);
+#if defined(__x86_64__) || defined(__i386__)
+ // multiply by conjugated channel
+ mmtmpP0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
+ // print_ints("re",&mmtmpP0);
+ // mmtmpP0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpP1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+ mmtmpP1 = _mm_shufflehi_epi16(mmtmpP1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpP1 = _mm_sign_epi16(mmtmpP1,*(__m128i*)&conjugate[0]);
+ // print_ints("im",&mmtmpP1);
+ mmtmpP1 = _mm_madd_epi16(mmtmpP1,rxdataF128[0]);
+ // mmtmpP1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpP0 = _mm_srai_epi32(mmtmpP0,output_shift);
+ // print_ints("re(shift)",&mmtmpP0);
+ mmtmpP1 = _mm_srai_epi32(mmtmpP1,output_shift);
+ // print_ints("im(shift)",&mmtmpP1);
+ mmtmpP2 = _mm_unpacklo_epi32(mmtmpP0,mmtmpP1);
+ mmtmpP3 = _mm_unpackhi_epi32(mmtmpP0,mmtmpP1);
+ // print_ints("c0",&mmtmpP2);
+ // print_ints("c1",&mmtmpP3);
+ rxdataF_comp128[0] = _mm_packs_epi32(mmtmpP2,mmtmpP3);
+ // print_shorts("rx:",rxdataF128);
+ // print_shorts("ch:",dl_ch128);
+ // print_shorts("pack:",rxdataF_comp128);
+
+ // multiply by conjugated channel
+ mmtmpP0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
+ // mmtmpP0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpP1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+ mmtmpP1 = _mm_shufflehi_epi16(mmtmpP1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpP1 = _mm_sign_epi16(mmtmpP1,*(__m128i*)&conjugate[0]);
+ mmtmpP1 = _mm_madd_epi16(mmtmpP1,rxdataF128[1]);
+ // mmtmpP1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpP0 = _mm_srai_epi32(mmtmpP0,output_shift);
+ mmtmpP1 = _mm_srai_epi32(mmtmpP1,output_shift);
+ mmtmpP2 = _mm_unpacklo_epi32(mmtmpP0,mmtmpP1);
+ mmtmpP3 = _mm_unpackhi_epi32(mmtmpP0,mmtmpP1);
+ rxdataF_comp128[1] = _mm_packs_epi32(mmtmpP2,mmtmpP3);
+ // print_shorts("rx:",rxdataF128+1);
+ // print_shorts("ch:",dl_ch128+1);
+ // print_shorts("pack:",rxdataF_comp128+1);
+
+ if (symbol_mod>1) {
+ // multiply by conjugated channel
+ mmtmpP0 = _mm_madd_epi16(dl_ch128[2],rxdataF128[2]);
+ // mmtmpP0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpP1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
+ mmtmpP1 = _mm_shufflehi_epi16(mmtmpP1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpP1 = _mm_sign_epi16(mmtmpP1,*(__m128i*)&conjugate[0]);
+ mmtmpP1 = _mm_madd_epi16(mmtmpP1,rxdataF128[2]);
+ // mmtmpP1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpP0 = _mm_srai_epi32(mmtmpP0,output_shift);
+ mmtmpP1 = _mm_srai_epi32(mmtmpP1,output_shift);
+ mmtmpP2 = _mm_unpacklo_epi32(mmtmpP0,mmtmpP1);
+ mmtmpP3 = _mm_unpackhi_epi32(mmtmpP0,mmtmpP1);
+ rxdataF_comp128[2] = _mm_packs_epi32(mmtmpP2,mmtmpP3);
+ // print_shorts("rx:",rxdataF128+2);
+ // print_shorts("ch:",dl_ch128+2);
+ // print_shorts("pack:",rxdataF_comp128+2);
+
+ dl_ch128+=3;
+ rxdataF128+=3;
+ rxdataF_comp128+=3;
+ } else {
+ dl_ch128+=2;
+ rxdataF128+=2;
+ rxdataF_comp128+=2;
+ }
+#elif defined(__arm__)
+// to be filled in
+#endif
+ }
+ }
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+void pbch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
+ int **rxdataF_comp,
+ uint8_t symbol)
+{
+
+ uint8_t aatx, symbol_mod;
+ int i, nb_rb=6;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *rxdataF_comp128_0,*rxdataF_comp128_1;
+#elif defined(__arm__)
+ int16x8_t *rxdataF_comp128_0,*rxdataF_comp128_1;
+#endif
+ symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
+
+ if (frame_parms->nb_antennas_rx>1) {
+ for (aatx=0; aatx<4; aatx++) { //frame_parms->nb_antenna_ports_eNB;aatx++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_0 = (__m128i *)&rxdataF_comp[(aatx<<1)][symbol_mod*6*12];
+ rxdataF_comp128_1 = (__m128i *)&rxdataF_comp[(aatx<<1)+1][symbol_mod*6*12];
+#elif defined(__arm__)
+ rxdataF_comp128_0 = (int16x8_t *)&rxdataF_comp[(aatx<<1)][symbol_mod*6*12];
+ rxdataF_comp128_1 = (int16x8_t *)&rxdataF_comp[(aatx<<1)+1][symbol_mod*6*12];
+
+#endif
+ // MRC on each re of rb, both on MF output and magnitude (for 16QAM/64QAM llr computation)
+ for (i=0; i<nb_rb*3; i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+#elif defined(__arm__)
+ rxdataF_comp128_0[i] = vhaddq_s16(rxdataF_comp128_0[i],rxdataF_comp128_1[i]);
+
+#endif
+ }
+ }
+ }
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+void pbch_unscrambling(LTE_DL_FRAME_PARMS *frame_parms,
+ int8_t* llr,
+ uint32_t length,
+ uint8_t frame_mod4)
+{
+ int i;
+ uint8_t reset;
+ uint32_t x1, x2, s=0;
+
+ reset = 1;
+ // x1 is set in first call to lte_gold_generic
+ x2 = frame_parms->Nid_cell; //this is c_init in 36.211 Sec 6.6.1
+ // msg("pbch_unscrambling: Nid_cell = %d\n",x2);
+
+ for (i=0; i<length; i++) {
+ if (i%32==0) {
+ s = lte_gold_generic(&x1, &x2, reset);
+ // printf("lte_gold[%d]=%x\n",i,s);
+ reset = 0;
+ }
+
+ // take the quarter of the PBCH that corresponds to this frame
+ if ((i>=(frame_mod4*(length>>2))) && (i<((1+frame_mod4)*(length>>2)))) {
+
+ if (((s>>(i%32))&1)==0)
+ llr[i] = -llr[i];
+ }
+ }
+}
+
+void pbch_alamouti(LTE_DL_FRAME_PARMS *frame_parms,
+ int **rxdataF_comp,
+ uint8_t symbol)
+{
+
+
+ int16_t *rxF0,*rxF1;
+ // __m128i *ch_mag0,*ch_mag1,*ch_mag0b,*ch_mag1b;
+ uint8_t rb,re,symbol_mod;
+ int jj;
+
+ // printf("Doing alamouti\n");
+ symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
+ jj = (symbol_mod*6*12);
+
+ rxF0 = (int16_t*)&rxdataF_comp[0][jj]; //tx antenna 0 h0*y
+ rxF1 = (int16_t*)&rxdataF_comp[2][jj]; //tx antenna 1 h1*y
+
+ for (rb=0; rb<6; rb++) {
+
+ for (re=0; re<12; re+=2) {
+
+ // Alamouti RX combining
+
+ rxF0[0] = rxF0[0] + rxF1[2];
+ rxF0[1] = rxF0[1] - rxF1[3];
+
+ rxF0[2] = rxF0[2] - rxF1[0];
+ rxF0[3] = rxF0[3] + rxF1[1];
+
+ rxF0+=4;
+ rxF1+=4;
+ }
+
+ }
+
+}
+
+void pbch_quantize(int8_t *pbch_llr8,
+ int16_t *pbch_llr,
+ uint16_t len)
+{
+
+ uint16_t i;
+
+ for (i=0; i<len; i++) {
+ if (pbch_llr[i]>7)
+ pbch_llr8[i]=7;
+ else if (pbch_llr[i]<-8)
+ pbch_llr8[i]=-8;
+ else
+ pbch_llr8[i] = (char)(pbch_llr[i]);
+
+ }
+}
+
+static unsigned char dummy_w_rx[3*3*(16+PBCH_A)];
+static int8_t pbch_w_rx[3*3*(16+PBCH_A)],pbch_d_rx[96+(3*(16+PBCH_A))];
+
+
+uint16_t rx_pbch(LTE_UE_COMMON *lte_ue_common_vars,
+ LTE_UE_PBCH *lte_ue_pbch_vars,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t eNB_id,
+ MIMO_mode_t mimo_mode,
+ uint32_t high_speed_flag,
+ uint8_t frame_mod4)
+{
+
+ uint8_t log2_maxh;//,aatx,aarx;
+ int max_h=0;
+
+ int symbol,i;
+ uint32_t nsymb = (frame_parms->Ncp==0) ? 14:12;
+ uint16_t pbch_E;
+ uint8_t pbch_a[8];
+ uint8_t RCC;
+
+ int8_t *pbch_e_rx;
+ uint8_t *decoded_output = lte_ue_pbch_vars->decoded_output;
+ uint16_t crc;
+
+
+ // pbch_D = 16+PBCH_A;
+
+ pbch_E = (frame_parms->Ncp==0) ? 1920 : 1728; //RE/RB * #RB * bits/RB (QPSK)
+ pbch_e_rx = <e_ue_pbch_vars->llr[frame_mod4*(pbch_E>>2)];
+#ifdef DEBUG_PBCH
+ LOG_D(PHY,"[PBCH] starting symbol loop (Ncp %d, frame_mod4 %d,mimo_mode %d\n",frame_parms->Ncp,frame_mod4,mimo_mode);
+#endif
+
+ // clear LLR buffer
+ memset(lte_ue_pbch_vars->llr,0,pbch_E);
+
+ for (symbol=(nsymb>>1); symbol<(nsymb>>1)+4; symbol++) {
+
+#ifdef DEBUG_PBCH
+ LOG_D(PHY,"[PBCH] starting extract\n");
+#endif
+ pbch_extract(lte_ue_common_vars->common_vars_rx_data_per_thread[0].rxdataF,
+ lte_ue_common_vars->common_vars_rx_data_per_thread[0].dl_ch_estimates[eNB_id],
+ lte_ue_pbch_vars->rxdataF_ext,
+ lte_ue_pbch_vars->dl_ch_estimates_ext,
+ symbol,
+ high_speed_flag,
+ frame_parms);
+#ifdef DEBUG_PBCH
+ LOG_D(PHY,"[PHY] PBCH Symbol %d\n",symbol);
+ LOG_D(PHY,"[PHY] PBCH starting channel_level\n");
+#endif
+
+ max_h = pbch_channel_level(lte_ue_pbch_vars->dl_ch_estimates_ext,
+ frame_parms,
+ symbol);
+ log2_maxh = 3+(log2_approx(max_h)/2);
+
+#ifdef DEBUG_PBCH
+ LOG_D(PHY,"[PHY] PBCH log2_maxh = %d (%d)\n",log2_maxh,max_h);
+#endif
+
+ pbch_channel_compensation(lte_ue_pbch_vars->rxdataF_ext,
+ lte_ue_pbch_vars->dl_ch_estimates_ext,
+ lte_ue_pbch_vars->rxdataF_comp,
+ frame_parms,
+ symbol,
+ log2_maxh); // log2_maxh+I0_shift
+
+ if (frame_parms->nb_antennas_rx > 1)
+ pbch_detection_mrc(frame_parms,
+ lte_ue_pbch_vars->rxdataF_comp,
+ symbol);
+
+
+ if (mimo_mode == ALAMOUTI) {
+ pbch_alamouti(frame_parms,lte_ue_pbch_vars->rxdataF_comp,symbol);
+ } else if (mimo_mode != SISO) {
+ LOG_D(PHY,"[PBCH][RX] Unsupported MIMO mode\n");
+ return(-1);
+ }
+
+ if (symbol>(nsymb>>1)+1) {
+ pbch_quantize(pbch_e_rx,
+ (short*)&(lte_ue_pbch_vars->rxdataF_comp[0][(symbol%(nsymb>>1))*72]),
+ 144);
+
+ pbch_e_rx+=144;
+ } else {
+ pbch_quantize(pbch_e_rx,
+ (short*)&(lte_ue_pbch_vars->rxdataF_comp[0][(symbol%(nsymb>>1))*72]),
+ 96);
+
+ pbch_e_rx+=96;
+ }
+
+
+ }
+
+ pbch_e_rx = lte_ue_pbch_vars->llr;
+
+
+
+ //un-scrambling
+#ifdef DEBUG_PBCH
+ LOG_D(PHY,"[PBCH] doing unscrambling\n");
+#endif
+
+
+ pbch_unscrambling(frame_parms,
+ pbch_e_rx,
+ pbch_E,
+ frame_mod4);
+
+
+
+ //un-rate matching
+#ifdef DEBUG_PBCH
+ LOG_D(PHY,"[PBCH] doing un-rate-matching\n");
+#endif
+
+
+ memset(dummy_w_rx,0,3*3*(16+PBCH_A));
+ RCC = generate_dummy_w_cc(16+PBCH_A,
+ dummy_w_rx);
+
+
+ lte_rate_matching_cc_rx(RCC,pbch_E,pbch_w_rx,dummy_w_rx,pbch_e_rx);
+
+ sub_block_deinterleaving_cc((unsigned int)(PBCH_A+16),
+ &pbch_d_rx[96],
+ &pbch_w_rx[0]);
+
+ memset(pbch_a,0,((16+PBCH_A)>>3));
+
+
+
+
+ phy_viterbi_lte_sse2(pbch_d_rx+96,pbch_a,16+PBCH_A);
+
+ // Fix byte endian of PBCH (bit 23 goes in first)
+ for (i=0; i<(PBCH_A>>3); i++)
+ decoded_output[(PBCH_A>>3)-i-1] = pbch_a[i];
+
+#ifdef DEBUG_PBCH
+
+ for (i=0; i<(PBCH_A>>3); i++)
+ LOG_I(PHY,"[PBCH] pbch_a[%d] = %x\n",i,decoded_output[i]);
+
+#endif //DEBUG_PBCH
+
+#ifdef DEBUG_PBCH
+ LOG_I(PHY,"PBCH CRC %x : %x\n",
+ crc16(pbch_a,PBCH_A),
+ ((uint16_t)pbch_a[PBCH_A>>3]<<8)+pbch_a[(PBCH_A>>3)+1]);
+#endif
+
+ crc = (crc16(pbch_a,PBCH_A)>>16) ^
+ (((uint16_t)pbch_a[PBCH_A>>3]<<8)+pbch_a[(PBCH_A>>3)+1]);
+
+ if (crc == 0x0000)
+ return(1);
+ else if (crc == 0xffff)
+ return(2);
+ else if (crc == 0x5555)
+ return(4);
+ else
+ return(-1);
+
+
+}
diff --git a/openair1/PHY/LTE_UE_TRANSPORT/pcfich_ue.c b/openair1/PHY/LTE_UE_TRANSPORT/pcfich_ue.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7e24cb87dad212b71f461996a6a6a89f02468fa
--- /dev/null
+++ b/openair1/PHY/LTE_UE_TRANSPORT/pcfich_ue.c
@@ -0,0 +1,312 @@
+/*
+ * 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/pcfich.c
+* \brief Top-level routines for generating and decoding the PCFICH/CFI physical/transport channel V8.6 2009-03
+* \author R. Knopp
+* \date 2011
+* \version 0.1
+* \company Eurecom
+* \email: knopp@eurecom.fr
+* \note
+* \warning
+*/
+#include "PHY/defs.h"
+
+//#define DEBUG_PCFICH
+
+void generate_pcfich_reg_mapping(LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+ uint16_t kbar = 6 * (frame_parms->Nid_cell %(2*frame_parms->N_RB_DL));
+ uint16_t first_reg;
+ uint16_t *pcfich_reg = frame_parms->pcfich_reg;
+
+ pcfich_reg[0] = kbar/6;
+ first_reg = pcfich_reg[0];
+
+ frame_parms->pcfich_first_reg_idx=0;
+
+ pcfich_reg[1] = ((kbar + (frame_parms->N_RB_DL>>1)*6)%(frame_parms->N_RB_DL*12))/6;
+
+ if (pcfich_reg[1] < pcfich_reg[0]) {
+ frame_parms->pcfich_first_reg_idx = 1;
+ first_reg = pcfich_reg[1];
+ }
+
+ pcfich_reg[2] = ((kbar + (frame_parms->N_RB_DL)*6)%(frame_parms->N_RB_DL*12))/6;
+
+ if (pcfich_reg[2] < first_reg) {
+ frame_parms->pcfich_first_reg_idx = 2;
+ first_reg = pcfich_reg[2];
+ }
+
+ pcfich_reg[3] = ((kbar + ((3*frame_parms->N_RB_DL)>>1)*6)%(frame_parms->N_RB_DL*12))/6;
+
+ if (pcfich_reg[3] < first_reg) {
+ frame_parms->pcfich_first_reg_idx = 3;
+ first_reg = pcfich_reg[3];
+ }
+
+
+ //#ifdef DEBUG_PCFICH
+ printf("pcfich_reg : %d,%d,%d,%d\n",pcfich_reg[0],pcfich_reg[1],pcfich_reg[2],pcfich_reg[3]);
+ //#endif
+}
+
+void pcfich_scrambling(LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t subframe,
+ uint8_t *b,
+ uint8_t *bt)
+{
+ uint32_t i;
+ uint8_t reset;
+ uint32_t x1, x2, s=0;
+
+ reset = 1;
+ // x1 is set in lte_gold_generic
+ x2 = ((((2*frame_parms->Nid_cell)+1)*(1+subframe))<<9) + frame_parms->Nid_cell; //this is c_init in 36.211 Sec 6.7.1
+
+ for (i=0; i<32; i++) {
+ if ((i&0x1f)==0) {
+ s = lte_gold_generic(&x1, &x2, reset);
+ //printf("lte_gold[%d]=%x\n",i,s);
+ reset = 0;
+ }
+
+ bt[i] = (b[i]&1) ^ ((s>>(i&0x1f))&1);
+ }
+}
+
+void pcfich_unscrambling(LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t subframe,
+ int16_t *d)
+{
+
+ uint32_t i;
+ uint8_t reset;
+ uint32_t x1, x2, s=0;
+
+ reset = 1;
+ // x1 is set in lte_gold_generic
+ x2 = ((((2*frame_parms->Nid_cell)+1)*(1+subframe))<<9) + frame_parms->Nid_cell; //this is c_init in 36.211 Sec 6.7.1
+
+ for (i=0; i<32; i++) {
+ if ((i&0x1f)==0) {
+ s = lte_gold_generic(&x1, &x2, reset);
+ //printf("lte_gold[%d]=%x\n",i,s);
+ reset = 0;
+ }
+
+ if (((s>>(i&0x1f))&1) == 1)
+ d[i]=-d[i];
+
+ }
+}
+
+uint8_t pcfich_b[4][32]= {{0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1},
+ {1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0},
+ {1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1},
+ {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
+};
+
+void generate_pcfich(uint8_t num_pdcch_symbols,
+ int16_t amp,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ int32_t **txdataF,
+ uint8_t subframe)
+{
+
+ uint8_t pcfich_bt[32],nsymb,pcfich_quad;
+ int32_t pcfich_d[2][16];
+ uint8_t i;
+ uint32_t symbol_offset,m,re_offset,reg_offset;
+ int16_t gain_lin_QPSK;
+ uint16_t *pcfich_reg = frame_parms->pcfich_reg;
+
+ int nushiftmod3 = frame_parms->nushift%3;
+#ifdef DEBUG_PCFICH
+ LOG_D(PHY,"Generating PCFICH in subfrmae %d for %d PDCCH symbols, AMP %d, p %d, Ncp %d\n",
+ subframe,num_pdcch_symbols,amp,frame_parms->nb_antenna_ports_eNB,frame_parms->Ncp);
+#endif
+
+ // scrambling
+ if ((num_pdcch_symbols>0) && (num_pdcch_symbols<4))
+ pcfich_scrambling(frame_parms,subframe,pcfich_b[num_pdcch_symbols-1],pcfich_bt);
+
+ // modulation
+ if (frame_parms->nb_antenna_ports_eNB==1)
+ gain_lin_QPSK = (int16_t)((amp*ONE_OVER_SQRT2_Q15)>>15);
+ else
+ gain_lin_QPSK = amp/2;
+
+ if (frame_parms->nb_antenna_ports_eNB==1) { // SISO
+
+ for (i=0; i<16; i++) {
+ ((int16_t*)(&(pcfich_d[0][i])))[0] = ((pcfich_bt[2*i] == 1) ? -gain_lin_QPSK : gain_lin_QPSK);
+ ((int16_t*)(&(pcfich_d[1][i])))[0] = ((pcfich_bt[2*i] == 1) ? -gain_lin_QPSK : gain_lin_QPSK);
+ ((int16_t*)(&(pcfich_d[0][i])))[1] = ((pcfich_bt[2*i+1] == 1) ? -gain_lin_QPSK : gain_lin_QPSK);
+ ((int16_t*)(&(pcfich_d[1][i])))[1] = ((pcfich_bt[2*i+1] == 1) ? -gain_lin_QPSK : gain_lin_QPSK);
+ }
+ } else { // ALAMOUTI
+ for (i=0; i<16; i+=2) {
+ // first antenna position n -> x0
+ ((int16_t*)(&(pcfich_d[0][i])))[0] = ((pcfich_bt[2*i] == 1) ? -gain_lin_QPSK : gain_lin_QPSK);
+ ((int16_t*)(&(pcfich_d[0][i])))[1] = ((pcfich_bt[2*i+1] == 1) ? -gain_lin_QPSK : gain_lin_QPSK);
+ // second antenna position n -> -x1*
+ ((int16_t*)(&(pcfich_d[1][i])))[0] = ((pcfich_bt[2*i+2] == 1) ? gain_lin_QPSK : -gain_lin_QPSK);
+ ((int16_t*)(&(pcfich_d[1][i])))[1] = ((pcfich_bt[2*i+3] == 1) ? -gain_lin_QPSK : gain_lin_QPSK);
+ // fill in the rest of the ALAMOUTI precoding
+ ((int16_t*)&pcfich_d[0][i+1])[0] = -((int16_t*)&pcfich_d[1][i])[0];
+ ((int16_t*)&pcfich_d[0][i+1])[1] = ((int16_t*)&pcfich_d[1][i])[1];
+ ((int16_t*)&pcfich_d[1][i+1])[0] = ((int16_t*)&pcfich_d[0][i])[0];
+ ((int16_t*)&pcfich_d[1][i+1])[1] = -((int16_t*)&pcfich_d[0][i])[1];
+
+
+ }
+ }
+
+
+ // mapping
+ nsymb = (frame_parms->Ncp==0) ? 14:12;
+
+ symbol_offset = (uint32_t)frame_parms->ofdm_symbol_size*(subframe*nsymb);
+ re_offset = frame_parms->first_carrier_offset;
+
+ // loop over 4 quadruplets and lookup REGs
+ m=0;
+
+ for (pcfich_quad=0; pcfich_quad<4; pcfich_quad++) {
+ reg_offset = re_offset+((uint16_t)pcfich_reg[pcfich_quad]*6);
+
+ if (reg_offset>=frame_parms->ofdm_symbol_size)
+ reg_offset=1 + reg_offset-frame_parms->ofdm_symbol_size;
+
+ for (i=0; i<6; i++) {
+ if ((i!=nushiftmod3)&&(i!=(nushiftmod3+3))) {
+ txdataF[0][symbol_offset+reg_offset+i] = pcfich_d[0][m];
+
+ if (frame_parms->nb_antenna_ports_eNB>1)
+ txdataF[1][symbol_offset+reg_offset+i] = pcfich_d[1][m];
+
+ m++;
+ }
+ }
+ }
+
+}
+
+
+uint8_t rx_pcfich(LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t subframe,
+ LTE_UE_PDCCH *lte_ue_pdcch_vars,
+ MIMO_mode_t mimo_mode)
+{
+
+ uint8_t pcfich_quad;
+ uint8_t i,j;
+ uint16_t reg_offset;
+
+ int32_t **rxdataF_comp = lte_ue_pdcch_vars->rxdataF_comp;
+ int16_t pcfich_d[32],*pcfich_d_ptr;
+ int32_t metric,old_metric=-16384;
+ uint8_t num_pdcch_symbols=3;
+ uint16_t *pcfich_reg = frame_parms->pcfich_reg;
+
+ // demapping
+ // loop over 4 quadruplets and lookup REGs
+ // m=0;
+ pcfich_d_ptr = pcfich_d;
+
+ for (pcfich_quad=0; pcfich_quad<4; pcfich_quad++) {
+ reg_offset = (pcfich_reg[pcfich_quad]*4);
+
+ for (i=0; i<4; i++) {
+
+ pcfich_d_ptr[0] = ((int16_t*)&rxdataF_comp[0][reg_offset+i])[0]; // RE component
+ pcfich_d_ptr[1] = ((int16_t*)&rxdataF_comp[0][reg_offset+i])[1]; // IM component
+#ifdef DEBUG_PCFICH
+ printf("rx_pcfich: quad %d, i %d, offset %d => (%d,%d) => pcfich_d_ptr[0] %d \n",pcfich_quad,i,reg_offset+i,
+ ((int16_t*)&rxdataF_comp[0][reg_offset+i])[0],
+ ((int16_t*)&rxdataF_comp[0][reg_offset+i])[1],
+ pcfich_d_ptr[0]);
+#endif
+ pcfich_d_ptr+=2;
+ }
+
+ /*
+ }
+ else { // ALAMOUTI
+ for (i=0;i<4;i+=2) {
+ pcfich_d_ptr[0] = 0;
+ pcfich_d_ptr[1] = 0;
+ pcfich_d_ptr[2] = 0;
+ pcfich_d_ptr[3] = 0;
+ for (j=0;j<frame_parms->nb_antennas_rx;j++) {
+
+ pcfich_d_ptr[0] += (((int16_t*)&rxdataF_comp[j][reg_offset+i])[0]+
+ ((int16_t*)&rxdataF_comp[j+2][reg_offset+i+1])[0]); // RE component
+ pcfich_d_ptr[1] += (((int16_t*)&rxdataF_comp[j][reg_offset+i])[1] -
+ ((int16_t*)&rxdataF_comp[j+2][reg_offset+i+1])[1]);// IM component
+
+ pcfich_d_ptr[2] += (((int16_t*)&rxdataF_comp[j][reg_offset+i+1])[0]-
+ ((int16_t*)&rxdataF_comp[j+2][reg_offset+i])[0]); // RE component
+ pcfich_d_ptr[3] += (((int16_t*)&rxdataF_comp[j][reg_offset+i+1])[1] +
+ ((int16_t*)&rxdataF_comp[j+2][reg_offset+i])[1]);// IM component
+
+
+ }
+
+ pcfich_d_ptr+=4;
+
+ }
+ */
+ }
+
+ // pcfhich unscrambling
+
+ pcfich_unscrambling(frame_parms,subframe,pcfich_d);
+
+ // pcfich detection
+
+ for (i=0; i<3; i++) {
+ metric = 0;
+
+ for (j=0; j<32; j++) {
+ // printf("pcfich_b[%d][%d] %d => pcfich_d[%d] %d\n",i,j,pcfich_b[i][j],j,pcfich_d[j]);
+ metric += (int32_t)(((pcfich_b[i][j]==0) ? (pcfich_d[j]) : (-pcfich_d[j])));
+ }
+
+#ifdef DEBUG_PCFICH
+ printf("metric %d : %d\n",i,metric);
+#endif
+
+ if (metric > old_metric) {
+ num_pdcch_symbols = 1+i;
+ old_metric = metric;
+ }
+ }
+
+#ifdef DEBUG_PCFICH
+ printf("[PHY] PCFICH detected for %d PDCCH symbols\n",num_pdcch_symbols);
+#endif
+ return(num_pdcch_symbols);
+}
diff --git a/openair1/PHY/LTE_UE_TRANSPORT/pch_ue.c b/openair1/PHY/LTE_UE_TRANSPORT/pch_ue.c
new file mode 100644
index 0000000000000000000000000000000000000000..600c5215bdd5c4bbde741ff86b4dad7196620633
--- /dev/null
+++ b/openair1/PHY/LTE_UE_TRANSPORT/pch_ue.c
@@ -0,0 +1,54 @@
+/*
+ * 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 "PHY/defs.h"
+#include "PHY/extern.h"
+#include "assertions.h"
+
+const unsigned int Ttab[4] = {32,64,128,256};
+
+// This function implements the initialization of paging parameters for UE (See Section 7, 36.304)
+// It must be called after setting IMSImod1024 during UE startup and after receiving SIB2
+int init_ue_paging_info(PHY_VARS_UE *ue, long defaultPagingCycle, long nB) {
+
+ LTE_DL_FRAME_PARMS *fp = &ue->frame_parms;
+
+ unsigned int T = Ttab[defaultPagingCycle];
+ unsigned int N = (nB<=2) ? T : (T>>(nB-2));
+ unsigned int Ns = (nB<2) ? (1<<(2-nB)) : 1;
+ unsigned int UE_ID = ue->IMSImod1024;
+ unsigned int i_s = (UE_ID/N)%Ns;
+
+
+ ue->PF = (T/N) * (UE_ID % N);
+
+ // This implements Section 7.2 from 36.304
+ if (Ns==1)
+ ue->PO = (fp->frame_type==FDD) ? 9 : 0;
+ else if (Ns==2)
+ ue->PO = (fp->frame_type==FDD) ? (4+(5*i_s)) : (5*i_s);
+ else if (Ns==4)
+ ue->PO = (fp->frame_type==FDD) ? (4*(i_s&1)+(5*(i_s>>1))) : ((i_s&1)+(5*(i_s>>1)));
+ else
+ AssertFatal(1==0,"init_ue_paging_info: Ns is %d\n",Ns);
+
+ return(0);
+}
diff --git a/openair1/PHY/LTE_UE_TRANSPORT/phich_ue.c b/openair1/PHY/LTE_UE_TRANSPORT/phich_ue.c
new file mode 100644
index 0000000000000000000000000000000000000000..2bd7140c32ccc96524b58d9e489280bae5cf7754
--- /dev/null
+++ b/openair1/PHY/LTE_UE_TRANSPORT/phich_ue.c
@@ -0,0 +1,1570 @@
+/*
+ * 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/phich.c
+* \brief Top-level routines for generating and decoding the PHICH/HI physical/transport channel V8.6 2009-03
+* \author R. Knopp
+* \date 2011
+* \version 0.1
+* \company Eurecom
+* \email: knopp@eurecom.fr
+* \note
+* \warning
+*/
+
+#include "PHY/defs.h"
+#include "PHY/extern.h"
+#include "SCHED/defs.h"
+#include "defs.h"
+
+#include "LAYER2/MAC/extern.h"
+#include "LAYER2/MAC/defs.h"
+
+#include "T.h"
+
+//#define DEBUG_PHICH 1
+
+//extern unsigned short pcfich_reg[4];
+//extern unsigned char pcfich_first_reg_idx;
+
+//unsigned short phich_reg[MAX_NUM_PHICH_GROUPS][3];
+
+
+uint8_t rv_table[4] = {0, 2, 3, 1};
+
+uint8_t get_mi(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe)
+{
+
+ // for FDD
+ if (frame_parms->frame_type == FDD)
+ return 1;
+
+ // for TDD
+ switch (frame_parms->tdd_config) {
+
+ case 0:
+ if ((subframe==0) || (subframe==5))
+ return(2);
+ else return(1);
+
+ break;
+
+ case 1:
+ if ((subframe==0) || (subframe==5))
+ return(0);
+ else return(1);
+
+ break;
+
+ case 2:
+ if ((subframe==3) || (subframe==8))
+ return(1);
+ else return(0);
+
+ break;
+
+ case 3:
+ if ((subframe==0) || (subframe==8) || (subframe==9))
+ return(1);
+ else return(0);
+
+ break;
+
+ case 4:
+ if ((subframe==8) || (subframe==9))
+ return(1);
+ else return(0);
+
+ break;
+
+ case 5:
+ if (subframe==8)
+ return(1);
+ else return(0);
+
+ break;
+
+ case 6:
+ return(1);
+ break;
+
+ default:
+ return(0);
+ }
+}
+
+unsigned char subframe2_ul_harq(LTE_DL_FRAME_PARMS *frame_parms,unsigned char subframe)
+{
+
+ if (frame_parms->frame_type == FDD)
+ return(subframe&7);
+
+ switch (frame_parms->tdd_config) {
+ case 3:
+ if ( (subframe == 8) || (subframe == 9) ) {
+ return(subframe-8);
+ } else if (subframe==0)
+ return(2);
+ else {
+ LOG_E(PHY,"phich.c: subframe2_ul_harq, illegal subframe %d for tdd_config %d\n",
+ subframe,frame_parms->tdd_config);
+ return(0);
+ }
+
+ break;
+
+ case 4:
+ if ( (subframe == 8) || (subframe == 9) ) {
+ return(subframe-8);
+ } else {
+ LOG_E(PHY,"phich.c: subframe2_ul_harq, illegal subframe %d for tdd_config %d\n",
+ subframe,frame_parms->tdd_config);
+ return(0);
+ }
+
+ break;
+
+ }
+
+ return(0);
+}
+
+int phich_frame2_pusch_frame(LTE_DL_FRAME_PARMS *frame_parms, int frame, int subframe)
+{
+ int pusch_frame;
+
+ if (frame_parms->frame_type == FDD) {
+ pusch_frame = subframe<4 ? frame + 1024 - 1 : frame;
+ } else {
+ // Note this is not true, but it doesn't matter, the frame number is irrelevant for TDD!
+ pusch_frame = (frame);
+ }
+
+ //LOG_D(PHY, "frame %d subframe %d: PUSCH frame = %d\n", frame, subframe, pusch_frame);
+ return pusch_frame % 1024;
+}
+
+uint8_t phich_subframe2_pusch_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe)
+{
+ uint8_t pusch_subframe = 255;
+
+ if (frame_parms->frame_type == FDD)
+ return subframe < 4 ? subframe + 6 : subframe - 4;
+
+ switch (frame_parms->tdd_config) {
+ case 0:
+ if (subframe == 0)
+ pusch_subframe = (3);
+ else if (subframe == 5) {
+ pusch_subframe = (8);
+ } else if (subframe == 6)
+ pusch_subframe = (2);
+ else if (subframe == 1)
+ pusch_subframe = (7);
+ else {
+ 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);
+ }
+
+ break;
+
+ case 1:
+ if (subframe == 6)
+ pusch_subframe = (2);
+ else if (subframe == 9)
+ pusch_subframe = (3);
+ else if (subframe == 1)
+ pusch_subframe = (7);
+ else if (subframe == 4)
+ pusch_subframe = (8);
+ else {
+ 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);
+ }
+
+ break;
+
+ case 2:
+ if (subframe == 8)
+ pusch_subframe = (2);
+ else if (subframe == 3)
+ pusch_subframe = (7);
+ else {
+ 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);
+ }
+
+ break;
+
+ case 3:
+ if ( (subframe == 8) || (subframe == 9) ) {
+ pusch_subframe = (subframe-6);
+ } else if (subframe==0)
+ pusch_subframe = (4);
+ else {
+ 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);
+ }
+
+ break;
+
+ case 4:
+ if ( (subframe == 8) || (subframe == 9) ) {
+ pusch_subframe = (subframe-6);
+ } else {
+ 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);
+ }
+
+ break;
+
+ case 5:
+ if (subframe == 8) {
+ pusch_subframe = (2);
+ } else {
+ 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);
+ }
+
+ break;
+
+ case 6:
+ if (subframe == 6) {
+ pusch_subframe = (2);
+ } else if (subframe == 9) {
+ pusch_subframe = (3);
+ } else if (subframe == 0) {
+ pusch_subframe = (4);
+ } else if (subframe == 1) {
+ pusch_subframe = (7);
+ } else if (subframe == 5) {
+ pusch_subframe = (8);
+ } else {
+ 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);
+ }
+
+ break;
+
+ default:
+ AssertFatal(1==0, "no implementation for TDD UL/DL-config = %d!\n", frame_parms->tdd_config);
+ pusch_subframe = (0);
+ }
+
+ LOG_D(PHY, "subframe %d: PUSCH subframe = %d\n", subframe, pusch_subframe);
+ return pusch_subframe;
+}
+
+int check_pcfich(LTE_DL_FRAME_PARMS *frame_parms,uint16_t reg)
+{
+
+ if ((reg == frame_parms->pcfich_reg[0]) ||
+ (reg == frame_parms->pcfich_reg[1]) ||
+ (reg == frame_parms->pcfich_reg[2]) ||
+ (reg == frame_parms->pcfich_reg[3]))
+ return(1);
+
+ return(0);
+}
+
+void generate_phich_reg_mapping(LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+ unsigned short n0 = (frame_parms->N_RB_DL * 2) - 4; // 2 REG per RB less the 4 used by PCFICH in first symbol
+ unsigned short n1 = (frame_parms->N_RB_DL * 3); // 3 REG per RB in second and third symbol
+ unsigned short n2 = n1;
+ unsigned short mprime = 0;
+ unsigned short Ngroup_PHICH;
+ // uint16_t *phich_reg = frame_parms->phich_reg;
+ uint16_t *pcfich_reg = frame_parms->pcfich_reg;
+
+ // compute Ngroup_PHICH (see formula at beginning of Section 6.9 in 36-211
+ Ngroup_PHICH = (frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)/48;
+
+
+ if (((frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)%48) > 0)
+ Ngroup_PHICH++;
+
+ // check if Extended prefix
+ if (frame_parms->Ncp == 1) {
+ Ngroup_PHICH<<=1;
+ }
+
+#ifdef DEBUG_PHICH
+ LOG_D(PHY,"Ngroup_PHICH %d (phich_config_common.phich_resource %d,phich_config_common.phich_duration %s, NidCell %d,Ncp %d, frame_type %d), smallest pcfich REG %d, n0 %d, n1 %d (first PHICH REG %d)\n",
+ ((frame_parms->Ncp == NORMAL)?Ngroup_PHICH:(Ngroup_PHICH>>1)),
+ frame_parms->phich_config_common.phich_resource,
+ frame_parms->phich_config_common.phich_duration==normal?"normal":"extended",
+ frame_parms->Nid_cell,frame_parms->Ncp,frame_parms->frame_type,
+ pcfich_reg[frame_parms->pcfich_first_reg_idx],
+ n0,
+ n1,
+ ((frame_parms->Nid_cell))%n0);
+#endif
+
+ // This is the algorithm from Section 6.9.3 in 36-211, it works only for normal PHICH duration for now ...
+
+ for (mprime=0;
+ mprime<((frame_parms->Ncp == NORMAL)?Ngroup_PHICH:(Ngroup_PHICH>>1));
+ mprime++) {
+
+ if (frame_parms->phich_config_common.phich_duration==normal) { // normal PHICH duration
+
+ frame_parms->phich_reg[mprime][0] = (frame_parms->Nid_cell + mprime)%n0;
+
+ if (frame_parms->phich_reg[mprime][0]>=pcfich_reg[frame_parms->pcfich_first_reg_idx])
+ frame_parms->phich_reg[mprime][0]++;
+
+ if (frame_parms->phich_reg[mprime][0]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+1)&3])
+ frame_parms->phich_reg[mprime][0]++;
+
+ if (frame_parms->phich_reg[mprime][0]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+2)&3])
+ frame_parms->phich_reg[mprime][0]++;
+
+ if (frame_parms->phich_reg[mprime][0]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+3)&3])
+ frame_parms->phich_reg[mprime][0]++;
+
+ frame_parms->phich_reg[mprime][1] = (frame_parms->Nid_cell + mprime + (n0/3))%n0;
+
+
+ if (frame_parms->phich_reg[mprime][1]>=pcfich_reg[frame_parms->pcfich_first_reg_idx])
+ frame_parms->phich_reg[mprime][1]++;
+
+ if (frame_parms->phich_reg[mprime][1]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+1)&3])
+ frame_parms->phich_reg[mprime][1]++;
+
+ if (frame_parms->phich_reg[mprime][1]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+2)&3])
+ frame_parms->phich_reg[mprime][1]++;
+
+ if (frame_parms->phich_reg[mprime][1]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+3)&3])
+ frame_parms->phich_reg[mprime][1]++;
+
+
+ frame_parms->phich_reg[mprime][2] = (frame_parms->Nid_cell + mprime + (2*n0/3))%n0;
+
+ if (frame_parms->phich_reg[mprime][2]>=pcfich_reg[frame_parms->pcfich_first_reg_idx])
+ frame_parms->phich_reg[mprime][2]++;
+
+ if (frame_parms->phich_reg[mprime][2]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+1)&3])
+ frame_parms->phich_reg[mprime][2]++;
+
+ if (frame_parms->phich_reg[mprime][2]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+2)&3])
+ frame_parms->phich_reg[mprime][2]++;
+
+ if (frame_parms->phich_reg[mprime][2]>=pcfich_reg[(frame_parms->pcfich_first_reg_idx+3)&3])
+ frame_parms->phich_reg[mprime][2]++;
+
+#ifdef DEBUG_PHICH
+ printf("phich_reg :%d => %d,%d,%d\n",mprime,frame_parms->phich_reg[mprime][0],frame_parms->phich_reg[mprime][1],frame_parms->phich_reg[mprime][2]);
+#endif
+ } else { // extended PHICH duration
+ frame_parms->phich_reg[mprime<<1][0] = (frame_parms->Nid_cell + mprime)%n0;
+ frame_parms->phich_reg[1+(mprime<<1)][0] = (frame_parms->Nid_cell + mprime)%n0;
+
+ frame_parms->phich_reg[mprime<<1][1] = ((frame_parms->Nid_cell*n1/n0) + mprime + (n1/3))%n1;
+ frame_parms->phich_reg[mprime<<1][2] = ((frame_parms->Nid_cell*n2/n0) + mprime + (2*n2/3))%n2;
+
+ frame_parms->phich_reg[1+(mprime<<1)][1] = ((frame_parms->Nid_cell*n1/n0) + mprime + (n1/3))%n1;
+ frame_parms->phich_reg[1+(mprime<<1)][2] = ((frame_parms->Nid_cell*n2/n0) + mprime + (2*n2/3))%n2;
+ //#ifdef DEBUG_PHICH
+ printf("phich_reg :%d => %d,%d,%d\n",mprime<<1,frame_parms->phich_reg[mprime<<1][0],frame_parms->phich_reg[mprime][1],frame_parms->phich_reg[mprime][2]);
+ printf("phich_reg :%d => %d,%d,%d\n",1+(mprime<<1),frame_parms->phich_reg[1+(mprime<<1)][0],frame_parms->phich_reg[1+(mprime<<1)][1],frame_parms->phich_reg[1+(mprime<<1)][2]);
+ //#endif
+ }
+ } // mprime loop
+} // num_pdcch_symbols loop
+
+
+void generate_phich_emul(LTE_DL_FRAME_PARMS *frame_parms,
+ uint8_t HI,
+ uint8_t subframe)
+{
+
+
+}
+
+int32_t alam_bpsk_perm1[4] = {2,1,4,3}; // -conj(x) 1 (-1-j) -> 2 (1-j), 2->1, 3 (-1+j) -> (4) 1+j, 4->3
+int32_t alam_bpsk_perm2[4] = {3,4,2,1}; // conj(x) 1 (-1-j) -> 3 (-1+j), 3->1, 2 (1-j) -> 4 (1+j), 4->2
+
+// This routine generates the PHICH
+
+void generate_phich(LTE_DL_FRAME_PARMS *frame_parms,
+ int16_t amp,
+ uint8_t nseq_PHICH,
+ uint8_t ngroup_PHICH,
+ uint8_t HI,
+ uint8_t subframe,
+ int32_t **y)
+{
+
+ int16_t d[24],*dp;
+ // unsigned int i,aa;
+ unsigned int re_offset;
+ int16_t y0_16[8],y1_16[8];
+ int16_t *y0,*y1;
+ // scrambling
+ uint32_t x1, x2, s=0;
+ uint8_t reset = 1;
+ int16_t cs[12];
+ uint32_t i,i2,i3,m,j;
+ int16_t gain_lin_QPSK;
+ uint32_t subframe_offset=((frame_parms->Ncp==0)?14:12)*frame_parms->ofdm_symbol_size*subframe;
+
+ memset(d,0,24*sizeof(int16_t));
+
+ if (frame_parms->nb_antenna_ports_eNB==1)
+ gain_lin_QPSK = (int16_t)(((int32_t)amp*ONE_OVER_SQRT2_Q15)>>15);
+ else
+ gain_lin_QPSK = amp/2;
+
+ //printf("PHICH : gain_lin_QPSK %d\n",gain_lin_QPSK);
+
+ // BPSK modulation of HI input (to be repeated 3 times, 36-212 Section 5.3.5, p. 56 in v8.6)
+ if (HI>0)
+ HI=1;
+
+
+ // c = (1-(2*HI))*SSS_AMP;
+ // x1 is set in lte_gold_generic
+ x2 = (((subframe+1)*((frame_parms->Nid_cell<<1)+1))<<9) + frame_parms->Nid_cell;
+
+ s = lte_gold_generic(&x1, &x2, reset);
+
+ // compute scrambling sequence
+ for (i=0; i<12; i++) {
+ cs[i] = (uint8_t)((s>>(i&0x1f))&1);
+ cs[i] = (cs[i] == 0) ? (1-(HI<<1)) : ((HI<<1)-1);
+ }
+
+ if (frame_parms->Ncp == 0) { // Normal Cyclic Prefix
+
+ // printf("Doing PHICH : Normal CP, subframe %d\n",subframe);
+ // 12 output symbols (Msymb)
+ for (i=0,i2=0,i3=0; i<3; i++,i2+=4,i3+=8) {
+ switch (nseq_PHICH) {
+ case 0: // +1 +1 +1 +1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[3+i3] = cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[5+i3] = cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ d[7+i3] = cs[3+i2];
+ break;
+
+ case 1: // +1 -1 +1 -1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[3+i3] = -cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[5+i3] = cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ d[7+i3] = -cs[3+i2];
+ break;
+
+ case 2: // +1 +1 -1 -1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[3+i3] = cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[5+i3] = -cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ d[7+i3] = -cs[3+i2];
+ break;
+
+ case 3: // +1 -1 -1 +1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[3+i3] = -cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[5+i3] = -cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ d[7+i3] = cs[3+i2];
+ break;
+
+ case 4: // +j +j +j +j
+ d[i3] = -cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[3+i3] = cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[5+i3] = cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ d[7+i3] = cs[3+i2];
+ break;
+
+ case 5: // +j -j +j -j
+ d[1+i3] = cs[i2];
+ d[3+i3] = -cs[1+i2];
+ d[5+i3] = cs[2+i2];
+ d[7+i3] = -cs[3+i2];
+ d[i3] = -cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ break;
+
+ case 6: // +j +j -j -j
+ d[1+i3] = cs[i2];
+ d[3+i3] = cs[1+i2];
+ d[5+i3] = -cs[2+i2];
+ d[7+i3] = -cs[3+i2];
+ d[i3] = -cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ break;
+
+ case 7: // +j -j -j +j
+ d[1+i3] = cs[i2];
+ d[3+i3] = -cs[1+i2];
+ d[5+i3] = -cs[2+i2];
+ d[7+i3] = cs[3+i2];
+ d[i3] = -cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ break;
+
+ default:
+ AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
+ } // nseq_PHICH
+ }
+
+#ifdef DEBUG_PHICH
+ LOG_D(PHY,"[PUSCH 0]PHICH d = ");
+
+ for (i=0; i<24; i+=2)
+ LOG_D(PHY,"(%d,%d)",d[i],d[i+1]);
+
+ LOG_D(PHY,"\n");
+#endif
+
+ // modulation here
+ if (frame_parms->nb_antenna_ports_eNB != 1) {
+ // do Alamouti precoding here
+
+ // Symbol 0
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][0]*6);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+ y1 = (int16_t*)&y[1][re_offset+subframe_offset];
+
+ // first antenna position n -> x0
+ y0_16[0] = d[0]*gain_lin_QPSK;
+ y0_16[1] = d[1]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[0] = -d[2]*gain_lin_QPSK;
+ y1_16[1] = d[3]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[2] = -y1_16[0];
+ y0_16[3] = y1_16[1];
+ y1_16[2] = y0_16[0];
+ y1_16[3] = -y0_16[1];
+
+ // first antenna position n -> x0
+ y0_16[4] = d[4]*gain_lin_QPSK;
+ y0_16[5] = d[5]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[4] = -d[6]*gain_lin_QPSK;
+ y1_16[5] = d[7]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[6] = -y1_16[4];
+ y0_16[7] = y1_16[5];
+ y1_16[6] = y0_16[4];
+ y1_16[7] = -y0_16[5];
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m];
+ y1[j] += y1_16[m++];
+ y0[j+1] += y0_16[m];
+ y1[j+1] += y1_16[m++];
+ }
+ }
+
+ // Symbol 1
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][1]*6);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+ y1 = (int16_t*)&y[1][re_offset+subframe_offset];
+
+ // first antenna position n -> x0
+ y0_16[0] = d[8]*gain_lin_QPSK;
+ y0_16[1] = d[9]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[0] = -d[10]*gain_lin_QPSK;
+ y1_16[1] = d[11]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[2] = -y1_16[0];
+ y0_16[3] = y1_16[1];
+ y1_16[2] = y0_16[0];
+ y1_16[3] = -y0_16[1];
+
+ // first antenna position n -> x0
+ y0_16[4] = d[12]*gain_lin_QPSK;
+ y0_16[5] = d[13]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[4] = -d[14]*gain_lin_QPSK;
+ y1_16[5] = d[15]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[6] = -y1_16[4];
+ y0_16[7] = y1_16[5];
+ y1_16[6] = y0_16[4];
+ y1_16[7] = -y0_16[5];
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m];
+ y1[j] += y1_16[m++];
+ y0[j+1] += y0_16[m];
+ y1[j+1] += y1_16[m++];
+ }
+ }
+
+ // Symbol 2
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][2]*6);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+ y1 = (int16_t*)&y[1][re_offset+subframe_offset];
+
+ // first antenna position n -> x0
+ y0_16[0] = d[16]*gain_lin_QPSK;
+ y0_16[1] = d[17]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[0] = -d[18]*gain_lin_QPSK;
+ y1_16[1] = d[19]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[2] = -y1_16[0];
+ y0_16[3] = y1_16[1];
+ y1_16[2] = y0_16[0];
+ y1_16[3] = -y0_16[1];
+
+ // first antenna position n -> x0
+ y0_16[4] = d[20]*gain_lin_QPSK;
+ y0_16[5] = d[21]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[4] = -d[22]*gain_lin_QPSK;
+ y1_16[5] = d[23]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[6] = -y1_16[4];
+ y0_16[7] = y1_16[5];
+ y1_16[6] = y0_16[4];
+ y1_16[7] = -y0_16[5];
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m];
+ y1[j] += y1_16[m++];
+ y0[j+1] += y0_16[m];
+ y1[j+1] += y1_16[m++];
+ }
+ }
+
+ } // nb_antenna_ports_eNB
+
+ else {
+ // Symbol 0
+ // printf("[PUSCH 0]PHICH REG %d\n",frame_parms->phich_reg[ngroup_PHICH][0]);
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][0]*6);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+ // printf("y0 %p\n",y0);
+
+ y0_16[0] = d[0]*gain_lin_QPSK;
+ y0_16[1] = d[1]*gain_lin_QPSK;
+ y0_16[2] = d[2]*gain_lin_QPSK;
+ y0_16[3] = d[3]*gain_lin_QPSK;
+ y0_16[4] = d[4]*gain_lin_QPSK;
+ y0_16[5] = d[5]*gain_lin_QPSK;
+ y0_16[6] = d[6]*gain_lin_QPSK;
+ y0_16[7] = d[7]*gain_lin_QPSK;
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m++];
+ y0[j+1] += y0_16[m++];
+ }
+ }
+
+ // Symbol 1
+ // printf("[PUSCH 0]PHICH REG %d\n",frame_parms->phich_reg[ngroup_PHICH][1]);
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][1]*6);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+
+ y0_16[0] = d[8]*gain_lin_QPSK;
+ y0_16[1] = d[9]*gain_lin_QPSK;
+ y0_16[2] = d[10]*gain_lin_QPSK;
+ y0_16[3] = d[11]*gain_lin_QPSK;
+ y0_16[4] = d[12]*gain_lin_QPSK;
+ y0_16[5] = d[13]*gain_lin_QPSK;
+ y0_16[6] = d[14]*gain_lin_QPSK;
+ y0_16[7] = d[15]*gain_lin_QPSK;
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m++];
+ y0[j+1] += y0_16[m++];
+ }
+ }
+
+ // Symbol 2
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][2]*6);
+
+ // printf("[PUSCH 0]PHICH REG %d\n",frame_parms->phich_reg[ngroup_PHICH][2]);
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+
+ y0_16[0] = d[16]*gain_lin_QPSK;
+ y0_16[1] = d[17]*gain_lin_QPSK;
+ y0_16[2] = d[18]*gain_lin_QPSK;
+ y0_16[3] = d[19]*gain_lin_QPSK;
+ y0_16[4] = d[20]*gain_lin_QPSK;
+ y0_16[5] = d[21]*gain_lin_QPSK;
+ y0_16[6] = d[22]*gain_lin_QPSK;
+ y0_16[7] = d[23]*gain_lin_QPSK;
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m++];
+ y0[j+1] += y0_16[m++];
+ }
+ }
+
+ /*
+ for (i=0;i<512;i++)
+ printf("re %d (%d): %d,%d\n",i,subframe_offset+i,((int16_t*)&y[0][subframe_offset+i])[0],((int16_t*)&y[0][subframe_offset+i])[1]);
+ */
+ } // nb_antenna_ports_eNB
+ } else { // extended prefix
+
+ // 6 output symbols
+ if ((ngroup_PHICH & 1) == 1)
+ dp = &d[4];
+ else
+ dp = d;
+
+ switch (nseq_PHICH) {
+ case 0: // +1 +1
+ dp[0] = cs[0];
+ dp[2] = cs[1];
+ dp[8] = cs[2];
+ dp[10] = cs[3];
+ dp[16] = cs[4];
+ dp[18] = cs[5];
+ dp[1] = cs[0];
+ dp[3] = cs[1];
+ dp[9] = cs[2];
+ dp[11] = cs[3];
+ dp[17] = cs[4];
+ dp[19] = cs[5];
+ break;
+
+ case 1: // +1 -1
+ dp[0] = cs[0];
+ dp[2] = -cs[1];
+ dp[8] = cs[2];
+ dp[10] = -cs[3];
+ dp[16] = cs[4];
+ dp[18] = -cs[5];
+ dp[1] = cs[0];
+ dp[3] = -cs[1];
+ dp[9] = cs[2];
+ dp[11] = -cs[3];
+ dp[17] = cs[4];
+ dp[19] = -cs[5];
+ break;
+
+ case 2: // +j +j
+ dp[1] = cs[0];
+ dp[3] = cs[1];
+ dp[9] = cs[2];
+ dp[11] = cs[3];
+ dp[17] = cs[4];
+ dp[19] = cs[5];
+ dp[0] = -cs[0];
+ dp[2] = -cs[1];
+ dp[8] = -cs[2];
+ dp[10] = -cs[3];
+ dp[16] = -cs[4];
+ dp[18] = -cs[5];
+
+ break;
+
+ case 3: // +j -j
+ dp[1] = cs[0];
+ dp[3] = -cs[1];
+ dp[9] = cs[2];
+ dp[11] = -cs[3];
+ dp[17] = cs[4];
+ dp[19] = -cs[5];
+ dp[0] = -cs[0];
+ dp[2] = cs[1];
+ dp[8] = -cs[2];
+ dp[10] = cs[3];
+ dp[16] = -cs[4];
+ dp[18] = cs[5];
+ break;
+
+ default:
+ AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
+ }
+
+
+
+ if (frame_parms->nb_antenna_ports_eNB != 1) {
+ // do Alamouti precoding here
+ // Symbol 0
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][0]*6);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+ y1 = (int16_t*)&y[1][re_offset+subframe_offset];
+
+ // first antenna position n -> x0
+ y0_16[0] = d[0]*gain_lin_QPSK;
+ y0_16[1] = d[1]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[0] = -d[2]*gain_lin_QPSK;
+ y1_16[1] = d[3]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[2] = -y1_16[0];
+ y0_16[3] = y1_16[1];
+ y1_16[2] = y0_16[0];
+ y1_16[3] = -y0_16[1];
+
+ // first antenna position n -> x0
+ y0_16[4] = d[4]*gain_lin_QPSK;
+ y0_16[5] = d[5]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[4] = -d[6]*gain_lin_QPSK;
+ y1_16[5] = d[7]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[6] = -y1_16[4];
+ y0_16[7] = y1_16[5];
+ y1_16[6] = y0_16[4];
+ y1_16[7] = -y0_16[5];
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m];
+ y1[j] += y1_16[m++];
+ y0[j+1] += y0_16[m];
+ y1[j+1] += y1_16[m++];
+ }
+ }
+
+ // Symbol 1
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][1]<<2);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ re_offset += (frame_parms->ofdm_symbol_size);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+ y1 = (int16_t*)&y[1][re_offset+subframe_offset];
+
+ // first antenna position n -> x0
+ y0_16[0] = d[8]*gain_lin_QPSK;
+ y0_16[1] = d[9]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[0] = -d[10]*gain_lin_QPSK;
+ y1_16[1] = d[11]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[2] = -y1_16[0];
+ y0_16[3] = y1_16[1];
+ y1_16[2] = y0_16[0];
+ y1_16[3] = -y0_16[1];
+
+ // first antenna position n -> x0
+ y0_16[4] = d[12]*gain_lin_QPSK;
+ y0_16[5] = d[13]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[4] = -d[14]*gain_lin_QPSK;
+ y1_16[5] = d[15]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[6] = -y1_16[4];
+ y0_16[7] = y1_16[5];
+ y1_16[6] = y0_16[4];
+ y1_16[7] = -y0_16[5];
+
+ for (i=0,j=0,m=0; i<4; i++,j+=2) {
+ y0[j] += y0_16[m];
+ y1[j] += y1_16[m++];
+ y0[j+1] += y0_16[m];
+ y1[j+1] += y1_16[m++];
+ }
+
+ // Symbol 2
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][2]<<2);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ re_offset += (frame_parms->ofdm_symbol_size<<1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+ y1 = (int16_t*)&y[1][re_offset+subframe_offset];
+
+ // first antenna position n -> x0
+ y0_16[0] = d[16]*gain_lin_QPSK;
+ y0_16[1] = d[17]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[0] = -d[18]*gain_lin_QPSK;
+ y1_16[1] = d[19]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[2] = -y1_16[0];
+ y0_16[3] = y1_16[1];
+ y1_16[2] = y0_16[0];
+ y1_16[3] = -y0_16[1];
+
+ // first antenna position n -> x0
+ y0_16[4] = d[20]*gain_lin_QPSK;
+ y0_16[5] = d[21]*gain_lin_QPSK;
+ // second antenna position n -> -x1*
+ y1_16[4] = -d[22]*gain_lin_QPSK;
+ y1_16[5] = d[23]*gain_lin_QPSK;
+ // fill in the rest of the ALAMOUTI precoding
+ y0_16[6] = -y1_16[4];
+ y0_16[7] = y1_16[5];
+ y1_16[6] = y0_16[4];
+ y1_16[7] = -y0_16[5];
+
+ for (i=0,j=0,m=0; i<4; i++,j+=2) {
+ y0[j] += y0_16[m];
+ y1[j] += y1_16[m++];
+ y0[j+1] += y0_16[m];
+ y1[j+1] += y1_16[m++];
+ }
+ } else {
+
+ // Symbol 0
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][0]*6);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+
+ y0_16[0] = d[0]*gain_lin_QPSK;
+ y0_16[1] = d[1]*gain_lin_QPSK;
+ y0_16[2] = d[2]*gain_lin_QPSK;
+ y0_16[3] = d[3]*gain_lin_QPSK;
+ y0_16[4] = d[4]*gain_lin_QPSK;
+ y0_16[5] = d[5]*gain_lin_QPSK;
+ y0_16[6] = d[6]*gain_lin_QPSK;
+ y0_16[7] = d[7]*gain_lin_QPSK;
+
+ for (i=0,j=0,m=0; i<6; i++,j+=2) {
+ if ((i!=(frame_parms->nushift))&&(i!=(frame_parms->nushift+3))) {
+ y0[j] += y0_16[m++];
+ y0[j+1] += y0_16[m++];
+ }
+ }
+
+ // Symbol 1
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][1]<<2);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ re_offset += (frame_parms->ofdm_symbol_size);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+
+ y0_16[0] = d[8]*gain_lin_QPSK;
+ y0_16[1] = d[9]*gain_lin_QPSK;
+ y0_16[2] = d[10]*gain_lin_QPSK;
+ y0_16[3] = d[11]*gain_lin_QPSK;
+ y0_16[4] = d[12]*gain_lin_QPSK;
+ y0_16[5] = d[13]*gain_lin_QPSK;
+ y0_16[6] = d[14]*gain_lin_QPSK;
+ y0_16[7] = d[15]*gain_lin_QPSK;
+
+ for (i=0,j=0,m=0; i<4; i++,j+=2) {
+ y0[j] += y0_16[m++];
+ y0[j+1] += y0_16[m++];
+ }
+
+
+ // Symbol 2
+ re_offset = frame_parms->first_carrier_offset + (frame_parms->phich_reg[ngroup_PHICH][2]<<2);
+
+ if (re_offset > frame_parms->ofdm_symbol_size)
+ re_offset -= (frame_parms->ofdm_symbol_size-1);
+
+ re_offset += (frame_parms->ofdm_symbol_size<<1);
+
+ y0 = (int16_t*)&y[0][re_offset+subframe_offset];
+
+ y0_16[0] = d[16]*gain_lin_QPSK;
+ y0_16[1] = d[17]*gain_lin_QPSK;
+ y0_16[2] = d[18]*gain_lin_QPSK;
+ y0_16[3] = d[19]*gain_lin_QPSK;
+ y0_16[4] = d[20]*gain_lin_QPSK;
+ y0_16[5] = d[21]*gain_lin_QPSK;
+ y0_16[6] = d[22]*gain_lin_QPSK;
+ y0_16[7] = d[23]*gain_lin_QPSK;
+
+ for (i=0,j=0,m=0; i<4; i++) {
+ y0[j] += y0_16[m++];
+ y0[j+1] += y0_16[m++];
+ }
+
+ } // nb_antenna_ports_eNB
+ } // normal/extended prefix
+}
+
+// This routine demodulates the PHICH and updates PUSCH/ULSCH parameters
+
+void rx_phich(PHY_VARS_UE *ue,
+ UE_rxtx_proc_t *proc,
+ uint8_t subframe,
+ uint8_t eNB_id)
+{
+
+
+ LTE_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
+ LTE_UE_PDCCH **pdcch_vars = &ue->pdcch_vars[ue->current_thread_id[subframe]][eNB_id];
+
+ // uint8_t HI;
+ uint8_t harq_pid = phich_subframe_to_harq_pid(frame_parms,proc->frame_rx,subframe);
+ LTE_UE_ULSCH_t *ulsch = ue->ulsch[eNB_id];
+ int16_t phich_d[24],*phich_d_ptr,HI16;
+ // unsigned int i,aa;
+ int8_t d[24],*dp;
+ uint16_t reg_offset;
+
+ // scrambling
+ uint32_t x1, x2, s=0;
+ uint8_t reset = 1;
+ int16_t cs[12];
+ uint32_t i,i2,i3,phich_quad;
+ int32_t **rxdataF_comp = pdcch_vars[eNB_id]->rxdataF_comp;
+ uint8_t Ngroup_PHICH,ngroup_PHICH,nseq_PHICH;
+ uint8_t NSF_PHICH = 4;
+ uint8_t pusch_subframe;
+
+ int8_t delta_PUSCH_acc[4] = {-1,0,1,3};
+
+ // check if we're expecting a PHICH in this subframe
+ LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH RX\n",ue->Mod_id,harq_pid,proc->frame_rx,subframe);
+
+ if (!ulsch)
+ return;
+
+ LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH RX Status: %d \n",ue->Mod_id,harq_pid,proc->frame_rx,subframe, ulsch->harq_processes[harq_pid]->status);
+
+ if (ulsch->harq_processes[harq_pid]->status == ACTIVE) {
+ LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH RX ACTIVE\n",ue->Mod_id,harq_pid,proc->frame_rx,subframe);
+ Ngroup_PHICH = (frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)/48;
+
+ if (((frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)%48) > 0)
+ Ngroup_PHICH++;
+
+ if (frame_parms->Ncp == 1)
+ NSF_PHICH = 2;
+
+
+ ngroup_PHICH = (ulsch->harq_processes[harq_pid]->first_rb +
+ ulsch->harq_processes[harq_pid]->n_DMRS)%Ngroup_PHICH;
+
+ if ((frame_parms->tdd_config == 0) && (frame_parms->frame_type == TDD) ) {
+ pusch_subframe = phich_subframe2_pusch_subframe(frame_parms,subframe);
+
+ if ((pusch_subframe == 4) || (pusch_subframe == 9))
+ ngroup_PHICH += Ngroup_PHICH;
+ }
+
+ nseq_PHICH = ((ulsch->harq_processes[harq_pid]->first_rb/Ngroup_PHICH) +
+ ulsch->harq_processes[harq_pid]->n_DMRS)%(2*NSF_PHICH);
+ } else {
+ LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH RX %s\n",
+ ue->Mod_id,
+ harq_pid,
+ proc->frame_rx,
+ subframe,
+ (ulsch->harq_processes[harq_pid]->status==SCH_IDLE? "SCH_IDLE" :
+ (ulsch->harq_processes[harq_pid]->status==ACTIVE? "ACTIVE" :
+ (ulsch->harq_processes[harq_pid]->status==CBA_ACTIVE? "CBA_ACTIVE":
+ (ulsch->harq_processes[harq_pid]->status==DISABLED? "DISABLED" : "UNKNOWN")))));
+
+ return;
+ }
+
+ memset(d,0,24*sizeof(int8_t));
+ phich_d_ptr = phich_d;
+
+ // x1 is set in lte_gold_generic
+ x2 = (((subframe+1)*((frame_parms->Nid_cell<<1)+1))<<9) + frame_parms->Nid_cell;
+
+ s = lte_gold_generic(&x1, &x2, reset);
+
+ // compute scrambling sequence
+ for (i=0; i<12; i++) {
+ cs[i] = 1-(((s>>(i&0x1f))&1)<<1);
+ }
+
+ if (frame_parms->Ncp == 0) { // Normal Cyclic Prefix
+
+
+ // 12 output symbols (Msymb)
+
+ for (i=0,i2=0,i3=0; i<3; i++,i2+=4,i3+=8) {
+ switch (nseq_PHICH) {
+ case 0: // +1 +1 +1 +1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[3+i3] = cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[5+i3] = cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ d[7+i3] = cs[3+i2];
+ break;
+
+ case 1: // +1 -1 +1 -1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[3+i3] = -cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[5+i3] = cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ d[7+i3] = -cs[3+i2];
+ break;
+
+ case 2: // +1 +1 -1 -1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[3+i3] = cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[5+i3] = -cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ d[7+i3] = -cs[3+i2];
+ break;
+
+ case 3: // +1 -1 -1 +1
+ d[i3] = cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[3+i3] = -cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[5+i3] = -cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ d[7+i3] = cs[3+i2];
+ break;
+
+ case 4: // +j +j +j +j
+ d[i3] = -cs[i2];
+ d[1+i3] = cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[3+i3] = cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[5+i3] = cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ d[7+i3] = cs[3+i2];
+ break;
+
+ case 5: // +j -j +j -j
+ d[1+i3] = cs[i2];
+ d[3+i3] = -cs[1+i2];
+ d[5+i3] = cs[2+i2];
+ d[7+i3] = -cs[3+i2];
+ d[i3] = -cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[4+i3] = -cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ break;
+
+ case 6: // +j +j -j -j
+ d[1+i3] = cs[i2];
+ d[3+i3] = cs[1+i2];
+ d[5+i3] = -cs[2+i2];
+ d[7+i3] = -cs[3+i2];
+ d[i3] = -cs[i2];
+ d[2+i3] = -cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[6+i3] = cs[3+i2];
+ break;
+
+ case 7: // +j -j -j +j
+ d[1+i3] = cs[i2];
+ d[3+i3] = -cs[1+i2];
+ d[5+i3] = -cs[2+i2];
+ d[7+i3] = cs[3+i2];
+ d[i3] = -cs[i2];
+ d[2+i3] = cs[1+i2];
+ d[4+i3] = cs[2+i2];
+ d[6+i3] = -cs[3+i2];
+ break;
+
+ default:
+ AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
+ } // nseq_PHICH
+ }
+
+#ifdef DEBUG_PHICH
+ LOG_D(PHY,"PHICH =>");
+
+ for (i=0; i<24; i++) {
+ LOG_D(PHY,"%2d,",d[i]);
+ }
+
+ LOG_D(PHY,"\n");
+#endif
+ // demodulation here
+
+
+ } else { // extended prefix
+
+ // 6 output symbols
+ if ((ngroup_PHICH & 1) == 1)
+ dp = &d[4];
+ else
+ dp = d;
+
+ switch (nseq_PHICH) {
+ case 0: // +1 +1
+ dp[0] = cs[0];
+ dp[2] = cs[1];
+ dp[8] = cs[2];
+ dp[10] = cs[3];
+ dp[16] = cs[4];
+ dp[18] = cs[5];
+ dp[1] = cs[0];
+ dp[3] = cs[1];
+ dp[9] = cs[2];
+ dp[11] = cs[3];
+ dp[17] = cs[4];
+ dp[19] = cs[5];
+ break;
+
+ case 1: // +1 -1
+ dp[0] = cs[0];
+ dp[2] = -cs[1];
+ dp[8] = cs[2];
+ dp[10] = -cs[3];
+ dp[16] = cs[4];
+ dp[18] = -cs[5];
+ dp[1] = cs[0];
+ dp[3] = -cs[1];
+ dp[9] = cs[2];
+ dp[11] = -cs[3];
+ dp[17] = cs[4];
+ dp[19] = -cs[5];
+ break;
+
+ case 2: // +j +j
+ dp[1] = cs[0];
+ dp[3] = cs[1];
+ dp[9] = cs[2];
+ dp[11] = cs[3];
+ dp[17] = cs[4];
+ dp[19] = cs[5];
+ dp[0] = -cs[0];
+ dp[2] = -cs[1];
+ dp[8] = -cs[2];
+ dp[10] = -cs[3];
+ dp[16] = -cs[4];
+ dp[18] = -cs[5];
+
+ break;
+
+ case 3: // +j -j
+ dp[1] = cs[0];
+ dp[3] = -cs[1];
+ dp[9] = cs[2];
+ dp[11] = -cs[3];
+ dp[17] = cs[4];
+ dp[19] = -cs[5];
+ dp[0] = -cs[0];
+ dp[2] = cs[1];
+ dp[8] = -cs[2];
+ dp[10] = cs[3];
+ dp[16] = -cs[4];
+ dp[18] = cs[5];
+ break;
+
+ default:
+ AssertFatal(1==0,"phich_coding.c: Illegal PHICH Number\n");
+ }
+ }
+
+ HI16 = 0;
+
+ //#ifdef DEBUG_PHICH
+
+ //#endif
+ /*
+ for (i=0;i<200;i++)
+ printf("re %d: %d %d\n",i,((int16_t*)&rxdataF_comp[0][i])[0],((int16_t*)&rxdataF_comp[0][i])[1]);
+ */
+ for (phich_quad=0; phich_quad<3; phich_quad++) {
+ if (frame_parms->Ncp == 1)
+ reg_offset = (frame_parms->phich_reg[ngroup_PHICH][phich_quad]*4)+ (phich_quad*frame_parms->N_RB_DL*12);
+ else
+ reg_offset = (frame_parms->phich_reg[ngroup_PHICH][phich_quad]*4);
+
+ // msg("\n[PUSCH 0]PHICH (RX) quad %d (%d)=>",phich_quad,reg_offset);
+ dp = &d[phich_quad*8];;
+
+ for (i=0; i<8; i++) {
+ phich_d_ptr[i] = ((int16_t*)&rxdataF_comp[0][reg_offset])[i];
+
+#ifdef DEBUG_PHICH
+ LOG_D(PHY,"%d,",((int16_t*)&rxdataF_comp[0][reg_offset])[i]);
+#endif
+
+ HI16 += (phich_d_ptr[i] * dp[i]);
+ }
+ }
+
+#ifdef DEBUG_PHICH
+ LOG_D(PHY,"\n");
+ LOG_D(PHY,"HI16 %d\n",HI16);
+#endif
+
+ if (HI16>0) { //NACK
+ if (ue->ulsch_Msg3_active[eNB_id] == 1) {
+ LOG_D(PHY,"[UE %d][PUSCH %d][RAPROC] Frame %d subframe %d Msg3 PHICH, received NAK (%d) nseq %d, ngroup %d\n",
+ ue->Mod_id,harq_pid,
+ proc->frame_rx,
+ subframe,
+ HI16,
+ nseq_PHICH,
+ ngroup_PHICH);
+
+ ulsch->f_pusch += delta_PUSCH_acc[ulsch->harq_processes[harq_pid]->TPC];
+
+ LOG_D(PHY,"[PUSCH %d] AbsSubframe %d.%d: f_pusch (ACC) %d, adjusting by %d (TPC %d)\n",
+ harq_pid,proc->frame_rx,subframe,ulsch->f_pusch,
+ delta_PUSCH_acc[ulsch->harq_processes[harq_pid]->TPC],
+ ulsch->harq_processes[harq_pid]->TPC);
+
+
+ ulsch->harq_processes[harq_pid]->subframe_scheduling_flag = 1;
+ // ulsch->harq_processes[harq_pid]->Ndi = 0;
+ ulsch->harq_processes[harq_pid]->round++;
+ ulsch->harq_processes[harq_pid]->rvidx = rv_table[ulsch->harq_processes[harq_pid]->round&3];
+
+ if (ulsch->harq_processes[harq_pid]->round>=ue->frame_parms.maxHARQ_Msg3Tx) {
+ ulsch->harq_processes[harq_pid]->subframe_scheduling_flag =0;
+ ulsch->harq_processes[harq_pid]->status = SCH_IDLE;
+ // inform MAC that Msg3 transmission has failed
+ ue->ulsch_Msg3_active[eNB_id] = 0;
+ }
+ } else {
+#ifdef UE_DEBUG_TRACE
+ LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH, received NAK (%d) nseq %d, ngroup %d round %d (Mlimit %d)\n",
+ ue->Mod_id,harq_pid,
+ proc->frame_rx%1024,
+ subframe,
+ HI16,
+ nseq_PHICH,
+ ngroup_PHICH,
+ ulsch->harq_processes[harq_pid]->round,
+ ulsch->Mlimit);
+#endif
+
+ // ulsch->harq_processes[harq_pid]->Ndi = 0;
+ ulsch->harq_processes[harq_pid]->round++;
+
+ if ( ulsch->harq_processes[harq_pid]->round >= (ulsch->Mlimit - 1) )
+ {
+ // this is last push re transmission
+ ulsch->harq_processes[harq_pid]->rvidx = rv_table[ulsch->harq_processes[harq_pid]->round&3];
+ ulsch->O_RI = 0;
+ ulsch->O = 0;
+ ulsch->uci_format = HLC_subband_cqi_nopmi;
+
+ // disable phich decoding since it is the last retransmission
+ ulsch->harq_processes[harq_pid]->status = SCH_IDLE;
+
+ //ulsch->harq_processes[harq_pid]->subframe_scheduling_flag = 0;
+ //ulsch->harq_processes[harq_pid]->round = 0;
+
+ //LOG_I(PHY,"PUSCH MAX Retransmission acheived ==> flush harq buff (%d) \n",harq_pid);
+ //LOG_I(PHY,"[HARQ-UL harqId: %d] PHICH NACK MAX RETRANS(%d) ==> subframe_scheduling_flag = %d round: %d\n", harq_pid, ulsch->Mlimit, ulsch->harq_processes[harq_pid]->subframe_scheduling_flag, ulsch->harq_processes[harq_pid]->round);
+ }
+ else
+ {
+ // ulsch->harq_processes[harq_pid]->subframe_scheduling_flag = 1;
+ ulsch->harq_processes[harq_pid]->rvidx = rv_table[ulsch->harq_processes[harq_pid]->round&3];
+ ulsch->O_RI = 0;
+ ulsch->O = 0;
+ ulsch->uci_format = HLC_subband_cqi_nopmi;
+ //LOG_I(PHY,"[HARQ-UL harqId: %d] PHICH NACK ==> subframe_scheduling_flag = %d round: %d\n", harq_pid, ulsch->harq_processes[harq_pid]->subframe_scheduling_flag,ulsch->harq_processes[harq_pid]->round);
+ }
+ }
+#if T_TRACER
+ T(T_UE_PHY_ULSCH_UE_NACK, T_INT(eNB_id), T_INT(proc->frame_rx%1024), T_INT(subframe), T_INT(ulsch->rnti),
+ T_INT(harq_pid));
+#endif
+
+ } else { //ACK
+ if (ue->ulsch_Msg3_active[eNB_id] == 1) {
+ LOG_D(PHY,"[UE %d][PUSCH %d][RAPROC] Frame %d subframe %d Msg3 PHICH, received ACK (%d) nseq %d, ngroup %d\n\n",
+ ue->Mod_id,harq_pid,
+ proc->frame_rx,
+ subframe,
+ HI16,
+ nseq_PHICH,ngroup_PHICH);
+ } else {
+#ifdef UE_DEBUG_TRACE
+ LOG_D(PHY,"[UE %d][PUSCH %d] Frame %d subframe %d PHICH, received ACK (%d) nseq %d, ngroup %d\n\n",
+ ue->Mod_id,harq_pid,
+ proc->frame_rx%1024,
+ subframe, HI16,
+ nseq_PHICH,ngroup_PHICH);
+#endif
+ }
+
+ // LOG_I(PHY,"[HARQ-UL harqId: %d] subframe_scheduling_flag = %d \n",harq_pid, ulsch->harq_processes[harq_pid]->subframe_scheduling_flag);
+
+ // Incase of adaptive retransmission, PHICH is always decoded as ACK (at least with OAI-eNB)
+ // Workaround:
+ // rely only on DCI0 decoding and check if NDI has toggled
+ // save current harq_processes content in temporary struct
+ // harqId-8 corresponds to the temporary struct. In total we have 8 harq process(0 ..7) + 1 temporary harq process()
+ //ulsch->harq_processes[8] = ulsch->harq_processes[harq_pid];
+
+
+ ulsch->harq_processes[harq_pid]->status = SCH_IDLE;
+ ulsch->harq_processes[harq_pid]->round = 0;
+ ulsch->harq_processes[harq_pid]->subframe_scheduling_flag = 0;
+ // inform MAC?
+ ue->ulsch_Msg3_active[eNB_id] = 0;
+
+#if T_TRACER
+ T(T_UE_PHY_ULSCH_UE_ACK, T_INT(eNB_id), T_INT(proc->frame_rx%1024), T_INT(subframe), T_INT(ulsch->rnti),
+ T_INT(harq_pid));
+#endif
+
+ }
+
+}
+
+void generate_phich_top(PHY_VARS_eNB *eNB,
+ eNB_rxtx_proc_t *proc,
+ int16_t amp)
+{
+
+
+ LTE_DL_FRAME_PARMS *frame_parms=&eNB->frame_parms;
+ int32_t **txdataF = eNB->common_vars.txdataF;
+ uint8_t harq_pid;
+ uint8_t Ngroup_PHICH,ngroup_PHICH,nseq_PHICH;
+ uint8_t NSF_PHICH = 4;
+ uint8_t pusch_subframe;
+ uint8_t i;
+ uint32_t pusch_frame;
+ int subframe = proc->subframe_tx;
+ phich_config_t *phich;
+
+ // compute Ngroup_PHICH (see formula at beginning of Section 6.9 in 36-211
+
+ Ngroup_PHICH = (frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)/48;
+
+ if (((frame_parms->phich_config_common.phich_resource*frame_parms->N_RB_DL)%48) > 0)
+ Ngroup_PHICH++;
+
+ if (frame_parms->Ncp == 1)
+ NSF_PHICH = 2;
+
+ 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++) {
+
+ phich = &eNB->phich_vars[subframe&1].config[i];
+
+ ngroup_PHICH = (phich->first_rb +
+ phich->n_DMRS)%Ngroup_PHICH;
+
+ if ((frame_parms->tdd_config == 0) && (frame_parms->frame_type == TDD) ) {
+
+ if ((pusch_subframe == 4) || (pusch_subframe == 9))
+ ngroup_PHICH += Ngroup_PHICH;
+ }
+
+ nseq_PHICH = ((phich->first_rb/Ngroup_PHICH) +
+ phich->n_DMRS)%(2*NSF_PHICH);
+ LOG_D(PHY,"[eNB %d][PUSCH %d] Frame %d subframe %d Generating PHICH, AMP %d ngroup_PHICH %d/%d, nseq_PHICH %d : HI %d, first_rb %d)\n",
+ eNB->Mod_id,harq_pid,proc->frame_tx,
+ subframe,amp,ngroup_PHICH,Ngroup_PHICH,nseq_PHICH,
+ phich->hi,
+ phich->first_rb);
+
+ T(T_ENB_PHY_PHICH, T_INT(eNB->Mod_id), T_INT(proc->frame_tx), T_INT(subframe),
+ T_INT(-1 /* TODO: rnti */), T_INT(harq_pid),
+ T_INT(Ngroup_PHICH), T_INT(NSF_PHICH),
+ T_INT(ngroup_PHICH), T_INT(nseq_PHICH),
+ T_INT(phich->hi),
+ T_INT(phich->first_rb),
+ T_INT(phich->n_DMRS));
+
+ generate_phich(frame_parms,
+ amp,//amp*2,
+ nseq_PHICH,
+ ngroup_PHICH,
+ phich->hi,
+ subframe,
+ txdataF);
+ }// for (i=0; i<eNB->phich_vars[subframe&1].num_hi; i++) {
+ eNB->phich_vars[subframe&1].num_hi=0;
+}
diff --git a/openair1/PHY/LTE_UE_TRANSPORT/pmch_ue.c b/openair1/PHY/LTE_UE_TRANSPORT/pmch_ue.c
new file mode 100644
index 0000000000000000000000000000000000000000..e756df1fe1a5b4fd4612d0f019bca3bd57c7a64f
--- /dev/null
+++ b/openair1/PHY/LTE_UE_TRANSPORT/pmch_ue.c
@@ -0,0 +1,1045 @@
+/*
+ * 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 "PHY/defs.h"
+#include "PHY/extern.h"
+#include "PHY/sse_intrin.h"
+
+// Mask for identifying subframe for MBMS
+#define MBSFN_TDD_SF3 0x80// for TDD
+#define MBSFN_TDD_SF4 0x40
+#define MBSFN_TDD_SF7 0x20
+#define MBSFN_TDD_SF8 0x10
+#define MBSFN_TDD_SF9 0x08
+
+#include "PHY/defs.h"
+
+#define MBSFN_FDD_SF1 0x80// for FDD
+#define MBSFN_FDD_SF2 0x40
+#define MBSFN_FDD_SF3 0x20
+#define MBSFN_FDD_SF6 0x10
+#define MBSFN_FDD_SF7 0x08
+#define MBSFN_FDD_SF8 0x04
+
+
+
+void dump_mch(PHY_VARS_UE *ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,int subframe)
+{
+
+ unsigned int nsymb_pmch=12;
+ char fname[32],vname[32];
+ int N_RB_DL=ue->frame_parms.N_RB_DL;
+
+ sprintf(fname,"mch_rxF_ext0.m");
+ sprintf(vname,"pmch_rxF_ext0");
+ write_output(fname,vname,ue->pdsch_vars_MCH[eNB_id]->rxdataF_ext[0],12*N_RB_DL*nsymb_pmch,1,1);
+ sprintf(fname,"mch_ch_ext00.m");
+ sprintf(vname,"pmch_ch_ext00");
+ write_output(fname,vname,ue->pdsch_vars_MCH[eNB_id]->dl_ch_estimates_ext[0],12*N_RB_DL*nsymb_pmch,1,1);
+ /*
+ write_output("dlsch%d_ch_ext01.m","dl01_ch0_ext",pdsch_vars[eNB_id]->dl_ch_estimates_ext[1],12*N_RB_DL*nsymb_pmch,1,1);
+ write_output("dlsch%d_ch_ext10.m","dl10_ch0_ext",pdsch_vars[eNB_id]->dl_ch_estimates_ext[2],12*N_RB_DL*nsymb_pmch,1,1);
+ write_output("dlsch%d_ch_ext11.m","dl11_ch0_ext",pdsch_vars[eNB_id]->dl_ch_estimates_ext[3],12*N_RB_DL*nsymb_pmch,1,1);
+ write_output("dlsch%d_rho.m","dl_rho",pdsch_vars[eNB_id]->rho[0],12*N_RB_DL*nsymb_pmch,1,1);
+ */
+ sprintf(fname,"mch_rxF_comp0.m");
+ sprintf(vname,"pmch_rxF_comp0");
+ write_output(fname,vname,ue->pdsch_vars_MCH[eNB_id]->rxdataF_comp0[0],12*N_RB_DL*nsymb_pmch,1,1);
+ sprintf(fname,"mch_rxF_llr.m");
+ sprintf(vname,"pmch_llr");
+ write_output(fname,vname, ue->pdsch_vars_MCH[eNB_id]->llr[0],coded_bits_per_codeword,1,0);
+ sprintf(fname,"mch_mag1.m");
+ sprintf(vname,"pmch_mag1");
+ write_output(fname,vname,ue->pdsch_vars_MCH[eNB_id]->dl_ch_mag0[0],12*N_RB_DL*nsymb_pmch,1,1);
+ sprintf(fname,"mch_mag2.m");
+ sprintf(vname,"pmch_mag2");
+ write_output(fname,vname,ue->pdsch_vars_MCH[eNB_id]->dl_ch_magb0[0],12*N_RB_DL*nsymb_pmch,1,1);
+
+ write_output("mch00_ch0.m","pmch00_ch0",
+ &(ue->common_vars.common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id][0][0]),
+ ue->frame_parms.ofdm_symbol_size*12,1,1);
+
+ write_output("rxsig_mch.m","rxs_mch",
+ &ue->common_vars.rxdata[0][subframe*ue->frame_parms.samples_per_tti],
+ ue->frame_parms.samples_per_tti,1,1);
+
+ /*
+ if (PHY_vars_eNB_g)
+ write_output("txsig_mch.m","txs_mch",
+ &PHY_vars_eNB_g[0][0]->common_vars.txdata[0][0][subframe*ue->frame_parms.samples_per_tti],
+ ue->frame_parms.samples_per_tti,1,1);*/
+}
+
+int is_pmch_subframe(uint32_t frame, int subframe, LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+ uint32_t period;
+ uint8_t i;
+
+ // LOG_D(PHY,"is_pmch_subframe: frame %d, subframe %d, num_MBSFN_config %d\n",
+ // frame,subframe,frame_parms->num_MBSFN_config);
+
+ for (i=0; i<frame_parms->num_MBSFN_config; i++) { // we have at least one MBSFN configuration
+ period = 1<<frame_parms->MBSFN_config[i].radioframeAllocationPeriod;
+
+ if ((frame % period) == frame_parms->MBSFN_config[i].radioframeAllocationOffset) {
+ if (frame_parms->MBSFN_config[i].fourFrames_flag == 0) {
+ if (frame_parms->frame_type == FDD) {
+ switch (subframe) {
+
+ case 1:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_FDD_SF1) > 0)
+ return(1);
+
+ break;
+
+ case 2:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_FDD_SF2) > 0)
+ return(1);
+
+ break;
+
+ case 3:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_FDD_SF3) > 0)
+ return(1);
+
+ break;
+
+ case 6:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_FDD_SF6) > 0)
+ return(1);
+
+ break;
+
+ case 7:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_FDD_SF7) > 0)
+ return(1);
+
+ break;
+
+ case 8:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_FDD_SF8) > 0)
+ return(1);
+
+ break;
+ }
+ } else {
+ switch (subframe) {
+ case 3:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_TDD_SF3) > 0)
+ return(1);
+
+ break;
+
+ case 4:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_TDD_SF4) > 0)
+ return(1);
+
+ break;
+
+ case 7:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_TDD_SF7) > 0)
+ return(1);
+
+ break;
+
+ case 8:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_TDD_SF8) > 0)
+ return(1);
+
+ break;
+
+ case 9:
+ if ((frame_parms->MBSFN_config[i].mbsfn_SubframeConfig & MBSFN_TDD_SF9) > 0)
+ return(1);
+
+ break;
+ }
+ }
+
+ } else { // handle 4 frames case
+
+ }
+ }
+ }
+
+ return(0);
+}
+
+void fill_eNB_dlsch_MCH(PHY_VARS_eNB *eNB,int mcs,int ndi,int rvidx)
+{
+
+ LTE_eNB_DLSCH_t *dlsch = eNB->dlsch_MCH;
+ LTE_DL_FRAME_PARMS *frame_parms=&eNB->frame_parms;
+
+ // dlsch->rnti = M_RNTI;
+ dlsch->harq_processes[0]->mcs = mcs;
+ // dlsch->harq_processes[0]->Ndi = ndi;
+ dlsch->harq_processes[0]->rvidx = rvidx;
+ dlsch->harq_processes[0]->Nl = 1;
+ dlsch->harq_processes[0]->TBS = TBStable[get_I_TBS(dlsch->harq_processes[0]->mcs)][frame_parms->N_RB_DL-1];
+ // dlsch->harq_ids[subframe] = 0;
+ dlsch->harq_processes[0]->nb_rb = frame_parms->N_RB_DL;
+
+ switch(frame_parms->N_RB_DL) {
+ case 6:
+ dlsch->harq_processes[0]->rb_alloc[0] = 0x3f;
+ break;
+
+ case 25:
+ dlsch->harq_processes[0]->rb_alloc[0] = 0x1ffffff;
+ break;
+
+ case 50:
+ dlsch->harq_processes[0]->rb_alloc[0] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc[1] = 0x3ffff;
+ break;
+
+ case 100:
+ dlsch->harq_processes[0]->rb_alloc[0] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc[1] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc[2] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc[3] = 0xf;
+ break;
+ }
+
+ if (eNB->abstraction_flag) {
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].cntl.pmch_flag=1;
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].num_pmch=1; // assumption: there is always one pmch in each SF
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].num_common_dci=0;
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].num_ue_spec_dci=0;
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].dlsch_type[0]=5;// put at the reserved position for PMCH
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].harq_pid[0]=0;
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].ue_id[0]=255;//broadcast
+ eNB_transport_info[eNB->Mod_id][eNB->CC_id].tbs[0]=dlsch->harq_processes[0]->TBS>>3;
+ }
+
+}
+
+void fill_UE_dlsch_MCH(PHY_VARS_UE *ue,int mcs,int ndi,int rvidx,int eNB_id)
+{
+
+ LTE_UE_DLSCH_t *dlsch = ue->dlsch_MCH[eNB_id];
+ LTE_DL_FRAME_PARMS *frame_parms=&ue->frame_parms;
+
+ // dlsch->rnti = M_RNTI;
+ dlsch->harq_processes[0]->mcs = mcs;
+ dlsch->harq_processes[0]->rvidx = rvidx;
+ // dlsch->harq_processes[0]->Ndi = ndi;
+ dlsch->harq_processes[0]->Nl = 1;
+ dlsch->harq_processes[0]->TBS = TBStable[get_I_TBS(dlsch->harq_processes[0]->mcs)][frame_parms->N_RB_DL-1];
+ dlsch->current_harq_pid = 0;
+ dlsch->harq_processes[0]->nb_rb = frame_parms->N_RB_DL;
+
+ switch(frame_parms->N_RB_DL) {
+ case 6:
+ dlsch->harq_processes[0]->rb_alloc_even[0] = 0x3f;
+ dlsch->harq_processes[0]->rb_alloc_odd[0] = 0x3f;
+ break;
+
+ case 25:
+ dlsch->harq_processes[0]->rb_alloc_even[0] = 0x1ffffff;
+ dlsch->harq_processes[0]->rb_alloc_odd[0] = 0x1ffffff;
+ break;
+
+ case 50:
+ dlsch->harq_processes[0]->rb_alloc_even[0] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_odd[0] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_even[1] = 0x3ffff;
+ dlsch->harq_processes[0]->rb_alloc_odd[1] = 0x3ffff;
+ break;
+
+ case 100:
+ dlsch->harq_processes[0]->rb_alloc_even[0] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_odd[0] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_even[1] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_odd[1] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_even[2] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_odd[2] = 0xffffffff;
+ dlsch->harq_processes[0]->rb_alloc_even[3] = 0xf;
+ dlsch->harq_processes[0]->rb_alloc_odd[3] = 0xf;
+ break;
+ }
+}
+
+void generate_mch(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc,uint8_t *a)
+{
+
+ int G;
+ int subframe = proc->subframe_tx;
+ int frame = proc->frame_tx;
+
+ if (eNB->abstraction_flag != 0) {
+ if (eNB_transport_info_TB_index[eNB->Mod_id][eNB->CC_id]!=0)
+ printf("[PHY][EMU] PMCH transport block position is different than zero %d \n", eNB_transport_info_TB_index[eNB->Mod_id][eNB->CC_id]);
+
+ memcpy(eNB->dlsch_MCH->harq_processes[0]->b,
+ a,
+ eNB->dlsch_MCH->harq_processes[0]->TBS>>3);
+ LOG_D(PHY, "[eNB %d] dlsch_encoding_emul pmch , tbs is %d \n",
+ eNB->Mod_id,
+ eNB->dlsch_MCH->harq_processes[0]->TBS>>3);
+
+ memcpy(&eNB_transport_info[eNB->Mod_id][eNB->CC_id].transport_blocks[eNB_transport_info_TB_index[eNB->Mod_id][eNB->CC_id]],
+ a,
+ eNB->dlsch_MCH->harq_processes[0]->TBS>>3);
+ eNB_transport_info_TB_index[eNB->Mod_id][eNB->CC_id]+= eNB->dlsch_MCH->harq_processes[0]->TBS>>3;//=eNB_transport_info[eNB->Mod_id].tbs[0];
+ } else {
+ G = get_G(&eNB->frame_parms,
+ eNB->frame_parms.N_RB_DL,
+ eNB->dlsch_MCH->harq_processes[0]->rb_alloc,
+ get_Qm(eNB->dlsch_MCH->harq_processes[0]->mcs),1,
+ 2,proc->frame_tx,subframe,0);
+
+ generate_mbsfn_pilot(eNB,proc,
+ eNB->common_vars.txdataF,
+ AMP);
+
+
+ AssertFatal(dlsch_encoding(eNB,
+ a,
+ 1,
+ eNB->dlsch_MCH,
+ proc->frame_tx,
+ subframe,
+ &eNB->dlsch_rate_matching_stats,
+ &eNB->dlsch_turbo_encoding_stats,
+ &eNB->dlsch_interleaving_stats)==0,
+ "problem in dlsch_encoding");
+
+ dlsch_scrambling(&eNB->frame_parms,1,eNB->dlsch_MCH,0,G,0,frame,subframe<<1);
+
+
+ mch_modulation(eNB->common_vars.txdataF,
+ AMP,
+ subframe,
+ &eNB->frame_parms,
+ eNB->dlsch_MCH);
+ }
+
+}
+
+void mch_extract_rbs(int **rxdataF,
+ int **dl_ch_estimates,
+ int **rxdataF_ext,
+ int **dl_ch_estimates_ext,
+ unsigned char symbol,
+ unsigned char subframe,
+ LTE_DL_FRAME_PARMS *frame_parms)
+{
+
+ int pilots=0,i,j,offset,aarx;
+
+ // printf("Extracting PMCH: symbol %d\n",symbol);
+ if ((symbol==2)||
+ (symbol==10)) {
+ pilots = 1;
+ offset = 1;
+ } else if (symbol==6) {
+ pilots = 1;
+ offset = 0;
+ }
+
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+ if (pilots==1) {
+ for (i=offset,j=0; i<frame_parms->N_RB_DL*6; i+=2,j++) {
+ /* printf("MCH with pilots: i %d, j %d => %d,%d\n",i,j,
+ *(int16_t*)&rxdataF[aarx][i+frame_parms->first_carrier_offset + (symbol*frame_parms->ofdm_symbol_size)],
+ *(int16_t*)(1+&rxdataF[aarx][i+frame_parms->first_carrier_offset + (symbol*frame_parms->ofdm_symbol_size)]));
+ */
+ rxdataF_ext[aarx][j+symbol*(frame_parms->N_RB_DL*12)] = rxdataF[aarx][i+frame_parms->first_carrier_offset + (symbol*frame_parms->ofdm_symbol_size)];
+ rxdataF_ext[aarx][(frame_parms->N_RB_DL*3)+j+symbol*(frame_parms->N_RB_DL*12)] = rxdataF[aarx][i+1+ (symbol*frame_parms->ofdm_symbol_size)];
+ dl_ch_estimates_ext[aarx][j+symbol*(frame_parms->N_RB_DL*12)] = dl_ch_estimates[aarx][i+(symbol*frame_parms->ofdm_symbol_size)];
+ dl_ch_estimates_ext[aarx][(frame_parms->N_RB_DL*3)+j+symbol*(frame_parms->N_RB_DL*12)] = dl_ch_estimates[aarx][i+(frame_parms->N_RB_DL*6)+(symbol*frame_parms->ofdm_symbol_size)];
+ }
+ } else {
+
+ memcpy((void*)&rxdataF_ext[aarx][symbol*(frame_parms->N_RB_DL*12)],
+ (void*)&rxdataF[aarx][frame_parms->first_carrier_offset + (symbol*frame_parms->ofdm_symbol_size)],
+ frame_parms->N_RB_DL*24);
+ memcpy((void*)&rxdataF_ext[aarx][(frame_parms->N_RB_DL*6) + symbol*(frame_parms->N_RB_DL*12)],
+ (void*)&rxdataF[aarx][1 + (symbol*frame_parms->ofdm_symbol_size)],
+ frame_parms->N_RB_DL*24);
+ memcpy((void*)&dl_ch_estimates_ext[aarx][symbol*(frame_parms->N_RB_DL*12)],
+ (void*)&dl_ch_estimates[aarx][(symbol*frame_parms->ofdm_symbol_size)],
+ frame_parms->N_RB_DL*48);
+
+ }
+
+ }
+
+
+
+}
+
+void mch_channel_level(int **dl_ch_estimates_ext,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ int *avg,
+ uint8_t symbol,
+ unsigned short nb_rb)
+{
+
+ int i,aarx,nre;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *dl_ch128,avg128;
+#elif defined(__arm__)
+ int32x4_t avg128;
+#endif
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+#if defined(__x86_64__) || defined(__i386__)
+ //clear average level
+ avg128 = _mm_setzero_si128();
+ // 5 is always a symbol with no pilots for both normal and extended prefix
+
+ dl_ch128=(__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
+#elif defined(__arm__)
+
+
+#endif
+ if ((symbol == 2) || (symbol == 6) || (symbol == 10))
+ nre = (frame_parms->N_RB_DL*6);
+ else
+ nre = (frame_parms->N_RB_DL*12);
+
+ for (i=0; i<(nre>>2); i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ avg128 = _mm_add_epi32(avg128,_mm_madd_epi16(dl_ch128[0],dl_ch128[0]));
+#elif defined(__arm__)
+
+#endif
+ }
+
+ avg[aarx] = (((int*)&avg128)[0] +
+ ((int*)&avg128)[1] +
+ ((int*)&avg128)[2] +
+ ((int*)&avg128)[3])/nre;
+
+ // printf("Channel level : %d\n",avg[(aatx<<1)+aarx]);
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+void mch_channel_compensation(int **rxdataF_ext,
+ int **dl_ch_estimates_ext,
+ int **dl_ch_mag,
+ int **dl_ch_magb,
+ int **rxdataF_comp,
+ LTE_DL_FRAME_PARMS *frame_parms,
+ unsigned char symbol,
+ unsigned char mod_order,
+ unsigned char output_shift)
+{
+
+ int aarx,nre,i;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *dl_ch128,*dl_ch_mag128,*dl_ch_mag128b,*rxdataF128,*rxdataF_comp128;
+ __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp128,QAM_amp128b;
+#elif defined(__arm__)
+
+#endif
+ if ((symbol == 2) || (symbol == 6) || (symbol == 10))
+ nre = frame_parms->N_RB_DL*6;
+ else
+ nre = frame_parms->N_RB_DL*12;
+
+#if defined(__x86_64__) || defined(__i386__)
+ if (mod_order == 4) {
+ QAM_amp128 = _mm_set1_epi16(QAM16_n1); // 2/sqrt(10)
+ QAM_amp128b = _mm_setzero_si128();
+ } else if (mod_order == 6) {
+ QAM_amp128 = _mm_set1_epi16(QAM64_n1); //
+ QAM_amp128b = _mm_set1_epi16(QAM64_n2);
+ }
+#elif defined(__arm__)
+
+#endif
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+
+ dl_ch128 = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128 = (__m128i *)&dl_ch_mag[aarx][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128b = (__m128i *)&dl_ch_magb[aarx][symbol*frame_parms->N_RB_DL*12];
+ rxdataF128 = (__m128i *)&rxdataF_ext[aarx][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128 = (__m128i *)&rxdataF_comp[aarx][symbol*frame_parms->N_RB_DL*12];
+#elif defined(__arm__)
+
+#endif
+
+ for (i=0; i<(nre>>2); i+=2) {
+ if (mod_order>2) {
+ // get channel amplitude if not QPSK
+#if defined(__x86_64__) || defined(__i386__)
+
+ mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128[0]);
+ mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+
+ mmtmpD1 = _mm_madd_epi16(dl_ch128[1],dl_ch128[1]);
+ mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+
+ mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
+
+ // store channel magnitude here in a new field of dlsch
+
+ dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
+ dl_ch_mag128b[0] = dl_ch_mag128[0];
+ dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
+ dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
+
+ dl_ch_mag128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
+ dl_ch_mag128b[1] = dl_ch_mag128[1];
+ dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
+ dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
+
+
+ dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
+ dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
+
+
+ dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
+ dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
+
+#elif defined(__arm__)
+
+#endif
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+
+ // multiply by conjugated channel
+ mmtmpD0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
+ // print_ints("re",&mmtmpD0);
+
+ // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+ mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
+ // print_ints("im",&mmtmpD1);
+ mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[0]);
+ // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+ // print_ints("re(shift)",&mmtmpD0);
+ mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+ // print_ints("im(shift)",&mmtmpD1);
+ mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+ mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+ // print_ints("c0",&mmtmpD2);
+ // print_ints("c1",&mmtmpD3);
+ rxdataF_comp128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+ // print_shorts("rx:",rxdataF128);
+ // print_shorts("ch:",dl_ch128);
+ // print_shorts("pack:",rxdataF_comp128);
+
+ // multiply by conjugated channel
+ mmtmpD0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
+ // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+ mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+ mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+ mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+ mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[1]);
+ // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+ mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+ mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+ mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+ mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+
+ rxdataF_comp128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+ // print_shorts("rx:",rxdataF128+1);
+ // print_shorts("ch:",dl_ch128+1);
+ // print_shorts("pack:",rxdataF_comp128+1);
+
+ dl_ch128+=2;
+ dl_ch_mag128+=2;
+ dl_ch_mag128b+=2;
+ rxdataF128+=2;
+ rxdataF_comp128+=2;
+
+#elif defined(__arm__)
+
+#endif
+ }
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+
+}
+
+void mch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
+ int **rxdataF_comp,
+ int **dl_ch_mag,
+ int **dl_ch_magb,
+ unsigned char symbol)
+{
+
+
+ int i;
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *rxdataF_comp128_0,*rxdataF_comp128_1,*dl_ch_mag128_0,*dl_ch_mag128_1,*dl_ch_mag128_0b,*dl_ch_mag128_1b;
+#elif defined(__arm__)
+ int16x8_t *rxdataF_comp128_0,*rxdataF_comp128_1,*dl_ch_mag128_0,*dl_ch_mag128_1,*dl_ch_mag128_0b,*dl_ch_mag128_1b;
+#endif
+ if (frame_parms->nb_antennas_rx>1) {
+
+#if defined(__x86_64__) || defined(__i386__)
+
+ rxdataF_comp128_0 = (__m128i *)&rxdataF_comp[0][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_1 = (__m128i *)&rxdataF_comp[1][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_0 = (__m128i *)&dl_ch_mag[0][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_1 = (__m128i *)&dl_ch_mag[1][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_0b = (__m128i *)&dl_ch_magb[0][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_1b = (__m128i *)&dl_ch_magb[1][symbol*frame_parms->N_RB_DL*12];
+
+#elif defined(__arm__)
+ rxdataF_comp128_0 = (int16x8_t *)&rxdataF_comp[0][symbol*frame_parms->N_RB_DL*12];
+ rxdataF_comp128_1 = (int16x8_t *)&rxdataF_comp[1][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_0 = (int16x8_t *)&dl_ch_mag[0][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_1 = (int16x8_t *)&dl_ch_mag[1][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_0b = (int16x8_t *)&dl_ch_magb[0][symbol*frame_parms->N_RB_DL*12];
+ dl_ch_mag128_1b = (int16x8_t *)&dl_ch_magb[1][symbol*frame_parms->N_RB_DL*12];
+
+#endif
+ // MRC on each re of rb, both on MF output and magnitude (for 16QAM/64QAM llr computation)
+ for (i=0; i<frame_parms->N_RB_DL*3; i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+ dl_ch_mag128_0[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1));
+ dl_ch_mag128_0b[i] = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1));
+#elif defined(__arm__)
+ rxdataF_comp128_0[i] = vhaddq_s16(rxdataF_comp128_0[i],rxdataF_comp128_1[i]);
+ dl_ch_mag128_0[i] = vhaddq_s16(dl_ch_mag128_0[i],dl_ch_mag128_1[i]);
+ dl_ch_mag128_0b[i] = vhaddq_s16(dl_ch_mag128_0b[i],dl_ch_mag128_1b[i]);
+#endif
+ }
+ }
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+int mch_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
+ int **rxdataF_comp,
+ short *dlsch_llr,
+ unsigned char symbol,
+ short **llr32p)
+{
+
+ uint32_t *rxF = (uint32_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+ uint32_t *llr32;
+ int i,len;
+
+ if (symbol==2) {
+ llr32 = (uint32_t*)dlsch_llr;
+ } else {
+ llr32 = (uint32_t*)(*llr32p);
+ }
+
+ AssertFatal(llr32!=NULL,"dlsch_qpsk_llr: llr is null, symbol %d, llr32=%p\n",symbol, llr32);
+
+
+ if ((symbol==2) || (symbol==6) || (symbol==10)) {
+ len = frame_parms->N_RB_DL*6;
+ } else {
+ len = frame_parms->N_RB_DL*12;
+ }
+
+ // printf("dlsch_qpsk_llr: symbol %d,len %d,pbch_pss_sss_adjust %d\n",symbol,len,pbch_pss_sss_adjust);
+ for (i=0; i<len; i++) {
+ *llr32 = *rxF;
+ rxF++;
+ llr32++;
+ }
+
+ *llr32p = (short *)llr32;
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+
+ return(0);
+}
+
+//----------------------------------------------------------------------------------------------
+// 16-QAM
+//----------------------------------------------------------------------------------------------
+
+void mch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
+ int **rxdataF_comp,
+ short *dlsch_llr,
+ int **dl_ch_mag,
+ unsigned char symbol,
+ int16_t **llr32p)
+{
+
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i *rxF = (__m128i*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+ __m128i *ch_mag;
+ __m128i llr128[2],xmm0;
+ uint32_t *llr32;
+#elif defined(__arm__)
+ int16x8_t *rxF = (int16x8_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+ int16x8_t *ch_mag;
+ int16x8_t llr128[2],xmm0;
+ int16_t *llr16;
+#endif
+ int i,len;
+ unsigned char len_mod4=0;
+
+#if defined(__x86_64__) || defined(__i386__)
+ if (symbol==2) {
+ llr32 = (uint32_t*)dlsch_llr;
+ } else {
+ llr32 = (uint32_t*)*llr32p;
+ }
+#elif defined(__arm__)
+ if (symbol==2) {
+ llr16 = (int16_t*)dlsch_llr;
+ } else {
+ llr16 = (int16_t*)*llr32p;
+ }
+#endif
+#if defined(__x86_64__) || defined(__i386__)
+ ch_mag = (__m128i*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
+#elif defined(__arm__)
+ ch_mag = (int16x8_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
+#endif
+ if ((symbol==2) || (symbol==6) || (symbol==10)) {
+ len = frame_parms->N_RB_DL*6;
+ } else {
+ len = frame_parms->N_RB_DL*12;
+ }
+
+
+
+ // update output pointer according to number of REs in this symbol (<<2 because 4 bits per RE)
+ if (symbol==2)
+ *llr32p = dlsch_llr + (len<<2);
+ else
+ *llr32p += (len<<2);
+
+ len_mod4 = len&3;
+ len>>=2; // length in quad words (4 REs)
+ len+=(len_mod4==0 ? 0 : 1);
+
+ for (i=0; i<len; i++) {
+
+#if defined(__x86_64__) || defined(__i386__)
+ xmm0 = _mm_abs_epi16(rxF[i]);
+ xmm0 = _mm_subs_epi16(ch_mag[i],xmm0);
+
+ // lambda_1=y_R, lambda_2=|y_R|-|h|^2, lamda_3=y_I, lambda_4=|y_I|-|h|^2
+ llr128[0] = _mm_unpacklo_epi32(rxF[i],xmm0);
+ llr128[1] = _mm_unpackhi_epi32(rxF[i],xmm0);
+ llr32[0] = ((uint32_t *)&llr128[0])[0];
+ llr32[1] = ((uint32_t *)&llr128[0])[1];
+ llr32[2] = ((uint32_t *)&llr128[0])[2];
+ llr32[3] = ((uint32_t *)&llr128[0])[3];
+ llr32[4] = ((uint32_t *)&llr128[1])[0];
+ llr32[5] = ((uint32_t *)&llr128[1])[1];
+ llr32[6] = ((uint32_t *)&llr128[1])[2];
+ llr32[7] = ((uint32_t *)&llr128[1])[3];
+ llr32+=8;
+
+#elif defined(__arm__)
+ xmm0 = vabsq_s16(rxF[i]);
+ xmm0 = vsubq_s16(ch_mag[i],xmm0);
+
+ // lambda_1=y_R, lambda_2=|y_R|-|h|^2, lamda_3=y_I, lambda_4=|y_I|-|h|^2
+
+ llr16[0] = vgetq_lane_s16(rxF[i],0);
+ llr16[1] = vgetq_lane_s16(xmm0,0);
+ llr16[2] = vgetq_lane_s16(rxF[i],1);
+ llr16[3] = vgetq_lane_s16(xmm0,1);
+ llr16[4] = vgetq_lane_s16(rxF[i],2);
+ llr16[5] = vgetq_lane_s16(xmm0,2);
+ llr16[6] = vgetq_lane_s16(rxF[i],2);
+ llr16[7] = vgetq_lane_s16(xmm0,3);
+ llr16[8] = vgetq_lane_s16(rxF[i],4);
+ llr16[9] = vgetq_lane_s16(xmm0,4);
+ llr16[10] = vgetq_lane_s16(rxF[i],5);
+ llr16[11] = vgetq_lane_s16(xmm0,5);
+ llr16[12] = vgetq_lane_s16(rxF[i],6);
+ llr16[13] = vgetq_lane_s16(xmm0,6);
+ llr16[14] = vgetq_lane_s16(rxF[i],7);
+ llr16[15] = vgetq_lane_s16(xmm0,7);
+ llr16+=16;
+#endif
+
+ }
+
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+//----------------------------------------------------------------------------------------------
+// 64-QAM
+//----------------------------------------------------------------------------------------------
+
+void mch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
+ int **rxdataF_comp,
+ short *dlsch_llr,
+ int **dl_ch_mag,
+ int **dl_ch_magb,
+ unsigned char symbol,
+ short **llr_save)
+{
+
+#if defined(__x86_64__) || defined(__i386__)
+ __m128i xmm1,xmm2,*ch_mag,*ch_magb;
+ __m128i *rxF = (__m128i*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+#elif defined(__arm__)
+ int16x8_t xmm1,xmm2,*ch_mag,*ch_magb;
+ int16x8_t *rxF = (int16x8_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+#endif
+
+ int i,len,len2;
+ // int j=0;
+ unsigned char len_mod4;
+ short *llr;
+ int16_t *llr2;
+
+ if (symbol==2)
+ llr = dlsch_llr;
+ else
+ llr = *llr_save;
+
+#if defined(__x86_64__) || defined(__i386__)
+ ch_mag = (__m128i*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
+ ch_magb = (__m128i*)&dl_ch_magb[0][(symbol*frame_parms->N_RB_DL*12)];
+#elif defined(__arm__)
+ ch_mag = (int16x8_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
+ ch_magb = (int16x8_t*)&dl_ch_magb[0][(symbol*frame_parms->N_RB_DL*12)];
+#endif
+ if ((symbol==2) || (symbol==6) || (symbol==10)) {
+ len = frame_parms->N_RB_DL*6;
+ } else {
+ len = frame_parms->N_RB_DL*12;
+ }
+
+
+ llr2 = llr;
+ llr += (len*6);
+
+ len_mod4 =len&3;
+ len2=len>>2; // length in quad words (4 REs)
+ len2+=(len_mod4?0:1);
+
+
+ for (i=0; i<len2; i++) {
+#if defined(__x86_64__) || defined(__i386__)
+ xmm1 = _mm_abs_epi16(rxF[i]);
+ xmm1 = _mm_subs_epi16(ch_mag[i],xmm1);
+ xmm2 = _mm_abs_epi16(xmm1);
+ xmm2 = _mm_subs_epi16(ch_magb[i],xmm2);
+#elif defined(__arm__)
+ xmm1 = vabsq_s16(rxF[i]);
+ xmm1 = vsubq_s16(ch_mag[i],xmm1);
+ xmm2 = vabsq_s16(xmm1);
+ xmm2 = vsubq_s16(ch_magb[i],xmm2);
+#endif
+
+ /*
+ printf("pmch i: %d => mag (%d,%d) (%d,%d)\n",i,((short *)&ch_mag[i])[0],((short *)&ch_magb[i])[0],
+ ((short *)&rxF[i])[0],((short *)&rxF[i])[1]);
+ */
+ // loop over all LLRs in quad word (24 coded bits)
+ /*
+ for (j=0;j<8;j+=2) {
+ llr2[0] = ((short *)&rxF[i])[j];
+ llr2[1] = ((short *)&rxF[i])[j+1];
+ llr2[2] = _mm_extract_epi16(xmm1,j);
+ llr2[3] = _mm_extract_epi16(xmm1,j+1);//((short *)&xmm1)[j+1];
+ llr2[4] = _mm_extract_epi16(xmm2,j);//((short *)&xmm2)[j];
+ llr2[5] = _mm_extract_epi16(xmm2,j+1);//((short *)&xmm2)[j+1];
+
+ llr2+=6;
+ }
+ */
+ llr2[0] = ((short *)&rxF[i])[0];
+ llr2[1] = ((short *)&rxF[i])[1];
+#if defined(__x86_64__) || defined(__i386__)
+ llr2[2] = _mm_extract_epi16(xmm1,0);
+ llr2[3] = _mm_extract_epi16(xmm1,1);//((short *)&xmm1)[j+1];
+ llr2[4] = _mm_extract_epi16(xmm2,0);//((short *)&xmm2)[j];
+ llr2[5] = _mm_extract_epi16(xmm2,1);//((short *)&xmm2)[j+1];
+#elif defined(__arm__)
+ llr2[2] = vgetq_lane_s16(xmm1,0);
+ llr2[3] = vgetq_lane_s16(xmm1,1);//((short *)&xmm1)[j+1];
+ llr2[4] = vgetq_lane_s16(xmm2,0);//((short *)&xmm2)[j];
+ llr2[5] = vgetq_lane_s16(xmm2,1);//((short *)&xmm2)[j+1];
+#endif
+
+ llr2+=6;
+ llr2[0] = ((short *)&rxF[i])[2];
+ llr2[1] = ((short *)&rxF[i])[3];
+#if defined(__x86_64__) || defined(__i386__)
+ llr2[2] = _mm_extract_epi16(xmm1,2);
+ llr2[3] = _mm_extract_epi16(xmm1,3);//((short *)&xmm1)[j+1];
+ llr2[4] = _mm_extract_epi16(xmm2,2);//((short *)&xmm2)[j];
+ llr2[5] = _mm_extract_epi16(xmm2,3);//((short *)&xmm2)[j+1];
+#elif defined(__arm__)
+ llr2[2] = vgetq_lane_s16(xmm1,2);
+ llr2[3] = vgetq_lane_s16(xmm1,3);//((short *)&xmm1)[j+1];
+ llr2[4] = vgetq_lane_s16(xmm2,2);//((short *)&xmm2)[j];
+ llr2[5] = vgetq_lane_s16(xmm2,3);//((short *)&xmm2)[j+1];
+#endif
+ llr2+=6;
+ llr2[0] = ((short *)&rxF[i])[4];
+ llr2[1] = ((short *)&rxF[i])[5];
+#if defined(__x86_64__) || defined(__i386__)
+ llr2[2] = _mm_extract_epi16(xmm1,4);
+ llr2[3] = _mm_extract_epi16(xmm1,5);//((short *)&xmm1)[j+1];
+ llr2[4] = _mm_extract_epi16(xmm2,4);//((short *)&xmm2)[j];
+ llr2[5] = _mm_extract_epi16(xmm2,5);//((short *)&xmm2)[j+1];
+#elif defined(__arm__)
+ llr2[2] = vgetq_lane_s16(xmm1,4);
+ llr2[3] = vgetq_lane_s16(xmm1,5);//((short *)&xmm1)[j+1];
+ llr2[4] = vgetq_lane_s16(xmm2,4);//((short *)&xmm2)[j];
+ llr2[5] = vgetq_lane_s16(xmm2,5);//((short *)&xmm2)[j+1];
+#endif
+ llr2+=6;
+ llr2[0] = ((short *)&rxF[i])[6];
+ llr2[1] = ((short *)&rxF[i])[7];
+#if defined(__x86_64__) || defined(__i386__)
+ llr2[2] = _mm_extract_epi16(xmm1,6);
+ llr2[3] = _mm_extract_epi16(xmm1,7);//((short *)&xmm1)[j+1];
+ llr2[4] = _mm_extract_epi16(xmm2,6);//((short *)&xmm2)[j];
+ llr2[5] = _mm_extract_epi16(xmm2,7);//((short *)&xmm2)[j+1];
+#elif defined(__arm__)
+ llr2[2] = vgetq_lane_s16(xmm1,6);
+ llr2[3] = vgetq_lane_s16(xmm1,7);//((short *)&xmm1)[j+1];
+ llr2[4] = vgetq_lane_s16(xmm2,6);//((short *)&xmm2)[j];
+ llr2[5] = vgetq_lane_s16(xmm2,7);//((short *)&xmm2)[j+1];
+#endif
+ llr2+=6;
+ }
+
+ *llr_save = llr;
+#if defined(__x86_64__) || defined(__i386__)
+ _mm_empty();
+ _m_empty();
+#endif
+}
+
+int avg_pmch[4];
+int rx_pmch(PHY_VARS_UE *ue,
+ unsigned char eNB_id,
+ uint8_t subframe,
+ unsigned char symbol)
+{
+
+ LTE_UE_COMMON *common_vars = &ue->common_vars;
+ LTE_UE_PDSCH **pdsch_vars = &ue->pdsch_vars_MCH[eNB_id];
+ LTE_DL_FRAME_PARMS *frame_parms = &ue->frame_parms;
+ LTE_UE_DLSCH_t **dlsch = &ue->dlsch_MCH[eNB_id];
+ int avgs,aarx;
+
+ //printf("*********************mch: symbol %d\n",symbol);
+
+ mch_extract_rbs(common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].rxdataF,
+ common_vars->common_vars_rx_data_per_thread[ue->current_thread_id[subframe]].dl_ch_estimates[eNB_id],
+ pdsch_vars[eNB_id]->rxdataF_ext,
+ pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+ symbol,
+ subframe,
+ frame_parms);
+
+ if (symbol == 2) {
+ mch_channel_level(pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+ frame_parms,
+ avg_pmch,
+ symbol,
+ frame_parms->N_RB_DL);
+ }
+
+ avgs = 0;
+
+ for (aarx=0; aarx<frame_parms->nb_antennas_rx; aarx++)
+ avgs = cmax(avgs,avg_pmch[aarx]);
+
+ if (get_Qm(dlsch[0]->harq_processes[0]->mcs)==2)
+ pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) ;// + 2
+ else
+ pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2); // + 5;// + 2
+
+ mch_channel_compensation(pdsch_vars[eNB_id]->rxdataF_ext,
+ pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+ pdsch_vars[eNB_id]->dl_ch_mag0,
+ pdsch_vars[eNB_id]->dl_ch_magb0,
+ pdsch_vars[eNB_id]->rxdataF_comp0,
+ frame_parms,
+ symbol,
+ get_Qm(dlsch[0]->harq_processes[0]->mcs),
+ pdsch_vars[eNB_id]->log2_maxh);
+
+
+ if (frame_parms->nb_antennas_rx > 1)
+ mch_detection_mrc(frame_parms,
+ pdsch_vars[eNB_id]->rxdataF_comp0,
+ pdsch_vars[eNB_id]->dl_ch_mag0,
+ pdsch_vars[eNB_id]->dl_ch_magb0,
+ symbol);
+
+ switch (get_Qm(dlsch[0]->harq_processes[0]->mcs)) {
+ case 2 :
+ mch_qpsk_llr(frame_parms,
+ pdsch_vars[eNB_id]->rxdataF_comp0,
+ pdsch_vars[eNB_id]->llr[0],
+ symbol,
+ pdsch_vars[eNB_id]->llr128);
+ break;
+
+ case 4:
+ mch_16qam_llr(frame_parms,
+ pdsch_vars[eNB_id]->rxdataF_comp0,
+ pdsch_vars[eNB_id]->llr[0],
+ pdsch_vars[eNB_id]->dl_ch_mag0,
+ symbol,
+ pdsch_vars[eNB_id]->llr128);
+ break;
+
+ case 6:
+ mch_64qam_llr(frame_parms,
+ pdsch_vars[eNB_id]->rxdataF_comp0,
+ pdsch_vars[eNB_id]->llr[0],
+ pdsch_vars[eNB_id]->dl_ch_mag0,
+ pdsch_vars[eNB_id]->dl_ch_magb0,
+ symbol,
+ pdsch_vars[eNB_id]->llr128);
+ break;
+ }
+
+ return(0);
+}
+