diff --git a/openair2/PHY_INTERFACE/phy_stub_UE.c b/openair2/PHY_INTERFACE/phy_stub_UE.c index 67833b442fb4d83d12bd744680a2ac68f8ef8c5d..e44d137213edae19afcabbd7c30a7b62d97e88b9 100644 --- a/openair2/PHY_INTERFACE/phy_stub_UE.c +++ b/openair2/PHY_INTERFACE/phy_stub_UE.c @@ -43,8 +43,7 @@ void configure_nfapi_pnf(char *vnf_ip_addr, UL_IND_t *UL_INFO = NULL; -queue_t dl_config_req_queue; -queue_t tx_req_pdu_queue; +queue_t dl_config_req_tx_req_queue; queue_t ul_config_req_queue; queue_t hi_dci0_req_queue; @@ -928,194 +927,12 @@ void hi_dci0_req_UE_MAC(int sfn, } } -static bool is_my_dl_config_req(const nfapi_dl_config_request_t *req) -{ - - const rnti_t my_rnti = UE_mac_inst[0].crnti; - int num_pdus = req->dl_config_request_body.number_pdu; - // look through list of pdus for rnti type 1 with my_rnti (normal dlsch case) - for (int i = 0; i < num_pdus; i++) - { - nfapi_dl_config_request_pdu_t *pdu = &req->dl_config_request_body.dl_config_pdu_list[i]; - const int pdu_type = pdu->pdu_type; - if (pdu_type == NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE) - { - const rnti_t dci_rnti = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti; - const int rnti_type = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti_type; - if (rnti_type == 1 && dci_rnti == my_rnti) - { - return true; - } - } - else if(pdu_type != NFAPI_DL_CONFIG_DLSCH_PDU_TYPE) - { - return true; // Because these two pdu_types are coupled and we have to accept all other pdu_types - } - } - - // Look for broadcasted rnti types - for (int i = 0; i < num_pdus; i++) - { - nfapi_dl_config_request_pdu_t *pdu = &req->dl_config_request_body.dl_config_pdu_list[i]; - const int pdu_type = pdu->pdu_type; - if (pdu_type == NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE) - { - const int rnti_type = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti_type; - if (rnti_type != 1) - { - return true; - } - } - } - - - return false; -} - -static int get_dlsch_pdu_indicies(const nfapi_dl_config_request_t *req, int *pdu_indicies, size_t max_pdu_indicies) -{ - - const rnti_t my_rnti = UE_mac_inst[0].crnti; // This is 0 representing the num_ues is 1 - int num_pdus = req->dl_config_request_body.number_pdu; - size_t num_pdu_indicies = 0; - for (int i = 0; i < num_pdus; i++) - { - nfapi_dl_config_request_pdu_t *pdu = &req->dl_config_request_body.dl_config_pdu_list[i]; - const int pdu_type = pdu->pdu_type; - if (pdu_type == NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE) - { - const rnti_t dci_rnti = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti; - const int rnti_type = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti_type; - if (rnti_type == 1 && dci_rnti != my_rnti && i + 1 < num_pdus) - { - if (num_pdu_indicies < max_pdu_indicies) - { - pdu_indicies[num_pdu_indicies++] = i + 1; // This an index of a dlsch pdu which contains a pdu_index field - } - i++; - } - } - } - - return num_pdu_indicies; -} - -typedef struct dlsch_pdu_indicies_and_request_t -{ - size_t num_indicies; - int *indicies; - nfapi_dl_config_request_t *req; -}dlsch_pdu_indicies_and_request_t; - -static void print_lists(const dlsch_pdu_indicies_and_request_t *dlsch_list, const nfapi_tx_req_pdu_list_t *tx_pdu_list) -{ - const size_t max_result = 1024; - uint16_t num_pdus = tx_pdu_list->num_pdus; - char dlsch_result[max_result]; - char tx_pdu_result[max_result]; - - snprintf(dlsch_result, max_result, "dlsch_list::"); - snprintf(tx_pdu_result, max_result, "tx_pdu_list::"); - - for (size_t i = 0; i < num_pdus; ++i) - { - int dlsch_len = strlen(dlsch_result); - int tx_pdu_len = strlen(tx_pdu_result); - if (tx_pdu_len >= max_result - 1 || dlsch_len >= max_result - 1) - { - break; - } - snprintf(dlsch_result + dlsch_len, max_result - dlsch_len, " %d", dlsch_list->indicies[i]); - snprintf(tx_pdu_result + tx_pdu_len, max_result - tx_pdu_len, " %d", tx_pdu_list->pdus[i].pdu_index); - } - - LOG_E(MAC, "%s\n", dlsch_result); - LOG_E(MAC, "%s\n", tx_pdu_result); -} - -static bool match_dl_config_req(void *wanted_vp, void *candidate_vp) -{ - dlsch_pdu_indicies_and_request_t *wanted = wanted_vp; - const nfapi_tx_req_pdu_list_t *candidate = candidate_vp; - - int num_pdus = candidate->num_pdus; - if (wanted->num_indicies != num_pdus) - { - LOG_E(MAC, "tx_req_pdus not equal to dlsch_pdus:: %zu != %d\n", wanted->num_indicies, num_pdus); - return false; - } - - for (int i = 0; i < num_pdus; ++i) - { - bool found = false; - const nfapi_tx_request_pdu_t *pdu = &candidate->pdus[i]; - for (int j = 0; j < num_pdus; ++j) - { - size_t dlsch_index = wanted->indicies[j]; - AssertFatal(dlsch_index < wanted->req->dl_config_request_body.number_pdu, "dlsch_index is out of range of pdu_list\n"); - nfapi_dl_config_request_pdu_t *dlsch_pdu = &wanted->req->dl_config_request_body.dl_config_pdu_list[dlsch_index]; - - // This may be redundant but wont hurt. - AssertFatal(dlsch_pdu->pdu_type == NFAPI_DL_CONFIG_DLSCH_PDU_TYPE, - "dlsch_index: %zu does not map to a DLSCH_PDU in dl_config_req sfn.sf = %d.%d pdu_type = %d\n", - dlsch_index, wanted->req->sfn_sf >> 4, wanted->req->sfn_sf & 15, dlsch_pdu->pdu_type); - - if (pdu->pdu_index == dlsch_pdu->dlsch_pdu.dlsch_pdu_rel8.pdu_index) - { - found = true; - break; - } - } - if (!found) - { - LOG_E(MAC, "Could not find tx_req_pdu index to match dlsch_index for pdu_index: %d\n", - pdu->pdu_index); - print_lists(wanted, candidate); - return false; - } - } - return true; -} - // The following set of memcpy functions should be getting called as callback // functions from pnf_p7_subframe_ind. int memcpy_dl_config_req(L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t *pnf_p7, nfapi_dl_config_request_t *req) { - if (!is_my_dl_config_req(req) && req->dl_config_request_body.number_pdu <= 2) - { - const size_t max_dlsch_pdu_indicies = 1024; - int dlsch_pdu_indicies[max_dlsch_pdu_indicies]; - // Need to remove corresponding tx_req (comes before dl_config_req always) - int num_dlsch_pdu_indicies = get_dlsch_pdu_indicies(req, dlsch_pdu_indicies, max_dlsch_pdu_indicies); - if (num_dlsch_pdu_indicies == 0) - { - LOG_E(MAC, "COULD NOT FIND DLSCH_PDU_INDICIES for dl_config_req SFN.SF: %d.%d", - req->sfn_sf >> 4, req->sfn_sf & 15); - return 0; - } - dlsch_pdu_indicies_and_request_t wanted = - { - num_dlsch_pdu_indicies, - dlsch_pdu_indicies, - req, - }; - nfapi_tx_req_pdu_list_t *matched = - unqueue_matching(&tx_req_pdu_queue, /*max_depth=*/ 2, - match_dl_config_req, &wanted); - if (!matched) - { - LOG_E(MAC, "Could not unqueue_matching\n"); - return 0; - } - - LOG_I(MAC, "REMOVING.. dl_config_req & tx_req\n"); - free(matched); - - return 0; - } - nfapi_dl_config_request_t *p = malloc(sizeof(nfapi_dl_config_request_t)); // UE_mac_inst[Mod_id].p->header = req->header; @@ -1139,10 +956,6 @@ int memcpy_dl_config_req(L1_rxtx_proc_t *proc, req->dl_config_request_body.dl_config_pdu_list[i]; } - if (!put_queue(&dl_config_req_queue, p)) { - free(p); - } - LOG_I(MAC, "DL_CONFIG_REQ QUEUE: %zu", dl_config_req_queue.num_items); return 0; } @@ -1246,10 +1059,6 @@ int memcpy_tx_req(nfapi_pnf_p7_config_t *pnf_p7, nfapi_tx_request_t *req) { } } - if (!put_queue(&tx_req_pdu_queue, list)) { - nfapi_free_tx_req_pdu_list(list); - } - return 0; } @@ -1278,10 +1087,16 @@ static bool is_my_hi_dci0_req(nfapi_hi_dci0_request_t *hi_dci0_req) int memcpy_hi_dci0_req (L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t* pnf_p7, nfapi_hi_dci0_request_t* req) { - if (!is_my_hi_dci0_req(req)) return 0; + + if (!is_my_hi_dci0_req(req)) + { + LOG_W(MAC, "Filtering hi_dci0_req\n"); + return 0; + } nfapi_hi_dci0_request_t *p = (nfapi_hi_dci0_request_t *)malloc(sizeof(nfapi_hi_dci0_request_t)); //if(req!=0){ + p->sfn_sf = req->sfn_sf; p->vendor_extension = req->vendor_extension; @@ -1439,6 +1254,9 @@ void *ue_standalone_pnf_task(void *context) int sd = ue_rx_sock_descriptor; assert(sd > 0); + + nfapi_tx_request_t tx_req; + bool tx_req_valid = false; while (true) { ssize_t len = recvfrom(sd, buffer, sizeof(buffer), 0, (struct sockaddr *)&server_address, &addr_len); @@ -1468,7 +1286,6 @@ void *ue_standalone_pnf_task(void *context) LOG_E(MAC, "Header unpack failed for standalone pnf\n"); continue; } - switch (header.message_id) { case NFAPI_DL_CONFIG_REQUEST: @@ -1478,32 +1295,51 @@ void *ue_standalone_pnf_task(void *context) sizeof(dl_config_req), NULL) < 0) { LOG_E(MAC, "Message dl_config_req failed to unpack\n"); + break; + } + + // In multiUE scenario possible to get a dl_config_req before the tx_req? -Melissa + // How should we handle this? -Melissa + LOG_I(MAC, "dl_config_req Frame: %u Subframe: %u\n", dl_config_req.sfn_sf >> 4, + dl_config_req.sfn_sf & 15); + if (!tx_req_valid) + { + LOG_W(MAC, "The tx_req not valid.\n"); + break; } - else + if (dl_config_req.sfn_sf != tx_req.sfn_sf) { - // check to see if dl_config_req is null - LOG_I(MAC, "dl_config_req Frame: %u Subframe: %u\n", dl_config_req.sfn_sf >> 4, - dl_config_req.sfn_sf & 15); - memcpy_dl_config_req(NULL, NULL, &dl_config_req); + LOG_W(MAC, "sfnsf mismatch. dl_config_req Frame: %u Subframe: %u, tx_req Frame: %u Subframe: %u\n", + dl_config_req.sfn_sf >> 4, dl_config_req.sfn_sf & 15, + tx_req.sfn_sf >> 4, tx_req.sfn_sf & 15); + tx_req_valid = false; + break; } + + enqueue_dl_config_req_tx_req(&dl_config_req, &tx_req); + tx_req_valid = false; + break; } case NFAPI_TX_REQUEST: { - nfapi_tx_request_t tx_req; // lock this tx_req if (nfapi_p7_message_unpack((void *)buffer, len, &tx_req, sizeof(tx_req), NULL) < 0) { LOG_E(MAC, "Message tx_req failed to unpack\n"); + break; } - else + + LOG_I(MAC, "tx_req Frame: %u Subframe: %u\n", tx_req.sfn_sf >> 4, + tx_req.sfn_sf & 15); + if (tx_req_valid) { - // check to see if tx_req is null - LOG_I(MAC, "tx_req Frame: %u Subframe: %u\n", tx_req.sfn_sf >> 4, - tx_req.sfn_sf & 15); - memcpy_tx_req(NULL, &tx_req); + LOG_W(MAC, "Received consecutive tx_reqs\n"); } + + tx_req_valid = true; + break; } case NFAPI_HI_DCI0_REQUEST: @@ -1514,12 +1350,12 @@ void *ue_standalone_pnf_task(void *context) sizeof(hi_dci0_req), NULL) < 0) { LOG_E(MAC, "Message hi_dci0_req failed to unpack\n"); + break; } - else - { - // check to see if hi_dci0_req is null - memcpy_hi_dci0_req(NULL, NULL, &hi_dci0_req); - } + + // check to see if hi_dci0_req is null + memcpy_hi_dci0_req(NULL, NULL, &hi_dci0_req); + break; } case NFAPI_UL_CONFIG_REQUEST: @@ -1530,12 +1366,12 @@ void *ue_standalone_pnf_task(void *context) sizeof(ul_config_req), NULL) < 0) { LOG_E(MAC, "Message ul_config_req failed to unpack\n"); + break; } - else - { - // check to see if ul_config_req is null - memcpy_ul_config_req(NULL, NULL, &ul_config_req); - } + + // check to see if ul_config_req is null + memcpy_ul_config_req(NULL, NULL, &ul_config_req); + break; } default: @@ -1546,6 +1382,132 @@ void *ue_standalone_pnf_task(void *context) } } + +void *memcpy_dl_config_req_standalone(nfapi_dl_config_request_t *dl_config_req) +{ + nfapi_dl_config_request_t *p = malloc(sizeof(nfapi_dl_config_request_t)); + + p->sfn_sf = dl_config_req->sfn_sf; + + p->vendor_extension = dl_config_req->vendor_extension; + + p->dl_config_request_body.number_dci = dl_config_req->dl_config_request_body.number_dci; + p->dl_config_request_body.number_pdcch_ofdm_symbols = dl_config_req->dl_config_request_body.number_pdcch_ofdm_symbols; + p->dl_config_request_body.number_pdsch_rnti = dl_config_req->dl_config_request_body.number_pdsch_rnti; + p->dl_config_request_body.number_pdu = dl_config_req->dl_config_request_body.number_pdu; + + p->dl_config_request_body.tl.tag = dl_config_req->dl_config_request_body.tl.tag; + p->dl_config_request_body.tl.length = dl_config_req->dl_config_request_body.tl.length; + + p->dl_config_request_body.dl_config_pdu_list = + calloc(dl_config_req->dl_config_request_body.number_pdu, + sizeof(nfapi_dl_config_request_pdu_t)); + for (int i = 0; i < p->dl_config_request_body.number_pdu; i++) { + p->dl_config_request_body.dl_config_pdu_list[i] = + dl_config_req->dl_config_request_body.dl_config_pdu_list[i]; + } + return p; +} + +void *memcpy_tx_req_standalone(nfapi_tx_request_t *tx_req) +{ + int num_pdus = tx_req->tx_request_body.number_of_pdus; + + nfapi_tx_req_pdu_list_t *list = calloc(1, sizeof(nfapi_tx_req_pdu_list_t) + num_pdus * sizeof(nfapi_tx_request_pdu_t)); + list->num_pdus = num_pdus; + nfapi_tx_request_pdu_t *p = list->pdus; + + for (int i = 0; i < num_pdus; i++) + { + p[i].num_segments = tx_req->tx_request_body.tx_pdu_list[i].num_segments; + p[i].pdu_index = tx_req->tx_request_body.tx_pdu_list[i].pdu_index; + p[i].pdu_length = tx_req->tx_request_body.tx_pdu_list[i].pdu_length; + for (int j = 0; j < tx_req->tx_request_body.tx_pdu_list[i].num_segments; j++) + { + p[i].segments[j].segment_length = tx_req->tx_request_body.tx_pdu_list[i].segments[j].segment_length; + if (p[i].segments[j].segment_length > 0) + { + p[i].segments[j].segment_data = calloc( + p[i].segments[j].segment_length, sizeof(uint8_t)); + memcpy(p[i].segments[j].segment_data, + tx_req->tx_request_body.tx_pdu_list[i].segments[j].segment_data, + p[i].segments[j].segment_length); + } + } + } + return list; +} + +static bool is_my_dl_config_req(const nfapi_dl_config_request_t *req) +{ + + const rnti_t my_rnti = UE_mac_inst[0].crnti; + int num_pdus = req->dl_config_request_body.number_pdu; + // look through list of pdus for rnti type 1 with my_rnti (normal dlsch case) + for (int i = 0; i < num_pdus; i++) + { + nfapi_dl_config_request_pdu_t *pdu = &req->dl_config_request_body.dl_config_pdu_list[i]; + const int pdu_type = pdu->pdu_type; + if (pdu_type == NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE) + { + const rnti_t dci_rnti = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti; + const int rnti_type = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti_type; + if (rnti_type == 1 && dci_rnti == my_rnti) + { + return true; + } + } + else if(pdu_type != NFAPI_DL_CONFIG_DLSCH_PDU_TYPE) + { + return true; // Because these two pdu_types are coupled and we have to accept all other pdu_types + } + } + + // Look for broadcasted rnti types + for (int i = 0; i < num_pdus; i++) + { + nfapi_dl_config_request_pdu_t *pdu = &req->dl_config_request_body.dl_config_pdu_list[i]; + const int pdu_type = pdu->pdu_type; + if (pdu_type == NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE) + { + const int rnti_type = pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti_type; + if (rnti_type != 1) + { + return true; + } + } + } + + + return false; +} + +void enqueue_dl_config_req_tx_req(nfapi_dl_config_request_t *dl_config_req, nfapi_tx_request_t *tx_req) +{ + if (!is_my_dl_config_req(dl_config_req)) + { + LOG_I(MAC, "Filtering dl_config_req and tx_req\n"); + return; + } + + nfapi_dl_config_request_t *dl_config_req_temp = memcpy_dl_config_req_standalone(dl_config_req); + nfapi_tx_req_pdu_list_t *tx_req_temp = memcpy_tx_req_standalone(tx_req); + LOG_E(MAC, "This is the num_pdus for tx_req: %d\n", tx_req_temp->num_pdus); + LOG_E(MAC, "This is the num_pdus for dl_config_req and the sfn_sf: %d, %d:%d\n", dl_config_req_temp->dl_config_request_body.number_pdu, + NFAPI_SFNSF2SFN(dl_config_req_temp->sfn_sf), NFAPI_SFNSF2SF(dl_config_req_temp->sfn_sf)); + + nfapi_dl_config_req_tx_req_t *req = malloc(sizeof(nfapi_dl_config_req_tx_req_t)); + req->dl_config_req = dl_config_req_temp; + req->tx_req_pdu_list = tx_req_temp; + + if (!put_queue(&dl_config_req_tx_req_queue, req)) + { + free(req->dl_config_req); + nfapi_free_tx_req_pdu_list(req->tx_req_pdu_list); + free(req); + } +} + const char *hexdump(const void *data, size_t data_len, char *out, size_t out_len) { char *p = out; diff --git a/openair2/PHY_INTERFACE/phy_stub_UE.h b/openair2/PHY_INTERFACE/phy_stub_UE.h index 135d01e977e857f811bd1f25ede6552a8f1f2a93..d1324e4e6f99913747be82260f8797bb1cbbf67d 100644 --- a/openair2/PHY_INTERFACE/phy_stub_UE.h +++ b/openair2/PHY_INTERFACE/phy_stub_UE.h @@ -103,6 +103,12 @@ typedef struct nfapi_tx_req_pdu_list_t nfapi_tx_request_pdu_t pdus[]; /* see "struct hack" */ } nfapi_tx_req_pdu_list_t; +typedef struct nfapi_dl_config_req_tx_req_t +{ + nfapi_dl_config_request_t *dl_config_req; + nfapi_tx_req_pdu_list_t *tx_req_pdu_list; +} nfapi_dl_config_req_tx_req_t; + void nfapi_free_tx_req_pdu_list(nfapi_tx_req_pdu_list_t *); void dl_config_req_UE_MAC_dci(int sfn, @@ -142,6 +148,10 @@ int memcpy_hi_dci0_req (L1_rxtx_proc_t *proc, nfapi_pnf_p7_config_t* pnf_p7, nfa void UE_config_stub_pnf(void); +void *memcpy_tx_req_standalone(nfapi_tx_request_t *tx_req); + +void *memcpy_dl_config_req_standalone(nfapi_dl_config_request_t *dl_config_req); + // open an SCTP socket with a standalone PNF module void ue_init_standalone_socket(const char *addr, int tx_port, int rx_port); @@ -149,6 +159,7 @@ void ue_init_standalone_socket(const char *addr, int tx_port, int rx_port); void *ue_standalone_pnf_task(void *context); void send_standalone_msg(UL_IND_t *UL, nfapi_message_id_e msg_type); void send_standalone_dummy(void); +void enqueue_dl_config_req_tx_req(nfapi_dl_config_request_t *dl_config_req, nfapi_tx_request_t *tx_req); // Convert downlink nfapi messages to a string. // Returned memory is malloc'ed, caller is responsible for freeing. @@ -160,8 +171,7 @@ char *nfapi_ul_config_req_to_string(nfapi_ul_config_request_t *req); const char *dl_pdu_type_to_string(uint8_t pdu_type); const char *ul_pdu_type_to_string(uint8_t pdu_type); -extern queue_t dl_config_req_queue; -extern queue_t tx_req_pdu_queue; /* items in this queue are nfapi_tx_req_pdu_list_t* */ +extern queue_t dl_config_req_tx_req_queue; extern queue_t ul_config_req_queue; extern queue_t hi_dci0_req_queue; diff --git a/targets/RT/USER/lte-ue.c b/targets/RT/USER/lte-ue.c index b2030e3cedcdc170c92b2e5edf873027dbfb6ccd..0b95029710d20976e7d7b0737e28a83b771596e9 100644 --- a/targets/RT/USER/lte-ue.c +++ b/targets/RT/USER/lte-ue.c @@ -1062,14 +1062,11 @@ static void *UE_phy_stub_standalone_pnf_task(void *arg) //PANOS: CAREFUL HERE! wait_sync("UE_phy_stub_standalone_pnf_task"); - int num_pairs = 0; - int num_lone = 0; int last_sfn_sf = -1; LOG_I(MAC, "Clearing Queues\n"); - reset_queue(&dl_config_req_queue); + reset_queue(&dl_config_req_tx_req_queue); reset_queue(&ul_config_req_queue); - reset_queue(&tx_req_pdu_queue); reset_queue(&hi_dci0_req_queue); while (!oai_exit) { @@ -1088,51 +1085,13 @@ static void *UE_phy_stub_standalone_pnf_task(void *arg) } last_sfn_sf = sfn_sf; - nfapi_tx_req_pdu_list_t *tx_req_pdu_list = get_queue(&tx_req_pdu_queue); - nfapi_dl_config_request_t *dl_config_req = get_queue(&dl_config_req_queue); - if (tx_req_pdu_list) - { - uint64_t deadline = clock_usec() + 1000; - if (!dl_config_req) - { - for (;;) - { - LOG_E(MAC, "Spinning and waiting for corresponding dl_config_req\n"); - dl_config_req = get_queue(&dl_config_req_queue); - if (dl_config_req) - { - break; - } - if (clock_usec() >= deadline) - { - LOG_E(MAC, "Giving up waiting for dl_config_req\n"); - break; - } - usleep(1); - } - } - } - + nfapi_dl_config_req_tx_req_t *dl_config_req_tx_req = get_queue(&dl_config_req_tx_req_queue); nfapi_ul_config_request_t *ul_config_req = get_queue(&ul_config_req_queue); nfapi_hi_dci0_request_t *hi_dci0_req = get_queue(&hi_dci0_req_queue); LOG_I(MAC, "received from proxy frame %d subframe %d\n", NFAPI_SFNSF2SFN(sfn_sf), NFAPI_SFNSF2SF(sfn_sf)); - if (dl_config_req != NULL) { - uint16_t dl_num_pdus = dl_config_req->dl_config_request_body.number_pdu; - LOG_A(MAC, "(OAI UE) Received dl_config_req from proxy at Frame: %d, Subframe: %d," - " with number of PDUs: %u\n", - NFAPI_SFNSF2SFN(dl_config_req->sfn_sf), NFAPI_SFNSF2SF(dl_config_req->sfn_sf), - dl_num_pdus); - if (dl_num_pdus > 0) { - char *dl_str = nfapi_dl_config_req_to_string(dl_config_req); - LOG_I(MAC, "dl_config_req: %s\n", dl_str); - free(dl_str); - } - } - if (tx_req_pdu_list != NULL) { - LOG_D(MAC, "tx_req pdus: %d\n", tx_req_pdu_list->num_pdus); - } + if (ul_config_req != NULL) { uint8_t ul_num_pdus = ul_config_req->ul_config_request_body.number_of_pdus; if (ul_num_pdus > 0) { @@ -1147,16 +1106,24 @@ static void *UE_phy_stub_standalone_pnf_task(void *arg) NFAPI_SFNSF2SFN(hi_dci0_req->sfn_sf), NFAPI_SFNSF2SF(hi_dci0_req->sfn_sf)); } - if ((dl_config_req != NULL) != (tx_req_pdu_list != NULL)) { - num_lone++; - } else { - num_pairs++; - } + if (dl_config_req_tx_req != NULL) { - if (dl_config_req && tx_req_pdu_list) { - if ((num_pairs % 1000) == 0) { - LOG_I(MAC, "num_pairs:%d, num_lone:%d\n", num_pairs, num_lone); + nfapi_tx_req_pdu_list_t *tx_req_pdu_list = dl_config_req_tx_req->tx_req_pdu_list; + nfapi_dl_config_request_t *dl_config_req = dl_config_req_tx_req->dl_config_req; + + uint16_t dl_num_pdus = dl_config_req->dl_config_request_body.number_pdu; + LOG_A(MAC, "(OAI UE) Received dl_config_req from proxy at Frame: %d, Subframe: %d," + " with number of PDUs: %u\n", + NFAPI_SFNSF2SFN(dl_config_req->sfn_sf), NFAPI_SFNSF2SF(dl_config_req->sfn_sf), + dl_num_pdus); + if (dl_num_pdus > 0) { + char *dl_str = nfapi_dl_config_req_to_string(dl_config_req); + LOG_I(MAC, "dl_config_req: %s\n", dl_str); + free(dl_str); } + LOG_D(MAC, "tx_req pdus: %d\n", tx_req_pdu_list->num_pdus); + + // Handling dl_config_req and tx_req: nfapi_dl_config_request_body_t *dl_config_req_body = &dl_config_req->dl_config_request_body; for (int i = 0; i < dl_config_req_body->number_pdu; ++i) { nfapi_dl_config_request_pdu_t *pdu = &dl_config_req_body->dl_config_pdu_list[i]; @@ -1345,24 +1312,24 @@ static void *UE_phy_stub_standalone_pnf_task(void *arg) } // De-allocate memory of nfapi requests copies before next subframe round - if (dl_config_req != NULL) { - if (dl_config_req->vendor_extension != NULL) { - free(dl_config_req->vendor_extension); - dl_config_req->vendor_extension = NULL; + if (dl_config_req_tx_req != NULL) { + if (dl_config_req_tx_req->dl_config_req->vendor_extension != NULL) { + free(dl_config_req_tx_req->dl_config_req->vendor_extension); + dl_config_req_tx_req->dl_config_req->vendor_extension = NULL; } - if (dl_config_req->dl_config_request_body.dl_config_pdu_list != NULL) { - free(dl_config_req->dl_config_request_body.dl_config_pdu_list); - dl_config_req->dl_config_request_body.dl_config_pdu_list = NULL; + if (dl_config_req_tx_req->dl_config_req->dl_config_request_body.dl_config_pdu_list != NULL) { + free(dl_config_req_tx_req->dl_config_req->dl_config_request_body.dl_config_pdu_list); + dl_config_req_tx_req->dl_config_req->dl_config_request_body.dl_config_pdu_list = NULL; } + nfapi_free_tx_req_pdu_list(dl_config_req_tx_req->tx_req_pdu_list); + dl_config_req_tx_req->tx_req_pdu_list = NULL; - free(dl_config_req); - dl_config_req = NULL; - } + free(dl_config_req_tx_req->dl_config_req); + dl_config_req_tx_req->dl_config_req = NULL; - if (tx_req_pdu_list != NULL) { - nfapi_free_tx_req_pdu_list(tx_req_pdu_list); - tx_req_pdu_list = NULL; + free(dl_config_req_tx_req); + dl_config_req_tx_req = NULL; } if (ul_config_req != NULL) { diff --git a/targets/RT/USER/lte-uesoftmodem.c b/targets/RT/USER/lte-uesoftmodem.c index e162a48726844b6ea05440fbff6f5fbbf6037487..a2b575182b276d4e1522682ad7135b3a25c7bed9 100644 --- a/targets/RT/USER/lte-uesoftmodem.c +++ b/targets/RT/USER/lte-uesoftmodem.c @@ -121,7 +121,6 @@ uint64_t downlink_frequency[MAX_NUM_CCs][4]; int32_t uplink_frequency_offset[MAX_NUM_CCs][4]; - int UE_scan = 1; int UE_scan_carrier = 0; @@ -280,7 +279,7 @@ void exit_function(const char *file, const char *function, const int line, const } extern int16_t dlsch_demod_shift; - +uint16_t ue_idx_standalone = 0xFFFF; static void get_options(void) { int CC_id=0; int tddflag=0; @@ -529,7 +528,7 @@ int restart_L1L2(module_id_t enb_id) { void init_pdcp(void) { uint32_t pdcp_initmask = (!IS_SOFTMODEM_NOS1) ? LINK_ENB_PDCP_TO_GTPV1U_BIT : (LINK_ENB_PDCP_TO_GTPV1U_BIT | PDCP_USE_NETLINK_BIT | LINK_ENB_PDCP_TO_IP_DRIVER_BIT); - + // Do we need to include standalone mode here? - Andrew if (IS_SOFTMODEM_BASICSIM || IS_SOFTMODEM_RFSIM || (nfapi_getmode()==NFAPI_UE_STUB_PNF)) { pdcp_initmask = pdcp_initmask | UE_NAS_USE_TUN_BIT; } @@ -731,8 +730,7 @@ int main( int argc, char **argv ) { //init_UE_stub(1,eMBMS_active,uecap_xer_in,emul_iface); init_UE_stub_single_thread(NB_UE_INST,eMBMS_active,uecap_xer_in,emul_iface); } else if (NFAPI_MODE==NFAPI_MODE_STANDALONE_PNF) { - init_queue(&dl_config_req_queue); - init_queue(&tx_req_pdu_queue); + init_queue(&dl_config_req_tx_req_queue); init_queue(&hi_dci0_req_queue); init_queue(&ul_config_req_queue);