Skip to content

O
OpenXG-RAN
Commit 75f213ea authored by Rúben Soares Silva's avatar Rúben Soares Silva Committed by Robert Schmidt
Browse files
Options

Move functions for packing/unpacking UL_TTI.request 

Add unitary test for UL_TTI.request ( test pack/unpack, free, copy and compare )

Add function rand32_range
parent 0653c38a
Show whitespace changes
Inline Side-by-side
Showing with 1107 additions and 643 deletions
nfapi/open-nFAPI/fapi/inc/nr_fapi_p7.h
View file @ 75f213ea
......@@ -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
nfapi/open-nFAPI/fapi/src/nr_fapi_p7.c
View file @ 75f213ea
......@@ -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;
}
nfapi/open-nFAPI/nfapi/public_inc/nr_nfapi_p7.h
View file @ 75f213ea
......@@ -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);
......
nfapi/open-nFAPI/nfapi/src/nfapi_p7.c
View file @ 75f213ea
......@@ -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; i<value->n_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[] = {
......
nfapi/tests/nr_fapi_test.h
View file @ 75f213ea
......@@ -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)
......
nfapi/tests/p7/CMakeLists.txt
View file @ 75f213ea
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)
......
nfapi/tests/p7/nr_fapi_ul_tti_request_test.c 0 → 100644
View file @ 75f213ea
/*
* 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 = &params->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 = &params->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, &copy);
DevAssert(eq_ul_tti_request(msg, &copy));
free_ul_tti_request(&copy);
}
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;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment