From 0653c38a9dbdc445f827a18c6b7697a4ff05e9d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=BAben=20Soares=20Silva?= Date: Mon, 16 Sep 2024 14:31:45 +0100 Subject: [PATCH] Fix packing/unpacking procedures for UL_TTI.request Create separate function to pack/unpack rx_beamforming PDU Reorder PDU handling order to follow from 0 to 3 Changed PUSCH pdu_bitmap switch to separate if to handle multiple optional sub-pdus Fix bit_len_harq size to 16 bit Add utility functions related to UL_TTI.request --- nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h | 3 + nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c | 563 ++++++++++++++++++ .../nfapi/public_inc/nfapi_nr_interface_scf.h | 4 +- nfapi/open-nFAPI/nfapi/src/nfapi_p7.c | 550 +++++++++-------- 4 files changed, 882 insertions(+), 238 deletions(-) diff --git a/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h b/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h index 78805a2e0e..883af1e884 100644 --- a/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h +++ b/nfapi/open-nFAPI/fapi/inc/nr_fapi_p7_utils.h @@ -36,9 +36,12 @@ #include "nr_fapi.h" bool eq_dl_tti_request(const nfapi_nr_dl_tti_request_t *a, const nfapi_nr_dl_tti_request_t *b); +bool eq_ul_tti_request(const nfapi_nr_ul_tti_request_t *a, const nfapi_nr_ul_tti_request_t *b); void free_dl_tti_request(nfapi_nr_dl_tti_request_t *msg); +void free_ul_tti_request(nfapi_nr_ul_tti_request_t *msg); void copy_dl_tti_request(const nfapi_nr_dl_tti_request_t *src, nfapi_nr_dl_tti_request_t *dst); +void copy_ul_tti_request(const nfapi_nr_ul_tti_request_t *src, nfapi_nr_ul_tti_request_t *dst); #endif // OPENAIRINTERFACE_NR_FAPI_P7_UTILS_H diff --git a/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c b/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c index 6d066b384e..bceb249b13 100644 --- a/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c +++ b/nfapi/open-nFAPI/fapi/src/nr_fapi_p7_utils.c @@ -210,6 +210,283 @@ bool eq_dl_tti_request(const nfapi_nr_dl_tti_request_t *a, const nfapi_nr_dl_tti return true; } +static bool eq_ul_tti_beamforming(const nfapi_nr_ul_beamforming_t *a, const nfapi_nr_ul_beamforming_t *b) +{ + EQ(a->trp_scheme, b->trp_scheme); + EQ(a->num_prgs, b->num_prgs); + EQ(a->prg_size, b->prg_size); + EQ(a->dig_bf_interface, b->dig_bf_interface); + for (int prg = 0; prg < a->num_prgs; ++prg) { + for (int dbf_if = 0; dbf_if < a->dig_bf_interface; ++dbf_if) { + EQ(a->prgs_list[prg].dig_bf_interface_list[dbf_if].beam_idx, b->prgs_list[prg].dig_bf_interface_list[dbf_if].beam_idx); + } + } + + return true; +} + +static bool eq_ul_tti_request_prach_pdu(const nfapi_nr_prach_pdu_t *a, const nfapi_nr_prach_pdu_t *b) +{ + EQ(a->phys_cell_id, b->phys_cell_id); + EQ(a->num_prach_ocas, b->num_prach_ocas); + EQ(a->prach_format, b->prach_format); + EQ(a->num_ra, b->num_ra); + EQ(a->prach_start_symbol, b->prach_start_symbol); + EQ(a->num_cs, b->num_cs); + EQ(eq_ul_tti_beamforming(&a->beamforming, &b->beamforming), true); + return true; +} + +static bool eq_ul_tti_request_pusch_pdu(const nfapi_nr_pusch_pdu_t *a, const nfapi_nr_pusch_pdu_t *b) +{ + EQ(a->pdu_bit_map, b->pdu_bit_map); + EQ(a->rnti, b->rnti); + EQ(a->handle, b->handle); + EQ(a->bwp_size, b->bwp_size); + EQ(a->bwp_start, b->bwp_start); + EQ(a->subcarrier_spacing, b->subcarrier_spacing); + EQ(a->cyclic_prefix, b->cyclic_prefix); + EQ(a->target_code_rate, b->target_code_rate); + EQ(a->qam_mod_order, b->qam_mod_order); + EQ(a->mcs_index, b->mcs_index); + EQ(a->mcs_table, b->mcs_table); + EQ(a->transform_precoding, b->transform_precoding); + EQ(a->data_scrambling_id, b->data_scrambling_id); + EQ(a->nrOfLayers, b->nrOfLayers); + EQ(a->ul_dmrs_symb_pos, b->ul_dmrs_symb_pos); + EQ(a->dmrs_config_type, b->dmrs_config_type); + EQ(a->ul_dmrs_scrambling_id, b->ul_dmrs_scrambling_id); + EQ(a->pusch_identity, b->pusch_identity); + EQ(a->scid, b->scid); + EQ(a->num_dmrs_cdm_grps_no_data, b->num_dmrs_cdm_grps_no_data); + EQ(a->dmrs_ports, b->dmrs_ports); + EQ(a->resource_alloc, b->resource_alloc); + for (int i = 0; i < 36; ++i) { + EQ(a->rb_bitmap[i], b->rb_bitmap[i]); + } + EQ(a->rb_start, b->rb_start); + EQ(a->rb_size, b->rb_size); + EQ(a->vrb_to_prb_mapping, b->vrb_to_prb_mapping); + EQ(a->frequency_hopping, b->frequency_hopping); + EQ(a->tx_direct_current_location, b->tx_direct_current_location); + EQ(a->uplink_frequency_shift_7p5khz, b->uplink_frequency_shift_7p5khz); + EQ(a->start_symbol_index, b->start_symbol_index); + EQ(a->nr_of_symbols, b->nr_of_symbols); + + if (a->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_DATA) { + const nfapi_nr_pusch_data_t *a_pusch_data = &a->pusch_data; + const nfapi_nr_pusch_data_t *b_pusch_data = &b->pusch_data; + EQ(a_pusch_data->rv_index, b_pusch_data->rv_index); + EQ(a_pusch_data->harq_process_id, b_pusch_data->harq_process_id); + EQ(a_pusch_data->new_data_indicator, b_pusch_data->new_data_indicator); + EQ(a_pusch_data->tb_size, b_pusch_data->tb_size); + EQ(a_pusch_data->num_cb, b_pusch_data->num_cb); + for (int i = 0; i < (a_pusch_data->num_cb + 7) / 8; ++i) { + EQ(a_pusch_data->cb_present_and_position[i], b_pusch_data->cb_present_and_position[i]); + } + } + if (a->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_UCI) { + const nfapi_nr_pusch_uci_t *a_pusch_uci = &a->pusch_uci; + const nfapi_nr_pusch_uci_t *b_pusch_uci = &b->pusch_uci; + EQ(a_pusch_uci->harq_ack_bit_length, b_pusch_uci->harq_ack_bit_length); + EQ(a_pusch_uci->csi_part1_bit_length, b_pusch_uci->csi_part1_bit_length); + EQ(a_pusch_uci->csi_part2_bit_length, b_pusch_uci->csi_part2_bit_length); + EQ(a_pusch_uci->alpha_scaling, b_pusch_uci->alpha_scaling); + EQ(a_pusch_uci->beta_offset_harq_ack, b_pusch_uci->beta_offset_harq_ack); + EQ(a_pusch_uci->beta_offset_csi1, b_pusch_uci->beta_offset_csi1); + EQ(a_pusch_uci->beta_offset_csi2, b_pusch_uci->beta_offset_csi2); + } + if (a->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) { + const nfapi_nr_pusch_ptrs_t *a_pusch_ptrs = &a->pusch_ptrs; + const nfapi_nr_pusch_ptrs_t *b_pusch_ptrs = &b->pusch_ptrs; + + EQ(a_pusch_ptrs->num_ptrs_ports, b_pusch_ptrs->num_ptrs_ports); + for (int i = 0; i < a_pusch_ptrs->num_ptrs_ports; ++i) { + const nfapi_nr_ptrs_ports_t *a_ptrs_port = &a_pusch_ptrs->ptrs_ports_list[i]; + const nfapi_nr_ptrs_ports_t *b_ptrs_port = &b_pusch_ptrs->ptrs_ports_list[i]; + + EQ(a_ptrs_port->ptrs_port_index, b_ptrs_port->ptrs_port_index); + EQ(a_ptrs_port->ptrs_dmrs_port, b_ptrs_port->ptrs_dmrs_port); + EQ(a_ptrs_port->ptrs_re_offset, b_ptrs_port->ptrs_re_offset); + } + + EQ(a_pusch_ptrs->ptrs_time_density, b_pusch_ptrs->ptrs_time_density); + EQ(a_pusch_ptrs->ptrs_freq_density, b_pusch_ptrs->ptrs_freq_density); + EQ(a_pusch_ptrs->ul_ptrs_power, b_pusch_ptrs->ul_ptrs_power); + } + if (a->pdu_bit_map & PUSCH_PDU_BITMAP_DFTS_OFDM) { + const nfapi_nr_dfts_ofdm_t *a_dfts_ofdm = &a->dfts_ofdm; + const nfapi_nr_dfts_ofdm_t *b_dfts_ofdm = &b->dfts_ofdm; + + EQ(a_dfts_ofdm->low_papr_group_number, b_dfts_ofdm->low_papr_group_number); + EQ(a_dfts_ofdm->low_papr_sequence_number, b_dfts_ofdm->low_papr_sequence_number); + EQ(a_dfts_ofdm->ul_ptrs_sample_density, b_dfts_ofdm->ul_ptrs_sample_density); + EQ(a_dfts_ofdm->ul_ptrs_time_density_transform_precoding, b_dfts_ofdm->ul_ptrs_time_density_transform_precoding); + } + EQ(eq_ul_tti_beamforming(&a->beamforming, &b->beamforming), true); + EQ(a->maintenance_parms_v3.ldpcBaseGraph, b->maintenance_parms_v3.ldpcBaseGraph); + EQ(a->maintenance_parms_v3.tbSizeLbrmBytes, b->maintenance_parms_v3.tbSizeLbrmBytes); + return true; +} + +static bool eq_ul_tti_request_pucch_pdu(const nfapi_nr_pucch_pdu_t *a, const nfapi_nr_pucch_pdu_t *b) +{ + EQ(a->rnti, b->rnti); + EQ(a->handle, b->handle); + EQ(a->bwp_size, b->bwp_size); + EQ(a->bwp_start, b->bwp_start); + EQ(a->subcarrier_spacing, b->subcarrier_spacing); + EQ(a->cyclic_prefix, b->cyclic_prefix); + EQ(a->format_type, b->format_type); + EQ(a->multi_slot_tx_indicator, b->multi_slot_tx_indicator); + EQ(a->pi_2bpsk, b->pi_2bpsk); + EQ(a->prb_start, b->prb_start); + EQ(a->prb_size, b->prb_size); + EQ(a->start_symbol_index, b->start_symbol_index); + EQ(a->nr_of_symbols, b->nr_of_symbols); + EQ(a->freq_hop_flag, b->freq_hop_flag); + EQ(a->second_hop_prb, b->second_hop_prb); + EQ(a->group_hop_flag, b->group_hop_flag); + EQ(a->sequence_hop_flag, b->sequence_hop_flag); + EQ(a->hopping_id, b->hopping_id); + EQ(a->initial_cyclic_shift, b->initial_cyclic_shift); + EQ(a->data_scrambling_id, b->data_scrambling_id); + EQ(a->time_domain_occ_idx, b->time_domain_occ_idx); + EQ(a->pre_dft_occ_idx, b->pre_dft_occ_idx); + EQ(a->pre_dft_occ_len, b->pre_dft_occ_len); + EQ(a->add_dmrs_flag, b->add_dmrs_flag); + EQ(a->dmrs_scrambling_id, b->dmrs_scrambling_id); + EQ(a->dmrs_cyclic_shift, b->dmrs_cyclic_shift); + EQ(a->sr_flag, b->sr_flag); + EQ(a->bit_len_harq, b->bit_len_harq); + EQ(a->bit_len_csi_part1, b->bit_len_csi_part1); + EQ(a->bit_len_csi_part2, b->bit_len_csi_part2); + EQ(eq_ul_tti_beamforming(&a->beamforming, &b->beamforming), true); + return true; +} + +static bool eq_ul_tti_request_srs_parameters(const nfapi_v4_srs_parameters_t *a, + const uint8_t num_symbols, + const nfapi_v4_srs_parameters_t *b) +{ + EQ(a->srs_bandwidth_size, b->srs_bandwidth_size); + for (int symbol_idx = 0; symbol_idx < num_symbols; ++symbol_idx) { + const nfapi_v4_srs_parameters_symbols_t *a_symbol = &a->symbol_list[symbol_idx]; + const nfapi_v4_srs_parameters_symbols_t *b_symbol = &b->symbol_list[symbol_idx]; + EQ(a_symbol->srs_bandwidth_start, b_symbol->srs_bandwidth_start); + EQ(a_symbol->sequence_group, b_symbol->sequence_group); + EQ(a_symbol->sequence_number, b_symbol->sequence_number); + } + +#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) { + const nfapi_v4_srs_parameters_symbols_t *a_symbol = &a->symbol_list[symbol_idx]; + const nfapi_v4_srs_parameters_symbols_t *b_symbol = &b->symbol_list[symbol_idx]; + EQ(a_symbol->srs_bandwidth_start, b_symbol->srs_bandwidth_start); + EQ(a_symbol->sequence_group, b_symbol->sequence_group); + EQ(a_symbol->sequence_number, b_symbol->sequence_number); + } +#endif // ENABLE_AERIAL + + EQ(a->usage, b->usage); + const uint8_t nUsage = __builtin_popcount(a->usage); + for (int idx = 0; idx < nUsage; ++idx) { + EQ(a->report_type[idx], b->report_type[idx]); + } + EQ(a->singular_Value_representation, b->singular_Value_representation); + EQ(a->iq_representation, b->iq_representation); + EQ(a->prg_size, b->prg_size); + EQ(a->num_total_ue_antennas, b->num_total_ue_antennas); + EQ(a->ue_antennas_in_this_srs_resource_set, b->ue_antennas_in_this_srs_resource_set); + EQ(a->sampled_ue_antennas, b->sampled_ue_antennas); + EQ(a->report_scope, b->report_scope); + EQ(a->num_ul_spatial_streams_ports, b->num_ul_spatial_streams_ports); + for (int idx = 0; idx < a->num_ul_spatial_streams_ports; ++idx) { + EQ(a->Ul_spatial_stream_ports[idx], b->Ul_spatial_stream_ports[idx]); + } + return true; +} + +static bool eq_ul_tti_request_srs_pdu(const nfapi_nr_srs_pdu_t *a, const nfapi_nr_srs_pdu_t *b) +{ + EQ(a->rnti, b->rnti); + EQ(a->handle, b->handle); + EQ(a->bwp_size, b->bwp_size); + EQ(a->bwp_start, b->bwp_start); + EQ(a->subcarrier_spacing, b->subcarrier_spacing); + EQ(a->cyclic_prefix, b->cyclic_prefix); + EQ(a->num_ant_ports, b->num_ant_ports); + EQ(a->num_symbols, b->num_symbols); + EQ(a->num_repetitions, b->num_repetitions); + EQ(a->time_start_position, b->time_start_position); + EQ(a->config_index, b->config_index); + EQ(a->sequence_id, b->sequence_id); + EQ(a->bandwidth_index, b->bandwidth_index); + EQ(a->comb_size, b->comb_size); + EQ(a->comb_offset, b->comb_offset); + EQ(a->cyclic_shift, b->cyclic_shift); + EQ(a->frequency_position, b->frequency_position); + EQ(a->frequency_shift, b->frequency_shift); + EQ(a->frequency_hopping, b->frequency_hopping); + EQ(a->group_or_sequence_hopping, b->group_or_sequence_hopping); + EQ(a->resource_type, b->resource_type); + EQ(a->t_srs, b->t_srs); + EQ(a->t_offset, b->t_offset); + EQ(eq_ul_tti_beamforming(&a->beamforming, &b->beamforming), true); + EQ(eq_ul_tti_request_srs_parameters(&a->srs_parameters_v4, 1 << a->num_symbols, &b->srs_parameters_v4), true); + return true; +} + +bool eq_ul_tti_request(const nfapi_nr_ul_tti_request_t *a, const nfapi_nr_ul_tti_request_t *b) +{ + EQ(a->header.message_id, b->header.message_id); + EQ(a->header.message_length, b->header.message_length); + + EQ(a->SFN, b->SFN); + EQ(a->Slot, b->Slot); + EQ(a->n_pdus, b->n_pdus); + EQ(a->rach_present, b->rach_present); + EQ(a->n_ulsch, b->n_ulsch); + EQ(a->n_ulcch, b->n_ulcch); + EQ(a->n_group, b->n_group); + + for (int PDU = 0; PDU < a->n_pdus; ++PDU) { + // take the PDU at the start of loops + const nfapi_nr_ul_tti_request_number_of_pdus_t *a_pdu = &a->pdus_list[PDU]; + const nfapi_nr_ul_tti_request_number_of_pdus_t *b_pdu = &b->pdus_list[PDU]; + + EQ(a_pdu->pdu_type, b_pdu->pdu_type); + EQ(a_pdu->pdu_size, b_pdu->pdu_size); + + switch (a_pdu->pdu_type) { + case NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE: + EQ(eq_ul_tti_request_prach_pdu(&a_pdu->prach_pdu, &b_pdu->prach_pdu), true); + break; + case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: + EQ(eq_ul_tti_request_pusch_pdu(&a_pdu->pusch_pdu, &b_pdu->pusch_pdu), true); + break; + case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: + EQ(eq_ul_tti_request_pucch_pdu(&a_pdu->pucch_pdu, &b_pdu->pucch_pdu), true); + break; + case NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE: + EQ(eq_ul_tti_request_srs_pdu(&a_pdu->srs_pdu, &b_pdu->srs_pdu), true); + break; + default: + // PDU Type is not any known value + return false; + } + } + + for (int nGroup = 0; nGroup < a->n_group; ++nGroup) { + EQ(a->groups_list[nGroup].n_ue, b->groups_list[nGroup].n_ue); + for (int UE = 0; UE < a->groups_list[nGroup].n_ue; ++UE) { + EQ(a->groups_list[nGroup].ue_list[UE].pdu_idx, b->groups_list[nGroup].ue_list[UE].pdu_idx); + } + } + return true; +} + void free_dl_tti_request(nfapi_nr_dl_tti_request_t *msg) { if (msg->vendor_extension) { @@ -217,6 +494,20 @@ void free_dl_tti_request(nfapi_nr_dl_tti_request_t *msg) } } +void free_ul_tti_request(nfapi_nr_ul_tti_request_t *msg) +{ + for (int idx_pdu = 0; idx_pdu < msg->n_pdus; ++idx_pdu) { + nfapi_nr_ul_tti_request_number_of_pdus_t *pdu = &msg->pdus_list[idx_pdu]; + switch (pdu->pdu_type) { + case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: + free(pdu->pusch_pdu.pusch_ptrs.ptrs_ports_list); + break; + default: + break; + } + } +} + static void copy_dl_tti_beamforming(const nfapi_nr_tx_precoding_and_beamforming_t *src, nfapi_nr_tx_precoding_and_beamforming_t *dst) { @@ -404,3 +695,275 @@ void copy_dl_tti_request(const nfapi_nr_dl_tti_request_t *src, nfapi_nr_dl_tti_r } } } + +static void copy_ul_tti_beamforming(const nfapi_nr_ul_beamforming_t *src, nfapi_nr_ul_beamforming_t *dst) +{ + dst->trp_scheme = src->trp_scheme; + dst->num_prgs = src->num_prgs; + dst->prg_size = src->prg_size; + dst->dig_bf_interface = src->dig_bf_interface; + + for (int prg = 0; prg < dst->num_prgs; ++prg) { + if (dst->dig_bf_interface > 0) { + for (int dbf_if = 0; dbf_if < dst->dig_bf_interface; ++dbf_if) { + dst->prgs_list[prg].dig_bf_interface_list[dbf_if].beam_idx = src->prgs_list[prg].dig_bf_interface_list[dbf_if].beam_idx; + } + } + } +} + +static void copy_ul_tti_request_prach_pdu(const nfapi_nr_prach_pdu_t *src, nfapi_nr_prach_pdu_t *dst) +{ + dst->phys_cell_id = src->phys_cell_id; + dst->num_prach_ocas = src->num_prach_ocas; + dst->prach_format = src->prach_format; + dst->num_ra = src->num_ra; + dst->prach_start_symbol = src->prach_start_symbol; + dst->num_cs = src->num_cs; + copy_ul_tti_beamforming(&src->beamforming, &dst->beamforming); +} + +static void copy_ul_tti_request_pusch_pdu(const nfapi_nr_pusch_pdu_t *src, nfapi_nr_pusch_pdu_t *dst) +{ + dst->pdu_bit_map = src->pdu_bit_map; + dst->rnti = src->rnti; + dst->handle = src->handle; + dst->bwp_size = src->bwp_size; + dst->bwp_start = src->bwp_start; + dst->subcarrier_spacing = src->subcarrier_spacing; + dst->cyclic_prefix = src->cyclic_prefix; + dst->target_code_rate = src->target_code_rate; + dst->qam_mod_order = src->qam_mod_order; + dst->mcs_index = src->mcs_index; + dst->mcs_table = src->mcs_table; + dst->transform_precoding = src->transform_precoding; + dst->data_scrambling_id = src->data_scrambling_id; + dst->nrOfLayers = src->nrOfLayers; + dst->ul_dmrs_symb_pos = src->ul_dmrs_symb_pos; + dst->dmrs_config_type = src->dmrs_config_type; + dst->ul_dmrs_scrambling_id = src->ul_dmrs_scrambling_id; + dst->pusch_identity = src->pusch_identity; + dst->scid = src->scid; + dst->num_dmrs_cdm_grps_no_data = src->num_dmrs_cdm_grps_no_data; + dst->dmrs_ports = src->dmrs_ports; + dst->resource_alloc = src->resource_alloc; + for (int i = 0; i < 36; ++i) { + dst->rb_bitmap[i] = src->rb_bitmap[i]; + } + dst->rb_start = src->rb_start; + dst->rb_size = src->rb_size; + dst->vrb_to_prb_mapping = src->vrb_to_prb_mapping; + dst->frequency_hopping = src->frequency_hopping; + dst->tx_direct_current_location = src->tx_direct_current_location; + dst->uplink_frequency_shift_7p5khz = src->uplink_frequency_shift_7p5khz; + dst->start_symbol_index = src->start_symbol_index; + dst->nr_of_symbols = src->nr_of_symbols; + + if (dst->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_DATA) { + const nfapi_nr_pusch_data_t *src_pusch_data = &src->pusch_data; + nfapi_nr_pusch_data_t *dst_pusch_data = &dst->pusch_data; + dst_pusch_data->rv_index = src_pusch_data->rv_index; + dst_pusch_data->harq_process_id = src_pusch_data->harq_process_id; + dst_pusch_data->new_data_indicator = src_pusch_data->new_data_indicator; + dst_pusch_data->tb_size = src_pusch_data->tb_size; + dst_pusch_data->num_cb = src_pusch_data->num_cb; + for (int i = 0; i < (src_pusch_data->num_cb + 7) / 8; ++i) { + dst_pusch_data->cb_present_and_position[i] = src_pusch_data->cb_present_and_position[i]; + } + } + if (src->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_UCI) { + const nfapi_nr_pusch_uci_t *src_pusch_uci = &src->pusch_uci; + nfapi_nr_pusch_uci_t *dst_pusch_uci = &dst->pusch_uci; + dst_pusch_uci->harq_ack_bit_length = src_pusch_uci->harq_ack_bit_length; + dst_pusch_uci->csi_part1_bit_length = src_pusch_uci->csi_part1_bit_length; + dst_pusch_uci->csi_part2_bit_length = src_pusch_uci->csi_part2_bit_length; + dst_pusch_uci->alpha_scaling = src_pusch_uci->alpha_scaling; + dst_pusch_uci->beta_offset_harq_ack = src_pusch_uci->beta_offset_harq_ack; + dst_pusch_uci->beta_offset_csi1 = src_pusch_uci->beta_offset_csi1; + dst_pusch_uci->beta_offset_csi2 = src_pusch_uci->beta_offset_csi2; + } + if (src->pdu_bit_map & PUSCH_PDU_BITMAP_PUSCH_PTRS) { + const nfapi_nr_pusch_ptrs_t *src_pusch_ptrs = &src->pusch_ptrs; + nfapi_nr_pusch_ptrs_t *dst_pusch_ptrs = &dst->pusch_ptrs; + + dst_pusch_ptrs->num_ptrs_ports = src_pusch_ptrs->num_ptrs_ports; + dst_pusch_ptrs->ptrs_ports_list = calloc(dst_pusch_ptrs->num_ptrs_ports, sizeof(nfapi_nr_ptrs_ports_t)); + for (int i = 0; i < src_pusch_ptrs->num_ptrs_ports; ++i) { + const nfapi_nr_ptrs_ports_t *src_ptrs_port = &src_pusch_ptrs->ptrs_ports_list[i]; + nfapi_nr_ptrs_ports_t *dst_ptrs_port = &dst_pusch_ptrs->ptrs_ports_list[i]; + + dst_ptrs_port->ptrs_port_index = src_ptrs_port->ptrs_port_index; + dst_ptrs_port->ptrs_dmrs_port = src_ptrs_port->ptrs_dmrs_port; + dst_ptrs_port->ptrs_re_offset = src_ptrs_port->ptrs_re_offset; + } + + dst_pusch_ptrs->ptrs_time_density = src_pusch_ptrs->ptrs_time_density; + dst_pusch_ptrs->ptrs_freq_density = src_pusch_ptrs->ptrs_freq_density; + dst_pusch_ptrs->ul_ptrs_power = src_pusch_ptrs->ul_ptrs_power; + } + if (src->pdu_bit_map & PUSCH_PDU_BITMAP_DFTS_OFDM) { + const nfapi_nr_dfts_ofdm_t *src_dfts_ofdm = &src->dfts_ofdm; + nfapi_nr_dfts_ofdm_t *dst_dfts_ofdm = &dst->dfts_ofdm; + + dst_dfts_ofdm->low_papr_group_number = src_dfts_ofdm->low_papr_group_number; + dst_dfts_ofdm->low_papr_sequence_number = src_dfts_ofdm->low_papr_sequence_number; + dst_dfts_ofdm->ul_ptrs_sample_density = src_dfts_ofdm->ul_ptrs_sample_density; + dst_dfts_ofdm->ul_ptrs_time_density_transform_precoding = src_dfts_ofdm->ul_ptrs_time_density_transform_precoding; + } + copy_ul_tti_beamforming(&src->beamforming, &dst->beamforming); + dst->maintenance_parms_v3.ldpcBaseGraph = src->maintenance_parms_v3.ldpcBaseGraph; + dst->maintenance_parms_v3.tbSizeLbrmBytes = src->maintenance_parms_v3.tbSizeLbrmBytes; +} + +static void copy_ul_tti_request_pucch_pdu(const nfapi_nr_pucch_pdu_t *src, nfapi_nr_pucch_pdu_t *dst) +{ + dst->rnti = src->rnti; + dst->handle = src->handle; + dst->bwp_size = src->bwp_size; + dst->bwp_start = src->bwp_start; + dst->subcarrier_spacing = src->subcarrier_spacing; + dst->cyclic_prefix = src->cyclic_prefix; + dst->format_type = src->format_type; + dst->multi_slot_tx_indicator = src->multi_slot_tx_indicator; + dst->pi_2bpsk = src->pi_2bpsk; + dst->prb_start = src->prb_start; + dst->prb_size = src->prb_size; + dst->start_symbol_index = src->start_symbol_index; + dst->nr_of_symbols = src->nr_of_symbols; + dst->freq_hop_flag = src->freq_hop_flag; + dst->second_hop_prb = src->second_hop_prb; + dst->group_hop_flag = src->group_hop_flag; + dst->sequence_hop_flag = src->sequence_hop_flag; + dst->hopping_id = src->hopping_id; + dst->initial_cyclic_shift = src->initial_cyclic_shift; + dst->data_scrambling_id = src->data_scrambling_id; + dst->time_domain_occ_idx = src->time_domain_occ_idx; + dst->pre_dft_occ_idx = src->pre_dft_occ_idx; + dst->pre_dft_occ_len = src->pre_dft_occ_len; + dst->add_dmrs_flag = src->add_dmrs_flag; + dst->dmrs_scrambling_id = src->dmrs_scrambling_id; + dst->dmrs_cyclic_shift = src->dmrs_cyclic_shift; + dst->sr_flag = src->sr_flag; + dst->bit_len_harq = src->bit_len_harq; + dst->bit_len_csi_part1 = src->bit_len_csi_part1; + dst->bit_len_csi_part2 = src->bit_len_csi_part2; + copy_ul_tti_beamforming(&src->beamforming, &dst->beamforming); +} + +static void copy_ul_tti_request_srs_parameters(const nfapi_v4_srs_parameters_t *src, + const uint8_t num_symbols, + nfapi_v4_srs_parameters_t *dst) +{ + dst->srs_bandwidth_size = src->srs_bandwidth_size; + for (int symbol_idx = 0; symbol_idx < num_symbols; ++symbol_idx) { + nfapi_v4_srs_parameters_symbols_t *dst_symbol = &dst->symbol_list[symbol_idx]; + const nfapi_v4_srs_parameters_symbols_t *src_symbol = &src->symbol_list[symbol_idx]; + dst_symbol->srs_bandwidth_start = src_symbol->srs_bandwidth_start; + dst_symbol->sequence_group = src_symbol->sequence_group; + dst_symbol->sequence_number = src_symbol->sequence_number; + } + +#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 *dst_symbol = &dst->symbol_list[symbol_idx]; + const nfapi_v4_srs_parameters_symbols_t *src_symbol = &src->symbol_list[symbol_idx]; + dst_symbol->srs_bandwidth_start = src_symbol->srs_bandwidth_start; + dst_symbol->sequence_group = src_symbol->sequence_group; + dst_symbol->sequence_number = src_symbol->sequence_number; + } +#endif // ENABLE_AERIAL + dst->usage = src->usage; + const uint8_t nUsage = __builtin_popcount(dst->usage); + for (int idx = 0; idx < nUsage; ++idx) { + dst->report_type[idx] = src->report_type[idx]; + } + dst->singular_Value_representation = src->singular_Value_representation; + dst->iq_representation = src->iq_representation; + dst->prg_size = src->prg_size; + dst->num_total_ue_antennas = src->num_total_ue_antennas; + dst->ue_antennas_in_this_srs_resource_set = src->ue_antennas_in_this_srs_resource_set; + dst->sampled_ue_antennas = src->sampled_ue_antennas; + dst->report_scope = src->report_scope; + dst->num_ul_spatial_streams_ports = src->num_ul_spatial_streams_ports; + for (int idx = 0; idx < dst->num_ul_spatial_streams_ports; ++idx) { + dst->Ul_spatial_stream_ports[idx] = src->Ul_spatial_stream_ports[idx]; + } +} + +static void copy_ul_tti_request_srs_pdu(const nfapi_nr_srs_pdu_t *src, nfapi_nr_srs_pdu_t *dst) +{ + dst->rnti = src->rnti; + dst->handle = src->handle; + dst->bwp_size = src->bwp_size; + dst->bwp_start = src->bwp_start; + dst->subcarrier_spacing = src->subcarrier_spacing; + dst->cyclic_prefix = src->cyclic_prefix; + dst->num_ant_ports = src->num_ant_ports; + dst->num_symbols = src->num_symbols; + dst->num_repetitions = src->num_repetitions; + dst->time_start_position = src->time_start_position; + dst->config_index = src->config_index; + dst->sequence_id = src->sequence_id; + dst->bandwidth_index = src->bandwidth_index; + dst->comb_size = src->comb_size; + dst->comb_offset = src->comb_offset; + dst->cyclic_shift = src->cyclic_shift; + dst->frequency_position = src->frequency_position; + dst->frequency_shift = src->frequency_shift; + dst->frequency_hopping = src->frequency_hopping; + dst->group_or_sequence_hopping = src->group_or_sequence_hopping; + dst->resource_type = src->resource_type; + dst->t_srs = src->t_srs; + dst->t_offset = src->t_offset; + copy_ul_tti_beamforming(&src->beamforming, &dst->beamforming); + copy_ul_tti_request_srs_parameters(&src->srs_parameters_v4, 1 << src->num_symbols, &dst->srs_parameters_v4); +} + +void copy_ul_tti_request(const nfapi_nr_ul_tti_request_t *src, nfapi_nr_ul_tti_request_t *dst) +{ + dst->header.message_id = src->header.message_id; + dst->header.message_length = src->header.message_length; + + dst->SFN = src->SFN; + dst->Slot = src->Slot; + dst->n_pdus = src->n_pdus; + dst->rach_present = src->rach_present; + dst->n_ulsch = src->n_ulsch; + dst->n_ulcch = src->n_ulcch; + dst->n_group = src->n_group; + + for (int PDU = 0; PDU < src->n_pdus; ++PDU) { + // take the PDU at the start of loops + const nfapi_nr_ul_tti_request_number_of_pdus_t *src_pdu = &src->pdus_list[PDU]; + nfapi_nr_ul_tti_request_number_of_pdus_t *dst_pdu = &dst->pdus_list[PDU]; + + dst_pdu->pdu_type = src_pdu->pdu_type; + dst_pdu->pdu_size = src_pdu->pdu_size; + + switch (src_pdu->pdu_type) { + case NFAPI_NR_UL_CONFIG_PRACH_PDU_TYPE: + copy_ul_tti_request_prach_pdu(&src_pdu->prach_pdu, &dst_pdu->prach_pdu); + break; + case NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE: + copy_ul_tti_request_pusch_pdu(&src_pdu->pusch_pdu, &dst_pdu->pusch_pdu); + break; + case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: + copy_ul_tti_request_pucch_pdu(&src_pdu->pucch_pdu, &dst_pdu->pucch_pdu); + break; + case NFAPI_NR_UL_CONFIG_SRS_PDU_TYPE: + copy_ul_tti_request_srs_pdu(&src_pdu->srs_pdu, &dst_pdu->srs_pdu); + break; + default: + // PDU Type is not any known value + AssertFatal(1 == 0, "PDU Type value unknown, allowed values range from 0 to 3\n"); + } + } + + for (int nGroup = 0; nGroup < src->n_group; ++nGroup) { + dst->groups_list[nGroup].n_ue = src->groups_list[nGroup].n_ue; + for (int UE = 0; UE < src->groups_list[nGroup].n_ue; ++UE) { + dst->groups_list[nGroup].ue_list[UE].pdu_idx = src->groups_list[nGroup].ue_list[UE].pdu_idx; + } + } +} diff --git a/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface_scf.h b/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface_scf.h index 1cdbd8921f..9c7f4c251a 100644 --- a/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface_scf.h +++ b/nfapi/open-nFAPI/nfapi/public_inc/nfapi_nr_interface_scf.h @@ -1359,7 +1359,7 @@ typedef struct uint8_t dmrs_cyclic_shift; uint8_t sr_flag; - uint8_t bit_len_harq; + uint16_t bit_len_harq; uint16_t bit_len_csi_part1; uint16_t bit_len_csi_part2; @@ -1375,7 +1375,7 @@ typedef struct { typedef struct { uint16_t srs_bandwidth_size; // mSRS,b: Number of PRB’s that are sounded for each SRS symbol, per 3GPP TS 38.211, section 6.4.1.4.3. Value: 4->272 - nfapi_v4_srs_parameters_symbols_t *symbol_list; + nfapi_v4_srs_parameters_symbols_t symbol_list[4]; uint32_t usage; // Bitmap indicating the type of report(s) expected at L2 from the SRS signaled by this PDU. Bit positions: 0 – beamManagement; 1 – codebook; 2 – nonCodebook; 3 – antennaSwitching; 4 – 255: reserved. For each of this bit positions: 1 = requested; 0 = not requested. nUsage = sum(all bits in usage) uint8_t report_type[4]; // Interpretation of each Report Type depends on usage: beamManagement (1 = PRG SNR, 2-255 reserved); codebook (1 = PRG I and Q channel estimate, per srs Tx port and gNB antenna element, 2-255 reserved); nonCodebook (1 = PRG I and Q channel estimate, per SRI and gNB antenna element, 2-255 reserved); antennaSwitching (1 = SVD representation UE Rx and gNB sets of antenna element, 2-255 reserved); all (0 – no report required). uint8_t singular_Value_representation; // 0 – 8-bit dB; 1 – 16-bit linear; 255 – not applicable diff --git a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c index bd85c756ed..b73194f4cd 100644 --- a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c +++ b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c @@ -725,6 +725,24 @@ static uint8_t pack_ul_config_request_ulsch_rel13_value(void *tlv, uint8_t **ppW //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) @@ -733,54 +751,8 @@ static uint8_t pack_ul_tti_request_prach_pdu(nfapi_nr_prach_pdu_t *prach_pdu, ui return 0; } - // Pack RX Beamforming PDU - if (!(push16(prach_pdu->beamforming.num_prgs, ppWritePackedMsg, end) - && push16(prach_pdu->beamforming.prg_size, ppWritePackedMsg, end) - && push8(prach_pdu->beamforming.dig_bf_interface, ppWritePackedMsg, end))) - return 0; + return pack_nr_rx_beamforming_pdu(&prach_pdu->beamforming, ppWritePackedMsg, end); - for (int prg = 0; prg < prach_pdu->beamforming.num_prgs; prg++) { - for (int digBFInterface = 0; digBFInterface < prach_pdu->beamforming.dig_bf_interface; digBFInterface++) { - if (!push16(prach_pdu->beamforming.prgs_list[prg].dig_bf_interface_list[digBFInterface].beam_idx, 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) - && push8(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) - // Pack RX Beamforming PDU - && push16(pucch_pdu->beamforming.num_prgs, ppWritePackedMsg, end) - && push16(pucch_pdu->beamforming.prg_size, ppWritePackedMsg, end) - && push8(pucch_pdu->beamforming.dig_bf_interface, ppWritePackedMsg, end))) { - return 0; - } - - for (int prg = 0; prg < pucch_pdu->beamforming.num_prgs; prg++) { - for (int digBFInterface = 0; digBFInterface < pucch_pdu->beamforming.dig_bf_interface; digBFInterface++) { - if (!push16(pucch_pdu->beamforming.prgs_list[prg].dig_bf_interface_list[digBFInterface].beam_idx, ppWritePackedMsg, end)) - return 0; - } - } - return 1; } static uint8_t pack_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pusch_pdu, uint8_t **ppWritePackedMsg, uint8_t *end) @@ -802,83 +774,144 @@ static uint8_t pack_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pusch_pdu, ui && 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) - // TODO: ignoring beamforming tlv for now - )) { + && 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 - switch (pusch_pdu->pdu_bit_map) { - case 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; - } - } break; - - case 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; - } - } break; - - case 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; - } - } break; - - case 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; - } - } break; - - default: { - NFAPI_TRACE(NFAPI_TRACE_INFO, "Invalid pdu bitmap %d \n", pusch_pdu->pdu_bit_map); + // 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->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) && @@ -897,23 +930,18 @@ static uint8_t pack_ul_tti_request_srs_pdu(nfapi_nr_srs_pdu_t *srs_pdu, uint8_t push8(srs_pdu->resource_type, ppWritePackedMsg, end) && push16(srs_pdu->t_srs, ppWritePackedMsg, end) && push16(srs_pdu->t_offset, ppWritePackedMsg, end) - // TODO: ignoring beamforming tlv for now )){ return 0; } - // Rx Beamforming PDU - if(!(push16(srs_pdu->beamforming.num_prgs,ppWritePackedMsg,end) && - push16(srs_pdu->beamforming.prg_size,ppWritePackedMsg,end) && - push8(srs_pdu->beamforming.dig_bf_interface,ppWritePackedMsg,end))){ - return 0; + + if (!(pack_nr_rx_beamforming_pdu(&srs_pdu->beamforming, ppWritePackedMsg, end))) { + return 0; } - for(int prg = 0; prg < srs_pdu->beamforming.num_prgs; prg ++){ - for(int digInt = 0; digInt < srs_pdu->beamforming.dig_bf_interface; digInt++){ - if(!push16(srs_pdu->beamforming.prgs_list[0].dig_bf_interface_list[0].beam_idx,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; } @@ -1226,13 +1254,13 @@ static uint8_t pack_ul_tti_pdu_list_value(void *tlv, uint8_t **ppWritePackedMsg, return 0; } break; - case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { - if (!pack_ul_tti_request_pucch_pdu(&value->pucch_pdu, ppWritePackedMsg, end)) + 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_PUSCH_PDU_TYPE: { - if (!pack_ul_tti_request_pusch_pdu(&value->pusch_pdu, ppWritePackedMsg, end)) + case NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE: { + if (!pack_ul_tti_request_pucch_pdu(&value->pucch_pdu, ppWritePackedMsg, end)) return 0; } break; @@ -4287,63 +4315,34 @@ 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(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end) +static uint8_t unpack_ul_tti_request_prach_pdu(nfapi_nr_prach_pdu_t *prach_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) { - nfapi_nr_prach_pdu_t *prach_pdu = (nfapi_nr_prach_pdu_t *)tlv; - 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; } - // Unpack RX Beamforming PDU - if (!(pull16(ppReadPackedMsg, &prach_pdu->beamforming.num_prgs, end) - && pull16(ppReadPackedMsg, &prach_pdu->beamforming.prg_size, end) - && pull8(ppReadPackedMsg, &prach_pdu->beamforming.dig_bf_interface, end))) { - return 0; - } - for (int prg = 0; prg < prach_pdu->beamforming.num_prgs; prg++) { - for (int digBFInterface = 0; digBFInterface < prach_pdu->beamforming.dig_bf_interface; digBFInterface++) { - if (!pull16(ppReadPackedMsg, &prach_pdu->beamforming.prgs_list[prg].dig_bf_interface_list[digBFInterface].beam_idx, end)) { - return 0; - } - } - } - - return 1; + return unpack_nr_rx_beamforming_pdu(&prach_pdu->beamforming, ppReadPackedMsg, end); } -static uint8_t unpack_ul_tti_request_pucch_pdu(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end) +static uint8_t unpack_ul_tti_request_pusch_pdu(nfapi_nr_pusch_pdu_t *pusch_pdu, uint8_t **ppReadPackedMsg, uint8_t *end) { - nfapi_nr_pucch_pdu_t *pucch_pdu = (nfapi_nr_pucch_pdu_t *)tlv; - uint16_t dummy16 = 0; - uint8_t dummy8 = 0; - return (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) - && pull8(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) && - // TODO: ignoring beamforming tlv for now - pull16(ppReadPackedMsg, &dummy16, end) && pull16(ppReadPackedMsg, &dummy16, end) && pull8(ppReadPackedMsg, &dummy8, end)); -} - -static uint8_t unpack_ul_tti_request_pusch_pdu(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end) -{ - nfapi_nr_pusch_pdu_t *pusch_pdu = (nfapi_nr_pusch_pdu_t *)tlv; - 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) @@ -4361,62 +4360,72 @@ static uint8_t unpack_ul_tti_request_pusch_pdu(void *tlv, uint8_t **ppReadPacked && 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) - // TODO: ignoring beamforming tlv for now - )) + && pull8(ppReadPackedMsg, &pusch_pdu->start_symbol_index, end) && pull8(ppReadPackedMsg, &pusch_pdu->nr_of_symbols, end))) return 0; - // Pack Optional Data only included if indicated in pduBitmap - switch (pusch_pdu->pdu_bit_map) { - case 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; - } - } break; - - case 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; - } - } break; - - case PUSCH_PDU_BITMAP_PUSCH_PTRS: { - if (!(pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.num_ptrs_ports, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list->ptrs_dmrs_port, end) - && pull16(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list->ptrs_port_index, end) - && pull8(ppReadPackedMsg, &pusch_pdu->pusch_ptrs.ptrs_ports_list->ptrs_re_offset, end) - && 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; - } - } break; - - case 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; - } - } break; - - default: { - NFAPI_TRACE(NFAPI_TRACE_INFO, "Invalid pdu bitmap %d \n", pusch_pdu->pdu_bit_map); + // 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))) @@ -4425,10 +4434,71 @@ static uint8_t unpack_ul_tti_request_pusch_pdu(void *tlv, uint8_t **ppReadPacked return 1; } -static uint8_t unpack_ul_tti_request_srs_pdu(void *tlv, uint8_t **ppReadPackedMsg, uint8_t *end) { - nfapi_nr_srs_pdu_t *srs_pdu = (nfapi_nr_srs_pdu_t *)tlv; - return( - pull16(ppReadPackedMsg, &srs_pdu->rnti, end) && +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) && @@ -4450,9 +4520,18 @@ static uint8_t unpack_ul_tti_request_srs_pdu(void *tlv, uint8_t **ppReadPackedMs 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) - // TODO: ignoring beamforming tlv for now - ); + 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; } @@ -4471,18 +4550,17 @@ static uint8_t unpack_ul_tti_pdu_list_value(uint8_t **ppReadPackedMsg, uint8_t * } 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_PUSCH_PDU_TYPE: { - if(!unpack_ul_tti_request_pusch_pdu(&pNfapiMsg->pusch_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; @@ -4525,10 +4603,10 @@ uint8_t unpack_ul_tti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg return 0; if (!pull8(ppReadPackedMsg, &pNfapiMsg->rach_present, end)) return 0; - if (!pull8(ppReadPackedMsg, &pNfapiMsg->n_ulcch, 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++) {