/* * 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 config_ue.c * \brief common utility functions for NR (gNB and UE) * \author R. Knopp, * \date 2019 * \version 0.1 * \company Eurecom * \email: knopp@eurecom.fr * \note * \warning */ #include #include "assertions.h" #include "nr_common.h" const char *duplex_mode[]={"FDD","TDD"}; int tables_5_3_2[5][11] = { {25, 52, 79, 106, 133, 160, 216, 270, -1, -1, -1}, // 15 FR1 {11, 24, 38, 51, 65, 78, 106, 133, 162, 217, 273}, // 30 FR1 {-1, 11, 18, 24, 31, 38, 51, 65, 79, 107, 135}, // 60 FR1 {66, 132, 264, -1 , -1, -1, -1, -1, -1, -1, -1}, // 60 FR2 {32, 66, 132, 264, -1, -1, -1, -1, -1, -1, -1} // 120FR2 }; int get_supported_band_index(int scs, int band, int n_rbs){ int scs_index = scs; if (band>256) scs_index++; for (int i=0; i<11; i++) { if(n_rbs == tables_5_3_2[scs][i]) return i; } return (-1); // not found } // Table 5.2-1 NR operating bands in FR1 & FR2 (3GPP TS 38.101) // Table 5.4.2.3-1 Applicable NR-ARFCN per operating band in FR1 & FR2 (3GPP TS 38.101) // Notes: // - N_OFFs for bands from 80 to 89 and band 95 is referred to UL // - Frequencies are expressed in KHz // - col: NR_band ul_min ul_max dl_min dl_max step N_OFFs_DL deltaf_raster const nr_bandentry_t nr_bandtable[] = { {1, 1920000, 1980000, 2110000, 2170000, 20, 422000, 100}, {2, 1850000, 1910000, 1930000, 1990000, 20, 386000, 100}, {3, 1710000, 1785000, 1805000, 1880000, 20, 361000, 100}, {5, 824000, 849000, 869000, 894000, 20, 173800, 100}, {7, 2500000, 2570000, 2620000, 2690000, 20, 524000, 100}, {8, 880000, 915000, 925000, 960000, 20, 185000, 100}, {12, 698000, 716000, 729000, 746000, 20, 145800, 100}, {14, 788000, 798000, 758000, 768000, 20, 151600, 100}, {18, 815000, 830000, 860000, 875000, 20, 172000, 100}, {20, 832000, 862000, 791000, 821000, 20, 158200, 100}, {25, 1850000, 1915000, 1930000, 1995000, 20, 386000, 100}, {26, 814000, 849000, 859000, 894000, 20, 171800, 100}, {28, 703000, 758000, 758000, 813000, 20, 151600, 100}, {29, 000, 000, 717000, 728000, 20, 143400, 100}, {30, 2305000, 2315000, 2350000, 2360000, 20, 470000, 100}, {34, 2010000, 2025000, 2010000, 2025000, 20, 402000, 100}, {38, 2570000, 2620000, 2570000, 2630000, 20, 514000, 100}, {39, 1880000, 1920000, 1880000, 1920000, 20, 376000, 100}, {40, 2300000, 2400000, 2300000, 2400000, 20, 460000, 100}, {41, 2496000, 2690000, 2496000, 2690000, 3, 499200, 15}, {41, 2496000, 2690000, 2496000, 2690000, 6, 499200, 30}, {47, 5855000, 5925000, 5855000, 5925000, 1, 790334, 15}, {48, 3550000, 3700000, 3550000, 3700000, 1, 636667, 15}, {48, 3550000, 3700000, 3550000, 3700000, 2, 636668, 30}, {50, 1432000, 1517000, 1432000, 1517000, 20, 286400, 100}, {51, 1427000, 1432000, 1427000, 1432000, 20, 285400, 100}, {53, 2483500, 2495000, 2483500, 2495000, 20, 496700, 100}, {65, 1920000, 2010000, 2110000, 2200000, 20, 422000, 100}, {66, 1710000, 1780000, 2110000, 2200000, 20, 422000, 100}, {70, 1695000, 1710000, 1995000, 2020000, 20, 399000, 100}, {71, 663000, 698000, 617000, 652000, 20, 123400, 100}, {74, 1427000, 1470000, 1475000, 1518000, 20, 295000, 100}, {75, 000, 000, 1432000, 1517000, 20, 286400, 100}, {76, 000, 000, 1427000, 1432000, 20, 285400, 100}, {77, 3300000, 4200000, 3300000, 4200000, 1, 620000, 15}, {77, 3300000, 4200000, 3300000, 4200000, 2, 620000, 30}, {78, 3300000, 3800000, 3300000, 3800000, 1, 620000, 15}, {78, 3300000, 3800000, 3300000, 3800000, 2, 620000, 30}, {79, 4400010, 5000000, 4400010, 5000000, 1, 693334, 15}, {79, 4400010, 5000000, 4400010, 5000000, 2, 693334, 30}, {80, 1710000, 1785000, 000, 000, 20, 342000, 100}, {81, 880000, 915000, 000, 000, 20, 176000, 100}, {82, 832000, 862000, 000, 000, 20, 166400, 100}, {83, 703000, 748000, 000, 000, 20, 140600, 100}, {84, 1920000, 1980000, 000, 000, 20, 384000, 100}, {86, 1710000, 1785000, 000, 000, 20, 342000, 100}, {89, 824000, 849000, 000, 000, 20, 342000, 100}, {90, 2496000, 2690000, 2496000, 2690000, 3, 499200, 15}, {90, 2496000, 2690000, 2496000, 2690000, 6, 499200, 30}, {90, 2496000, 2690000, 2496000, 2690000, 20, 499200, 100}, {91, 832000, 862000, 1427000, 1432000, 20, 285400, 100}, {92, 832000, 862000, 1432000, 1517000, 20, 286400, 100}, {93, 880000, 915000, 1427000, 1432000, 20, 285400, 100}, {94, 880000, 915000, 1432000, 1517000, 20, 286400, 100}, {95, 2010000, 2025000, 000, 000, 20, 402000, 100}, {96, 5925000, 7125000, 5925000, 7125000, 1, 795000, 15}, {257,26500020,29500000,26500020,29500000, 1,2054166, 60}, {257,26500080,29500000,26500080,29500000, 2,2054167, 120}, {258,24250080,27500000,24250080,27500000, 1,2016667, 60}, {258,24250080,27500000,24250080,27500000, 2,2016667, 120}, {260,37000020,40000000,37000020,40000000, 1,2229166, 60}, {260,37000080,40000000,37000080,40000000, 2,2229167, 120}, {261,27500040,28350000,27500040,28350000, 1,2070833, 60}, {261,27500040,28350000,27500040,28350000, 2,2070833, 120} }; uint16_t get_band(uint64_t downlink_frequency, int32_t delta_duplex) { const uint64_t dl_freq_khz = downlink_frequency / 1000; const int32_t delta_duplex_khz = delta_duplex / 1000; uint64_t center_freq_diff_khz = 999999999999999999; // 2^64 uint16_t current_band = 0; for (int ind = 0; ind < sizeofArray(nr_bandtable); ind++) { if (dl_freq_khz < nr_bandtable[ind].dl_min || dl_freq_khz > nr_bandtable[ind].dl_max) continue; int32_t current_offset_khz = nr_bandtable[ind].ul_min - nr_bandtable[ind].dl_min; if (current_offset_khz != delta_duplex_khz) continue; uint64_t center_frequency_khz = (nr_bandtable[ind].dl_max + nr_bandtable[ind].dl_min) / 2; if (abs(dl_freq_khz - center_frequency_khz) < center_freq_diff_khz){ current_band = nr_bandtable[ind].band; center_freq_diff_khz = abs(dl_freq_khz - center_frequency_khz); } } printf("DL frequency %"PRIu64": band %d, UL frequency %"PRIu64"\n", downlink_frequency, current_band, downlink_frequency+delta_duplex); AssertFatal(current_band != 0, "Can't find EUTRA band for frequency %"PRIu64" and duplex_spacing %u\n", downlink_frequency, delta_duplex); return current_band; } int NRRIV2BW(int locationAndBandwidth,int N_RB) { int tmp = locationAndBandwidth/N_RB; int tmp2 = locationAndBandwidth%N_RB; if (tmp <= ((N_RB>>1)+1) && (tmp+tmp2)>1)+1) && (tmp+tmp2)0 && (NPRB + RBstart <= BWPsize),"Illegal NPRB/RBstart Configuration (%d,%d) for BWPsize %d\n",NPRB,RBstart,BWPsize); if (NPRB <= 1+(BWPsize>>1)) return(BWPsize*(NPRB-1)+RBstart); else return(BWPsize*(BWPsize+1-NPRB) + (BWPsize-1-RBstart)); } int PRBalloc_to_locationandbandwidth(int NPRB,int RBstart) { return(PRBalloc_to_locationandbandwidth0(NPRB,RBstart,275)); } int cce_to_reg_interleaving(const int R, int k, int n_shift, const int C, int L, const int N_regs) { int f; // interleaving function if(R==0) f = k; else { int c = k/R; int r = k%R; f = (r*C + c + n_shift)%(N_regs/L); } return f; } void get_coreset_rballoc(uint8_t *FreqDomainResource,int *n_rb,int *rb_offset) { uint8_t count=0, start=0, start_set=0; uint64_t bitmap = (((uint64_t)FreqDomainResource[0])<<37)| (((uint64_t)FreqDomainResource[1])<<29)| (((uint64_t)FreqDomainResource[2])<<21)| (((uint64_t)FreqDomainResource[3])<<13)| (((uint64_t)FreqDomainResource[4])<<5)| (((uint64_t)FreqDomainResource[5])>>3); for (int i=0; i<45; i++) if ((bitmap>>(44-i))&1) { count++; if (!start_set) { start = i; start_set = 1; } } *rb_offset = 6*start; *n_rb = 6*count; } int get_nb_periods_per_frame(uint8_t tdd_period) { int nb_periods_per_frame; switch(tdd_period) { case 0: nb_periods_per_frame = 20; // 10ms/0p5ms break; case 1: nb_periods_per_frame = 16; // 10ms/0p625ms break; case 2: nb_periods_per_frame = 10; // 10ms/1ms break; case 3: nb_periods_per_frame = 8; // 10ms/1p25ms break; case 4: nb_periods_per_frame = 5; // 10ms/2ms break; case 5: nb_periods_per_frame = 4; // 10ms/2p5ms break; case 6: nb_periods_per_frame = 2; // 10ms/5ms break; case 7: nb_periods_per_frame = 1; // 10ms/10ms break; default: AssertFatal(1==0,"Undefined tdd period %d\n", tdd_period); } return nb_periods_per_frame; } int get_dmrs_port(int nl, uint16_t dmrs_ports) { if (dmrs_ports == 0) return 0; // dci 1_0 int p = -1; int found = -1; for (int i=0; i<12; i++) { // loop over dmrs ports if((dmrs_ports>>i)&0x01) { // check if current bit is 1 found++; if (found == nl) { // found antenna port number corresponding to current layer p = i; break; } } } AssertFatal(p>-1,"No dmrs port corresponding to layer %d found\n",nl); return p; } frame_type_t get_frame_type(uint16_t current_band, uint8_t scs_index) { frame_type_t current_type; int32_t delta_duplex = get_delta_duplex(current_band, scs_index); if (delta_duplex == 0) current_type = TDD; else current_type = FDD; LOG_I(NR_MAC, "NR band %d, duplex mode %s, duplex spacing = %d KHz\n", current_band, duplex_mode[current_type], delta_duplex); return current_type; } // Computes the duplex spacing (either positive or negative) in KHz int32_t get_delta_duplex(int nr_bandP, uint8_t scs_index) { int nr_table_idx = get_nr_table_idx(nr_bandP, scs_index); int32_t delta_duplex = (nr_bandtable[nr_table_idx].ul_min - nr_bandtable[nr_table_idx].dl_min); LOG_I(NR_MAC, "NR band duplex spacing is %d KHz (nr_bandtable[%d].band = %d)\n", delta_duplex, nr_table_idx, nr_bandtable[nr_table_idx].band); return delta_duplex; } uint16_t config_bandwidth(int mu, int nb_rb, int nr_band) { if (nr_band < 100) { //FR1 switch(mu) { case 0 : if (nb_rb<=25) return 5; if (nb_rb<=52) return 10; if (nb_rb<=79) return 15; if (nb_rb<=106) return 20; if (nb_rb<=133) return 25; if (nb_rb<=160) return 30; if (nb_rb<=216) return 40; if (nb_rb<=270) return 50; AssertFatal(1==0,"Number of DL resource blocks %d undefined for mu %d and band %d\n", nb_rb, mu, nr_band); break; case 1 : if (nb_rb<=11) return 5; if (nb_rb<=24) return 10; if (nb_rb<=38) return 15; if (nb_rb<=51) return 20; if (nb_rb<=65) return 25; if (nb_rb<=78) return 30; if (nb_rb<=106) return 40; if (nb_rb<=133) return 50; if (nb_rb<=162) return 60; if (nb_rb<=189) return 70; if (nb_rb<=217) return 80; if (nb_rb<=245) return 90; if (nb_rb<=273) return 100; AssertFatal(1==0,"Number of DL resource blocks %d undefined for mu %d and band %d\n", nb_rb, mu, nr_band); break; case 2 : if (nb_rb<=11) return 10; if (nb_rb<=18) return 15; if (nb_rb<=24) return 20; if (nb_rb<=31) return 25; if (nb_rb<=38) return 30; if (nb_rb<=51) return 40; if (nb_rb<=65) return 50; if (nb_rb<=79) return 60; if (nb_rb<=93) return 70; if (nb_rb<=107) return 80; if (nb_rb<=121) return 90; if (nb_rb<=135) return 100; AssertFatal(1==0,"Number of DL resource blocks %d undefined for mu %d and band %d\n", nb_rb, mu, nr_band); break; default: AssertFatal(1==0,"Numerology %d undefined for band %d in FR1\n", mu,nr_band); } } else { switch(mu) { case 2 : if (nb_rb<=66) return 50; if (nb_rb<=132) return 100; if (nb_rb<=264) return 200; AssertFatal(1==0,"Number of DL resource blocks %d undefined for mu %d and band %d\n", nb_rb, mu, nr_band); break; case 3 : if (nb_rb<=32) return 50; if (nb_rb<=66) return 100; if (nb_rb<=132) return 200; if (nb_rb<=264) return 400; AssertFatal(1==0,"Number of DL resource blocks %d undefined for mu %d and band %d\n", nb_rb, mu, nr_band); break; default: AssertFatal(1==0,"Numerology %d undefined for band %d in FR1\n", mu,nr_band); } } } // Returns the corresponding row index of the NR table int get_nr_table_idx(int nr_bandP, uint8_t scs_index) { int scs_khz = 15 << scs_index; int supplementary_bands[] = {29,75,76,80,81,82,83,84,86,89,95}; for(int j = 0; j < sizeofArray(supplementary_bands); j++){ if (nr_bandP == supplementary_bands[j]) AssertFatal(0 == 1, "Band %d is a supplementary band (%d). This is not supported yet.\n", nr_bandP, supplementary_bands[j]); } int i; for (i = 0; i < sizeofArray(nr_bandtable); i++) { if ( nr_bandtable[i].band == nr_bandP && nr_bandtable[i].deltaf_raster == scs_khz ) break; } if (i == sizeofArray(nr_bandtable)) { LOG_I(PHY, "not found same deltaf_raster == scs_khz, use only band and last deltaf_raster \n"); for(i=sizeofArray(nr_bandtable)-1; i >=0; i--) if ( nr_bandtable[i].band == nr_bandP ) break; } AssertFatal(i > 0 && i < sizeofArray(nr_bandtable), "band is not existing: %d\n",nr_bandP); LOG_D(PHY, "NR band table index %d (Band %d, dl_min %lu, ul_min %lu)\n", i, nr_bandtable[i].band, nr_bandtable[i].dl_min,nr_bandtable[i].ul_min); return i; } int get_subband_size(int NPRB,int size) { // implements table 5.2.1.4-2 from 36.214 // //Bandwidth part (PRBs) Subband size (PRBs) // < 24 N/A //24 – 72 4, 8 //73 – 144 8, 16 //145 – 275 16, 32 if (NPRB<24) return(1); if (NPRB<72) return (size==0 ? 4 : 8); if (NPRB<144) return (size==0 ? 8 : 16); if (NPRB<275) return (size==0 ? 16 : 32); AssertFatal(1==0,"Shouldn't get here, NPRB %d\n",NPRB); } // from start symbol index and nb or symbols to symbol occupation bitmap in a slot uint16_t SL_to_bitmap(int startSymbolIndex, int nrOfSymbols) { return ((1<= 0 && (SLIVdiv14 <= 13-SLIVmod14)) { *L=SLIVdiv14+1; *S=SLIVmod14; } else { *L=15-SLIVdiv14; *S=13-SLIVmod14; } }