#include "xran_mlog_lnx.h"
#include "xran_fh_o_du.h"
+#include "xran_fh_o_ru.h"
#include "xran_compression.h"
#include "xran_cp_api.h"
#include "xran_sync_api.h"
#include "xran_mlog_task_id.h"
#include "app_io_fh_xran.h"
-
+#ifdef FWK_ENABLED
+#include "app_bbu_pool.h"
+#endif
/* buffers size */
uint32_t nFpgaToSW_FTH_RxBufferLen;
uint32_t nFpgaToSW_PRACH_RxBufferLen;
void app_io_xran_fh_rx_prach_callback(void *pCallbackTag, int32_t status);
void app_io_xran_fh_rx_srs_callback(void *pCallbackTag, xran_status_t status);
+#ifndef FWK_ENABLED
+void app_io_xran_fh_bbu_rx_callback(void *pCallbackTag, xran_status_t status);
+void app_io_xran_fh_bbu_rx_bfw_callback(void *pCallbackTag, xran_status_t status);
+void app_io_xran_fh_bbu_rx_prach_callback(void *pCallbackTag, xran_status_t status);
+void app_io_xran_fh_bbu_rx_srs_callback(void *pCallbackTag, xran_status_t status);
+#endif
+
+extern RuntimeConfig* p_startupConfiguration[XRAN_PORTS_NUM];
+
struct bbu_xran_io_if *
app_io_xran_if_alloc(void)
{
uint32_t nSlotIdx;
uint64_t nSecond;
- uint32_t nXranTime = xran_get_slot_idx(0, &nFrameIdx, &nSubframeIdx, &nSlotIdx, &nSecond);
+ /*uint32_t nXranTime = */xran_get_slot_idx(0, &nFrameIdx, &nSubframeIdx, &nSlotIdx, &nSecond);
nSfIdx = nFrameIdx*NUM_OF_SUBFRAME_PER_FRAME*nNrOfSlotInSf
+ nSubframeIdx*nNrOfSlotInSf
+ nSlotIdx;
uint64_t t1 = MLogTick();
uint32_t mlogVar[10];
uint32_t mlogVarCnt = 0;
- uint8_t Numerlogy = app_io_xran_fh_config[0].frame_conf.nNumerology;
- uint8_t nNrOfSlotInSf = 1<<Numerlogy;
- int32_t sfIdx = app_io_xran_sfidx_get(nNrOfSlotInSf);
+ //uint8_t Numerlogy = app_io_xran_fh_config[0].frame_conf.nNumerology;
+ //uint8_t nNrOfSlotInSf = 1<<Numerlogy;
+ //int32_t sfIdx = app_io_xran_sfidx_get(nNrOfSlotInSf);
int32_t nCellIdx;
- int32_t sym, nSlotIdx;
- uint64_t mlog_start, mlog_end;
+ int32_t sym, nSlotIdx, ntti;
+ uint64_t mlog_start;
struct xran_cb_tag *pTag = (struct xran_cb_tag *) pCallbackTag;
+ int32_t o_xu_id = pTag->oXuId;
+ struct xran_io_shared_ctrl *psIoCtrl = app_io_xran_if_ctrl_get(o_xu_id);
+ struct xran_fh_config *pXranConf = &app_io_xran_fh_config[o_xu_id];
+ uint32_t xran_max_antenna_nr = RTE_MAX(pXranConf->neAxc, pXranConf->neAxcUl);
+ //int32_t nSectorNum = pXranConf->nCC;
+ uint32_t ant_id, sym_id, idxElm;
+ struct xran_prb_map *pRbMap = NULL;
+ struct xran_prb_elm *pRbElm = NULL;
mlog_start = MLogTick();
nCellIdx = pTag->cellId;
nSlotIdx = pTag->slotiId; ///((status >> 16) & 0xFFFF); /** TTI aka slotIdx */
sym = pTag->symbol & 0xFF; /* sym */
+ ntti = (nSlotIdx + XRAN_N_FE_BUF_LEN -1) % XRAN_N_FE_BUF_LEN;
{
mlogVar[mlogVarCnt++] = 0xbcbcbcbc;
+ mlogVar[mlogVarCnt++] = o_xu_id;
mlogVar[mlogVarCnt++] = nCellIdx;
mlogVar[mlogVarCnt++] = sym;
mlogVar[mlogVarCnt++] = nSlotIdx;
+ mlogVar[mlogVarCnt++] = ntti;
//mlogVar[mlogVarCnt++] = nSlotIdx % gNumSlotPerSfn[nCellIdx];
//mlogVar[mlogVarCnt++] = get_slot_type(nCellIdx, nSlotIdx, SLOT_TYPE_UL);
MLogAddVariables(mlogVarCnt, mlogVar, mlog_start);
}
+ if(psIoCtrl == NULL)
+ {
+ printf("psIoCtrl NULL! o_xu_id= %d\n", o_xu_id);
+ return;
+ }
+
+ if (sym == XRAN_HALF_CB_SYM) {
+ // 1/4 of slot
+ } else if (sym == XRAN_HALF_CB_SYM) {
+ // First Half
+ } else if (sym == XRAN_THREE_FOURTHS_CB_SYM) {
+ // 2/4 of slot
+ } else if (sym == XRAN_FULL_CB_SYM) {
+ // Second Half
+ } else {
+ /* error */
+ MLogTask(PID_GNB_SYM_CB, t1, MLogTick());
+ return;
+ }
+
+ if(sym == XRAN_FULL_CB_SYM) //full slot callback only
+ {
+ for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) {
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[ntti][nCellIdx][ant_id].sBufferList.pBuffers->pData;
+ if(pRbMap == NULL){
+ printf("(%d:%d:%d)pRbMap == NULL\n", nCellIdx, ntti, ant_id);
+ exit(-1);
+ }
+ for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) {
+ for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++ ) {
+ pRbElm = &pRbMap->prbMap[idxElm];
+ pRbElm->nSecDesc[sym_id] = 0;
+ }
+ }
+ }
+ }
+
rte_pause();
MLogTask(PID_GNB_SYM_CB, t1, MLogTick());
void
app_io_xran_fh_rx_srs_callback(void *pCallbackTag, xran_status_t status)
+{
+ uint64_t t1 = MLogTick();
+ uint32_t mlogVar[10];
+ uint32_t mlogVarCnt = 0;
+ //uint8_t Numerlogy = app_io_xran_fh_config[0].frame_conf.nNumerology;
+ //uint8_t nNrOfSlotInSf = 1<<Numerlogy;
+ //int32_t sfIdx = app_io_xran_sfidx_get(nNrOfSlotInSf);
+ int32_t nCellIdx;
+ int32_t sym, nSlotIdx, ntti;
+ struct xran_cb_tag *pTag = (struct xran_cb_tag *) pCallbackTag;
+ int32_t o_xu_id = pTag->oXuId;
+ struct xran_io_shared_ctrl *psIoCtrl = app_io_xran_if_ctrl_get(o_xu_id);
+ struct xran_fh_config *pXranConf = &app_io_xran_fh_config[o_xu_id];
+ uint32_t xran_max_antenna_nr = RTE_MAX(pXranConf->neAxc, pXranConf->neAxcUl);
+ //int32_t nSectorNum = pXranConf->nCC;
+ uint32_t ant_id, sym_id, idxElm;
+ struct xran_prb_map *pRbMap = NULL;
+ struct xran_prb_elm *pRbElm = NULL;
+ uint32_t xran_max_ant_array_elm_nr = RTE_MAX(pXranConf->nAntElmTRx, xran_max_antenna_nr);
+
+ nCellIdx = pTag->cellId;
+ nSlotIdx = pTag->slotiId; ///((status >> 16) & 0xFFFF); /** TTI aka slotIdx */
+ sym = pTag->symbol & 0xFF; /* sym */
+ ntti = (nSlotIdx + XRAN_N_FE_BUF_LEN-1) % XRAN_N_FE_BUF_LEN;
+
+ {
+ mlogVar[mlogVarCnt++] = 0xCCCCCCCC;
+ mlogVar[mlogVarCnt++] = o_xu_id;
+ mlogVar[mlogVarCnt++] = nCellIdx;
+ mlogVar[mlogVarCnt++] = sym;
+ mlogVar[mlogVarCnt++] = nSlotIdx;
+ mlogVar[mlogVarCnt++] = ntti;
+ MLogAddVariables(mlogVarCnt, mlogVar, MLogTick());
+ }
+
+ if(psIoCtrl == NULL)
+ {
+ printf("psIoCtrl NULL! o_xu_id= %d\n", o_xu_id);
+ return;
+ }
+
+ if(sym == XRAN_FULL_CB_SYM) { //full slot callback only
+ for(ant_id = 0; ant_id < xran_max_ant_array_elm_nr; ant_id++) {
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[ntti][nCellIdx][ant_id].sBufferList.pBuffers->pData;
+ if(pRbMap == NULL){
+ printf("(%d:%d:%d)pRbMap == NULL\n", nCellIdx, ntti, ant_id);
+ exit(-1);
+ }
+ for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) {
+ for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++ ) {
+ pRbElm = &pRbMap->prbMap[idxElm];
+ pRbElm->nSecDesc[sym_id] = 0;
+ }
+ }
+ }
+ }
+ MLogTask(PID_GNB_SRS_CB, t1, MLogTick());
+}
+
+void
+app_io_xran_fh_rx_bfw_callback(void *pCallbackTag, xran_status_t status)
{
uint64_t t1 = MLogTick();
uint32_t mlogVar[10];
MLogAddVariables(mlogVarCnt, mlogVar, MLogTick());
rte_pause();
- MLogTask(PID_GNB_SRS_CB, t1, MLogTick());
+ MLogTask(PID_GNB_BFW_CB, t1, MLogTick());
}
-
int32_t
app_io_xran_dl_tti_call_back(void * param)
{
return 0;
}
+uint32_t
+NEXT_POW2 ( uint32_t x )
+{
+ uint32_t value = 1 ;
+ while ( value <= x)
+ value = value << 1;
+
+ return value ;
+}
+
int32_t
-app_io_xran_interface(uint32_t o_xu_id, RuntimeConfig *p_o_xu_cfg, UsecaseConfig* p_use_cfg)
+app_io_xran_interface(uint32_t o_xu_id, RuntimeConfig *p_o_xu_cfg, UsecaseConfig* p_use_cfg, struct xran_fh_init* p_xran_fh_init)
{
xran_status_t status;
struct bbu_xran_io_if *psBbuIo = app_io_xran_if_get();
struct xran_io_shared_ctrl *psIoCtrl = app_io_xran_if_ctrl_get(o_xu_id);
int32_t nSectorIndex[XRAN_MAX_SECTOR_NR];
int32_t nSectorNum;
- int32_t i, j, k, m, z;
+ int32_t i, j, k = 0, z;
void *ptr;
void *mb;
+ void *ring;
uint32_t *u32dptr;
- uint16_t *u16dptr;
- uint8_t *u8dptr;
uint32_t xran_max_antenna_nr = RTE_MAX(p_o_xu_cfg->numAxc, p_o_xu_cfg->numUlAxc);
uint32_t xran_max_ant_array_elm_nr = RTE_MAX(p_o_xu_cfg->antElmTRx, xran_max_antenna_nr);
uint32_t xran_max_sections_per_slot = RTE_MAX(p_o_xu_cfg->max_sections_per_slot, XRAN_MIN_SECTIONS_PER_SLOT);
- uint32_t size_of_prb_map = sizeof(struct xran_prb_map) + sizeof(struct xran_prb_elm)*(xran_max_sections_per_slot - 1);
+ uint32_t xran_max_prb = app_xran_get_num_rbs(p_o_xu_cfg->xranTech, p_o_xu_cfg->mu_number,p_o_xu_cfg->nDLBandwidth, p_o_xu_cfg->nDLAbsFrePointA);
+ uint32_t numPrbElm = xran_get_num_prb_elm(p_o_xu_cfg->p_PrbMapDl, p_o_xu_cfg->mtu);
+ uint32_t size_of_prb_map = sizeof(struct xran_prb_map) + sizeof(struct xran_prb_elm)*(numPrbElm);
+ uint32_t xran_max_antenna_nr_prach = RTE_MIN(xran_max_antenna_nr, XRAN_MAX_PRACH_ANT_NUM);
SWXRANInterfaceTypeEnum eInterfaceType;
struct xran_buffer_list *pFthRxSrsBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN];
struct xran_buffer_list *pFthRxSrsPrbMapBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN];
+ struct xran_buffer_list *pFthRxCpPrbMapBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN];
+ struct xran_buffer_list *pFthTxCpPrbMapBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN];
+
if(psBbuIo == NULL)
rte_panic("psBbuIo == NULL\n");
nSectorIndex[nSectorNum] = nSectorNum;
}
+ nSectorNum = p_o_xu_cfg->numCC;
+
+ if(o_xu_id == 0) {
+ psBbuIo->num_o_ru = p_use_cfg->oXuNum;
+ psBbuIo->bbu_offload = p_xran_fh_init->io_cfg.bbu_offload;
+ }
+
+ psIoCtrl->byteOrder = XRAN_NE_BE_BYTE_ORDER;
+ psIoCtrl->iqOrder = XRAN_I_Q_ORDER;
+
+ for (nSectorNum = 0; nSectorNum < XRAN_MAX_SECTOR_NR; nSectorNum++)
+ {
+ nSectorIndex[nSectorNum] = nSectorNum;
+ }
+
+ if(p_use_cfg->oXuNum > 1 && p_use_cfg->oXuNum <= XRAN_PORTS_NUM) {
+ nSectorNum = p_o_xu_cfg->numCC;
+ psBbuIo->num_cc_per_port[o_xu_id] = p_o_xu_cfg->numCC;
+ printf("port %d has %d CCs\n",o_xu_id, psBbuIo->num_cc_per_port[o_xu_id]);
+ for(i = 0; i < XRAN_MAX_SECTOR_NR && i < nSectorNum; i++) {
+ psBbuIo->map_cell_id2port[o_xu_id][i] = (o_xu_id*nSectorNum)+i;
+ printf("port %d cc_id %d is phy id %d\n", o_xu_id, i, psBbuIo->map_cell_id2port[o_xu_id][i]);
+ }
+ }
+ else {
+ nSectorNum = p_o_xu_cfg->numCC;;
+ psBbuIo->num_cc_per_port[o_xu_id] = nSectorNum;
+ printf("port %d has %d CCs\n",o_xu_id, psBbuIo->num_cc_per_port[o_xu_id]);
+ for(i = 0; i < XRAN_MAX_SECTOR_NR && i < nSectorNum; i++) {
+ psBbuIo->map_cell_id2port[o_xu_id][i] = i;
+ printf("port %d cc_id %d is phy id %d\n", o_xu_id, i, psBbuIo->map_cell_id2port[o_xu_id][i]);
+ }
+ }
+
nSectorNum = p_o_xu_cfg->numCC;
printf ("XRAN front haul xran_mm_init \n");
status = xran_mm_init (app_io_xran_handle, (uint64_t) SW_FPGA_FH_TOTAL_BUFFER_LEN, SW_FPGA_SEGMENT_BUFFER_LEN);
psBbuIo->nInstanceNum[o_xu_id] = p_o_xu_cfg->numCC;
if (o_xu_id < XRAN_PORTS_NUM) {
- status = xran_sector_get_instances (o_xu_id, app_io_xran_handle, psBbuIo->nInstanceNum[o_xu_id], &psBbuIo->nInstanceHandle[o_xu_id][0]);
+ status = xran_sector_get_instances (o_xu_id, app_io_xran_handle,
+ psBbuIo->nInstanceNum[o_xu_id],
+ &psBbuIo->nInstanceHandle[o_xu_id][0]);
if (status != XRAN_STATUS_SUCCESS) {
- printf ("get sector instance failed %d for XRAN nInstanceNum[%d] %d\n",k, psBbuIo->nInstanceNum[o_xu_id], o_xu_id);
+ printf ("get sector instance failed for XRAN nInstanceNum[%d] %d\n",psBbuIo->nInstanceNum[o_xu_id], o_xu_id);
exit(-1);
}
for (i = 0; i < psBbuIo->nInstanceNum[o_xu_id]; i++) {
- printf("%s [%d]: CC %d handle %p\n", __FUNCTION__, k, i, psBbuIo->nInstanceHandle[o_xu_id][i]);
+ printf("%s: CC %d handle %p\n", __FUNCTION__, i, psBbuIo->nInstanceHandle[o_xu_id][i]);
}
} else {
printf ("Failed at XRAN front haul xran_mm_init \n");
eInterfaceType = XRANFTHTX_OUT;
printf("nSectorIndex[%d] = %d\n",i, nSectorIndex[i]);
status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT, nSW_ToFpga_FTH_TxBufferLen);
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT)-1, nSW_ToFpga_FTH_TxBufferLen);
if(XRAN_STATUS_SUCCESS != status) {
rte_panic("Failed at xran_bm_init , status %d\n", status);
}
// ptr_temp[2] = z; // Ant
// ptr_temp[3] = k; // sym
}
+ if(psBbuIo->bbu_offload){
+ status = xran_bm_allocate_ring(psBbuIo->nInstanceHandle[o_xu_id][i], "TXO", i, j, z, k, &ring);
+ if(XRAN_STATUS_SUCCESS != status){
+ rte_panic("Failed at xran_bm_allocate_ring , status %d\n",status);
+ }
+ psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pRing = (void *)ring;
}
}
}
-
- /* C-plane DL */
- eInterfaceType = XRANFTHTX_SEC_DESC_OUT;
- status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT*xran_max_sections_per_slot*XRAN_MAX_FRAGMENT, sizeof(struct xran_section_desc));
- if(XRAN_STATUS_SUCCESS != status) {
- rte_panic("Failed at xran_bm_init , status %d\n", status);
}
+ /* C-plane DL */
printf("size_of_prb_map %d\n", size_of_prb_map);
eInterfaceType = XRANFTHTX_PRB_MAP_OUT;
status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT, size_of_prb_map);
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT)-1, size_of_prb_map);
if(XRAN_STATUS_SUCCESS != status) {
rte_panic("Failed at xran_bm_init , status %d\n", status);
}
psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFrontHaulTxPrbMapBuffers[j][i][z];
- {
psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes = size_of_prb_map;
psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements = 1;
psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes = 0;
psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl = (void *)mb;
if(ptr){
- void *sd_ptr;
- void *sd_mb;
- int32_t elm_id;
struct xran_prb_map * p_rb_map = (struct xran_prb_map *)ptr;
+ memset(p_rb_map, 0, size_of_prb_map);
if (p_o_xu_cfg->appMode == APP_O_DU) {
if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
- memcpy(ptr, p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_DL][j][i][z], size_of_prb_map);
+ if(p_o_xu_cfg->RunSlotPrbMapBySymbolEnable){
+ xran_init_PrbMap_by_symbol_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_DL][j][i][z], ptr, p_o_xu_cfg->mtu, xran_max_prb);
+ }
+ else {
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_DL][j][i][z], ptr, p_o_xu_cfg->mtu);
+ }
} else {
- memcpy(ptr, p_o_xu_cfg->p_PrbMapDl, size_of_prb_map);
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_PrbMapDl, ptr, p_o_xu_cfg->mtu);
}
} else {
if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
- memcpy(ptr, p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_UL][j][i][z], size_of_prb_map);
- } else {
- memcpy(ptr, p_o_xu_cfg->p_PrbMapUl, size_of_prb_map);
- }
- }
-
- for (elm_id = 0; elm_id < p_rb_map->nPrbElm; elm_id++){
- struct xran_prb_elm *pPrbElem = &p_rb_map->prbMap[elm_id];
- for(k = 0; k < XRAN_NUM_OF_SYMBOL_PER_SLOT; k++){
- for(m = 0; m < XRAN_MAX_FRAGMENT; m++){
- status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][XRANFTHTX_SEC_DESC_OUT],&sd_ptr, &sd_mb);
- if(XRAN_STATUS_SUCCESS != status){
- rte_panic("SD Failed at DESC_OUT xran_bm_allocate_buffer , m %d k %d elm_id %d\n",m,k, elm_id);
- }
- pPrbElem->p_sec_desc[k][m] = sd_ptr;
- memset(sd_ptr,0,sizeof(struct xran_section_desc));
+ if(p_o_xu_cfg->RunSlotPrbMapBySymbolEnable){
+ xran_init_PrbMap_by_symbol_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_UL][j][i][z], ptr, p_o_xu_cfg->mtu, xran_max_prb);
}
+ else {
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_UL][j][i][z], ptr, p_o_xu_cfg->mtu);
}
+ } else {
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_PrbMapUl, ptr, p_o_xu_cfg->mtu);
}
}
}
for(i = 0; i<nSectorNum; i++)
{
eInterfaceType = XRANFTHRX_IN;
- status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType], XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT, nSW_ToFpga_FTH_TxBufferLen);
+ status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT)-1, nSW_ToFpga_FTH_TxBufferLen);
if(XRAN_STATUS_SUCCESS != status)
{
printf("Failed at xran_bm_init, status %d\n", status);
psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pCtrl = (void *) mb;
if(ptr){
u32dptr = (uint32_t*)(ptr);
- uint8_t *ptr_temp = (uint8_t *)ptr;
+ //uint8_t *ptr_temp = (uint8_t *)ptr;
memset(u32dptr, 0x0, nFpgaToSW_FTH_RxBufferLen);
// ptr_temp[0] = j; // TTI
// ptr_temp[1] = i; // Sec
}
/* C-plane */
- eInterfaceType = XRANFTHTX_SEC_DESC_IN;
- status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT*xran_max_sections_per_slot*XRAN_MAX_FRAGMENT, sizeof(struct xran_section_desc));
- if(XRAN_STATUS_SUCCESS != status) {
- rte_panic("Failed at xran_bm_init , status %d\n", status);
- }
eInterfaceType = XRANFTHRX_PRB_MAP_IN;
status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT, size_of_prb_map);
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT)-1, size_of_prb_map);
if(XRAN_STATUS_SUCCESS != status) {
rte_panic("Failed at xran_bm_init, status %d\n", status);
}
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFrontHaulRxPrbMapBuffers[j][i][z];
- {
+
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes = size_of_prb_map;
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements = 1;
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes = 0;
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pData = (uint8_t *)ptr;
psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl = (void *)mb;
if(ptr){
- void *sd_ptr;
- void *sd_mb;
- int32_t elm_id;
struct xran_prb_map * p_rb_map = (struct xran_prb_map *)ptr;
+ memset(p_rb_map, 0, size_of_prb_map);
if (p_o_xu_cfg->appMode == APP_O_DU) {
if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
- memcpy(ptr, p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_UL][j][i][z], size_of_prb_map);
+ if(p_o_xu_cfg->RunSlotPrbMapBySymbolEnable){
+ xran_init_PrbMap_by_symbol_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_UL][j][i][z], ptr, p_o_xu_cfg->mtu, xran_max_prb);
+ }
+ else {
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_UL][j][i][z], ptr, p_o_xu_cfg->mtu);
+ }
} else {
- memcpy(ptr, p_o_xu_cfg->p_PrbMapUl, size_of_prb_map);
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_PrbMapUl, ptr, p_o_xu_cfg->mtu);
}
} else {
if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
+ if(p_o_xu_cfg->RunSlotPrbMapBySymbolEnable){
+ xran_init_PrbMap_by_symbol_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_DL][j][i][z], ptr, p_o_xu_cfg->mtu, xran_max_prb);
+ }
+ else {
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_DL][j][i][z], ptr, p_o_xu_cfg->mtu);
+ }
+ } else {
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_PrbMapDl, ptr, p_o_xu_cfg->mtu);
+ }
+ }
+ }
+ }
+ }
+
+ if(p_o_xu_cfg->appMode == APP_O_RU){
+ /* C-plane Rx */
+ eInterfaceType = XRANCP_PRB_MAP_IN_RX;
+ status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
+ XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT, size_of_prb_map);
+ if(XRAN_STATUS_SUCCESS != status) {
+ rte_panic("Failed at xran_bm_init, status %d\n", status);
+ }
+
+ for(j = 0;j < XRAN_N_FE_BUF_LEN; j++) {
+ for(z = 0; z < xran_max_antenna_nr; z++){
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].bValid = 0;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].nSegGenerated = -1;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].nSegToBeGen = -1;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFrontHaulCpRxPrbMapBbuIoBufCtrl[j][i][z];
+
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes = size_of_prb_map;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements = 1;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes = 0;
+ status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i],psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],&ptr, &mb);
+ if(XRAN_STATUS_SUCCESS != status) {
+ rte_panic("Failed at xran_bm_allocate_buffer , status %d\n",status);
+ }
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pData = (uint8_t *)ptr;
+ psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl = (void *)mb;
+
+ if(ptr){
+ struct xran_prb_map * p_rb_map = (struct xran_prb_map *)ptr;
+ memset(p_rb_map, 0, size_of_prb_map);
+
+ if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
memcpy(ptr, p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_DL][j][i][z], size_of_prb_map);
} else {
memcpy(ptr, p_o_xu_cfg->p_PrbMapDl, size_of_prb_map);
}
}
+ }
+ }
- for (elm_id = 0; elm_id < p_rb_map->nPrbElm; elm_id++){
- struct xran_prb_elm *pPrbElem = &p_rb_map->prbMap[elm_id];
- for(k = 0; k < XRAN_NUM_OF_SYMBOL_PER_SLOT; k++){
- for(m = 0; m < XRAN_MAX_FRAGMENT; m++){
- status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][XRANFTHTX_SEC_DESC_IN],&sd_ptr, &sd_mb);
+
+/* C-plane Tx */
+ eInterfaceType = XRANCP_PRB_MAP_IN_TX;
+ status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT)-1, size_of_prb_map);
if(XRAN_STATUS_SUCCESS != status){
- rte_panic("SD Failed at DESC_IN xran_bm_allocate_buffer , m %d k %d\n",m,k);
- }
- pPrbElem->p_sec_desc[k][m] = sd_ptr;
- memset(sd_ptr,0,sizeof(struct xran_section_desc));
+ rte_panic("Failed at xran_bm_init, status %d\n", status);
}
+
+ for(j = 0;j < XRAN_N_FE_BUF_LEN; j++) {
+ for(z = 0; z < xran_max_antenna_nr; z++){
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].bValid = 0;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].nSegGenerated = -1;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].nSegToBeGen = -1;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFrontHaulCpTxPrbMapBbuIoBufCtrl[j][i][z];
+
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes = size_of_prb_map;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements = 1;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes = 0;
+ status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i],psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],&ptr, &mb);
+ if(XRAN_STATUS_SUCCESS != status) {
+ rte_panic("Failed at xran_bm_allocate_buffer , status %d\n",status);
}
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pData = (uint8_t *)ptr;
+ psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl = (void *)mb;
+ if(ptr){
+ struct xran_prb_map * p_rb_map = (struct xran_prb_map *)ptr;
+ memset(p_rb_map, 0, size_of_prb_map);
+
+ if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
+ memcpy(ptr, p_o_xu_cfg->p_RunSlotPrbMap[XRAN_DIR_DL][j][i][z], size_of_prb_map);
+ } else {
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_PrbMapDl, ptr, p_o_xu_cfg->mtu);
}
}
}
for(i = 0; i<nSectorNum; i++)
{
eInterfaceType = XRANFTHRACH_IN;
- status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],&psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],XRAN_N_FE_BUF_LEN*xran_max_antenna_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT, PRACH_PLAYBACK_BUFFER_BYTES);
+ status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],&psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_antenna_nr_prach*XRAN_NUM_OF_SYMBOL_PER_SLOT)-1, PRACH_PLAYBACK_BUFFER_BYTES);
if(XRAN_STATUS_SUCCESS != status) {
rte_panic("Failed at xran_bm_init, status %d\n", status);
}
for(j = 0;j < XRAN_N_FE_BUF_LEN; j++)
{
- for(z = 0; z < xran_max_antenna_nr; z++){
+ for(z = 0; z < xran_max_antenna_nr_prach; z++){
psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].bValid = 0;
psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].nSegGenerated = -1;
psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].nSegToBeGen = -1;
psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
- psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = xran_max_antenna_nr; // ant number.
+ psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = xran_max_antenna_nr_prach; // ant number.
psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFHPrachRxBuffers[j][i][z][0];
psIoCtrl->sFHPrachRxBbuIoBufCtrlDecomp[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFHPrachRxBuffersDecomp[j][i][z][0];
for(k = 0; k< XRAN_NUM_OF_SYMBOL_PER_SLOT; k++)
for(i = 0; i<nSectorNum && xran_max_ant_array_elm_nr; i++) {
eInterfaceType = XRANSRS_IN;
status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],&psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_ant_array_elm_nr*XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT, nSW_ToFpga_FTH_TxBufferLen);
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_ant_array_elm_nr*XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT)-1, nSW_ToFpga_FTH_TxBufferLen);
if(XRAN_STATUS_SUCCESS != status) {
rte_panic("Failed at xran_bm_init, status %d\n", status);
}
/* SRS C-plane */
- eInterfaceType = XRANSRS_SEC_DESC_IN;
- status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_ant_array_elm_nr*xran_max_sections_per_slot*XRAN_NUM_OF_SYMBOL_PER_SLOT*XRAN_MAX_FRAGMENT, sizeof(struct xran_section_desc));
- if(XRAN_STATUS_SUCCESS != status) {
- rte_panic("Failed at xran_bm_init , status %d\n", status);
- }
eInterfaceType = XRANSRS_PRB_MAP_IN;
status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i], &psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][eInterfaceType],
- XRAN_N_FE_BUF_LEN*xran_max_ant_array_elm_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT, size_of_prb_map);
+ NEXT_POW2(XRAN_N_FE_BUF_LEN*xran_max_ant_array_elm_nr*XRAN_NUM_OF_SYMBOL_PER_SLOT)-1, size_of_prb_map);
if(XRAN_STATUS_SUCCESS != status) {
rte_panic("Failed at xran_bm_init, status %d\n", status);
}
psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFHSrsRxPrbMapBuffers[j][i][z];
- {
+
psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes = size_of_prb_map;
psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements = 1;
psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes = 0;
psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl = (void *)mb;
if(ptr) {
- void *sd_ptr;
- void *sd_mb;
- int32_t elm_id;
struct xran_prb_map * p_rb_map = (struct xran_prb_map *)ptr;
+ memset(p_rb_map, 0, size_of_prb_map);
if (p_o_xu_cfg->appMode == APP_O_DU) {
if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
if(p_o_xu_cfg->RunSlotPrbMapEnabled) {
memcpy(ptr, p_o_xu_cfg->p_RunSrsSlotPrbMap[XRAN_DIR_DL][j][i][z], size_of_prb_map);
} else {
- memcpy(ptr, p_o_xu_cfg->p_PrbMapSrs, size_of_prb_map);
+ //memcpy(ptr, p_o_xu_cfg->p_PrbMapSrs, size_of_prb_map);
+ xran_init_PrbMap_from_cfg(p_o_xu_cfg->p_PrbMapSrs, ptr, p_o_xu_cfg->mtu);
}
}
-
- for (elm_id = 0; elm_id < p_rb_map->nPrbElm; elm_id++){
- struct xran_prb_elm *pPrbElem = &p_rb_map->prbMap[elm_id];
- for(k = 0; k < XRAN_NUM_OF_SYMBOL_PER_SLOT; k++){
- for(m = 0; m < XRAN_MAX_FRAGMENT; m++){
- status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][nSectorIndex[i]][XRANSRS_SEC_DESC_IN],&sd_ptr, &sd_mb);
- if(XRAN_STATUS_SUCCESS != status){
- rte_panic("SD Failed at SRS_SEC_DESC_IN xran_bm_allocate_buffer , m %d k %d\n",m,k);
- }
- pPrbElem->p_sec_desc[k][m] = sd_ptr;
- memset(sd_ptr,0,sizeof(struct xran_section_desc));
- }
- }
- }
- }
}
}
}
pFthRxPrbMapBuffer[i][z][j] = NULL;
pFthRxRachBuffer[i][z][j] = NULL;
pFthRxRachBufferDecomp[i][z][j] = NULL;
+ pFthRxCpPrbMapBuffer[i][z][j] = NULL;
+ pFthTxCpPrbMapBuffer[i][z][j] = NULL;
}
for(z = 0; z < XRAN_MAX_ANT_ARRAY_ELM_NR; z++){
pFthRxSrsBuffer[i][z][j] = NULL;
pFthRxPrbMapBuffer[i][z][j] = &(psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
pFthRxRachBuffer[i][z][j] = &(psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList);
pFthRxRachBufferDecomp[i][z][j] = &(psIoCtrl->sFHPrachRxBbuIoBufCtrlDecomp[j][i][z].sBufferList);
+ pFthRxCpPrbMapBuffer[i][z][j] = &(psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
+ pFthTxCpPrbMapBuffer[i][z][j] = &(psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
}
for(z = 0; z < XRAN_MAX_ANT_ARRAY_ELM_NR && xran_max_ant_array_elm_nr; z++){
/* add pusch callback */
for (i = 0; i<nSectorNum; i++)
{
+ psBbuIo->RxCbTag[o_xu_id][i].oXuId = o_xu_id;
psBbuIo->RxCbTag[o_xu_id][i].cellId = i;
psBbuIo->RxCbTag[o_xu_id][i].symbol = 0;
psBbuIo->RxCbTag[o_xu_id][i].slotiId = 0;
+ if(psBbuIo->bbu_offload)
+ xran_5g_fronthault_config (psBbuIo->nInstanceHandle[o_xu_id][i],
+ pFthTxBuffer[i],
+ pFthTxPrbMapBuffer[i],
+ pFthRxBuffer[i],
+ pFthRxPrbMapBuffer[i],
+ app_io_xran_fh_bbu_rx_callback, &psBbuIo->RxCbTag[o_xu_id][i]);
+ else
xran_5g_fronthault_config (psBbuIo->nInstanceHandle[o_xu_id][i],
pFthTxBuffer[i],
pFthTxPrbMapBuffer[i],
pFthRxPrbMapBuffer[i],
app_io_xran_fh_rx_callback, &psBbuIo->RxCbTag[o_xu_id][i]);
}
+ /* add BFWs callback here */
+ for (i = 0; i<nSectorNum; i++) {
+ psBbuIo->BfwCbTag[o_xu_id][i].cellId = o_xu_id;
+ psBbuIo->BfwCbTag[o_xu_id][i].cellId = i;
+ psBbuIo->BfwCbTag[o_xu_id][i].symbol = 0;
+ psBbuIo->BfwCbTag[o_xu_id][i].slotiId = 0;
+#if 0
+ if(psBbuIo->bbu_offload)
+ xran_5g_bfw_config(psBbuIo->nInstanceHandle[o_xu_id][i],
+ pFthRxCpPrbMapBuffer[i],
+ pFthTxCpPrbMapBuffer[i],
+ app_io_xran_fh_bbu_rx_bfw_callback,&psBbuIo->BfwCbTag[o_xu_id][i]);
+ else
+#endif
+ xran_5g_bfw_config(psBbuIo->nInstanceHandle[o_xu_id][i],
+ pFthRxCpPrbMapBuffer[i],
+ pFthTxCpPrbMapBuffer[i],
+ app_io_xran_fh_rx_bfw_callback,&psBbuIo->BfwCbTag[o_xu_id][i]);
+ }
/* add prach callback here */
for (i = 0; i<nSectorNum; i++)
{
+ psBbuIo->PrachCbTag[o_xu_id][i].oXuId = o_xu_id;
psBbuIo->PrachCbTag[o_xu_id][i].cellId = i;
psBbuIo->PrachCbTag[o_xu_id][i].symbol = 0;
psBbuIo->PrachCbTag[o_xu_id][i].slotiId = 0;
+ if(psBbuIo->bbu_offload)
+ xran_5g_prach_req(psBbuIo->nInstanceHandle[o_xu_id][i], pFthRxRachBuffer[i],pFthRxRachBufferDecomp[i],
+ app_io_xran_fh_bbu_rx_prach_callback,&psBbuIo->PrachCbTag[o_xu_id][i]);
+ else
xran_5g_prach_req(psBbuIo->nInstanceHandle[o_xu_id][i], pFthRxRachBuffer[i],pFthRxRachBufferDecomp[i],
app_io_xran_fh_rx_prach_callback,&psBbuIo->PrachCbTag[o_xu_id][i]);
}
/* add SRS callback here */
for (i = 0; i<nSectorNum && xran_max_ant_array_elm_nr; i++) {
+ psBbuIo->SrsCbTag[o_xu_id][i].oXuId = o_xu_id;
psBbuIo->SrsCbTag[o_xu_id][i].cellId = i;
psBbuIo->SrsCbTag[o_xu_id][i].symbol = 0;
psBbuIo->SrsCbTag[o_xu_id][i].slotiId = 0;
+ if(psBbuIo->bbu_offload)
+ xran_5g_srs_req(psBbuIo->nInstanceHandle[o_xu_id][i], pFthRxSrsBuffer[i], pFthRxSrsPrbMapBuffer[i],
+ app_io_xran_fh_bbu_rx_srs_callback,&psBbuIo->SrsCbTag[o_xu_id][i]);
+ else
xran_5g_srs_req(psBbuIo->nInstanceHandle[o_xu_id][i], pFthRxSrsBuffer[i], pFthRxSrsPrbMapBuffer[i],
app_io_xran_fh_rx_srs_callback,&psBbuIo->SrsCbTag[o_xu_id][i]);
}
}
int32_t
-app_io_xran_ext_type11_populate(struct xran_prb_elm* p_pRbMapElm, int16_t *p_tx_dl_bfw_buffer, uint32_t mtu)
+app_io_xran_ext_type1_populate(struct xran_prb_elm* p_pRbMapElm, char *p_bfw_buffer, uint32_t mtu, uint16_t* numSetBFW_total)
+{
+ xran_status_t status = XRAN_STATUS_SUCCESS;
+
+ int16_t ext_len;
+ int16_t ext_sec_total = 0;
+ int8_t * ext_buf = NULL;
+ int8_t * ext_buf_start = NULL;
+
+ ext_len = p_pRbMapElm->bf_weight.maxExtBufSize = mtu; /* MAX_RX_LEN; */ /* Maximum space of external buffer */
+ if (p_pRbMapElm->bf_weight.p_ext_start)
+ ext_buf = (int8_t *)p_pRbMapElm->bf_weight.p_ext_start;
+ else
+ ext_buf = (int8_t *)xran_malloc(p_pRbMapElm->bf_weight.maxExtBufSize);
+
+ if(ext_buf == NULL)
+ rte_panic("xran_malloc return NULL [sz %d]\n", p_pRbMapElm->bf_weight.maxExtBufSize);
+
+ if(ext_buf) {
+ ext_buf_start = ext_buf;
+ ext_buf += (RTE_PKTMBUF_HEADROOM +
+ sizeof(struct xran_ecpri_hdr) +
+ sizeof(struct xran_cp_radioapp_section1_header));
+
+ ext_len -= (RTE_PKTMBUF_HEADROOM +
+ sizeof(struct xran_ecpri_hdr) +
+ sizeof(struct xran_cp_radioapp_section1_header));
+
+ ext_sec_total = xran_cp_populate_section_ext_1((int8_t *)ext_buf,
+ ext_len,
+ (int16_t *) (p_bfw_buffer + (*numSetBFW_total*p_pRbMapElm->bf_weight.nAntElmTRx)*4),
+ p_pRbMapElm);
+ if(ext_sec_total > 0) {
+ p_pRbMapElm->bf_weight.p_ext_start = ext_buf_start;
+ p_pRbMapElm->bf_weight.p_ext_section = ext_buf;
+ p_pRbMapElm->bf_weight.ext_section_sz = ext_sec_total;
+ } else
+ rte_panic("xran_cp_populate_section_ext_1 return error [%d]\n", ext_sec_total);
+ } else {
+ rte_panic("xran_malloc return NULL\n");
+ }
+
+ return status;
+}
+
+int32_t
+app_io_xran_ext_type11_populate(struct xran_prb_elm* p_pRbMapElm, char *p_tx_dl_bfw_buffer, uint32_t mtu)
{
xran_status_t status = XRAN_STATUS_SUCCESS;
int32_t n_max_set_bfw;
p_pRbMapElm->bf_weight.maxExtBufSize = mtu; /* MAX_RX_LEN; */ /* Maximum space of external buffer */
+ if (p_pRbMapElm->bf_weight.p_ext_start)
+ extbuf = (uint8_t *)p_pRbMapElm->bf_weight.p_ext_start;
+ else
extbuf = (uint8_t*)xran_malloc(p_pRbMapElm->bf_weight.maxExtBufSize);
if(extbuf == NULL)
- rte_panic("xran_malloc return NULL\n");
+ rte_panic("xran_malloc return NULL [sz %d]\n", p_pRbMapElm->bf_weight.maxExtBufSize);
/* Check BFWs can be fit with MTU size */
n_max_set_bfw = xran_cp_estimate_max_set_bfws(p_pRbMapElm->bf_weight.nAntElmTRx,
pRbMap->prbMap[0].nRBSize = nRBs;
pRbMap->prbMap[0].nStartSymb = 0;
pRbMap->prbMap[0].numSymb = 14;
- pRbMap->prbMap[0].p_sec_desc[sym_id][0]->iq_buffer_offset = 0;
- pRbMap->prbMap[0].p_sec_desc[sym_id][0]->iq_buffer_len = nRBs *4L;
+ pRbMap->prbMap[0].sec_desc[sym_id][0].iq_buffer_offset = 0;
+ pRbMap->prbMap[0].sec_desc[sym_id][0].iq_buffer_len = nRBs *4L;
pRbMap->prbMap[0].nBeamIndex = 0;
pRbMap->prbMap[0].compMethod = XRAN_COMPMETHOD_NONE;
int32_t
app_io_xran_iq_content_init_cp_tx(uint8_t appMode, struct xran_fh_config *pXranConf,
struct bbu_xran_io_if *psBbuIo, struct xran_io_shared_ctrl *psIoCtrl, struct o_xu_buffers * p_iq,
- int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t tti, int32_t flowId)
+ int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t target_tti, int32_t flowId)
{
int32_t status = 0;
struct xran_prb_map* pRbMap = NULL;
+ char* dl_bfw_pos = NULL;
+
+ int32_t tti_dst = target_tti % XRAN_N_FE_BUF_LEN;
+ int32_t tti_src = target_tti % p_iq->numSlots;
+ int32_t tx_dl_bfw_buffer_position = tti_src * (pXranConf->nDLRBs*pXranConf->nAntElmTRx)*4;
+ uint16_t numSetBFW_total = 0;
if(p_iq->p_tx_play_buffer[flowId]) {
- pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
+ cc_id = cc_id % XRAN_MAX_SECTOR_NR;
+ ant_id = ant_id % XRAN_MAX_ANTENNA_NR;
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[tti_dst][cc_id][ant_id].sBufferList.pBuffers->pData;
+ dl_bfw_pos = ((char*)p_iq->p_tx_dl_bfw_buffer[flowId]) + tx_dl_bfw_buffer_position;
if(pRbMap) {
if (pXranConf->DynamicSectionEna == 0) {
- app_io_xran_iq_content_init_cp_rb_map(pRbMap, XRAN_DIR_DL, cc_id, ant_id, sym_id, tti, pXranConf->nDLRBs);
+ if(pRbMap->nPrbElm != 1 )
+ app_io_xran_iq_content_init_cp_rb_map(pRbMap, XRAN_DIR_DL, cc_id, ant_id, sym_id, tti_dst, pXranConf->nDLRBs);
} else if(pXranConf->ru_conf.xranCat == XRAN_CATEGORY_B
&& appMode == APP_O_DU
&& sym_id == 0) { /* BFWs are per slot */
int32_t idxElm = 0;
- char* dl_bfw_pos = ((char*)p_iq->p_tx_dl_bfw_buffer[flowId]) + p_iq->tx_dl_bfw_buffer_position[flowId];
struct xran_prb_elm* p_pRbMapElm = NULL;
for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++) {
p_pRbMapElm->bf_weight.nAntElmTRx = pXranConf->nAntElmTRx;
if(p_pRbMapElm->BeamFormingType == XRAN_BEAM_WEIGHT && p_pRbMapElm->bf_weight_update) {
- if(p_pRbMapElm->bf_weight.numBundPrb == 0) {
- /* No bundled PRB, using extension 1 */
- int16_t ext_len = 9600;
- int16_t ext_sec_total = 0;
- int8_t * ext_buf =(int8_t*) xran_malloc(ext_len);
- int8_t * ext_buf_start = ext_buf;
- if(ext_buf) {
- ext_buf += (RTE_PKTMBUF_HEADROOM +
- sizeof(struct xran_ecpri_hdr) +
- sizeof(struct xran_cp_radioapp_section1_header) +
- sizeof(struct xran_cp_radioapp_section1));
-
- ext_len -= (RTE_PKTMBUF_HEADROOM +
- sizeof(struct xran_ecpri_hdr) +
- sizeof(struct xran_cp_radioapp_section1_header) +
- sizeof(struct xran_cp_radioapp_section1));
-
- ext_sec_total = xran_cp_populate_section_ext_1((int8_t *)ext_buf,
- ext_len,
- (int16_t *) (dl_bfw_pos + (p_pRbMapElm->nRBStart*p_pRbMapElm->bf_weight.nAntElmTRx)*4),
- p_pRbMapElm->nRBSize,
- p_pRbMapElm->bf_weight.nAntElmTRx,
- p_pRbMapElm->iqWidth, p_pRbMapElm->compMethod);
- if(ext_sec_total > 0) {
- p_pRbMapElm->bf_weight.p_ext_start = ext_buf_start;
- p_pRbMapElm->bf_weight.p_ext_section = ext_buf;
- p_pRbMapElm->bf_weight.ext_section_sz = ext_sec_total;
- } else
- rte_panic("xran_cp_populate_section_ext_1 return error [%d]\n", ext_sec_total);
+ if(p_pRbMapElm->bf_weight.extType == 1) {
+ app_io_xran_ext_type1_populate(p_pRbMapElm, dl_bfw_pos, app_io_xran_fh_init.mtu, &numSetBFW_total);
} else {
- rte_panic("xran_malloc return NULL\n");
- }
- } else {
- app_io_xran_ext_type11_populate(p_pRbMapElm, p_iq->p_tx_dl_bfw_buffer[flowId], app_io_xran_fh_init.mtu);
+ app_io_xran_ext_type11_populate(p_pRbMapElm, dl_bfw_pos, app_io_xran_fh_init.mtu);
}
}
+ numSetBFW_total += p_pRbMapElm->bf_weight.numSetBFWs;
}
}
} else {
- printf("DL pRbMap ==NULL\n");
+ printf("DL pRbMap ==NULL [%d][%d][%d]\n", tti_dst, cc_id, ant_id);
exit(-1);
}
-
- if(pXranConf->ru_conf.xranCat == XRAN_CATEGORY_B && appMode == APP_O_DU && sym_id == 0) {
- p_iq->tx_dl_bfw_buffer_position[flowId] += (pXranConf->nDLRBs*pXranConf->nAntElmTRx)*4;
- if(p_iq->tx_dl_bfw_buffer_position[flowId] >= p_iq->tx_dl_bfw_buffer_size[flowId])
- p_iq->tx_dl_bfw_buffer_position[flowId] = 0;
- }
} else {
//printf("flowId %d\n", flowId);
}
int32_t
app_io_xran_iq_content_init_cp_rx(uint8_t appMode, struct xran_fh_config *pXranConf,
struct bbu_xran_io_if *psBbuIo, struct xran_io_shared_ctrl *psIoCtrl, struct o_xu_buffers * p_iq,
- int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t tti, int32_t flowId)
+ int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t target_tti, int32_t flowId)
{
- int32_t status = 0;
struct xran_prb_map* pRbMap = NULL;
- char *pos = NULL;
- void *ptr = NULL;
+ char* ul_bfw_pos = NULL;
+
+ int32_t tti_dst = target_tti % XRAN_N_FE_BUF_LEN;
+ int32_t tti_src = target_tti % p_iq->numSlots;
+ int32_t tx_ul_bfw_buffer_position = tti_src * (pXranConf->nULRBs*pXranConf->nAntElmTRx)*4;
+
+ uint16_t numSetBFW_total = 0;
- pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
+ cc_id = cc_id % XRAN_MAX_SECTOR_NR;
+ ant_id = ant_id % XRAN_MAX_ANTENNA_NR;
+
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[tti_dst][cc_id][ant_id].sBufferList.pBuffers->pData;
+ ul_bfw_pos = ((char*)p_iq->p_tx_ul_bfw_buffer[flowId]) + tx_ul_bfw_buffer_position;
if(pRbMap) {
if (pXranConf->DynamicSectionEna == 0) {
- app_io_xran_iq_content_init_cp_rb_map(pRbMap, XRAN_DIR_UL, cc_id, ant_id, sym_id, tti, pXranConf->nULRBs);
+ if(pRbMap->nPrbElm != 1 )
+ app_io_xran_iq_content_init_cp_rb_map(pRbMap, XRAN_DIR_UL, cc_id, ant_id, sym_id, tti_dst, pXranConf->nULRBs);
} else if(pXranConf->ru_conf.xranCat == XRAN_CATEGORY_B
&& appMode == APP_O_DU
&& sym_id == 0) {
int32_t idxElm = 0;
- char * ul_bfw_pos = ((char*)p_iq->p_tx_ul_bfw_buffer[flowId]) + p_iq->tx_ul_bfw_buffer_position[flowId];
struct xran_prb_elm* p_pRbMapElm = NULL;
for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++) {
p_pRbMapElm->bf_weight.nAntElmTRx = pXranConf->nAntElmTRx;
if(p_pRbMapElm->BeamFormingType == XRAN_BEAM_WEIGHT && p_pRbMapElm->bf_weight_update) {
- if(p_pRbMapElm->bf_weight.numBundPrb == 0) {
- /* No bundled PRB, using extension 1 */
-
- int16_t ext_len = 9600;
- int16_t ext_sec_total = 0;
- int8_t * ext_buf =(int8_t*) xran_malloc(ext_len);
- int8_t * ext_buf_start = ext_buf;
- int32_t idRb = 0;
- int16_t *ptr = NULL;
- int32_t i;
- if(ext_buf) {
- ext_buf += (RTE_PKTMBUF_HEADROOM +
- sizeof(struct xran_ecpri_hdr) +
- sizeof(struct xran_cp_radioapp_section1_header) +
- sizeof(struct xran_cp_radioapp_section1));
-
- ext_len -= (RTE_PKTMBUF_HEADROOM +
- sizeof(struct xran_ecpri_hdr) +
- sizeof(struct xran_cp_radioapp_section1_header) +
- sizeof(struct xran_cp_radioapp_section1));
-
- ptr = (int16_t*)(ul_bfw_pos +(p_pRbMapElm->nRBStart*p_pRbMapElm->bf_weight.nAntElmTRx)*4);
- ext_sec_total = xran_cp_populate_section_ext_1((int8_t *)ext_buf,
- ext_len,
- (int16_t *) (ul_bfw_pos + (p_pRbMapElm->nRBStart*p_pRbMapElm->bf_weight.nAntElmTRx)*4),
- p_pRbMapElm->nRBSize,
- p_pRbMapElm->bf_weight.nAntElmTRx,
- p_pRbMapElm->iqWidth, p_pRbMapElm->compMethod);
- if(ext_sec_total > 0) {
- p_pRbMapElm->bf_weight.p_ext_start = ext_buf_start;
- p_pRbMapElm->bf_weight.p_ext_section = ext_buf;
- p_pRbMapElm->bf_weight.ext_section_sz = ext_sec_total;
+ if(p_pRbMapElm->bf_weight.extType == 1) {
+ app_io_xran_ext_type1_populate(p_pRbMapElm, ul_bfw_pos, app_io_xran_fh_init.mtu, &numSetBFW_total);
} else {
- rte_panic("xran_cp_populate_section_ext_1 return error [%d]\n", ext_sec_total);
- }
- } else {
- rte_panic("xran_malloc return NULL\n");
- }
- } else {
- app_io_xran_ext_type11_populate(p_pRbMapElm, p_iq->p_tx_ul_bfw_buffer[flowId], app_io_xran_fh_init.mtu);
- }
- }
+ app_io_xran_ext_type11_populate(p_pRbMapElm, ul_bfw_pos, app_io_xran_fh_init.mtu);
}
+ } /* if(p_pRbMapElm->BeamFormingType == XRAN_BEAM_WEIGHT && p_pRbMapElm->bf_weight_update) */
+ numSetBFW_total += p_pRbMapElm->bf_weight.numSetBFWs;
+ } /* for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++) */
}
- p_iq->tx_ul_bfw_buffer_position[flowId] += (pXranConf->nULRBs*pXranConf->nAntElmTRx)*4;
- if(p_iq->tx_ul_bfw_buffer_position[flowId] >= p_iq->tx_ul_bfw_buffer_size[flowId])
- p_iq->tx_ul_bfw_buffer_position[flowId] = 0;
} else {
rte_panic("DL pRbMap ==NULL\n");
}
int32_t
app_io_xran_iq_content_init_up_tx(uint8_t appMode, struct xran_fh_config *pXranConf,
struct bbu_xran_io_if *psBbuIo, struct xran_io_shared_ctrl *psIoCtrl, struct o_xu_buffers * p_iq,
- int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t tti, int32_t flowId)
+ int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t target_tti, int32_t flowId)
{
char *pos = NULL;
void *ptr = NULL;
struct xran_prb_map* pRbMap = NULL;
enum xran_comp_hdr_type staticEn = XRAN_COMP_HDR_TYPE_DYNAMIC;
+ int32_t tti_dst = target_tti % XRAN_N_FE_BUF_LEN;
+ int32_t tti_src = target_tti % p_iq->numSlots;
+ int32_t tx_play_buffer_position = tti_src * (XRAN_NUM_OF_SYMBOL_PER_SLOT*pXranConf->nDLRBs*N_SC_PER_PRB*4) + (sym_id * pXranConf->nDLRBs*N_SC_PER_PRB*4);
+
if (pXranConf != NULL)
{
staticEn = pXranConf->ru_conf.xranCompHdrType;
- pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
- pos = ((char*)p_iq->p_tx_play_buffer[flowId]) + p_iq->tx_play_buffer_position[flowId];
- ptr = psIoCtrl->sFrontHaulTxBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[tti_dst][cc_id][ant_id].sBufferList.pBuffers->pData;
+ pos = ((char*)p_iq->p_tx_play_buffer[flowId]) + tx_play_buffer_position;
+ ptr = psIoCtrl->sFrontHaulTxBbuIoBufCtrl[tti_dst][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
if(ptr && pos) {
int32_t idxElm = 0;
uint8_t *dst = (uint8_t *)u8dptr;
uint8_t *src = (uint8_t *)pos;
+ uint16_t num_sections, idx, comp_method;
+ uint16_t prb_per_section;
struct xran_prb_elm* p_prbMapElm = &pRbMap->prbMap[idxElm];
dst = xran_add_hdr_offset(dst, ((staticEn == XRAN_COMP_HDR_TYPE_DYNAMIC) ? p_prbMapElm->compMethod : XRAN_COMPMETHOD_NONE));
for (idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++) {
struct xran_section_desc *p_sec_desc = NULL;
p_prbMapElm = &pRbMap->prbMap[idxElm];
- p_sec_desc = p_prbMapElm->p_sec_desc[sym_id][0];
+ p_sec_desc = &p_prbMapElm->sec_desc[sym_id][0];
+
+ if(p_prbMapElm->bf_weight.extType == 1)
+ {
+ num_sections = p_prbMapElm->bf_weight.numSetBFWs;
+ prb_per_section = p_prbMapElm->bf_weight.numBundPrb;
+ }
+ else
+ {
+ num_sections = 1;
+ prb_per_section = p_prbMapElm->UP_nRBSize;
+ }
if(p_sec_desc == NULL) {
rte_panic ("p_sec_desc == NULL\n");
continue;
}
- src = (uint8_t *)(pos + p_prbMapElm->nRBStart*N_SC_PER_PRB*4L);
+ src = (uint8_t *)(pos + p_prbMapElm->UP_nRBStart*N_SC_PER_PRB*4L);
+ p_sec_desc->iq_buffer_offset = RTE_PTR_DIFF(dst, u8dptr);
+ p_sec_desc->iq_buffer_len = 0;
+
+ for(idx=0; idx < num_sections ; idx++)
+ {
+ //printf("\nidx %hu u8dptr %p dst %p",idx,u8dptr,dst);
+
+ if((idx+1)*prb_per_section > p_prbMapElm->UP_nRBSize){
+ prb_per_section = (p_prbMapElm->UP_nRBSize - idx*prb_per_section);
+ }
if(p_prbMapElm->compMethod == XRAN_COMPMETHOD_NONE) {
- payload_len = p_prbMapElm->nRBSize*N_SC_PER_PRB*4L;
+ payload_len = prb_per_section*N_SC_PER_PRB*4L;
memcpy(dst, src, payload_len);
} else if ((p_prbMapElm->compMethod == XRAN_COMPMETHOD_BLKFLOAT) || (p_prbMapElm->compMethod == XRAN_COMPMETHOD_MODULATION)) {
memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
bfp_com_req.data_in = (int16_t*)src;
- bfp_com_req.numRBs = p_prbMapElm->nRBSize;
- bfp_com_req.len = p_prbMapElm->nRBSize*N_SC_PER_PRB*4L;
+ bfp_com_req.numRBs = prb_per_section;
+ bfp_com_req.len = prb_per_section*N_SC_PER_PRB*4L;
bfp_com_req.compMethod = p_prbMapElm->compMethod;
bfp_com_req.iqWidth = p_prbMapElm->iqWidth;
bfp_com_req.ScaleFactor= p_prbMapElm->ScaleFactor;
exit(-1);
}
+ if(num_sections != 1)
+ src += prb_per_section*N_SC_PER_PRB*4L;
+
/* update RB map for given element */
- p_sec_desc->iq_buffer_offset = RTE_PTR_DIFF(dst, u8dptr);
- p_sec_desc->iq_buffer_len = payload_len;
+ //p_sec_desc->iq_buffer_offset = RTE_PTR_DIFF(dst, u8dptr);
+ p_sec_desc->iq_buffer_len += payload_len;
/* add headroom for ORAN headers between IQs for chunk of RBs*/
dst += payload_len;
+ if(idx+1 == num_sections) /* Create space for (eth + eCPRI + radio app + section + comp) headers required by next prbElement */
+ {
dst = xran_add_hdr_offset(dst, ((staticEn == XRAN_COMP_HDR_TYPE_DYNAMIC) ? p_prbMapElm->compMethod : XRAN_COMPMETHOD_NONE));
}
+ else
+ {
+ /* Create space for section/compression header in current prbElement */
+ //TODO: Check if alignment required for this case
+ dst += sizeof(struct data_section_hdr);
+ p_sec_desc->iq_buffer_len += sizeof(struct data_section_hdr);
- p_iq->tx_play_buffer_position[flowId] += pXranConf->nDLRBs*N_SC_PER_PRB*4;
- if(p_iq->tx_play_buffer_position[flowId] >= p_iq->tx_play_buffer_size[flowId])
- p_iq->tx_play_buffer_position[flowId] = 0;
- } else {
- rte_panic("ptr ==NULL\n");
+ comp_method = ((staticEn == XRAN_COMP_HDR_TYPE_DYNAMIC) ? p_prbMapElm->compMethod : XRAN_COMPMETHOD_NONE);
+
+ if( comp_method != XRAN_COMPMETHOD_NONE)
+ {
+ dst += sizeof (struct data_section_compression_hdr);
+ p_sec_desc->iq_buffer_len += sizeof(struct data_section_compression_hdr);
}
}
-
+ } /*for num_section */
+ } /* for (idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++) */
+ } /* if(ptr && pos) */
+ else {
+ rte_panic("ptr ==NULL\n");
+ }
+ } /* if (pXranConf != NULL) */
return 0;
}
ptr = psIoCtrl->sFHPrachRxBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
if(ptr && pos) {
- int32_t compMethod = pXranConf->ru_conf.compMeth;
+ int32_t compMethod = pXranConf->ru_conf.compMeth_PRACH;
if(compMethod == XRAN_COMPMETHOD_NONE) {
u32dptr = (uint32_t*)(ptr);
comp_req.len = RTE_MIN(PRACH_PLAYBACK_BUFFER_BYTES, p_iq->tx_prach_play_buffer_size[flowId]);
comp_req.numRBs = comp_req.len / 12 / 4; /* 12RE, 4bytes */
comp_req.compMethod = compMethod;
- comp_req.iqWidth = pXranConf->ru_conf.iqWidth;
+ comp_req.iqWidth = pXranConf->ru_conf.iqWidth_PRACH;
comp_req.ScaleFactor = 0; /* TODO */
comp_req.reMask = 0xfff; /* TODO */
for (idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++) {
struct xran_section_desc *p_sec_desc = NULL;
p_prbMapElm = &pRbMap->prbMap[idxElm];
- p_sec_desc = p_prbMapElm->p_sec_desc[sym_id][0];
+ p_sec_desc = &p_prbMapElm->sec_desc[sym_id][0];
if(p_sec_desc == NULL){
rte_panic ("p_sec_desc == NULL\n");
continue;
}
- src = (uint8_t *)(pos + p_prbMapElm->nRBStart*N_SC_PER_PRB*4L);
+ src = (uint8_t *)(pos + p_prbMapElm->UP_nRBStart*N_SC_PER_PRB*4L);
if(p_prbMapElm->compMethod == XRAN_COMPMETHOD_NONE) {
- payload_len = p_prbMapElm->nRBSize*N_SC_PER_PRB*4L;
+ payload_len = p_prbMapElm->UP_nRBSize*N_SC_PER_PRB*4L;
memcpy(dst, src, payload_len);
} else if (p_prbMapElm->compMethod == XRAN_COMPMETHOD_BLKFLOAT
memset(&bfp_com_rsp, 0, sizeof(struct xranlib_compress_response));
bfp_com_req.data_in = (int16_t*)src;
- bfp_com_req.numRBs = p_prbMapElm->nRBSize;
- bfp_com_req.len = p_prbMapElm->nRBSize*N_SC_PER_PRB*4L;
+ bfp_com_req.numRBs = p_prbMapElm->UP_nRBSize;
+ bfp_com_req.len = p_prbMapElm->UP_nRBSize*N_SC_PER_PRB*4L;
bfp_com_req.compMethod = p_prbMapElm->compMethod;
bfp_com_req.iqWidth = p_prbMapElm->iqWidth;
bfp_com_req.ScaleFactor= p_prbMapElm->ScaleFactor;
int32_t cc_id, ant_id, sym_id, tti;
int32_t flowId;
- uint8_t frame_id = 0;
- uint8_t subframe_id = 0;
- uint8_t slot_id = 0;
- uint8_t sym = 0;
-
- void *ptr;
- uint32_t *u32dptr;
- uint16_t *u16dptr;
- uint8_t *u8dptr;
+ //uint8_t frame_id = 0;
+ //uint8_t subframe_id = 0;
+ //uint8_t slot_id = 0;
+ //uint8_t sym = 0;
struct xran_fh_config *pXranConf = &app_io_xran_fh_config[o_xu_id];
- struct xran_fh_init *pXranInit = &app_io_xran_fh_init;
+ //struct xran_fh_init *pXranInit = &app_io_xran_fh_init;
struct o_xu_buffers * p_iq = NULL;
uint32_t xran_max_antenna_nr = RTE_MAX(p_o_xu_cfg->numAxc, p_o_xu_cfg->numUlAxc);
uint32_t xran_max_ant_array_elm_nr = RTE_MAX(p_o_xu_cfg->antElmTRx, xran_max_antenna_nr);
-
- char *pos = NULL;
- struct xran_prb_map *pRbMap = NULL;
+ uint32_t xran_max_antenna_nr_prach = RTE_MIN(xran_max_antenna_nr, XRAN_MAX_PRACH_ANT_NUM);
if(psBbuIo == NULL){
rte_panic("psBbuIo == NULL\n");
/* prach TX for RU only */
if(p_o_xu_cfg->appMode == APP_O_RU && p_o_xu_cfg->enablePrach) {
- for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) {
+ for(ant_id = 0; ant_id < xran_max_antenna_nr_prach; ant_id++) {
for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) {
- flowId = p_o_xu_cfg->numAxc*cc_id + ant_id;
+ flowId = xran_max_antenna_nr_prach * cc_id + ant_id;
if ((status = app_io_xran_iq_content_init_up_prach(p_o_xu_cfg->appMode, pXranConf,
psBbuIo, psIoCtrl, p_iq,
cc_id, ant_id, sym_id, tti, flowId)) != 0) {
- rte_panic("app_io_xran_iq_content_init_cp_tx");
+ rte_panic("app_io_xran_iq_content_init_up_prach");
}
}
}
if ((status = app_io_xran_iq_content_init_up_srs(p_o_xu_cfg->appMode, pXranConf,
psBbuIo, psIoCtrl, p_iq,
cc_id, ant_id, sym_id, tti, flowId)) != 0){
- rte_panic("app_io_xran_iq_content_init_cp_tx");
+ rte_panic("app_io_xran_iq_content_init_up_srs");
}
}
}
void app_io_xran_if_stop(void)
{
xran_status_t status = 0;
- SWXRANInterfaceTypeEnum eInterfaceType;
status += xran_mm_destroy(app_io_xran_handle)*2;
}
int32_t
-app_io_xran_iq_content_get(uint32_t o_xu_id, RuntimeConfig *p_o_xu_cfg)
+app_io_xran_iq_content_get_up_prach(uint8_t appMode, struct xran_fh_config *pXranConf,
+ struct bbu_xran_io_if *psBbuIo, struct xran_io_shared_ctrl *psIoCtrl, struct o_xu_buffers * p_iq,
+ int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t target_tti, int32_t flowId)
{
- struct bbu_xran_io_if *psBbuIo = app_io_xran_if_get();
- struct xran_io_shared_ctrl *psIoCtrl = app_io_xran_if_ctrl_get(o_xu_id);
- xran_status_t status;
- int32_t nSectorIndex[XRAN_MAX_SECTOR_NR];
- int32_t nSectorNum;
- int32_t cc_id, ant_id, sym_id, tti;
- int32_t flowId;
-
- uint8_t frame_id = 0;
- uint8_t subframe_id = 0;
- uint8_t slot_id = 0;
- uint8_t sym = 0;
- uint16_t idxDesc = 0;
-
- void *ptr;
- uint32_t *u32dptr;
- uint16_t *u16dptr;
- uint8_t *u8dptr;
+ xran_status_t status = 0;
+ int32_t prach_len = 0;
+ void *ptr = NULL;
+ char *pos = NULL;
- struct xran_fh_config *pXranConf = &app_io_xran_fh_config[o_xu_id];
+ int32_t tti_src = target_tti % XRAN_N_FE_BUF_LEN;
+ int32_t tti_dst = target_tti % p_iq->numSlots;
+ int32_t prach_log_buffer_position;
- uint32_t xran_max_antenna_nr = RTE_MAX(p_o_xu_cfg->numAxc, p_o_xu_cfg->numUlAxc);
- uint32_t xran_max_ant_array_elm_nr = RTE_MAX(p_o_xu_cfg->antElmTRx, xran_max_antenna_nr);
+ prach_len = (3 * pXranConf->ru_conf.iqWidth_PRACH) * pXranConf->prach_conf.numPrbc; /* 12RE*2pairs/8bits (12*2/8=3)*/
+ prach_log_buffer_position = tti_dst * (XRAN_NUM_OF_SYMBOL_PER_SLOT*prach_len) + (sym_id * prach_len);
- char *pos = NULL;
- struct o_xu_buffers *p_iq = NULL;
+ if(p_iq->p_prach_log_buffer[flowId]) {
+ pos = ((char*)p_iq->p_prach_log_buffer[flowId]) + prach_log_buffer_position;
+ ptr = psIoCtrl->sFHPrachRxBbuIoBufCtrlDecomp[tti_src][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
+ if(ptr) {
+ int32_t compMethod = pXranConf->ru_conf.compMeth_PRACH;
+ if(compMethod == XRAN_COMPMETHOD_NONE) {
+ memcpy(pos, (uint32_t *)(ptr), prach_len);
+ } else {
+ struct xranlib_decompress_request decomp_req;
+ struct xranlib_decompress_response decomp_rsp;
+ int32_t parm_size;
+
+ memset(&decomp_req, 0, sizeof(struct xranlib_decompress_request));
+ memset(&decomp_rsp, 0, sizeof(struct xranlib_decompress_response));
+
+ switch(compMethod) {
+ case XRAN_COMPMETHOD_BLKFLOAT: parm_size = 1; break;
+ case XRAN_COMPMETHOD_MODULATION: parm_size = 0; break;
+ default:
+ parm_size = 0;
+ }
- if(psBbuIo == NULL)
- rte_panic("psBbuIo == NULL\n");
+ decomp_req.data_in = (int8_t *)ptr;
+ decomp_req.numRBs = pXranConf->prach_conf.numPrbc;
+ decomp_req.len = (3 * pXranConf->ru_conf.iqWidth_PRACH + parm_size) * pXranConf->prach_conf.numPrbc; /* 12RE*2pairs/8bits (12*2/8=3)*/
+ decomp_req.compMethod = compMethod;
+ decomp_req.iqWidth = pXranConf->ru_conf.iqWidth_PRACH;
+ decomp_req.ScaleFactor = 0; /* TODO */
+ decomp_req.reMask = 0xfff; /* TODO */
- if(psIoCtrl == NULL)
- rte_panic("psIoCtrl == NULL\n");
+ decomp_rsp.data_out = (int16_t *)pos;
+ decomp_rsp.len = 0;
- for (nSectorNum = 0; nSectorNum < XRAN_MAX_SECTOR_NR; nSectorNum++) {
- nSectorIndex[nSectorNum] = nSectorNum;
+ xranlib_decompress(&decomp_req, &decomp_rsp);
}
+ }
+ } /* if(p_iq->p_prach_log_buffer[flowId]) */
- nSectorNum = p_o_xu_cfg->numCC;
- printf ("app_io_xran_iq_content_get\n");
-
- if(p_o_xu_cfg->p_buff) {
- p_iq = p_o_xu_cfg->p_buff;
- } else {
- printf("Error p_o_xu_cfg->p_buff\n");
- exit(-1);
+ return status;
}
- for(cc_id = 0; cc_id <nSectorNum; cc_id++) {
- for(tti = 0; tti < XRAN_N_FE_BUF_LEN; tti++) {
- for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) {
+int32_t
+app_io_xran_iq_content_get_up_srs(uint8_t appMode, struct xran_fh_config *pXranConf,
+ struct bbu_xran_io_if *psBbuIo, struct xran_io_shared_ctrl *psIoCtrl, struct o_xu_buffers * p_iq,
+ int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t target_tti, int32_t flowId)
+{
+ xran_status_t status = 0;
int32_t idxElm = 0;
struct xran_prb_map *pRbMap = NULL;
struct xran_prb_elm *pRbElm = NULL;
struct xran_section_desc *p_sec_desc = NULL;
- int32_t prach_len = 0;
- pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
+ void *ptr = NULL;
+ char *pos = NULL;
+ uint32_t *u32dptr;
+
+ int32_t tti_src = target_tti % XRAN_N_FE_BUF_LEN;
+ int32_t tti_dst = target_tti % p_iq->numSlots;
+ int32_t srs_log_buffer_position = tti_dst * (XRAN_NUM_OF_SYMBOL_PER_SLOT*pXranConf->nULRBs*N_SC_PER_PRB*4) + (sym_id * pXranConf->nULRBs*N_SC_PER_PRB*4);
+
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[tti_src][cc_id][ant_id].sBufferList.pBuffers->pData;
if(pRbMap == NULL){
- printf("pRbMap == NULL\n");
- exit(-1);
+ rte_panic("pRbMap == NULL\n");
}
- if(p_o_xu_cfg->appMode == APP_O_RU)
- flowId = p_o_xu_cfg->numAxc * cc_id + ant_id;
- else
- flowId = p_o_xu_cfg->numUlAxc * cc_id + ant_id;
- for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) {
+ if(p_iq->p_srs_log_buffer[flowId]) {
pRbElm = &pRbMap->prbMap[0];
- if(pRbMap->nPrbElm == 1){
- if(p_iq->p_rx_log_buffer[flowId]) {
- pos = ((char*)p_iq->p_rx_log_buffer[flowId]) + p_iq->rx_log_buffer_position[flowId];
- uint32_t one_rb_size = (((pRbElm->iqWidth == 0) || (pRbElm->iqWidth == 16)) ? (N_SC_PER_PRB*2*2) : (3 * pRbElm->iqWidth + 1));
- if (app_io_xran_fh_init.mtu < pRbElm->nRBSize * one_rb_size)
- {
- ptr = psIoCtrl->sFrontHaulRxBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
+ /*if(pRbMap->nPrbElm == 1) {
+ if(sym_id >= pRbElm->nStartSymb && sym_id < pRbElm->nStartSymb + pRbElm->numSymb) {
+ pos = ((char*)p_iq->p_srs_log_buffer[flowId]) + p_iq->srs_log_buffer_position[flowId];
+ ptr = psIoCtrl->sFHSrsRxBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
if(ptr){
int32_t payload_len = 0;
u32dptr = (uint32_t*)(ptr);
memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
-
switch(pRbElm->compMethod) {
case XRAN_COMPMETHOD_BLKFLOAT:
parm_size = 1;
bfp_decom_req.len = (3 * pRbElm->iqWidth + parm_size) * pRbElm->nRBSize;
bfp_decom_req.compMethod = pRbElm->compMethod;
bfp_decom_req.iqWidth = pRbElm->iqWidth;
- bfp_decom_req.reMask = pRbElm->reMask;
- bfp_decom_req.ScaleFactor= pRbElm->ScaleFactor;
bfp_decom_rsp.data_out = (int16_t *)(pos + pRbElm->nRBStart*N_SC_PER_PRB*4);
bfp_decom_rsp.len = 0;
memcpy(pos + pRbElm->nRBStart*N_SC_PER_PRB*4L , u32dptr, pRbElm->nRBSize*N_SC_PER_PRB*4L);
}
}else {
- printf("%s:%d [%d][%d][%d][%d]ptr ==NULL\n", __FUNCTION__, __LINE__, tti,cc_id,ant_id, sym_id);
+ printf("[%d][%d][%d][%d]ptr ==NULL\n",tti,cc_id,ant_id, sym_id);
}
}
- else
- {
- p_sec_desc = pRbElm->p_sec_desc[sym_id][0];
- if(p_iq->p_rx_log_buffer[flowId] && p_sec_desc){
+ } else*/ {
+ for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++ ) {
+ pRbElm = &pRbMap->prbMap[idxElm];
+ p_sec_desc = &pRbElm->sec_desc[sym_id][0];
+ if(p_iq->p_srs_log_buffer[flowId] && p_sec_desc) {
if(sym_id >= pRbElm->nStartSymb && sym_id < pRbElm->nStartSymb + pRbElm->numSymb){
- pos = ((char*)p_iq->p_rx_log_buffer[flowId]) + p_iq->rx_log_buffer_position[flowId];
+ pos = ((char*)p_iq->p_srs_log_buffer[flowId]) + srs_log_buffer_position;
ptr = p_sec_desc->pData;
if(ptr){
- int32_t payload_len = 0;
u32dptr = (uint32_t*)(ptr);
if (pRbElm->compMethod != XRAN_COMPMETHOD_NONE){
struct xranlib_decompress_request bfp_decom_req;
bfp_decom_req.len = (3 * pRbElm->iqWidth + parm_size)*pRbElm->nRBSize;
bfp_decom_req.compMethod = pRbElm->compMethod;
bfp_decom_req.iqWidth = pRbElm->iqWidth;
- bfp_decom_req.reMask = pRbElm->reMask;
- bfp_decom_req.ScaleFactor= pRbElm->ScaleFactor;
bfp_decom_rsp.data_out = (int16_t *)(pos + pRbElm->nRBStart*N_SC_PER_PRB*4);
bfp_decom_rsp.len = 0;
xranlib_decompress(&bfp_decom_req, &bfp_decom_rsp);
- payload_len = bfp_decom_rsp.len;
-
- }
- else {
+ } else {
memcpy(pos + pRbElm->nRBStart*N_SC_PER_PRB*4 , u32dptr, pRbElm->nRBSize*N_SC_PER_PRB*4);
}
}
- else {
- printf("%s:%d [%d][%d][%d][%d]ptr ==NULL\n", __FUNCTION__, __LINE__, tti,cc_id,ant_id, sym_id);
}
+ } else {
+ printf("(%d : %d : %d) flowid %d, p_sec_desc is empty\n", target_tti, sym_id, ant_id,flowId);
}
}
- else
- printf("(%d : %d : %d) flowid %d, p_sec_desc is empty\n", tti, sym_id, ant_id,flowId);
}
}
- } else {
+
+ return status;
+}
+
+int32_t
+app_io_xran_iq_content_get_up_rx(uint8_t appMode, struct xran_fh_config *pXranConf,
+ struct bbu_xran_io_if *psBbuIo, struct xran_io_shared_ctrl *psIoCtrl, struct o_xu_buffers * p_iq,
+ int32_t cc_id, int32_t ant_id, int32_t sym_id, int32_t target_tti, int32_t flowId)
+{
+ xran_status_t status = 0;
+ int32_t idxElm = 0;
+ int32_t idxSection = 0;
+ struct xran_prb_map *pRbMap = NULL;
+ struct xran_prb_elm *pRbElm = NULL;
+ struct xran_prb_elm *pRbElmRx = NULL;
+ struct xran_section_desc *p_sec_desc = NULL;
+
+ uint16_t idxDesc = 0;
+
+ void *ptr = NULL;
+ char *pos = NULL;
+ uint32_t *u32dptr;
+ struct data_section_hdr* data_hdr;
+ uint16_t num_prbu = 0, start_prbu = 0, prb_idx;
+ char *src;
+ const int16_t data_size = sizeof(struct data_section_hdr);
+ const int16_t compr_size = sizeof(struct data_section_compression_hdr);
+
+ int32_t tti_src = target_tti % XRAN_N_FE_BUF_LEN;
+ int32_t tti_dst = target_tti % p_iq->numSlots;
+ int32_t rx_log_buffer_position = tti_dst * (XRAN_NUM_OF_SYMBOL_PER_SLOT*pXranConf->nULRBs*N_SC_PER_PRB*4) + (sym_id * pXranConf->nULRBs*N_SC_PER_PRB*4);
+
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[tti_src][cc_id][ant_id].sBufferList.pBuffers->pData;
+ if(pRbMap == NULL) {
+ printf("pRbMap == NULL\n");
+ exit(-1);
+ }
+
+ if(0 == pXranConf->RunSlotPrbMapBySymbolEnable)
+ {
for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++ ) {
pRbElm = &pRbMap->prbMap[idxElm];
- p_sec_desc = pRbElm->p_sec_desc[sym_id][0];
+ for (idxDesc = 0; idxDesc < XRAN_MAX_FRAGMENT; idxDesc++) {
+ p_sec_desc = &pRbElm->sec_desc[sym_id][idxDesc];
if(p_iq->p_rx_log_buffer[flowId] && p_sec_desc){
if(sym_id >= pRbElm->nStartSymb && sym_id < pRbElm->nStartSymb + pRbElm->numSymb){
- pos = ((char*)p_iq->p_rx_log_buffer[flowId]) + p_iq->rx_log_buffer_position[flowId];
+ if (!p_sec_desc->pCtrl)
+ continue;
+ pos = ((char*)p_iq->p_rx_log_buffer[flowId]) + rx_log_buffer_position;
ptr = p_sec_desc->pData;
- if(ptr){
- int32_t payload_len = 0;
- u32dptr = (uint32_t*)(ptr);
+ src = (char *)ptr;
+ data_hdr = (struct data_section_hdr *)src;
+ num_prbu = p_sec_desc->num_prbu;
+ start_prbu = p_sec_desc->start_prbu;
+ prb_idx = start_prbu;
+ while(prb_idx < (pRbElm->UP_nRBStart + pRbElm->UP_nRBSize) && num_prbu != 0){
+ if(src){
+ u32dptr = (uint32_t*)(src);
if (pRbElm->compMethod != XRAN_COMPMETHOD_NONE){
struct xranlib_decompress_request bfp_decom_req;
struct xranlib_decompress_response bfp_decom_rsp;
- int32_t parm_size;
+ int32_t parm_size = 0;
memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
}
bfp_decom_req.data_in = (int8_t *)u32dptr;
- bfp_decom_req.numRBs = pRbElm->nRBSize;
- bfp_decom_req.len = (3 * pRbElm->iqWidth + parm_size)*pRbElm->nRBSize;
+ bfp_decom_req.numRBs = num_prbu;
+ bfp_decom_req.len = (3 * pRbElm->iqWidth + parm_size)*num_prbu;
bfp_decom_req.compMethod = pRbElm->compMethod;
bfp_decom_req.iqWidth = pRbElm->iqWidth;
bfp_decom_req.reMask = pRbElm->reMask;
bfp_decom_req.ScaleFactor= pRbElm->ScaleFactor;
- bfp_decom_rsp.data_out = (int16_t *)(pos + pRbElm->nRBStart*N_SC_PER_PRB*4);
+ bfp_decom_rsp.data_out = (int16_t *)(pos + start_prbu*N_SC_PER_PRB*4);
bfp_decom_rsp.len = 0;
xranlib_decompress(&bfp_decom_req, &bfp_decom_rsp);
- payload_len = bfp_decom_rsp.len;
+ src += (3 * pRbElm->iqWidth + parm_size)*num_prbu;
} else {
- memcpy(pos + pRbElm->nRBStart*N_SC_PER_PRB*4 , u32dptr, pRbElm->nRBSize*N_SC_PER_PRB*4);
+ memcpy(pos + start_prbu*N_SC_PER_PRB*4 , u32dptr, num_prbu*N_SC_PER_PRB*4);
+ src += num_prbu*N_SC_PER_PRB*4;
}
}
else {
- // printf("%s:%d [%d][%d][%d][%d]ptr ==NULL\n", __FUNCTION__, __LINE__, tti,cc_id,ant_id, sym_id);
- }
+ // printf("%s:%d [%d][%d][%d][%d]src ==NULL\n", __FUNCTION__, __LINE__, tti,cc_id,ant_id, sym_id);
}
+ data_hdr = (struct data_section_hdr *)src;
+ if(pRbElm->bf_weight.extType == 1 && data_hdr != NULL)
+ {
+ data_hdr->fields.all_bits = rte_be_to_cpu_32(data_hdr->fields.all_bits);
+ num_prbu = data_hdr->fields.num_prbu;
+ start_prbu = data_hdr->fields.start_prbu;
+ prb_idx += num_prbu;
+ src += data_size;
+ if (pRbElm->compMethod != XRAN_COMPMETHOD_NONE && pXranConf->ru_conf.xranCompHdrType == XRAN_COMP_HDR_TYPE_DYNAMIC)
+ src += compr_size;
}
else
- printf("(%d : %d : %d) flowid %d, p_sec_desc is empty\n", tti, sym_id, ant_id,flowId);
- }
+ break;
}
- p_iq->rx_log_buffer_position[flowId] += pXranConf->nULRBs*N_SC_PER_PRB*4;
-
- if(p_iq->rx_log_buffer_position[flowId] >= p_iq->rx_log_buffer_size[flowId])
- p_iq->rx_log_buffer_position[flowId] = 0;
}
-
-
- flowId = p_o_xu_cfg->numAxc * cc_id + ant_id;
- prach_len = (3 * pXranConf->ru_conf.iqWidth_PRACH) * pXranConf->prach_conf.numPrbc; /* 12RE*2pairs/8bits (12*2/8=3)*/
- for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) {
-
- if(p_iq->p_prach_log_buffer[flowId]) {
- pos = ((char*)p_iq->p_prach_log_buffer[flowId]) + p_iq->prach_log_buffer_position[flowId];
- ptr = psIoCtrl->sFHPrachRxBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
- if(ptr) {
- int32_t compMethod = pXranConf->ru_conf.compMeth_PRACH;
-
- if(compMethod == XRAN_COMPMETHOD_NONE) {
- memcpy(pos, (uint32_t *)(ptr), prach_len);
- }
- else {
- struct xranlib_decompress_request decomp_req;
- struct xranlib_decompress_response decomp_rsp;
- int32_t parm_size;
-
- memset(&decomp_req, 0, sizeof(struct xranlib_decompress_request));
- memset(&decomp_rsp, 0, sizeof(struct xranlib_decompress_response));
-
- switch(compMethod) {
- case XRAN_COMPMETHOD_BLKFLOAT: parm_size = 1; break;
- case XRAN_COMPMETHOD_MODULATION: parm_size = 0; break;
- default:
- parm_size = 0;
}
-
- decomp_req.data_in = (int8_t *)ptr;
- decomp_req.numRBs = pXranConf->prach_conf.numPrbc;
- decomp_req.len = (3 * pXranConf->ru_conf.iqWidth_PRACH + parm_size) * pXranConf->prach_conf.numPrbc; /* 12RE*2pairs/8bits (12*2/8=3)*/
- decomp_req.compMethod = compMethod;
- decomp_req.iqWidth = pXranConf->ru_conf.iqWidth_PRACH;
- decomp_req.ScaleFactor = 0; /* TODO */
- decomp_req.reMask = 0xfff; /* TODO */
-
- decomp_rsp.data_out = (int16_t *)pos;
- decomp_rsp.len = 0;
-
- xranlib_decompress(&decomp_req, &decomp_rsp);
+ else
+ printf("(%d : %d : %d) flowid %d, p_sec_desc is empty\n", target_tti, sym_id, ant_id,flowId);
}
}
-
- p_iq->prach_log_buffer_position[flowId] += prach_len;
-
- if(p_iq->prach_log_buffer_position[flowId] >= p_iq->prach_log_buffer_size[flowId])
- p_iq->prach_log_buffer_position[flowId] = 0;
- } /* if(p_iq->p_prach_log_buffer[flowId]) */
- } /* for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) */
- } /* for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) */
-
- /* SRS RX for O-DU only */
- if(p_o_xu_cfg->appMode == APP_O_DU && p_o_xu_cfg->enableSrs) {
- for(ant_id = 0; ant_id < xran_max_ant_array_elm_nr; ant_id++) {
- int32_t idxElm = 0;
- struct xran_prb_map *pRbMap = NULL;
- struct xran_prb_elm *pRbElm = NULL;
- struct xran_section_desc *p_sec_desc = NULL;
- pRbMap = (struct xran_prb_map *) psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
- if(pRbMap == NULL) {
- printf("pRbMap == NULL\n");
- exit(-1);
}
- flowId = p_o_xu_cfg->antElmTRx*cc_id + ant_id;
- if(p_iq->p_srs_log_buffer[flowId]) {
- for(sym_id = 0; sym_id < XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT; sym_id++) {
- pRbElm = &pRbMap->prbMap[0];
- /*if(pRbMap->nPrbElm == 1) {
+ else
+ {
+ for(idxSection = 0; idxSection < pRbMap->nPrbElm; idxSection++ ) {
+ pRbElmRx = &pRbMap->prbMap[idxSection];
+ for (idxDesc = 0; idxDesc < XRAN_MAX_FRAGMENT; idxDesc++) {
+ p_sec_desc = &pRbElmRx->sec_desc[sym_id][idxDesc];
+ if(p_iq->p_rx_log_buffer[flowId] && p_sec_desc){
+ if(!p_sec_desc->pCtrl)
+ continue;
+ for(idxElm = idxSection; idxElm < pRbMap->nPrbElm; idxElm++ )
+ {
+ pRbElm = &pRbMap->prbMap[idxElm];
if(sym_id >= pRbElm->nStartSymb && sym_id < pRbElm->nStartSymb + pRbElm->numSymb) {
- pos = ((char*)p_iq->p_srs_log_buffer[flowId]) + p_iq->srs_log_buffer_position[flowId];
- ptr = psIoCtrl->sFHSrsRxBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers[sym_id].pData;
- if(ptr){
- int32_t payload_len = 0;
- u32dptr = (uint32_t*)(ptr);
+ pos = ((char*)p_iq->p_rx_log_buffer[flowId]) + rx_log_buffer_position;
+ ptr = p_sec_desc->pData;
+ src = (char *)ptr;
+ data_hdr = (struct data_section_hdr *)src;
+ num_prbu = p_sec_desc->num_prbu;
+ start_prbu = p_sec_desc->start_prbu;
+ prb_idx = start_prbu;
+ while(prb_idx < (pRbElm->UP_nRBStart + pRbElm->UP_nRBSize) && num_prbu != 0){
+ // while(prb_idx < (pRbElm->nRBStart + pRbElm->nRBSize) && num_prbu != 0){
+ if(src){
+ u32dptr = (uint32_t*)(src);
if (pRbElm->compMethod != XRAN_COMPMETHOD_NONE){
struct xranlib_decompress_request bfp_decom_req;
struct xranlib_decompress_response bfp_decom_rsp;
- int32_t parm_size;
+ int32_t parm_size = 0;
memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
}
bfp_decom_req.data_in = (int8_t *)u32dptr;
- bfp_decom_req.numRBs = pRbElm->nRBSize;
- bfp_decom_req.len = (3* pRbElm->iqWidth + parm_size)*pRbElm->nRBSize;
+ bfp_decom_req.numRBs = num_prbu;
+ bfp_decom_req.len = (3 * pRbElm->iqWidth + parm_size)*num_prbu;
bfp_decom_req.compMethod = pRbElm->compMethod;
bfp_decom_req.iqWidth = pRbElm->iqWidth;
+ bfp_decom_req.reMask = pRbElm->reMask;
+ bfp_decom_req.ScaleFactor= pRbElm->ScaleFactor;
- bfp_decom_rsp.data_out = (int16_t *)(pos + pRbElm->nRBStart*N_SC_PER_PRB*4);
+ bfp_decom_rsp.data_out = (int16_t *)(pos + start_prbu*N_SC_PER_PRB*4);
bfp_decom_rsp.len = 0;
xranlib_decompress(&bfp_decom_req, &bfp_decom_rsp);
- payload_len = bfp_decom_rsp.len;
+ src += (3 * pRbElm->iqWidth + parm_size)*num_prbu;
} else {
- u32dptr = (uint32_t*)(ptr);
- memcpy(pos + pRbElm->nRBStart*N_SC_PER_PRB*4L , u32dptr, pRbElm->nRBSize*N_SC_PER_PRB*4L);
+ memcpy(pos + start_prbu*N_SC_PER_PRB*4 , u32dptr, num_prbu*N_SC_PER_PRB*4);
+ src += num_prbu*N_SC_PER_PRB*4;
+ }
+ }
+ else {
+ // printf("%s:%d [%d][%d][%d][%d]src ==NULL\n", __FUNCTION__, __LINE__, tti,cc_id,ant_id, sym_id);
+ }
+ data_hdr = (struct data_section_hdr *)src;
+ if(pRbElm->bf_weight.extType == 1 && data_hdr != NULL)
+ {
+ data_hdr->fields.all_bits = rte_be_to_cpu_32(data_hdr->fields.all_bits);
+ num_prbu = data_hdr->fields.num_prbu;
+ start_prbu = data_hdr->fields.start_prbu;
+ prb_idx += num_prbu;
+ src += data_size;
+ if (pRbElm->compMethod != XRAN_COMPMETHOD_NONE && pXranConf->ru_conf.xranCompHdrType == XRAN_COMP_HDR_TYPE_DYNAMIC)
+ src += compr_size;
+ }
+ else
+ break;
+ }
+ // break;
+ }
+ }
+ }
+ else
+ printf("(%d : %d : %d) flowid %d, p_sec_desc is empty\n", target_tti, sym_id, ant_id,flowId);
+ }
+ }
+ }
+ return status;
+}
+
+
+
+int32_t
+app_io_xran_iq_content_get(uint32_t o_xu_id, RuntimeConfig *p_o_xu_cfg)
+{
+ struct bbu_xran_io_if *psBbuIo = app_io_xran_if_get();
+ struct xran_io_shared_ctrl *psIoCtrl = app_io_xran_if_ctrl_get(o_xu_id);
+ xran_status_t status;
+ int32_t nSectorIndex[XRAN_MAX_SECTOR_NR];
+ int32_t nSectorNum;
+ int32_t cc_id, ant_id, sym_id, tti;
+ int32_t flowId;
+ struct xran_fh_config *pXranConf = &app_io_xran_fh_config[o_xu_id];
+ char *pos = NULL;
+
+ uint32_t xran_max_antenna_nr = RTE_MAX(p_o_xu_cfg->numAxc, p_o_xu_cfg->numUlAxc);
+ uint32_t xran_max_ant_array_elm_nr = RTE_MAX(p_o_xu_cfg->antElmTRx, xran_max_antenna_nr);
+ uint32_t xran_max_antenna_nr_prach = RTE_MIN(xran_max_antenna_nr, XRAN_MAX_PRACH_ANT_NUM);
+
+ struct o_xu_buffers *p_iq = NULL;
+
+ if(psBbuIo == NULL)
+ rte_panic("psBbuIo == NULL\n");
+
+ if(psIoCtrl == NULL)
+ rte_panic("psIoCtrl == NULL\n");
+
+ for (nSectorNum = 0; nSectorNum < XRAN_MAX_SECTOR_NR; nSectorNum++) {
+ nSectorIndex[nSectorNum] = nSectorNum;
}
+
+ nSectorNum = p_o_xu_cfg->numCC;
+ printf ("app_io_xran_iq_content_get\n");
+
+ if(p_o_xu_cfg->p_buff) {
+ p_iq = p_o_xu_cfg->p_buff;
}else {
- printf("[%d][%d][%d][%d]ptr ==NULL\n",tti,cc_id,ant_id, sym_id);
+ printf("Error p_o_xu_cfg->p_buff\n");
+ exit(-1);
}
+
+ if(p_o_xu_cfg->p_buff) {
+ p_iq = p_o_xu_cfg->p_buff;
+ } else {
+ rte_panic("Error p_o_xu_cfg->p_buff\n");
}
- } else*/ {
+
+ if(psBbuIo->bbu_offload == 0) {
+ for(cc_id = 0; cc_id <nSectorNum; cc_id++) {
+ for(tti = 0; tti < XRAN_N_FE_BUF_LEN; tti++) {
+ for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) {
+ if(p_o_xu_cfg->appMode == APP_O_RU)
+ flowId = p_o_xu_cfg->numAxc * cc_id + ant_id;
+ else
+ flowId = p_o_xu_cfg->numUlAxc * cc_id + ant_id;
+
+ for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) {
+ if ((status = app_io_xran_iq_content_get_up_rx(p_o_xu_cfg->appMode, pXranConf,
+ psBbuIo, psIoCtrl, p_iq,
+ cc_id, ant_id, sym_id, tti, flowId)) != 0) {
+ rte_panic("app_io_xran_iq_content_get_up_rx");
+ }
+ }
+ if(p_o_xu_cfg->appMode == APP_O_DU && p_o_xu_cfg->enablePrach && (ant_id < xran_max_antenna_nr_prach)) {
+ flowId = xran_max_antenna_nr_prach * cc_id + ant_id;
+ for(sym_id = 0; sym_id < XRAN_NUM_OF_SYMBOL_PER_SLOT; sym_id++) {
+ if ((status = app_io_xran_iq_content_get_up_prach(p_o_xu_cfg->appMode, pXranConf,
+ psBbuIo, psIoCtrl, p_iq,
+ cc_id, ant_id, sym_id, tti, flowId)) != 0) {
+ rte_panic("app_io_xran_iq_content_get_up_prach");
+ }
+ }
+ }
+ } /* for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) */
+
+ /* SRS RX for O-DU only */
+ if(p_o_xu_cfg->appMode == APP_O_DU && p_o_xu_cfg->enableSrs) {
+ for(ant_id = 0; ant_id < xran_max_ant_array_elm_nr; ant_id++) {
+ flowId = p_o_xu_cfg->antElmTRx*cc_id + ant_id;
+ for(sym_id = 0; sym_id < XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT; sym_id++) {
+ if ((status = app_io_xran_iq_content_get_up_srs(p_o_xu_cfg->appMode, pXranConf,
+ psBbuIo, psIoCtrl, p_iq,
+ cc_id, ant_id, sym_id, tti, flowId)) != 0) {
+ rte_panic("app_io_xran_iq_content_get_up_srs");
+ }
+ }
+ }
+ }
+
+ /* CP - DL for O-RU only */
+ if(p_o_xu_cfg->appMode == APP_O_RU && p_o_xu_cfg->xranCat == 1 && p_o_xu_cfg->extType == 1) {
+ for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) {
+ uint16_t idxElm = 0;
+ int i = 0, len;
+ uint8_t *src_buf;
+ char *src = NULL;
+ struct xran_prb_map *pRbMap = NULL;
+ struct xran_prb_elm *pRbElm = NULL;
+ int8_t *iq_data = NULL;
+ uint16_t N = pXranConf->nAntElmTRx;
+ uint8_t parm_size;
+ int32_t tti_dst = tti % p_iq->numSlots ;
+ int32_t tx_dl_bfw_buffer_position = tti_dst * (pXranConf->nDLRBs*pXranConf->nAntElmTRx)*4;
+ uint16_t iq_size;
+ struct xran_cp_radioapp_section_ext1 * ext1;
+ uint8_t bfwIqWidth;
+ uint8_t total_ext1_len = 0;
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFHCpRxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
+ if(pRbMap == NULL) {
+ printf("pRbMap == NULL\n");
+ exit(-1);
+ }
+ flowId = p_o_xu_cfg->numAxc * cc_id + ant_id;
+ pos = (char*)p_iq->p_tx_dl_bfw_log_buffer[flowId] + tx_dl_bfw_buffer_position;
for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++ ) {
pRbElm = &pRbMap->prbMap[idxElm];
- p_sec_desc = pRbElm->p_sec_desc[sym_id][0];
- if(p_iq->p_srs_log_buffer[flowId] && p_sec_desc) {
- if(sym_id >= pRbElm->nStartSymb && sym_id < pRbElm->nStartSymb + pRbElm->numSymb) {
- pos = ((char*)p_iq->p_srs_log_buffer[flowId]) + p_iq->srs_log_buffer_position[flowId];
- ptr = p_sec_desc->pData;
- if(ptr) {
- int32_t payload_len = 0;
- u32dptr = (uint32_t*)(ptr);
- if (pRbElm->compMethod != XRAN_COMPMETHOD_NONE) {
- struct xranlib_decompress_request bfp_decom_req;
- struct xranlib_decompress_response bfp_decom_rsp;
- int32_t parm_size;
-
- memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
- memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
- switch(pRbElm->compMethod) {
- case XRAN_COMPMETHOD_BLKFLOAT:
+ bfwIqWidth = pRbElm->bf_weight.bfwIqWidth;
+ if(p_iq->p_tx_dl_bfw_log_buffer[flowId]) {
+ src = (char *)pRbElm->bf_weight.p_ext_section;
+ if(!pRbElm->bf_weight.p_ext_start)
+ continue;
+
+ for(i = 0; i < (pRbElm->bf_weight.numSetBFWs); i++) {
+ if(src){
+ src_buf = (uint8_t *)src;
+ ext1 = (struct xran_cp_radioapp_section_ext1 *)src_buf;
+ src_buf += sizeof(struct xran_cp_radioapp_section_ext1);
+ if(src_buf == NULL)
+ break;
+
+ iq_data = (int8_t *)(src_buf);
+ total_ext1_len = ext1->extLen * XRAN_SECTIONEXT_ALIGN;
+ if (pRbElm->bf_weight.bfwCompMeth == XRAN_COMPMETHOD_NONE){
+ iq_size = N * bfwIqWidth * 2; // total in bits
+ parm_size = iq_size>>3; // total in bytes (/8)
+ if(iq_size%8) parm_size++; // round up
+ len = parm_size;
+ memcpy(pos,iq_data,len);
+ }
+ else {
+ switch(pRbElm->bf_weight.bfwCompMeth) {
+ case XRAN_BFWCOMPMETHOD_BLKFLOAT:
parm_size = 1;
break;
- case XRAN_COMPMETHOD_MODULATION:
- parm_size = 0;
+
+ case XRAN_BFWCOMPMETHOD_BLKSCALE:
+ parm_size = 1;
+ break;
+
+ case XRAN_BFWCOMPMETHOD_ULAW:
+ parm_size = 1;
+ break;
+
+ case XRAN_BFWCOMPMETHOD_BEAMSPACE:
+ parm_size = N>>3; if(N%8) parm_size++; parm_size *= 8;
break;
+
default:
parm_size = 0;
}
+ len = parm_size;
+ /* Get BF weights */
+ iq_size = N * bfwIqWidth * 2; // total in bits
+ parm_size = iq_size>>3; // total in bytes (/8)
+ if(iq_size%8) parm_size++; // round up
+ len += parm_size;
+ struct xranlib_decompress_request bfp_decom_req;
+ struct xranlib_decompress_response bfp_decom_rsp;
- bfp_decom_req.data_in = (int8_t *)u32dptr;
- bfp_decom_req.numRBs = pRbElm->nRBSize;
- bfp_decom_req.len = (3 * pRbElm->iqWidth + parm_size)*pRbElm->nRBSize;
- bfp_decom_req.compMethod = pRbElm->compMethod;
- bfp_decom_req.iqWidth = pRbElm->iqWidth;
-
- bfp_decom_rsp.data_out = (int16_t *)(pos + pRbElm->nRBStart*N_SC_PER_PRB*4);
- bfp_decom_rsp.len = 0;
+ memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
+ memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
- xranlib_decompress(&bfp_decom_req, &bfp_decom_rsp);
- payload_len = bfp_decom_rsp.len;
+ bfp_decom_req.data_in = (int8_t*)iq_data;
+ bfp_decom_req.numRBs = 1;
+ bfp_decom_req.numDataElements = N*2;
+ bfp_decom_req.len = len;
+ bfp_decom_req.compMethod = pRbElm->bf_weight.bfwCompMeth;
+ bfp_decom_req.iqWidth = bfwIqWidth;
- } else {
- memcpy(pos + pRbElm->nRBStart*N_SC_PER_PRB*4 , u32dptr, pRbElm->nRBSize*N_SC_PER_PRB*4);
+ bfp_decom_rsp.data_out = (int16_t *)(pos);
+ bfp_decom_rsp.len = 0;
+ xranlib_decompress_bfw(&bfp_decom_req, &bfp_decom_rsp);
}
+ pos += N*4;
}
+ src += (total_ext1_len + sizeof(struct xran_cp_radioapp_section1));
}
- } else {
- printf("(%d : %d : %d) flowid %d, p_sec_desc is empty\n", tti, sym_id, ant_id,flowId);
}
}
- }
- p_iq->srs_log_buffer_position[flowId] += pXranConf->nULRBs*N_SC_PER_PRB*4;
- if(p_iq->srs_log_buffer_position[flowId] >= p_iq->srs_log_buffer_size[flowId])
- p_iq->srs_log_buffer_position[flowId] = 0;
+ } /* for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) */
+ } /* if(p_o_xu_cfg->appMode == APP_O_RU) */
+
+
+ /* CP - UL for O-RU only */
+ if(p_o_xu_cfg->appMode == APP_O_RU && p_o_xu_cfg->xranCat == 1 && p_o_xu_cfg->extType == 1) {
+ for(ant_id = 0; ant_id < p_o_xu_cfg->numUlAxc; ant_id++) {
+ uint16_t idxElm = 0;
+ int i = 0, len;
+ uint8_t *src_buf;
+ char *src = NULL;
+ struct xran_prb_map *pRbMap = NULL;
+ struct xran_prb_elm *pRbElm = NULL;
+ int8_t *iq_data = NULL;
+ uint16_t N = pXranConf->nAntElmTRx;
+ uint8_t parm_size;
+ uint16_t iq_size;
+ struct xran_cp_radioapp_section_ext1 * ext1;
+ uint8_t bfwIqWidth;
+ uint8_t total_ext1_len = 0;
+ int32_t tti_dst = tti % p_iq->numSlots;
+ int32_t tx_ul_bfw_buffer_position = tti_dst * (pXranConf->nULRBs*pXranConf->nAntElmTRx)*4;
+ pRbMap = (struct xran_prb_map *) psIoCtrl->sFHCpTxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
+ if(pRbMap == NULL) {
+ printf("pRbMap == NULL\n");
+ exit(-1);
+ }
+ flowId = p_o_xu_cfg->numUlAxc * cc_id + ant_id;
+ pos = ((char*)p_iq->p_tx_ul_bfw_log_buffer[flowId]) + tx_ul_bfw_buffer_position;
+ for(idxElm = 0; idxElm < pRbMap->nPrbElm; idxElm++ ) {
+ pRbElm = &pRbMap->prbMap[idxElm];
+ bfwIqWidth = pRbElm->bf_weight.bfwIqWidth;
+ if(p_iq->p_tx_ul_bfw_log_buffer[flowId]) {
+ src = (char *)pRbElm->bf_weight.p_ext_section;
+ if(!pRbElm->bf_weight.p_ext_start)
+ continue;
+
+ for(i = 0; i < (pRbElm->bf_weight.numSetBFWs); i++) {
+ if(src){
+ src_buf = (uint8_t *)src;
+ ext1 = (struct xran_cp_radioapp_section_ext1 *)src_buf;
+ src_buf += sizeof(struct xran_cp_radioapp_section_ext1);
+ if(src_buf == NULL)
+ break;
+
+ iq_data = (int8_t *)(src_buf);
+ total_ext1_len = ext1->extLen * XRAN_SECTIONEXT_ALIGN;
+ if (pRbElm->bf_weight.bfwCompMeth == XRAN_COMPMETHOD_NONE){
+ iq_size = N * bfwIqWidth * 2; // total in bits
+ parm_size = iq_size>>3; // total in bytes (/8)
+ if(iq_size%8) parm_size++; // round up
+ len = parm_size;
+ memcpy(pos,iq_data,len);
}
+ else {
+ switch(pRbElm->bf_weight.bfwCompMeth) {
+ case XRAN_BFWCOMPMETHOD_BLKFLOAT:
+ parm_size = 1;
+ break;
+
+ case XRAN_BFWCOMPMETHOD_BLKSCALE:
+ parm_size = 1;
+ break;
+
+ case XRAN_BFWCOMPMETHOD_ULAW:
+ parm_size = 1;
+ break;
+
+ case XRAN_BFWCOMPMETHOD_BEAMSPACE:
+ parm_size = N>>3; if(N%8) parm_size++; parm_size *= 8;
+ break;
+
+ default:
+ parm_size = 0;
}
+ len = parm_size;
+ /* Get BF weights */
+ iq_size = N * bfwIqWidth * 2; // total in bits
+ parm_size = iq_size>>3; // total in bytes (/8)
+ if(iq_size%8) parm_size++; // round up
+ len += parm_size;
+ struct xranlib_decompress_request bfp_decom_req;
+ struct xranlib_decompress_response bfp_decom_rsp;
+
+ memset(&bfp_decom_req, 0, sizeof(struct xranlib_decompress_request));
+ memset(&bfp_decom_rsp, 0, sizeof(struct xranlib_decompress_response));
+
+ bfp_decom_req.data_in = (int8_t*)iq_data;
+ bfp_decom_req.numRBs = 1;
+ bfp_decom_req.numDataElements = N*2;
+ bfp_decom_req.len = len;
+ bfp_decom_req.compMethod = pRbElm->bf_weight.bfwCompMeth;
+ bfp_decom_req.iqWidth = bfwIqWidth;
+
+ bfp_decom_rsp.data_out = (int16_t *)(pos);
+ bfp_decom_rsp.len = 0;
+ xranlib_decompress_bfw(&bfp_decom_req, &bfp_decom_rsp);
}
+ pos += N*4;
}
+ src += (total_ext1_len + sizeof(struct xran_cp_radioapp_section1));
}
}
-
+ }
+ } /* for(ant_id = 0; ant_id < xran_max_antenna_nr; ant_id++) */
+ } /* if(p_o_xu_cfg->appMode == APP_O_RU) */
+ } /*for(tti = 0; tti < XRAN_N_FE_BUF_LEN; tti++)*/
+ } /*for(cc_id = 0; cc_id <nSectorNum; cc_id++)*/
+ }
return 0;
}
p_xran_fh_cfg->prach_conf.nPrachFreqStart = 0;
p_xran_fh_cfg->prach_conf.nPrachFilterIdx = XRAN_FILTERINDEX_PRACH_ABC;
p_xran_fh_cfg->prach_conf.nPrachConfIdx = p_o_xu_cfg->prachConfigIndex;
+ p_xran_fh_cfg->prach_conf.nPrachConfIdxLTE = p_o_xu_cfg->prachConfigIndexLTE; //will be used in case of dss only
p_xran_fh_cfg->prach_conf.nPrachFreqOffset = -792;
- p_xran_fh_cfg->srs_conf.symbMask = p_o_xu_cfg->srsSymMask;
+ p_xran_fh_cfg->srs_conf.symbMask = p_o_xu_cfg->srsSymMask; // deprecated
+
+ if(p_o_xu_cfg->numAxc > XRAN_MAX_PRACH_ANT_NUM)
+ p_xran_fh_cfg->srs_conf.eAxC_offset = p_o_xu_cfg->numAxc + XRAN_MAX_PRACH_ANT_NUM; /* PUSCH, PRACH, SRS */
+ else
p_xran_fh_cfg->srs_conf.eAxC_offset = 2 * p_o_xu_cfg->numAxc; /* PUSCH, PRACH, SRS */
+ p_xran_fh_cfg->srs_conf.slot = p_o_xu_cfg->srsSlot;
+ p_xran_fh_cfg->srs_conf.ndm_offset = p_o_xu_cfg->srsNdmOffset;
+ p_xran_fh_cfg->srs_conf.ndm_txduration = p_o_xu_cfg->srsNdmTxDuration;
p_xran_fh_cfg->ru_conf.xranTech = p_o_xu_cfg->xranTech;
p_xran_fh_cfg->ru_conf.xranCompHdrType = p_o_xu_cfg->CompHdrType;
p_xran_fh_cfg->ru_conf.xranCat = p_o_xu_cfg->xranCat;
+
+ if (p_xran_fh_cfg->ru_conf.xranCat == XRAN_CATEGORY_A)
+ p_xran_fh_cfg->neAxcUl = p_xran_fh_cfg->neAxc;
+
p_xran_fh_cfg->ru_conf.iqWidth = p_o_xu_cfg->p_PrbMapDl->prbMap[0].iqWidth;
if (p_o_xu_cfg->compression == 0)
if (p_o_xu_cfg->prachCompMethod == 0)
p_o_xu_cfg->prachiqWidth = 16;
p_xran_fh_cfg->ru_conf.iqWidth_PRACH = p_o_xu_cfg->prachiqWidth;
-
p_xran_fh_cfg->ru_conf.fftSize = 0;
while (p_o_xu_cfg->nULFftSize >>= 1)
p_xran_fh_cfg->max_sections_per_slot = RTE_MAX(p_o_xu_cfg->max_sections_per_slot, XRAN_MIN_SECTIONS_PER_SLOT);
p_xran_fh_cfg->max_sections_per_symbol = RTE_MAX(p_o_xu_cfg->max_sections_per_symbol, XRAN_MIN_SECTIONS_PER_SLOT);
+ p_xran_fh_cfg->RunSlotPrbMapBySymbolEnable = p_o_xu_cfg->RunSlotPrbMapBySymbolEnable;
printf("Max Sections: %d per symb %d per slot\n", p_xran_fh_cfg->max_sections_per_slot, p_xran_fh_cfg->max_sections_per_symbol);
if(p_o_xu_cfg->maxFrameId)
p_xran_fh_cfg->cp_vlan_tag = p_o_xu_cfg->cp_vlan_tag;
p_xran_fh_cfg->up_vlan_tag = p_o_xu_cfg->up_vlan_tag;
+ p_xran_fh_cfg->dssEnable = p_o_xu_cfg->dssEnable;
+ p_xran_fh_cfg->dssPeriod = p_o_xu_cfg->dssPeriod;
+ for(i=0; i<p_o_xu_cfg->dssPeriod; i++) {
+ p_xran_fh_cfg->technology[i] = p_o_xu_cfg->technology[i];
+ }
+
return ret;
}
p_xran_fh_init->io_cfg.eowd_cmn[APP_O_DU].measId = p_use_cfg->owdmMeasId;
p_xran_fh_init->io_cfg.eowd_cmn[APP_O_DU].owdm_enable = p_use_cfg->owdmEnable;
p_xran_fh_init->io_cfg.eowd_cmn[APP_O_DU].owdm_PlLength = p_use_cfg->owdmPlLength;
+ p_xran_fh_init->dlCpProcBurst = p_use_cfg->dlCpProcBurst;
} else {
printf("set O-RU\n");
p_xran_fh_init->io_cfg.eowd_cmn[APP_O_RU].owdm_PlLength = p_use_cfg->owdmPlLength;
}
+ if(p_use_cfg->bbu_offload) {
+ if (p_xran_fh_init->io_cfg.id == 0) { /* O-DU */
+ p_xran_fh_init->io_cfg.bbu_offload = 1;
+ p_xran_fh_init->dlCpProcBurst = 1;
+ } else {
+ p_xran_fh_init->io_cfg.bbu_offload = 0;
+ }
+ } else {
+ p_xran_fh_init->io_cfg.bbu_offload = 0;
+ }
+
+ if (p_xran_fh_init->io_cfg.bbu_offload == 0 && XRAN_N_FE_BUF_LEN < 20)
+ rte_panic("Sample application with out BBU requires XRAN_N_FE_BUF_LEN to be at least 20 TTIs\n");
+
p_xran_fh_init->io_cfg.io_sleep = p_use_cfg->io_sleep;
p_xran_fh_init->io_cfg.dpdkMemorySize = p_use_cfg->dpdk_mem_sz;
p_xran_fh_init->io_cfg.bbdev_mode = XRAN_BBDEV_NOT_USED;
p_xran_fh_init->io_cfg.nEthLinePerPort = p_use_cfg->EthLinesNumber;
p_xran_fh_init->io_cfg.nEthLineSpeed = p_use_cfg->EthLinkSpeed;
+ if(p_use_cfg->mlogxrandisable == 1)
+ p_xran_fh_init->mlogxranenable = 0;
+ else
+ p_xran_fh_init->mlogxranenable = 1;
+
app_io_xran_eAxCid_conf_set(&p_xran_fh_init->eAxCId_conf, p_o_xu_cfg);
i = 0;
printf("nSW_ToFpga_FTH_TxBufferLen %d\n", nSW_ToFpga_FTH_TxBufferLen);
return 0;
}
+
+int32_t
+app_io_xran_map_cellid_to_port(struct bbu_xran_io_if * p_xran_io, uint32_t cell_id, uint32_t *ret_cc_id)
+{
+ int32_t port_id;
+ int32_t cc_id;
+
+ if(p_xran_io) {
+ if(cell_id < XRAN_PORTS_NUM*XRAN_MAX_SECTOR_NR) {
+ for (port_id = 0 ; port_id < XRAN_PORTS_NUM && port_id < p_xran_io->num_o_ru; port_id++) {
+ for(cc_id = 0; cc_id < XRAN_MAX_SECTOR_NR && cc_id < p_xran_io->num_cc_per_port[port_id]; cc_id++)
+ if(cell_id == (uint32_t)p_xran_io->map_cell_id2port[port_id][cc_id]) {
+ if(ret_cc_id) {
+ *ret_cc_id = cc_id;
+ return port_id;
+ }
+ }
+ }
+ }
+ }
+
+ printf("%s error [cell_id %d]\n", __FUNCTION__, cell_id);
+ return -1;
+}
+
+#ifndef FWK_ENABLED
+void
+app_io_xran_fh_bbu_rx_callback(void *pCallbackTag, xran_status_t status)
+{
+ app_io_xran_fh_rx_callback(pCallbackTag, status);
+}
+
+void
+app_io_xran_fh_bbu_rx_bfw_callback(void *pCallbackTag, xran_status_t status)
+{
+ app_io_xran_fh_rx_bfw_callback(pCallbackTag, status);
+}
+
+void
+app_io_xran_fh_bbu_rx_prach_callback(void *pCallbackTag, xran_status_t status)
+{
+ app_io_xran_fh_rx_prach_callback(pCallbackTag, status);
+}
+
+void
+app_io_xran_fh_bbu_rx_srs_callback(void *pCallbackTag, xran_status_t status)
+{
+ app_io_xran_fh_rx_srs_callback(pCallbackTag, status);
+}
+#endif
Code Review / o-du / phy.git / blobdiff