proto_NB_IoT.h 29.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The OpenAirInterface Software Alliance licenses this file to You under
 * the OAI Public License, Version 1.0  (the "License"); you may not use this file
 * except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.openairinterface.org/?page_id=698
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *-------------------------------------------------------------------------------
 * For more information about the OpenAirInterface (OAI) Software Alliance:
 *      contact@openairinterface.org
 */

/*! \file PHY/LTE_TRANSPORT/proto.h
 * \brief Function prototypes for PHY physical/transport channel processing and generation V8.6 2009-03
 * \author R. Knopp, F. Kaltenberger
 * \date 2011
 * \version 0.1
 * \company Eurecom
 * \email: knopp@eurecom.fr
Matthieu Kanj's avatar
Matthieu Kanj committed
29 30 31 32
 * \last changes: M. Kanj, V. Savaux
 * \date: 2018
 * \company: b<>com
 * \email: matthieu.kanj@b-com.com, vincent.savaux@b-com.com
33 34 35 36 37
 * \note
 * \warning
 */
#ifndef __LTE_TRANSPORT_PROTO_NB_IOT__H__
#define __LTE_TRANSPORT_PROTO_NB_IOT__H__
38
#include "PHY/defs_NB_IoT.h"
39
#include "PHY/impl_defs_lte.h"
40
#include "PHY/defs.h"
Matthieu Kanj's avatar
Matthieu Kanj committed
41
//#include "PHY/LTE_TRANSPORT/defs_NB_IoT.h"
42
//#include <math.h>
43

44
//NPSS
Matthieu Kanj's avatar
Matthieu Kanj committed
45
void free_eNB_dlsch_NB_IoT(NB_IoT_eNB_NDLSCH_t *dlsch);
46
void free_eNB_dlcch_NB_IoT(NB_IoT_eNB_NPDCCH_t *dlcch);
Matthieu Kanj's avatar
Matthieu Kanj committed
47

Matthieu Kanj's avatar
Matthieu Kanj committed
48
void init_unscrambling_lut_NB_IoT(void);
49

50 51
int generate_npss_NB_IoT(int32_t                **txdataF,
                         short                  amp,
52
                         LTE_DL_FRAME_PARMS  *frame_parms,
53 54 55
                         unsigned short         symbol_offset,          // symbol_offset should equal to 3 for NB-IoT 
                         unsigned short         slot_offset,
                         unsigned short         RB_IoT_ID);             // new attribute (values are between 0.. Max_RB_number-1), it does not exist for LTE
56 57 58

//NSSS

59 60
int generate_sss_NB_IoT(int32_t                **txdataF,
                        int16_t                amp,
61
                        LTE_DL_FRAME_PARMS  *frame_parms, 
62 63 64
                        uint16_t               symbol_offset,             // symbol_offset = 3 for NB-IoT 
                        uint16_t               slot_offset, 
                        unsigned short         frame_number,        // new attribute (Get value from higher layer), it does not exist for LTE
65 66 67 68 69 70 71 72 73 74
                        unsigned short         RB_IoT_ID);          // new attribute (values are between 0.. Max_RB_number-1), it does not exist for LTE 

//*****************Vincent part for Cell ID estimation from NSSS ******************// 

int rx_nsss_NB_IoT(PHY_VARS_UE_NB_IoT *ue,int32_t *tot_metric); 

int nsss_extract_NB_IoT(PHY_VARS_UE_NB_IoT *ue,
            NB_IoT_DL_FRAME_PARMS *frame_parms,
            int32_t **nsss_ext,
            int l);
75 76 77

//NRS

78
void generate_pilots_NB_IoT(PHY_VARS_eNB  *phy_vars_eNB,
79 80 81 82 83
                            int32_t              **txdataF,
                            int16_t              amp,
                            uint16_t             Ntti,                // Ntti = 10
                            unsigned short       RB_IoT_ID,       // RB reserved for NB-IoT
                            unsigned short       With_NSSS);      // With_NSSS = 1; if the frame include a sub-Frame with NSSS signal
84 85 86 87


//NPBCH

88
int allocate_npbch_REs_in_RB(LTE_DL_FRAME_PARMS  *frame_parms,
89 90 91 92 93 94 95 96 97
                             int32_t                **txdataF,
                             uint32_t               *jj,
                             uint32_t               symbol_offset,
                             uint8_t                *x0,
                             uint8_t                pilots,
                             int16_t                amp,
                             unsigned short         id_offset,
                             uint32_t               *re_allocated);

98 99 100 101 102 103 104 105 106 107 108 109
// NPDSCH
int allocate_REs_in_RB_NB_IoT(LTE_DL_FRAME_PARMS    *frame_parms,
                              int32_t               **txdataF,
                              uint32_t              *jj,
                              uint32_t              symbol_offset,
                              uint8_t               *x0,
                              uint8_t               pilots,
                              int16_t               amp,
                              unsigned short        id_offset,
                              uint8_t               pilot_shift,
                              uint32_t              *re_allocated); 

Matthieu Kanj's avatar
Matthieu Kanj committed
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
int generate_NDLSCH_NB_IoT(NB_IoT_eNB_NDLSCH_t    *RAR,
                       int32_t                    **txdataF,
                       int16_t                    amp,
                       LTE_DL_FRAME_PARMS         *frame_parms,
                       uint32_t                   frame,
                       uint32_t                   subframe,
                       int                        RB_IoT_ID);

int generate_SIB23(NB_IoT_eNB_NDLSCH_t    *SIB23,
                   int32_t                **txdataF,
                   int16_t                amp,
                   LTE_DL_FRAME_PARMS     *frame_parms,
                   uint32_t               frame,
                   uint32_t               subframe,
                   int                    RB_IoT_ID);

Matthieu Kanj's avatar
Matthieu Kanj committed
126 127 128 129 130 131
int generate_SIB1(NB_IoT_eNB_NDLSCH_t     *sib1_struct,
                   int32_t                **txdataF,
                   int16_t                amp,
                   LTE_DL_FRAME_PARMS     *frame_parms,
                   uint32_t               frame,
                   uint32_t               subframe,
Matthieu Kanj's avatar
Matthieu Kanj committed
132 133
                   int                    RB_IoT_ID,
                   uint8_t                operation_mode);
134 135 136 137

int generate_npbch(NB_IoT_eNB_NPBCH_t     *eNB_npbch,
                   int32_t                **txdataF,
                   int                    amp,
138
                   LTE_DL_FRAME_PARMS  *frame_parms,
139 140 141 142 143
                   uint8_t                *npbch_pdu,
                   uint8_t                frame_mod64,
                   unsigned short         NB_IoT_RB_ID);


144
void npbch_scrambling(LTE_DL_FRAME_PARMS  *frame_parms,
145 146
                      uint8_t                *npbch_e,
                      uint32_t               length);
147

Matthieu Kanj's avatar
Matthieu Kanj committed
148 149 150 151 152 153 154 155 156 157

void dlsch_scrambling_Gen_NB_IoT(LTE_DL_FRAME_PARMS         *frame_parms,
                                  NB_IoT_eNB_NDLSCH_t       *dlsch,
                                  int                       tot_bits,            // total number of bits to transmit
                                  uint16_t                  Nf,                  // Nf is the frame number (0..9)
                                  uint8_t                   Ns,
                                  uint32_t                  rnti); 

NB_IoT_eNB_NDLSCH_t *new_eNB_dlsch_NB_IoT(uint8_t length, LTE_DL_FRAME_PARMS* frame_parms);

158 159
NB_IoT_eNB_NPDCCH_t *new_eNB_dlcch_NB_IoT(LTE_DL_FRAME_PARMS* frame_parms);

Matthieu Kanj's avatar
Matthieu Kanj committed
160 161 162 163 164 165 166
/*void dlsch_scrambling_Gen_NB_IoT(LTE_DL_FRAME_PARMS      *frame_parms,
                                  NB_IoT_eNB_NDLSCH_t    *dlsch,
                                  int                    tot_bits,         // total number of bits to transmit
                                  uint16_t               Nf,               // Nf is the frame number (0..9)
                                  uint8_t                Ns,
                                  uint32_t               rnti,     /// for SIB1 the SI_RNTI should be get from the DL request
                                  uint8_t                type);*/
Matthieu Kanj's avatar
Matthieu Kanj committed
167 168 169 170 171 172 173 174 175 176 177 178 179
/*
int scrambling_npbch_REs_rel_14(LTE_DL_FRAME_PARMS      *frame_parms,
                                int32_t                 **txdataF,
                                uint32_t                *jj,
                                int                     l,
                                uint32_t                symbol_offset,
                                uint8_t                 pilots,
                                unsigned short          id_offset,
                                uint8_t                 *reset,
                                uint32_t                *x1,
                                uint32_t                *x2,
                                uint32_t                *s);
*/
180 181
// Functions below implement 36-211 and 36-212

182 183
/*Function to pack the DCI*/ 
// newly added function for NB-IoT , does not exist for LTE
184 185 186 187 188 189 190 191 192
void add_dci_NB_IoT(DCI_PDU_NB_IoT    *DCI_pdu,
                    void              *pdu,
                    rnti_t            rnti,
                    unsigned char     dci_size_bytes,
                    unsigned char     aggregation, 
                    unsigned char     dci_size_bits,
                    unsigned char     dci_fmt,
                    uint8_t           npdcch_start_symbol);

193

194
/*Use the UL DCI Information to configure PHY and also Pack the DCI*/
195
int generate_eNB_ulsch_params_from_dci_NB_IoT(PHY_VARS_eNB     *eNB,
Matthieu Kanj's avatar
Matthieu Kanj committed
196
                                              eNB_rxtx_proc_t         *proc,
197 198 199 200 201 202 203
                                              DCI_CONTENT             *DCI_Content,
                                              uint16_t                rnti,
                                              DCI_format_NB_IoT_t     dci_format,
                                              uint8_t                 UE_id,
                                              uint8_t                 aggregation,
									                            uint8_t                 npdcch_start_symbol);

204

205
/*Use the DL DCI Information to configure PHY and also Pack the DCI*/
206
int generate_eNB_dlsch_params_from_dci_NB_IoT(PHY_VARS_eNB    *eNB,
207 208 209 210 211
                                              int                    frame,
                                              uint8_t                subframe,
                                              DCI_CONTENT            *DCI_Content,
                                              uint16_t               rnti,
                                              DCI_format_NB_IoT_t    dci_format,
Matthieu Kanj's avatar
Matthieu Kanj committed
212
                                              NB_IoT_eNB_NPDCCH_t      *ndlcch,
213
                                              LTE_DL_FRAME_PARMS  *frame_parms,
214
                                              uint8_t                aggregation,
215 216
									                            uint8_t                npdcch_start_symbol,
                                              uint8_t                ncce_index);
217

218

219
/*Function for DCI encoding, scrambling, modulation*/
220 221 222 223 224 225 226 227
uint8_t generate_dci_top_NB_IoT(NB_IoT_eNB_NPDCCH_t     *npdcch,
						                    uint8_t                 Num_dci,
                                DCI_ALLOC_NB_IoT_t      *dci_alloc,
                                int16_t                 amp,
                                NB_IoT_DL_FRAME_PARMS   *fp,
                                int32_t                 **txdataF,
                                uint32_t                subframe,
						                    uint8_t                 npdcch_start_symbol);
228

229 230 231 232 233 234 235 236 237 238 239
/*!
  \brief Decoding of PUSCH/ACK/RI/ACK from 36-212.
  @param phy_vars_eNB Pointer to eNB top-level descriptor
  @param proc Pointer to RXTX proc variables
  @param UE_id ID of UE transmitting this PUSCH
  @param subframe Index of subframe for PUSCH
  @param control_only_flag Receive PUSCH with control information only
  @param Nbundled Nbundled parameter for ACK/NAK scrambling from 36-212/36-213
  @param llr8_flag If 1, indicate that the 8-bit turbo decoder should be used
  @returns 0 on success
*/
Matthieu Kanj's avatar
Matthieu Kanj committed
240 241
unsigned int  ulsch_decoding_NB_IoT(PHY_VARS_eNB     *phy_vars_eNB,
                                    eNB_rxtx_proc_t  *proc,
242 243 244 245
                                    uint8_t                 UE_id,
                                    uint8_t                 control_only_flag,
                                    uint8_t                 Nbundled,
                                    uint8_t                 llr8_flag);
246

247

Matthieu Kanj's avatar
Matthieu Kanj committed
248
//  NB_IoT_eNB_NULSCH_t *new_eNB_ulsch_NB_IoT(uint8_t abstraction_flag);
249

250

Matthieu Kanj's avatar
Matthieu Kanj committed
251
uint8_t subframe2harq_pid_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms,uint32_t frame,uint8_t subframe);
252

253 254 255

/** \brief Compute Q (modulation order) based on I_MCS for PUSCH.  Implements table 8.6.1-1 from 36.213.
    @param I_MCS */
256 257 258

//uint8_t get_Qm_ul_NB_IoT(uint8_t I_MCS);
unsigned char get_Qm_ul_NB_IoT(unsigned char I_MCS, uint8_t N_sc_RU);
259

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
/** \fn dlsch_encoding(PHY_VARS_eNB *eNB,
    uint8_t *input_buffer,
    LTE_DL_FRAME_PARMS *frame_parms,
    uint8_t num_pdcch_symbols,
    LTE_eNB_DLSCH_t *dlsch,
    int frame,
    uint8_t subframe)
    \brief This function performs a subset of the bit-coding functions for LTE as described in 36-212, Release 8.Support is limited to turbo-coded channels (DLSCH/ULSCH). The implemented functions are:
    - CRC computation and addition
    - Code block segmentation and sub-block CRC addition
    - Channel coding (Turbo coding)
    - Rate matching (sub-block interleaving, bit collection, selection and transmission
    - Code block concatenation
    @param eNB Pointer to eNB PHY context
    @param input_buffer Pointer to input buffer for sub-frame
    @param frame_parms Pointer to frame descriptor structure
    @param num_pdcch_symbols Number of PDCCH symbols in this subframe
    @param dlsch Pointer to dlsch to be encoded
    @param frame Frame number
    @param subframe Subframe number
    @param rm_stats Time statistics for rate-matching
    @param te_stats Time statistics for turbo-encoding
    @param i_stats Time statistics for interleaving
    @returns status
*/

Matthieu Kanj's avatar
Matthieu Kanj committed
286 287 288 289 290 291 292 293 294 295
int dci_modulation_NB_IoT(int32_t              **txdataF,
                          int16_t              amp,
                          LTE_DL_FRAME_PARMS   *frame_parms,
                          uint8_t              control_region_size,      
                          NB_IoT_eNB_NPDCCH_t  *dlcch,            
                          unsigned int         npdsch_data_subframe,        
                          uint8_t              agr_level,
                          uint8_t              ncce_index,
                          unsigned int         subframe,
                          unsigned short       NB_IoT_RB_ID);
Matthieu Kanj's avatar
Matthieu Kanj committed
296 297

int dci_allocate_REs_in_RB_NB_IoT(LTE_DL_FRAME_PARMS  *frame_parms,
Matthieu Kanj's avatar
Matthieu Kanj committed
298 299 300 301 302 303 304
                                  int32_t             **txdataF,
                                  uint32_t            *jj,
                                  uint32_t            symbol_offset,
                                  uint8_t             *x0,
                                  uint8_t             pilots,
                                  uint8_t             pilot_shift,
                                  int16_t             amp,
Matthieu Kanj's avatar
Matthieu Kanj committed
305
                                  unsigned short      id_offset,
Matthieu Kanj's avatar
Matthieu Kanj committed
306
                                  uint8_t             ncce_index,
Matthieu Kanj's avatar
Matthieu Kanj committed
307 308 309 310 311 312 313
                                  uint8_t             agr_level,
                                  uint32_t            *re_allocated);


void dci_encoding_NB_IoT(uint8_t                  *a,
                         NB_IoT_eNB_NPDCCH_t      *dlcch,                  
                         uint8_t                  A,
Matthieu Kanj's avatar
Matthieu Kanj committed
314
                         uint16_t                 G,              
Matthieu Kanj's avatar
Matthieu Kanj committed
315 316 317
                         uint8_t                  ncce_index,
                         uint8_t                  agr_level);

Matthieu Kanj's avatar
Matthieu Kanj committed
318 319

void npdcch_scrambling_NB_IoT(LTE_DL_FRAME_PARMS     *frame_parms,
Matthieu Kanj's avatar
Matthieu Kanj committed
320 321 322 323 324
                              NB_IoT_eNB_NPDCCH_t     *dlcch,     // Input data
                              int                     G,          // Total number of bits to transmit in one subframe(case of DCI = G)
                              uint8_t                 Ns,       //XXX we pass the subframe  // Slot number (0..19)
                              uint8_t                 ncce_index,
                              uint8_t                 agr_level); 
Matthieu Kanj's avatar
Matthieu Kanj committed
325 326


327 328
int dlsch_modulation_NB_IoT(int32_t               **txdataF,
                            int16_t               amp,
Matthieu Kanj's avatar
Matthieu Kanj committed
329
                            LTE_DL_FRAME_PARMS    *frame_parms,
330
                            uint8_t               control_region_size,      // control region size for LTE , values between 0..3, (0 for stand-alone / 1, 2 or 3 for in-band)
Matthieu Kanj's avatar
Matthieu Kanj committed
331
                            NB_IoT_eNB_NDLSCH_t   *dlsch0,  //NB_IoT_eNB_NDLSCH_t
332
                            int                   G,              // number of bits per subframe
Matthieu Kanj's avatar
Matthieu Kanj committed
333 334
                            unsigned int          npdsch_data_subframe,     // subframe index of the data table of npdsch channel (G*Nsf)  , values are between 0..Nsf        
                            unsigned int          subframe,
335
                            unsigned short        NB_IoT_RB_ID);
Matthieu Kanj's avatar
Matthieu Kanj committed
336
/*
Matthieu Kanj's avatar
Matthieu Kanj committed
337
int dlsch_modulation_rar_NB_IoT(int32_t         **txdataF,
Matthieu Kanj's avatar
Matthieu Kanj committed
338 339 340 341 342 343 344 345 346
                                int16_t         amp,
                                LTE_DL_FRAME_PARMS      *frame_parms,
                                uint8_t         control_region_size,      // control region size for LTE , values between 0..3, (0 for stand-alone / 1, 2 or 3 for in-band)
                                NB_IoT_DL_eNB_HARQ_t      *dlsch0, //NB_IoT_eNB_NDLSCH_t
                                int           G,              // number of bits per subframe
                                unsigned int        npdsch_data_subframe,     // subframe index of the data table of npdsch channel (G*Nsf)  , values are between 0..Nsf        
                                unsigned int        subframe,
                                unsigned short      NB_IoT_RB_ID,
                                uint8_t             option);
Matthieu Kanj's avatar
Matthieu Kanj committed
347
*/
348
int32_t dlsch_encoding_NB_IoT(unsigned char              *a,
Matthieu Kanj's avatar
Matthieu Kanj committed
349
                              NB_IoT_eNB_NDLSCH_t        *dlsch, // NB_IoT_eNB_NDLSCH_t
350
                              uint8_t                    Nsf,        // number of subframes required for npdsch pdu transmission calculated from Isf (3GPP spec table)
Matthieu Kanj's avatar
Matthieu Kanj committed
351
                              unsigned int               G);         // G (number of available RE) is implicitly multiplied by 2 (since only QPSK modulation)
352
 
Matthieu Kanj's avatar
Matthieu Kanj committed
353

Matthieu Kanj's avatar
Matthieu Kanj committed
354
/////////////////////////////////////////////////////////////////
Matthieu Kanj's avatar
Matthieu Kanj committed
355 356
void rx_ulsch_NB_IoT(PHY_VARS_eNB      *phy_vars_eNB,
                     eNB_rxtx_proc_t   *proc,
357 358
                     uint8_t                  eNB_id,               // this is the effective sector id
                     uint8_t                  UE_id,
359
                     NB_IoT_eNB_NULSCH_t      **ulsch,
360 361
                     uint8_t                  cooperation_flag);

Matthieu Kanj's avatar
Matthieu Kanj committed
362

363
uint8_t rx_ulsch_Gen_NB_IoT(PHY_VARS_eNB            *eNB,
Matthieu Kanj's avatar
Matthieu Kanj committed
364 365 366 367 368 369 370 371 372 373 374 375 376 377
                         eNB_rxtx_proc_t         *proc,
                         uint8_t                 eNB_id,  // this is the effective sector id
                         uint8_t                 UE_id,
                         NB_IoT_eNB_NULSCH_t     **ulsch,
                         uint8_t                 npusch_format,         // 1, 2  
                         uint16_t                UL_RB_ID_NB_IoT,  // 22 , to be included in // to be replaced by NB_IoT_start ??
                         uint8_t                 subcarrier_spacing,  // 0 (3.75 KHz) or 1 (15 KHz)
                         uint32_t                rnti_tmp, //= 65522
                         uint8_t                 scrambling_subframe_msg3,
                         uint32_t                scrambling_frame_msg3,
                         uint16_t                nb_slot,   // total number of occupied slots
                         uint16_t                I_sc,
                         uint16_t                Nsc_RU,
                         uint16_t                Mcs,
Matthieu Kanj's avatar
Matthieu Kanj committed
378
                         unsigned int            A,
Matthieu Kanj's avatar
Matthieu Kanj committed
379 380
                         uint16_t                counter_msg,
                         uint8_t                 subframerx,
Matthieu Kanj's avatar
Matthieu Kanj committed
381
                         uint8_t                 rvdx);
Matthieu Kanj's avatar
Matthieu Kanj committed
382

Matthieu Kanj's avatar
Matthieu Kanj committed
383 384 385 386 387 388 389 390 391
void ulsch_extract_rbs_single_NB_IoT(int32_t **rxdataF,
                                     int32_t **rxdataF_ext,
                                     // uint32_t first_rb, 
                                     uint16_t UL_RB_ID_NB_IoT, // index of UL NB_IoT resource block !!! may be defined twice : in frame_parms and in NB_IoT_UL_eNB_HARQ_t
                                     uint8_t N_sc_RU, // number of subcarriers in UL 
                                     uint8_t subframe,// uint32_t I_sc, // NB_IoT: subcarrier indication field: must be defined in higher layer
                                     uint8_t l,
                                     uint8_t Ns,
                                     LTE_DL_FRAME_PARMS *frame_parms);
Matthieu Kanj's avatar
Matthieu Kanj committed
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409

void ulsch_channel_level_NB_IoT(int32_t **drs_ch_estimates_ext,
                                LTE_DL_FRAME_PARMS *frame_parms,
                                int32_t *avg,
                                uint16_t nb_rb);

void ulsch_channel_compensation_NB_IoT(int32_t **rxdataF_ext,
                                int32_t **ul_ch_estimates_ext,
                                int32_t **ul_ch_mag,
                                int32_t **ul_ch_magb,
                                int32_t **rxdataF_comp,
                                LTE_DL_FRAME_PARMS *frame_parms,
                                uint8_t symbol,
                                uint8_t Qm,
                                uint16_t nb_rb,
                                uint8_t output_shift);

void lte_idft_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms,uint32_t *z, uint16_t Msc_PUSCH);
410

411 412
void extract_CQI_NB_IoT(void *o,UCI_format_NB_IoT_t uci_format,NB_IoT_eNB_UE_stats *stats,uint8_t N_RB_DL, uint16_t * crnti, uint8_t * access_mode);

413
//*****************Vincent part for nprach ******************//
Matthieu Kanj's avatar
Matthieu Kanj committed
414
uint32_t process_nprach_NB_IoT(PHY_VARS_eNB *eNB, int frame, uint8_t subframe,uint32_t *rnti, uint16_t *preamble_index, uint16_t *timing_advance); 
415

416
uint32_t TA_estimation_NB_IoT(PHY_VARS_eNB *eNB, 
417 418 419 420
                              int16_t *Rx_sub_sampled_buffer, 
                              uint16_t sub_sampling_rate, 
                              uint16_t FRAME_LENGTH_COMPLEX_SUB_SAMPLES, 
                              uint32_t estimated_TA_coarse, 
421
                              uint8_t coarse); 
422

423
uint8_t NPRACH_detection_NB_IoT(int16_t *input_buffer,uint32_t FRAME_LENGTH_COMPLEX_SAMPLESx); 
424

425 426 427
int16_t* sub_sampling_NB_IoT(int16_t *input_buffer, uint32_t length_input, uint32_t *length_ouput, uint16_t sub_sampling_rate); 

void filtering_signal(int16_t *input_buffer, int16_t *filtered_buffer, uint32_t FRAME_LENGTH_COMPLEX_SAMPLESx); 
428
//************************************************************//
429 430
uint16_t get_UL_sc_start_NB_IoT(uint16_t I_sc); 

Matthieu Kanj's avatar
Matthieu Kanj committed
431 432 433 434 435 436 437 438 439 440
uint16_t get_UL_sc_index_start_NB_IoT(uint8_t subcarrier_spacing, uint16_t I_sc, uint8_t npush_format);

uint16_t get_UL_N_ru_NB_IoT(uint8_t I_mcs, uint8_t I_ru, uint8_t flag_msg3);

uint16_t get_UL_N_rep_NB_IoT(uint8_t I_rep);

uint8_t get_numb_UL_sc_NB_IoT(uint8_t subcarrier_spacing, uint8_t I_sc, uint8_t npush_format);

uint8_t get_UL_slots_per_RU_NB_IoT(uint8_t subcarrier_spacing, uint8_t subcarrier_indcation, uint8_t UL_format);

Matthieu Kanj's avatar
Matthieu Kanj committed
441
void generate_grouphop_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms); 
442 443

void init_ul_hopping_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms); 
444

Matthieu Kanj's avatar
Matthieu Kanj committed
445 446 447 448 449 450 451 452 453
void rotate_single_carrier_NB_IoT(PHY_VARS_eNB          *eNB, 
                                  LTE_DL_FRAME_PARMS    *frame_parms,
                                  int32_t               **rxdataF_comp, 
                                  uint8_t               UE_id,
                                  uint8_t               symbol, 
                                  uint8_t               counter_msg3,
                                  uint32_t              I_sc,
                                  uint8_t               Qm,
                                  uint8_t               option); 
454

Matthieu Kanj's avatar
Matthieu Kanj committed
455 456
void fill_rbs_zeros_NB_IoT(PHY_VARS_eNB *eNB, 
                                  LTE_DL_FRAME_PARMS *frame_parms,
457 458 459 460
                                  int32_t **rxdataF_comp, 
                                  uint8_t UE_id,
                                  uint8_t symbol); 

Matthieu Kanj's avatar
Matthieu Kanj committed
461 462
int32_t ulsch_bpsk_llr_NB_IoT(PHY_VARS_eNB *eNB, 
                              LTE_DL_FRAME_PARMS *frame_parms,
463 464 465 466 467 468
                              int32_t **rxdataF_comp,
                              int16_t *ulsch_llr,
                              uint8_t symbol, 
                              uint8_t uint8_t, 
                              int16_t **llrp); 

Matthieu Kanj's avatar
Matthieu Kanj committed
469 470
int32_t ulsch_qpsk_llr_NB_IoT(PHY_VARS_eNB *eNB, 
                              LTE_DL_FRAME_PARMS *frame_parms,
471 472 473
                              int32_t **rxdataF_comp,
                              int16_t *ulsch_llr, 
                              uint8_t symbol, 
Matthieu Kanj's avatar
Matthieu Kanj committed
474 475 476
                              uint8_t UE_id,
                              uint32_t I_sc,
                              uint8_t Nsc_RU, 
Matthieu Kanj's avatar
Matthieu Kanj committed
477
                              int16_t *llrp);
478

Matthieu Kanj's avatar
Matthieu Kanj committed
479 480
void rotate_bpsk_NB_IoT(PHY_VARS_eNB *eNB, 
                        LTE_DL_FRAME_PARMS *frame_parms,
481 482 483
                        int32_t **rxdataF_comp, 
                        uint8_t UE_id,
                        uint8_t symbol); 
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505
//************************************************************// 


int rx_npdsch_NB_IoT(PHY_VARS_UE_NB_IoT *ue,
                      unsigned char eNB_id,
                      unsigned char eNB_id_i, //if this == ue->n_connected_eNB, we assume MU interference
                      uint32_t frame,
                      uint8_t subframe,
                      unsigned char symbol,
                      unsigned char first_symbol_flag,
                      unsigned char i_mod,
                      unsigned char harq_pid); 

unsigned short dlsch_extract_rbs_single_NB_IoT(int **rxdataF,
                                        int **dl_ch_estimates,
                                        int **rxdataF_ext,
                                        int **dl_ch_estimates_ext,
                                        unsigned short pmi,
                                        unsigned char *pmi_ext,
                                        unsigned int *rb_alloc,
                                        unsigned char symbol,
                                        unsigned char subframe,
506
                                        uint32_t frame,
507 508 509
                                        uint32_t high_speed_flag,
                                        NB_IoT_DL_FRAME_PARMS *frame_parms); 

510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
void dlsch_channel_level_NB_IoT(int **dl_ch_estimates_ext,
                                NB_IoT_DL_FRAME_PARMS *frame_parms,
                                int32_t *avg,
                                uint8_t symbol,
                                unsigned short nb_rb); 

void dlsch_channel_compensation_NB_IoT(int **rxdataF_ext,
                                        int **dl_ch_estimates_ext,
                                        int **dl_ch_mag,
                                        int **dl_ch_magb,
                                        int **rxdataF_comp,
                                        int **rho,
                                        NB_IoT_DL_FRAME_PARMS *frame_parms,
                                        unsigned char symbol,
                                        uint8_t first_symbol_flag,
                                        unsigned char mod_order,
                                        unsigned short nb_rb,
                                        unsigned char output_shift,
                                        PHY_MEASUREMENTS_NB_IoT *measurements); 

Vincent Savaux's avatar
Vincent Savaux committed
530 531 532 533 534 535 536 537 538
int dlsch_qpsk_llr_NB_IoT(NB_IoT_DL_FRAME_PARMS *frame_parms,
                           int32_t **rxdataF_comp,
                           int16_t *dlsch_llr,
                           uint8_t symbol,
                           uint8_t first_symbol_flag,
                           uint16_t nb_rb,
                           int16_t **llr32p,
                           uint8_t beamforming_mode); 

Matthieu Kanj's avatar
Matthieu Kanj committed
539 540
/// Vincent: temporary functions 

Matthieu Kanj's avatar
Matthieu Kanj committed
541 542 543 544 545 546 547 548 549 550
int ul_chest_tmp_NB_IoT(int32_t             **rxdataF_ext,
                        int32_t             **ul_ch_estimates,
                        uint8_t             l, //symbol within slot 
                        uint8_t             Ns,
                        uint8_t             counter_msg3,
                        uint8_t             pilot_pos1,
                        uint8_t             pilot_pos2,
                        uint32_t            I_sc,
                        uint8_t             Qm,
                        LTE_DL_FRAME_PARMS  *frame_parms); 
Matthieu Kanj's avatar
Matthieu Kanj committed
551

Matthieu Kanj's avatar
Matthieu Kanj committed
552 553 554 555 556 557 558 559 560 561 562 563
/// Channel estimation for NPUSCH format 2
int ul_chest_tmp_f2_NB_IoT(int32_t **rxdataF_ext,
                           int32_t **ul_ch_estimates,
                           uint8_t l, //symbol within slot 
                           uint8_t Ns,
                           uint8_t counter_msg3,
                           uint8_t flag,
                           uint8_t subframerx,
                           uint8_t Qm, 
                           uint32_t I_sc,
                           LTE_DL_FRAME_PARMS *frame_parms);

Matthieu Kanj's avatar
Matthieu Kanj committed
564
void rotate_channel_sc_tmp_NB_IoT(int16_t *estimated_channel,
Matthieu Kanj's avatar
Matthieu Kanj committed
565 566
                                  uint8_t l, 
                                  uint8_t Qm, 
Matthieu Kanj's avatar
Matthieu Kanj committed
567 568
                                  uint8_t counter_msg3,
                                  uint8_t flag); 
Matthieu Kanj's avatar
Matthieu Kanj committed
569 570 571 572 573 574 575 576

int ul_chequal_tmp_NB_IoT(int32_t **rxdataF_ext,
      int32_t **rxdataF_comp,
      int32_t **ul_ch_estimates,
      uint8_t l, //symbol within slot 
      uint8_t Ns,
      LTE_DL_FRAME_PARMS *frame_parms);
///
Matthieu Kanj's avatar
Matthieu Kanj committed
577 578 579 580

////////////////////////////NB-IoT testing ///////////////////////////////
void clean_eNb_ulsch_NB_IoT(NB_IoT_eNB_NULSCH_t *ulsch);

Matthieu Kanj's avatar
Matthieu Kanj committed
581
int get_G_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms);
Matthieu Kanj's avatar
Matthieu Kanj committed
582

Matthieu Kanj's avatar
Matthieu Kanj committed
583 584 585 586 587 588
int get_G_SIB1_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms, uint8_t operation_mode_info);

int get_rep_num_SIB1_NB_IoT(uint8_t scheduling_info_sib1);

int get_start_frame_SIB1_NB_IoT(LTE_DL_FRAME_PARMS *frame_parms,uint8_t repetition);

Matthieu Kanj's avatar
Matthieu Kanj committed
589
NB_IoT_eNB_NULSCH_t *new_eNB_ulsch_NB_IoT(uint8_t max_turbo_iterations,uint8_t N_RB_UL, uint8_t abstraction_flag);
Matthieu Kanj's avatar
Matthieu Kanj committed
590

591 592


593
#endif