fhi_lib/app/src/common.c

   1 /******************************************************************************\r
   2 *\r
   3 *   Copyright (c) 2019 Intel.\r
   4 *\r
   5 *   Licensed under the Apache License, Version 2.0 (the "License");\r
   6 *   you may not use this file except in compliance with the License.\r
   7 *   You may obtain a copy of the License at\r
   8 *\r
   9 *       http://www.apache.org/licenses/LICENSE-2.0\r
  10 *\r
  11 *   Unless required by applicable law or agreed to in writing, software\r
  12 *   distributed under the License is distributed on an "AS IS" BASIS,\r
  13 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14 *   See the License for the specific language governing permissions and\r
  15 *   limitations under the License.\r
  16 *\r
  17 *******************************************************************************/\r
  18 \r
  19 #include <assert.h>\r
  20 #include <err.h>\r
  21 #include <arpa/inet.h>\r
  22 #include <sys/time.h>\r
  23 #include <time.h>\r
  24 \r
  25 #include "common.h"\r
  26 #include "xran_fh_o_du.h"\r
  27 #include "xran_pkt.h"\r
  28 #include "xran_pkt_up.h"\r
  29 #include "xran_cp_api.h"\r
  30 #include "xran_up_api.h"\r
  31 \r
  32 #include "xran_mlog_lnx.h"\r
  33 \r
  34 extern enum app_state state;\r
  35 \r
  36 int iq_playback_buffer_size_dl = IQ_PLAYBACK_BUFFER_BYTES;\r
  37 int iq_playback_buffer_size_ul = IQ_PLAYBACK_BUFFER_BYTES;\r
  38 \r
  39 int iq_bfw_buffer_size_dl = IQ_PLAYBACK_BUFFER_BYTES;\r
  40 int iq_bfw_buffer_size_ul = IQ_PLAYBACK_BUFFER_BYTES;\r
  41 \r
  42 int iq_srs_buffer_size_ul = IQ_PLAYBACK_BUFFER_BYTES;\r
  43 \r
  44 uint8_t numCCPorts = 1;\r
  45 /* Number of antennas supported by front-end */\r
  46 \r
  47 uint8_t num_eAxc = 4;\r
  48 /* Number of CPRI ports supported by front-end */\r
  49 \r
  50 int16_t *p_tx_play_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  51 int32_t tx_play_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  52 int32_t tx_play_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  53 \r
  54 int16_t *p_tx_prach_play_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  55 int32_t tx_prach_play_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  56 int32_t tx_prach_play_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  57 \r
  58 int16_t *p_tx_srs_play_buffer[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];\r
  59 int32_t tx_srs_play_buffer_size[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];\r
  60 int32_t tx_srs_play_buffer_position[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];\r
  61 \r
  62 int16_t *p_rx_log_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  63 int32_t rx_log_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  64 int32_t rx_log_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  65 \r
  66 int16_t *p_prach_log_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  67 int32_t prach_log_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  68 int32_t prach_log_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  69 \r
  70 int16_t *p_srs_log_buffer[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];\r
  71 int32_t srs_log_buffer_size[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];\r
  72 int32_t srs_log_buffer_position[XRAN_MAX_SECTOR_NR*XRAN_MAX_ANT_ARRAY_ELM_NR];\r
  73 \r
  74 int16_t *p_tx_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  75 int32_t tx_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  76 \r
  77 int16_t *p_rx_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  78 int32_t rx_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  79 \r
  80 /* beamforming weights for UL (O-DU) */\r
  81 int16_t *p_tx_dl_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  82 int32_t tx_dl_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  83 int32_t tx_dl_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  84 \r
  85 /* beamforming weights for UL (O-DU) */\r
  86 int16_t *p_tx_ul_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  87 int32_t tx_ul_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  88 int32_t tx_ul_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  89 \r
  90 /* beamforming weights for UL (O-RU) */\r
  91 int16_t *p_rx_dl_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  92 int32_t rx_dl_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  93 int32_t rx_dl_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  94 \r
  95 /* beamforming weights for UL (O-RU) */\r
  96 int16_t *p_rx_ul_bfw_buffer[MAX_ANT_CARRIER_SUPPORTED];\r
  97 int32_t rx_ul_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];\r
  98 int32_t rx_ul_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];\r
  99 \r
 100 // F1 Tables 38.101-1 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB\r
 101 uint16_t nNumRbsPerSymF1[3][13] =\r
 102 {\r
 103     //  5MHz    10MHz   15MHz   20 MHz  25 MHz  30 MHz  40 MHz  50MHz   60 MHz  70 MHz  80 MHz   90 MHz  100 MHz\r
 104         {25,    52,     79,     106,    133,    160,    216,    270,    0,         0,      0,      0,      0},         // Numerology 0 (15KHz)\r
 105         {11,    24,     38,     51,     65,     78,     106,    133,    162,       0,    217,    245,    273},         // Numerology 1 (30KHz)\r
 106         {0,     11,     18,     24,     31,     38,     51,     65,     79,        0,    107,    121,    135}          // Numerology 2 (60KHz)\r
 107 };\r
 108 \r
 109 // F2 Tables 38.101-2 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB\r
 110 uint16_t nNumRbsPerSymF2[2][4] =\r
 111 {\r
 112     //  50Mhz  100MHz  200MHz   400MHz\r
 113         {66,    132,    264,     0},        // Numerology 2 (60KHz)\r
 114         {32,    66,     132,     264}       // Numerology 3 (120KHz)\r
 115 };\r
 116 \r
 117 // 38.211 - Table 4.2.1\r
 118 uint16_t nSubCarrierSpacing[5] =\r
 119 {\r
 120     15,     // mu = 0\r
 121     30,     // mu = 1\r
 122     60,     // mu = 2\r
 123     120,    // mu = 3\r
 124     240     // mu = 4\r
 125 };\r
 126 \r
 127 // TTI interval in us (slot duration)\r
 128 uint16_t nTtiInterval[4] =\r
 129 {\r
 130     1000,     // mu = 0\r
 131     500,     // mu = 1\r
 132     250,     // mu = 2\r
 133     125,     // mu = 3\r
 134 };\r
 135 \r
 136 \r
 137 // F1 Tables 38.101-1 Table F.5.3. Window length for normal CP\r
 138 uint16_t nCpSizeF1[3][13][2] =\r
 139 {\r
 140     //    5MHz      10MHz      15MHz       20 MHz      25 MHz     30 MHz      40 MHz       50MHz       60 MHz      70 MHz     80 MHz     90 MHz     100 MHz\r
 141         {{40, 36}, {80, 72}, {120, 108}, {160, 144}, {160, 144}, {240, 216}, {320, 288}, {320, 288},     {0, 0},     {0, 0},     {0, 0},     {0, 0},     {0, 0}},        // Numerology 0 (15KHz)\r
 142         {{22, 18}, {44, 36},   {66, 54},   {88, 72},   {88, 72}, {132, 108}, {176, 144}, {176, 144}, {264, 216}, {264, 216}, {352, 288}, {352, 288}, {352, 288}},       // Numerology 1 (30KHz)\r
 143         {  {0, 0}, {26, 18},   {39, 27},   {52, 36},   {52, 36},   {78, 54},  {104, 72},  {104, 72}, {156, 108}, {156, 108}, {208, 144}, {208, 144}, {208, 144}},       // Numerology 2 (60KHz)\r
 144 };\r
 145 \r
 146 // F2 Tables 38.101-2 Table F.5.3. Window length for normal CP\r
 147 int16_t nCpSizeF2[2][4][2] =\r
 148 {\r
 149     //    50Mhz    100MHz      200MHz     400MHz\r
 150         {  {0, 0}, {104, 72}, {208, 144}, {416, 288}}, // Numerology 2 (60KHz)\r
 151         {{68, 36}, {136, 72}, {272, 144}, {544, 288}}, // Numerology 3 (120KHz)\r
 152 };\r
 153 \r
 154 uint32_t gMaxSlotNum;\r
 155 uint32_t gNumDLCtx;\r
 156 uint32_t gNumULCtx;\r
 157 uint32_t gDLResetAdvance;\r
 158 uint32_t gDLProcAdvance;\r
 159 uint32_t gULProcAdvance;\r
 160 \r
 161 static uint16_t g_NumSlotTDDLoop[XRAN_MAX_SECTOR_NR] = { XRAN_NUM_OF_SLOT_IN_TDD_LOOP };\r
 162 static uint16_t g_NumDLSymSp[XRAN_MAX_SECTOR_NR][XRAN_NUM_OF_SLOT_IN_TDD_LOOP] = {0};\r
 163 static uint16_t g_NumULSymSp[XRAN_MAX_SECTOR_NR][XRAN_NUM_OF_SLOT_IN_TDD_LOOP] = {0};\r
 164 static uint8_t g_SlotType[XRAN_MAX_SECTOR_NR][XRAN_NUM_OF_SLOT_IN_TDD_LOOP] = {{XRAN_SLOT_TYPE_INVALID}};\r
 165 float g_UlRate[XRAN_MAX_SECTOR_NR] = {0.0};\r
 166 float g_DlRate[XRAN_MAX_SECTOR_NR] = {0.0};\r
 167 \r
 168 uint32_t app_xran_get_tti_interval(uint8_t nMu)\r
 169 {\r
 170     if (nMu < 4)\r
 171     {\r
 172         return nTtiInterval[nMu];\r
 173     }\r
 174     else\r
 175     {\r
 176         printf("ERROR: %s Mu[%d] is not valid\n",__FUNCTION__, nMu);\r
 177     }\r
 178 \r
 179     return 0;\r
 180 }\r
 181 \r
 182 uint32_t app_xran_get_scs(uint8_t nMu)\r
 183 {\r
 184     if (nMu <= 3)\r
 185     {\r
 186         return nSubCarrierSpacing[nMu];\r
 187     }\r
 188     else\r
 189     {\r
 190         printf("ERROR: %s Mu[%d] is not valid\n",__FUNCTION__, nMu);\r
 191     }\r
 192 \r
 193     return 0;\r
 194 }\r
 195 \r
 196 \r
 197 \r
 198 \r
 199 //-------------------------------------------------------------------------------------------\r
 200 /** @ingroup group_nr5g_source_phy_common\r
 201  *\r
 202  *  @param[in]   nNumerology - Numerology determine sub carrier spacing, Value: 0->4 0: 15khz,  1: 30khz,  2: 60khz 3: 120khz, 4: 240khz\r
 203  *  @param[in]   nBandwidth - Carrier bandwidth for in MHz. Value: 5->400\r
 204  *  @param[in]   nAbsFrePointA - Abs Freq Point A of the Carrier Center Frequency for in KHz Value: 450000->52600000\r
 205  *\r
 206  *  @return  Number of RBs in cell\r
 207  *\r
 208  *  @description\r
 209  *  Returns number of RBs based on 38.101-1 and 38.101-2 for the cell\r
 210  *\r
 211 **/\r
 212 //-------------------------------------------------------------------------------------------\r
 213 uint16_t app_xran_get_num_rbs(uint32_t nNumerology, uint32_t nBandwidth, uint32_t nAbsFrePointA)\r
 214 {\r
 215     uint32_t error = 1;\r
 216     uint16_t numRBs = 0;\r
 217 \r
 218     if (nAbsFrePointA <= 6000000)\r
 219     {\r
 220         // F1 Tables 38.101-1 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB\r
 221         if (nNumerology < 3)\r
 222         {\r
 223             switch(nBandwidth)\r
 224             {\r
 225                 case PHY_BW_5_0_MHZ:\r
 226                     numRBs = nNumRbsPerSymF1[nNumerology][0];\r
 227                     error = 0;\r
 228                 break;\r
 229                 case PHY_BW_10_0_MHZ:\r
 230                     numRBs = nNumRbsPerSymF1[nNumerology][1];\r
 231                     error = 0;\r
 232                 break;\r
 233                 case PHY_BW_15_0_MHZ:\r
 234                     numRBs = nNumRbsPerSymF1[nNumerology][2];\r
 235                     error = 0;\r
 236                 break;\r
 237                 case PHY_BW_20_0_MHZ:\r
 238                     numRBs = nNumRbsPerSymF1[nNumerology][3];\r
 239                     error = 0;\r
 240                 break;\r
 241                 case PHY_BW_25_0_MHZ:\r
 242                     numRBs = nNumRbsPerSymF1[nNumerology][4];\r
 243                     error = 0;\r
 244                 break;\r
 245                 case PHY_BW_30_0_MHZ:\r
 246                     numRBs = nNumRbsPerSymF1[nNumerology][5];\r
 247                     error = 0;\r
 248                 break;\r
 249                 case PHY_BW_40_0_MHZ:\r
 250                     numRBs = nNumRbsPerSymF1[nNumerology][6];\r
 251                     error = 0;\r
 252                 break;\r
 253                 case PHY_BW_50_0_MHZ:\r
 254                     numRBs = nNumRbsPerSymF1[nNumerology][7];\r
 255                     error = 0;\r
 256                 break;\r
 257                 case PHY_BW_60_0_MHZ:\r
 258                     numRBs = nNumRbsPerSymF1[nNumerology][8];\r
 259                     error = 0;\r
 260                 break;\r
 261                 case PHY_BW_70_0_MHZ:\r
 262                     numRBs = nNumRbsPerSymF1[nNumerology][9];\r
 263                     error = 0;\r
 264                 break;\r
 265                 case PHY_BW_80_0_MHZ:\r
 266                     numRBs = nNumRbsPerSymF1[nNumerology][10];\r
 267                     error = 0;\r
 268                 break;\r
 269                 case PHY_BW_90_0_MHZ:\r
 270                     numRBs = nNumRbsPerSymF1[nNumerology][11];\r
 271                     error = 0;\r
 272                 break;\r
 273                 case PHY_BW_100_0_MHZ:\r
 274                     numRBs = nNumRbsPerSymF1[nNumerology][12];\r
 275                     error = 0;\r
 276                 break;\r
 277                 default:\r
 278                     error = 1;\r
 279                 break;\r
 280             }\r
 281         }\r
 282     }\r
 283     else\r
 284     {\r
 285         if ((nNumerology >= 2) && (nNumerology <= 3))\r
 286         {\r
 287             // F2 Tables 38.101-2 Table 5.3.2-1. Maximum transmission bandwidth configuration NRB\r
 288             switch(nBandwidth)\r
 289             {\r
 290                 case PHY_BW_50_0_MHZ:\r
 291                     numRBs = nNumRbsPerSymF2[nNumerology-2][0];\r
 292                     error = 0;\r
 293                 break;\r
 294                 case PHY_BW_100_0_MHZ:\r
 295                     numRBs = nNumRbsPerSymF2[nNumerology-2][1];\r
 296                     error = 0;\r
 297                 break;\r
 298                 case PHY_BW_200_0_MHZ:\r
 299                     numRBs = nNumRbsPerSymF2[nNumerology-2][2];\r
 300                     error = 0;\r
 301                 break;\r
 302                 case PHY_BW_400_0_MHZ:\r
 303                     numRBs = nNumRbsPerSymF2[nNumerology-2][3];\r
 304                     error = 0;\r
 305                 break;\r
 306                 default:\r
 307                     error = 1;\r
 308                 break;\r
 309             }\r
 310         }\r
 311     }\r
 312 \r
 313 \r
 314     if (error)\r
 315     {\r
 316         printf("ERROR: %s: nNumerology[%d] nBandwidth[%d] nAbsFrePointA[%d]\n",__FUNCTION__, nNumerology, nBandwidth, nAbsFrePointA);\r
 317     }\r
 318     else\r
 319     {\r
 320         printf("%s: nNumerology[%d] nBandwidth[%d] nAbsFrePointA[%d] numRBs[%d]\n",__FUNCTION__, nNumerology, nBandwidth, nAbsFrePointA, numRBs);\r
 321     }\r
 322 \r
 323     return numRBs;\r
 324 }\r
 325 \r
 326 //-------------------------------------------------------------------------------------------\r
 327 /** @ingroup phy_cal_nrarfcn\r
 328  *\r
 329  *  @param[in]   center frequency\r
 330  *\r
 331  *  @return  NR-ARFCN\r
 332  *\r
 333  *  @description\r
 334  *  This calculates NR-ARFCN value according to center frequency\r
 335  *\r
 336 **/\r
 337 //-------------------------------------------------------------------------------------------\r
 338 uint32_t app_xran_cal_nrarfcn(uint32_t nCenterFreq)\r
 339 {\r
 340     uint32_t nDeltaFglobal,nFoffs,nNoffs;\r
 341     uint32_t nNRARFCN = 0;\r
 342 \r
 343     if(nCenterFreq > 0 && nCenterFreq < 3000*1000)\r
 344     {\r
 345         nDeltaFglobal = 5;\r
 346         nFoffs = 0;\r
 347         nNoffs = 0;\r
 348     }\r
 349     else if(nCenterFreq >= 3000*1000 && nCenterFreq < 24250*1000)\r
 350     {\r
 351         nDeltaFglobal = 15;\r
 352         nFoffs = 3000*1000;\r
 353         nNoffs = 600000;\r
 354     }\r
 355     else if(nCenterFreq >= 24250*1000 && nCenterFreq <= 100000*1000)\r
 356     {\r
 357         nDeltaFglobal = 60;\r
 358         nFoffs = 24250080;\r
 359         nNoffs = 2016667;\r
 360     }\r
 361     else\r
 362     {\r
 363          printf("@@@@ incorrect center frerquency %d\n",nCenterFreq);\r
 364          return (0);\r
 365     }\r
 366 \r
 367     nNRARFCN = ((nCenterFreq - nFoffs)/nDeltaFglobal) + nNoffs;\r
 368 \r
 369     printf("%s: nCenterFreq[%d] nDeltaFglobal[%d] nFoffs[%d] nNoffs[%d] nNRARFCN[%d]\n", __FUNCTION__, nCenterFreq, nDeltaFglobal, nFoffs, nNoffs, nNRARFCN);\r
 370     return (nNRARFCN);\r
 371 }\r
 372 \r
 373 int32_t app_xran_slot_limit(int32_t nSfIdx)\r
 374 {\r
 375     while (nSfIdx < 0) {\r
 376         nSfIdx += gMaxSlotNum;\r
 377     }\r
 378 \r
 379     while (nSfIdx >= gMaxSlotNum) {\r
 380         nSfIdx -= gMaxSlotNum;\r
 381     }\r
 382 \r
 383     return nSfIdx;\r
 384 }\r
 385 \r
 386 void app_xran_clear_slot_type(uint32_t nPhyInstanceId)\r
 387 {\r
 388     g_UlRate[nPhyInstanceId] = 0.0;\r
 389     g_DlRate[nPhyInstanceId] = 0.0;\r
 390     g_NumSlotTDDLoop[nPhyInstanceId] = 1;\r
 391 }\r
 392 \r
 393 int32_t app_xran_set_slot_type(uint32_t nPhyInstanceId, uint32_t nFrameDuplexType, uint32_t nTddPeriod, struct xran_slot_config *psSlotConfig)\r
 394 {\r
 395     uint32_t nSlotNum, nSymNum, nVal, i;\r
 396     uint32_t numDlSym, numUlSym, numGuardSym;\r
 397     uint32_t numDlSlots = 0, numUlSlots = 0, numSpDlSlots = 0, numSpUlSlots = 0, numSpSlots = 0;\r
 398     char sSlotPattern[XRAN_SLOT_TYPE_LAST][10] = {"IN\0", "DL\0", "UL\0", "SP\0", "FD\0"};\r
 399 \r
 400     // nPhyInstanceId    Carrier ID\r
 401     // nFrameDuplexType  0 = FDD 1 = TDD\r
 402     // nTddPeriod        Tdd Periodicity\r
 403     // psSlotConfig[80]  Slot Config Structure for nTddPeriod Slots\r
 404 \r
 405     g_UlRate[nPhyInstanceId] = 0.0;\r
 406     g_DlRate[nPhyInstanceId] = 0.0;\r
 407     g_NumSlotTDDLoop[nPhyInstanceId] = nTddPeriod;\r
 408 \r
 409     for (i = 0; i < XRAN_NUM_OF_SLOT_IN_TDD_LOOP; i++)\r
 410     {\r
 411         g_SlotType[nPhyInstanceId][i] = XRAN_SLOT_TYPE_INVALID;\r
 412         g_NumDLSymSp[nPhyInstanceId][i] = 0;\r
 413         g_NumULSymSp[nPhyInstanceId][i] = 0;\r
 414     }\r
 415 \r
 416     if (nFrameDuplexType == XRAN_FDD)\r
 417     {\r
 418         for (i = 0; i < XRAN_NUM_OF_SLOT_IN_TDD_LOOP; i++)\r
 419         {\r
 420             g_SlotType[nPhyInstanceId][i] = XRAN_SLOT_TYPE_FDD;\r
 421         }\r
 422         g_NumSlotTDDLoop[nPhyInstanceId] = 1;\r
 423         g_DlRate[nPhyInstanceId] = 1.0;\r
 424         g_UlRate[nPhyInstanceId] = 1.0;\r
 425     }\r
 426     else\r
 427     {\r
 428         for (nSlotNum = 0; nSlotNum < nTddPeriod; nSlotNum++)\r
 429         {\r
 430             numDlSym = 0;\r
 431             numUlSym = 0;\r
 432             numGuardSym = 0;\r
 433             for (nSymNum = 0; nSymNum < XRAN_NUM_OF_SYMBOL_PER_SLOT; nSymNum++)\r
 434             {\r
 435                 switch(psSlotConfig[nSlotNum].nSymbolType[nSymNum])\r
 436                 {\r
 437                     case XRAN_SYMBOL_TYPE_DL:\r
 438                         numDlSym++;\r
 439                     break;\r
 440                     case XRAN_SYMBOL_TYPE_GUARD:\r
 441                         numGuardSym++;\r
 442                     break;\r
 443                     default:\r
 444                         numUlSym++;\r
 445                     break;\r
 446                 }\r
 447             }\r
 448 \r
 449             // printf("nSlotNum[%d] : numDlSym[%d] numGuardSym[%d] numUlSym[%d]\n", nSlotNum, numDlSym, numGuardSym, numUlSym);\r
 450 \r
 451             if ((numUlSym == 0) && (numGuardSym == 0))\r
 452             {\r
 453                 g_SlotType[nPhyInstanceId][nSlotNum] = XRAN_SLOT_TYPE_DL;\r
 454                 numDlSlots++;\r
 455             }\r
 456             else if ((numDlSym == 0) && (numGuardSym == 0))\r
 457             {\r
 458                 g_SlotType[nPhyInstanceId][nSlotNum] = XRAN_SLOT_TYPE_UL;\r
 459                 numUlSlots++;\r
 460             }\r
 461             else\r
 462             {\r
 463                 g_SlotType[nPhyInstanceId][nSlotNum] = XRAN_SLOT_TYPE_SP;\r
 464                 numSpSlots++;\r
 465 \r
 466                 if (numDlSym)\r
 467                 {\r
 468                     numSpDlSlots++;\r
 469                     g_NumDLSymSp[nPhyInstanceId][nSlotNum] = numDlSym;\r
 470                 }\r
 471                 if (numUlSym)\r
 472                 {\r
 473                     numSpUlSlots++;\r
 474                     g_NumULSymSp[nPhyInstanceId][nSlotNum] = numUlSym;\r
 475                 }\r
 476             }\r
 477 \r
 478             // printf("            numDlSlots[%d] numUlSlots[%d] numSpSlots[%d] numSpDlSlots[%d] numSpUlSlots[%d]\n", numDlSlots, numUlSlots, numSpSlots, numSpDlSlots, numSpUlSlots);\r
 479         }\r
 480 \r
 481         g_DlRate[nPhyInstanceId] = (float)(numDlSlots + numSpDlSlots) / (float)nTddPeriod;\r
 482         g_UlRate[nPhyInstanceId] = (float)(numUlSlots + numSpUlSlots) / (float)nTddPeriod;\r
 483     }\r
 484 \r
 485     printf("set_slot_type: nPhyInstanceId[%d] nFrameDuplexType[%d], nTddPeriod[%d]\n",\r
 486         nPhyInstanceId, nFrameDuplexType, nTddPeriod);\r
 487 \r
 488     printf("DLRate[%f] ULRate[%f]\n", g_DlRate[nPhyInstanceId], g_UlRate[nPhyInstanceId]);\r
 489 \r
 490     nVal = (g_NumSlotTDDLoop[nPhyInstanceId] < 10) ? g_NumSlotTDDLoop[nPhyInstanceId] : 10;\r
 491 \r
 492     printf("SlotPattern:\n");\r
 493     printf("Slot:   ");\r
 494     for (nSlotNum = 0; nSlotNum < nVal; nSlotNum++)\r
 495     {\r
 496         printf("%d    ", nSlotNum);\r
 497     }\r
 498     printf("\n");\r
 499 \r
 500     printf("  %3d   ", 0);\r
 501     for (nSlotNum = 0, i = 0; nSlotNum < g_NumSlotTDDLoop[nPhyInstanceId]; nSlotNum++)\r
 502     {\r
 503         printf("%s   ", sSlotPattern[g_SlotType[nPhyInstanceId][nSlotNum]]);\r
 504         i++;\r
 505         if ((i == 10) && ((nSlotNum+1) < g_NumSlotTDDLoop[nPhyInstanceId]))\r
 506         {\r
 507             printf("\n");\r
 508             printf("  %3d   ", nSlotNum);\r
 509             i = 0;\r
 510         }\r
 511     }\r
 512     printf("\n\n");\r
 513 \r
 514     return 0;\r
 515 }\r
 516 \r
 517 int32_t app_xran_get_slot_type(int32_t nCellIdx, int32_t nSlotdx, int32_t nType)\r
 518 {\r
 519     int32_t nSfIdxMod, nSfType, ret = 0;\r
 520 \r
 521     nSfIdxMod = app_xran_slot_limit(nSlotdx) % ((g_NumSlotTDDLoop[nCellIdx] > 0) ? g_NumSlotTDDLoop[nCellIdx]: 1);\r
 522     nSfType = g_SlotType[nCellIdx][nSfIdxMod];\r
 523 \r
 524     if (nSfType == nType)\r
 525     {\r
 526         ret = 1;\r
 527     }\r
 528     else if (nSfType == XRAN_SLOT_TYPE_SP)\r
 529     {\r
 530         if ((nType == XRAN_SLOT_TYPE_DL) && g_NumDLSymSp[nCellIdx][nSfIdxMod])\r
 531         {\r
 532             ret = 1;\r
 533         }\r
 534 \r
 535         if ((nType == XRAN_SLOT_TYPE_UL) && g_NumULSymSp[nCellIdx][nSfIdxMod])\r
 536         {\r
 537             ret = 1;\r
 538         }\r
 539     }\r
 540     else if (nSfType == XRAN_SLOT_TYPE_FDD)\r
 541     {\r
 542         ret = 1;\r
 543     }\r
 544 \r
 545     return ret;\r
 546 }\r
 547 \r
 548 \r
 549 \r
 550 void sys_save_buf_to_file(char *filename, char *bufname, unsigned char *pBuffer, unsigned int size, unsigned int buffers_num)\r
 551 {\r
 552     if (size)\r
 553     {\r
 554         if (filename && bufname)\r
 555         {\r
 556             FILE           *file;\r
 557             printf("Storing %s to file %s: ", bufname, filename);\r
 558             file = fopen(filename, "wb");\r
 559             if (file == NULL)\r
 560             {\r
 561                 printf("can't open file %s!!!", filename);\r
 562             }\r
 563             else\r
 564             {\r
 565                 uint32_t             num;\r
 566                 num = fwrite(pBuffer, buffers_num, size, file);\r
 567                 fflush(file);\r
 568                 fclose(file);\r
 569                 printf("from addr (0x%lx) size (%d) bytes num (%d)", (uint64_t)pBuffer, size, num);\r
 570             }\r
 571             printf(" \n");\r
 572         }\r
 573         else\r
 574         {\r
 575             printf(" the file name, buffer name are not set!!!");\r
 576         }\r
 577     }\r
 578     else\r
 579     {\r
 580         printf(" the %s is free: size = %d bytes!!!", bufname, size);\r
 581     }\r
 582 }\r
 583 \r
 584 int sys_load_file_to_buff(char *filename, char *bufname, unsigned char *pBuffer, unsigned int size, unsigned int buffers_num)\r
 585 {\r
 586     unsigned int  file_size = 0;\r
 587     int  num= 0;\r
 588 \r
 589     if (size)\r
 590     {\r
 591         if (filename && bufname)\r
 592         {\r
 593             FILE           *file;\r
 594             printf("Loading file %s to  %s: ", filename, bufname);\r
 595             file = fopen(filename, "rb");\r
 596 \r
 597 \r
 598             if (file == NULL)\r
 599             {\r
 600                 printf("can't open file %s!!!", filename);\r
 601                 exit(-1);\r
 602             }\r
 603             else\r
 604             {\r
 605                 fseek(file, 0, SEEK_END);\r
 606                 file_size = ftell(file);\r
 607                 fseek(file, 0, SEEK_SET);\r
 608 \r
 609                 if ((file_size > size) || (file_size == 0))\r
 610                     file_size = size;\r
 611 \r
 612                 printf("Reading IQ samples from file: File Size: %d [Buffer Size: %d]\n", file_size, size);\r
 613 \r
 614                 num = fread(pBuffer, buffers_num, size, file);\r
 615                 fflush(file);\r
 616                 fclose(file);\r
 617                 printf("from addr (0x%lx) size (%d) bytes num (%d)", (uint64_t)pBuffer, file_size, num);\r
 618             }\r
 619             printf(" \n");\r
 620 \r
 621         }\r
 622         else\r
 623         {\r
 624             printf(" the file name, buffer name are not set!!!");\r
 625         }\r
 626     }\r
 627     else\r
 628     {\r
 629         printf(" the %s is free: size = %d bytes!!!", bufname, size);\r
 630     }\r
 631     return num;\r
 632 }\r
 633 \r
 634 \r
 635 void sys_save_buf_to_file_txt(char *filename, char *bufname, unsigned char *pBuffer, unsigned int size, unsigned int buffers_num)\r
 636 {\r
 637     unsigned int i;\r
 638     int ret = 0;\r
 639     if (pBuffer == NULL)\r
 640         return;\r
 641 \r
 642     if (size)\r
 643     {\r
 644         if (filename && bufname)\r
 645         {\r
 646             FILE           *file;\r
 647             printf("Storing %s to file %s: ", bufname, filename);\r
 648             file = fopen(filename, "w");\r
 649             if (file == NULL)\r
 650             {\r
 651                 printf("can't open file %s!!!", filename);\r
 652                 exit(-1);\r
 653             }\r
 654             else\r
 655             {\r
 656                 uint32_t num = 0;\r
 657 \r
 658                 signed short *ptr = (signed short*)pBuffer;\r
 659                 for (i = 0; i < (size/((unsigned int)sizeof(signed short) /** 2 * 2 * 2*/)); i = i + 2)\r
 660                 {\r
 661 #ifndef CSCOPE_DEBUG\r
 662                     ret = fprintf(file,"%d %d\n", ptr[i], ptr[i + 1]);\r
 663 #else\r
 664                     ret = fprintf(file,"%d %d ", ptr[i], ptr[i + 1]);\r
 665                     /*      I data => Ramp data, from 1 to 792.\r
 666                             Q data => Contains time information of the current symbol:\r
 667                             Bits [15:14] = Antenna-ID\r
 668                             Bits [13:12] = \9300\94\r
 669                             Bits [11:8]  = Subframe-ID\r
 670                             Bits [7:4]   = Slot-ID\r
 671                             Bits [3:0]   = Symbol-ID */\r
 672                             fprintf(file, "0x%04x: ant %d Subframe-ID %d Slot-ID %d Symbol-ID %d\n",\r
 673                                         ptr[i + 1], (ptr[i + 1]>>14) & 0x3,  (ptr[i + 1]>>8) & 0xF,  (ptr[i + 1]>>4) & 0xF, (ptr[i + 1]>>0) & 0xF);\r
 674 #endif\r
 675                     if (ret < 0)\r
 676                     {\r
 677                         printf("fprintf %d\n", ret);\r
 678                         fclose(file);\r
 679                         break;\r
 680                     }\r
 681                     num++;\r
 682                 }\r
 683                 fflush(file);\r
 684                 fclose(file);\r
 685                 printf("from addr (0x%lx) size (%d) IQ num (%d)", (uint64_t)pBuffer, size, num);\r
 686             }\r
 687             printf(" \n");\r
 688         }\r
 689         else\r
 690         {\r
 691             printf(" the file name, buffer name are not set!!!");\r
 692         }\r
 693     }\r
 694     else\r
 695     {\r
 696         printf(" the %s is free: size = %d bytes!!!", bufname, size);\r
 697     }\r
 698 }\r
 699 \r