diff --git a/executables/nr-ue.c b/executables/nr-ue.c index 86dc32674b..245e22ae60 100644 --- a/executables/nr-ue.c +++ b/executables/nr-ue.c @@ -19,6 +19,8 @@ * contact@openairinterface.org */ +#define _GNU_SOURCE // For pthread_setname_np +#include #include #include "executables/nr-uesoftmodem.h" #include "PHY/phy_extern_nr_ue.h" @@ -199,31 +201,16 @@ static void process_queued_nr_nfapi_msgs(NR_UE_MAC_INST_t *mac, int sfn_slot) nfapi_nr_rach_indication_t *rach_ind = unqueue_matching(&nr_rach_ind_queue, MAX_QUEUE_SIZE, sfn_slot_matcher, &sfn_slot); nfapi_nr_dl_tti_request_t *dl_tti_request = get_queue(&nr_dl_tti_req_queue); nfapi_nr_ul_dci_request_t *ul_dci_request = get_queue(&nr_ul_dci_req_queue); - LOG_D(NR_MAC, "Try to get a ul_tti_req for HARQ sfn/slot %d %d from queue with %lu items\n", - NFAPI_SFNSLOT2SFN(mac->nr_ue_emul_l1.active_harq_sfn_slot), - NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.active_harq_sfn_slot), nr_ul_tti_req_queue.num_items); - nfapi_nr_ul_tti_request_t *ul_tti_request_harq = unqueue_matching(&nr_ul_tti_req_queue, MAX_QUEUE_SIZE, sfn_slot_matcher, &mac->nr_ue_emul_l1.active_harq_sfn_slot); - if (ul_tti_request_harq && ul_tti_request_harq->n_pdus > 0) - { - check_and_process_dci(NULL, NULL, NULL, ul_tti_request_harq); - } - LOG_D(NR_MAC, "Try to get a ul_tti_req by matching CSI active SFN %d/SLOT %d from queue with %lu items\n", - NFAPI_SFNSLOT2SFN(mac->nr_ue_emul_l1.active_uci_sfn_slot), - NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.active_uci_sfn_slot), nr_ul_tti_req_queue.num_items); - nfapi_nr_ul_tti_request_t *ul_tti_request_uci = unqueue_matching(&nr_ul_tti_req_queue, MAX_QUEUE_SIZE, sfn_slot_matcher, &mac->nr_ue_emul_l1.active_uci_sfn_slot); - if (ul_tti_request_uci && ul_tti_request_uci->n_pdus > 0) - { - check_and_process_dci(NULL, NULL, NULL, ul_tti_request_uci); - } - - LOG_D(NR_MAC, "Try to get a ul_tti_req by matching CRC active SFN %d/SLOT %d from queue with %lu items\n", - NFAPI_SFNSLOT2SFN(mac->nr_ue_emul_l1.crc_rx_ind_sfn_slot), - NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.crc_rx_ind_sfn_slot), nr_ul_tti_req_queue.num_items); - nfapi_nr_ul_tti_request_t *ul_tti_request_crc = unqueue_matching(&nr_ul_tti_req_queue, MAX_QUEUE_SIZE, sfn_slot_matcher, &mac->nr_ue_emul_l1.crc_rx_ind_sfn_slot); - if (ul_tti_request_crc && ul_tti_request_crc->n_pdus > 0) - { - check_and_process_dci(NULL, NULL, NULL, ul_tti_request_crc); + for (int i = 0; i < NR_MAX_HARQ_PROCESSES; i++) { + LOG_D(NR_MAC, "Try to get a ul_tti_req by matching CRC active SFN %d/SLOT %d from queue with %lu items\n", + NFAPI_SFNSLOT2SFN(mac->nr_ue_emul_l1.harq[i].active_ul_harq_sfn_slot), + NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.harq[i].active_ul_harq_sfn_slot), nr_ul_tti_req_queue.num_items); + nfapi_nr_ul_tti_request_t *ul_tti_request_crc = unqueue_matching(&nr_ul_tti_req_queue, MAX_QUEUE_SIZE, sfn_slot_matcher, &mac->nr_ue_emul_l1.harq[i].active_ul_harq_sfn_slot); + if (ul_tti_request_crc && ul_tti_request_crc->n_pdus > 0) + { + check_and_process_dci(NULL, NULL, NULL, ul_tti_request_crc); + } } if (rach_ind && rach_ind->number_of_pdus > 0) @@ -327,6 +314,13 @@ static void *NRUE_phy_stub_standalone_pnf_task(void *arg) int last_sfn_slot = -1; uint16_t sfn_slot = 0; + module_id_t mod_id = 0; + NR_UE_MAC_INST_t *mac = get_mac_inst(mod_id); + for (int i = 0; i < NR_MAX_HARQ_PROCESSES; i++) { + mac->nr_ue_emul_l1.harq[i].active = false; + mac->nr_ue_emul_l1.harq[i].active_ul_harq_sfn_slot = -1; + } + while (!oai_exit) { if (sem_wait(&sfn_slot_semaphore) != 0) @@ -361,8 +355,6 @@ static void *NRUE_phy_stub_standalone_pnf_task(void *arg) LOG_D(NR_MAC, "The received sfn/slot [%d %d] from proxy\n", frame, slot); - module_id_t mod_id = 0; - NR_UE_MAC_INST_t *mac = get_mac_inst(mod_id); if (get_softmodem_params()->sa && mac->mib == NULL) { LOG_D(NR_MAC, "We haven't gotten MIB. Lets see if we received it\n"); @@ -417,8 +409,10 @@ static void *NRUE_phy_stub_standalone_pnf_task(void *arg) mac->scc_SIB->tdd_UL_DL_ConfigurationCommon, ul_info.slot_tx, mac->frame_type)) { - LOG_D(NR_MAC, "Slot %d. calling nr_ue_ul_ind() from %s\n", ul_info.slot_tx, __FUNCTION__); - nr_ue_ul_indication(&ul_info); + LOG_D(NR_MAC, "Slot %d. calling nr_ue_ul_ind() and nr_ue_pucch_scheduler() from %s\n", ul_info.slot_tx, __FUNCTION__); + nr_ue_scheduler(NULL, &ul_info); + nr_ue_prach_scheduler(mod_id, ul_info.frame_tx, ul_info.slot_tx, ul_info.thread_id); + nr_ue_pucch_scheduler(mod_id, ul_info.frame_tx, ul_info.slot_tx, ul_info.thread_id); check_nr_prach(mac, &ul_info, &prach_resources); } if (!IS_SOFTMODEM_NOS1 && get_softmodem_params()->sa) { diff --git a/nfapi/open-nFAPI/nfapi/inc/nfapi.h b/nfapi/open-nFAPI/nfapi/inc/nfapi.h index 0f09efa78a..c1f423a8db 100644 --- a/nfapi/open-nFAPI/nfapi/inc/nfapi.h +++ b/nfapi/open-nFAPI/nfapi/inc/nfapi.h @@ -44,13 +44,21 @@ uint8_t pulls32(uint8_t **in, int32_t *out, uint8_t *end); uint32_t pullarray8(uint8_t **in, uint8_t out[], uint32_t max_len, uint32_t len, uint8_t *end); uint32_t pullarray16(uint8_t **in, uint16_t out[], uint32_t max_len, uint32_t len, uint8_t *end); uint32_t pullarrays16(uint8_t **in, int16_t out[], uint32_t max_len, uint32_t len, uint8_t *end); -uint32_t pullarray32(uint8_t **in, uint32_t out[], uint32_t max_len, uint32_t len, uint8_t *end); +uint32_t pullarray32(uint8_t **values_to_pull, + uint32_t out[], + uint32_t max_num_values_to_pull, + uint32_t num_values_to_pull, + uint8_t *out_end); uint32_t pullarrays32(uint8_t **in, int32_t out[], uint32_t max_len, uint32_t len, uint8_t *end); uint32_t pusharray8(uint8_t in[], uint32_t max_len, uint32_t len, uint8_t **out, uint8_t *end); uint32_t pusharray16(uint16_t in[], uint32_t max_len, uint32_t len, uint8_t **out, uint8_t *end); uint32_t pusharrays16(int16_t in[], uint32_t max_len, uint32_t len, uint8_t **out, uint8_t *end); -uint32_t pusharray32(uint32_t in[], uint32_t max_len, uint32_t len, uint8_t **out, uint8_t *end); +uint32_t pusharray32(const uint32_t *values_to_push, + uint32_t max_num_values_to_push, + uint32_t num_values_to_push, + uint8_t **out, + uint8_t *out_end); uint32_t pusharrays32(int32_t in[], uint32_t max_len, uint32_t len, uint8_t **out, uint8_t *end); typedef uint8_t (*pack_array_elem_fn)(void* elem, uint8_t **ppWritePackedMsg, uint8_t *end); diff --git a/nfapi/open-nFAPI/nfapi/src/nfapi.c b/nfapi/open-nFAPI/nfapi/src/nfapi.c index 44ac0c3720..09c0229db0 100644 --- a/nfapi/open-nFAPI/nfapi/src/nfapi.c +++ b/nfapi/open-nFAPI/nfapi/src/nfapi.c @@ -352,25 +352,31 @@ uint32_t pusharrays16(int16_t in[], uint32_t max_len, uint32_t len, uint8_t **ou return 0; } } -uint32_t pullarray32(uint8_t **in, uint32_t out[], uint32_t max_len, uint32_t len, uint8_t *end) { - if(len == 0) +uint32_t pullarray32(uint8_t **values_to_pull, + uint32_t out[], + uint32_t max_num_values_to_pull, + uint32_t num_values_to_pull, + uint8_t *out_end) { + if (num_values_to_pull == 0) + return 1; - if(len > max_len) { - NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s exceed array size (%d > %d)\n", __FUNCTION__, len, max_len); + if (num_values_to_pull > max_num_values_to_pull) { + NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s exceed array size (%d > %d)\n", + __FUNCTION__, num_values_to_pull, max_num_values_to_pull); on_error(); return 0; } - if((end - (*in)) >= sizeof(uint32_t) * len) { + if ((out_end - (*values_to_pull)) >= sizeof(uint32_t) * num_values_to_pull) { uint32_t idx; - for(idx = 0; idx < len; ++idx) { - if(!pull32(in, &out[idx], end)) + for (idx = 0; idx < num_values_to_pull; ++idx) { + if (!pull32(values_to_pull, &out[idx], out_end)) return 0; } - return sizeof(uint32_t) * len; + return sizeof(uint32_t) * num_values_to_pull; } else { NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s no space in buffer\n", __FUNCTION__); on_error(); @@ -403,25 +409,30 @@ uint32_t pullarrays32(uint8_t **in, int32_t out[], uint32_t max_len, uint32_t le return 0; } } -uint32_t pusharray32(uint32_t in[], uint32_t max_len, uint32_t len, uint8_t **out, uint8_t *end) { - if(len == 0) +uint32_t pusharray32(const uint32_t *values_to_push, + uint32_t max_num_values_to_push, + uint32_t num_values_to_push, + uint8_t **out, + uint8_t *out_end) { + if (num_values_to_push == 0) return 1; - if(len > max_len) { - NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s exceed array size (%d > %d)\n", __FUNCTION__, len, max_len); + if (num_values_to_push > max_num_values_to_push) { + NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s exceed array size (%d > %d)\n", + __FUNCTION__, num_values_to_push, max_num_values_to_push); on_error(); return 0; } - if((end - (*out)) >= sizeof(uint32_t) * len) { + if ((out_end - (*out)) >= sizeof(uint32_t) * num_values_to_push) { uint32_t idx; - for(idx = 0; idx < len; ++idx) { - if(!push32(in[idx], out, end)) + for (idx = 0; idx < num_values_to_push; ++idx) { + if (!push32(values_to_push[idx], out, out_end)) return 0; } - return sizeof(uint32_t) * len; + return sizeof(uint32_t) * num_values_to_push; } else { NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s no space in buffer\n", __FUNCTION__); on_error(); diff --git a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c index 3817aa0895..ab3f2983e3 100644 --- a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c +++ b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c @@ -1893,15 +1893,23 @@ static uint8_t pack_tx_data_pdu_list_value(void *tlv, uint8_t **ppWritePackedMsg switch(value->TLVs[i].tag) { case 0: { - if(!pusharray32(value->TLVs[i].value.direct, 16384, value->TLVs[i].length, ppWritePackedMsg, end)) + if (!pusharray32(value->TLVs[i].value.direct, sizeof(value->TLVs[i].value.direct) / sizeof(uint32_t), + value->TLVs[i].length / sizeof(uint32_t), ppWritePackedMsg, end)) { + NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s():%d. value->TLVs[i].length %d \n", + __FUNCTION__, __LINE__, value->TLVs[i].length); return 0; + } break; } case 1: { - if(!pusharray32(value->TLVs[i].value.ptr, value->TLVs[i].length, value->TLVs[i].length, ppWritePackedMsg, end)) + if (!pusharray32(value->TLVs[i].value.ptr, value->TLVs[i].length / sizeof(uint32_t), + value->TLVs[i].length / sizeof(uint32_t), ppWritePackedMsg, end)) { + NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s():%d. value->TLVs[i].length %d \n", + __FUNCTION__, __LINE__, value->TLVs[i].length); return 0; + } break; } @@ -3181,32 +3189,36 @@ return 1; static uint8_t pack_nr_uci_pucch_0_1(void* tlv, uint8_t **ppWritePackedMsg, uint8_t *end) { nfapi_nr_uci_pucch_pdu_format_0_1_t* value = (nfapi_nr_uci_pucch_pdu_format_0_1_t*)tlv; - if(!(push8(value->pduBitmap, ppWritePackedMsg, end) && - push32(value->handle, ppWritePackedMsg, end) && - push16(value->rnti, ppWritePackedMsg, end) && - push8(value->pucch_format, ppWritePackedMsg, end) && - push8(value->ul_cqi, ppWritePackedMsg, end) && - push16(value->timing_advance, ppWritePackedMsg, end) && - push16(value->rssi, ppWritePackedMsg, end) - )) - return 0; + if (!push8(value->pduBitmap, ppWritePackedMsg, end)) + return 0; + if (!push32(value->handle, ppWritePackedMsg, end)) + return 0; + if (!push16(value->rnti, ppWritePackedMsg, end)) + return 0; + if (!push8(value->pucch_format, ppWritePackedMsg, end)) + return 0; + if (!push8(value->ul_cqi, ppWritePackedMsg, end)) + return 0; + if (!push16(value->timing_advance, ppWritePackedMsg, end)) + return 0; + if (!push16(value->rssi, ppWritePackedMsg, end)) + return 0; if (value->pduBitmap & 0x01) { //SR - if (!(push8(value->sr->sr_indication, ppWritePackedMsg, end) && - push8(value->sr->sr_confidence_level, ppWritePackedMsg, end) - )) - return 0; + if (!push8(value->sr->sr_indication, ppWritePackedMsg, end)) + return 0; + if (!push8(value->sr->sr_confidence_level, ppWritePackedMsg, end)) + return 0; } if (((value->pduBitmap >> 1) & 0x01)) { //HARQ - if (!(push8(value->harq->num_harq, ppWritePackedMsg, end) && - push8(value->harq->harq_confidence_level, ppWritePackedMsg, end) - )) + if (!push8(value->harq->num_harq, ppWritePackedMsg, end)) + return 0; + if (!push8(value->harq->harq_confidence_level, ppWritePackedMsg, end)) return 0; for (int i = 0; i < value->harq->num_harq; i++) { - if (!(push8(value->harq->harq_list[i].harq_value, ppWritePackedMsg, end) - )) - return 0; + if (!push8(value->harq->harq_list[i].harq_value, ppWritePackedMsg, end)) + return 0; } } @@ -5533,14 +5545,18 @@ static uint8_t unpack_tx_data_pdu_list_value(uint8_t **ppReadPackedMsg, uint8_t switch(pNfapiMsg->TLVs[i].tag) { case 0: { - if(!pullarray32(ppReadPackedMsg, pNfapiMsg->TLVs[i].value.direct, 16384, pNfapiMsg->TLVs[i].length, end)) + if (!pullarray32(ppReadPackedMsg, pNfapiMsg->TLVs[i].value.direct, + sizeof(pNfapiMsg->TLVs[i].value.direct) / sizeof(uint32_t), + pNfapiMsg->TLVs[i].length / sizeof(uint32_t), end)) return 0; break; } case 1: { - if(!pullarray32(ppReadPackedMsg, pNfapiMsg->TLVs[i].value.ptr, pNfapiMsg->TLVs[i].length, pNfapiMsg->TLVs[i].length, end)) + if (!pullarray32(ppReadPackedMsg,pNfapiMsg->TLVs[i].value.ptr, + pNfapiMsg->TLVs[i].length / sizeof(uint32_t), + pNfapiMsg->TLVs[i].length / sizeof(uint32_t), end)) return 0; break; diff --git a/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c b/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c index 9e4a0f2d3d..81d0509f76 100644 --- a/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c +++ b/openair1/SCHED_NR_UE/fapi_nr_ue_l1.c @@ -40,6 +40,7 @@ #include "PHY/defs_nr_UE.h" #include "PHY/impl_defs_nr.h" #include "utils.h" +#include "openair2/PHY_INTERFACE/queue_t.h" extern PHY_VARS_NR_UE ***PHY_vars_UE_g; @@ -73,6 +74,38 @@ static void fill_uci_2_3_4(nfapi_nr_uci_pucch_pdu_format_2_3_4_t *pdu_2_3_4, pdu_2_3_4->csi_part1.csi_part1_crc = 0; } +static void free_uci_inds(nfapi_nr_uci_indication_t *uci_ind) +{ + for (int k = 0; k < uci_ind->num_ucis; k++) + { + if (uci_ind->uci_list[k].pdu_type == NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE) + { + nfapi_nr_uci_pucch_pdu_format_0_1_t *pdu_0_1 = &uci_ind->uci_list[k].pucch_pdu_format_0_1; + free(pdu_0_1->sr); + pdu_0_1->sr = NULL; + if (pdu_0_1->harq) + { + free(pdu_0_1->harq->harq_list); + pdu_0_1->harq->harq_list = NULL; + } + free(pdu_0_1->harq); + pdu_0_1->harq = NULL; + } + if (uci_ind->uci_list[k].pdu_type == NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE) + { + nfapi_nr_uci_pucch_pdu_format_2_3_4_t *pdu_2_3_4 = &uci_ind->uci_list[k].pucch_pdu_format_2_3_4; + free(pdu_2_3_4->sr.sr_payload); + pdu_2_3_4->sr.sr_payload = NULL; + free(pdu_2_3_4->harq.harq_payload); + pdu_2_3_4->harq.harq_payload = NULL; + } + } + free(uci_ind->uci_list); + uci_ind->uci_list = NULL; + free(uci_ind); + uci_ind = NULL; +} + int8_t nr_ue_scheduled_response_stub(nr_scheduled_response_t *scheduled_response) { NR_UE_MAC_INST_t *mac = get_mac_inst(0); if(scheduled_response != NULL) @@ -122,7 +155,6 @@ int8_t nr_ue_scheduled_response_stub(nr_scheduled_response_t *scheduled_response crc_ind->number_crcs = scheduled_response->ul_config->number_pdus; crc_ind->sfn = scheduled_response->ul_config->sfn; crc_ind->slot = scheduled_response->ul_config->slot; - mac->nr_ue_emul_l1.crc_rx_ind_sfn_slot = NFAPI_SFNSLOT2HEX(crc_ind->sfn, crc_ind->slot); crc_ind->crc_list = CALLOC(crc_ind->number_crcs, sizeof(*crc_ind->crc_list)); for (int j = 0; j < crc_ind->number_crcs; j++) { @@ -136,6 +168,9 @@ int8_t nr_ue_scheduled_response_stub(nr_scheduled_response_t *scheduled_response crc_ind->crc_list[j].tb_crc_status = 0; crc_ind->crc_list[j].timing_advance = 31; crc_ind->crc_list[j].ul_cqi = 255; + AssertFatal(mac->nr_ue_emul_l1.harq[crc_ind->crc_list[j].harq_id].active_ul_harq_sfn_slot == -1, + "We did not send an active CRC when we should have!\n"); + mac->nr_ue_emul_l1.harq[crc_ind->crc_list[j].harq_id].active_ul_harq_sfn_slot = NFAPI_SFNSLOT2HEX(crc_ind->sfn, crc_ind->slot); LOG_D(NR_MAC, "This is sched sfn/sl [%d %d] and crc sfn/sl [%d %d] with mcs_index in ul_cqi -> %d\n", scheduled_response->frame, scheduled_response->slot, crc_ind->sfn, crc_ind->slot,pusch_config_pdu->mcs_index); } @@ -180,7 +215,7 @@ int8_t nr_ue_scheduled_response_stub(nr_scheduled_response_t *scheduled_response uci_ind->uci_list = CALLOC(uci_ind->num_ucis, sizeof(*uci_ind->uci_list)); for (int j = 0; j < uci_ind->num_ucis; j++) { - LOG_I(NR_MAC, "ul_config->ul_config_list[%d].pucch_config_pdu.n_bit = %d", i, ul_config->ul_config_list[i].pucch_config_pdu.n_bit); + LOG_I(NR_MAC, "ul_config->ul_config_list[%d].pucch_config_pdu.n_bit = %d\n", i, ul_config->ul_config_list[i].pucch_config_pdu.n_bit); if (ul_config->ul_config_list[i].pucch_config_pdu.n_bit > 3 && mac->nr_ue_emul_l1.num_csi_reports > 0) { uci_ind->uci_list[j].pdu_type = NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE; @@ -202,63 +237,38 @@ int8_t nr_ue_scheduled_response_stub(nr_scheduled_response_t *scheduled_response pdu_0_1->rssi = 0; if (mac->nr_ue_emul_l1.num_harqs > 0) { + int harq_index = 0; pdu_0_1->pduBitmap = 2; // (value->pduBitmap >> 1) & 0x01) == HARQ and (value->pduBitmap) & 0x01) == SR pdu_0_1->harq = CALLOC(1, sizeof(*pdu_0_1->harq)); - pdu_0_1->harq->num_harq = 1; + pdu_0_1->harq->num_harq = mac->nr_ue_emul_l1.num_harqs; pdu_0_1->harq->harq_confidence_level = 0; + pdu_0_1->harq->harq_list = CALLOC(pdu_0_1->harq->num_harq, sizeof(*pdu_0_1->harq->harq_list)); int harq_pid = -1; - for (int k = 0; k < 16; k++) + for (int k = 0; k < NR_MAX_HARQ_PROCESSES; k++) { - LOG_D(NR_MAC, "dl_frame = %d sl_slot = %d feedback_to_ul = %d active_harq_sfn_slot = %d.%d\n", - mac->dl_harq_info[k].dl_frame, - mac->dl_harq_info[k].dl_slot, - mac->dl_harq_info[k].feedback_to_ul, - NFAPI_SFNSLOT2SFN(mac->nr_ue_emul_l1.active_harq_sfn_slot), - NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.active_harq_sfn_slot)); - int sfn_slot = NFAPI_SFNSLOT2HEX(mac->dl_harq_info[k].dl_frame, - (mac->dl_harq_info[k].dl_slot + - mac->dl_harq_info[k].feedback_to_ul)); - if (!mac->dl_harq_info[k].active && - (sfn_slot == mac->nr_ue_emul_l1.active_harq_sfn_slot || - sfn_slot == mac->nr_ue_emul_l1.active_uci_sfn_slot)) + if (mac->nr_ue_emul_l1.harq[k].active && + mac->nr_ue_emul_l1.harq[k].active_dl_harq_sfn == uci_ind->sfn && + mac->nr_ue_emul_l1.harq[k].active_dl_harq_slot == uci_ind->slot) { + mac->nr_ue_emul_l1.harq[k].active = false; harq_pid = k; - LOG_D(NR_MAC, "Setting harq_pid = %d\n", k); + AssertFatal(harq_index < pdu_0_1->harq->num_harq, "Invalid harq_index %d\n", harq_index); + pdu_0_1->harq->harq_list[harq_index].harq_value = !mac->dl_harq_info[k].ack; + harq_index++; } } - pdu_0_1->harq->harq_list = CALLOC(pdu_0_1->harq->num_harq, sizeof(*pdu_0_1->harq->harq_list)); - for (int k = 0; k < pdu_0_1->harq->num_harq; k++) - { - AssertFatal(harq_pid != -1, "No active harq_pid, sfn_slot = %u.%u", uci_ind->sfn, uci_ind->slot); - pdu_0_1->harq->harq_list[k].harq_value = !mac->dl_harq_info[harq_pid].ack; - } + AssertFatal(harq_pid != -1, "No active harq_pid, sfn_slot = %u.%u", uci_ind->sfn, uci_ind->slot); } } - int sfn_slot = NFAPI_SFNSLOT2HEX(uci_ind->sfn, uci_ind->slot); - nfapi_nr_uci_indication_t *queued_uci_ind = unqueue_matching(&nr_uci_ind_queue, - MAX_QUEUE_SIZE, - sfn_slot_matcher, - &sfn_slot); - if (queued_uci_ind) - { - LOG_I(NR_MAC, "There was a matching UCI with sfn %d, slot %d in queue\n", - NFAPI_SFNSLOT2SFN(sfn_slot), NFAPI_SFNSLOT2SLOT(sfn_slot)); - free(queued_uci_ind); - break; - } } - LOG_I(NR_PHY, "In %s: Filled queue uci_ind_%d which was filled by ulconfig.\n" - "uci_num %d, SFN/SLOT: [%d, %d]\n", - __FUNCTION__, uci_ind->uci_list[0].pdu_type, - uci_ind->num_ucis, uci_ind->sfn, uci_ind->slot); - - if (!put_queue(&nr_uci_ind_queue, uci_ind)) - { - LOG_E(NR_MAC, "Put_queue failed for uci_ind\n"); - free(uci_ind->uci_list); - free(uci_ind); - } + LOG_I(NR_PHY, "Sending UCI with %d PDUs in sfn.slot %d/%d\n", + uci_ind->num_ucis, uci_ind->sfn, uci_ind->slot); + NR_UL_IND_t ul_info = { + .uci_ind = *uci_ind, + }; + send_nsa_standalone_msg(&ul_info, uci_ind->header.message_id); + free_uci_inds(uci_ind); break; } @@ -269,93 +279,6 @@ int8_t nr_ue_scheduled_response_stub(nr_scheduled_response_t *scheduled_response } scheduled_response->ul_config->number_pdus = 0; } - - if (scheduled_response->dl_config != NULL) - { - fapi_nr_dl_config_request_t *dl_config = scheduled_response->dl_config; - AssertFatal(dl_config->number_pdus < sizeof(dl_config->dl_config_list) / sizeof(dl_config->dl_config_list[0]), - "Too many dl_config pdus %d", dl_config->number_pdus); - for (int i = 0; i < dl_config->number_pdus; ++i) - { - LOG_D(PHY, "In %s: processing %s PDU of %d total DL PDUs (dl_config %p) \n", - __FUNCTION__, dl_pdu_type[dl_config->dl_config_list[i].pdu_type - 1], dl_config->number_pdus, dl_config); - - uint8_t pdu_type = dl_config->dl_config_list[i].pdu_type; - switch (pdu_type) - { - case (FAPI_NR_DL_CONFIG_TYPE_DLSCH): - { - nfapi_nr_uci_indication_t *uci_ind = CALLOC(1, sizeof(*uci_ind)); - uci_ind->header.message_id = NFAPI_NR_PHY_MSG_TYPE_UCI_INDICATION; - uci_ind->sfn = scheduled_response->frame; - uci_ind->slot = NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.active_harq_sfn_slot); - uci_ind->num_ucis = 1; - uci_ind->uci_list = CALLOC(uci_ind->num_ucis, sizeof(*uci_ind->uci_list)); - for (int j = 0; j < uci_ind->num_ucis; j++) - { - nfapi_nr_uci_pucch_pdu_format_0_1_t *pdu_0_1 = &uci_ind->uci_list[j].pucch_pdu_format_0_1; - uci_ind->uci_list[j].pdu_type = NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE; - uci_ind->uci_list[j].pdu_size = sizeof(nfapi_nr_uci_pucch_pdu_format_0_1_t); - memset(pdu_0_1, 0, sizeof(*pdu_0_1)); - pdu_0_1->handle = 0; - pdu_0_1->rnti = dl_config->dl_config_list[i].dlsch_config_pdu.rnti; - pdu_0_1->pucch_format = 1; - pdu_0_1->ul_cqi = 255; - pdu_0_1->timing_advance = 0; - pdu_0_1->rssi = 0; - pdu_0_1->pduBitmap = 2; // (value->pduBitmap >> 1) & 0x01) == HARQ and (value->pduBitmap) & 0x01) == SR - pdu_0_1->harq = CALLOC(1, sizeof(*pdu_0_1->harq)); - pdu_0_1->harq->num_harq = 1; - pdu_0_1->harq->harq_confidence_level = 0; - int harq_pid = -1; - for (int k = 0; k < 16; k++) - { - LOG_D(NR_MAC, "dl_frame = %d dl_slot = %d feedback_to_ul = %d active = %d k = %d " - "active_harq_sfn_slot = %d.%d " - "active_uci_sfn_slot = %d.%d\n", - mac->dl_harq_info[k].dl_frame, - mac->dl_harq_info[k].dl_slot, - mac->dl_harq_info[k].feedback_to_ul, - mac->dl_harq_info[k].active, - k, - NFAPI_SFNSLOT2SFN(mac->nr_ue_emul_l1.active_harq_sfn_slot), - NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.active_harq_sfn_slot), - NFAPI_SFNSLOT2SFN(mac->nr_ue_emul_l1.active_uci_sfn_slot), - NFAPI_SFNSLOT2SLOT(mac->nr_ue_emul_l1.active_uci_sfn_slot)); - int sfn_slot = NFAPI_SFNSLOT2HEX(mac->dl_harq_info[k].dl_frame, - (mac->dl_harq_info[k].dl_slot + - mac->dl_harq_info[k].feedback_to_ul)); - if (mac->dl_harq_info[k].active && - sfn_slot == mac->nr_ue_emul_l1.active_harq_sfn_slot) - { - harq_pid = k; - LOG_D(NR_MAC, "Setting harq_pid = %d\n", k); - } - } - pdu_0_1->harq->harq_list = CALLOC(pdu_0_1->harq->num_harq, sizeof(*pdu_0_1->harq->harq_list)); - for (int k = 0; k < pdu_0_1->harq->num_harq; k++) - { - AssertFatal(harq_pid != -1, "No active harq_pid, sfn_slot = %u.%u", uci_ind->sfn, uci_ind->slot); - pdu_0_1->harq->harq_list[k].harq_value = !mac->dl_harq_info[harq_pid].ack; - } - } - - LOG_I(NR_PHY, "In %s: Filled queue uci_ind which was filled by dlconfig.\n" - "uci_num %d, SFN/SLOT: [%d, %d]\n", - __FUNCTION__, uci_ind->num_ucis, uci_ind->sfn, uci_ind->slot); - - if (!put_queue(&nr_uci_ind_queue, uci_ind)) - { - LOG_E(NR_MAC, "Put_queue failed for uci_ind\n"); - free(uci_ind->uci_list); - free(uci_ind); - } - break; - } - } - } - } - } return 0; } diff --git a/openair2/LAYER2/NR_MAC_COMMON/nr_mac.h b/openair2/LAYER2/NR_MAC_COMMON/nr_mac.h index 35983582bc..9dd03ddcf6 100644 --- a/openair2/LAYER2/NR_MAC_COMMON/nr_mac.h +++ b/openair2/LAYER2/NR_MAC_COMMON/nr_mac.h @@ -39,6 +39,7 @@ #include #include "NR_SubcarrierSpacing.h" +#include "openair1/SCHED_NR_UE/harq_nr.h" #define NR_SHORT_BSR_TABLE_SIZE 32 #define NR_LONG_BSR_TABLE_SIZE 256 @@ -264,16 +265,26 @@ typedef struct { uint8_t nbits; } dci_field_t; +typedef struct { + /* The active harq sfn/slot field was created to save the + scheduled SFN/Slot transmission for the ACK/NAK. If we + do not save it, then we have to calculate it again as the + NRUE MAC layer already does in get_downlink_ack(). */ + int active_dl_harq_sfn; + int active_dl_harq_slot; + int active_ul_harq_sfn_slot; + bool active; +} emul_l1_harq_t; + typedef struct { bool expected_sib; - bool index_has_sib[16]; + bool index_has_sib[NR_MAX_HARQ_PROCESSES]; bool expected_rar; - bool index_has_rar[16]; + bool index_has_rar[NR_MAX_HARQ_PROCESSES]; bool expected_dci; - bool index_has_dci[16]; - int active_harq_sfn_slot; + bool index_has_dci[NR_MAX_HARQ_PROCESSES]; + emul_l1_harq_t harq[NR_MAX_HARQ_PROCESSES]; int active_uci_sfn_slot; - int crc_rx_ind_sfn_slot; int num_srs; int num_harqs; int num_csi_reports; diff --git a/openair2/LAYER2/NR_MAC_UE/mac_defs.h b/openair2/LAYER2/NR_MAC_UE/mac_defs.h index ad86b1385d..fc2c2d2c8b 100644 --- a/openair2/LAYER2/NR_MAC_UE/mac_defs.h +++ b/openair2/LAYER2/NR_MAC_UE/mac_defs.h @@ -432,7 +432,7 @@ typedef struct { // Defined for abstracted mode nr_downlink_indication_t dl_info; - NR_UE_HARQ_STATUS_t dl_harq_info[16]; + NR_UE_HARQ_STATUS_t dl_harq_info[NR_MAX_HARQ_PROCESSES]; nr_emulated_l1_t nr_ue_emul_l1; diff --git a/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c b/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c index b5680a9bf8..6ff4420639 100644 --- a/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c +++ b/openair2/LAYER2/NR_MAC_UE/nr_ue_procedures.c @@ -1334,10 +1334,18 @@ void set_harq_status(NR_UE_MAC_INST_t *mac, // FIXME k0 != 0 currently not taken into consideration current_harq->dl_frame = frame; current_harq->dl_slot = slot; - mac->nr_ue_emul_l1.active_harq_sfn_slot = NFAPI_SFNSLOT2HEX(frame, (slot + data_toul_fb)); + if (get_softmodem_params()->emulate_l1) { + int scs = get_softmodem_params()->numerology; + int slots_per_frame = nr_slots_per_frame[scs]; + slot += data_toul_fb; + if (slot >= slots_per_frame) { + frame = (frame + 1) % 1024; + slot %= slots_per_frame; + } + } LOG_D(NR_PHY,"Setting harq_status for harq_id %d, dl %d.%d, sched ul %d.%d\n", - harq_id, frame, slot, frame, (slot + data_toul_fb)); + harq_id, current_harq->dl_frame, current_harq->dl_slot, frame, slot); } @@ -1819,7 +1827,8 @@ int find_pucch_resource_set(NR_UE_MAC_INST_t *mac, int uci_size) { mac->cg->spCellConfig->spCellConfigDedicated->uplinkConfig->initialUplinkBWP->pucch_Config->choice.setup && mac->cg->spCellConfig->spCellConfigDedicated->uplinkConfig->initialUplinkBWP->pucch_Config->choice.setup->resourceSetToAddModList && mac->cg->spCellConfig->spCellConfigDedicated->uplinkConfig->initialUplinkBWP->pucch_Config->choice.setup->resourceSetToAddModList->list.array[pucch_resource_set_id] != NULL)) { - if (uci_size <= 2) { + // PUCCH with format0 can be up to 3 bits (2 ack/nacks + 1 sr is 3 max bits) + if (uci_size <= 3) { pucch_resource_set_id = 0; return (pucch_resource_set_id); break; @@ -2020,11 +2029,17 @@ uint8_t get_downlink_ack(NR_UE_MAC_INST_t *mac, sched_frame = current_harq->dl_frame; if (sched_slot>=slots_per_frame){ sched_slot %= slots_per_frame; - sched_frame++; + sched_frame = (sched_frame + 1) % 1024; } + AssertFatal(sched_slot < slots_per_frame, "sched_slot was calculated incorrect %d\n", sched_slot); LOG_D(PHY,"HARQ pid %d is active for %d.%d (dl_slot %d, feedback_to_ul %d, is_common %d\n",dl_harq_pid, sched_frame,sched_slot,current_harq->dl_slot,current_harq->feedback_to_ul,current_harq->is_common); /* check if current tx slot should transmit downlink acknowlegment */ if (sched_frame == frame && sched_slot == slot) { + if (get_softmodem_params()->emulate_l1) { + mac->nr_ue_emul_l1.harq[dl_harq_pid].active = true; + mac->nr_ue_emul_l1.harq[dl_harq_pid].active_dl_harq_sfn = frame; + mac->nr_ue_emul_l1.harq[dl_harq_pid].active_dl_harq_slot = slot; + } if (current_harq->dai > NR_DL_MAX_DAI) { LOG_E(MAC,"PUCCH Downlink DAI has an invalid value : at line %d in function %s of file %s \n", LINE_FILE , __func__, FILE_NAME); diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c index 15c0c23feb..114250434c 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_uci.c @@ -1309,9 +1309,13 @@ int nr_acknack_scheduling(int mod_id, /* we need to find a new PUCCH occasion */ /*(Re)Inizialization of timing information*/ + /* TODO: This is something of a hack. The last condition in the + if statement below was added. OAI is looking into this and is + expected to provide a solution. Without the hack, the gNB will + incorrectly schedule more than 2 ACK/nACKs in a single SFN/Slot. */ if ((pucch->frame == 0 && pucch->ul_slot == 0) || ((pucch->frame*n_slots_frame + pucch->ul_slot) < - (frame*n_slots_frame + slot))) { + (frame * n_slots_frame + slot)) && (frame != 1023)) { AssertFatal(pucch->sr_flag + pucch->dai_c == 0, "expected no SR/AckNack for UE %d in %4d.%2d, but has %d/%d for %4d.%2d\n", UE_id, frame, slot, pucch->sr_flag, pucch->dai_c, pucch->frame, pucch->ul_slot); diff --git a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c index 6d7dbf5506..e9394888f4 100644 --- a/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c +++ b/openair2/LAYER2/NR_MAC_gNB/gNB_scheduler_ulsch.c @@ -261,9 +261,18 @@ int nr_process_mac_pdu(module_id_t module_idP, case UL_SCH_LCID_L_TRUNCATED_BSR: //38.321 section 6.1.3.1 //variable length + /* Several checks have been added to this function to + ensure that the casting of the pduP is possible. There seems + to be a partial PDU at the end of this buffer, so here + we gracefully ignore that by returning 0. See: + https://gitlab.eurecom.fr/oai/openairinterface5g/-/issues/534 */ + if (pdu_len < sizeof(NR_MAC_SUBHEADER_SHORT)) + return 0; mac_ce_len |= (uint16_t)((NR_MAC_SUBHEADER_SHORT *)pduP)->L; mac_subheader_len = 2; if(((NR_MAC_SUBHEADER_SHORT *)pduP)->F){ + if (pdu_len < sizeof(NR_MAC_SUBHEADER_LONG)) + return 0; mac_ce_len |= (uint16_t)(((NR_MAC_SUBHEADER_LONG *)pduP)->L2)<<8; mac_subheader_len = 3; } @@ -340,9 +349,13 @@ int nr_process_mac_pdu(module_id_t module_idP, case UL_SCH_LCID_MULTI_ENTRY_PHR_1_OCT: //38.321 section 6.1.3.9 // varialbe length + if (pdu_len < sizeof(NR_MAC_SUBHEADER_SHORT)) + return 0; mac_ce_len |= (uint16_t)((NR_MAC_SUBHEADER_SHORT *)pduP)->L; mac_subheader_len = 2; if(((NR_MAC_SUBHEADER_SHORT *)pduP)->F){ + if (pdu_len < sizeof(NR_MAC_SUBHEADER_LONG)) + return 0; mac_ce_len |= (uint16_t)(((NR_MAC_SUBHEADER_LONG *)pduP)->L2)<<8; mac_subheader_len = 3; } @@ -352,9 +365,13 @@ int nr_process_mac_pdu(module_id_t module_idP, case UL_SCH_LCID_MULTI_ENTRY_PHR_4_OCT: //38.321 section 6.1.3.9 // varialbe length + if (pdu_len < sizeof(NR_MAC_SUBHEADER_SHORT)) + return 0; mac_ce_len |= (uint16_t)((NR_MAC_SUBHEADER_SHORT *)pduP)->L; mac_subheader_len = 2; if(((NR_MAC_SUBHEADER_SHORT *)pduP)->F){ + if (pdu_len < sizeof(NR_MAC_SUBHEADER_LONG)) + return 0; mac_ce_len |= (uint16_t)(((NR_MAC_SUBHEADER_LONG *)pduP)->L2)<<8; mac_subheader_len = 3; } @@ -368,8 +385,12 @@ int nr_process_mac_pdu(module_id_t module_idP, case UL_SCH_LCID_SRB1: case UL_SCH_LCID_SRB2: + if (pdu_len < sizeof(NR_MAC_SUBHEADER_SHORT)) + return 0; if(((NR_MAC_SUBHEADER_SHORT *)pduP)->F){ //mac_sdu_len |= (uint16_t)(((NR_MAC_SUBHEADER_LONG *)pduP)->L2)<<8; + if (pdu_len < sizeof(NR_MAC_SUBHEADER_LONG)) + return 0; mac_subheader_len = 3; mac_sdu_len = ((uint16_t)(((NR_MAC_SUBHEADER_LONG *) pduP)->L1 & 0x7f) << 8) | ((uint16_t)((NR_MAC_SUBHEADER_LONG *) pduP)->L2 & 0xff); @@ -453,8 +474,12 @@ int nr_process_mac_pdu(module_id_t module_idP, case UL_SCH_LCID_DTCH: // check if LCID is valid at current time. + if (pdu_len < sizeof(NR_MAC_SUBHEADER_SHORT)) + return 0; if (((NR_MAC_SUBHEADER_SHORT *)pduP)->F) { // mac_sdu_len |= (uint16_t)(((NR_MAC_SUBHEADER_LONG *)pduP)->L2)<<8; + if (pdu_len < sizeof(NR_MAC_SUBHEADER_LONG)) + return 0; mac_subheader_len = 3; mac_sdu_len = ((uint16_t)(((NR_MAC_SUBHEADER_LONG *)pduP)->L1 & 0x7f) << 8) | ((uint16_t)((NR_MAC_SUBHEADER_LONG *)pduP)->L2 & 0xff); diff --git a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c index 62aa101a50..d241e43a0f 100644 --- a/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c +++ b/openair2/LAYER2/nr_pdcp/nr_pdcp_entity.c @@ -51,7 +51,12 @@ static void nr_pdcp_entity_recv_pdu(nr_pdcp_entity_t *entity, if (entity->type != NR_PDCP_SRB && !(buffer[0] & 0x80)) { LOG_E(PDCP, "%s:%d:%s: fatal\n", __FILE__, __LINE__, __FUNCTION__); - exit(1); + /* TODO: This is something of a hack. The most significant bit + in buffer[0] should be 1 if the packet is a data packet. We are + processing malformed data packets if the most significant bit + is 0. Rather than exit(1), this hack allows us to continue for now. + We need to investigate why this hack is neccessary. */ + buffer[0] |= 128; } if (entity->sn_size == 12) { diff --git a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c index 396aa54a47..fc3a934411 100644 --- a/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c +++ b/openair2/NR_UE_PHY_INTERFACE/NR_IF_Module.c @@ -144,7 +144,7 @@ void send_nsa_standalone_msg(NR_UL_IND_t *UL_INFO, uint16_t msg_id) case NFAPI_NR_PHY_MSG_TYPE_RACH_INDICATION: { char buffer[NFAPI_MAX_PACKED_MESSAGE_SIZE]; - LOG_D(NR_MAC, "RACH header id :%d", UL_INFO->rach_ind.header.message_id); + LOG_D(NR_MAC, "RACH header id :%d\n", UL_INFO->rach_ind.header.message_id); int encoded_size = nfapi_nr_p7_message_pack(&UL_INFO->rach_ind, buffer, sizeof(buffer), NULL); if (encoded_size <= 0) { @@ -164,7 +164,7 @@ void send_nsa_standalone_msg(NR_UL_IND_t *UL_INFO, uint16_t msg_id) case NFAPI_NR_PHY_MSG_TYPE_RX_DATA_INDICATION: { char buffer[NFAPI_MAX_PACKED_MESSAGE_SIZE]; - LOG_D(NR_MAC, "RX header id :%d", UL_INFO->rx_ind.header.message_id); + LOG_D(NR_MAC, "RX header id :%d\n", UL_INFO->rx_ind.header.message_id); int encoded_size = nfapi_nr_p7_message_pack(&UL_INFO->rx_ind, buffer, sizeof(buffer), NULL); if (encoded_size <= 0) { @@ -184,7 +184,7 @@ void send_nsa_standalone_msg(NR_UL_IND_t *UL_INFO, uint16_t msg_id) case NFAPI_NR_PHY_MSG_TYPE_CRC_INDICATION: { char buffer[NFAPI_MAX_PACKED_MESSAGE_SIZE]; - LOG_D(NR_MAC, "CRC header id :%d", UL_INFO->crc_ind.header.message_id); + LOG_D(NR_MAC, "CRC header id :%d\n", UL_INFO->crc_ind.header.message_id); int encoded_size = nfapi_nr_p7_message_pack(&UL_INFO->crc_ind, buffer, sizeof(buffer), NULL); if (encoded_size <= 0) { @@ -204,7 +204,7 @@ void send_nsa_standalone_msg(NR_UL_IND_t *UL_INFO, uint16_t msg_id) case NFAPI_NR_PHY_MSG_TYPE_UCI_INDICATION: { char buffer[NFAPI_MAX_PACKED_MESSAGE_SIZE]; - LOG_I(NR_MAC, "UCI header id :%d", UL_INFO->uci_ind.header.message_id); + LOG_I(NR_MAC, "UCI header id :%d\n", UL_INFO->uci_ind.header.message_id); int encoded_size = nfapi_nr_p7_message_pack(&UL_INFO->uci_ind, buffer, sizeof(buffer), NULL); if (encoded_size <= 0) { @@ -303,6 +303,8 @@ static void fill_dl_info_with_pdcch(fapi_nr_dci_indication_t *dci, nfapi_nr_dl_d } dci->dci_list[idx].payloadSize = rx_dci->PayloadSizeBits; dci->dci_list[idx].rnti = rx_dci->RNTI; + dci->dci_list[idx].n_CCE = rx_dci->CceIndex; + dci->dci_list[idx].N_CCE = rx_dci->AggregationLevel; dci->number_of_dcis = idx + 1; } @@ -540,38 +542,6 @@ static void copy_tx_data_req_to_dl_info(nr_downlink_indication_t *dl_info, nfapi dl_info->rx_ind->number_pdus = pdu_idx; } -static void free_uci_inds(nfapi_nr_uci_indication_t *uci_ind) -{ - for (int k = 0; k < uci_ind->num_ucis; k++) - { - if (uci_ind->uci_list[k].pdu_type == NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE) - { - nfapi_nr_uci_pucch_pdu_format_0_1_t *pdu_0_1 = &uci_ind->uci_list[k].pucch_pdu_format_0_1; - free(pdu_0_1->sr); - pdu_0_1->sr = NULL; - if (pdu_0_1->harq) - { - free(pdu_0_1->harq->harq_list); - pdu_0_1->harq->harq_list = NULL; - } - free(pdu_0_1->harq); - pdu_0_1->harq = NULL; - } - if (uci_ind->uci_list[k].pdu_type == NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE) - { - nfapi_nr_uci_pucch_pdu_format_2_3_4_t *pdu_2_3_4 = &uci_ind->uci_list[k].pucch_pdu_format_2_3_4; - free(pdu_2_3_4->sr.sr_payload); - pdu_2_3_4->sr.sr_payload = NULL; - free(pdu_2_3_4->harq.harq_payload); - pdu_2_3_4->harq.harq_payload = NULL; - } - } - free(uci_ind->uci_list); - uci_ind->uci_list = NULL; - free(uci_ind); - uci_ind = NULL; -} - static void copy_ul_dci_data_req_to_dl_info(nr_downlink_indication_t *dl_info, nfapi_nr_ul_dci_request_t *ul_dci_req) { NR_UE_MAC_INST_t *mac = get_mac_inst(dl_info->module_id); @@ -624,6 +594,12 @@ static bool send_crc_ind_and_rx_ind(int sfn_slot) if (crc_ind && crc_ind->number_crcs > 0) { + NR_UE_MAC_INST_t *mac = get_mac_inst(0); + for (int i = 0; i < crc_ind->number_crcs; i++) { + int harq_pid = crc_ind->crc_list[i].harq_id; + LOG_D(NR_MAC, "Resetting harq_pid %d active_ul_harq_sfn_slot\n", harq_pid); + mac->nr_ue_emul_l1.harq[harq_pid].active_ul_harq_sfn_slot = -1; + } NR_UL_IND_t UL_INFO = { .crc_ind = *crc_ind, }; @@ -649,108 +625,23 @@ static bool send_crc_ind_and_rx_ind(int sfn_slot) static void copy_ul_tti_data_req_to_dl_info(nr_downlink_indication_t *dl_info, nfapi_nr_ul_tti_request_t *ul_tti_req) { - NR_UE_MAC_INST_t *mac = get_mac_inst(dl_info->module_id); int num_pdus = ul_tti_req->n_pdus; int sfn_slot = NFAPI_SFNSLOT2HEX(ul_tti_req->SFN, ul_tti_req->Slot); AssertFatal(num_pdus >= 0, "Invalid ul_tti_request number of PDUS\n"); AssertFatal(num_pdus <= sizeof(ul_tti_req->pdus_list) / sizeof(ul_tti_req->pdus_list[0]), "Too many pdus %d in ul_tti_req\n", num_pdus); - - bool sent_crc_rx = send_crc_ind_and_rx_ind(sfn_slot); - bool sent_uci = false; - for (int i = 0; i < num_pdus; i++) + if (!send_crc_ind_and_rx_ind(sfn_slot)) { - nfapi_nr_ul_tti_request_number_of_pdus_t *pdu_list = &ul_tti_req->pdus_list[i]; - LOG_D(NR_PHY, "This is the pdu type %d and rnti %x and SR flag %d and harq_pdu_len %d in in ul_tti_req\n", - pdu_list->pdu_type, ul_tti_req->pdus_list[i].pucch_pdu.rnti, pdu_list->pucch_pdu.sr_flag, pdu_list->pucch_pdu.bit_len_harq); - if (pdu_list->pdu_type == NFAPI_NR_UL_CONFIG_PUCCH_PDU_TYPE && pdu_list->pucch_pdu.rnti == mac->crnti) - { - AssertFatal(nr_uci_ind_queue.num_items >= 0, "Invalid num_items in UCI_ind queue %lu\n", - nr_uci_ind_queue.num_items); - - nfapi_nr_uci_indication_t *uci_ind = unqueue_matching(&nr_uci_ind_queue, - MAX_QUEUE_SIZE, - sfn_slot_matcher, - &sfn_slot); - if (!uci_ind) - { - LOG_I(NR_MAC, "There was not a matching UCI with sfn %d, slot %d in queue\n", - NFAPI_SFNSLOT2SFN(sfn_slot), NFAPI_SFNSLOT2SLOT(sfn_slot)); - return; - } - if (uci_ind && uci_ind->num_ucis > 0) - { - uci_ind->sfn = ul_tti_req->SFN; - uci_ind->slot = ul_tti_req->Slot; - LOG_D(NR_MAC, "This is the SFN/SF [%d, %d] and RNTI %x of the UCI ind. ul_tti_req.pdu[%d]->rnti = %x \n", - uci_ind->sfn, uci_ind->slot, uci_ind->uci_list[0].pucch_pdu_format_0_1.rnti, i, ul_tti_req->pdus_list[i].pucch_pdu.rnti); - for (int j = 0; j < uci_ind->num_ucis; j++) - { - if (uci_ind->uci_list[j].pdu_type == NFAPI_NR_UCI_FORMAT_0_1_PDU_TYPE) - { - nfapi_nr_uci_pucch_pdu_format_0_1_t *pdu_0_1 = &uci_ind->uci_list[j].pucch_pdu_format_0_1; - if (pdu_list->pucch_pdu.sr_flag) - { - pdu_0_1->pduBitmap = 1; // (value->pduBitmap >> 1) & 0x01) == HARQ and (value->pduBitmap) & 0x01) == SR - if (pdu_list->pucch_pdu.bit_len_harq > 0) - pdu_0_1->pduBitmap = 3; - pdu_0_1->sr = CALLOC(1, sizeof(*pdu_0_1->sr)); - pdu_0_1->sr->sr_confidence_level = 0; - pdu_0_1->sr->sr_indication = 1; - } - } - if (uci_ind->uci_list[j].pdu_type == NFAPI_NR_UCI_FORMAT_2_3_4_PDU_TYPE) - { - nfapi_nr_uci_pucch_pdu_format_2_3_4_t *pdu_2_3_4 = &uci_ind->uci_list[j].pucch_pdu_format_2_3_4; - if (pdu_list->pucch_pdu.sr_flag) - { - pdu_2_3_4->pduBitmap = 5; - pdu_2_3_4->sr.sr_bit_len = 0; - AssertFatal(!pdu_2_3_4->sr.sr_payload, "pdu_2_3_4->sr.sr_payload != NULL\n"); - pdu_2_3_4->sr.sr_payload = CALLOC((int)((pdu_2_3_4->sr.sr_bit_len / 8) + 1), - sizeof(*pdu_2_3_4->sr.sr_payload)); - } - if (pdu_list->pucch_pdu.bit_len_harq > 0) - { - pdu_2_3_4->pduBitmap = 6; - if (pdu_list->pucch_pdu.sr_flag) - { - pdu_2_3_4->pduBitmap = 7; - } - pdu_2_3_4->harq.harq_bit_len = pdu_list->pucch_pdu.bit_len_harq; - LOG_D(NR_MAC, "This is bit_len_harq %d and pdu_2_3_4->pduBitmap %d\n", - pdu_list->pucch_pdu.bit_len_harq, pdu_2_3_4->pduBitmap); - pdu_2_3_4->harq.harq_crc = 0; - AssertFatal(!pdu_2_3_4->harq.harq_payload, "pdu_2_3_4->harq.harq_payload != NULL\n"); - pdu_2_3_4->harq.harq_payload = CALLOC((int)((pdu_2_3_4->harq.harq_bit_len / 8) + 1), - sizeof(*pdu_2_3_4->harq.harq_payload)); - /* TODO: Later, when abstracting, we can set particular bits in the - payload to 0 to indicate a NACK. For now, we memset all bits to 1. */ - memset(pdu_2_3_4->harq.harq_payload, 0xff, sizeof(*pdu_2_3_4->harq.harq_payload)); - } - } - } - LOG_I(NR_MAC, "We have dequeued the previously filled uci_ind and updated the snf/slot to %d/%d.\n", - uci_ind->sfn, uci_ind->slot); - NR_UL_IND_t UL_INFO = { - .uci_ind = *uci_ind, - }; - send_nsa_standalone_msg(&UL_INFO, uci_ind->header.message_id); - sent_uci = true; - free_uci_inds(uci_ind); - } - } - } - if (!sent_uci && !sent_crc_rx) - { - LOG_E(NR_MAC, "UCI and CRC_RX ind not sent\n"); + LOG_D(NR_MAC, "CRC_RX ind not sent\n"); if (!put_queue(&nr_ul_tti_req_queue, ul_tti_req)) { LOG_E(NR_PHY, "put_queue failed for ul_tti_req.\n"); free(ul_tti_req); ul_tti_req = NULL; } + return; } + free(ul_tti_req); } static void fill_dci_from_dl_config(nr_downlink_indication_t*dl_ind, fapi_nr_dl_config_request_t *dl_config) @@ -784,17 +675,15 @@ static void fill_dci_from_dl_config(nr_downlink_indication_t*dl_ind, fapi_nr_dl_ "dl_config->number_pdus %d > dci_ind->dci_list array\n", num_dcis); for (int k = 0; k < num_dcis; k++) { - LOG_I(NR_PHY, "Received len %d, length options[%d] %d, format assigned %d, format options[%d] %d\n", + LOG_D(NR_PHY, "Received len %d, length options[%d] %d, format assigned %d, format options[%d] %d\n", dl_ind->dci_ind->dci_list[k].payloadSize, j, rel15_dci->dci_length_options[j], dl_ind->dci_ind->dci_list[k].dci_format, j, rel15_dci->dci_format_options[j]); if (rel15_dci->dci_length_options[j] == dl_ind->dci_ind->dci_list[k].payloadSize) { dl_ind->dci_ind->dci_list[k].dci_format = rel15_dci->dci_format_options[j]; + LOG_I(NR_PHY, "format assigned dl_ind->dci_ind->dci_list[k].dci_format %d\n", + dl_ind->dci_ind->dci_list[k].dci_format); } - int CCEind = rel15_dci->CCE[j]; - int L = rel15_dci->L[j]; - dl_ind->dci_ind->dci_list[k].n_CCE = CCEind; - dl_ind->dci_ind->dci_list[k].N_CCE = L; } } } @@ -843,7 +732,7 @@ void check_and_process_dci(nfapi_nr_dl_tti_request_t *dl_tti_request, { frame = ul_tti_request->SFN; slot = ul_tti_request->Slot; - LOG_I(NR_PHY, "[%d, %d] ul_tti_request\n", frame, slot); + LOG_D(NR_PHY, "[%d, %d] ul_tti_request\n", frame, slot); copy_ul_tti_data_req_to_dl_info(&mac->dl_info, ul_tti_request); } else @@ -857,6 +746,7 @@ void check_and_process_dci(nfapi_nr_dl_tti_request_t *dl_tti_request, NR_UL_TIME_ALIGNMENT_t ul_time_alignment; memset(&ul_time_alignment, 0, sizeof(ul_time_alignment)); fill_dci_from_dl_config(&mac->dl_info, &mac->dl_config_request); + nr_ue_scheduler(&mac->dl_info, NULL); nr_ue_dl_indication(&mac->dl_info, &ul_time_alignment); if (pthread_mutex_unlock(&mac->mutex_dl_info)) abort(); @@ -878,7 +768,10 @@ void check_and_process_dci(nfapi_nr_dl_tti_request_t *dl_tti_request, mac->scc_SIB->tdd_UL_DL_ConfigurationCommon, ul_info.slot_tx, mac->frame_type)) - nr_ue_ul_indication(&ul_info); + { + nr_ue_scheduler(NULL, &ul_info); + nr_ue_prach_scheduler(ul_info.module_id, ul_info.frame_tx, ul_info.slot_tx, ul_info.thread_id); + } } } @@ -921,7 +814,7 @@ void save_nr_measurement_info(nfapi_nr_dl_tti_request_t *dl_tti_request) static void enqueue_nr_nfapi_msg(void *buffer, ssize_t len, nfapi_p7_message_header_t header) { - + NR_UE_MAC_INST_t *mac = get_mac_inst(0); switch (header.message_id) { case NFAPI_NR_PHY_MSG_TYPE_DL_TTI_REQUEST: @@ -997,13 +890,30 @@ static void enqueue_nr_nfapi_msg(void *buffer, ssize_t len, nfapi_p7_message_hea LOG_E(NR_PHY, "Message ul_tti_request failed to unpack\n"); break; } - LOG_I(NR_PHY, "Received an NFAPI_NR_PHY_MSG_TYPE_UL_TTI_REQUEST message in SFN/slot %d %d.\n", - ul_tti_request->SFN, ul_tti_request->Slot); - if (!put_queue(&nr_ul_tti_req_queue, ul_tti_request)) - { - LOG_E(NR_PHY, "put_queue failed for ul_tti_request.\n"); - nfapi_nr_ul_tti_request_t *evicted_ul_tti_req = put_queue_replace(&nr_ul_tti_req_queue, ul_tti_request); - free(evicted_ul_tti_req); + /* We are filtering UL_TTI_REQs below. We only care about UL_TTI_REQs that + will trigger sending a ul_harq (CRC/RX pair). This UL_TTI_REQ will have + NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE. If we have not yet completed the CBRA/ + CFRA procedure, we need to queue all UL_TTI_REQs. */ + for (int i = 0; i < ul_tti_request->n_pdus; i++) { + if (ul_tti_request->pdus_list[i].pdu_type == NFAPI_NR_UL_CONFIG_PUSCH_PDU_TYPE && + mac->ra.ra_state >= RA_SUCCEEDED) { + if (!put_queue(&nr_ul_tti_req_queue, ul_tti_request)) + { + LOG_I(NR_PHY, "put_queue failed for ul_tti_request, calling put_queue_replace.\n"); + nfapi_nr_ul_tti_request_t *evicted_ul_tti_req = put_queue_replace(&nr_ul_tti_req_queue, ul_tti_request); + free(evicted_ul_tti_req); + } + break; + } + else if (mac->ra.ra_state < RA_SUCCEEDED) { + if (!put_queue(&nr_ul_tti_req_queue, ul_tti_request)) + { + LOG_I(NR_PHY, "put_queue failed for ul_tti_request, calling put_queue_replace.\n"); + nfapi_nr_ul_tti_request_t *evicted_ul_tti_req = put_queue_replace(&nr_ul_tti_req_queue, ul_tti_request); + free(evicted_ul_tti_req); + } + break; + } } break; } @@ -1174,8 +1084,12 @@ int handle_dci(module_id_t module_id, int cc_id, unsigned int gNB_index, frame_t // L2 Abstraction Layer // Note: sdu should always be processed because data and timing advance updates are transmitted by the UE int8_t handle_dlsch(nr_downlink_indication_t *dl_info, NR_UL_TIME_ALIGNMENT_t *ul_time_alignment, int pdu_id){ - - dl_info->rx_ind->rx_indication_body[pdu_id].pdsch_pdu.harq_pid = g_harq_pid; + /* L1 assigns harq_pid, but in emulated L1 mode we need to assign + the harq_pid based on the saved global g_harq_pid. Because we are + emulating L1, no antenna measurements are conducted to calculate + a harq_pid, therefore we must set it here. */ + if (get_softmodem_params()->emulate_l1) + dl_info->rx_ind->rx_indication_body[pdu_id].pdsch_pdu.harq_pid = g_harq_pid; update_harq_status(dl_info->module_id, dl_info->rx_ind->rx_indication_body[pdu_id].pdsch_pdu.harq_pid,