X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?p=o-du%2Fphy.git;a=blobdiff_plain;f=fhi_lib%2Fapp%2Fsrc%2Fconfig.c;fp=fhi_lib%2Fapp%2Fsrc%2Fconfig.c;h=71406d0ad4c0f3a9fc122793db6c8387902cdb30;hp=deec5a1458ffccf89ef76007a364a9c802fd96bc;hb=2de97529a4c5a1922214ba0e6f0fb84cacbd0bc7;hpb=81a09690b36b3a4e89b4dae34f30933de13f7f90 diff --git a/fhi_lib/app/src/config.c b/fhi_lib/app/src/config.c index deec5a1..71406d0 100644 --- a/fhi_lib/app/src/config.c +++ b/fhi_lib/app/src/config.c @@ -23,6 +23,8 @@ * @author Intel Corporation **/ +#include +#include #include "rte_common.h" #include "config.h" #include "common.h" @@ -54,6 +56,20 @@ #define KEY_SSLOTCONFIG "sSlotConfig" +#define KEY_XU_NUM "oXuNum" +#define KEY_XU_ETH_LINK_SPD "oXuEthLinkSpeed" +#define KEY_XU_ETH_LINE_NUM "oXuLinesNumber" +#define KEY_XU_CP_ON_ONE_VF "oXuCPon1Vf" +#define KEY_XU_RXQ_VF "oXuRxqNumber" +#define KEY_OWDM_INIT_EN "oXuOwdmInitEn" +#define KEY_OWDM_MEAS_METH "oXuOwdmMeasMeth" +#define KEY_OWDM_NUM_SAMPS "oXuOwdmNumSamps" +#define KEY_OWDM_FLTR_TYPE "oXuOwdmFltrType" +#define KEY_OWDM_RSP_TO "oXuOwdmRespTimeOut" +#define KEY_OWDM_MEAS_ST "oXuOwdmMeasState" +#define KEY_OWDM_MEAS_ID "oXuOwdmMeasId" +#define KEY_OWDM_EN "oXuOwdmEnabled" +#define KEY_OWDM_PL_LENGTH "oXuOwdmPlLength" #define KEY_CC_PER_PORT_NUM "ccNum" #define KEY_ANT_NUM "antNum" #define KEY_UL_ANT_NUM "antNumUL" @@ -66,17 +82,24 @@ #define KEY_FILE_DLBFWUE "DlBfwUe" #define KEY_FILE_ULBFWUE "UlBfwUe" +#define KEY_FILE_O_XU_CFG "oXuCfgFile" +#define KEY_O_XU_PCIE_BUS "PciBusAddoXu" +#define KEY_O_XU_REM_MAC "oXuRem" + #define KEY_FILE_ULSRS "antSrsC" #define KEY_TTI_PERIOD "ttiPeriod" #define KEY_MTU_SIZE "MTUSize" +#define KEY_MAIN_CORE "mainCore" #define KEY_IO_CORE "ioCore" #define KEY_IO_WORKER "ioWorker" +#define KEY_IO_WORKER_64_127 "ioWorker_64_127" #define KEY_IO_SLEEP "ioSleep" #define KEY_SYSTEM_CORE "systemCore" #define KEY_IOVA_MODE "iovaMode" +#define KEY_DPDK_MEM_SZ "dpdkMemorySize" #define KEY_INSTANCE_ID "instanceId" @@ -87,8 +110,13 @@ #define KEY_FILE_AxC "antC" #define KEY_FILE_PRACH_AxC "antPrachC" +#define KEY_FILE_SLOT_TX "SlotNumTx" +#define KEY_FILE_SLOT_RX "SlotNumRx" + #define KEY_PRACH_ENABLE "rachEanble" #define KEY_SRS_ENABLE "srsEanble" +#define KEY_PUSCH_MASK_ENABLE "puschMaskEnable" +#define KEY_PUSCH_MASK_SLOT "puschMaskSlot" #define KEY_PRACH_CFGIDX "prachConfigIndex" #define KEY_SRS_SYM_IDX "srsSym" @@ -100,6 +128,8 @@ #define KEY_HTONS_SWAP "nebyteorderswap" #define KEY_COMPRESSION "compression" #define KEY_COMP_TYPE "compType" +#define KEY_PRACH_COMPMETH "prachCompMethod" +#define KEY_PRACH_IQ "prachiqWidth" #define KEY_BFW_NUM "totalBFWeights" @@ -135,10 +165,27 @@ #define KEY_NPRBELEM_DL "nPrbElemDl" #define KEY_PRBELEM_DL "PrbElemDl" +#define KEY_PRBELEM_DL_CC_M "PrbElemDlCCMask" +#define KEY_PRBELEM_DL_ANT_M "PrbElemDlAntCMask" +#define KEY_EXTBFW_DL "ExtBfwDl" #define KEY_NPRBELEM_UL "nPrbElemUl" #define KEY_PRBELEM_UL "PrbElemUl" +#define KEY_PRBELEM_UL_CC_M "PrbElemUlCCMask" +#define KEY_PRBELEM_UL_ANT_M "PrbElemUlAntCMask" +#define KEY_EXTBFW_UL "ExtBfwUl" +#define KEY_NPRBELEM_SRS "nPrbElemSrs" +#define KEY_PRBELEM_SRS "PrbElemSrs" +#define KEY_MAX_SEC_SYM "max_sections_per_symbol" +#define KEY_MAX_SEC_SLOT "max_sections_per_slot" + +typedef int (*fillConfigStruct_fn)(void* cbPram, const char *key, const char *value); +struct slot_cfg_to_pars { + RuntimeConfig *config; + int32_t direction; + int32_t slot_idx; +}; /** * Set runtime configuration parameters to their defaults. @@ -150,6 +197,9 @@ static void init_config(RuntimeConfig* config) memset(config , 0, sizeof(RuntimeConfig)); } +static int32_t +parseFileViaCb (char *filename, fillConfigStruct_fn cbFn, void* cbParm); + /** - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - **/ static void trim(char* input) @@ -160,10 +210,13 @@ static void trim(char* input) input[i] = '\0'; } + static int fillConfigStruct(RuntimeConfig *config, const char *key, const char *value) { int32_t parse_res = 0; - static unsigned int section_idx_dl = 0, section_idx_ul; + static uint32_t section_idx_dl = 0; + static uint32_t section_idx_ul = 0; + static uint32_t section_idx_srs = 0; if (strcmp(key, KEY_APP_MODE) == 0){ config->appMode = atoi(value); @@ -269,6 +322,10 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * config->compression = atoi(value); } else if (strcmp(key, KEY_COMP_TYPE) == 0) { config->CompHdrType = atoi(value); + } else if (strcmp(key, KEY_PRACH_COMPMETH) == 0) { + config->prachCompMethod = atoi(value); + } else if (strcmp(key, KEY_PRACH_IQ) == 0) { + config->prachiqWidth = atoi(value); } else if (strcmp(key, KEY_MTU_SIZE) == 0) { config->mtu = atoi(value); printf("mtu %d\n", config->mtu); @@ -278,9 +335,15 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * } else if (strcmp(key, KEY_IO_CORE) == 0) { config->io_core = atoi(value); printf("io_core %d [core id]\n", config->io_core); + } else if (strcmp(key, KEY_MAIN_CORE) == 0) { + config->io_core = atoi(value); + printf("io_core %d [core id]\n", config->io_core); } else if (strcmp(key, KEY_IO_WORKER) == 0) { config->io_worker = strtoll(value, NULL, 0); printf("io_worker 0x%lx [mask]\n", config->io_worker); + } else if (strcmp(key, KEY_IO_WORKER_64_127) == 0) { + config->io_worker_64_127 = strtoll(value, NULL, 0); + printf("io_worker_64_127 0x%lx [mask]\n", config->io_worker_64_127); } else if (strcmp(key, KEY_SYSTEM_CORE) == 0) { config->system_core = atoi(value); printf("system core %d [core id]\n", config->system_core); @@ -376,6 +439,28 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * strncpy(&config->ul_srs_file[srs_ant][0], value, strlen(value)); printf("antSrsC%d: %s\n",srs_ant, config->ul_srs_file[srs_ant]); } + } else if (strncmp(key, KEY_FILE_SLOT_TX, strlen(KEY_FILE_SLOT_TX)) == 0) { + unsigned int slot_num = 0; + unsigned int direction = XRAN_DIR_DL; + sscanf(key,"SlotNumTx%02u",&slot_num); + if (slot_num >= XRAN_N_FE_BUF_LEN) { + printf("SlotNumTx%d exceeds max slots supported\n",slot_num); + } else { + config->SlotNum_fileEnabled = 1; + strncpy(&config->SlotNum_file[direction][slot_num][0], value, strlen(value)); + printf("SlotNumTx%d: %s\n",slot_num, config->SlotNum_file[direction][slot_num]); + } + }else if (strncmp(key, KEY_FILE_SLOT_RX, strlen(KEY_FILE_SLOT_RX)) == 0) { + unsigned int slot_num = 0; + unsigned int direction = XRAN_DIR_UL; + sscanf(key,"SlotNumRx%02u",&slot_num); + if (slot_num >= XRAN_N_FE_BUF_LEN) { + printf("SlotNumRx%d exceeds max slots supported\n",slot_num); + } else { + config->SlotNum_fileEnabled = 1; + strncpy(&config->SlotNum_file[direction][slot_num][0], value, strlen(value)); + printf("SlotNumRx%d: %s\n",slot_num, config->SlotNum_file[direction][slot_num]); + } } else if (strcmp(key, KEY_PRACH_ENABLE) == 0) { config->enablePrach = atoi(value); printf("Prach enable: %d\n",config->enablePrach); @@ -384,7 +469,13 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * printf("maxFrameId: %d\n",config->maxFrameId); } else if (strcmp(key, KEY_SRS_ENABLE) == 0) { config->enableSrs = atoi(value); - printf("Srs enable: %d\n",config->enablePrach); + printf("Srs enable: %d\n",config->enableSrs); + } else if (strcmp(key, KEY_PUSCH_MASK_ENABLE) == 0) { + config->puschMaskEnable = atoi(value); + printf("PUSCH mask enable: %d\n",config->puschMaskEnable); + } else if (strcmp(key, KEY_PUSCH_MASK_SLOT) == 0) { + config->puschMaskSlot = atoi(value); + printf("PUSCH mask enable: %d\n",config->puschMaskSlot); } else if (strcmp(key, KEY_PRACH_CFGIDX) == 0) { config->prachConfigIndex = atoi(value); printf("Prach config index: %d\n",config->prachConfigIndex); @@ -485,21 +576,27 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * } else if (strcmp(key, KEY_UP_VTAG ) == 0) { config->up_vlan_tag = atoi(value); printf("up_vlan_tag: %d\n",config->up_vlan_tag); + } else if (strcmp(key, KEY_MAX_SEC_SYM ) == 0) { + config->max_sections_per_symbol = atoi(value); + printf("max_sections_per_symbol: %d\n",config->max_sections_per_symbol); + } else if (strcmp(key, KEY_MAX_SEC_SLOT ) == 0) { + config->max_sections_per_slot = atoi(value); + printf("max_sections_per_slot: %d\n",config->max_sections_per_slot); } else if (strcmp(key, KEY_NPRBELEM_UL ) == 0) { - config->PrbMapUl.nPrbElm = atoi(value); - if (config->PrbMapUl.nPrbElm > XRAN_MAX_PRBS) + config->p_PrbMapUl->nPrbElm = atoi(value); + if (config->p_PrbMapUl->nPrbElm > XRAN_MAX_SECTIONS_PER_SLOT) { printf("nTddPeriod is larger than max allowed, invalid!\n"); - config->PrbMapUl.nPrbElm = XRAN_MAX_PRBS; + config->p_PrbMapUl->nPrbElm = XRAN_MAX_SECTIONS_PER_SLOT; } - printf("nPrbElemUl: %d\n",config->PrbMapUl.nPrbElm); + printf("nPrbElemUl: %d\n",config->p_PrbMapUl->nPrbElm); } else if (strncmp(key, KEY_PRBELEM_UL, strlen(KEY_PRBELEM_UL)) == 0) { sscanf(key,"PrbElemUl%u",§ion_idx_ul); - if (section_idx_ul >= config->PrbMapUl.nPrbElm){ + if (section_idx_ul >= config->p_PrbMapUl->nPrbElm){ printf("section_idx %d exceeds nPrbElemUl\n",section_idx_ul); } else{ - struct xran_prb_elm *pPrbElem = &config->PrbMapUl.prbMap[section_idx_ul]; + struct xran_prb_elm *pPrbElem = &config->p_PrbMapUl->prbMap[section_idx_ul]; sscanf(value, "%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd", (int16_t*)&pPrbElem->nRBStart, (int16_t*)&pPrbElem->nRBSize, @@ -514,21 +611,87 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * printf("nRBStart %d,nRBSize %d,nStartSymb %d,numSymb %d,nBeamIndex %d, bf_weight_update %d compMethod %d, iqWidth %d BeamFormingType %d\n", pPrbElem->nRBStart,pPrbElem->nRBSize,pPrbElem->nStartSymb,pPrbElem->numSymb,pPrbElem->nBeamIndex, pPrbElem->bf_weight_update, pPrbElem->compMethod, pPrbElem->iqWidth, pPrbElem->BeamFormingType); } + } else if(strncmp(key, KEY_EXTBFW_UL, strlen(KEY_EXTBFW_UL)) == 0) { + sscanf(key, "ExtBfwUl%u", §ion_idx_ul); + if(section_idx_ul >= config->p_PrbMapUl->nPrbElm) { + printf("section_idx %d of bfw exceeds nPrbElemUl\n",section_idx_ul); + } + else{ + struct xran_prb_elm *pPrbElem = &config->p_PrbMapUl->prbMap[section_idx_ul]; + sscanf(value, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", + (uint8_t*)&pPrbElem->bf_weight.numBundPrb, + (uint8_t*)&pPrbElem->bf_weight.numSetBFWs, + (uint8_t*)&pPrbElem->bf_weight.RAD, + (uint8_t*)&pPrbElem->bf_weight.disableBFWs, + (uint8_t*)&pPrbElem->bf_weight.bfwIqWidth, + (uint8_t*)&pPrbElem->bf_weight.bfwCompMeth); + printf(KEY_EXTBFW_UL"%d: ", section_idx_ul); + printf("numBundPrb %d, numSetBFW %d, RAD %d, disableBFW %d, bfwIqWidth %d, bfwCompMeth %d\n", + pPrbElem->bf_weight.numBundPrb, pPrbElem->bf_weight.numSetBFWs, pPrbElem->bf_weight.RAD, pPrbElem->bf_weight.disableBFWs, pPrbElem->bf_weight.bfwIqWidth, pPrbElem->bf_weight.bfwCompMeth); + } }else if (strcmp(key, KEY_NPRBELEM_DL ) == 0) { - config->PrbMapDl.nPrbElm = atoi(value); - if (config->PrbMapDl.nPrbElm > XRAN_MAX_PRBS) + config->p_PrbMapDl->nPrbElm = atoi(value); + if (config->p_PrbMapDl->nPrbElm > XRAN_MAX_SECTIONS_PER_SLOT) { - printf("nTddPeriod is larger than max allowed, invalid!\n"); - config->PrbMapDl.nPrbElm = XRAN_MAX_PRBS; + printf("nPrbElm is larger than max allowed, invalid!\n"); + config->p_PrbMapDl->nPrbElm = XRAN_MAX_SECTIONS_PER_SLOT; } - printf("nPrbElemDl: %d\n",config->PrbMapDl.nPrbElm); + printf("nPrbElemDl: %d\n",config->p_PrbMapDl->nPrbElm); } else if (strncmp(key, KEY_PRBELEM_DL, strlen(KEY_PRBELEM_DL)) == 0) { sscanf(key,"PrbElemDl%u",§ion_idx_dl); - if (section_idx_dl >= config->PrbMapDl.nPrbElm){ + if (section_idx_dl >= config->p_PrbMapDl->nPrbElm){ printf("section_idx %d exceeds nPrbElemDl\n",section_idx_dl); } else{ - struct xran_prb_elm *pPrbElem = &config->PrbMapDl.prbMap[section_idx_dl]; + struct xran_prb_elm *pPrbElem = &config->p_PrbMapDl->prbMap[section_idx_dl]; + sscanf(value, "%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd", + (int16_t*)&pPrbElem->nRBStart, + (int16_t*)&pPrbElem->nRBSize, + (int16_t*)&pPrbElem->nStartSymb, + (int16_t*)&pPrbElem->numSymb, + (int16_t*)&pPrbElem->nBeamIndex, + (int16_t*)&pPrbElem->bf_weight_update, + (int16_t*)&pPrbElem->compMethod, + (int16_t*)&pPrbElem->iqWidth, + (int16_t*)&pPrbElem->BeamFormingType, + (int16_t*)&pPrbElem->ScaleFactor, + (int16_t*)&pPrbElem->reMask); + printf("nPrbElemDl%d: ",section_idx_dl); + printf("nRBStart %d,nRBSize %d,nStartSymb %d,numSymb %d,nBeamIndex %d, bf_weight_update %d compMethod %d, iqWidth %d BeamFormingType %d ScaleFactor %d reMask %d\n", + pPrbElem->nRBStart,pPrbElem->nRBSize,pPrbElem->nStartSymb,pPrbElem->numSymb,pPrbElem->nBeamIndex, pPrbElem->bf_weight_update, pPrbElem->compMethod, pPrbElem->iqWidth, pPrbElem->BeamFormingType, pPrbElem->ScaleFactor, pPrbElem->reMask); + } + } else if(strncmp(key, KEY_EXTBFW_DL, strlen(KEY_EXTBFW_DL)) == 0) { + sscanf(key, "ExtBfwDl%u", §ion_idx_dl); + if(section_idx_dl >= config->p_PrbMapDl->nPrbElm) { + printf("section_idx %d of bfw exceeds nPrbElemUl\n",section_idx_dl); + } + else{ + struct xran_prb_elm *pPrbElem = &config->p_PrbMapDl->prbMap[section_idx_dl]; + sscanf(value, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", + (uint8_t*)&pPrbElem->bf_weight.numBundPrb, + (uint8_t*)&pPrbElem->bf_weight.numSetBFWs, + (uint8_t*)&pPrbElem->bf_weight.RAD, + (uint8_t*)&pPrbElem->bf_weight.disableBFWs, + (uint8_t*)&pPrbElem->bf_weight.bfwIqWidth, + (uint8_t*)&pPrbElem->bf_weight.bfwCompMeth); + printf(KEY_EXTBFW_DL"%d: ", section_idx_dl); + printf("numBundPrb %d, numSetBFW %d, RAD %d, disableBFW %d, bfwIqWidth %d, bfwCompMeth %d\n", + pPrbElem->bf_weight.numBundPrb, pPrbElem->bf_weight.numSetBFWs, pPrbElem->bf_weight.RAD, pPrbElem->bf_weight.disableBFWs, pPrbElem->bf_weight.bfwIqWidth, pPrbElem->bf_weight.bfwCompMeth); + } + } else if (strcmp(key, KEY_NPRBELEM_SRS ) == 0) { + config->p_PrbMapSrs->nPrbElm = atoi(value); + if (config->p_PrbMapSrs->nPrbElm > XRAN_MAX_SECTIONS_PER_SLOT) + { + printf("nPrbElm is larger than max allowed, invalid!\n"); + config->p_PrbMapSrs->nPrbElm = XRAN_MAX_SECTIONS_PER_SLOT; + } + printf("nPrbElemSrs: %d\n",config->p_PrbMapSrs->nPrbElm); + } else if (strncmp(key, KEY_PRBELEM_SRS, strlen(KEY_PRBELEM_SRS)) == 0) { + sscanf(key,"PrbElemSrs%u",§ion_idx_srs); + if (section_idx_srs >= config->p_PrbMapSrs->nPrbElm) { + printf("section_idx %d exceeds nPrbElemSrs\n",section_idx_srs); + }else { + struct xran_prb_elm *pPrbElem = &config->p_PrbMapSrs->prbMap[section_idx_srs]; sscanf(value, "%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd", (int16_t*)&pPrbElem->nRBStart, (int16_t*)&pPrbElem->nRBSize, @@ -539,10 +702,140 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * (int16_t*)&pPrbElem->compMethod, (int16_t*)&pPrbElem->iqWidth, (int16_t*)&pPrbElem->BeamFormingType); - printf("nPrbElemDl%d: ",section_idx_dl); + printf("nPrbElemSrs%d: ",section_idx_srs); printf("nRBStart %d,nRBSize %d,nStartSymb %d,numSymb %d,nBeamIndex %d, bf_weight_update %d compMethod %d, iqWidth %d BeamFormingType %d\n", pPrbElem->nRBStart,pPrbElem->nRBSize,pPrbElem->nStartSymb,pPrbElem->numSymb,pPrbElem->nBeamIndex, pPrbElem->bf_weight_update, pPrbElem->compMethod, pPrbElem->iqWidth, pPrbElem->BeamFormingType); } + }else { + printf("Unsupported configuration key [%s]\n", key); + return -1; + } + + return 0; +} + +static int +fillUsecaseStruct(UsecaseConfig *config, const char *key, const char *value) +{ + int32_t parse_res = 0; + if (strcmp(key, KEY_APP_MODE) == 0){ + config->appMode = atoi(value); + printf("appMode %d \n", config->appMode); + } else if (strcmp(key, KEY_XU_NUM) == 0){ + config->oXuNum = atoi(value); + printf("oXuNum %d \n", config->oXuNum); + } else if (strcmp(key, KEY_XU_ETH_LINK_SPD) == 0){ + config->EthLinkSpeed = atoi(value); + printf("EthLinkSpeed %d \n", config->EthLinkSpeed); + } else if (strcmp(key, KEY_XU_ETH_LINE_NUM) == 0){ + config->EthLinesNumber = atoi(value); + printf("EthLinkSpeed %d \n", config->EthLinesNumber); + } else if (strcmp(key, KEY_XU_RXQ_VF) == 0){ + config->num_rxq = atoi(value); + printf("oXuRxqNumber %d \n", config->num_rxq); + } else if (strcmp(key, KEY_XU_CP_ON_ONE_VF) == 0) { + config->one_vf_cu_plane = atoi(value); + printf("oXuCPon1Vf %d \n", config->one_vf_cu_plane); + } else if (strcmp(key, KEY_IO_SLEEP) == 0) { + config->io_sleep = atoi(value); + printf("io_sleep %d \n", config->io_sleep); + } else if (strcmp(key, KEY_IO_CORE) == 0) { + config->io_core = atoi(value); + printf("io_core %d [core id]\n", config->io_core); + } else if (strcmp(key, KEY_MAIN_CORE) == 0) { + config->main_core = atoi(value); + printf("main_core %d [core id]\n", config->main_core); + } else if (strcmp(key, KEY_IO_WORKER) == 0) { + config->io_worker = strtoll(value, NULL, 0); + printf("io_worker 0x%lx [mask]\n", config->io_worker); + } else if (strcmp(key, KEY_IO_WORKER_64_127) == 0) { + config->io_worker_64_127 = strtoll(value, NULL, 0); + printf("io_worker_64_127 0x%lx [mask]\n", config->io_worker_64_127); + } else if (strcmp(key, KEY_SYSTEM_CORE) == 0) { + config->system_core = atoi(value); + printf("system core %d [core id]\n", config->system_core); + } else if (strcmp(key, KEY_IOVA_MODE) == 0) { + config->iova_mode = atoi(value); + printf("iova_mode %d\n", config->iova_mode); + } else if (strcmp(key, KEY_DPDK_MEM_SZ) == 0) { + config->dpdk_mem_sz = atoi(value); + printf("dpdk_mem_sz %d\n", config->dpdk_mem_sz); + } else if (strcmp(key, KEY_INSTANCE_ID) == 0) { + config->instance_id = atoi(value); + printf("instance_id %d\n", config->instance_id); + }else if (strncmp(key, KEY_FILE_O_XU_CFG, strlen(KEY_FILE_O_XU_CFG)) == 0) { + unsigned int o_xu_id = 0; + sscanf(key,"oXuCfgFile%02u",&o_xu_id); + if (o_xu_id >= XRAN_PORTS_NUM) { + printf("oXuCfgFile%d exceeds max O-XU supported\n",o_xu_id); + } else { + strncpy(&config->o_xu_cfg_file[o_xu_id][0], value, strlen(value)); + printf("oXuCfgFile%d: %s\n",o_xu_id, config->o_xu_cfg_file[o_xu_id]); + } + } else if (strncmp(key, KEY_OWDM_INIT_EN, strlen(KEY_OWDM_INIT_EN)) == 0) { + config->owdmInitEn = atoi(value); + printf("owdmInitEn %d\n", config->owdmInitEn); + } else if (strncmp(key, KEY_OWDM_MEAS_METH, strlen(KEY_OWDM_MEAS_METH)) == 0) { + config->owdmMeasMeth = atoi(value); + printf("owdmMeasMeth %d\n", config->owdmMeasMeth); + } else if (strncmp(key, KEY_OWDM_NUM_SAMPS, strlen(KEY_OWDM_NUM_SAMPS)) == 0) { + config->owdmNumSamps = atoi(value); + printf("owdmNumSamps %d\n", config->owdmNumSamps); + } else if (strncmp(key, KEY_OWDM_FLTR_TYPE, strlen(KEY_OWDM_FLTR_TYPE)) == 0) { + config->owdmFltType = atoi(value); + printf("owdmFltType %d\n", config->owdmFltType); + } else if (strncmp(key, KEY_OWDM_RSP_TO, strlen(KEY_OWDM_RSP_TO)) == 0) { + config->owdmRspTo = atol(value); + printf("owdmRspTo %lu\n", config->owdmRspTo); + } else if (strncmp(key, KEY_OWDM_MEAS_ID, strlen(KEY_OWDM_MEAS_ID)) == 0) { + config->owdmMeasId = atoi(value); + printf("owdmMeasId %d\n", config->owdmMeasId); + } else if (strncmp(key, KEY_OWDM_EN, strlen(KEY_OWDM_EN)) == 0) { + config->owdmEnable = atoi(value); + printf("owdmEnable %d\n", config->owdmEnable); + } else if (strncmp(key, KEY_OWDM_PL_LENGTH, strlen(KEY_OWDM_PL_LENGTH)) == 0) { + config->owdmPlLength = atoi(value); + printf("owdmPlLength %d\n", config->owdmPlLength); + } else if (strncmp(key, KEY_OWDM_MEAS_ST, strlen(KEY_OWDM_MEAS_ST)) == 0) { + config->owdmMeasState = atoi(value); + printf("owdmMeasState %d\n", config->owdmMeasState); + } else if (strncmp(key, KEY_O_XU_PCIE_BUS, strlen(KEY_O_XU_PCIE_BUS)) == 0) { + unsigned int o_xu_id = 0; + unsigned int vf_num = 0; + sscanf(key,"PciBusAddoXu%02uVf%02u",&o_xu_id, &vf_num); + if (o_xu_id >= XRAN_PORTS_NUM || vf_num >= XRAN_VF_MAX){ + printf("PciBusAddoXu%dVf%d exceeds max O-XU supported\n",o_xu_id, vf_num); + } else { + strncpy(&config->o_xu_pcie_bus_addr[o_xu_id][vf_num][0], value, strlen(value)); + printf("PciBusAddoXu%dVf%d: %s\n",o_xu_id, vf_num, &config->o_xu_pcie_bus_addr[o_xu_id][vf_num][0]); + } + } else if (strncmp(key, KEY_O_XU_REM_MAC, strlen(KEY_O_XU_REM_MAC)) == 0) { + unsigned int xu_num = 0; + unsigned int vf_num = 0; + + sscanf(key,"oXuRem%02uMac%02u",&xu_num, &vf_num); + + if (xu_num >= XRAN_PORTS_NUM || vf_num >= XRAN_VF_MAX) { + printf("oXuRem%02uMac%02u exceeds max supported\n",xu_num, vf_num); + } else { + printf("oXuRem%02uMac%02u: %s\n",xu_num, vf_num, value); + sscanf(value, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx", (uint8_t*)&config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[0], + (uint8_t*)&config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[1], + (uint8_t*)&config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[2], + (uint8_t*)&config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[3], + (uint8_t*)&config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[4], + (uint8_t*)&config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[5]); + + printf("[xu %d vf %d]RU MAC address: %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n", + xu_num, + vf_num, + config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[0], + config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[1], + config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[2], + config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[3], + config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[4], + config->remote_o_xu_addr[xu_num][vf_num].addr_bytes[5]); + } } else { printf("Unsupported configuration key [%s]\n", key); return -1; @@ -551,7 +844,203 @@ static int fillConfigStruct(RuntimeConfig *config, const char *key, const char * return 0; } -int parseConfigFile(char *filename, RuntimeConfig *config) +static int +fillSlotStructAsCb(void* cbParam, const char *key, const char *value) +{ + struct slot_cfg_to_pars *p_slot_cfg = (struct slot_cfg_to_pars*) cbParam; + RuntimeConfig *config = p_slot_cfg->config; + int32_t direction = p_slot_cfg->direction; + int32_t slot_idx = p_slot_cfg->slot_idx; + uint32_t section_idx = 0; + + //printf("Dir %d slot %d\n", direction, slot_idx); + + if (strcmp(key, KEY_NPRBELEM_UL ) == 0) { + config->p_SlotPrbMap[direction][slot_idx]->nPrbElm = atoi(value); + if (config->p_SlotPrbMap[direction][slot_idx]->nPrbElm > XRAN_MAX_SECTIONS_PER_SLOT) + { + printf("nTddPeriod is larger than max allowed, invalid!\n"); + config->p_SlotPrbMap[direction][slot_idx]->nPrbElm = XRAN_MAX_SECTIONS_PER_SLOT; + } + printf("nPrbElemUl: %d\n",config->p_SlotPrbMap[direction][slot_idx]->nPrbElm ); + } else if (strncmp(key, KEY_PRBELEM_UL_ANT_M, strlen(KEY_PRBELEM_UL_ANT_M)) == 0) { + sscanf(key,"PrbElemUlAntCMask%u",§ion_idx); + if (section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm){ + printf("section_idx %d exceeds nPrbElemul\n",section_idx); + } + else{ + sscanf(value, "%lx",(uint64_t*)&config->SlotPrbAntCMask[direction][slot_idx][section_idx]); + printf("%s%u 0x%lx\n",KEY_PRBELEM_UL_ANT_M, section_idx, config->SlotPrbAntCMask[direction][slot_idx][section_idx]); + } + } else if (strncmp(key, KEY_PRBELEM_UL_CC_M, strlen(KEY_PRBELEM_UL_CC_M)) == 0) { + sscanf(key,"PrbElemUlCCMask%u",§ion_idx); + if (section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm){ + printf("section_idx %d exceeds nPrbElemUL\n",section_idx); + } + else{ + sscanf(value, "%02hx",(uint16_t*)&config->SlotPrbCCmask[direction][slot_idx][section_idx]); + printf("%s%u 0x%02x\n",KEY_PRBELEM_UL_CC_M, section_idx, config->SlotPrbCCmask[direction][slot_idx][section_idx]); + } + } else if (strncmp(key, KEY_PRBELEM_UL, strlen(KEY_PRBELEM_UL)) == 0) { + sscanf(key,"PrbElemUl%u",§ion_idx); + if (section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm) { + printf("section_idx %d exceeds nPrbElemUl\n",section_idx); + } + else { + struct xran_prb_elm *pPrbElem = &config->p_SlotPrbMap[direction][slot_idx]->prbMap[section_idx]; + sscanf(value, "%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd", + (int16_t*)&pPrbElem->nRBStart, + (int16_t*)&pPrbElem->nRBSize, + (int16_t*)&pPrbElem->nStartSymb, + (int16_t*)&pPrbElem->numSymb, + (int16_t*)&pPrbElem->nBeamIndex, + (int16_t*)&pPrbElem->bf_weight_update, + (int16_t*)&pPrbElem->compMethod, + (int16_t*)&pPrbElem->iqWidth, + (int16_t*)&pPrbElem->BeamFormingType); + printf("nPrbElemUl%d: ",section_idx); + printf("nRBStart %d,nRBSize %d,nStartSymb %d,numSymb %d,nBeamIndex %d, bf_weight_update %d compMethod %d, iqWidth %d BeamFormingType %d\n", + pPrbElem->nRBStart,pPrbElem->nRBSize,pPrbElem->nStartSymb,pPrbElem->numSymb,pPrbElem->nBeamIndex, pPrbElem->bf_weight_update, pPrbElem->compMethod, pPrbElem->iqWidth, pPrbElem->BeamFormingType); + } + } else if(strncmp(key, KEY_EXTBFW_UL, strlen(KEY_EXTBFW_UL)) == 0) { + sscanf(key, "ExtBfwUl%u", §ion_idx); + if(section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm) { + printf("section_idx %d of bfw exceeds nPrbElemUl\n",section_idx); + }else{ + struct xran_prb_elm *pPrbElem = &config->p_SlotPrbMap[direction][slot_idx]->prbMap[section_idx]; + sscanf(value, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", + (uint8_t*)&pPrbElem->bf_weight.numBundPrb, + (uint8_t*)&pPrbElem->bf_weight.numSetBFWs, + (uint8_t*)&pPrbElem->bf_weight.RAD, + (uint8_t*)&pPrbElem->bf_weight.disableBFWs, + (uint8_t*)&pPrbElem->bf_weight.bfwIqWidth, + (uint8_t*)&pPrbElem->bf_weight.bfwCompMeth); + printf(KEY_EXTBFW_UL"%d: ", section_idx); + printf("numBundPrb %d, numSetBFW %d, RAD %d, disableBFW %d, bfwIqWidth %d, bfwCompMeth %d\n", + pPrbElem->bf_weight.numBundPrb, pPrbElem->bf_weight.numSetBFWs, pPrbElem->bf_weight.RAD, pPrbElem->bf_weight.disableBFWs, pPrbElem->bf_weight.bfwIqWidth, pPrbElem->bf_weight.bfwCompMeth); + } + }else if (strcmp(key, KEY_NPRBELEM_DL ) == 0) { + config->p_SlotPrbMap[direction][slot_idx]->nPrbElm = atoi(value); + if (config->p_SlotPrbMap[direction][slot_idx]->nPrbElm > XRAN_MAX_SECTIONS_PER_SLOT) + { + printf("nTddPeriod is larger than max allowed, invalid!\n"); + config->p_SlotPrbMap[direction][slot_idx]->nPrbElm = XRAN_MAX_SECTIONS_PER_SLOT; + } + printf("nPrbElemDl: %d\n",config->p_SlotPrbMap[direction][slot_idx]->nPrbElm); + } else if (strncmp(key, KEY_PRBELEM_DL_ANT_M, strlen(KEY_PRBELEM_DL_ANT_M)) == 0) { + sscanf(key,"PrbElemDlAntCMask%u",§ion_idx); + if (section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm){ + printf("section_idx %d exceeds nPrbElemDl\n",section_idx); + } + else{ + sscanf(value, "%lx",(uint64_t*)&config->SlotPrbAntCMask[direction][slot_idx][section_idx]); + printf("%s%u 0x%lx\n",KEY_PRBELEM_DL_ANT_M, section_idx, config->SlotPrbAntCMask[direction][slot_idx][section_idx]); + } + } else if (strncmp(key, KEY_PRBELEM_DL_CC_M, strlen(KEY_PRBELEM_DL_CC_M)) == 0) { + sscanf(key,"PrbElemDlCCMask%u",§ion_idx); + if (section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm){ + printf("section_idx %d exceeds nPrbElemDl\n",section_idx); + } + else{ + sscanf(value, "%02hx",(uint16_t*)&config->SlotPrbCCmask[direction][slot_idx][section_idx]); + printf("%s%u 0x%02x\n",KEY_PRBELEM_DL_CC_M, section_idx, config->SlotPrbCCmask[direction][slot_idx][section_idx]); + } + } else if (strncmp(key, KEY_PRBELEM_DL, strlen(KEY_PRBELEM_DL)) == 0) { + sscanf(key,"PrbElemDl%u",§ion_idx); + if (section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm){ + printf("section_idx %d exceeds nPrbElemDl\n",section_idx); + } + else{ + struct xran_prb_elm *pPrbElem = &config->p_SlotPrbMap[direction][slot_idx]->prbMap[section_idx]; + sscanf(value, "%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd,%hd", + (int16_t*)&pPrbElem->nRBStart, + (int16_t*)&pPrbElem->nRBSize, + (int16_t*)&pPrbElem->nStartSymb, + (int16_t*)&pPrbElem->numSymb, + (int16_t*)&pPrbElem->nBeamIndex, + (int16_t*)&pPrbElem->bf_weight_update, + (int16_t*)&pPrbElem->compMethod, + (int16_t*)&pPrbElem->iqWidth, + (int16_t*)&pPrbElem->BeamFormingType); + printf("nPrbElemDl%d: ",section_idx); + printf("nRBStart %d,nRBSize %d,nStartSymb %d,numSymb %d,nBeamIndex %d, bf_weight_update %d compMethod %d, iqWidth %d BeamFormingType %d\n", + pPrbElem->nRBStart,pPrbElem->nRBSize,pPrbElem->nStartSymb,pPrbElem->numSymb,pPrbElem->nBeamIndex, pPrbElem->bf_weight_update, pPrbElem->compMethod, pPrbElem->iqWidth, pPrbElem->BeamFormingType); + } + } else if(strncmp(key, KEY_EXTBFW_DL, strlen(KEY_EXTBFW_DL)) == 0) { + sscanf(key, "ExtBfwDl%u", §ion_idx); + if(section_idx >= config->p_SlotPrbMap[direction][slot_idx]->nPrbElm) { + printf("section_idx %d of bfw exceeds nPrbElemUl\n",section_idx); + } + else{ + struct xran_prb_elm *pPrbElem = &config->p_SlotPrbMap[direction][slot_idx]->prbMap[section_idx]; + sscanf(value, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", + (uint8_t*)&pPrbElem->bf_weight.numBundPrb, + (uint8_t*)&pPrbElem->bf_weight.numSetBFWs, + (uint8_t*)&pPrbElem->bf_weight.RAD, + (uint8_t*)&pPrbElem->bf_weight.disableBFWs, + (uint8_t*)&pPrbElem->bf_weight.bfwIqWidth, + (uint8_t*)&pPrbElem->bf_weight.bfwCompMeth); + printf(KEY_EXTBFW_DL"%d: ",section_idx); + printf("numBundPrb %d, numSetBFW %d, RAD %d, disableBFW %d, bfwIqWidth %d, bfwCompMeth %d\n", + pPrbElem->bf_weight.numBundPrb, pPrbElem->bf_weight.numSetBFWs, pPrbElem->bf_weight.RAD, pPrbElem->bf_weight.disableBFWs, pPrbElem->bf_weight.bfwIqWidth, pPrbElem->bf_weight.bfwCompMeth); + } + } else { + printf("Unsupported configuration key [%s]\n", key); + return -1; + } + + return 0; +} + +struct xran_prb_map* +config_malloc_prb_map(void) +{ + uint32_t size = sizeof(struct xran_prb_map) + (XRAN_MAX_SECTIONS_PER_SLOT -1) * sizeof(struct xran_prb_elm); + void *ret = NULL; + + ret = malloc(size); + + if(ret) { + memset(ret, 0, size); + return (struct xran_prb_map*)ret; + } else { + rte_panic("xran_prb_map alloc failed"); + } +} + +int32_t +config_init(RuntimeConfig *p_o_xu_cfg) +{ + int32_t i, j, k, z; + memset(p_o_xu_cfg, 0, sizeof(RuntimeConfig)); + + p_o_xu_cfg->p_PrbMapDl = config_malloc_prb_map(); + p_o_xu_cfg->p_PrbMapUl = config_malloc_prb_map(); + p_o_xu_cfg->p_PrbMapSrs = config_malloc_prb_map(); + + for (i= 0; i < XRAN_DIR_MAX; i++){ + for (j= 0; j < XRAN_N_FE_BUF_LEN; j++){ + p_o_xu_cfg->p_SlotPrbMap[i][j] = config_malloc_prb_map(); + } + } + + for (i = 0; i < XRAN_DIR_MAX; i++) { + for (j = 0; j < XRAN_N_FE_BUF_LEN; j++) { + for (k = 0; k < XRAN_MAX_SECTOR_NR; k++) { + for (z = 0; z < XRAN_MAX_ANTENNA_NR; z++) { + p_o_xu_cfg->p_RunSlotPrbMap[i][j][k][z] = config_malloc_prb_map(); + p_o_xu_cfg->p_RunSrsSlotPrbMap[i][j][k][z] = config_malloc_prb_map(); + } + } + } + } + + return 0; +} + + +int +parseConfigFile(char *filename, RuntimeConfig *config) { char inputLine[MAX_LINE_SIZE] = {0}; int inputLen = 0; @@ -629,3 +1118,214 @@ int parseConfigFile(char *filename, RuntimeConfig *config) return 0; } + +int32_t +parseSlotConfigFile(char *dir, RuntimeConfig *config) +{ + int32_t ret = 0; + char filename[512]; + size_t len; + int32_t slot_idx = 0; + int32_t cc_idx = 0; + int32_t ant_idx = 0; + int32_t direction = 0; + struct slot_cfg_to_pars slot_cfg_param; + + for (direction = 0; direction < XRAN_DIR_MAX; direction++) { + for (slot_idx = 0; slot_idx < config->numSlots; slot_idx++){ + memset(filename, 0, sizeof(filename)); + printf("dir (%s)\n",dir); + len = strlen(dir) + 1; + if (len > 511) { + printf("parseSlotConfigFile: Name of directory, %s is too long. Maximum is 511 characters!!\n", dir); + return -1; + } else { + strncpy(filename, dir, len); + } + strncat(filename, "/", 1); + len +=1; + len = (sizeof(filename)) - len; + + if(len > strlen(config->SlotNum_file[direction][slot_idx])){ + strncat(filename, config->SlotNum_file[direction][slot_idx], RTE_MIN (len, strlen(config->SlotNum_file[direction][slot_idx]))); + } else { + printf("File name error\n"); + return -1; + } + printf("slot_file[%d][%d] (%s)\n",direction, slot_idx, filename); + printf("\n=================== Slot%s %d===================\n", ((direction == XRAN_DIR_UL) ? "RX" : "TX"), slot_idx); + + slot_cfg_param.direction = direction; + slot_cfg_param.slot_idx = slot_idx; + slot_cfg_param.config = config; + + if (parseFileViaCb(filename, fillSlotStructAsCb, (void*)&slot_cfg_param)) { + printf("Configuration file error\n"); + return -1; + } + } + } + + return ret; +} + +int32_t +parseFileViaCb (char *filename, fillConfigStruct_fn cbFn, void* cbParm) +{ + char inputLine[MAX_LINE_SIZE] = {0}; + int inputLen = 0; + int i; + int lineNum = 0; + char key[MAX_LINE_SIZE] = {0}; + char value[MAX_LINE_SIZE] = {0}; + FILE *file = fopen(filename, "r"); + + if (NULL == file) { + log_err("Error while opening config file from: %s", filename); + return -1; + } + + for (;;) { + if (fgets(inputLine, MAX_LINE_SIZE, file) == NULL) { + if (lineNum > 0) { + printf("%d lines of config file has been read.\n", lineNum); + break; + } else { + printf("Configuration file reading error has occurred.\n"); + fclose(file); + return -1; + } + } + + if (inputLine[strlen(inputLine)-1] == '\n') + inputLine[strlen(inputLine)-1] == '\0'; + + lineNum++; + inputLen = strlen(inputLine); + + for (i=0; i inputLen - 1) || (i - 2 > inputLen)) { + log_err("Parsing config file error at line %d", lineNum); + fclose(file); + return -1; + } + strncpy(value, &inputLine[i+1], (sizeof(value) - 1)); + value[inputLen-i-2] = '\0'; + trim(value); + + if (strlen(key) == 0 || strlen(value) == 0) { + printf("Parsing config file error at line %d", lineNum); + fclose(file); + return -1; + } + + if(cbFn){ + if (cbFn(cbParm, key, value) != 0) { + fclose(file); + return -1; + } + } else { + printf("cbFn==NULL\n"); + fclose(file); + return -1; + } + + break; + } + + memset(&inputLine[0], 0, sizeof(MAX_LINE_SIZE)); + memset(&key[0], 0, sizeof(MAX_LINE_SIZE)); + memset(&value[0], 0, sizeof(MAX_LINE_SIZE)); + } + fclose(file); + + return 0; +} + +int parseUsecaseFile(char *filename, UsecaseConfig *usecase_cfg) +{ + char inputLine[MAX_LINE_SIZE] = {0}; + int inputLen = 0; + int i; + int lineNum = 0; + char key[MAX_LINE_SIZE] = {0}; + char value[MAX_LINE_SIZE] = {0}; + FILE *file = fopen(filename, "r"); + + if (NULL == file) { + log_err("Error while opening config file from: %s", filename); + return -1; + } + + for (;;) { + if (fgets(inputLine, MAX_LINE_SIZE, file) == NULL) { + if (lineNum > 0) { + printf("%d lines of config file has been read.\n", lineNum); + break; + } else { + printf("Configuration file reading error has occurred.\n"); + fclose(file); + return -1; + } + } + + if (inputLine[strlen(inputLine)-1] == '\n') + inputLine[strlen(inputLine)-1] == '\0'; + + lineNum++; + inputLen = strlen(inputLine); + + for (i=0; i inputLen - 1) || (i - 2 > inputLen)) { + log_err("Parsing config file error at line %d", lineNum); + fclose(file); + return -1; + } + strncpy(value, &inputLine[i+1], (sizeof(value) - 1)); + value[inputLen-i-2] = '\0'; + trim(value); + + if (strlen(key) == 0 || strlen(value) == 0) { + printf("Parsing config file error at line %d", lineNum); + fclose(file); + return -1; + } + + if (fillUsecaseStruct(usecase_cfg, key, value) != 0) { + fclose(file); + return -1; + } + + break; + } + + memset(&inputLine[0], 0, sizeof(MAX_LINE_SIZE)); + memset(&key[0], 0, sizeof(MAX_LINE_SIZE)); + memset(&value[0], 0, sizeof(MAX_LINE_SIZE)); + } + fclose(file); + + return 0; +}