upload info.yaml file
[o-du/phy.git] / 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