From: pborla Date: Tue, 6 Aug 2024 13:32:11 +0000 (+0530) Subject: [Epic-Id: ODUHIGH-618][Issue-Id: ODUHIGH-619] Implementing fapi decoder interface... X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=refs%2Fchanges%2F45%2F13245%2F4;p=o-du%2Fl2.git [Epic-Id: ODUHIGH-618][Issue-Id: ODUHIGH-619] Implementing fapi decoder interface files Change-Id: I2771e92e7eb9f2241c4cd57bcde4cc2e082a44d9 Signed-off-by: pborla --- diff --git a/tools/Fapi_Decoder/fapi_interface.c b/tools/Fapi_Decoder/fapi_interface.c new file mode 100644 index 000000000..5fab927b2 --- /dev/null +++ b/tools/Fapi_Decoder/fapi_interface.c @@ -0,0 +1,1636 @@ +#include +#include +#include +#include +#include +#include +#include "../../src/intel_fapi/fapi_interface.h" +#include "../../src/intel_fapi/fapi_vendor_extension.h" +#include "../../src/intel_fapi/nfapi_interface.h" +#include "../../src/intel_fapi/nr5g_fapi_common_types.h" +#include "../../src/intel_fapi/nr5g_fapi_internal.h" + +void decode_fapi_srs_pdu(fapi_srs_pdu_t* srsPdu); +void decode_fapi_precoding_bmform(const fapi_precoding_bmform_t* precodingBfForm); + +void decode_fapi_msg_header(fapi_msg_header_t* header) +{ + printf("\n"); + printf("num_msg = %u\t", header->num_msg); + printf("handle = %u\t", header->handle); +} + +void decode_fapi_msg(fapi_msg_t* msg) +{ + printf("\n"); + printf("msg_id = %u\t", msg->msg_id); + printf("length = %u\t", msg->length); + printf("pad = %u\t", msg->pad); +} + +void decode_fapi_tl(fapi_tl_t* tl) +{ + printf("\n"); + printf("tag = %u\t", tl->tag); + printf("length = %u\t", tl->length); +} + + +void decode_fapi_uint8_tlv(fapi_uint8_tlv_t* tlv) +{ + printf("\n"); + decode_fapi_tl(&tlv->tl); + printf("value = %u\t", tlv->value); + printf("rsv[0] = %u\t", tlv->rsv[0]); + printf("rsv[1] = %u\t", tlv->rsv[1]); + printf("rsv[2] = %u\t", tlv->rsv[2]); +} + +void decode_fapi_uint8_ptr_tlv(fapi_uint8_ptr_tlv_t* tlv) +{ + printf("\n"); + decode_fapi_tl(&tlv->tl); + if (tlv->value != NULL) + { + printf("value = %d", tlv->value); + printf("\t"); + } else + { + printf("value is NULL\t"); + } +} + +void decode_fapi_uint16_tlv(fapi_uint16_tlv_t* tlv) +{ + printf("\n"); + decode_fapi_tl(&tlv->tl); + printf("value = %u\t", tlv->value); + printf("rsv[0] = %u\t", tlv->rsv[0]); + printf("rsv[1] = %u\t", tlv->rsv[1]); +} +void decode_fapi_int16_tlv(fapi_int16_tlv_t* tlv) +{ + printf("\n"); + decode_fapi_tl(&tlv->tl); + printf("value = %d\t", tlv->value); + printf("rsv[0] = %u\t", tlv->rsv[0]); + printf("rsv[1] = %u\t", tlv->rsv[1]); +} + +void decode_fapi_uint32_tlv(fapi_uint32_tlv_t * tlv) +{ + printf("\n"); + decode_fapi_tl(&tlv->tl); + printf("value = %u ", tlv->value); +} + +void decode_fapi_config_tlv(fapi_config_tlv_t* config) +{ + printf("\n"); + printf("tag = %u\t", config->tag); + printf("length = %u\t", config->length); + printf("value = %u\t", config->value); +} + +void decode_fapi_config_num_tlv(fapi_config_num_tlv_t* config_num) +{ + printf("\n"); + decode_fapi_tl(&config_num->tl); + for (size_t i = 0; i < FAPI_NUMEROLOGIES; i++) { + printf("value[%zu] = %u\t", i, config_num->value[i]); + } + printf("rsv = %u\t", config_num->rsv); +} + +void decode_fapi_param_req(fapi_param_req_t* param_req) +{ + // Assuming fapi_msg_t header has its own check function + decode_fapi_msg(¶m_req->header); +} + +void decode_fapi_cell_parms(fapi_cell_parms_t* cell_parms) +{ + decode_fapi_uint16_tlv(&cell_parms->releaseCapability); + decode_fapi_uint16_tlv(&cell_parms->phyState); + decode_fapi_uint8_tlv(&cell_parms->skipBlankDlConfig); + decode_fapi_uint8_tlv(&cell_parms->skipBlankUlConfig); + decode_fapi_uint16_tlv(&cell_parms->numTlvsToReport); + for (size_t i = 0; i < FAPI_MAX_NUM_TLVS_CONFIG; i++) + { + decode_fapi_config_tlv(&cell_parms->tlvStatus[i]); + } +} + +void decode_fapi_carrier_parms(fapi_carrier_parms_t* carrier_parms) +{ + decode_fapi_uint8_tlv(&carrier_parms->cyclicPrefix); + decode_fapi_uint8_tlv(&carrier_parms->supportedSubcarrierSpacingDl); + decode_fapi_uint16_tlv(&carrier_parms->supportedBandwidthDl); + decode_fapi_uint8_tlv(&carrier_parms->supportedSubcarrierSpecingsUl); + decode_fapi_uint16_tlv(&carrier_parms->supportedBandwidthUl); +} + +void decode_fapi_pdcch_parms(fapi_pdcch_parms_t* pdcch_parms) +{ + decode_fapi_uint8_tlv(&pdcch_parms->cceMappingType); + decode_fapi_uint8_tlv(&pdcch_parms->coresetOutsideFirst3OfdmSymsOfSlot); + decode_fapi_uint8_tlv(&pdcch_parms->precoderGranularityCoreset); + decode_fapi_uint8_tlv(&pdcch_parms->pdcchMuMimo); + decode_fapi_uint8_tlv(&pdcch_parms->pdcchPrecoderCycling); + decode_fapi_uint8_tlv(&pdcch_parms->maxPdcchsPerSlot); +} + +void decode_fapi_pucch_parms(fapi_pucch_parms_t* pucch_parms) +{ + decode_fapi_uint8_tlv(&pucch_parms->pucchFormats); + decode_fapi_uint8_tlv(&pucch_parms->maxPucchsPerSlot); +} + +void decode_fapi_pdsch_parms(fapi_pdsch_parms_t* pdsch_parms) +{ + decode_fapi_uint8_tlv(&pdsch_parms->pdschMappingType); + decode_fapi_uint8_tlv(&pdsch_parms->pdschAllocationTypes); + decode_fapi_uint8_tlv(&pdsch_parms->pdschVrbToPrbMapping); + decode_fapi_uint8_tlv(&pdsch_parms->pdschCbg); + decode_fapi_uint8_tlv(&pdsch_parms->pdschDmrsConfigTypes); + decode_fapi_uint8_tlv(&pdsch_parms->pdschDmrsMaxLength); + decode_fapi_uint8_tlv(&pdsch_parms->pdschDmrsAdditionalPos); + decode_fapi_uint8_tlv(&pdsch_parms->maxPdschsTBsPerSlot); + decode_fapi_uint8_tlv(&pdsch_parms->maxNumberMimoLayersPdsch); + decode_fapi_uint8_tlv(&pdsch_parms->supportedMaxModulationOrderDl); + decode_fapi_uint8_tlv(&pdsch_parms->maxMuMimoUsersDl); + decode_fapi_uint8_tlv(&pdsch_parms->pdschDataInDmrsSymbols); + decode_fapi_uint8_tlv(&pdsch_parms->premptionSupport); + decode_fapi_uint8_tlv(&pdsch_parms->pdschNonSlotSupport); +} + +void decode_fapi_pusch_parms(fapi_pusch_parms_t* pusch_parms) +{ + decode_fapi_uint8_tlv(&pusch_parms->uciMuxUlschInPusch); + decode_fapi_uint8_tlv(&pusch_parms->uciOnlyPusch); + decode_fapi_uint8_tlv(&pusch_parms->puschFrequencyHopping); + decode_fapi_uint8_tlv(&pusch_parms->puschDmrsConfigTypes); + decode_fapi_uint8_tlv(&pusch_parms->puschDmrsMaxLen); + decode_fapi_uint8_tlv(&pusch_parms->puschDmrsAdditionalPos); + decode_fapi_uint8_tlv(&pusch_parms->puschCbg); + decode_fapi_uint8_tlv(&pusch_parms->puschMappingType); + decode_fapi_uint8_tlv(&pusch_parms->puschAllocationTypes); + decode_fapi_uint8_tlv(&pusch_parms->puschVrbToPrbMapping); + decode_fapi_uint8_tlv(&pusch_parms->puschMaxPtrsPorts); + decode_fapi_uint8_tlv(&pusch_parms->maxPduschsTBsPerSlot); + decode_fapi_uint8_tlv(&pusch_parms->maxNumberMimoLayersNonCbPusch); + decode_fapi_uint8_tlv(&pusch_parms->supportedModulationOrderUl); + decode_fapi_uint8_tlv(&pusch_parms->maxMuMimoUsersUl); + decode_fapi_uint8_tlv(&pusch_parms->dftsOfdmSupport); + decode_fapi_uint8_tlv(&pusch_parms->puschAggregationFactor); +} + +void decode_fapi_prach_parms(fapi_prach_parms_t* prach_parms) +{ + decode_fapi_uint8_tlv(&prach_parms->prachLongFormats); + decode_fapi_uint16_tlv(&prach_parms->prachShortFormats); + decode_fapi_uint8_tlv(&prach_parms->prachRestrictedSets); + decode_fapi_uint8_tlv(&prach_parms->maxPrachFdOccasionsInASlot); +} +void decode_fapi_meas_parms(fapi_meas_parms_t* meas_parms) +{ + decode_fapi_uint8_tlv(&meas_parms->rssiMeasurementSupport); +} + +void decode_fapi_params(fapi_params_t* params) +{ + decode_fapi_cell_parms(¶ms->cell_parms); + decode_fapi_carrier_parms(¶ms->carr_parms); + decode_fapi_pdcch_parms(¶ms->pdcch_parms); + decode_fapi_pucch_parms(¶ms->pucch_parms); + decode_fapi_pdsch_parms(¶ms->pdsch_parms); + decode_fapi_pusch_parms(¶ms->pusch_parms); + decode_fapi_prach_parms(¶ms->prach_parms); + decode_fapi_meas_parms(¶ms->meas_parms); +} + +void decode_fapi_param_resp(fapi_param_resp_t* param_resp) +{ + printf("\n"); + decode_fapi_msg(¶m_resp->header); + printf("error_code = %u\t", param_resp->error_code); + printf("number_of_tlvs = %u\t", param_resp->number_of_tlvs); + for (size_t i = 0; i < FAPI_MAX_NUM_TLVS_PARAMS; i++) + { + decode_fapi_uint16_tlv(¶m_resp->tlvs[i]); + } +} + +void decode_fapi_carrier_config(fapi_carrier_config_t* carrier_config) +{ + decode_fapi_uint16_tlv(&carrier_config->dlBandwidth); + decode_fapi_uint32_tlv(&carrier_config->dlFrequency); + decode_fapi_config_num_tlv(&carrier_config->dlk0); + decode_fapi_config_num_tlv(&carrier_config->dlGridSize); + decode_fapi_uint16_tlv(&carrier_config->numTxAnt); + decode_fapi_uint16_tlv(&carrier_config->uplinkBandwidth); + decode_fapi_uint32_tlv(&carrier_config->uplinkFrequency); + decode_fapi_config_num_tlv(&carrier_config->ulk0); + decode_fapi_config_num_tlv(&carrier_config->ulGridSize); + decode_fapi_uint16_tlv(&carrier_config->numRxAnt); + decode_fapi_uint8_tlv(&carrier_config->frequencyShift7p5KHz); +} + +void decode_fapi_cell_config(fapi_cell_config_t* cell_config) +{ + decode_fapi_uint8_tlv(&cell_config->phyCellId); + decode_fapi_uint8_tlv(&cell_config->frameDuplexType); +} + +void decode_fapi_ssb_config(fapi_ssb_config_t* ssb_config) +{ + decode_fapi_uint32_tlv(&ssb_config->ssPbchPower); + decode_fapi_uint8_tlv(&ssb_config->bchPayload); + decode_fapi_uint8_tlv(&ssb_config->scsCommon); +} + +void decode_fapi_prachFdOccasion(fapi_prachFdOccasion_t* prachFdOccasion) +{ + decode_fapi_uint16_tlv(&prachFdOccasion->prachRootSequenceIndex); + decode_fapi_uint8_tlv(&prachFdOccasion->numRootSequences); + decode_fapi_uint16_tlv(&prachFdOccasion->k1); + decode_fapi_uint8_tlv(&prachFdOccasion->prachZeroCorrConf); + decode_fapi_uint16_tlv(&prachFdOccasion->numUnusedRootSequences); + for (size_t i = 0; i < FAPI_MAX_NUM_UNUSED_ROOT_SEQUENCES; i++) { + decode_fapi_uint16_tlv(&prachFdOccasion->unusedRootSequences[i]); + } +} + +void decode_fapi_prach_configuration(fapi_prach_configuration_t* prachConfig) +{ + decode_fapi_uint8_tlv(&prachConfig->prachSequenceLength); + decode_fapi_uint8_tlv(&prachConfig->prachSubCSpacing); + decode_fapi_uint8_tlv(&prachConfig->restrictedSetConfig); + decode_fapi_uint8_tlv(&prachConfig->numPrachFdOccasions); + decode_fapi_uint8_tlv(&prachConfig->prachConfigIndex); + for (size_t i = 0; i < FAPI_MAX_NUM_PRACH_FD_OCCASIONS; i++) { + decode_fapi_prachFdOccasion(&prachConfig->prachFdOccasion[i]); + } + decode_fapi_uint8_tlv(&prachConfig->ssbPerRach); + decode_fapi_uint8_tlv(&prachConfig->prachMultipleCarriersInABand); +} + +void decode_fapi_ssb_table(fapi_ssb_table_t* ssbTable) +{ + decode_fapi_uint16_tlv(&ssbTable->ssbOffsetPointA); + decode_fapi_uint8_tlv(&ssbTable->betaPss); + decode_fapi_uint8_tlv(&ssbTable->ssbPeriod); + decode_fapi_uint8_tlv(&ssbTable->ssbSubCarrierOffset); + decode_fapi_uint32_tlv(&ssbTable->mib); + for (size_t i = 0; i < 2; i++) { + decode_fapi_uint32_tlv(&ssbTable->ssbMask[i]); + } + for (size_t i = 0; i < 64; i++) { + decode_fapi_uint8_tlv(&ssbTable->beamId[i]); + } + decode_fapi_uint8_tlv(&ssbTable->ssPbchMultipleCarriersInABand); + decode_fapi_uint8_tlv(&ssbTable->multipleCellsSsPbchInACarrier); +} + +void decode_fapi_slotconfig(fapi_slotconfig_t* slotConfig) +{ + for (size_t i = 0; i < FAPI_MAX_NUM_OF_SYMBOLS_PER_SLOT; i++) { + decode_fapi_uint8_tlv(&slotConfig->slotConfig[i]); + } +} + +void decode_fapi_tdd_table(fapi_tdd_table_t* tddTable) +{ + decode_fapi_uint8_tlv(&tddTable->tddPeriod); + for (size_t i = 0; i < FAPI_MAX_TDD_PERIODICITY; i++) { + decode_fapi_slotconfig(&tddTable->slotConfig[i]); + } +} + +void decode_fapi_meas_config(fapi_meas_config_t* measConfig) +{ + decode_fapi_uint8_tlv(&measConfig->rssiMeasurement); +} + +void decode_fapi_dig_beam_weight(fapi_dig_beam_weight_t* digBeamWeight) +{ + printf("\n"); + printf("digBeamWeightRe = %d\t", digBeamWeight->digBeamWeightRe); + printf("digBeamWeightIm = %d\t", digBeamWeight->digBeamWeightIm); +} + +void decode_fapi_dig_beam_config(fapi_dig_beam_config_t* digBeamConfig) +{ + printf("\n"); + printf("beamIdx = %u\t", digBeamConfig->beamIdx); + for (size_t i = 0; i < FAPI_MAX_NUMBER_TX_RUS; i++) { + decode_fapi_dig_beam_weight(&digBeamConfig->digBeamWeight[i]); + } +} + +void decode_fapi_beamforming_table(fapi_beamforming_table_t* beamformingTable) +{ + printf("\n"); + printf("numDigBeams = %u\t", beamformingTable->numDigBeams); + printf("numTxRus = %u\t", beamformingTable->numTxRus); + for (size_t i = 0; i < FAPI_MAX_NUMBER_OF_BEAMS; i++) { + decode_fapi_dig_beam_config(&beamformingTable->digBeam[i]); + } +} + +void decode_fapi_precoderWeight_t(fapi_precoderWeight_t* precoder) +{ + + printf("\n"); + printf("preCoderWeightRe = %d\t", precoder->preCoderWeightRe); + printf("preCoderWeightIm = %d\t", precoder->preCoderWeightIm); + +} +void decode_fapi_precoder_weight_t(fapi_precoder_weight_t* precoderWeight) +{ + for (size_t i = 0; i < FAPI_MAX_NUM_ANT_PORTS; i++) { + decode_fapi_precoderWeight_t(&precoderWeight->precoder_weight[i]); + } +} + +void decode_fapi_precoding_table(fapi_precoding_table_t* precodingTable) +{ + printf("\n"); + printf("pmIdx = %u\t", precodingTable->pmIdx); + printf("numLayers = %u\t", precodingTable->numLayers); + printf("numAntPorts = %u\t", precodingTable->numAntPorts); + for (size_t i = 0; i < FAPI_MAX_NUM_LAYERS; i++) { + decode_fapi_precoder_weight_t(&precodingTable->precoderWeight[i]); + } +} + +void decode_fapi_config(fapi_config_t* config) +{ + decode_fapi_carrier_config(&config->carrierConfig); + decode_fapi_cell_config(&config->cellConfig); + decode_fapi_ssb_config(&config->ssbConfig); + decode_fapi_prach_configuration(&config->prachConfig); + decode_fapi_ssb_table(&config->ssbTable); + decode_fapi_tdd_table(&config->tddTable); + decode_fapi_meas_config(&config->measConfig); + decode_fapi_beamforming_table(&config->beamformingTable); + decode_fapi_precoding_table(&config->precodingTable); +} + +void handleCfgReqtlv(fapi_uint32_tlv_t* tlv, fapi_config_t* config) +{ + printf("\n"); + printf("\ttl.tag = %u\t", tlv->tl.tag); + switch (tlv->tl.tag) { + // Carrier Configuration Tags + case FAPI_DL_BANDWIDTH_TAG: + config->carrierConfig.dlBandwidth.value = (uint16_t)tlv->value; + break; + + case FAPI_UPLINK_BANDWIDTH_TAG: + config->carrierConfig.uplinkBandwidth.value = (uint16_t)tlv->value; + break; + + case FAPI_DL_FREQUENCY_TAG: + config->carrierConfig.dlFrequency.value = (uint32_t)tlv->value; + break; + + case FAPI_UPLINK_FREQUENCY_TAG: + config->carrierConfig.uplinkFrequency.value = (uint32_t)tlv->value; + break; + + case FAPI_DL_K0_TAG: + config->carrierConfig.dlk0.value[0] = (uint16_t)tlv->value; + break; + + case FAPI_UL_K0_TAG: + config->carrierConfig.ulk0.value[0] = (uint16_t)tlv->value; + break; + + case FAPI_DL_GRIDSIZE_TAG: + config->carrierConfig.dlGridSize.value[0] = (uint8_t)tlv->value; + break; + + case FAPI_UL_GRID_SIZE_TAG: + config->carrierConfig.ulGridSize.value[0] = (uint8_t)tlv->value; + break; + + case FAPI_NUM_TX_ANT_TAG: + config->carrierConfig.numTxAnt.value = (uint8_t)tlv->value; + break; + + case FAPI_NUM_RX_ANT_TAG: + config->carrierConfig.numRxAnt.value = (uint8_t)tlv->value; + break; + + case FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG: + config->carrierConfig.frequencyShift7p5KHz.value = (uint8_t)tlv->value; + break; + + // Cell Configuration Tags + case FAPI_PHY_CELL_ID_TAG: + config->cellConfig.phyCellId.value = (uint16_t)tlv->value; + break; + + case FAPI_FRAME_DUPLEX_TYPE_TAG: + config->cellConfig.frameDuplexType.value = (uint8_t)tlv->value; + break; + + // SSB Configuration Tags + case FAPI_SS_PBCH_POWER_TAG: + config->ssbConfig.ssPbchPower.value = (int8_t)tlv->value; + break; + + case FAPI_BCH_PAYLOAD_TAG: + config->ssbConfig.bchPayload.value = (uint32_t)tlv->value; + break; + + case FAPI_SCS_COMMON_TAG: + config->ssbConfig.scsCommon.value = (uint16_t)tlv->value; + break; + + // PRACH Configuration Tags + case FAPI_PRACH_SEQUENCE_LENGTH_TAG: + config->prachConfig.prachSequenceLength.value = (uint8_t)tlv->value; + break; + + case FAPI_PRACH_SUBC_SPACING_TAG: + config->prachConfig.prachSubCSpacing.value = (uint8_t)tlv->value; + break; + + case FAPI_RESTRICTED_SET_CONFIG_TAG: + config->prachConfig.restrictedSetConfig.value = (uint8_t)tlv->value; + break; + + case FAPI_NUM_PRACH_FD_OCCASIONS_TAG: + config->prachConfig.numPrachFdOccasions.value = (uint8_t)tlv->value; + break; + + case FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG: + config->prachConfig.prachFdOccasion[0].prachRootSequenceIndex.value = (uint16_t)tlv->value; + break; + + case FAPI_NUM_ROOT_SEQUENCES_TAG: + config->prachConfig.prachFdOccasion[0].numRootSequences.value = (uint16_t)tlv->value; + break; + + case FAPI_K1_TAG: + config->prachConfig.prachFdOccasion[0].k1.value = (uint8_t)tlv->value; + break; + + case FAPI_PRACH_ZERO_CORR_CONF_TAG: + config->prachConfig.prachFdOccasion[0].prachZeroCorrConf.value = (uint8_t)tlv->value; + break; + + case FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG: + config->prachConfig.prachFdOccasion[0].numUnusedRootSequences.value = (uint8_t)tlv->value; + break; + + case FAPI_UNUSED_ROOT_SEQUENCES_TAG: + { + for(uint8_t idx =0; idxprachConfig.prachFdOccasion[0].numUnusedRootSequences.value; idx++) + config->prachConfig.prachFdOccasion[0].unusedRootSequences[idx].value = (uint8_t)tlv->value; + break; + } + + case FAPI_SSB_PER_RACH_TAG: + config->prachConfig.ssbPerRach.value = (uint8_t)tlv->value; + break; + + case FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG: + config->prachConfig.prachMultipleCarriersInABand.value = (uint8_t)tlv->value; + break; + + // SSB Table Tags + case FAPI_SSB_OFFSET_POINT_A_TAG: + config->ssbTable.ssbOffsetPointA.value = (uint32_t)tlv->value; + break; + + case FAPI_BETA_PSS_TAG: + config->ssbTable.betaPss.value = (uint8_t)tlv->value; + break; + + case FAPI_SSB_PERIOD_TAG: + config->ssbTable.ssbPeriod.value = (uint8_t)tlv->value; + break; + + case FAPI_SSB_SUBCARRIER_OFFSET_TAG: + config->ssbTable.ssbSubCarrierOffset.value = (uint16_t)tlv->value; + break; + + case FAPI_MIB_TAG: + config->ssbTable.mib.value = (uint32_t)tlv->value; + break; + + case FAPI_SSB_MASK_TAG: + memcpy(config->ssbTable.ssbMask, &tlv->value, sizeof(config->ssbTable.ssbMask)); + break; + + case FAPI_BEAM_ID_TAG: + memcpy(config->ssbTable.beamId, &tlv->value, sizeof(config->ssbTable.beamId)); + break; + + case FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG: + config->ssbTable.ssPbchMultipleCarriersInABand.value = (uint8_t)tlv->value; + break; + + case FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG: + config->ssbTable.multipleCellsSsPbchInACarrier.value = (uint8_t)tlv->value; + break; + + // TDD Table Tags + case FAPI_TDD_PERIOD_TAG: + config->tddTable.tddPeriod.value = (uint8_t)tlv->value; + break; + + case FAPI_SLOT_CONFIG_TAG: + memcpy(config->tddTable.slotConfig, &tlv->value, sizeof(config->tddTable.slotConfig)); + break; + + // Measurement Configuration Tags + case FAPI_RSSI_MEASUREMENT_TAG: + config->measConfig.rssiMeasurement.value = (uint8_t)tlv->value; + break; + + default: + printf("Unsupported TLV tag: %u\t", tlv->tl.tag); + break; + } +} + + +void decode_fapi_config_req(fapi_config_req_t* configReq) +{ + printf("\n"); + fapi_config_t config; + + decode_fapi_msg(&configReq->header); + printf("number_of_tlvs = %u\t", configReq->number_of_tlvs); + for (size_t i = 0; i < configReq->number_of_tlvs; i++) { + decode_fapi_uint32_tlv(&configReq->tlvs[i]); + handleCfgReqtlv(&configReq->tlvs[i], &config); + } + decode_fapi_config(&config); +} + +void decode_fapi_config_resp(fapi_config_resp_t* configResp) +{ + printf("\n"); + decode_fapi_msg(&configResp->header); + printf("error_code = %u\t", configResp->error_code); + printf("number_of_invalid_tlvs = %u\t", configResp->number_of_invalid_tlvs); + printf("number_of_inv_tlvs_idle_only = %u\t", configResp->number_of_inv_tlvs_idle_only); + printf("number_of_inv_tlvs_running_only = %u\t", configResp->number_of_inv_tlvs_running_only); + printf("number_of_missing_tlvs = %u\t", configResp->number_of_missing_tlvs); + for (size_t i = 0; i < 4 * FAPI_MAX_NUM_TLVS_CONFIG; i++) { + decode_fapi_uint16_tlv(&configResp->tlvs[i]); + } +} + +void decode_fapi_start_req(fapi_start_req_t* startReq) +{ + decode_fapi_msg(&startReq->header); +} + +void decode_fapi_stop_req(fapi_stop_req_t* stopReq) +{ + decode_fapi_msg(&stopReq->header); +} + +void decode_fapi_stop_ind(fapi_stop_ind_t* stopInd) +{ + decode_fapi_msg(&stopInd->header); +} + +void decode_fapi_error_ind(fapi_error_ind_t* errorInd) +{ + printf("\n"); + decode_fapi_msg(&errorInd->header); + printf("sfn = %u\t", errorInd->sfn); + printf("slot = %u\t", errorInd->slot); + printf("message_id = %u\t", errorInd->message_id); + printf("error_code = %u\t", errorInd->error_code); +} + +void decode_fapi_slot_ind(fapi_slot_ind_t* slotInd) +{ + printf("\n"); + decode_fapi_msg(&slotInd->header); + printf("sfn = %u\t", slotInd->sfn); + printf("slot = %u\t", slotInd->slot); +} + +void decode_fapi_bmi(const fapi_bmi_t* bmi) +{ + printf("\n"); + printf("beamidx = %u\t", bmi->beamidx); +} + +void decode_fapi_pmi_bfi(const fapi_pmi_bfi_t* pmiBfi) +{ + printf("\n"); + printf("pmIdx = %u\t", pmiBfi->pmIdx); + for (size_t i = 0; i < FAPI_MAX_NUM_DIGBFINTERFACES; i++) { + decode_fapi_bmi(&pmiBfi->beamIdx[i]); + } +} + +void decode_fapi_dl_dci(fapi_dl_dci_t* dlDci) +{ + printf("\n"); + printf("rnti = %u\t", dlDci->rnti); + printf("scramblingId = %u\t", dlDci->scramblingId); + printf("scramblingRnti = %u\t", dlDci->scramblingRnti); + printf("cceIndex = %u\t", dlDci->cceIndex); + printf("aggregationLevel = %u\t", dlDci->aggregationLevel); + decode_fapi_precoding_bmform(&dlDci->pc_and_bform); + printf("beta_pdcch_1_0 = %u\t", dlDci->beta_pdcch_1_0); + printf("powerControlOffsetSS = %u\t", dlDci->powerControlOffsetSS); + printf("payloadSizeBits = %u\t", dlDci->payloadSizeBits); + for (size_t i = 0; i < FAPI_DCI_PAYLOAD_BYTE_LEN; i++) { + printf("payload[%zu] = %u\t", i, dlDci->payload[i]); + } +} + +void decode_fapi_dl_pdcch_pdu(fapi_dl_pdcch_pdu_t* dlPdcchPdu) +{ + printf("\n"); + printf("bwpSize = %u\t", dlPdcchPdu->bwpSize); + printf("bwpStart = %u\t", dlPdcchPdu->bwpStart); + printf("subCarrierSpacing = %u\t", dlPdcchPdu->subCarrierSpacing); + printf("cyclicPrefix = %u\t", dlPdcchPdu->cyclicPrefix); + printf("startSymbolIndex = %u\t", dlPdcchPdu->startSymbolIndex); + printf("durationSymbols = %u\t", dlPdcchPdu->durationSymbols); + printf("freqDomainResource = "); + for (size_t i = 0; i < sizeof(dlPdcchPdu->freqDomainResource); i++) { + printf("%u ", dlPdcchPdu->freqDomainResource[i]); + } + printf("\t"); + printf("cceRegMappingType = %u\t", dlPdcchPdu->cceRegMappingType); + printf("regBundleSize = %u\t", dlPdcchPdu->regBundleSize); + printf("interleaverSize = %u\t", dlPdcchPdu->interleaverSize); + printf("coreSetType = %u\t", dlPdcchPdu->coreSetType); + printf("shiftIndex = %u\t", dlPdcchPdu->shiftIndex); + printf("precoderGranularity = %u\t", dlPdcchPdu->precoderGranularity); + printf("numDlDci = %u\t", dlPdcchPdu->numDlDci); + for (size_t i = 0; i < dlPdcchPdu->numDlDci; i++) { + decode_fapi_dl_dci(&dlPdcchPdu->dlDci[i]); + } +} + +void decode_fapi_codeword_pdu(fapi_codeword_pdu_t* codewordPdu) +{ + printf("\n"); + printf("targetCodeRate = %u\t", codewordPdu->targetCodeRate); + printf("qamModOrder = %u\t", codewordPdu->qamModOrder); + printf("mcsIndex = %u\t", codewordPdu->mcsIndex); + printf("mcsTable = %u\t", codewordPdu->mcsTable); + printf("rvIndex = %u\t", codewordPdu->rvIndex); + printf("tbSize = %u\t", codewordPdu->tbSize); +} + +void decode_fapi_precoding_bmform(const fapi_precoding_bmform_t* precodingBfForm) +{ + printf("\n"); + printf("numPrgs = %u\t", precodingBfForm->numPrgs); + printf("prgSize = %u\t", precodingBfForm->prgSize); + printf("digBfInterfaces = %u\t", precodingBfForm->digBfInterfaces); + for (size_t i = 0; i < precodingBfForm->numPrgs; i++) + { + decode_fapi_pmi_bfi(&precodingBfForm->pmi_bfi[i]); + } +} + +void decode_fapi_dl_pdsch_pdu(fapi_dl_pdsch_pdu_t* dlPdschPdu) +{ + printf("\n"); + printf("pduBitMap = %u\t", dlPdschPdu->pduBitMap); + printf("rnti = %u\t", dlPdschPdu->rnti); + printf("pdu_index = %u\t", dlPdschPdu->pdu_index); + printf("bwpSize = %u\t", dlPdschPdu->bwpSize); + printf("bwpStart = %u\t", dlPdschPdu->bwpStart); + printf("subCarrierSpacing = %u\t", dlPdschPdu->subCarrierSpacing); + printf("cyclicPrefix = %u\t", dlPdschPdu->cyclicPrefix); + printf("nrOfCodeWords = %u\t", dlPdschPdu->nrOfCodeWords); + + for (size_t i = 0; i < dlPdschPdu->nrOfCodeWords; i++) { + printf("cwInfo[%zu]:\t", i); + decode_fapi_codeword_pdu(&dlPdschPdu->cwInfo[i]); + } + + printf("dataScramblingId = %u\t", dlPdschPdu->dataScramblingId); + printf("nrOfLayers = %u\t", dlPdschPdu->nrOfLayers); + printf("transmissionScheme = %u\t", dlPdschPdu->transmissionScheme); + printf("refPoint = %u\t", dlPdschPdu->refPoint); + printf("dmrsConfigType = %u\t", dlPdschPdu->dmrsConfigType); + printf("dlDmrsSymbPos = %u\t", dlPdschPdu->dlDmrsSymbPos); + printf("scid = %u\t", dlPdschPdu->scid); + printf("numDmrsCdmGrpsNoData = %u\t", dlPdschPdu->numDmrsCdmGrpsNoData); + printf("resourceAlloc = %u\t", dlPdschPdu->resourceAlloc); + printf("dlDmrsScramblingId = %u\t", dlPdschPdu->dlDmrsScramblingId); + printf("dmrsPorts = %u\t", dlPdschPdu->dmrsPorts); + printf("rbStart = %u\t", dlPdschPdu->rbStart); + printf("rbSize = %u\t", dlPdschPdu->rbSize); + + printf("rbBitmap = "); + for (size_t i = 0; i < sizeof(dlPdschPdu->rbBitmap); i++) { + printf("%u ", dlPdschPdu->rbBitmap[i]); + } + + printf("vrbToPrbMapping = %u\t", dlPdschPdu->vrbToPrbMapping); + printf("startSymbIndex = %u\t", dlPdschPdu->startSymbIndex); + printf("nrOfSymbols = %u\t", dlPdschPdu->nrOfSymbols); + printf("ptrsPortIndex = %u\t", dlPdschPdu->ptrsPortIndex); + printf("ptrsTimeDensity = %u\t", dlPdschPdu->ptrsTimeDensity); + printf("ptrsFreqDensity = %u\t", dlPdschPdu->ptrsFreqDensity); + printf("ptrsReOffset = %u\t", dlPdschPdu->ptrsReOffset); + printf("nEpreRatioOfPdschToPtrs = %u\t", dlPdschPdu->nEpreRatioOfPdschToPtrs); + + decode_fapi_precoding_bmform(&dlPdschPdu->preCodingAndBeamforming); + + printf("powerControlOffset = %u\t", dlPdschPdu->powerControlOffset); + printf("powerControlOffsetSS = %u\t", dlPdschPdu->powerControlOffsetSS); + printf("isLastCbPresent = %u\t", dlPdschPdu->isLastCbPresent); + printf("isInlineTbCrc = %u\t", dlPdschPdu->isInlineTbCrc); + printf("dlTbCrc = %u\t", dlPdschPdu->dlTbCrc); + printf("mappingType = %u\t", dlPdschPdu->mappingType); + printf("nrOfDmrsSymbols = %u\t", dlPdschPdu->nrOfDmrsSymbols); + printf("dmrsAddPos = %u\t", dlPdschPdu->dmrsAddPos); +} + +void decode_fapi_phy_mib_pdu(fapi_phy_mib_pdu_t* phyMibPdu) +{ + printf("\n"); + printf("dmrsTypeAPosition = %u\t", phyMibPdu->dmrsTypeAPosition); + printf("pdcchConfigSib1 = %u\t", phyMibPdu->pdcchConfigSib1); + printf("cellBarred = %u\t", phyMibPdu->cellBarred); + printf("intraFreqReselection = %u\t", phyMibPdu->intraFreqReselection); +} + +void decode_fapi_bch_payload(fapi_bch_payload_t* bchPayload) +{ + printf("\n"); + printf("bchPayload.bchPayload = %u\t", bchPayload->bchPayload); + printf("bchPayload.phyMibPdu:\t"); + decode_fapi_phy_mib_pdu(&bchPayload->phyMibPdu); +} + +void decode_fapi_dl_ssb_pdu(fapi_dl_ssb_pdu_t* dlSsbPdu) +{ + printf("\n"); + printf("physCellId = %u\t", dlSsbPdu->physCellId); + printf("betaPss = %u\t", dlSsbPdu->betaPss); + printf("ssbBlockIndex = %u\t", dlSsbPdu->ssbBlockIndex); + printf("ssbSubCarrierOffset = %u\t", dlSsbPdu->ssbSubCarrierOffset); + printf("bchPayloadFlag = %u\t", dlSsbPdu->bchPayloadFlag); + printf("ssbOffsetPointA = %u\t", dlSsbPdu->ssbOffsetPointA); + printf("bchPayload:\t"); + decode_fapi_bch_payload(&dlSsbPdu->bchPayload); + printf("preCodingAndBeamforming:\t"); + decode_fapi_precoding_bmform(&dlSsbPdu->preCodingAndBeamforming); +} + +void decode_fapi_dl_csi_rs_pdu(const fapi_dl_csi_rs_pdu_t *pdu) { + + printf("\n"); + printf("bwpSize = %u\t", pdu->bwpSize); + printf("bwpStart = %u\t", pdu->bwpStart); + printf("subCarrierSpacing = %u\t", pdu->subCarrierSpacing); + printf("cyclicPrefix = %u\t", pdu->cyclicPrefix); + printf("startRb = %u\t", pdu->startRb); + printf("nrOfRbs = %u\t", pdu->nrOfRbs); + printf("csiType = %u\t", pdu->csiType); + printf("row = %u\t", pdu->row); + printf("freqDomain = %u\t", pdu->freqDomain); + printf("symbL0 = %u\t", pdu->symbL0); + printf("symbL1 = %u\t", pdu->symbL1); + printf("cdmType = %u\t", pdu->cdmType); + printf("freqDensity = %u\t", pdu->freqDensity); + printf("scramId = %u\t", pdu->scramId); + printf("powerControlOffset = %u\t", pdu->powerControlOffset); + printf("powerControlOffsetSs = %u\t", pdu->powerControlOffsetSs); + decode_fapi_precoding_bmform(&pdu->preCodingAndBeamforming); + +} + +void decode_fapi_dl_tti_req_pdu(fapi_dl_tti_req_pdu_t* dlTtiReqPdu) +{ + printf("\n"); + printf("pduType = %u\t", dlTtiReqPdu->pduType); + printf("pduSize = %u\t", dlTtiReqPdu->pduSize); + + switch (dlTtiReqPdu->pduType) { + case 0: // Example case for pdcch_pdu + printf("pdcch_pdu:\t"); + decode_fapi_dl_pdcch_pdu(&dlTtiReqPdu->pdu.pdcch_pdu); + break; + case 1: // Example case for pdsch_pdu + printf("pdsch_pdu:\t"); + decode_fapi_dl_pdsch_pdu(&dlTtiReqPdu->pdu.pdsch_pdu); + break; + case 2: // Example case for csi_rs_pdu + printf("csi_rs_pdu:\t"); + decode_fapi_dl_csi_rs_pdu(&dlTtiReqPdu->pdu.csi_rs_pdu); + break; + case 3: // Example case for ssb_pdu + printf("ssb_pdu:\t"); + decode_fapi_dl_ssb_pdu(&dlTtiReqPdu->pdu.ssb_pdu); + break; + default: + printf("Unknown PDU type\t"); + break; + } +} + +void decode_fapi_ue_info(fapi_ue_info_t* ueInfo) +{ + printf("\n"); + printf("nUe = %u\t", ueInfo->nUe); + printf("pduIdx = "); + for (size_t i = 0; i < sizeof(ueInfo->pduIdx); i++) { + printf("%u ", ueInfo->pduIdx[i]); + } +} + +void decode_fapi_dl_tti_req(fapi_dl_tti_req_t* dlTtiReq) +{ + printf("\n"); + printf("sfn = %u\t", dlTtiReq->sfn); + printf("slot = %u\t", dlTtiReq->slot); + printf("nPdus = %u\t", dlTtiReq->nPdus); + printf("nGroup = %u\t", dlTtiReq->nGroup); + + printf("pdus:\t"); + for (size_t i = 0; i < dlTtiReq->nPdus; i++) { + printf("PDUs[%zu]:\t", i); + decode_fapi_dl_tti_req_pdu(&dlTtiReq->pdus[i]); + } + + printf("ue_grp_info:\t"); + for (size_t i = 0; i < dlTtiReq->nGroup; i++) { + printf("UE Group Info[%zu]:\t", i); + decode_fapi_ue_info(&dlTtiReq->ue_grp_info[i]); + } +} + +void decode_fapi_pusch_data(fapi_pusch_data_t* puschData) +{ + printf("\n"); + printf("rvIndex = %u\t", puschData->rvIndex); + printf("harqProcessId = %u\t", puschData->harqProcessId); + printf("newDataIndicator = %u\t", puschData->newDataIndicator); + printf("tbSize = %u\t", puschData->tbSize); + printf("numCb = %u\t", puschData->numCb); + printf("cbPresentAndPosition = "); + for (size_t i = 0; i < sizeof(puschData->cbPresentAndPosition); i++) { + printf("%u ", puschData->cbPresentAndPosition[i]); + } +} + +void decode_fapi_pusch_uci(fapi_pusch_uci_t* puschUci) +{ + printf("\n"); + printf("harqAckBitLength = %u\t", puschUci->harqAckBitLength); + printf("csiPart1BitLength = %u\t", puschUci->csiPart1BitLength); + printf("csiPart2BitLength = %u\t", puschUci->csiPart2BitLength); + printf("alphaScaling = %u\t", puschUci->alphaScaling); + printf("betaOffsetHarqAck = %u\t", puschUci->betaOffsetHarqAck); + printf("betaOffsetCsi1 = %u\t", puschUci->betaOffsetCsi1); + printf("betaOffsetCsi2 = %u\t", puschUci->betaOffsetCsi2); +} + +void decode_fapi_ptrs_info(fapi_ptrs_info_t* ptrsInfo) +{ + printf("\n"); + printf("ptrsPortIndex = %u\t", ptrsInfo->ptrsPortIndex); + printf("ptrsDmrsPort = %u\t", ptrsInfo->ptrsDmrsPort); + printf("ptrsReOffset = %u\t", ptrsInfo->ptrsReOffset); +} + +void decode_fapi_pusch_ptrs(fapi_pusch_ptrs_t* puschPtrs) +{ + printf("\n"); + printf("numPtrsPorts = %u\t", puschPtrs->numPtrsPorts); + printf("ptrsTimeDensity = %u\t", puschPtrs->ptrsTimeDensity); + printf("ptrsFreqDensity = %u\t", puschPtrs->ptrsFreqDensity); + printf("ulPtrsPower = %u\t", puschPtrs->ulPtrsPower); + + printf("ptrsInfo:\t"); + for (uint8_t i = 0; i < puschPtrs->numPtrsPorts; i++) { + printf("PTRS Info[%d]:\t", i); + decode_fapi_ptrs_info(&puschPtrs->ptrsInfo[i]); + } +} +void decode_fapi_dfts_ofdm(fapi_dfts_ofdm_t* dftsOfdm) +{ + printf("\n"); + printf("lowPaprSequenceNumber = %u\t", dftsOfdm->lowPaprSequenceNumber); + printf("lowPaprGroupNumber = %u\t", dftsOfdm->lowPaprGroupNumber); + printf("ulPtrsSampleDensity = %u\t", dftsOfdm->ulPtrsSampleDensity); + printf("ulPtrsTimeDensityTransformPrecoding = %u\t", dftsOfdm->ulPtrsTimeDensityTransformPrecoding); +} + +void decode_fapi_rx_bfi(fapi_rx_bfi_t* rxBfi) +{ + printf("\n"); + printf("beamIdx:\t"); + for (size_t i = 0; i < FAPI_MAX_NUM_DIGBFINTERFACES; i++) { + printf("BeamIdx[%zu]:\t", i); + decode_fapi_bmi(&rxBfi->beamIdx[i]); + } +} + +void decode_fapi_ul_rx_bmform_pdu(fapi_ul_rx_bmform_pdu_t* ulRxBmformPdu) +{ + printf("\n"); + printf("numPrgs = %u\t", ulRxBmformPdu->numPrgs); + printf("prgSize = %u\t", ulRxBmformPdu->prgSize); + printf("digBfInterface = %u\t", ulRxBmformPdu->digBfInterface); + + printf("pad = ["); + for (size_t i = 0; i <3; i++) { + printf("%u ", ulRxBmformPdu->pad[i]); + } + printf("rx_bfi:\t"); + for (size_t i = 0; i < ulRxBmformPdu->numPrgs; i++) { + printf("RX BFI[%zu]:\t", i); + decode_fapi_rx_bfi(&ulRxBmformPdu->rx_bfi[i]); + } +} + +void decode_fapi_ul_prach_pdu(fapi_ul_prach_pdu_t ulPrachPdu) +{ + printf("\n"); + printf("physCellId = %u\t", ulPrachPdu.physCellId); + printf("numPrachOcas = %u\t", ulPrachPdu.numPrachOcas); + printf("prachFormat = %u\t", ulPrachPdu.prachFormat); + printf("numRa = %u\t", ulPrachPdu.numRa); + printf("prachStartSymbol = %u\t", ulPrachPdu.prachStartSymbol); + printf("numCs = %u\t", ulPrachPdu.numCs); + printf("beamforming:\t"); + decode_fapi_ul_rx_bmform_pdu(&ulPrachPdu.beamforming); +} + +void decode_fapi_ul_pusch_pdu(fapi_ul_pusch_pdu_t* ulPuschPdu) +{ + printf("\n"); + printf("pduBitMap = %u\t", ulPuschPdu->pduBitMap); + printf("rnti = %u\t", ulPuschPdu->rnti); + printf("handle = %u\t", ulPuschPdu->handle); + printf("bwpSize = %u\t", ulPuschPdu->bwpSize); + printf("bwpStart = %u\t", ulPuschPdu->bwpStart); + printf("subCarrierSpacing = %u\t", ulPuschPdu->subCarrierSpacing); + printf("cyclicPrefix = %u\t", ulPuschPdu->cyclicPrefix); + printf("mcsIndex = %u\t", ulPuschPdu->mcsIndex); + printf("mcsTable = %u\t", ulPuschPdu->mcsTable); + printf("targetCodeRate = %u\t", ulPuschPdu->targetCodeRate); + printf("qamModOrder = %u\t", ulPuschPdu->qamModOrder); + printf("transformPrecoding = %u\t", ulPuschPdu->transformPrecoding); + printf("dataScramblingId = %u\t", ulPuschPdu->dataScramblingId); + printf("nrOfLayers = %u\t", ulPuschPdu->nrOfLayers); + printf("dmrsConfigType = %u\t", ulPuschPdu->dmrsConfigType); + printf("ulDmrsSymbPos = %u\t", ulPuschPdu->ulDmrsSymbPos); + printf("ulDmrsScramblingId = %u\t", ulPuschPdu->ulDmrsScramblingId); + printf("scid = %u\t", ulPuschPdu->scid); + printf("numDmrsCdmGrpsNoData = %u\t", ulPuschPdu->numDmrsCdmGrpsNoData); + printf("dmrsPorts = %u\t", ulPuschPdu->dmrsPorts); + printf("nTpPuschId = %u\t", ulPuschPdu->nTpPuschId); + printf("tpPi2Bpsk = %u\t", ulPuschPdu->tpPi2Bpsk); + printf("rbBitmap = ["); + for (size_t i = 0; i < sizeof(ulPuschPdu->rbBitmap); i++) { + printf("%u ", ulPuschPdu->rbBitmap[i]); + } + printf("]\t"); + printf("rbStart = %u\t", ulPuschPdu->rbStart); + printf("rbSize = %u\t", ulPuschPdu->rbSize); + printf("vrbToPrbMapping = %u\t", ulPuschPdu->vrbToPrbMapping); + printf("frequencyHopping = %u\t", ulPuschPdu->frequencyHopping); + printf("txDirectCurrentLocation = %u\t", ulPuschPdu->txDirectCurrentLocation); + printf("resourceAlloc = %u\t", ulPuschPdu->resourceAlloc); + printf("uplinkFrequencyShift7p5khz = %u\t", ulPuschPdu->uplinkFrequencyShift7p5khz); + printf("startSymbIndex = %u\t", ulPuschPdu->startSymbIndex); + printf("nrOfSymbols = %u\t", ulPuschPdu->nrOfSymbols); + printf("mappingType = %u\t", ulPuschPdu->mappingType); + printf("nrOfDmrsSymbols = %u\t", ulPuschPdu->nrOfDmrsSymbols); + printf("dmrsAddPos = %u\t", ulPuschPdu->dmrsAddPos); + + // Check nested structures + printf("puschData:\t"); + decode_fapi_pusch_data(&ulPuschPdu->puschData); + printf("puschUci:\t"); + decode_fapi_pusch_uci(&ulPuschPdu->puschUci); + printf("puschPtrs:\t"); + decode_fapi_pusch_ptrs(&ulPuschPdu->puschPtrs); + printf("dftsOfdm:\t"); + decode_fapi_dfts_ofdm(&ulPuschPdu->dftsOfdm); + printf("beamforming:\t"); + decode_fapi_ul_rx_bmform_pdu(&ulPuschPdu->beamforming); +} + +void decode_fapi_ul_pucch_pdu(fapi_ul_pucch_pdu_t* ulPucchPdu) +{ + printf("\n"); + printf("rnti = %u\t", ulPucchPdu->rnti); + + printf("pad1 = ["); + for (size_t i = 0; i < sizeof(ulPucchPdu->pad1); i++) { + printf("%u ", ulPucchPdu->pad1[i]); + } + printf("]\t"); + + printf("handle = %u\t", ulPucchPdu->handle); + printf("bwpSize = %u\t", ulPucchPdu->bwpSize); + printf("bwpStart = %u\t", ulPucchPdu->bwpStart); + printf("subCarrierSpacing = %u\t", ulPucchPdu->subCarrierSpacing); + printf("cyclicPrefix = %u\t", ulPucchPdu->cyclicPrefix); + printf("formatType = %u\t", ulPucchPdu->formatType); + printf("multiSlotTxIndicator = %u\t", ulPucchPdu->multiSlotTxIndicator); + printf("pi2Bpsk = %u\t", ulPucchPdu->pi2Bpsk); + printf("pad2 = %u\t", ulPucchPdu->pad2); + printf("prbStart = %u\t", ulPucchPdu->prbStart); + printf("prbSize = %u\t", ulPucchPdu->prbSize); + printf("startSymbolIndex = %u\t", ulPucchPdu->startSymbolIndex); + printf("nrOfSymbols = %u\t", ulPucchPdu->nrOfSymbols); + printf("freqHopFlag = %u\t", ulPucchPdu->freqHopFlag); + printf("groupHopFlag = %u\t", ulPucchPdu->groupHopFlag); + printf("sequenceHopFlag = %u\t", ulPucchPdu->sequenceHopFlag); + printf("pad3 = %u\t", ulPucchPdu->pad3); + printf("secondHopPrb = %u\t", ulPucchPdu->secondHopPrb); + printf("hoppingId = %u\t", ulPucchPdu->hoppingId); + printf("initialCyclicShift = %u\t", ulPucchPdu->initialCyclicShift); + printf("dataScramblingId = %u\t", ulPucchPdu->dataScramblingId); + printf("timeDomainOccIdx = %u\t", ulPucchPdu->timeDomainOccIdx); + printf("preDftOccIdx = %u\t", ulPucchPdu->preDftOccIdx); + printf("preDftOccLen = %u\t", ulPucchPdu->preDftOccLen); + printf("addDmrsFlag = %u\t", ulPucchPdu->addDmrsFlag); + printf("dmrsScramblingId = %u\t", ulPucchPdu->dmrsScramblingId); + printf("dmrsCyclicShift = %u\t", ulPucchPdu->dmrsCyclicShift); + printf("srFlag = %u\t", ulPucchPdu->srFlag); + printf("bitLenHarq = %u\t", ulPucchPdu->bitLenHarq); + + printf("pad4 = ["); + for (size_t i = 0; i < sizeof(ulPucchPdu->pad4); i++) { + printf("%u ", ulPucchPdu->pad4[i]); + } + printf("]\t"); + + printf("bitLenCsiPart1 = %u\t", ulPucchPdu->bitLenCsiPart1); + printf("bitLenCsiPart2 = %u\t", ulPucchPdu->bitLenCsiPart2); + + // Check nested structure + printf("beamforming:\t"); + decode_fapi_ul_rx_bmform_pdu(&ulPucchPdu->beamforming); +} +// Function to print the structure members + +void decode_fapi_ul_srs_pdu(fapi_ul_srs_pdu_t* ulSrsPdu) +{ + printf("\n"); + printf("rnti = %u\t", ulSrsPdu->rnti); + printf("handle = %u\t", ulSrsPdu->handle); + printf("bwpSize = %u\t", ulSrsPdu->bwpSize); + printf("bwpStart = %u\t", ulSrsPdu->bwpStart); + printf("subCarrierSpacing = %u\t", ulSrsPdu->subCarrierSpacing); + printf("cyclicPrefix = %u\t", ulSrsPdu->cyclicPrefix); + printf("numAntPorts = %u\t", ulSrsPdu->numAntPorts); + printf("numSymbols = %u\t", ulSrsPdu->numSymbols); + printf("numRepetitions = %u\t", ulSrsPdu->numRepetitions); + printf("timeStartPosition = %u\t", ulSrsPdu->timeStartPosition); + printf("configIndex = %u\t", ulSrsPdu->configIndex); + printf("bandwidthIndex = %u\t", ulSrsPdu->bandwidthIndex); + printf("sequenceId = %u\t", ulSrsPdu->sequenceId); + printf("combSize = %u\t", ulSrsPdu->combSize); + printf("combOffset = %u\t", ulSrsPdu->combOffset); + printf("cyclicShift = %u\t", ulSrsPdu->cyclicShift); + printf("frequencyPosition = %u\t", ulSrsPdu->frequencyPosition); + printf("frequencyShift = %u\t", ulSrsPdu->frequencyShift); + printf("frequencyHopping = %u\t", ulSrsPdu->frequencyHopping); + printf("groupOrSequenceHopping = %u\t", ulSrsPdu->groupOrSequenceHopping); + printf("resourceType = %u\t", ulSrsPdu->resourceType); + printf("tSrs = %u\t", ulSrsPdu->tSrs); + printf("tOffset = %u\t", ulSrsPdu->tOffset); + decode_fapi_ul_rx_bmform_pdu(&ulSrsPdu->beamforming); +} + +void decode_fapi_ul_tti_req_pdu(fapi_ul_tti_req_pdu_t* ulTtiReqPdu) +{ + printf("\n"); + printf("pduType = %u\t", ulTtiReqPdu->pduType); + printf("pduSize = %u\t", ulTtiReqPdu->pduSize); + + // Check each PDU type + switch (ulTtiReqPdu->pduType) { + case 0: // PRACH + printf("PRACH PDU:\t"); + decode_fapi_ul_prach_pdu(ulTtiReqPdu->pdu.prach_pdu); + break; + case 1: // PUSCH + printf("PUSCH PDU:\t"); + decode_fapi_ul_pusch_pdu(&ulTtiReqPdu->pdu.pusch_pdu); + break; + case 2: // PUCCH + printf("PUCCH PDU:\t"); + decode_fapi_ul_pucch_pdu(&ulTtiReqPdu->pdu.pucch_pdu); + break; + case 3: // SRS + printf("SRS PDU:\t"); + decode_fapi_ul_srs_pdu(&ulTtiReqPdu->pdu.srs_pdu); + break; + default: + printf("ERROR: Unknown PDU type %u\t", ulTtiReqPdu->pduType); + } +} + +void decode_fapi_ul_tti_req(fapi_ul_tti_req_t* ulTtiReq) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("sfn = %u\t", ulTtiReq->sfn); + printf("slot = %u\t", ulTtiReq->slot); + printf("nPdus = %u\t", ulTtiReq->nPdus); + printf("rachPresent = %u\t", ulTtiReq->rachPresent); + printf("nUlsch = %u\t", ulTtiReq->nUlsch); + printf("nUlcch = %u\t", ulTtiReq->nUlcch); + printf("nGroup = %u\t", ulTtiReq->nGroup); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(ulTtiReq->pad); i++) { + printf("%u ", ulTtiReq->pad[i]); + } + printf("]\t"); + + printf("PDUs:\t"); + for (size_t i = 0; i < ulTtiReq->nPdus; i++) { + printf("PDU[%zu]:\t", i); + decode_fapi_ul_tti_req_pdu(&ulTtiReq->pdus[i]); + } + + printf("UE Group Info:\t"); + for (size_t i = 0; i < ulTtiReq->nGroup; i++) { + printf("UE Group Info[%zu]:\t", i); + decode_fapi_ue_info(&ulTtiReq->ueGrpInfo[i]); + } +} + +void decode_fapi_dci_pdu(fapi_dci_pdu_t* dciPdu) +{ + printf("\n"); + printf("pduType = %u\t", dciPdu->pduType); + printf("pduSize = %u\t", dciPdu->pduSize); + printf("pdcchPduConfig:\t"); + decode_fapi_dl_pdcch_pdu(&dciPdu->pdcchPduConfig); +} + +void decode_fapi_ul_dci_req(fapi_ul_dci_req_t* ulDciReq) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("sfn = %u\t", ulDciReq->sfn); + printf("slot = %u\t", ulDciReq->slot); + printf("numPdus = %u\t", ulDciReq->numPdus); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(ulDciReq->pad); i++) { + printf("%u ", ulDciReq->pad[i]); + } + printf("]\t"); + + printf("PDUs:\t"); + for (size_t i = 0; i < ulDciReq->numPdus; i++) { + printf("PDU[%zu]:\t", i); + decode_fapi_dci_pdu(&ulDciReq->pdus[i]); + } +} + +void decode_fapi_tx_pdu_desc(fapi_tx_pdu_desc_t* txPduDesc) +{ + printf("\n"); + printf("pdu_length = %u\t", txPduDesc->pdu_length); + printf("pdu_index = %u\t", txPduDesc->pdu_index); + printf("num_tlvs = %u\t", txPduDesc->num_tlvs); + + printf("TLVs:\t"); + for (size_t i = 0; i < txPduDesc->num_tlvs; i++) { + printf("TLV[%zu]: { /* Details omitted */ }\t", i); + } +} + +void decode_fapi_tx_data_req(fapi_tx_data_req_t* txDataReq) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("sfn = %u\t", txDataReq->sfn); + printf("slot = %u\t", txDataReq->slot); + printf("num_pdus = %u\t", txDataReq->num_pdus); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(txDataReq->pad); i++) { + printf("%u ", txDataReq->pad[i]); + } + printf("]\t"); + + printf("PDU Descriptions:\t"); + for (size_t i = 0; i < txDataReq->num_pdus; i++) { + printf("PDU Desc[%zu]:\t", i); + decode_fapi_tx_pdu_desc(&txDataReq->pdu_desc[i]); + } +} + +void decode_fapi_pdu_ind_info(fapi_pdu_ind_info_t* pduIndInfo) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("handle = %u\t", pduIndInfo->handle); + printf("rnti = %u\t", pduIndInfo->rnti); + printf("harqId = %u\t", pduIndInfo->harqId); + printf("ul_cqi = %u\t", pduIndInfo->ul_cqi); + printf("timingAdvance = %u\t", pduIndInfo->timingAdvance); + printf("rssi = %u\t", pduIndInfo->rssi); + printf("pdu_length = %u\t", pduIndInfo->pdu_length); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(pduIndInfo->pad); i++) { + printf("%u ", pduIndInfo->pad[i]); + } + printf("]\t"); + + // Note: pduData is a void pointer; you need to know its type to print or inspect its content + printf("pduData = %p\t", pduIndInfo->pduData); +} + +void decode_fapi_rx_data_indication(fapi_rx_data_indication_t* rxDataInd) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("header = { /* Details omitted */ }\t"); + printf("sfn = %u\t", rxDataInd->sfn); + printf("slot = %u\t", rxDataInd->slot); + printf("numPdus = %u\t", rxDataInd->numPdus); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(rxDataInd->pad); i++) { + printf("%u ", rxDataInd->pad[i]); + } + printf("]\t"); + + printf("PDU Indication Info:\t"); + for (size_t i = 0; i < rxDataInd->numPdus; i++) { + printf("PDU Ind[%zu]:\t", i); + decode_fapi_pdu_ind_info(&rxDataInd->pdus[i]); + } +} + +void decode_fapi_crc_ind_info(fapi_crc_ind_info_t* crcIndInfo) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("handle = %u\t", crcIndInfo->handle); + printf("rnti = %u\t", crcIndInfo->rnti); + printf("harqId = %u\t", crcIndInfo->harqId); + printf("tbCrcStatus = %u\t", crcIndInfo->tbCrcStatus); + printf("ul_cqi = %u\t", crcIndInfo->ul_cqi); + + printf("pad = %u\t", crcIndInfo->pad); + + printf("numCb = %u\t", crcIndInfo->numCb); + printf("timingAdvance = %u\t", crcIndInfo->timingAdvance); + printf("rssi = %u\t", crcIndInfo->rssi); + + printf("cbCrcStatus:\t"); + for (size_t i = 0; i < sizeof(crcIndInfo->cbCrcStatus); i++) { + printf("cbCrcStatus[%zu] = %u\t", i, crcIndInfo->cbCrcStatus[i]); + } +} + +void decode_fapi_crc_ind(fapi_crc_ind_t* crcInd) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("header = { /* Details omitted */ }\t"); + printf("sfn = %u\t", crcInd->sfn); + printf("slot = %u\t", crcInd->slot); + printf("numCrcs = %u\t", crcInd->numCrcs); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(crcInd->pad); i++) { + printf("%u ", crcInd->pad[i]); + } + printf("]\t"); + + printf("CRC Info:\t"); + for (size_t i = 0; i < crcInd->numCrcs; i++) { + printf("CRC[%zu]:\t", i); + decode_fapi_crc_ind_info(&crcInd->crc[i]); + } +} + +void decode_fapi_harq_info(fapi_harq_info_t* harqInfo) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("harqCrc = %u\t", harqInfo->harqCrc); + + printf("pad = %u\t", harqInfo->pad); + + printf("harqBitLen = %u\t", harqInfo->harqBitLen); + printf("harqPayload: "); + for (size_t i = 0; i < sizeof(harqInfo->harqPayload); i++) { + printf("%u ", harqInfo->harqPayload[i]); + } +} + +void decode_fapi_csi_p1_info(fapi_csi_p1_info_t* csiP1Info) +{ + + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("csiPart1Crc = %u\t", csiP1Info->csiPart1Crc); + printf("pad = %u\t", csiP1Info->pad); + printf("csiPart1BitLen = %u\t", csiP1Info->csiPart1BitLen); + printf("csiPart1Payload: "); + for (size_t i = 0; i < sizeof(csiP1Info->csiPart1Payload); i++) { + printf("%u ", csiP1Info->csiPart1Payload[i]); + } +} + +void decode_fapi_csi_p2_info(fapi_csi_p2_info_t* csiP2Info) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("csiPart2Crc = %u\t", csiP2Info->csiPart2Crc); + printf("pad = %u\t", csiP2Info->pad); + printf("csiPart2BitLen = %u\t", csiP2Info->csiPart2BitLen); + printf("csiPart2Payload: "); + for (size_t i = 0; i < sizeof(csiP2Info->csiPart2Payload); i++) { + printf("%u ", csiP2Info->csiPart2Payload[i]); + } +} + +void decode_fapi_uci_o_pusch(fapi_uci_o_pusch_t* uciO_pusch) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("handle = %u\t", uciO_pusch->handle); + printf("pduBitmap = %u\t", uciO_pusch->pduBitmap); + printf("ul_cqi = %u\t", uciO_pusch->ul_cqi); + printf("rnti = %u\t", uciO_pusch->rnti); + printf("timingAdvance = %u\t", uciO_pusch->timingAdvance); + printf("rssi = %u\t", uciO_pusch->rssi); + + // Print only if indicated by pduBitmap + if (uciO_pusch->pduBitmap & 0x01) { // Example check for HARQ info + printf("HARQ Info:\t"); + decode_fapi_harq_info(&uciO_pusch->harqInfo); + } + + if (uciO_pusch->pduBitmap & 0x02) { // Example check for CSI Part 1 info + printf("CSI Part 1 Info:\t"); + decode_fapi_csi_p1_info(&uciO_pusch->csiPart1info); + } + + if (uciO_pusch->pduBitmap & 0x04) { // Example check for CSI Part 2 info + printf("CSI Part 2 Info:\t"); + decode_fapi_csi_p2_info(&uciO_pusch->csiPart2info); + } +} + +void decode_fapi_sr_f0f1_info(fapi_sr_f0f1_info_t* srF0F1Info) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("srIndication = %u\t", srF0F1Info->srIndication); + printf("srConfidenceLevel = %u\t", srF0F1Info->srConfidenceLevel); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(srF0F1Info->pad); i++) { + printf("%u ", srF0F1Info->pad[i]); + } + printf("]\t"); +} + +void decode_fapi_harq_f0f1_info(fapi_harq_f0f1_info_t* harqF0F1Info) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("numHarq = %u\t", harqF0F1Info->numHarq); + printf("harqConfidenceLevel = %u\t", harqF0F1Info->harqConfidenceLevel); + printf("harqValue: "); + for (size_t i = 0; i < sizeof(harqF0F1Info->harqValue); i++) { + printf("%u ", harqF0F1Info->harqValue[i]); + } +} + +void decode_fapi_sr_f2f3f4_info(fapi_sr_f2f3f4_info_t* srF2F3F4Info) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("srBitlen = %u\t", srF2F3F4Info->srBitlen); + printf("srPayload: "); + for (size_t i = 0; i < sizeof(srF2F3F4Info->srPayload); i++) { + printf("%u ", srF2F3F4Info->srPayload[i]); + } +} + +void decode_fapi_harq_f2f3f4_info(fapi_harq_f2f3f4_info_t* harqF2F3F4Info) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("harqCrc = %u\t", harqF2F3F4Info->harqCrc); + printf("pad = %u\t", harqF2F3F4Info->pad); + printf("harqBitLen = %u\t", harqF2F3F4Info->harqBitLen); + printf("harqPayload: "); + for (size_t i = 0; i < sizeof(harqF2F3F4Info->harqPayload); i++) { + printf("%u ", harqF2F3F4Info->harqPayload[i]); + } +} + +void decode_fapi_uci_o_pucch_f2f3f4(fapi_uci_o_pucch_f2f3f4_t* uciO_pucch_f2f3f4) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("handle = %u\t", uciO_pucch_f2f3f4->handle); + printf("pduBitmap = %u\t", uciO_pucch_f2f3f4->pduBitmap); + printf("pucchFormat = %u\t", uciO_pucch_f2f3f4->pucchFormat); + printf("ul_cqi = %u\t", uciO_pucch_f2f3f4->ul_cqi); + printf("pad = %u\t", uciO_pucch_f2f3f4->pad); + printf("rnti = %u\t", uciO_pucch_f2f3f4->rnti); + printf("timingAdvance = %u\t", uciO_pucch_f2f3f4->timingAdvance); + printf("rssi = %u\t", uciO_pucch_f2f3f4->rssi); + printf("num_uci_bits = %u\t", uciO_pucch_f2f3f4->num_uci_bits); + printf("uciBits: "); + for (size_t i = 0; i < sizeof(uciO_pucch_f2f3f4->uciBits); i++) { + printf("%u ", uciO_pucch_f2f3f4->uciBits[i]); + } +} + +void decode_fapi_uci_o_pucch_f0f1(fapi_uci_o_pucch_f0f1_t* uciO_pucch_f0f1) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("handle = %u\t", uciO_pucch_f0f1->handle); + printf("pduBitmap = %u\t", uciO_pucch_f0f1->pduBitmap); + printf("pucchFormat = %u\t", uciO_pucch_f0f1->pucchFormat); + printf("ul_cqi = %u\t", uciO_pucch_f0f1->ul_cqi); + printf("pad = %u\t", uciO_pucch_f0f1->pad); + + printf("rnti = %u\t", uciO_pucch_f0f1->rnti); + printf("timingAdvance = %u\t", uciO_pucch_f0f1->timingAdvance); + printf("rssi = %u\t", uciO_pucch_f0f1->rssi); + + printf("pad1 = ["); + for (size_t i = 0; i < sizeof(uciO_pucch_f0f1->pad1); i++) { + printf("%u ", uciO_pucch_f0f1->pad1[i]); + } + printf("]\t"); + + printf("srInfo: \t"); + decode_fapi_sr_f0f1_info(&uciO_pucch_f0f1->srInfo); + + printf("harqInfo: \t"); + decode_fapi_harq_f0f1_info(&uciO_pucch_f0f1->harqInfo); +} + +void decode_fapi_uci_pdu_info(fapi_uci_pdu_info_t* uciPduInfo) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("pduType = %u\t", uciPduInfo->pduType); + printf("pduSize = %u\t", uciPduInfo->pduSize); + + switch (uciPduInfo->pduType) { + case 0: // Assuming 0 for uciPusch + printf("uciPusch: \t"); + decode_fapi_uci_o_pusch(&uciPduInfo->uci.uciPusch); + break; + case 1: // Assuming 1 for uciPucchF0F1 + printf("uciPucchF0F1: \t"); + decode_fapi_uci_o_pucch_f0f1(&uciPduInfo->uci.uciPucchF0F1); + break; + case 2: // Assuming 2 for uciPucchF2F3F4 + printf("uciPucchF2F3F4: \t"); + decode_fapi_uci_o_pucch_f2f3f4(&uciPduInfo->uci.uciPucchF2F3F4); + break; + default: + printf("Unknown pduType = %u\t", uciPduInfo->pduType); + break; + } +} + +void decode_fapi_uci_indication(fapi_uci_indication_t* uciIndication) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("sfn = %u\t", uciIndication->sfn); + printf("slot = %u\t", uciIndication->slot); + printf("numUcis = %u\t", uciIndication->numUcis); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(uciIndication->pad); i++) { + printf("%u ", uciIndication->pad[i]); + } + printf("]\t"); + + for (size_t i = 0; i < uciIndication->numUcis; i++) { + printf("uciPdu[%zu]: \t", i); + decode_fapi_uci_pdu_info(&uciIndication->uciPdu[i]); + } +} + +void decode_fapi_symb_snr(fapi_symb_snr_t* symbSnr) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("numRbs = %u\t", symbSnr->numRbs); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(symbSnr->pad); i++) { + printf("%u ", symbSnr->pad[i]); + } + printf("]\t"); + + printf("rbSNR: "); + for (size_t i = 0; i < sizeof(symbSnr->rbSNR); i++) { + printf("%u ", symbSnr->rbSNR[i]); + } +} + +void decode_fapi_srs_pdu(fapi_srs_pdu_t* srsPdu) +{ + printf("\n"); + printf("header = { /* Details omitted */ }\t"); + printf("handle = %u\t", srsPdu->handle); + printf("rnti = %u\t", srsPdu->rnti); + printf("timingAdvance = %u\t", srsPdu->timingAdvance); + printf("numSymbols = %u\t", srsPdu->numSymbols); + printf("wideBandSnr = %u\t", srsPdu->wideBandSnr); + printf("numReportedSymbols = %u\t", srsPdu->numReportedSymbols); + printf("pad = %u\t", srsPdu->pad); + for (size_t i = 0; i < srsPdu->numReportedSymbols; i++) { + printf("symbSnr[%zu]: \t", i); + decode_fapi_symb_snr(&srsPdu->symbSnr[i]); + } +} + +void decode_fapi_srs_indication(fapi_srs_indication_t* srsIndication) +{ + printf("\n"); + printf("sfn = %u\t", srsIndication->sfn); + printf("slot = %u\t", srsIndication->slot); + printf("numPdus = %u\t", srsIndication->numPdus); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(srsIndication->pad); i++) { + printf("%u ", srsIndication->pad[i]); + } + printf("]\t"); + + for (size_t i = 0; i < srsIndication->numPdus; i++) { + printf("srsPdus[%zu]: \t", i); + decode_fapi_srs_pdu(&srsIndication->srsPdus[i]); + } +} + +void decode_fapi_preamble_info(fapi_preamble_info_t* preambleInfo) +{ + printf("\n"); + printf("preambleIndex = %u\t", preambleInfo->preambleIndex); + printf("pad = %u\t", preambleInfo->pad); + printf("timingAdvance = %u\t", preambleInfo->timingAdvance); + printf("preamblePwr = %u\t", preambleInfo->preamblePwr); +} + +void decode_fapi_rach_pdu(fapi_rach_pdu_t* rachPdu) +{ + printf("\n"); + printf("phyCellId = %u\t", rachPdu->phyCellId); + printf("symbolIndex = %u\t", rachPdu->symbolIndex); + printf("slotIndex = %u\t", rachPdu->slotIndex); + printf("freqIndex = %u\t", rachPdu->freqIndex); + printf("avgRssi = %u\t", rachPdu->avgRssi); + printf("avgSnr = %u\t", rachPdu->avgSnr); + printf("numPreamble = %u\t", rachPdu->numPreamble); + + for (size_t i = 0; i < rachPdu->numPreamble; i++) { + printf("preambleInfo[%zu]: \t", i); + decode_fapi_preamble_info(&rachPdu->preambleInfo[i]); + } +} + +void decode_fapi_rach_indication(fapi_rach_indication_t* rachIndication) +{ + printf("\n"); + printf("sfn = %u\t", rachIndication->sfn); + printf("slot = %u\t", rachIndication->slot); + printf("numPdus = %u\t", rachIndication->numPdus); + + printf("pad = ["); + for (size_t i = 0; i < sizeof(rachIndication->pad); i++) { + printf("%u ", rachIndication->pad[i]); + } + printf("]\t"); + + for (size_t i = 0; i < rachIndication->numPdus; i++) { + printf("rachPdu[%zu]: \t", i); + decode_fapi_rach_pdu(&rachIndication->rachPdu[i]); + } +} diff --git a/tools/Fapi_Decoder/fapi_vendor_extension.c b/tools/Fapi_Decoder/fapi_vendor_extension.c new file mode 100644 index 000000000..97b3bffc5 --- /dev/null +++ b/tools/Fapi_Decoder/fapi_vendor_extension.c @@ -0,0 +1,625 @@ +#include +#include +#include +#include +#include +#include +#include "../../src/intel_fapi/fapi_interface.h" +#include "../../src/intel_fapi/fapi_vendor_extension.h" +#include "../../src/intel_fapi/nfapi_interface.h" +#include "../../src/intel_fapi/nr5g_fapi_common_types.h" +#include "../../src/intel_fapi/nr5g_fapi_internal.h" +#include "fapi_interface.c" + +void decode_fapi_api_queue_elem_t( fapi_api_queue_elem_t* elem) +{ + if (elem == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_api_queue_elem_t \t"); + printf("msg_type= %u\t", elem->msg_type); + printf("num_message_in_block= %u\t", elem->num_message_in_block); + printf("msg_len= %u\t", elem->msg_len); + printf("align_offset = %u\t", elem->align_offset); + printf("time_stamp= %llu\t", elem->time_stamp); + printf("\n"); +} + +void decode_fapi_config_req_vendor_msg_t( fapi_config_req_vendor_msg_t* config_req) +{ + if (config_req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_config_req_vendor_msg_t \t"); + printf("hopping_id= %u\t", config_req->hopping_id); + printf("carrier_aggregation_level= %u\t", config_req->carrier_aggregation_level); + printf("group_hop_flag= %u\t", config_req->group_hop_flag); + printf("sequence_hop_flag= %u\t", config_req->sequence_hop_flag); + printf("prach_nr_of_rx_ru= %u\t", config_req->prach_nr_of_rx_ru); + printf("nr_of_dl_ports= %u\t", config_req->nr_of_dl_ports); + printf("nr_of_ul_ports= %u\t", config_req->nr_of_ul_ports); + printf("urllc_capable= %u\t", config_req->urllc_capable); + printf("urllc_mini_slot_mask= %u\t", config_req->urllc_mini_slot_mask); + printf("ssb_subc_spacing= %u\t", config_req->ssb_subc_spacing); + printf("use_vendor_EpreXSSB= %u\t", config_req->use_vendor_EpreXSSB); + printf("pad= %u %u\t", config_req->pad[0], config_req->pad[1]); + printf("\n"); +} + +void decode_fapi_start_req_vendor_msg_t( fapi_start_req_vendor_msg_t* start_req) +{ + if (start_req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_start_req_vendor_msg_t \t"); + printf("sfn= %u\t", start_req->sfn); + printf("slot = %u\t", start_req->slot); + printf("mode= %u\t", start_req->mode); +#ifdef DEBUG_MODE + printf("count = %u\t", start_req->count); + printf("period= %u\t", start_req->period); +#endif + printf("\n"); +} + +void decode_fapi_stop_req_vendor_msg_t( fapi_stop_req_vendor_msg_t* stop_req) +{ + if (stop_req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_stop_req_vendor_msg_t \t"); + printf("sfn= %u\t", stop_req->sfn); + printf("slot = %u\t", stop_req->slot); + printf("\n"); +} + +void decode_fapi_vendor_ul_pusch_pdu_t( fapi_vendor_ul_pusch_pdu_t* pusch_pdu) +{ + if (pusch_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ul_pusch_pdu_t \t"); + printf("nr_of_antenna_ports= %u\t", pusch_pdu->nr_of_antenna_ports); + printf("nr_of_rx_ru= %u\t", pusch_pdu->nr_of_rx_ru); + printf("pad= %u %u\t", pusch_pdu->pad[0], pusch_pdu->pad[1]); + printf("rx_ru_idx = "); + for (int i = 0; i < pusch_pdu->nr_of_rx_ru; ++i) { + printf("%u ", pusch_pdu->rx_ru_idx[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_ul_pucch_pdu_t( fapi_vendor_ul_pucch_pdu_t* pucch_pdu) +{ + if (pucch_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ul_pucch_pdu_t \t"); + printf("nr_of_rx_ru= %u\t", pucch_pdu->nr_of_rx_ru); + printf("pad= %u\t", pucch_pdu->pad[0]); + printf("group_id= %u\t", pucch_pdu->group_id); + printf("rx_ru_idx = "); + for (int i = 0; i < pucch_pdu->nr_of_rx_ru; ++i) { + printf("%u ", pucch_pdu->rx_ru_idx[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_ul_srs_pdu_t( fapi_vendor_ul_srs_pdu_t* srs_pdu) +{ + if (srs_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ul_srs_pdu_t \t"); + printf("nr_of_rx_ru= %u\t", srs_pdu->nr_of_rx_ru); + printf("pad= %u %u %u\t", srs_pdu->pad[0], srs_pdu->pad[1], srs_pdu->pad[2]); + printf("rx_ru_idx = "); + for (int i = 0; i < srs_pdu->nr_of_rx_ru; ++i) { + printf("%u ", srs_pdu->rx_ru_idx[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_ul_tti_req_pdu_t( fapi_vendor_ul_tti_req_pdu_t* ul_tti_req_pdu) +{ + if (ul_tti_req_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ul_tti_req_pdu_t \t"); + printf("pdu_type= %u\t", ul_tti_req_pdu->pdu_type); + printf("pad= %u\t", ul_tti_req_pdu->pad); + switch (ul_tti_req_pdu->pdu_type) + { + case FAPI_PUSCH_PDU_TYPE: + printf("pusch_pdu\n"); + decode_fapi_vendor_ul_pusch_pdu_t(&ul_tti_req_pdu->pdu.pusch_pdu); + break; + case FAPI_PUCCH_PDU_TYPE: + printf("pucch_pdu\n"); + decode_fapi_vendor_ul_pucch_pdu_t(&ul_tti_req_pdu->pdu.pucch_pdu); + break; + case FAPI_SRS_PDU_TYPE: + printf("srs_pdu\n"); + decode_fapi_vendor_ul_srs_pdu_t(&ul_tti_req_pdu->pdu.srs_pdu); + break; + default: + printf("Unknown PDU type\n"); + break; + } + printf("\n"); +} + +void decode_fapi_vendor_ul_tti_req_t( fapi_vendor_ul_tti_req_t* ul_tti_req) +{ + if (ul_tti_req == NULL) + { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ul_tti_req_t \t"); + printf("sym= %u\t", ul_tti_req->sym); + printf("num_ul_pdu= %u\t", ul_tti_req->num_ul_pdu); + printf("pad= %u %u %u\t", ul_tti_req->pad[0], ul_tti_req->pad[1], ul_tti_req->pad[2]); + + for (int i = 0; i < ul_tti_req->num_ul_pdu; ++i) + { + printf("ul_pdus[%d]:\n", i); + decode_fapi_vendor_ul_tti_req_pdu_t(&ul_tti_req->ul_pdus[i]); + } + printf("\n"); +} + + +void decode_fapi_vendor_dl_dci_t( fapi_vendor_dl_dci_t* dl_dci) +{ + if (dl_dci == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_dl_dci_t \t"); + printf("epre_ratio_of_pdcch_to_ssb= %u\t", dl_dci->epre_ratio_of_pdcch_to_ssb); + printf("epre_ratio_of_dmrs_to_ssb= %u\t", dl_dci->epre_ratio_of_dmrs_to_ssb); + printf("\n"); +} + +void decode_fapi_vendor_dl_pdcch_pdu_t( fapi_vendor_dl_pdcch_pdu_t* dl_pdcch_pdu) { + if (dl_pdcch_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_dl_pdcch_pdu_t \t"); + printf("num_dl_dci= %u\t", dl_pdcch_pdu->num_dl_dci); + printf("pad= %u %u\t", dl_pdcch_pdu->pad[0], dl_pdcch_pdu->pad[1]); + + for (int i = 0; i < dl_pdcch_pdu->num_dl_dci; ++i) { + printf("dl_dci[%d]:\n", i); + decode_fapi_vendor_dl_dci_t(&dl_pdcch_pdu->dl_dci[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_dl_pdsch_pdu_t( fapi_vendor_dl_pdsch_pdu_t* pdsch_pdu) { + if (pdsch_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_dl_pdsch_pdu_t \t"); + printf("epre_ratio_of_pdsch_to_ssb= %u\t", pdsch_pdu->epre_ratio_of_pdsch_to_ssb); + printf("epre_ratio_of_dmrs_to_ssb= %u\t", pdsch_pdu->epre_ratio_of_dmrs_to_ssb); + printf("nr_of_antenna_ports= %u\t", pdsch_pdu->nr_of_antenna_ports); + printf("pad= %u %u %u\t", pdsch_pdu->pad[0], pdsch_pdu->pad[1], pdsch_pdu->pad[2]); + printf("tx_ru_idx = "); + for (int i = 0; i < FAPI_VENDOR_MAX_TXRU_NUM; ++i) { + printf("%u ", pdsch_pdu->tx_ru_idx[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_csi_rs_pdu_t( fapi_vendor_csi_rs_pdu_t* csi_rs_pdu) { + if (csi_rs_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_csi_rs_pdu_t \t"); + printf("epre_ratio_to_ssb= %u\t", csi_rs_pdu->epre_ratio_to_ssb); + printf("pad= %u %u\t", csi_rs_pdu->pad[0], csi_rs_pdu->pad[1]); + printf("\n"); +} + +void decode_fapi_vendor_dl_tti_req_pdu_t( fapi_vendor_dl_tti_req_pdu_t* dl_tti_req_pdu) { + if (dl_tti_req_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_dl_tti_req_pdu_t \t"); + printf("pdu_type= %u\t", dl_tti_req_pdu->pdu_type); + printf("pdu_size= %u\t", dl_tti_req_pdu->pdu_size); + switch (dl_tti_req_pdu->pdu_type) + { + case FAPI_PDCCH_PDU_TYPE: + printf("pdcch_pdu:\n"); + decode_fapi_vendor_dl_pdcch_pdu_t(&dl_tti_req_pdu->pdu.pdcch_pdu); + break; + case FAPI_PDSCH_PDU_TYPE: + printf("pdsch_pdu:\n"); + decode_fapi_vendor_dl_pdsch_pdu_t(&dl_tti_req_pdu->pdu.pdsch_pdu); + break; + case FAPI_CSIRS_PDU_TYPE: + printf("csi_rs_pdu:\n"); + decode_fapi_vendor_csi_rs_pdu_t(&dl_tti_req_pdu->pdu.csi_rs_pdu); + break; + default : + printf("Unknown PDU type\n"); + break; + } + printf("\n"); +} + +void decode_fapi_vendor_dl_tti_req_t( fapi_vendor_dl_tti_req_t* dl_tti_req) { + if (dl_tti_req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_dl_tti_req_t \t"); + printf("sym= %u\t", dl_tti_req->sym); + printf("lte_crs_carrier_freq_dl= %u\t", dl_tti_req->lte_crs_carrier_freq_dl); + printf("lte_crs_present = %u\t", dl_tti_req->lte_crs_present); + printf("lte_crs_carrier_bandwidth_dl= %u\t", dl_tti_req->lte_crs_carrier_bandwidth_dl); + printf("lte_crs_nr_of_crs_ports= %u\t", dl_tti_req->lte_crs_nr_of_crs_ports); + printf("lte_crs_v_shift = %u\t", dl_tti_req->lte_crs_v_shift); + printf("pdcch_precoder_en= %u\t", dl_tti_req->pdcch_precoder_en); + printf("ssb_precoder_en= %u\t", dl_tti_req->ssb_precoder_en); + printf("num_pdus= %u\t", dl_tti_req->num_pdus); + printf("pad= %u %u %u\t", dl_tti_req->pad[0], dl_tti_req->pad[1], dl_tti_req->pad[2]); + + for (int i = 0; i < dl_tti_req->num_pdus; ++i) { + printf("pdus[%d]:\t", i); + decode_fapi_vendor_dl_tti_req_pdu_t(&dl_tti_req->pdus[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_dci_pdu_t( fapi_vendor_dci_pdu_t* dci_pdu) { + if (dci_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_dci_pdu_t \t"); + printf("pdu_type= %u\t", dci_pdu->pdu_type); + printf("pdu_size= %u\t", dci_pdu->pdu_size); + printf("pdcch_pdu_config:\n"); + decode_fapi_vendor_dl_pdcch_pdu_t(&dci_pdu->pdcch_pdu_config); + printf("\n"); +} + +void decode_fapi_vendor_ul_dci_req_t( fapi_vendor_ul_dci_req_t* ul_dci_req) { + if (ul_dci_req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ul_dci_req_t \t"); + printf("sym= %u\t", ul_dci_req->sym); + printf("num_pdus= %u\t", ul_dci_req->num_pdus); + printf("pad= %u %u %u\t", ul_dci_req->pad[0], ul_dci_req->pad[1], ul_dci_req->pad[2]); + + for (int i = 0; i < ul_dci_req->num_pdus; ++i) { + printf("pdus[%d]:\n", i); + decode_fapi_vendor_dci_pdu_t(&ul_dci_req->pdus[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_tx_data_req_t( fapi_vendor_tx_data_req_t* tx_data_req) { + if (tx_data_req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_tx_data_req_t \t"); + printf("sym= %u\t", tx_data_req->sym); + printf("\n"); +} + +void decode_fapi_vendor_p7_msg_t( fapi_vendor_p7_msg_t* p7_msg) { + if (p7_msg == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_p7_msg_t \n"); + decode_fapi_vendor_dl_tti_req_t(&p7_msg->dl_tti_req); + decode_fapi_vendor_ul_tti_req_t(&p7_msg->ul_tti_req); + decode_fapi_vendor_ul_dci_req_t(&p7_msg->ul_dci_req); + decode_fapi_vendor_tx_data_req_t(&p7_msg->tx_data_req); + printf("\n"); +} + +void decode_fapi_vendor_msg_t( fapi_vendor_msg_t* vendor_msg) { + if (vendor_msg == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_msg_t \n"); + printf("header:\n"); + decode_fapi_msg(&vendor_msg->header); + decode_fapi_config_req_vendor_msg_t(&vendor_msg->config_req_vendor); + decode_fapi_start_req_vendor_msg_t(&vendor_msg->start_req_vendor); + decode_fapi_stop_req_vendor_msg_t(&vendor_msg->stop_req_vendor); + decode_fapi_vendor_p7_msg_t(&vendor_msg->p7_req_vendor); + printf("\n"); +} + +void decode_fapi_vendor_ext_shutdown_req_t( fapi_vendor_ext_shutdown_req_t* shutdown_req) { + if (shutdown_req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_shutdown_req_t \t"); + printf("sfn= %u\t", shutdown_req->sfn); + printf("slot = %u\t", shutdown_req->slot); + printf("test_type= %u\t", shutdown_req->test_type); + printf("\n"); +} + +void decode_fapi_vendor_ext_shutdown_res_t( fapi_vendor_ext_shutdown_res_t* shutdown_res) { + if (shutdown_res == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_shutdown_res_t \t"); + printf("sfn= %u\t", shutdown_res->sfn); + printf("slot = %u\t", shutdown_res->slot); + printf("nStatus= %u\t", shutdown_res->nStatus); + printf("\n"); +} + +void decode_fapi_vendor_ext_snr_t( fapi_vendor_ext_snr_t* snr) { + if (snr == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_snr_t \t"); + for (int i = 0; i < MAX_SNR_COUNT; ++i) { + printf("nSNR[%d]= %d\t", i, snr->nSNR[i]); + } + printf("pad= %d\t", snr->pad); + printf("\n"); +} + +void decode_fapi_vendor_ext_srs_pdu_t( fapi_vendor_ext_srs_pdu_t* srs_pdu) { + if (srs_pdu == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_srs_pdu_t \t"); + printf("nr_of_port = %u\t", srs_pdu->nr_of_port); + printf("nr_of_rx_ant = %u\t", srs_pdu->nr_of_rx_ant); + printf("nr_of_rbs= %u\t", srs_pdu->nr_of_rbs); + printf("is_chan_est_pres= %u\t", srs_pdu->is_chan_est_pres); + printf("pad= %u %u %u\t", srs_pdu->pad[0], srs_pdu->pad[1], srs_pdu->pad[2]); + + for (int i = 0; i < srs_pdu->nr_of_port; ++i) { + for (int j = 0; j < srs_pdu->nr_of_rx_ant; ++j) { + printf("p_srs_chan_est[%d][%d]= %d\t", i, j, srs_pdu->p_srs_chan_est[i][j]); + } + } + printf("\n"); +} + +void decode_fapi_vendor_ext_srs_ind_t( fapi_vendor_ext_srs_ind_t* srs_ind) { + if (srs_ind == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_srs_ind_t \t"); + printf("num_pdus= %u\t", srs_ind->num_pdus); + printf("pad= %u %u %u\t", srs_ind->pad[0], srs_ind->pad[1], srs_ind->pad[2]); + + for (int i = 0; i < srs_ind->num_pdus; ++i) { + printf("srs_pdus[%d]:\n", i); + decode_fapi_vendor_ext_srs_pdu_t(&srs_ind->srs_pdus[i]); + } + printf("\n"); +} + +void decode_fapi_vendor_ext_slot_ind_t( fapi_vendor_ext_slot_ind_t* slot_ind) { + if (slot_ind == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_slot_ind_t \t"); + printf("carrier_idx= %u\t", slot_ind->carrier_idx); + printf("sym= %u\t", slot_ind->sym); + printf("\n"); +} + +void decode_fapi_vendor_ext_rx_data_ind_t( fapi_vendor_ext_rx_data_ind_t* rx_data_ind) { + if (rx_data_ind == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_rx_data_ind_t \t"); + printf("carrier_idx= %u\t", rx_data_ind->carrier_idx); + printf("sym= %u\t", rx_data_ind->sym); + printf("\n"); +} + +void decode_fapi_vendor_ext_crc_ind_t( fapi_vendor_ext_crc_ind_t* crc_ind) { + if (crc_ind == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_crc_ind_t \t"); + printf("carrier_idx= %u\t", crc_ind->carrier_idx); + printf("sym= %u\t", crc_ind->sym); + printf("\n"); +} + +void decode_fapi_vendor_ext_uci_ind_t( fapi_vendor_ext_uci_ind_t* uci_ind) { + if (uci_ind == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_uci_ind_t \t"); + printf("carrier_idx= %u\t", uci_ind->carrier_idx); + printf("sym= %u\t", uci_ind->sym); + printf("\n"); +} + +void decode_fapi_vendor_p7_ind_msg_t(fapi_vendor_p7_ind_msg_t* msg) +{ + if (msg== NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_p7_ind_msg_t \n"); + decode_fapi_msg(&msg->header); + decode_fapi_vendor_ext_snr_t(&msg->crc_snr); + decode_fapi_vendor_ext_snr_t(&msg->uci_snr); + decode_fapi_vendor_ext_srs_ind_t(&msg->srs_ind); + decode_fapi_vendor_ext_slot_ind_t(&msg->slot_ind); + decode_fapi_vendor_ext_rx_data_ind_t(&msg->rx_data_ind); + decode_fapi_vendor_ext_crc_ind_t(&msg->crc_ind); + decode_fapi_vendor_ext_uci_ind_t(&msg->uci_ind); + +} + +#ifdef DEBUG_MODE +void decode_fapi_vendor_ext_iq_samples_info_t( fapi_vendor_ext_iq_samples_info_t* iq_samples_info) { + if (iq_samples_info == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_iq_samples_info_t \n"); + printf("carrNum= %u\n", iq_samples_info->carrNum); + printf("numSubframes= %u\n", iq_samples_info->numSubframes); + printf("nIsRadioMode= %u\n", iq_samples_info->nIsRadioMode); + printf("timerModeFreqDomain= %u\n", iq_samples_info->timerModeFreqDomain); + printf("phaseCompensationEnable= %u\n", iq_samples_info->phaseCompensationEnable); + printf("startFrameNum= %u\n", iq_samples_info->startFrameNum); + printf("startSlotNum= %u\n", iq_samples_info->startSlotNum); + printf("startSymNum= %u\n", iq_samples_info->startSymNum); + + printf("filename_in_ul_iq:\n"); + for (int i = 0; i < FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS; ++i) { + printf(" [%d]= %s\n", i, iq_samples_info->filename_in_ul_iq[i]); + } + + printf("filename_in_ul_iq_compressed:\n"); + for (int i = 0; i < FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS; ++i) { + printf(" [%d]= %s\n", i, iq_samples_info->filename_in_ul_iq_compressed[i]); + } + + printf("filename_in_prach_iq:\n"); + for (int i = 0; i < FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS; ++i) { + printf(" [%d]= %s\n", i, iq_samples_info->filename_in_prach_iq[i]); + } + + printf("filename_in_srs_iq:\n"); + for (int i = 0; i < FAPI_MAX_IQ_SAMPLE_UL_ANTENNA; ++i) { + printf(" [%d]= %s\n", i, iq_samples_info->filename_in_srs_iq[i]); + } + + printf("filename_out_dl_iq= %s\n", iq_samples_info->filename_out_dl_iq); + + printf("filename_out_dl_beam:\n"); + for (int i = 0; i < FAPI_MAX_IQ_SAMPLE_DL_PORTS; ++i) { + printf(" [%d]= %s\n", i, iq_samples_info->filename_out_dl_beam[i]); + } + + printf("filename_out_ul_beam:\n"); + for (int i = 0; i < FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS; ++i) { + printf(" [%d]= %s\n", i, iq_samples_info->filename_out_ul_beam[i]); + } + + printf("filename_out_dl_iq_compressed= %s\n", iq_samples_info->filename_out_dl_iq_compressed); + + printf("nDLCompressionIdx= %u\n", iq_samples_info->nDLCompressionIdx); + printf("nDLCompiqWidth= %u\n", iq_samples_info->nDLCompiqWidth); + printf("nDLCompScaleFactor= %u\n", iq_samples_info->nDLCompScaleFactor); + printf("nDLCompreMask= %u\n", iq_samples_info->nDLCompreMask); + + printf("nULDecompressionIdx= %u\n", iq_samples_info->nULDecompressionIdx); + printf("nULDecompiqWidth= %u\n", iq_samples_info->nULDecompiqWidth); + + printf("buffer size= %lu\n", sizeof(iq_samples_info->buffer)); +} + +void decode_fapi_vendor_ext_iq_samples_req_t( fapi_vendor_ext_iq_samples_req_t* req) { + if (req == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_iq_samples_req_t \n"); + decode_fapi_msg(&req->header); + decode_fapi_vendor_ext_iq_samples_info_t(&req->iq_samples_info); +} + +void decode_fapi_vendor_ext_dl_iq_samples_res_t( fapi_vendor_ext_dl_iq_samples_res_t* res) { + if (res == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_dl_iq_samples_res_t \n"); + decode_fapi_msg(&res->header); +} + +void decode_fapi_vendor_ext_ul_iq_samples_res_t( fapi_vendor_ext_ul_iq_samples_res_t* res) +{ + if (res == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_ul_iq_samples_res_t \n"); + decode_fapi_msg(&res->header); +} + +void decode_fapi_vendor_ext_start_response_t( fapi_vendor_ext_start_response_t* res) +{ + if (res == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_start_response_t \n"); + decode_fapi_msg(&res->header); +} + +void decode_fapi_vendor_ext_add_remove_core_info_t( fapi_vendor_ext_add_remove_core_info_t* info) +{ + if (info == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_add_remove_core_info_t \n"); + printf("eOption= %u\n", info->eOption); + + printf("nCoreMask:\n"); + for (int i = 0; i < FAPI_MAX_MASK_OPTIONS; ++i) { + for (int j = 0; j < FAPI_MAX_NUM_SET_CORE_MASK; ++j) { + printf(" [%d][%d]= %llu\n", i, j, info->nCoreMask[i][j]); + } + } + + printf("nMacOptions:\n"); + for (int i = 0; i < FAPI_NUM_SPLIT_OPTIONS; ++i) { + printf(" [%d]= %u\n", i, info->nMacOptions[i]); + } +} + +void decode_fapi_vendor_ext_add_remove_core_msg_t( fapi_vendor_ext_add_remove_core_msg_t* msg) +{ + if (msg == NULL) { + printf("Error == Null pointer received.\n"); + return; + } + printf("fapi_vendor_ext_add_remove_core_msg_t \n"); + decode_fapi_msg(&msg->header); + decode_fapi_vendor_ext_add_remove_core_info_t(&msg->add_remove_core_info); +} +#endif diff --git a/tools/Fapi_Decoder/nr5g_fapi_internal.c b/tools/Fapi_Decoder/nr5g_fapi_internal.c new file mode 100644 index 000000000..7018bd35a --- /dev/null +++ b/tools/Fapi_Decoder/nr5g_fapi_internal.c @@ -0,0 +1,123 @@ + +#include +#include +#include +#include +#include +#include +#include "../../src/intel_fapi/fapi_interface.h" +#include "../../src/intel_fapi/fapi_vendor_extension.h" +#include "../../src/intel_fapi/nfapi_interface.h" +#include "../../src/intel_fapi/nr5g_fapi_common_types.h" +#include "../../src/intel_fapi/nr5g_fapi_internal.h" + +void decode_fapiSupport_t(fapiSupport_t support) +{ + printf("\n"); + switch (support) + { + case FAPI_NOT_SUPPORTED: + printf("FAPI_NOT_SUPPORTED\t"); + break; + case FAPI_SUPPORTED: + printf("FAPI_SUPPORTED\t"); + break; + default: + printf("Unknown fapiSupport_t value\t"); + } +} + +void decode_fapiTlvStatus_t(fapiTlvStatus_t status) +{ + printf("\n"); + switch (status) + { + case FAPI_IDLE_STATE_ONLY_OPTIONAL: + printf("FAPI_IDLE_STATE_ONLY_OPTIONAL\t"); + break; + case FAPI_IDLE_STATE_ONLY_MANDATORY: + printf("FAPI_IDLE_STATE_ONLY_MANDATORY\t"); + break; + case FAPI_IDLE_AND_CONFIGURED_STATES_OPTIONAL: + printf("FAPI_IDLE_AND_CONFIGURED_STATES_OPTIONAL\t"); + break; + case FAPI_IDLE_STATE_MANDATORY_CONFIGURED_STATE_OPTIONAL: + printf("FAPI_IDLE_STATE_MANDATORY_CONFIGURED_STATE_OPTIONAL\t"); + break; + case FAPI_IDLE_CONFIGURED_AND_RUNNING_STATES_OPTIONAL: + printf("FAPI_IDLE_CONFIGURED_AND_RUNNING_STATES_OPTIONAL\t"); + break; + case FAPI_IDLE_STATE_MANDATORY_CONFIGURED_AND_RUNNING_STATES_OPTIONAL: + printf("FAPI_IDLE_STATE_MANDATORY_CONFIGURED_AND_RUNNING_STATES_OPTIONAL\t"); + break; + default: + printf("Unknown fapiTlvStatus_t value\t"); + } +} + +void decode_fapiModOrder_t(fapiModOrder_t modOrder) +{ + printf("\n"); + switch (modOrder) + { + case FAPI_QPSK: + printf("FAPI_QPSK\t"); + break; + case FAPI_16QAM: + printf("FAPI_16QAM\t"); + break; + case FAPI_64QAM: + printf("FAPI_64QAM\t"); + break; + case FAPI_256QAM: + printf("FAPI_256QAM\t"); + break; + default: + printf("Unknown fapiModOrder_t value\t"); + } +} + +void decode_fapiSsbPerRach_t(fapiSsbPerRach_t ssbPerRach) +{ + printf("\n"); + switch (ssbPerRach) + { + case FAPI_SSB_PER_RACH_1_OVER_8: + printf("FAPI_SSB_PER_RACH_1_OVER_8\t"); + break; + case FAPI_SSB_PER_RACH_1_OVER_4: + printf("FAPI_SSB_PER_RACH_1_OVER_4\t"); + break; + case FAPI_SSB_PER_RACH_1_OVER_2: + printf("FAPI_SSB_PER_RACH_1_OVER_2\t"); + break; + case FAPI_SSB_PER_RACH_1: + printf("FAPI_SSB_PER_RACH_1\t"); + break; + case FAPI_SSB_PER_RACH_2: + printf("FAPI_SSB_PER_RACH_2\t"); + break; + case FAPI_SSB_PER_RACH_4: + printf("FAPI_SSB_PER_RACH_4\t"); + break; + case FAPI_SSB_PER_RACH_8: + printf("FAPI_SSB_PER_RACH_8\t"); + break; + case FAPI_SSB_PER_RACH_16: + printf("FAPI_SSB_PER_RACH_16\t"); + break; + default: + printf("Unknown fapiSsbPerRach_t value\t"); + } +} + +void print_pucch_resources(const nr5g_fapi_pucch_resources_t *resources) +{ + printf("\n"); + printf("Group ID: %u\n", resources->group_id); + printf("Initial Cyclic Shift: %u\n", resources->initial_cyclic_shift); + printf("Number of Symbols: %u\n", resources->nr_of_symbols); + printf("Start Symbol Index: %u\n", resources->start_symbol_index); + printf("Time Domain Occurrence Index: %u\n", resources->time_domain_occ_idx); +} +