diff --git a/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7.h b/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7.h index 8909878f28..5b4bbe5922 100644 --- a/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7.h +++ b/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7.h @@ -31,5 +31,7 @@ int fapi_nr_p7_message_unpack(void *pMessageBuf, uint8_t pack_dl_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config); uint8_t unpack_dl_tti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config); +uint8_t pack_ul_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config); +uint8_t unpack_ul_tti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config); #endif // OPENAIRINTERFACE_NR_FAPI_P7_H diff --git a/nfapi/open-nFAPI/fapi/src/nr_fapi_p7.c b/nfapi/open-nFAPI/fapi/src/nr_fapi_p7.c index 1aa5a0ed22..85ed7d5b58 100644 --- a/nfapi/open-nFAPI/fapi/src/nr_fapi_p7.c +++ b/nfapi/open-nFAPI/fapi/src/nr_fapi_p7.c @@ -34,7 +34,9 @@ uint8_t fapi_nr_p7_message_body_pack(nfapi_nr_p7_message_header_t *header, case NFAPI_NR_PHY_MSG_TYPE_DL_TTI_REQUEST: result = pack_dl_tti_request(header, ppWritePackedMsg, end, config); break; - + case NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST: + result = pack_ul_tti_request(header, ppWritePackedMsg, end, config); + break; default: { if (header->message_id >= NFAPI_VENDOR_EXT_MSG_MIN && header->message_id <= NFAPI_VENDOR_EXT_MSG_MAX) { if (config && config->pack_p7_vendor_extension) { @@ -139,7 +141,10 @@ int fapi_nr_p7_message_unpack(void *pMessageBuf, if (check_nr_fapi_unpack_length(NFAPI_NR_PHY_MSG_TYPE_DL_TTI_REQUEST, unpackedBufLen)) result = unpack_dl_tti_request(&pReadPackedMessage, end, pMessageHeader, config); break; - + case NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST: + if (check_nr_fapi_unpack_length(NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST, unpackedBufLen)) + result = unpack_ul_tti_request(&pReadPackedMessage, end, pMessageHeader, config); + break; default: if (pMessageHeader->message_id >= NFAPI_VENDOR_EXT_MSG_MIN && pMessageHeader->message_id <= NFAPI_VENDOR_EXT_MSG_MAX) { @@ -629,3 +634,634 @@ uint8_t unpack_dl_tti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg return 1; } + +// Pack fns for ul_tti PDUS + +static uint8_t pack_nr_rx_beamforming_pdu(const nfapi_nr_ul_beamforming_t *beamforming_pdu, + uint8_t **ppWritePackedMsg, + uint8_t *end) +{ // Pack RX Beamforming PDU + if (!(push8(beamforming_pdu->trp_scheme, ppWritePackedMsg, end) && push16(beamforming_pdu->num_prgs, ppWritePackedMsg, end) + && push16(beamforming_pdu->prg_size, ppWritePackedMsg, end) + && push8(beamforming_pdu->dig_bf_interface, ppWritePackedMsg, end))) { + return 0; + } + for (int prg = 0; prg < beamforming_pdu->num_prgs; prg++) { + for (int digBFInterface = 0; digBFInterface < beamforming_pdu->dig_bf_interface; digBFInterface++) { + if (!push16(beamforming_pdu->prgs_list[prg].dig_bf_interface_list[digBFInterface].beam_idx, ppWritePackedMsg, end)) { + return 0; + } + } + } + return 1; +} + +static uint8_t pack_ul_tti_request_prach_pdu(const nfapi_nr_prach_pdu_t *prach_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) +{ + if (!(push16(prach_pdu->phys_cell_id, ppWritePackedMsg, end) && push8(prach_pdu->num_prach_ocas, ppWritePackedMsg, end) + && push8(prach_pdu->prach_format, ppWritePackedMsg, end) && push8(prach_pdu->num_ra, ppWritePackedMsg, end) + && push8(prach_pdu->prach_start_symbol, ppWritePackedMsg, end) && push16(prach_pdu->num_cs, ppWritePackedMsg, end))) { + return 0; + } + + return pack_nr_rx_beamforming_pdu(&prach_pdu->beamforming, ppWritePackedMsg, end); +} + +static uint8_t pack_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pusch_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) +{ + if (!(push16(pusch_pdu->pdu_bit_map, ppWritePackedMsg, end) && push16(pusch_pdu->rnti, ppWritePackedMsg, end) + && push32(pusch_pdu->handle, ppWritePackedMsg, end) && push16(pusch_pdu->bwp_size, ppWritePackedMsg, end) + && push16(pusch_pdu->bwp_start, ppWritePackedMsg, end) && push8(pusch_pdu->subcarrier_spacing, ppWritePackedMsg, end) + && push8(pusch_pdu->cyclic_prefix, ppWritePackedMsg, end) && push16(pusch_pdu->target_code_rate, ppWritePackedMsg, end) + && push8(pusch_pdu->qam_mod_order, ppWritePackedMsg, end) && push8(pusch_pdu->mcs_index, ppWritePackedMsg, end) + && push8(pusch_pdu->mcs_table, ppWritePackedMsg, end) && push8(pusch_pdu->transform_precoding, ppWritePackedMsg, end) + && push16(pusch_pdu->data_scrambling_id, ppWritePackedMsg, end) && push8(pusch_pdu->nrOfLayers, ppWritePackedMsg, end) + && push16(pusch_pdu->ul_dmrs_symb_pos, ppWritePackedMsg, end) && push8(pusch_pdu->dmrs_config_type, ppWritePackedMsg, end) + && push16(pusch_pdu->ul_dmrs_scrambling_id, ppWritePackedMsg, end) + && push16(pusch_pdu->pusch_identity, ppWritePackedMsg, end) && push8(pusch_pdu->scid, ppWritePackedMsg, end) + && push8(pusch_pdu->num_dmrs_cdm_grps_no_data, ppWritePackedMsg, end) + && push16(pusch_pdu->dmrs_ports, ppWritePackedMsg, end) && push8(pusch_pdu->resource_alloc, ppWritePackedMsg, end) + && pusharray8(pusch_pdu->rb_bitmap, 36, 36, ppWritePackedMsg, end) && push16(pusch_pdu->rb_start, ppWritePackedMsg, end) + && push16(pusch_pdu->rb_size, ppWritePackedMsg, end) && push8(pusch_pdu->vrb_to_prb_mapping, ppWritePackedMsg, end) + && push8(pusch_pdu->frequency_hopping, ppWritePackedMsg, end) + && push16(pusch_pdu->tx_direct_current_location, ppWritePackedMsg, end) + && push8(pusch_pdu->uplink_frequency_shift_7p5khz, ppWritePackedMsg, end) + && push8(pusch_pdu->start_symbol_index, ppWritePackedMsg, end) && push8(pusch_pdu->nr_of_symbols, ppWritePackedMsg, end))) { + return 0; + } + + // Pack Optional Data only included if indicated in pduBitmap + // Check if PUSCH_PDU_BITMAP_PUSCH_DATA bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_DATA) { + // pack optional TLVs + if (!(push8(pusch_pdu->pusch_data.rv_index, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_data.harq_process_id, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_data.new_data_indicator, ppWritePackedMsg, end) + && push32(pusch_pdu->pusch_data.tb_size, ppWritePackedMsg, end) + && push16(pusch_pdu->pusch_data.num_cb, ppWritePackedMsg, end))) { + return 0; + } + const uint16_t cb_len = (pusch_pdu->pusch_data.num_cb + 7) / 8; + if (!pusharray8(pusch_pdu->pusch_data.cb_present_and_position, cb_len, cb_len, ppWritePackedMsg, end)) { + return 0; + } + } + + // Check if PUSCH_PDU_BITMAP_PUSCH_UCI bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_UCI) { + if (!(push16(pusch_pdu->pusch_uci.harq_ack_bit_length, ppWritePackedMsg, end) + && push16(pusch_pdu->pusch_uci.csi_part1_bit_length, ppWritePackedMsg, end) + && push16(pusch_pdu->pusch_uci.csi_part2_bit_length, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_uci.alpha_scaling, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_uci.beta_offset_harq_ack, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_uci.beta_offset_csi1, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_uci.beta_offset_csi2, ppWritePackedMsg, end))) { + return 0; + } + } + + // Check if PUSCH_PDU_BITMAP_PUSCH_PTRS bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) { + if (!push8(pusch_pdu->pusch_ptrs.num_ptrs_ports, ppWritePackedMsg, end)) { + return 0; + } + for (int i = 0; i < pusch_pdu->pusch_ptrs.num_ptrs_ports; ++i) { + if (!(push16(pusch_pdu->pusch_ptrs.ptrs_ports_list[i].ptrs_port_index, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_ptrs.ptrs_ports_list[i].ptrs_dmrs_port, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_ptrs.ptrs_ports_list[i].ptrs_re_offset, ppWritePackedMsg, end))) { + return 0; + } + } + + if (!(push8(pusch_pdu->pusch_ptrs.ptrs_time_density, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_ptrs.ptrs_freq_density, ppWritePackedMsg, end) + && push8(pusch_pdu->pusch_ptrs.ul_ptrs_power, ppWritePackedMsg, end))) { + return 0; + } + } + + // Check if PUSCH_PDU_BITMAP_DFTS_OFDM bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_DFTS_OFDM) { + if (!(push8(pusch_pdu->dfts_ofdm.low_papr_group_number, ppWritePackedMsg, end) + && push16(pusch_pdu->dfts_ofdm.low_papr_sequence_number, ppWritePackedMsg, end) + && push8(pusch_pdu->dfts_ofdm.ul_ptrs_sample_density, ppWritePackedMsg, end) + && push8(pusch_pdu->dfts_ofdm.ul_ptrs_time_density_transform_precoding, ppWritePackedMsg, end))) { + return 0; + } + } + + // Pack RX Beamforming PDU + if (!(pack_nr_rx_beamforming_pdu(&pusch_pdu->beamforming, ppWritePackedMsg, end))) { + return 0; + } + if (!(push8(pusch_pdu->maintenance_parms_v3.ldpcBaseGraph, ppWritePackedMsg, end) + && push32(pusch_pdu->maintenance_parms_v3.tbSizeLbrmBytes, ppWritePackedMsg, end))) + return 0; + return 1; +} + +static uint8_t pack_ul_tti_request_pucch_pdu(const nfapi_nr_pucch_pdu_t *pucch_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) +{ + if (!(push16(pucch_pdu->rnti, ppWritePackedMsg, end) && push32(pucch_pdu->handle, ppWritePackedMsg, end) + && push16(pucch_pdu->bwp_size, ppWritePackedMsg, end) && push16(pucch_pdu->bwp_start, ppWritePackedMsg, end) + && push8(pucch_pdu->subcarrier_spacing, ppWritePackedMsg, end) && push8(pucch_pdu->cyclic_prefix, ppWritePackedMsg, end) + && push8(pucch_pdu->format_type, ppWritePackedMsg, end) && push8(pucch_pdu->multi_slot_tx_indicator, ppWritePackedMsg, end) + && push8(pucch_pdu->pi_2bpsk, ppWritePackedMsg, end) && push16(pucch_pdu->prb_start, ppWritePackedMsg, end) + && push16(pucch_pdu->prb_size, ppWritePackedMsg, end) && push8(pucch_pdu->start_symbol_index, ppWritePackedMsg, end) + && push8(pucch_pdu->nr_of_symbols, ppWritePackedMsg, end) && push8(pucch_pdu->freq_hop_flag, ppWritePackedMsg, end) + && push16(pucch_pdu->second_hop_prb, ppWritePackedMsg, end) && push8(pucch_pdu->group_hop_flag, ppWritePackedMsg, end) + && push8(pucch_pdu->sequence_hop_flag, ppWritePackedMsg, end) && push16(pucch_pdu->hopping_id, ppWritePackedMsg, end) + && push16(pucch_pdu->initial_cyclic_shift, ppWritePackedMsg, end) + && push16(pucch_pdu->data_scrambling_id, ppWritePackedMsg, end) + && push8(pucch_pdu->time_domain_occ_idx, ppWritePackedMsg, end) && push8(pucch_pdu->pre_dft_occ_idx, ppWritePackedMsg, end) + && push8(pucch_pdu->pre_dft_occ_len, ppWritePackedMsg, end) && push8(pucch_pdu->add_dmrs_flag, ppWritePackedMsg, end) + && push16(pucch_pdu->dmrs_scrambling_id, ppWritePackedMsg, end) + && push8(pucch_pdu->dmrs_cyclic_shift, ppWritePackedMsg, end) && push8(pucch_pdu->sr_flag, ppWritePackedMsg, end) + && push16(pucch_pdu->bit_len_harq, ppWritePackedMsg, end) && push16(pucch_pdu->bit_len_csi_part1, ppWritePackedMsg, end) + && push16(pucch_pdu->bit_len_csi_part2, ppWritePackedMsg, end))) { + return 0; + } + + return pack_nr_rx_beamforming_pdu(&pucch_pdu->beamforming, ppWritePackedMsg, end); +} + +static uint8_t pack_ul_tti_request_srs_parameters_v4(nfapi_v4_srs_parameters_t *srsParameters, + const uint8_t num_symbols, + uint8_t **ppWritePackedMsg, + uint8_t *end) +{ + if (!(push16(srsParameters->srs_bandwidth_size, ppWritePackedMsg, end))) { + return 0; + } + for (int symbol_idx = 0; symbol_idx < num_symbols; ++symbol_idx) { + const nfapi_v4_srs_parameters_symbols_t *symbol = &srsParameters->symbol_list[symbol_idx]; + if (!(push16(symbol->srs_bandwidth_start, ppWritePackedMsg, end) && push8(symbol->sequence_group, ppWritePackedMsg, end) + && push8(symbol->sequence_number, ppWritePackedMsg, end))) { + return 0; + } + } +#ifdef ENABLE_AERIAL + // For Aerial, we always pack/unpack the 4 reported symbols, not only the ones indicated by num_symbols + for (int symbol_idx = num_symbols; symbol_idx < 4; ++symbol_idx) { + if (!(push16(0, ppWritePackedMsg, end) && push8(0, ppWritePackedMsg, end) && push8(0, ppWritePackedMsg, end))) { + return 0; + } + } +#endif // ENABLE_AERIAL + const uint8_t nUsage = __builtin_popcount(srsParameters->usage); + if (!(push32(srsParameters->usage, ppWritePackedMsg, end) + && pusharray8(srsParameters->report_type, 4, nUsage, ppWritePackedMsg, end) + && push8(srsParameters->singular_Value_representation, ppWritePackedMsg, end) + && push8(srsParameters->iq_representation, ppWritePackedMsg, end) && push16(srsParameters->prg_size, ppWritePackedMsg, end) + && push8(srsParameters->num_total_ue_antennas, ppWritePackedMsg, end) + && push32(srsParameters->ue_antennas_in_this_srs_resource_set, ppWritePackedMsg, end) + && push32(srsParameters->sampled_ue_antennas, ppWritePackedMsg, end) + && push8(srsParameters->report_scope, ppWritePackedMsg, end) + && push8(srsParameters->num_ul_spatial_streams_ports, ppWritePackedMsg, end) + && pusharray8(srsParameters->Ul_spatial_stream_ports, + 256, + srsParameters->num_ul_spatial_streams_ports, + ppWritePackedMsg, + end))) { + return 0; + } + return 1; +} + +static uint8_t pack_ul_tti_request_srs_pdu(nfapi_nr_srs_pdu_t *srs_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) +{ + if (!(push16(srs_pdu->rnti, ppWritePackedMsg, end) && push32(srs_pdu->handle, ppWritePackedMsg, end) + && push16(srs_pdu->bwp_size, ppWritePackedMsg, end) && push16(srs_pdu->bwp_start, ppWritePackedMsg, end) + && push8(srs_pdu->subcarrier_spacing, ppWritePackedMsg, end) && push8(srs_pdu->cyclic_prefix, ppWritePackedMsg, end) + && push8(srs_pdu->num_ant_ports, ppWritePackedMsg, end) && push8(srs_pdu->num_symbols, ppWritePackedMsg, end) + && push8(srs_pdu->num_repetitions, ppWritePackedMsg, end) && push8(srs_pdu->time_start_position, ppWritePackedMsg, end) + && push8(srs_pdu->config_index, ppWritePackedMsg, end) && push16(srs_pdu->sequence_id, ppWritePackedMsg, end) + && push8(srs_pdu->bandwidth_index, ppWritePackedMsg, end) && push8(srs_pdu->comb_size, ppWritePackedMsg, end) + && push8(srs_pdu->comb_offset, ppWritePackedMsg, end) && push8(srs_pdu->cyclic_shift, ppWritePackedMsg, end) + && push8(srs_pdu->frequency_position, ppWritePackedMsg, end) && push16(srs_pdu->frequency_shift, ppWritePackedMsg, end) + && push8(srs_pdu->frequency_hopping, ppWritePackedMsg, end) + && push8(srs_pdu->group_or_sequence_hopping, ppWritePackedMsg, end) && push8(srs_pdu->resource_type, ppWritePackedMsg, end) + && push16(srs_pdu->t_srs, ppWritePackedMsg, end) && push16(srs_pdu->t_offset, ppWritePackedMsg, end))) { + return 0; + } + + if(!(pack_nr_rx_beamforming_pdu(&srs_pdu->beamforming, ppWritePackedMsg, end))){ + return 0; + } + + if(!(pack_ul_tti_request_srs_parameters_v4(&srs_pdu->srs_parameters_v4, 1 << srs_pdu->num_symbols, ppWritePackedMsg, end))){ + return 0; + } + + return 1; +} + +static uint8_t pack_ul_tti_pdu_list_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end) +{ + nfapi_nr_ul_tti_request_number_of_pdus_t *value = (nfapi_nr_ul_tti_request_number_of_pdus_t *)tlv; + uintptr_t msgHead = (uintptr_t)*ppWritePackedMsg; + if (!push16(value->pdu_type, ppWritePackedMsg, end)) { + return 0; + } + uint8_t *pPackedLengthField = *ppWritePackedMsg; + + if (!push16(value->pdu_size, ppWritePackedMsg, end)) + return 0; + // pack PDUs + // first match the pdu type, then call the respective function + switch (value->pdu_type) { + case NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE: { + if (!pack_ul_tti_request_prach_pdu(&value->prach_pdu, ppWritePackedMsg, end)) + return 0; + } break; + + case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: { + if (!pack_ul_tti_request_pusch_pdu(&value->pusch_pdu, ppWritePackedMsg, end)) + return 0; + } break; + + case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { + if (!pack_ul_tti_request_pucch_pdu(&value->pucch_pdu, ppWritePackedMsg, end)) + return 0; + } break; + + case NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE: { + if (!pack_ul_tti_request_srs_pdu(&value->srs_pdu, ppWritePackedMsg, end)) + return 0; + } break; + + default: { + NFAPI_TRACE(NFAPI_TRACE_ERROR, "FIXME : Invalid UL_TTI pdu type %d \n", value->pdu_type); + } break; + } + + // pack proper size + uintptr_t msgEnd = (uintptr_t)*ppWritePackedMsg; + uint16_t packedMsgLen = msgEnd - msgHead; + value->pdu_size = packedMsgLen; + return push16(value->pdu_size, &pPackedLengthField, end); +} + +static uint8_t pack_ul_tti_groups_list_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end) +{ + nfapi_nr_ul_tti_request_number_of_groups_t *value = (nfapi_nr_ul_tti_request_number_of_groups_t *)tlv; + + if (!push8(value->n_ue, ppWritePackedMsg, end)) + return 0; + + for (int i = 0; i < value->n_ue; i++) { + if (!push8(value->ue_list[i].pdu_idx, ppWritePackedMsg, end)) + return 0; + } + + return 1; +} + +uint8_t pack_ul_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) +{ + nfapi_nr_ul_tti_request_t *pNfapiMsg = (nfapi_nr_ul_tti_request_t *)msg; + pNfapiMsg->n_ulcch = 0; + pNfapiMsg->n_ulsch = 0; + for (int i = 0; i < pNfapiMsg->n_pdus; i++) { + switch (pNfapiMsg->pdus_list[i].pdu_type) { + case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { + pNfapiMsg->n_ulcch++; + } break; + case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: { + pNfapiMsg->n_ulsch++; + } break; + default: + break; + } + } + if (!push16(pNfapiMsg->SFN, ppWritePackedMsg, end)) + return 0; + if (!push16(pNfapiMsg->Slot, ppWritePackedMsg, end)) + return 0; + if (!push8(pNfapiMsg->n_pdus, ppWritePackedMsg, end)) + return 0; + if (!push8(pNfapiMsg->rach_present, ppWritePackedMsg, end)) + return 0; + if (!push8(pNfapiMsg->n_ulsch, ppWritePackedMsg, end)) + return 0; + if (!push8(pNfapiMsg->n_ulcch, ppWritePackedMsg, end)) + return 0; + if (!push8(pNfapiMsg->n_group, ppWritePackedMsg, end)) + return 0; + + for (int i = 0; i < pNfapiMsg->n_pdus; i++) { + if (!pack_ul_tti_pdu_list_value(&pNfapiMsg->pdus_list[i], ppWritePackedMsg, end)) + return 0; + } + + for (int i = 0; i < pNfapiMsg->n_group; i++) { + if (!pack_ul_tti_groups_list_value(&pNfapiMsg->groups_list[i], ppWritePackedMsg, end)) + return 0; + } + + return 1; +} + +static uint8_t unpack_nr_rx_beamforming_pdu(nfapi_nr_ul_beamforming_t *beamforming_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) +{ // Unpack RX Beamforming PDU + if (!(pull8(ppReadPackedMsg, &beamforming_pdu->trp_scheme, end) && pull16(ppReadPackedMsg, &beamforming_pdu->num_prgs, end) + && pull16(ppReadPackedMsg, &beamforming_pdu->prg_size, end) + && pull8(ppReadPackedMsg, &beamforming_pdu->dig_bf_interface, end))) { + return 0; + } + for (int prg = 0; prg < beamforming_pdu->num_prgs; prg++) { + for (int digBFInterface = 0; digBFInterface < beamforming_pdu->dig_bf_interface; digBFInterface++) { + if (!pull16(ppReadPackedMsg, &beamforming_pdu->prgs_list[prg].dig_bf_interface_list[digBFInterface].beam_idx, end)) { + return 0; + } + } + } + return 1; +} + +static uint8_t unpack_ul_tti_request_prach_pdu(nfapi_nr_prach_pdu_t *prach_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) +{ + if (!(pull16(ppReadPackedMsg, &prach_pdu->phys_cell_id, end) && pull8(ppReadPackedMsg, &prach_pdu->num_prach_ocas, end) + && pull8(ppReadPackedMsg, &prach_pdu->prach_format, end) && pull8(ppReadPackedMsg, &prach_pdu->num_ra, end) + && pull8(ppReadPackedMsg, &prach_pdu->prach_start_symbol, end) && pull16(ppReadPackedMsg, &prach_pdu->num_cs, end))) { + return 0; + } + + return unpack_nr_rx_beamforming_pdu(&prach_pdu->beamforming, ppReadPackedMsg, end); +} + +static uint8_t unpack_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pusch_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) +{ + if (!(pull16(ppReadPackedMsg, &pusch_pdu->pdu_bit_map, end) && pull16(ppReadPackedMsg, &pusch_pdu->rnti, end) + && pull32(ppReadPackedMsg, &pusch_pdu->handle, end) && pull16(ppReadPackedMsg, &pusch_pdu->bwp_size, end) + && pull16(ppReadPackedMsg, &pusch_pdu->bwp_start, end) && pull8(ppReadPackedMsg, &pusch_pdu->subcarrier_spacing, end) + && pull8(ppReadPackedMsg, &pusch_pdu->cyclic_prefix, end) && pull16(ppReadPackedMsg, &pusch_pdu->target_code_rate, end) + && pull8(ppReadPackedMsg, &pusch_pdu->qam_mod_order, end) && pull8(ppReadPackedMsg, &pusch_pdu->mcs_index, end) + && pull8(ppReadPackedMsg, &pusch_pdu->mcs_table, end) && pull8(ppReadPackedMsg, &pusch_pdu->transform_precoding, end) + && pull16(ppReadPackedMsg, &pusch_pdu->data_scrambling_id, end) && pull8(ppReadPackedMsg, &pusch_pdu->nrOfLayers, end) + && pull16(ppReadPackedMsg, &pusch_pdu->ul_dmrs_symb_pos, end) && pull8(ppReadPackedMsg, &pusch_pdu->dmrs_config_type, end) + && pull16(ppReadPackedMsg, &pusch_pdu->ul_dmrs_scrambling_id, end) + && pull16(ppReadPackedMsg, &pusch_pdu->pusch_identity, end) && pull8(ppReadPackedMsg, &pusch_pdu->scid, end) + && pull8(ppReadPackedMsg, &pusch_pdu->num_dmrs_cdm_grps_no_data, end) + && pull16(ppReadPackedMsg, &pusch_pdu->dmrs_ports, end) && pull8(ppReadPackedMsg, &pusch_pdu->resource_alloc, end) + && pullarray8(ppReadPackedMsg, pusch_pdu->rb_bitmap, 36, 36, end) && pull16(ppReadPackedMsg, &pusch_pdu->rb_start, end) + && pull16(ppReadPackedMsg, &pusch_pdu->rb_size, end) && pull8(ppReadPackedMsg, &pusch_pdu->vrb_to_prb_mapping, end) + && pull8(ppReadPackedMsg, &pusch_pdu->frequency_hopping, end) + && pull16(ppReadPackedMsg, &pusch_pdu->tx_direct_current_location, end) + && pull8(ppReadPackedMsg, &pusch_pdu->uplink_frequency_shift_7p5khz, end) + && pull8(ppReadPackedMsg, &pusch_pdu->start_symbol_index, end) && pull8(ppReadPackedMsg, &pusch_pdu->nr_of_symbols, end))) + return 0; + + // Unpack Optional Data only included if indicated in pduBitmap + // Check if PUSCH_PDU_BITMAP_PUSCH_DATA bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_DATA) { + // pack optional TLVs + if (!(pull8(ppReadPackedMsg, &pusch_pdu->pusch_data.rv_index, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_data.harq_process_id, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_data.new_data_indicator, end) + && pull32(ppReadPackedMsg, &pusch_pdu->pusch_data.tb_size, end) + && pull16(ppReadPackedMsg, &pusch_pdu->pusch_data.num_cb, end))) { + return 0; + } + const uint8_t cb_len = (pusch_pdu->pusch_data.num_cb + 7) / 8; + if (!pullarray8(ppReadPackedMsg, pusch_pdu->pusch_data.cb_present_and_position, cb_len, cb_len, end)) { + return 0; + } + } + // Check if PUSCH_PDU_BITMAP_PUSCH_UCI bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_UCI) { + if (!(pull16(ppReadPackedMsg, &pusch_pdu->pusch_uci.harq_ack_bit_length, end) + && pull16(ppReadPackedMsg, &pusch_pdu->pusch_uci.csi_part1_bit_length, end) + && pull16(ppReadPackedMsg, &pusch_pdu->pusch_uci.csi_part2_bit_length, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.alpha_scaling, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.beta_offset_harq_ack, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.beta_offset_csi1, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.beta_offset_csi2, end))) { + return 0; + } + } + + // Check if PUSCH_PDU_BITMAP_PUSCH_PTRS bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) { + if (!(pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.num_ptrs_ports, end))) { + return 0; + } + pusch_pdu->pusch_ptrs.ptrs_ports_list = calloc(pusch_pdu->pusch_ptrs.num_ptrs_ports, sizeof(nfapi_nr_ptrs_ports_t)); + for (int ptrs_port = 0; ptrs_port < pusch_pdu->pusch_ptrs.num_ptrs_ports; ++ptrs_port) { + if (!(pull16(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list[ptrs_port].ptrs_port_index, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list[ptrs_port].ptrs_dmrs_port, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list[ptrs_port].ptrs_re_offset, end))) { + return 0; + } + } + if (!(pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_time_density, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_freq_density, end) + && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ul_ptrs_power, end))) { + return 0; + } + } + + // Check if PUSCH_PDU_BITMAP_DFTS_OFDM bit is set + if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_DFTS_OFDM) { + if (!(pull8(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.low_papr_group_number, end) + && pull16(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.low_papr_sequence_number, end) + && pull8(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.ul_ptrs_sample_density, end) + && pull8(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.ul_ptrs_time_density_transform_precoding, end))) { + return 0; + } + } + + if (!(unpack_nr_rx_beamforming_pdu(&pusch_pdu->beamforming, ppReadPackedMsg, end))) { + return 0; + } + + if (!(pull8(ppReadPackedMsg, &pusch_pdu->maintenance_parms_v3.ldpcBaseGraph, end) + && pull32(ppReadPackedMsg, &pusch_pdu->maintenance_parms_v3.tbSizeLbrmBytes, end))) + return 0; + + return 1; +} + +static uint8_t unpack_ul_tti_request_pucch_pdu(nfapi_nr_pucch_pdu_t *pucch_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) +{ + if (!(pull16(ppReadPackedMsg, &pucch_pdu->rnti, end) && pull32(ppReadPackedMsg, &pucch_pdu->handle, end) + && pull16(ppReadPackedMsg, &pucch_pdu->bwp_size, end) && pull16(ppReadPackedMsg, &pucch_pdu->bwp_start, end) + && pull8(ppReadPackedMsg, &pucch_pdu->subcarrier_spacing, end) && pull8(ppReadPackedMsg, &pucch_pdu->cyclic_prefix, end) + && pull8(ppReadPackedMsg, &pucch_pdu->format_type, end) && pull8(ppReadPackedMsg, &pucch_pdu->multi_slot_tx_indicator, end) + && pull8(ppReadPackedMsg, &pucch_pdu->pi_2bpsk, end) && pull16(ppReadPackedMsg, &pucch_pdu->prb_start, end) + && pull16(ppReadPackedMsg, &pucch_pdu->prb_size, end) && pull8(ppReadPackedMsg, &pucch_pdu->start_symbol_index, end) + && pull8(ppReadPackedMsg, &pucch_pdu->nr_of_symbols, end) && pull8(ppReadPackedMsg, &pucch_pdu->freq_hop_flag, end) + && pull16(ppReadPackedMsg, &pucch_pdu->second_hop_prb, end) && pull8(ppReadPackedMsg, &pucch_pdu->group_hop_flag, end) + && pull8(ppReadPackedMsg, &pucch_pdu->sequence_hop_flag, end) && pull16(ppReadPackedMsg, &pucch_pdu->hopping_id, end) + && pull16(ppReadPackedMsg, &pucch_pdu->initial_cyclic_shift, end) + && pull16(ppReadPackedMsg, &pucch_pdu->data_scrambling_id, end) + && pull8(ppReadPackedMsg, &pucch_pdu->time_domain_occ_idx, end) && pull8(ppReadPackedMsg, &pucch_pdu->pre_dft_occ_idx, end) + && pull8(ppReadPackedMsg, &pucch_pdu->pre_dft_occ_len, end) && pull8(ppReadPackedMsg, &pucch_pdu->add_dmrs_flag, end) + && pull16(ppReadPackedMsg, &pucch_pdu->dmrs_scrambling_id, end) + && pull8(ppReadPackedMsg, &pucch_pdu->dmrs_cyclic_shift, end) && pull8(ppReadPackedMsg, &pucch_pdu->sr_flag, end) + && pull16(ppReadPackedMsg, &pucch_pdu->bit_len_harq, end) && pull16(ppReadPackedMsg, &pucch_pdu->bit_len_csi_part1, end) + && pull16(ppReadPackedMsg, &pucch_pdu->bit_len_csi_part2, end))) { + return 0; + } + return unpack_nr_rx_beamforming_pdu(&pucch_pdu->beamforming, ppReadPackedMsg, end); +} + +static uint8_t unpack_ul_tti_request_srs_parameters_v4(nfapi_v4_srs_parameters_t *srsParameters, + const uint8_t num_symbols, + uint8_t **ppReadPackedMsg, + uint8_t *end) +{ + if (!(pull16(ppReadPackedMsg, &srsParameters->srs_bandwidth_size, end))) { + return 0; + } + + for (int symbol_idx = 0; symbol_idx < num_symbols; ++symbol_idx) { + nfapi_v4_srs_parameters_symbols_t *symbol = &srsParameters->symbol_list[symbol_idx]; + if (!(pull16(ppReadPackedMsg, &symbol->srs_bandwidth_start, end) && pull8(ppReadPackedMsg, &symbol->sequence_group, end) + && pull8(ppReadPackedMsg, &symbol->sequence_number, end))) { + return 0; + } + } +#ifdef ENABLE_AERIAL + // For Aerial, we always pack/unpack the 4 reported symbols, not only the ones indicated by num_symbols + for (int symbol_idx = num_symbols; symbol_idx < 4; ++symbol_idx) { + nfapi_v4_srs_parameters_symbols_t *symbol = &srsParameters->symbol_list[symbol_idx]; + if (!(pull16(ppReadPackedMsg, &symbol->srs_bandwidth_start, end) && pull8(ppReadPackedMsg, &symbol->sequence_group, end) + && pull8(ppReadPackedMsg, &symbol->sequence_number, end))) { + return 0; + } + } +#endif // ENABLE_AERIAL + + if (!(pull32(ppReadPackedMsg, &srsParameters->usage, end))) { + return 0; + } + const uint8_t nUsage = __builtin_popcount(srsParameters->usage); + if (!(pullarray8(ppReadPackedMsg, &srsParameters->report_type[0], 4, nUsage, end) + && pull8(ppReadPackedMsg, &srsParameters->singular_Value_representation, end) + && pull8(ppReadPackedMsg, &srsParameters->iq_representation, end) && pull16(ppReadPackedMsg, &srsParameters->prg_size, end) + && pull8(ppReadPackedMsg, &srsParameters->num_total_ue_antennas, end) + && pull32(ppReadPackedMsg, &srsParameters->ue_antennas_in_this_srs_resource_set, end) + && pull32(ppReadPackedMsg, &srsParameters->sampled_ue_antennas, end) + && pull8(ppReadPackedMsg, &srsParameters->report_scope, end) + && pull8(ppReadPackedMsg, &srsParameters->num_ul_spatial_streams_ports, end) + && pullarray8(ppReadPackedMsg, + &srsParameters->Ul_spatial_stream_ports[0], + 256, + srsParameters->num_ul_spatial_streams_ports, + end))) { + return 0; + } + return 1; +} + +static uint8_t unpack_ul_tti_request_srs_pdu(nfapi_nr_srs_pdu_t *srs_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) +{ + if (!(pull16(ppReadPackedMsg, &srs_pdu->rnti, end) && pull32(ppReadPackedMsg, &srs_pdu->handle, end) + && pull16(ppReadPackedMsg, &srs_pdu->bwp_size, end) && pull16(ppReadPackedMsg, &srs_pdu->bwp_start, end) + && pull8(ppReadPackedMsg, &srs_pdu->subcarrier_spacing, end) && pull8(ppReadPackedMsg, &srs_pdu->cyclic_prefix, end) + && pull8(ppReadPackedMsg, &srs_pdu->num_ant_ports, end) && pull8(ppReadPackedMsg, &srs_pdu->num_symbols, end) + && pull8(ppReadPackedMsg, &srs_pdu->num_repetitions, end) && pull8(ppReadPackedMsg, &srs_pdu->time_start_position, end) + && pull8(ppReadPackedMsg, &srs_pdu->config_index, end) && pull16(ppReadPackedMsg, &srs_pdu->sequence_id, end) + && pull8(ppReadPackedMsg, &srs_pdu->bandwidth_index, end) && pull8(ppReadPackedMsg, &srs_pdu->comb_size, end) + && pull8(ppReadPackedMsg, &srs_pdu->comb_offset, end) && pull8(ppReadPackedMsg, &srs_pdu->cyclic_shift, end) + && pull8(ppReadPackedMsg, &srs_pdu->frequency_position, end) && pull16(ppReadPackedMsg, &srs_pdu->frequency_shift, end) + && pull8(ppReadPackedMsg, &srs_pdu->frequency_hopping, end) + && pull8(ppReadPackedMsg, &srs_pdu->group_or_sequence_hopping, end) && pull8(ppReadPackedMsg, &srs_pdu->resource_type, end) + && pull16(ppReadPackedMsg, &srs_pdu->t_srs, end) && pull16(ppReadPackedMsg, &srs_pdu->t_offset, end))) { + return 0; + } + + if (!(unpack_nr_rx_beamforming_pdu(&srs_pdu->beamforming, ppReadPackedMsg, end))) { + return 0; + } + + if (!(unpack_ul_tti_request_srs_parameters_v4(&srs_pdu->srs_parameters_v4, 1 << srs_pdu->num_symbols, ppReadPackedMsg, end))) { + return 0; + } + + return 1; +} + +static uint8_t unpack_ul_tti_pdu_list_value(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg) +{ + nfapi_nr_ul_tti_request_number_of_pdus_t *pNfapiMsg = (nfapi_nr_ul_tti_request_number_of_pdus_t *)msg; + + if (!(pull16(ppReadPackedMsg, &pNfapiMsg->pdu_type, end) && pull16(ppReadPackedMsg, &pNfapiMsg->pdu_size, end))) + return 0; + + // first natch the pdu type, then call the respective function + switch (pNfapiMsg->pdu_type) { + case NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE: { + if (!unpack_ul_tti_request_prach_pdu(&pNfapiMsg->prach_pdu, ppReadPackedMsg, end)) + return 0; + } break; + + case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: { + if (!unpack_ul_tti_request_pusch_pdu(&pNfapiMsg->pusch_pdu, ppReadPackedMsg, end)) + return 0; + } break; + + case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { + if (!unpack_ul_tti_request_pucch_pdu(&pNfapiMsg->pucch_pdu, ppReadPackedMsg, end)) + return 0; + } break; + + case NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE: { + if (!unpack_ul_tti_request_srs_pdu(&pNfapiMsg->srs_pdu, ppReadPackedMsg, end)) + return 0; + } break; + + default: { + NFAPI_TRACE(NFAPI_TRACE_ERROR, "FIXME : Invalid UL_TTI pdu type %d \n", pNfapiMsg->pdu_type); + } break; + } + + return 1; +} + +static uint8_t unpack_ul_tti_groups_list_value(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg) +{ + nfapi_nr_ul_tti_request_number_of_groups_t *pNfapiMsg = (nfapi_nr_ul_tti_request_number_of_groups_t *)msg; + + if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_ue, end)) + return 0; + + for (int i = 0; i < pNfapiMsg->n_ue; i++) { + if (!pull8(ppReadPackedMsg, &pNfapiMsg->ue_list[i].pdu_idx, end)) + return 0; + } + + return 1; +} + +uint8_t unpack_ul_tti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config) +{ + nfapi_nr_ul_tti_request_t *pNfapiMsg = (nfapi_nr_ul_tti_request_t *)msg; + + if (!pull16(ppReadPackedMsg, &pNfapiMsg->SFN, end)) + return 0; + if (!pull16(ppReadPackedMsg, &pNfapiMsg->Slot, end)) + return 0; + if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_pdus, end)) + return 0; + if (!pull8(ppReadPackedMsg, &pNfapiMsg->rach_present, end)) + return 0; + if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_ulsch, end)) + return 0; + if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_ulcch, end)) + return 0; + if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_group, end)) + return 0; + for (int i = 0; i < pNfapiMsg->n_pdus; i++) { + if (!unpack_ul_tti_pdu_list_value(ppReadPackedMsg, end, &pNfapiMsg->pdus_list[i])) + return 0; + } + + for (int i = 0; i < pNfapiMsg->n_group; i++) { + if (!unpack_ul_tti_groups_list_value(ppReadPackedMsg, end, &pNfapiMsg->groups_list[i])) + return 0; + } + + return 1; +} diff --git a/nfapi/open-nFAPI/nfapi/public_inc/nr_nfapi_p7.h b/nfapi/open-nFAPI/nfapi/public_inc/nr_nfapi_p7.h index fcc3575e9e..6e500cc905 100644 --- a/nfapi/open-nFAPI/nfapi/public_inc/nr_nfapi_p7.h +++ b/nfapi/open-nFAPI/nfapi/public_inc/nr_nfapi_p7.h @@ -46,11 +46,6 @@ uint8_t unpack_nr_srs_indication(uint8_t **ppReadPackedMsg, nfapi_nr_srs_indication_t *pNfapiMsg, nfapi_p7_codec_config_t *config); - -uint8_t pack_ul_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config); - -uint8_t unpack_ul_tti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config); - uint8_t pack_ul_dci_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config); uint8_t pack_ue_release_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config); diff --git a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c index b73194f4cd..246b0b427e 100644 --- a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c +++ b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c @@ -723,228 +723,6 @@ static uint8_t pack_ul_config_request_ulsch_rel13_value(void *tlv, uint8_t **ppW push8(ulsch_pdu_rel13->empty_symbols_due_to_re_tunning, ppWritePackedMsg, end)); } -//Pack fns for ul_tti PDUS - -static uint8_t pack_nr_rx_beamforming_pdu(const nfapi_nr_ul_beamforming_t *beamforming_pdu, - uint8_t **ppWritePackedMsg, - uint8_t *end) -{ // Pack RX Beamforming PDU - if (!(push16((*beamforming_pdu).num_prgs, ppWritePackedMsg, end) && push16((*beamforming_pdu).prg_size, ppWritePackedMsg, end) - && push8((*beamforming_pdu).dig_bf_interface, ppWritePackedMsg, end))) { - return 0; - } - for (int prg = 0; prg < (*beamforming_pdu).num_prgs; prg++) { - for (int digBFInterface = 0; digBFInterface < (*beamforming_pdu).dig_bf_interface; digBFInterface++) { - if (!push16((*beamforming_pdu).prgs_list[prg].dig_bf_interface_list[digBFInterface].beam_idx, ppWritePackedMsg, end)) { - return 0; - } - } - } - return 1; -} - -static uint8_t pack_ul_tti_request_prach_pdu(nfapi_nr_prach_pdu_t *prach_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) -{ - if (!(push16(prach_pdu->phys_cell_id, ppWritePackedMsg, end) && push8(prach_pdu->num_prach_ocas, ppWritePackedMsg, end) - && push8(prach_pdu->prach_format, ppWritePackedMsg, end) && push8(prach_pdu->num_ra, ppWritePackedMsg, end) - && push8(prach_pdu->prach_start_symbol, ppWritePackedMsg, end) && push16(prach_pdu->num_cs, ppWritePackedMsg, end))) { - return 0; - } - - return pack_nr_rx_beamforming_pdu(&prach_pdu->beamforming, ppWritePackedMsg, end); - -} - -static uint8_t pack_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pusch_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) -{ - if (!(push16(pusch_pdu->pdu_bit_map, ppWritePackedMsg, end) && push16(pusch_pdu->rnti, ppWritePackedMsg, end) - && push32(pusch_pdu->handle, ppWritePackedMsg, end) && push16(pusch_pdu->bwp_size, ppWritePackedMsg, end) - && push16(pusch_pdu->bwp_start, ppWritePackedMsg, end) && push8(pusch_pdu->subcarrier_spacing, ppWritePackedMsg, end) - && push8(pusch_pdu->cyclic_prefix, ppWritePackedMsg, end) && push16(pusch_pdu->target_code_rate, ppWritePackedMsg, end) - && push8(pusch_pdu->qam_mod_order, ppWritePackedMsg, end) && push8(pusch_pdu->mcs_index, ppWritePackedMsg, end) - && push8(pusch_pdu->mcs_table, ppWritePackedMsg, end) && push8(pusch_pdu->transform_precoding, ppWritePackedMsg, end) - && push16(pusch_pdu->data_scrambling_id, ppWritePackedMsg, end) && push8(pusch_pdu->nrOfLayers, ppWritePackedMsg, end) - && push16(pusch_pdu->ul_dmrs_symb_pos, ppWritePackedMsg, end) && push8(pusch_pdu->dmrs_config_type, ppWritePackedMsg, end) - && push16(pusch_pdu->ul_dmrs_scrambling_id, ppWritePackedMsg, end) - && push16(pusch_pdu->pusch_identity, ppWritePackedMsg, end) && push8(pusch_pdu->scid, ppWritePackedMsg, end) - && push8(pusch_pdu->num_dmrs_cdm_grps_no_data, ppWritePackedMsg, end) - && push16(pusch_pdu->dmrs_ports, ppWritePackedMsg, end) && push8(pusch_pdu->resource_alloc, ppWritePackedMsg, end) - && pusharray8(pusch_pdu->rb_bitmap, 36, 36, ppWritePackedMsg, end) && push16(pusch_pdu->rb_start, ppWritePackedMsg, end) - && push16(pusch_pdu->rb_size, ppWritePackedMsg, end) && push8(pusch_pdu->vrb_to_prb_mapping, ppWritePackedMsg, end) - && push8(pusch_pdu->frequency_hopping, ppWritePackedMsg, end) - && push16(pusch_pdu->tx_direct_current_location, ppWritePackedMsg, end) - && push8(pusch_pdu->uplink_frequency_shift_7p5khz, ppWritePackedMsg, end) - && push8(pusch_pdu->start_symbol_index, ppWritePackedMsg, end) - && push8(pusch_pdu->nr_of_symbols, ppWritePackedMsg, end))) { - return 0; - } - - // Pack Optional Data only included if indicated in pduBitmap - // Check if PUSCH_PDU_BITMAP_PUSCH_DATA bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_DATA) { - // pack optional TLVs - if (!(push8(pusch_pdu->pusch_data.rv_index, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_data.harq_process_id, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_data.new_data_indicator, ppWritePackedMsg, end) - && push32(pusch_pdu->pusch_data.tb_size, ppWritePackedMsg, end) - && push16(pusch_pdu->pusch_data.num_cb, ppWritePackedMsg, end) - && pusharray8(pusch_pdu->pusch_data.cb_present_and_position, - (pusch_pdu->pusch_data.num_cb + 7) / 8, - (pusch_pdu->pusch_data.num_cb + 7) / 8, - ppWritePackedMsg, - end))) { - return 0; - } - } - - // Check if PUSCH_PDU_BITMAP_PUSCH_UCI bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_UCI) { - if (!(push16(pusch_pdu->pusch_uci.harq_ack_bit_length, ppWritePackedMsg, end) - && push16(pusch_pdu->pusch_uci.csi_part1_bit_length, ppWritePackedMsg, end) - && push16(pusch_pdu->pusch_uci.csi_part2_bit_length, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_uci.alpha_scaling, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_uci.beta_offset_harq_ack, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_uci.beta_offset_csi1, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_uci.beta_offset_csi2, ppWritePackedMsg, end))) { - return 0; - } - } - - // Check if PUSCH_PDU_BITMAP_PUSCH_PTRS bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) { - if (!push8(pusch_pdu->pusch_ptrs.num_ptrs_ports, ppWritePackedMsg, end)) { - return 0; - } - for (int i = 0; i < pusch_pdu->pusch_ptrs.num_ptrs_ports; ++i) { - if (!(push16(pusch_pdu->pusch_ptrs.ptrs_ports_list[i].ptrs_port_index, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_ptrs.ptrs_ports_list[i].ptrs_dmrs_port, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_ptrs.ptrs_ports_list[i].ptrs_re_offset, ppWritePackedMsg, end))) { - return 0; - } - } - - if (!(push8(pusch_pdu->pusch_ptrs.ptrs_time_density, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_ptrs.ptrs_freq_density, ppWritePackedMsg, end) - && push8(pusch_pdu->pusch_ptrs.ul_ptrs_power, ppWritePackedMsg, end))) { - return 0; - } - } - - // Check if PUSCH_PDU_BITMAP_DFTS_OFDM bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_DFTS_OFDM) { - if (!(push8(pusch_pdu->dfts_ofdm.low_papr_group_number, ppWritePackedMsg, end) - && push16(pusch_pdu->dfts_ofdm.low_papr_sequence_number, ppWritePackedMsg, end) - && push8(pusch_pdu->dfts_ofdm.ul_ptrs_sample_density, ppWritePackedMsg, end) - && push8(pusch_pdu->dfts_ofdm.ul_ptrs_time_density_transform_precoding, ppWritePackedMsg, end))) { - return 0; - } - } - - // Pack RX Beamforming PDU - if (!(pack_nr_rx_beamforming_pdu(&pusch_pdu->beamforming, ppWritePackedMsg, end))) { - return 0; - } - if (!(push8(pusch_pdu->maintenance_parms_v3.ldpcBaseGraph, ppWritePackedMsg, end) - && push32(pusch_pdu->maintenance_parms_v3.tbSizeLbrmBytes, ppWritePackedMsg, end))) - return 0; - return 1; -} - -static uint8_t pack_ul_tti_request_pucch_pdu(nfapi_nr_pucch_pdu_t *pucch_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) -{ - if (!(push16(pucch_pdu->rnti, ppWritePackedMsg, end) && push32(pucch_pdu->handle, ppWritePackedMsg, end) - && push16(pucch_pdu->bwp_size, ppWritePackedMsg, end) && push16(pucch_pdu->bwp_start, ppWritePackedMsg, end) - && push8(pucch_pdu->subcarrier_spacing, ppWritePackedMsg, end) && push8(pucch_pdu->cyclic_prefix, ppWritePackedMsg, end) - && push8(pucch_pdu->format_type, ppWritePackedMsg, end) && push8(pucch_pdu->multi_slot_tx_indicator, ppWritePackedMsg, end) - && push8(pucch_pdu->pi_2bpsk, ppWritePackedMsg, end) && push16(pucch_pdu->prb_start, ppWritePackedMsg, end) - && push16(pucch_pdu->prb_size, ppWritePackedMsg, end) && push8(pucch_pdu->start_symbol_index, ppWritePackedMsg, end) - && push8(pucch_pdu->nr_of_symbols, ppWritePackedMsg, end) && push8(pucch_pdu->freq_hop_flag, ppWritePackedMsg, end) - && push16(pucch_pdu->second_hop_prb, ppWritePackedMsg, end) && push8(pucch_pdu->group_hop_flag, ppWritePackedMsg, end) - && push8(pucch_pdu->sequence_hop_flag, ppWritePackedMsg, end) && push16(pucch_pdu->hopping_id, ppWritePackedMsg, end) - && push16(pucch_pdu->initial_cyclic_shift, ppWritePackedMsg, end) - && push16(pucch_pdu->data_scrambling_id, ppWritePackedMsg, end) - && push8(pucch_pdu->time_domain_occ_idx, ppWritePackedMsg, end) && push8(pucch_pdu->pre_dft_occ_idx, ppWritePackedMsg, end) - && push8(pucch_pdu->pre_dft_occ_len, ppWritePackedMsg, end) && push8(pucch_pdu->add_dmrs_flag, ppWritePackedMsg, end) - && push16(pucch_pdu->dmrs_scrambling_id, ppWritePackedMsg, end) - && push8(pucch_pdu->dmrs_cyclic_shift, ppWritePackedMsg, end) && push8(pucch_pdu->sr_flag, ppWritePackedMsg, end) - && push16(pucch_pdu->bit_len_harq, ppWritePackedMsg, end) && push16(pucch_pdu->bit_len_csi_part1, ppWritePackedMsg, end) - && push16(pucch_pdu->bit_len_csi_part2, ppWritePackedMsg, end))) { - return 0; - } - - return pack_nr_rx_beamforming_pdu(&pucch_pdu->beamforming, ppWritePackedMsg, end); -} - -static uint8_t pack_ul_tti_request_srs_parameters_v4(nfapi_v4_srs_parameters_t *srsParameters, uint8_t num_symbols, uint8_t **ppWritePackedMsg, uint8_t *end){ - if(!(push16(srsParameters->srs_bandwidth_size, ppWritePackedMsg, end))){ - return 0; - } - for (int symbol_idx = 0; symbol_idx < num_symbols; ++symbol_idx) { - nfapi_v4_srs_parameters_symbols_t *symbol = &srsParameters->symbol_list[symbol_idx]; - if(!(push16(symbol->srs_bandwidth_start, ppWritePackedMsg, end) && - push8(symbol->sequence_group, ppWritePackedMsg, end) && - push8(symbol->sequence_number, ppWritePackedMsg, end))){ - return 0; - } - } - uint8_t nUsage = __builtin_popcount(srsParameters->usage); - if(!(push32(srsParameters->usage, ppWritePackedMsg, end) && - pusharray8(srsParameters->report_type,4,nUsage , ppWritePackedMsg, end) && - push8(srsParameters->singular_Value_representation, ppWritePackedMsg, end) && - push8(srsParameters->iq_representation, ppWritePackedMsg, end) && - push16(srsParameters->prg_size, ppWritePackedMsg, end) && - push8(srsParameters->num_total_ue_antennas, ppWritePackedMsg, end) && - push32(srsParameters->ue_antennas_in_this_srs_resource_set, ppWritePackedMsg, end) && - push32(srsParameters->sampled_ue_antennas, ppWritePackedMsg, end) && - push8(srsParameters->report_scope, ppWritePackedMsg, end) && - push8(srsParameters->num_ul_spatial_streams_ports, ppWritePackedMsg, end) && - pusharray8(srsParameters->Ul_spatial_stream_ports, 256, srsParameters->num_ul_spatial_streams_ports, ppWritePackedMsg, end) - )){ - return 0; - } - return 1; -} - -static uint8_t pack_ul_tti_request_srs_pdu(nfapi_nr_srs_pdu_t *srs_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) { - if(!( - push16(srs_pdu->rnti, ppWritePackedMsg, end) && - push32(srs_pdu->handle, ppWritePackedMsg, end) && - push16(srs_pdu->bwp_size, ppWritePackedMsg, end) && - push16(srs_pdu->bwp_start, ppWritePackedMsg, end) && - push8(srs_pdu->subcarrier_spacing, ppWritePackedMsg, end)&& - push8(srs_pdu->cyclic_prefix, ppWritePackedMsg, end) && - push8(srs_pdu->num_ant_ports, ppWritePackedMsg, end) && - push8(srs_pdu->num_symbols, ppWritePackedMsg, end) && - push8(srs_pdu->num_repetitions, ppWritePackedMsg, end) && - push8(srs_pdu->time_start_position, ppWritePackedMsg, end) && - push8(srs_pdu->config_index, ppWritePackedMsg, end) && - push16(srs_pdu->sequence_id, ppWritePackedMsg, end) && - push8(srs_pdu->bandwidth_index, ppWritePackedMsg, end) && - push8(srs_pdu->comb_size, ppWritePackedMsg, end) && - push8(srs_pdu->comb_offset, ppWritePackedMsg, end) && - push8(srs_pdu->cyclic_shift, ppWritePackedMsg, end) && - push8(srs_pdu->frequency_position, ppWritePackedMsg, end) && - push16(srs_pdu->frequency_shift, ppWritePackedMsg, end) && - push8(srs_pdu->frequency_hopping, ppWritePackedMsg, end) && - push8(srs_pdu->group_or_sequence_hopping, ppWritePackedMsg, end) && - push8(srs_pdu->resource_type, ppWritePackedMsg, end) && - push16(srs_pdu->t_srs, ppWritePackedMsg, end) && - push16(srs_pdu->t_offset, ppWritePackedMsg, end) - )){ - return 0; - } - - if (!(pack_nr_rx_beamforming_pdu(&srs_pdu->beamforming, ppWritePackedMsg, end))) { - return 0; - } - - if (!(pack_ul_tti_request_srs_parameters_v4(&srs_pdu->srs_parameters_v4, srs_pdu->num_symbols, ppWritePackedMsg, end))) { - return 0; - } - - return 1; -} - static uint8_t pack_ul_config_request_ulsch_pdu(nfapi_ul_config_ulsch_pdu *ulsch_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) { return ( pack_tlv(NFAPI_UL_CONFIG_REQUEST_ULSCH_PDU_REL8_TAG, &ulsch_pdu->ulsch_pdu_rel8, ppWritePackedMsg, end, &pack_ul_config_request_ulsch_rel8_value) && pack_tlv(NFAPI_UL_CONFIG_REQUEST_ULSCH_PDU_REL10_TAG, &ulsch_pdu->ulsch_pdu_rel10, ppWritePackedMsg, end, &pack_ul_config_request_ulsch_rel10_value) && @@ -1235,66 +1013,6 @@ static uint8_t pack_ul_config_request_nrach_pdu_rel13_value(void *tlv, uint8_t * push8(nrach_pdu_rel13->nprach_config_2, ppWritePackedMsg, end)); } -static uint8_t pack_ul_tti_pdu_list_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end) -{ - nfapi_nr_ul_tti_request_number_of_pdus_t *value = (nfapi_nr_ul_tti_request_number_of_pdus_t *)tlv; - uintptr_t msgHead = (uintptr_t)*ppWritePackedMsg; - if (!push16(value->pdu_type, ppWritePackedMsg, end)) { - return 0; - } - uint8_t *pPackedLengthField = *ppWritePackedMsg; - - if (!push16(value->pdu_size, ppWritePackedMsg, end)) - return 0; - // pack PDUs - // first match the pdu type, then call the respective function - switch (value->pdu_type) { - case NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE: { - if (!pack_ul_tti_request_prach_pdu(&value->prach_pdu, ppWritePackedMsg, end)) - return 0; - } break; - - case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: { - if (!pack_ul_tti_request_pusch_pdu(&value->pusch_pdu, ppWritePackedMsg, end)) - return 0; - } break; - - case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { - if (!pack_ul_tti_request_pucch_pdu(&value->pucch_pdu, ppWritePackedMsg, end)) - return 0; - } break; - - case NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE: { - if (!pack_ul_tti_request_srs_pdu(&value->srs_pdu, ppWritePackedMsg, end)) - return 0; - } break; - - default: { - NFAPI_TRACE(NFAPI_TRACE_ERROR, "FIXME : Invalid UL_TTI pdu type %d \n", value->pdu_type); - } break; - } - - // pack proper size - uintptr_t msgEnd = (uintptr_t)*ppWritePackedMsg; - uint16_t packedMsgLen = msgEnd - msgHead; - value->pdu_size = packedMsgLen; - return push16(value->pdu_size, &pPackedLengthField, end); -} - -static uint8_t pack_ul_tti_groups_list_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end) { - nfapi_nr_ul_tti_request_number_of_groups_t *value = (nfapi_nr_ul_tti_request_number_of_groups_t *)tlv; - - if(!push8(value->n_ue, ppWritePackedMsg, end)) - return 0; - - for(int i=0; in_ue; i++) { - if(!push8(value->ue_list[i].pdu_idx, ppWritePackedMsg, end)) - return 0; - } - - return 1; -} - static uint8_t pack_ul_config_request_body_value(void *tlv, uint8_t **ppWritePackedMsg, uint8_t *end) { nfapi_ul_config_request_body_t *value = (nfapi_ul_config_request_body_t *)tlv; @@ -1468,52 +1186,6 @@ static uint8_t pack_ul_config_request_body_value(void *tlv, uint8_t **ppWritePac return 1; } -uint8_t pack_ul_tti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) -{ - nfapi_nr_ul_tti_request_t *pNfapiMsg = (nfapi_nr_ul_tti_request_t *)msg; - pNfapiMsg->n_ulcch = 0; - pNfapiMsg->n_ulsch = 0; - for (int i = 0; i < pNfapiMsg->n_pdus; i++) { - switch ((&pNfapiMsg->pdus_list[i])->pdu_type) { - case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { - pNfapiMsg->n_ulcch++; - } break; - case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: { - pNfapiMsg->n_ulsch++; - } break; - default: - break; - } - } - - if (!push16(pNfapiMsg->SFN, ppWritePackedMsg, end)) - return 0; - if (!push16(pNfapiMsg->Slot, ppWritePackedMsg, end)) - return 0; - if (!push8(pNfapiMsg->n_pdus, ppWritePackedMsg, end)) - return 0; - if (!push8(pNfapiMsg->rach_present, ppWritePackedMsg, end)) - return 0; - if (!push8(pNfapiMsg->n_ulsch, ppWritePackedMsg, end)) - return 0; - if (!push8(pNfapiMsg->n_ulcch, ppWritePackedMsg, end)) - return 0; - if (!push8(pNfapiMsg->n_group, ppWritePackedMsg, end)) - return 0; - - for (int i = 0; i < pNfapiMsg->n_pdus; i++) { - if (!pack_ul_tti_pdu_list_value(&pNfapiMsg->pdus_list[i], ppWritePackedMsg, end)) - return 0; - } - - for (int i = 0; i < pNfapiMsg->n_group; i++) { - if (!pack_ul_tti_groups_list_value(&pNfapiMsg->groups_list[i], ppWritePackedMsg, end)) - return 0; - } - - return 1; -} - static uint8_t pack_ul_config_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t *config) { nfapi_ul_config_request_t *pNfapiMsg = (nfapi_ul_config_request_t *)msg; return ( push16(pNfapiMsg->sfn_sf, ppWritePackedMsg, end) && @@ -4315,313 +3987,6 @@ static uint8_t unpack_dl_config_request_body_value(void *tlv, uint8_t **ppReadPa return 1; } -static uint8_t unpack_nr_rx_beamforming_pdu(nfapi_nr_ul_beamforming_t *beamforming_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) -{ // Unpack RX Beamforming PDU - if (!(pull16(ppReadPackedMsg, &beamforming_pdu->num_prgs, end) && pull16(ppReadPackedMsg, &beamforming_pdu->prg_size, end) - && pull8(ppReadPackedMsg, &beamforming_pdu->dig_bf_interface, end))) { - return 0; - } - for (int prg = 0; prg < beamforming_pdu->num_prgs; prg++) { - for (int digBFInterface = 0; digBFInterface < beamforming_pdu->dig_bf_interface; digBFInterface++) { - if (!pull16(ppReadPackedMsg, &beamforming_pdu->prgs_list[prg].dig_bf_interface_list[digBFInterface].beam_idx, end)) { - return 0; - } - } - } - return 1; -} - -static uint8_t unpack_ul_tti_request_prach_pdu(nfapi_nr_prach_pdu_t *prach_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) -{ - if (!(pull16(ppReadPackedMsg, &prach_pdu->phys_cell_id, end) && pull8(ppReadPackedMsg, &prach_pdu->num_prach_ocas, end) - && pull8(ppReadPackedMsg, &prach_pdu->prach_format, end) && pull8(ppReadPackedMsg, &prach_pdu->num_ra, end) - && pull8(ppReadPackedMsg, &prach_pdu->prach_start_symbol, end) && pull16(ppReadPackedMsg, &prach_pdu->num_cs, end))) { - return 0; - } - return unpack_nr_rx_beamforming_pdu(&prach_pdu->beamforming, ppReadPackedMsg, end); -} - -static uint8_t unpack_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pusch_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) -{ - if (!(pull16(ppReadPackedMsg, &pusch_pdu->pdu_bit_map, end) && pull16(ppReadPackedMsg, &pusch_pdu->rnti, end) - && pull32(ppReadPackedMsg, &pusch_pdu->handle, end) && pull16(ppReadPackedMsg, &pusch_pdu->bwp_size, end) - && pull16(ppReadPackedMsg, &pusch_pdu->bwp_start, end) && pull8(ppReadPackedMsg, &pusch_pdu->subcarrier_spacing, end) - && pull8(ppReadPackedMsg, &pusch_pdu->cyclic_prefix, end) && pull16(ppReadPackedMsg, &pusch_pdu->target_code_rate, end) - && pull8(ppReadPackedMsg, &pusch_pdu->qam_mod_order, end) && pull8(ppReadPackedMsg, &pusch_pdu->mcs_index, end) - && pull8(ppReadPackedMsg, &pusch_pdu->mcs_table, end) && pull8(ppReadPackedMsg, &pusch_pdu->transform_precoding, end) - && pull16(ppReadPackedMsg, &pusch_pdu->data_scrambling_id, end) && pull8(ppReadPackedMsg, &pusch_pdu->nrOfLayers, end) - && pull16(ppReadPackedMsg, &pusch_pdu->ul_dmrs_symb_pos, end) && pull8(ppReadPackedMsg, &pusch_pdu->dmrs_config_type, end) - && pull16(ppReadPackedMsg, &pusch_pdu->ul_dmrs_scrambling_id, end) - && pull16(ppReadPackedMsg, &pusch_pdu->pusch_identity, end) && pull8(ppReadPackedMsg, &pusch_pdu->scid, end) - && pull8(ppReadPackedMsg, &pusch_pdu->num_dmrs_cdm_grps_no_data, end) - && pull16(ppReadPackedMsg, &pusch_pdu->dmrs_ports, end) && pull8(ppReadPackedMsg, &pusch_pdu->resource_alloc, end) - && pullarray8(ppReadPackedMsg, pusch_pdu->rb_bitmap, 36, 36, end) && pull16(ppReadPackedMsg, &pusch_pdu->rb_start, end) - && pull16(ppReadPackedMsg, &pusch_pdu->rb_size, end) && pull8(ppReadPackedMsg, &pusch_pdu->vrb_to_prb_mapping, end) - && pull8(ppReadPackedMsg, &pusch_pdu->frequency_hopping, end) - && pull16(ppReadPackedMsg, &pusch_pdu->tx_direct_current_location, end) - && pull8(ppReadPackedMsg, &pusch_pdu->uplink_frequency_shift_7p5khz, end) - && pull8(ppReadPackedMsg, &pusch_pdu->start_symbol_index, end) && pull8(ppReadPackedMsg, &pusch_pdu->nr_of_symbols, end))) - return 0; - - // Unpack Optional Data only included if indicated in pduBitmap - // Check if PUSCH_PDU_BITMAP_PUSCH_DATA bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_DATA) { - // pack optional TLVs - if (!(pull8(ppReadPackedMsg, &pusch_pdu->pusch_data.rv_index, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_data.harq_process_id, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_data.new_data_indicator, end) - && pull32(ppReadPackedMsg, &pusch_pdu->pusch_data.tb_size, end) - && pull16(ppReadPackedMsg, &pusch_pdu->pusch_data.num_cb, end) - && pullarray8(ppReadPackedMsg, - pusch_pdu->pusch_data.cb_present_and_position, - (pusch_pdu->pusch_data.num_cb + 7) / 8, - (pusch_pdu->pusch_data.num_cb + 7) / 8, - end))) { - return 0; - } - } - // Check if PUSCH_PDU_BITMAP_PUSCH_UCI bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_UCI) { - if (!(pull16(ppReadPackedMsg, &pusch_pdu->pusch_uci.harq_ack_bit_length, end) - && pull16(ppReadPackedMsg, &pusch_pdu->pusch_uci.csi_part1_bit_length, end) - && pull16(ppReadPackedMsg, &pusch_pdu->pusch_uci.csi_part2_bit_length, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.alpha_scaling, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.beta_offset_harq_ack, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.beta_offset_csi1, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_uci.beta_offset_csi2, end))) { - return 0; - } - } - - // Check if PUSCH_PDU_BITMAP_PUSCH_PTRS bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) { - if (!(pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.num_ptrs_ports, end))) { - return 0; - } - pusch_pdu->pusch_ptrs.ptrs_ports_list = calloc(pusch_pdu->pusch_ptrs.num_ptrs_ports, sizeof(nfapi_nr_ptrs_ports_t)); - for (int ptrs_port = 0; ptrs_port < pusch_pdu->pusch_ptrs.num_ptrs_ports; ++ptrs_port) { - if (!(pull16(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list[ptrs_port].ptrs_port_index, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list[ptrs_port].ptrs_dmrs_port, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list[ptrs_port].ptrs_re_offset, end))) { - return 0; - } - } - if (!(pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_time_density, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_freq_density, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ul_ptrs_power, end))) { - return 0; - } - } - - // Check if PUSCH_PDU_BITMAP_DFTS_OFDM bit is set - if (pusch_pdu->pdu_bit_map & PUSCH_PDU_BITMAP_DFTS_OFDM) { - if (!(pull8(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.low_papr_group_number, end) - && pull16(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.low_papr_sequence_number, end) - && pull8(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.ul_ptrs_sample_density, end) - && pull8(ppReadPackedMsg, &pusch_pdu->dfts_ofdm.ul_ptrs_time_density_transform_precoding, end))) { - return 0; - } - } - - if (!(unpack_nr_rx_beamforming_pdu(&pusch_pdu->beamforming, ppReadPackedMsg, end))) { - return 0; - } - - if (!(pull8(ppReadPackedMsg, &pusch_pdu->maintenance_parms_v3.ldpcBaseGraph, end) - && pull32(ppReadPackedMsg, &pusch_pdu->maintenance_parms_v3.tbSizeLbrmBytes, end))) - return 0; - - return 1; -} - -static uint8_t unpack_ul_tti_request_pucch_pdu(nfapi_nr_pucch_pdu_t *pucch_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) -{ - if (!(pull16(ppReadPackedMsg, &pucch_pdu->rnti, end) && pull32(ppReadPackedMsg, &pucch_pdu->handle, end) - && pull16(ppReadPackedMsg, &pucch_pdu->bwp_size, end) && pull16(ppReadPackedMsg, &pucch_pdu->bwp_start, end) - && pull8(ppReadPackedMsg, &pucch_pdu->subcarrier_spacing, end) && pull8(ppReadPackedMsg, &pucch_pdu->cyclic_prefix, end) - && pull8(ppReadPackedMsg, &pucch_pdu->format_type, end) && pull8(ppReadPackedMsg, &pucch_pdu->multi_slot_tx_indicator, end) - && pull8(ppReadPackedMsg, &pucch_pdu->pi_2bpsk, end) && pull16(ppReadPackedMsg, &pucch_pdu->prb_start, end) - && pull16(ppReadPackedMsg, &pucch_pdu->prb_size, end) && pull8(ppReadPackedMsg, &pucch_pdu->start_symbol_index, end) - && pull8(ppReadPackedMsg, &pucch_pdu->nr_of_symbols, end) && pull8(ppReadPackedMsg, &pucch_pdu->freq_hop_flag, end) - && pull16(ppReadPackedMsg, &pucch_pdu->second_hop_prb, end) && pull8(ppReadPackedMsg, &pucch_pdu->group_hop_flag, end) - && pull8(ppReadPackedMsg, &pucch_pdu->sequence_hop_flag, end) && pull16(ppReadPackedMsg, &pucch_pdu->hopping_id, end) - && pull16(ppReadPackedMsg, &pucch_pdu->initial_cyclic_shift, end) - && pull16(ppReadPackedMsg, &pucch_pdu->data_scrambling_id, end) - && pull8(ppReadPackedMsg, &pucch_pdu->time_domain_occ_idx, end) && pull8(ppReadPackedMsg, &pucch_pdu->pre_dft_occ_idx, end) - && pull8(ppReadPackedMsg, &pucch_pdu->pre_dft_occ_len, end) && pull8(ppReadPackedMsg, &pucch_pdu->add_dmrs_flag, end) - && pull16(ppReadPackedMsg, &pucch_pdu->dmrs_scrambling_id, end) - && pull8(ppReadPackedMsg, &pucch_pdu->dmrs_cyclic_shift, end) && pull8(ppReadPackedMsg, &pucch_pdu->sr_flag, end) - && pull16(ppReadPackedMsg, &pucch_pdu->bit_len_harq, end) && pull16(ppReadPackedMsg, &pucch_pdu->bit_len_csi_part1, end) - && pull16(ppReadPackedMsg, &pucch_pdu->bit_len_csi_part2, end))) { - return 0; - } - return unpack_nr_rx_beamforming_pdu(&pucch_pdu->beamforming, ppReadPackedMsg, end); -} - -static uint8_t unpack_ul_tti_request_srs_parameters_v4(nfapi_v4_srs_parameters_t *srsParameters, - uint8_t num_symbols, - uint8_t **ppReadPackedMsg, - uint8_t *end) -{ - if (!(pull16(ppReadPackedMsg, &srsParameters->srs_bandwidth_size, end))) { - return 0; - } - - for (int symbol_idx = 0; symbol_idx < num_symbols; ++symbol_idx) { - nfapi_v4_srs_parameters_symbols_t *symbol = &srsParameters->symbol_list[symbol_idx]; - if (!(pull16(ppReadPackedMsg, &symbol->srs_bandwidth_start, end) && pull8(ppReadPackedMsg, &symbol->sequence_group, end) - && pull8(ppReadPackedMsg, &symbol->sequence_number, end))) { - return 0; - } - } - if (!(pull32(ppReadPackedMsg, &srsParameters->usage, end))) { - return 0; - } - uint8_t nUsage = __builtin_popcount(srsParameters->usage); - if (!(pullarray8(ppReadPackedMsg, &srsParameters->report_type[0], 4, nUsage, end) - && pull8(ppReadPackedMsg, &srsParameters->singular_Value_representation, end) - && pull8(ppReadPackedMsg, &srsParameters->iq_representation, end) && pull16(ppReadPackedMsg, &srsParameters->prg_size, end) - && pull8(ppReadPackedMsg, &srsParameters->num_total_ue_antennas, end) - && pull32(ppReadPackedMsg, &srsParameters->ue_antennas_in_this_srs_resource_set, end) - && pull32(ppReadPackedMsg, &srsParameters->sampled_ue_antennas, end) - && pull8(ppReadPackedMsg, &srsParameters->report_scope, end) - && pull8(ppReadPackedMsg, &srsParameters->num_ul_spatial_streams_ports, end) - && pullarray8(ppReadPackedMsg, - &srsParameters->Ul_spatial_stream_ports[0], - 256, - srsParameters->num_ul_spatial_streams_ports, - end))) { - return 0; - } - return 1; -} - -static uint8_t unpack_ul_tti_request_srs_pdu(nfapi_nr_srs_pdu_t *srs_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) -{ - if (!(pull16(ppReadPackedMsg, &srs_pdu->rnti, end) && - pull32(ppReadPackedMsg, &srs_pdu->handle, end) && - pull16(ppReadPackedMsg, &srs_pdu->bwp_size, end) && - pull16(ppReadPackedMsg, &srs_pdu->bwp_start, end) && - pull8(ppReadPackedMsg, &srs_pdu->subcarrier_spacing, end) && - pull8(ppReadPackedMsg, &srs_pdu->cyclic_prefix, end) && - pull8(ppReadPackedMsg, &srs_pdu->num_ant_ports, end) && - pull8(ppReadPackedMsg, &srs_pdu->num_symbols, end) && - pull8(ppReadPackedMsg, &srs_pdu->num_repetitions, end) && - pull8(ppReadPackedMsg, &srs_pdu->time_start_position, end) && - pull8(ppReadPackedMsg, &srs_pdu->config_index, end) && - pull16(ppReadPackedMsg, &srs_pdu->sequence_id, end) && - pull8(ppReadPackedMsg, &srs_pdu->bandwidth_index, end) && - pull8(ppReadPackedMsg, &srs_pdu->comb_size, end) && - pull8(ppReadPackedMsg, &srs_pdu->comb_offset, end) && - pull8(ppReadPackedMsg, &srs_pdu->cyclic_shift, end) && - pull8(ppReadPackedMsg, &srs_pdu->frequency_position, end) && - pull16(ppReadPackedMsg, &srs_pdu->frequency_shift, end) && - pull8(ppReadPackedMsg, &srs_pdu->frequency_hopping, end) && - pull8(ppReadPackedMsg, &srs_pdu->group_or_sequence_hopping, end) && - pull8(ppReadPackedMsg, &srs_pdu->resource_type, end) && - pull16(ppReadPackedMsg, &srs_pdu->t_srs, end) && - pull16(ppReadPackedMsg, &srs_pdu->t_offset, end))) { - return 0; - } - if (!(unpack_nr_rx_beamforming_pdu(&srs_pdu->beamforming, ppReadPackedMsg, end))) { - return 0; - } - - if (!(unpack_ul_tti_request_srs_parameters_v4(&srs_pdu->srs_parameters_v4, srs_pdu->num_symbols, ppReadPackedMsg, end))) { - return 0; - } - - return 1; -} - - -static uint8_t unpack_ul_tti_pdu_list_value(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg) { - nfapi_nr_ul_tti_request_number_of_pdus_t *pNfapiMsg = (nfapi_nr_ul_tti_request_number_of_pdus_t *)msg; - - if(!(pull16(ppReadPackedMsg, &pNfapiMsg->pdu_type, end) && - pull16(ppReadPackedMsg, &pNfapiMsg->pdu_size, end) )) - return 0; - - // first natch the pdu type, then call the respective function - switch(pNfapiMsg->pdu_type) { - case NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE: { - if(!unpack_ul_tti_request_prach_pdu(&pNfapiMsg->prach_pdu, ppReadPackedMsg, end)) - return 0; - } - break; - - case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: { - if (!unpack_ul_tti_request_pusch_pdu(&pNfapiMsg->pusch_pdu, ppReadPackedMsg, end)) - return 0; - } break; - - case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { - if(!unpack_ul_tti_request_pucch_pdu(&pNfapiMsg->pucch_pdu, ppReadPackedMsg, end)) - return 0; - } - break; - - case NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE: { - if(!unpack_ul_tti_request_srs_pdu(&pNfapiMsg->srs_pdu, ppReadPackedMsg, end)) - return 0; - } - break; - - default: { - NFAPI_TRACE(NFAPI_TRACE_ERROR, "FIXME : Invalid UL_TTI pdu type %d \n", pNfapiMsg->pdu_type ); - } - break; - } - - return 1; -} - - -static uint8_t unpack_ul_tti_groups_list_value(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg) { - nfapi_nr_ul_tti_request_number_of_groups_t *pNfapiMsg = (nfapi_nr_ul_tti_request_number_of_groups_t *)msg; - - if(!pull8(ppReadPackedMsg, &pNfapiMsg->n_ue, end)) - return 0; - - for (int i = 0; i < pNfapiMsg->n_ue; i++) { - if(!pull8(ppReadPackedMsg, &pNfapiMsg->ue_list[i].pdu_idx,end) ) - return 0; - } - - return 1; -} - -uint8_t unpack_ul_tti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config) -{ - nfapi_nr_ul_tti_request_t *pNfapiMsg = (nfapi_nr_ul_tti_request_t *)msg; - - if (!pull16(ppReadPackedMsg, &pNfapiMsg->SFN, end)) - return 0; - if (!pull16(ppReadPackedMsg, &pNfapiMsg->Slot, end)) - return 0; - if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_pdus, end)) - return 0; - if (!pull8(ppReadPackedMsg, &pNfapiMsg->rach_present, end)) - return 0; - if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_ulsch, end)) - return 0; - if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_ulcch, end)) - return 0; - if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_group, end)) - return 0; - for (int i = 0; i < pNfapiMsg->n_pdus; i++) { - if (!unpack_ul_tti_pdu_list_value(ppReadPackedMsg, end, &pNfapiMsg->pdus_list[i])) - return 0; - } - - for (int i = 0; i < pNfapiMsg->n_group; i++) { - if (!unpack_ul_tti_groups_list_value(ppReadPackedMsg, end, &pNfapiMsg->groups_list[i])) - return 0; - } - - return 1; -} - static uint8_t unpack_dl_config_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t *config) { nfapi_dl_config_request_t *pNfapiMsg = (nfapi_dl_config_request_t *)msg; unpack_p7_tlv_t unpack_fns[] = { diff --git a/nfapi/tests/nr_fapi_test.h b/nfapi/tests/nr_fapi_test.h index 3c4c67a542..6681a74f24 100644 --- a/nfapi/tests/nr_fapi_test.h +++ b/nfapi/tests/nr_fapi_test.h @@ -81,6 +81,11 @@ uint16_t rand16_range(uint16_t lower, uint16_t upper) return (rand() % (upper - lower + 1)) + lower; } +uint32_t rand32_range(uint32_t lower, uint32_t upper) +{ + return (rand() % (upper - lower + 1)) + lower; +} + int main(int n, char *v[]); static inline void fapi_test_init_seeded(time_t seed) diff --git a/nfapi/tests/p7/CMakeLists.txt b/nfapi/tests/p7/CMakeLists.txt index 1ceef08bfd..6fc4b78c12 100644 --- a/nfapi/tests/p7/CMakeLists.txt +++ b/nfapi/tests/p7/CMakeLists.txt @@ -1,5 +1,5 @@ set(Test_Labels fapi p7) -set(_fapi_p7_messages "dci_inversion;dl_tti_request") +set(_fapi_p7_messages "dci_inversion;dl_tti_request;ul_tti_request") foreach (fapi_p7_message IN LISTS _fapi_p7_messages) add_executable(nr_fapi_${fapi_p7_message}_test nr_fapi_${fapi_p7_message}_test.c) target_link_libraries(nr_fapi_${fapi_p7_message}_test PUBLIC nr_fapi_p7) diff --git a/nfapi/tests/p7/nr_fapi_ul_tti_request_test.c b/nfapi/tests/p7/nr_fapi_ul_tti_request_test.c new file mode 100644 index 0000000000..4f65cbfc9e --- /dev/null +++ b/nfapi/tests/p7/nr_fapi_ul_tti_request_test.c @@ -0,0 +1,461 @@ +/* + * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The OpenAirInterface Software Alliance licenses this file to You under + * the OAI Public License, Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.openairinterface.org/?page_id=698 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + *------------------------------------------------------------------------------- + * For more information about the OpenAirInterface (OAI) Software Alliance: + * contact@openairinterface.org + */ +#include "dci_payload_utils.h" +#include "nr_fapi_p7.h" +#include "nr_fapi_p7_utils.h" + +static void fill_ul_tti_request_beamforming(nfapi_nr_ul_beamforming_t *beamforming_pdu) +{ + beamforming_pdu->trp_scheme = rand8(); + beamforming_pdu->num_prgs = rand16_range(1, NFAPI_MAX_NUM_PRGS); + beamforming_pdu->prg_size = rand16_range(1, 275); + beamforming_pdu->dig_bf_interface = rand8_range(1,NFAPI_MAX_NUM_BG_IF); + + for (int prg = 0; prg < beamforming_pdu->num_prgs; ++prg) { + for (int dbf_if = 0; dbf_if < beamforming_pdu->dig_bf_interface; ++dbf_if) { + beamforming_pdu->prgs_list[prg].dig_bf_interface_list[dbf_if].beam_idx = rand16(); + } + } +} + +static void fill_ul_tti_request_prach_pdu(nfapi_nr_prach_pdu_t *pdu) +{ + pdu->phys_cell_id = rand16_range(0, 1007); + pdu->num_prach_ocas = rand8_range(1, 7); + pdu->prach_format = rand8_range(0, 13); + pdu->num_ra = rand8_range(0, 7); + pdu->prach_start_symbol = rand8_range(0, 13); + pdu->num_cs = rand16_range(0, 419); + fill_ul_tti_request_beamforming(&pdu->beamforming); +} + +static void fill_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pdu) +{ + pdu->pdu_bit_map = rand16_range(0b0000, 0b1111); + pdu->rnti = rand16_range(1, 65535); + pdu->handle = rand32(); + pdu->bwp_size = rand16_range(1, 275); + pdu->bwp_start = rand16_range(0, 274); + pdu->subcarrier_spacing = rand8_range(0, 4); + pdu->cyclic_prefix = rand8_range(0, 1); + pdu->target_code_rate = rand16_range(300, 9480); + uint8_t transform_precoding = rand8_range(0, 1); + uint8_t qam_mod_order_values[] = {1, 2, 4, 6, 8}; + // Value: 2,4,6,8 if transform precoding is disabled + // Value: 1,2,4,6,8 if transform precoding is enabled + pdu->qam_mod_order = qam_mod_order_values[rand8_range(1 - pdu->transform_precoding, 4)]; + pdu->mcs_index = rand8_range(0, 31); + pdu->mcs_table = rand8_range(0, 4); + pdu->transform_precoding = transform_precoding; + pdu->data_scrambling_id = rand16(); + pdu->nrOfLayers = rand8_range(1, 4); + // Bitmap occupying the 14 LSBs + pdu->ul_dmrs_symb_pos = rand16_range(0b00000000000000, 0b11111111111111); + pdu->dmrs_config_type = rand8_range(0, 1); + pdu->ul_dmrs_scrambling_id = rand16(); + pdu->pusch_identity = rand16_range(0, 1007); + pdu->scid = rand8_range(0, 1); + pdu->num_dmrs_cdm_grps_no_data = rand8_range(1, 3); + // Bitmap occupying the 11 LSBs + pdu->dmrs_ports = rand16_range(0b00000000000, 0b11111111111); + pdu->resource_alloc = rand8_range(0, 1); + for (int i = 0; i < 36; ++i) { + pdu->rb_bitmap[i] = rand8(); + } + pdu->rb_start = rand16_range(0, 274); + pdu->rb_size = rand16_range(1, 275); + pdu->vrb_to_prb_mapping = 0; + pdu->frequency_hopping = rand8_range(0, 1); + pdu->tx_direct_current_location = rand16_range(0, 4095); + pdu->uplink_frequency_shift_7p5khz = rand8_range(0, 1); + pdu->start_symbol_index = rand8_range(0, 13); + pdu->nr_of_symbols = rand8_range(1, 14); + + // Check if PUSCH_PDU_BITMAP_PUSCH_DATA bit is set + if (pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_DATA) { + nfapi_nr_pusch_data_t *pusch_data = &pdu->pusch_data; + pusch_data->rv_index = rand8_range(0, 3); + pusch_data->harq_process_id = rand8_range(0, 15); + pusch_data->new_data_indicator = rand8_range(0, 1); + // TBSize is 32 bits in width, but the value is from 0 to 65535 ( max for 16 bits ) + pusch_data->tb_size = rand16(); + // num_cb set always to 0, due to OAI not supporting CBG + pusch_data->num_cb = 0; + for (int i = 0; i < (pusch_data->num_cb + 7) / 8; ++i) { + pusch_data->cb_present_and_position[i] = 0; + } + } + + // Check if PUSCH_PDU_BITMAP_PUSCH_UCI bit is set + if (pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_UCI) { + nfapi_nr_pusch_uci_t *pusch_uci = &pdu->pusch_uci; + // For testing purposes "decide" here if it uses small block length or polar + pusch_uci->harq_ack_bit_length = rand16_range(0, 1706); + if (pusch_uci->harq_ack_bit_length <= 11) { + pusch_uci->csi_part1_bit_length = rand16_range(0, 11); + pusch_uci->csi_part2_bit_length = rand16_range(0, 11); + } else { + pusch_uci->csi_part1_bit_length = rand16_range(12, 1706); + pusch_uci->csi_part2_bit_length = rand16_range(12, 1706); + } + pusch_uci->alpha_scaling = rand8_range(0, 3); + pusch_uci->beta_offset_harq_ack = rand8_range(0, 15); + pusch_uci->beta_offset_csi1 = rand8_range(0, 18); + pusch_uci->beta_offset_csi2 = rand8_range(0, 18); + } + + // Check if PUSCH_PDU_BITMAP_PUSCH_PTRS bit is set + if (pdu->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) { + nfapi_nr_pusch_ptrs_t *pusch_ptrs = &pdu->pusch_ptrs; + pusch_ptrs->num_ptrs_ports = rand8_range(1, 2); + pusch_ptrs->ptrs_ports_list = calloc(pusch_ptrs->num_ptrs_ports, sizeof(nfapi_nr_ptrs_ports_t)); + for (int ptrs_port = 0; ptrs_port < pusch_ptrs->num_ptrs_ports; ++ptrs_port) { + // Bitmap occupying the 12 LSBs + pusch_ptrs->ptrs_ports_list[ptrs_port].ptrs_port_index = rand16_range(0b000000000000, 0b111111111111); + pusch_ptrs->ptrs_ports_list[ptrs_port].ptrs_dmrs_port = rand8_range(0, 11); + pusch_ptrs->ptrs_ports_list[ptrs_port].ptrs_re_offset = rand8_range(0, 11); + } + pusch_ptrs->ptrs_time_density = rand8_range(0, 2); + pusch_ptrs->ptrs_freq_density = rand8_range(0, 1); + pusch_ptrs->ul_ptrs_power = rand8_range(0, 3); + } + + // Check if PUSCH_PDU_BITMAP_DFTS_OFDM bit is set + if (pdu->pdu_bit_map & PUSCH_PDU_BITMAP_DFTS_OFDM) { + nfapi_nr_dfts_ofdm_t *dfts_ofdm = &pdu->dfts_ofdm; + dfts_ofdm->low_papr_group_number = rand8_range(0, 29); + dfts_ofdm->low_papr_sequence_number = rand16(); + dfts_ofdm->ul_ptrs_sample_density = rand8_range(1, 8); + dfts_ofdm->ul_ptrs_time_density_transform_precoding = rand8_range(1, 4); + } + + fill_ul_tti_request_beamforming(&pdu->beamforming); + pdu->maintenance_parms_v3.ldpcBaseGraph = rand8(); + pdu->maintenance_parms_v3.tbSizeLbrmBytes = rand32(); +} + +static void fill_ul_tti_request_pucch_pdu(nfapi_nr_pucch_pdu_t *pdu) +{ + pdu->rnti = rand16_range(1, 65535); + pdu->handle = rand32(); + pdu->bwp_size = rand16_range(1, 275); + pdu->bwp_start = rand16_range(0, 274); + pdu->subcarrier_spacing = rand8_range(0, 4); + pdu->cyclic_prefix = rand8_range(0, 1); + pdu->format_type = rand8_range(0, 4); + pdu->multi_slot_tx_indicator = rand8_range(0, 3); + pdu->pi_2bpsk = rand8_range(0, 1); + pdu->prb_start = rand16_range(0, 274); + pdu->prb_size = rand16_range(1, 16); + pdu->start_symbol_index = rand8_range(0, 13); + if (pdu->format_type == 0 || pdu->format_type == 2) { + pdu->nr_of_symbols = rand8_range(1, 2); + } else { + pdu->nr_of_symbols = rand8_range(4, 14); + } + pdu->freq_hop_flag = rand8_range(0, 1); + pdu->second_hop_prb = rand16_range(0, 274); + // Following 4 parameters are Valid for formats 0, 1, 3 and 4, assuming that otherwise, set to 0 + if (pdu->format_type == 0 || pdu->format_type == 1 || pdu->format_type == 3 || pdu->format_type == 4) { + pdu->group_hop_flag = rand8_range(0, 1); + pdu->sequence_hop_flag = rand8_range(0, 1); + pdu->hopping_id = rand16_range(0, 1023); + pdu->initial_cyclic_shift = rand16_range(0, 11); + } else { + pdu->group_hop_flag = 0; + pdu->sequence_hop_flag = 0; + pdu->hopping_id = 0; + pdu->initial_cyclic_shift = 0; + } + // Valid for format 2, 3 and 4. + if (pdu->format_type == 2 || pdu->format_type == 3 || pdu->format_type == 4) { + pdu->data_scrambling_id = rand16_range(0, 1023); + } else { + pdu->data_scrambling_id = 0; + } + + // Valid for format 1. + if (pdu->format_type == 1) { + pdu->time_domain_occ_idx = rand8_range(0, 6); + } else { + pdu->time_domain_occ_idx = 0; + } + + // the following 2 parameters are Valid for format 4. + if (pdu->format_type == 4) { + pdu->pre_dft_occ_idx = rand8_range(0, 3); + // Value: 2 or 4 + pdu->pre_dft_occ_len = 2 + (2 * rand8_range(0, 1)); + } else { + pdu->pre_dft_occ_idx = 0; + pdu->pre_dft_occ_len = 0; + } + + // Valid for formats 3 and 4. + if (pdu->format_type == 3 || pdu->format_type == 4) { + pdu->add_dmrs_flag = rand8_range(0, 1); + } else { + pdu->add_dmrs_flag = 0; + } + + // Valid for format 2. + if (pdu->format_type == 2) { + pdu->dmrs_scrambling_id = rand16(); + } else { + pdu->dmrs_scrambling_id = 0; + } + + // Valid for format 4. + if (pdu->format_type == 4) { + pdu->dmrs_cyclic_shift = rand8_range(0, 9); + } else { + pdu->dmrs_cyclic_shift = 0; + } + + // Valid for format 0 and 1 + if (pdu->format_type == 0 || pdu->format_type == 1) { + pdu->sr_flag = rand8_range(0, 1); + } else { + pdu->sr_flag = 0; + } + // Value: + // 0 = no HARQ bits + // 1->2 = Valid for Formats 0 and 1 + // 2 -> 1706 = Valid for Formats 2, 3 and 4 + if (pdu->format_type == 0 || pdu->format_type == 1) { + //{0,1,2} + pdu->bit_len_harq = rand16_range(0, 2); + } else { + // {0}∪{2,…,1706} + uint16_t bit_len_harq = rand16_range(0, 1705); + if (bit_len_harq == 0) { + pdu->bit_len_harq = 0; + } else { + // Shift range {1,…,1705} -> {2,…,1706} + pdu->bit_len_harq = bit_len_harq + 1; + } + } + + // Following 2 parameters are Valid for format 2, 3 and 4. + if (pdu->format_type == 2 || pdu->format_type == 3 || pdu->format_type == 4) { + pdu->bit_len_csi_part1 = rand16_range(0, 1706); + pdu->bit_len_csi_part2 = rand16_range(0, 1706); + } else { + pdu->bit_len_csi_part1 = 0; + pdu->bit_len_csi_part2 = 0; + } + + fill_ul_tti_request_beamforming(&pdu->beamforming); +} + +static void fill_ul_tti_request_srs_parameters(nfapi_v4_srs_parameters_t *params, const uint8_t num_symbols){ + params->srs_bandwidth_size = rand16_range(4, 272); + for (int idx = 0; idx < num_symbols; ++idx) { + nfapi_v4_srs_parameters_symbols_t *symbol = ¶ms->symbol_list[idx]; + symbol->srs_bandwidth_start = rand16_range(0,268); + symbol->sequence_group = rand8_range(0,29); + symbol->sequence_number = rand8_range(0,1); + } + +#ifdef ENABLE_AERIAL + // For Aerial, we always process the 4 reported symbols, not only the ones indicated by num_symbols + for (int symbol_idx = num_symbols; symbol_idx < 4; ++symbol_idx) { + nfapi_v4_srs_parameters_symbols_t *symbol = ¶ms->symbol_list[idx]; + symbol->srs_bandwidth_start = rand16_range(0,268); + symbol->sequence_group = rand8_range(0,29); + symbol->sequence_number = rand8_range(0,1); + } +#endif // ENABLE_AERIAL + + params->usage = rand32_range(0, 0b1111); + const uint8_t nUsage = __builtin_popcount(params->usage); + for (int idx = 0; idx < nUsage; ++idx) { + params->report_type[idx] = rand8_range(0,1); + } + params->singular_Value_representation = rand8_range(0,1); + params->iq_representation = rand8_range(0,1); + params->prg_size = rand16_range(1,272); + params->num_total_ue_antennas = rand8_range(1, 16); + params->ue_antennas_in_this_srs_resource_set = rand32(); + params->sampled_ue_antennas = rand32(); + params->report_scope = rand8_range(0,1); + params->num_ul_spatial_streams_ports = rand8_range(0, 255); + for (int idx = 0; idx < params->num_ul_spatial_streams_ports; ++idx) { + params->Ul_spatial_stream_ports[idx] = rand8(); + } +} + +static void fill_ul_tti_request_srs_pdu(nfapi_nr_srs_pdu_t *pdu) +{ + pdu->rnti = rand16_range(1, 65535); + pdu->handle = rand32(); + pdu->bwp_size = rand16_range(1, 275); + pdu->bwp_start = rand16_range(0, 274); + pdu->subcarrier_spacing = rand8_range(0, 4); + pdu->cyclic_prefix = rand8_range(0, 1); + pdu->num_ant_ports = rand8_range(0, 2); + pdu->num_symbols = rand8_range(0, 2); + pdu->num_repetitions = rand8_range(0, 2); + pdu->time_start_position = rand8_range(0, 13); + pdu->config_index = rand8_range(0, 63); + pdu->sequence_id = rand16_range(0, 1023); + pdu->bandwidth_index = rand8_range(0, 3); + pdu->comb_size = rand8_range(0, 1); + // Following 2 parameters value range differs according to comb_size + if (pdu->comb_size == 0) { + pdu->comb_offset = rand8_range(0, 1); + pdu->cyclic_shift = rand8_range(0, 7); + } else { + pdu->comb_offset = rand8_range(0, 3); + pdu->cyclic_shift = rand8_range(0, 11); + } + pdu->frequency_position = rand8_range(0, 67); + pdu->frequency_shift = rand16_range(0, 268); + pdu->frequency_hopping = rand8_range(0, 3); + pdu->group_or_sequence_hopping = rand8_range(0, 2); + pdu->resource_type = rand8_range(0, 2); + // Value: 1,2,3,4,5,8,10,16,20,32,40,64,80,160,320,640,1280,2560 + const uint16_t t_srs_values[] = {1, 2, 3, 4, 5, 8, 10, 16, 20, 32, 40, 64, 80, 160, 320, 640, 1280, 2560}; + pdu->t_srs = t_srs_values[rand16_range(0, 17)]; + pdu->t_offset = rand16_range(0, 2559); + fill_ul_tti_request_beamforming(&pdu->beamforming); + fill_ul_tti_request_srs_parameters(&pdu->srs_parameters_v4, 1 << pdu->num_symbols); +} + +static void fill_ul_tti_request(nfapi_nr_ul_tti_request_t *msg) +{ + msg->SFN = rand16_range(0, 1023); + msg->Slot = rand16_range(0, 159); + msg->n_pdus = rand8_range(4, 16); // Minimum 4 PDUs in order to test at least one of each + + printf(" NUM PDUS %d\n", msg->n_pdus); + msg->rach_present = 1; // rand8_range(0, 1); Always set to 1, since there can only be 1 PRACH PDU + printf(" NUM RACH PDUS %d\n", msg->rach_present); + uint8_t available_PDUs = msg->n_pdus - msg->rach_present; + msg->n_ulsch = rand8_range(1, available_PDUs - 2); + printf(" NUM PUSCH PDUS %d\n", msg->n_ulsch); + available_PDUs -= msg->n_ulsch; + msg->n_ulcch = rand8_range(1, available_PDUs - 1); + printf(" NUM PUCCH PDUS %d\n", msg->n_ulcch); + // The variable available_PDUs now contains the number of SRS PDUs needed to add to reach n_pdus + available_PDUs -= msg->n_ulcch; + printf(" NUM SRS PDUS %d\n", available_PDUs); + msg->n_group = rand8_range(0, NFAPI_MAX_NUM_GROUPS); + printf(" NUM Groups %d\n", msg->n_group); + + // Add PRACH PDU, if applicable + + if (msg->rach_present == 1) { + nfapi_nr_ul_tti_request_number_of_pdus_t *prach_pdu = &msg->pdus_list[0]; + prach_pdu->pdu_type = NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE; + prach_pdu->pdu_size = rand16(); + fill_ul_tti_request_prach_pdu(&prach_pdu->prach_pdu); + } + + // start either at 0 or 1, same value as rach_present + int pdu_idx = msg->rach_present; + // Assign all PUSCH PDUs + for (int i = 0; i < msg->n_ulsch; ++i, ++pdu_idx) { + nfapi_nr_ul_tti_request_number_of_pdus_t *pdu = &msg->pdus_list[pdu_idx]; + pdu->pdu_type = NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE; + pdu->pdu_size = rand16(); + fill_ul_tti_request_pusch_pdu(&pdu->pusch_pdu); + } + // Assign all PUCCH PDUs + for (int i = 0; i < msg->n_ulcch; ++i, ++pdu_idx) { + nfapi_nr_ul_tti_request_number_of_pdus_t *pdu = &msg->pdus_list[pdu_idx]; + pdu->pdu_type = NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE; + pdu->pdu_size = rand16(); + fill_ul_tti_request_pucch_pdu(&pdu->pucch_pdu); + } + + // Assing all SRS PDUs + for (int i = 0; i < available_PDUs; ++i, ++pdu_idx) { + nfapi_nr_ul_tti_request_number_of_pdus_t *pdu = &msg->pdus_list[pdu_idx]; + pdu->pdu_type = NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE; + pdu->pdu_size = rand16(); + fill_ul_tti_request_srs_pdu(&pdu->srs_pdu); + } + + for (int group_idx = 0; group_idx < msg->n_group; ++group_idx) { + nfapi_nr_ul_tti_request_number_of_groups_t *group = &msg->groups_list[group_idx]; + group->n_ue = rand8_range(1, 6); + for (int ue = 0; ue < group->n_ue; ++ue) { + group->ue_list[ue].pdu_idx = rand8(); + } + } +} + +static void test_pack_unpack(nfapi_nr_ul_tti_request_t *req) +{ + uint8_t msg_buf[1024 * 1024 * 2]; + // first test the packing procedure + int pack_result = fapi_nr_p7_message_pack(req, msg_buf, sizeof(msg_buf), NULL); + + DevAssert(pack_result >= 0 + NFAPI_HEADER_LENGTH); + // update req message_length value with value calculated in message_pack procedure + req->header.message_length = pack_result; //- NFAPI_HEADER_LENGTH; + // test the unpacking of the header + // copy first NFAPI_HEADER_LENGTH bytes into a new buffer, to simulate SCTP PEEK + fapi_message_header_t header; + uint32_t header_buffer_size = NFAPI_HEADER_LENGTH; + uint8_t header_buffer[header_buffer_size]; + for (int idx = 0; idx < header_buffer_size; idx++) { + header_buffer[idx] = msg_buf[idx]; + } + uint8_t *pReadPackedMessage = header_buffer; + int unpack_header_result = fapi_nr_message_header_unpack(&pReadPackedMessage, NFAPI_HEADER_LENGTH, &header, sizeof(header), 0); + DevAssert(unpack_header_result >= 0); + DevAssert(header.message_id == req->header.message_id); + DevAssert(header.message_length == req->header.message_length); + // test the unpacking and compare with initial message + nfapi_nr_ul_tti_request_t unpacked_req = {0}; + int unpack_result = + fapi_nr_p7_message_unpack(msg_buf, header.message_length + NFAPI_HEADER_LENGTH, &unpacked_req, sizeof(unpacked_req), 0); + DevAssert(unpack_result >= 0); + DevAssert(eq_ul_tti_request(&unpacked_req, req)); + free_ul_tti_request(&unpacked_req); +} + +static void test_copy(const nfapi_nr_ul_tti_request_t *msg) +{ + // Test copy function + nfapi_nr_ul_tti_request_t copy = {0}; + copy_ul_tti_request(msg, ©); + DevAssert(eq_ul_tti_request(msg, ©)); + free_ul_tti_request(©); +} + +int main(int n, char *v[]) +{ + fapi_test_init(); + + nfapi_nr_ul_tti_request_t req = {.header.message_id = NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST}; + + // Fill DL_TTI request + fill_ul_tti_request(&req); + // Perform tests + test_pack_unpack(&req); + test_copy(&req); + // All tests successful! + free_ul_tti_request(&req); + return 0; +}