diff --git a/ci-scripts/conf_files/rcc.band7.tm1.nfapi.conf b/ci-scripts/conf_files/rcc.band7.tm1.nfapi.conf
index 81fc7eedce43275998cfca24428ee77563e79452..28bfd91560d9085aa446f3e1267b6cf7853ea665 100644
--- a/ci-scripts/conf_files/rcc.band7.tm1.nfapi.conf
+++ b/ci-scripts/conf_files/rcc.band7.tm1.nfapi.conf
@@ -218,7 +218,7 @@ MACRLCs = (
THREAD_STRUCT = (
{
#three config for level of parallelism "PARALLEL_SINGLE_THREAD", "PARALLEL_RU_L1_SPLIT", or "PARALLEL_RU_L1_TRX_SPLIT"
- parallel_config = "PARALLEL_SINGLE_THREAD";
+ parallel_config = "PARALLEL_RU_L1_SPLIT";
#two option for worker "WORKER_DISABLE" or "WORKER_ENABLE"
worker_config = "WORKER_ENABLE";
}
diff --git a/ci-scripts/runTestOnVM.sh b/ci-scripts/runTestOnVM.sh
index 06b56458d0434125f55547dcbacc11b6a8800460..f2df1f7be046e584041dc4109780aeb0fd909b07 100755
--- a/ci-scripts/runTestOnVM.sh
+++ b/ci-scripts/runTestOnVM.sh
@@ -1843,7 +1843,7 @@ function run_test_on_vm {
fi
fi
- if [ $S1_NOS1_CFG -eq 0 ]
+ if [ $S1_NOS1_CFG -eq 2 ]
then
get_enb_noS1_ip_addr $ENB_VM_CMDS $ENB_VM_IP_ADDR
echo "############################################################"
diff --git a/common/utils/LOG/log.c b/common/utils/LOG/log.c
index 87150650db697c5f3c6e2127c125039f6a0e3269..857a83deab80c3b9027d62e64c5d4ea8b0d113d4 100644
--- a/common/utils/LOG/log.c
+++ b/common/utils/LOG/log.c
@@ -45,7 +45,19 @@
#include "common/config/config_userapi.h"
// main log variables
-
+log_mem_cnt_t log_mem_d[2];
+int log_mem_flag=0;
+int log_mem_multi=1;
+volatile int log_mem_side=0;
+pthread_mutex_t log_mem_lock;
+pthread_cond_t log_mem_notify;
+pthread_t log_mem_thread;
+int log_mem_file_cnt=0;
+volatile int log_mem_write_flag=0;
+volatile int log_mem_write_side=0;
+char __log_mem_filename[1024]={0};
+char * log_mem_filename = &__log_mem_filename[0];
+char logmem_filename[1024] = {0};
mapping log_level_names[] = {
@@ -456,15 +468,23 @@ void logRecord_mt(const char *file, const char *func, int line, int comp, int le
char log_buffer[MAX_LOG_TOTAL];
va_list args;
va_start(args, format);
+ if (log_mem_flag == 1) {
+ log_output_memory(file,func,line,comp,level, format,args);
+ } else {
log_header(log_buffer,MAX_LOG_TOTAL,comp, level,format);
g_log->log_component[comp].vprint(g_log->log_component[comp].stream,log_buffer, args);
+ }
va_end(args);
}
void vlogRecord_mt(const char *file, const char *func, int line, int comp, int level, const char *format, va_list args ) {
char log_buffer[MAX_LOG_TOTAL];
+ if (log_mem_flag == 1) {
+ log_output_memory(file,func,line,comp,level, format,args);
+ } else {
log_header(log_buffer,MAX_LOG_TOTAL,comp, level,format);
g_log->log_component[comp].vprint(g_log->log_component[comp].stream,log_buffer, args);
+ }
}
void log_dump(int component, void *buffer, int buffsize,int datatype, const char *format, ... ) {
@@ -646,6 +666,265 @@ void logClean (void) {
}
}
+extern int oai_exit;
+void flush_mem_to_file(void)
+{
+ int fp;
+ char f_name[1024];
+ struct timespec slp_tm;
+ slp_tm.tv_sec = 0;
+ slp_tm.tv_nsec = 10000;
+
+ pthread_setname_np( pthread_self(), "flush_mem_to_file");
+
+ while (!oai_exit) {
+ pthread_mutex_lock(&log_mem_lock);
+ log_mem_write_flag=0;
+ pthread_cond_wait(&log_mem_notify, &log_mem_lock);
+ log_mem_write_flag=1;
+ pthread_mutex_unlock(&log_mem_lock);
+ // write!
+ if(log_mem_d[log_mem_write_side].enable_flag==0){
+ if(log_mem_file_cnt>5){
+ log_mem_file_cnt=5;
+ printf("log over write!!!\n");
+ }
+ snprintf(f_name,1024, "%s_%d.log",log_mem_filename,log_mem_file_cnt);
+ fp=open(f_name, O_WRONLY | O_CREAT, 0666);
+ int ret = write(fp, log_mem_d[log_mem_write_side].buf_p, log_mem_d[log_mem_write_side].buf_index);
+ if ( ret < 0) {
+ fprintf(stderr,"{LOG} %s %d Couldn't write in %s \n",__FILE__,__LINE__,f_name);
+ exit(EXIT_FAILURE);
+ }
+ close(fp);
+ log_mem_file_cnt++;
+ log_mem_d[log_mem_write_side].buf_index=0;
+ log_mem_d[log_mem_write_side].enable_flag=1;
+ }else{
+ printf("If you'd like to write log, you should set enable flag to 0!!!\n");
+ nanosleep(&slp_tm,NULL);
+ }
+ }
+}
+
+char logmem_log_level[NUM_LOG_LEVEL]={'E','W','I','D','T'};
+
+void log_output_memory(const char *file, const char *func, int line, int comp, int level, const char* format,va_list args)
+{
+ //logRecord_mt(file,func,line, pthread_self(), comp, level, format, ##args)
+ int len = 0;
+ log_component_t *c;
+ char *log_start;
+ char *log_end;
+ /* The main difference with the version above is the use of this local log_buffer.
+ * The other difference is the return value of snprintf which was not used
+ * correctly. It was not a big problem because in practice MAX_LOG_TOTAL is
+ * big enough so that the buffer is never full.
+ */
+ char log_buffer[MAX_LOG_TOTAL];
+
+ /* for no gcc warnings */
+ (void)log_start;
+ (void)log_end;
+
+
+ c = &g_log->log_component[comp];
+
+ //VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LOG_RECORD, VCD_FUNCTION_IN);
+
+ // make sure that for log trace the extra info is only printed once, reset when the level changes
+ if (level == OAILOG_TRACE) {
+ log_start = log_buffer;
+ len = vsnprintf(log_buffer, MAX_LOG_TOTAL, format, args);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ log_end = log_buffer + len;
+ } else {
+ if ( (g_log->flag & 0x001) || (c->flag & 0x001) ) {
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "%s",
+ log_level_highlight_start[level]);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ }
+
+ log_start = log_buffer + len;
+
+// if ( (g_log->flag & 0x004) || (c->flag & 0x004) ) {
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s]",
+ g_log->log_component[comp].name);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+// }
+
+ if ( (level >= OAILOG_ERR) && (level <= OAILOG_TRACE) ) {
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%c]",
+ logmem_log_level[level]);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ }
+
+ if ( (g_log->flag & FLAG_THREAD) || (c->flag & FLAG_THREAD) ) {
+# define THREAD_NAME_LEN 128
+ char threadname[THREAD_NAME_LEN];
+ if (pthread_getname_np(pthread_self(), threadname, THREAD_NAME_LEN) != 0)
+ {
+ perror("pthread_getname_np : ");
+ } else {
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s]", threadname);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ }
+# undef THREAD_NAME_LEN
+ }
+
+ if ( (g_log->flag & FLAG_FUNCT) || (c->flag & FLAG_FUNCT) ) {
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s] ",
+ func);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ }
+
+ if ( (g_log->flag & FLAG_FILE_LINE) || (c->flag & FLAG_FILE_LINE) ) {
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%s:%d]",
+ file, line);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ }
+
+/* len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%08lx]", thread_id);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+
+ struct timeval gettime;
+ gettimeofday(&gettime,NULL);
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "[%ld.%06ld]", gettime.tv_sec, gettime.tv_usec);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+*/
+ if ( (g_log->flag & FLAG_NOCOLOR) || (c->flag & FLAG_NOCOLOR) ) {
+ len += snprintf(&log_buffer[len], MAX_LOG_TOTAL - len, "%s",
+ log_level_highlight_end[level]);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ }
+
+ len += vsnprintf(&log_buffer[len], MAX_LOG_TOTAL - len, format, args);
+ if (len > MAX_LOG_TOTAL) len = MAX_LOG_TOTAL;
+ log_end = log_buffer + len;
+ }
+
+ //va_end(args);
+
+ // OAI printf compatibility
+ if(log_mem_flag==1){
+ if(log_mem_d[log_mem_side].enable_flag==1){
+ int temp_index;
+ temp_index=log_mem_d[log_mem_side].buf_index;
+ if(temp_index+len+1 < LOG_MEM_SIZE){
+ log_mem_d[log_mem_side].buf_index+=len;
+ memcpy(&log_mem_d[log_mem_side].buf_p[temp_index],log_buffer,len);
+ }else{
+ log_mem_d[log_mem_side].enable_flag=0;
+ if(log_mem_d[1-log_mem_side].enable_flag==1){
+ temp_index=log_mem_d[1-log_mem_side].buf_index;
+ if(temp_index+len+1 < LOG_MEM_SIZE){
+ log_mem_d[1-log_mem_side].buf_index+=len;
+ log_mem_side=1-log_mem_side;
+ memcpy(&log_mem_d[log_mem_side].buf_p[temp_index],log_buffer,len);
+ /* write down !*/
+ if (pthread_mutex_lock(&log_mem_lock) != 0) {
+ return;
+ }
+ if(log_mem_write_flag==0){
+ log_mem_write_side=1-log_mem_side;
+ if(pthread_cond_signal(&log_mem_notify) != 0) {
+ }
+ }
+ if(pthread_mutex_unlock(&log_mem_lock) != 0) {
+ return;
+ }
+ }else{
+ log_mem_d[1-log_mem_side].enable_flag=0;
+ }
+ }
+ }
+ }
+ }else{
+ fwrite(log_buffer, len, 1, stdout);
+ }
+}
+
+int logInit_log_mem (void)
+{
+ if(log_mem_flag==1){
+ if(log_mem_multi==1){
+ printf("log-mem multi!!!\n");
+ log_mem_d[0].buf_p = malloc(LOG_MEM_SIZE);
+ log_mem_d[0].buf_index=0;
+ log_mem_d[0].enable_flag=1;
+ log_mem_d[1].buf_p = malloc(LOG_MEM_SIZE);
+ log_mem_d[1].buf_index=0;
+ log_mem_d[1].enable_flag=1;
+ log_mem_side=0;
+ if ((pthread_mutex_init (&log_mem_lock, NULL) != 0)
+ || (pthread_cond_init (&log_mem_notify, NULL) != 0)) {
+ log_mem_d[1].enable_flag=0;
+ return -1;
+ }
+ pthread_create(&log_mem_thread, NULL, (void *(*)(void *))flush_mem_to_file, (void*)NULL);
+ }else{
+ printf("log-mem single!!!\n");
+ log_mem_d[0].buf_p = malloc(LOG_MEM_SIZE);
+ log_mem_d[0].buf_index=0;
+ log_mem_d[0].enable_flag=1;
+ log_mem_d[1].enable_flag=0;
+ log_mem_side=0;
+ }
+ }else{
+ log_mem_d[0].buf_p=NULL;
+ log_mem_d[1].buf_p=NULL;
+ log_mem_d[0].enable_flag=0;
+ log_mem_d[1].enable_flag=0;
+ }
+
+ printf("log init done\n");
+
+ return 0;
+}
+
+void close_log_mem(void){
+ int fp;
+ char f_name[1024];
+
+ if(log_mem_flag==1){
+ log_mem_d[0].enable_flag=0;
+ log_mem_d[1].enable_flag=0;
+ usleep(10); // wait for log writing
+ while(log_mem_write_flag==1){
+ usleep(100);
+ }
+ if(log_mem_multi==1){
+ snprintf(f_name,1024, "%s_%d.log",log_mem_filename,log_mem_file_cnt);
+ fp=open(f_name, O_WRONLY | O_CREAT, 0666);
+ int ret = write(fp, log_mem_d[0].buf_p, log_mem_d[0].buf_index);
+ if ( ret < 0) {
+ fprintf(stderr,"{LOG} %s %d Couldn't write in %s \n",__FILE__,__LINE__,f_name);
+ exit(EXIT_FAILURE);
+ }
+ close(fp);
+ free(log_mem_d[0].buf_p);
+
+ snprintf(f_name,1024, "%s_%d.log",log_mem_filename,log_mem_file_cnt);
+ fp=open(f_name, O_WRONLY | O_CREAT, 0666);
+ ret = write(fp, log_mem_d[1].buf_p, log_mem_d[1].buf_index);
+ if ( ret < 0) {
+ fprintf(stderr,"{LOG} %s %d Couldn't write in %s \n",__FILE__,__LINE__,f_name);
+ exit(EXIT_FAILURE);
+ }
+ close(fp);
+ free(log_mem_d[1].buf_p);
+ }else{
+ fp=open(log_mem_filename, O_WRONLY | O_CREAT, 0666);
+ int ret = write(fp, log_mem_d[0].buf_p, log_mem_d[0].buf_index);
+ if ( ret < 0) {
+ fprintf(stderr,"{LOG} %s %d Couldn't write in %s \n",__FILE__,__LINE__,log_mem_filename);
+ exit(EXIT_FAILURE);
+ }
+ close(fp);
+ free(log_mem_d[0].buf_p);
+ }
+ }
+ }
#ifdef LOG_TEST
diff --git a/common/utils/LOG/log.h b/common/utils/LOG/log.h
index 1c413d580e202e8b7a302a066a7b289357dd26e8..be7db5470e4eeb4e9fe1e483254cd5763af9de4d 100644
--- a/common/utils/LOG/log.h
+++ b/common/utils/LOG/log.h
@@ -118,6 +118,8 @@ extern "C" {
#define FLAG_NOCOLOR 0x0001 /*!< \brief use colors in log messages, depending on level */
#define FLAG_THREAD 0x0008 /*!< \brief display thread name in log messages */
#define FLAG_LEVEL 0x0010 /*!< \brief display log level in log messages */
+#define FLAG_FUNCT 0x0020
+#define FLAG_FILE_LINE 0x0040
#define FLAG_TIME 0x0100
#define FLAG_INITIALIZED 0x8000
@@ -307,6 +309,19 @@ int is_newline( char *str, int size);
int register_log_component(char *name, char *fext, int compidx);
+#define LOG_MEM_SIZE 100*1024*1024
+#define LOG_MEM_FILE "./logmem.log"
+void flush_mem_to_file(void);
+void log_output_memory(const char *file, const char *func, int line, int comp, int level, const char* format,va_list args);
+int logInit_log_mem(void);
+void close_log_mem(void);
+
+typedef struct {
+ char* buf_p;
+ int buf_index;
+ int enable_flag;
+} log_mem_cnt_t;
+
/* @}*/
/*!\fn int32_t write_file_matlab(const char *fname, const char *vname, void *data, int length, int dec, char format);
diff --git a/common/utils/LOG/log_extern.h b/common/utils/LOG/log_extern.h
index 3c93d517ca76456f57927b34cfb915482b8b87c2..f6205889dc1477f2bc1bc86115ed89ff9ecaed72 100644
--- a/common/utils/LOG/log_extern.h
+++ b/common/utils/LOG/log_extern.h
@@ -27,4 +27,6 @@ extern log_t *g_log;
extern mapping log_level_names[];
extern mapping log_options[];
extern mapping log_maskmap[];
-
+extern int log_mem_flag;
+extern char * log_mem_filename;
+extern char logmem_filename[1024];
diff --git a/nfapi/oai_integration/nfapi_pnf.c b/nfapi/oai_integration/nfapi_pnf.c
index c835f38e115a449b6ede31168954873b52219288..f07fb1ad23f13aadeeabfe0b2178655bb4c2722e 100644
--- a/nfapi/oai_integration/nfapi_pnf.c
+++ b/nfapi/oai_integration/nfapi_pnf.c
@@ -83,7 +83,7 @@ nfapi_tx_request_pdu_t *tx_request_pdu[1023][10][10]; // [frame][subframe][max_n
uint8_t tx_pdus[32][8][4096];
-
+nfapi_ue_release_request_body_t release_rntis;
uint16_t phy_antenna_capability_values[] = { 1, 2, 4, 8, 16 };
nfapi_pnf_param_response_t g_pnf_param_resp;
@@ -197,19 +197,19 @@ static pthread_t pnf_start_pthread;
int nfapitooai_level(int nfapi_level) {
switch(nfapi_level) {
case NFAPI_TRACE_ERROR:
- return LOG_ERR;
+ return OAILOG_ERR;
case NFAPI_TRACE_WARN:
- return LOG_WARNING;
+ return OAILOG_WARNING;
case NFAPI_TRACE_NOTE:
- return LOG_INFO;
+ return OAILOG_INFO;
case NFAPI_TRACE_INFO:
- return LOG_DEBUG;
+ return OAILOG_DEBUG;
}
- return LOG_ERR;
+ return OAILOG_ERR;
}
void pnf_nfapi_trace(nfapi_trace_level_t nfapi_level, const char *message, ...) {
@@ -540,7 +540,6 @@ int config_request(nfapi_pnf_config_t *config, nfapi_pnf_phy_config_t *phy, nfap
}
if(req->nfapi_config.earfcn.tl.tag == NFAPI_NFAPI_EARFCN_TAG) {
- fp->eutra_band = 0;
fp->dl_CarrierFreq = from_earfcn(fp->eutra_band, req->nfapi_config.earfcn.value);
fp->ul_CarrierFreq = fp->dl_CarrierFreq - (get_uldl_offset(fp->eutra_band) * 1e5);
num_tlv++;
@@ -896,6 +895,15 @@ int pnf_phy_lbt_dl_config_req(nfapi_pnf_p7_config_t *config, nfapi_lbt_dl_config
return 0;
}
+int pnf_phy_ue_release_req(nfapi_pnf_p7_config_t* config, nfapi_ue_release_request_t* req) {
+ if (req->ue_release_request_body.number_of_TLVs==0)
+ return -1;
+
+ release_rntis.number_of_TLVs = req->ue_release_request_body.number_of_TLVs;
+ memcpy(&release_rntis.ue_release_request_TLVs_list, req->ue_release_request_body.ue_release_request_TLVs_list, sizeof(nfapi_ue_release_request_TLVs_t)*req->ue_release_request_body.number_of_TLVs);
+ return 0;
+}
+
int pnf_phy_vendor_ext(nfapi_pnf_p7_config_t *config, nfapi_p7_message_header_t *msg) {
if(msg->message_id == P7_VENDOR_EXT_REQ) {
//vendor_ext_p7_req* req = (vendor_ext_p7_req*)msg;
@@ -1024,7 +1032,7 @@ int start_request(nfapi_pnf_config_t *config, nfapi_pnf_phy_config_t *phy, nfapi
p7_config->hi_dci0_req = &pnf_phy_hi_dci0_req;
p7_config->tx_req = &pnf_phy_tx_req;
p7_config->lbt_dl_config_req = &pnf_phy_lbt_dl_config_req;
-
+ p7_config->ue_release_req = &pnf_phy_ue_release_req;
if (NFAPI_MODE==NFAPI_UE_STUB_PNF) {
p7_config->dl_config_req = &memcpy_dl_config_req;
p7_config->ul_config_req = &memcpy_ul_config_req;
@@ -1367,7 +1375,7 @@ void configure_nfapi_pnf(char *vnf_ip_addr, int vnf_p5_port, char *pnf_ip_addr,
printf("%s() PNF\n\n\n\n\n\n", __FUNCTION__);
if(NFAPI_MODE!=NFAPI_UE_STUB_PNF) {
- nfapi_setmode(NFAPI_PNF); // PNF!
+ nfapi_setmode(NFAPI_MODE_PNF); // PNF!
}
nfapi_pnf_config_t *config = nfapi_pnf_config_create();
diff --git a/nfapi/oai_integration/nfapi_vnf.c b/nfapi/oai_integration/nfapi_vnf.c
index 2752df3435d37090e4ddc3f2347e8a45896869ba..6b68a2965885dc02fd6d394eae28ef5372116810 100644
--- a/nfapi/oai_integration/nfapi_vnf.c
+++ b/nfapi/oai_integration/nfapi_vnf.c
@@ -42,6 +42,7 @@
#include "common/ran_context.h"
extern RAN_CONTEXT_t RC;
+extern UL_RCC_IND_t UL_RCC_INFO;
typedef struct {
uint8_t enabled;
@@ -424,6 +425,40 @@ int phy_rach_indication(struct nfapi_vnf_p7_config *config, nfapi_rach_indicatio
struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
printf("[VNF] RACH_IND eNB:%p sfn_sf:%d number_of_preambles:%d\n", eNB, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->rach_indication_body.number_of_preambles);
pthread_mutex_lock(&eNB->UL_INFO_mutex);
+ if(NFAPI_MODE == NFAPI_MODE_VNF){
+ int8_t index = -1;
+ for(uint8_t i= 0;i< NUM_NFPAI_SUBFRAME;i++){
+ if((UL_RCC_INFO.rach_ind[i].header.message_id == 0) && (index == -1)){
+ index = i;
+ break;
+ }
+ }
+ if(index == -1){
+ LOG_E(MAC,"phy_rach_indication : num of rach reach max \n");
+ return 0;
+ }
+ UL_RCC_INFO.rach_ind[index] = *ind;
+
+ if (ind->rach_indication_body.number_of_preambles > 0)
+ UL_RCC_INFO.rach_ind[index].rach_indication_body.preamble_list = malloc(sizeof(nfapi_preamble_pdu_t)*ind->rach_indication_body.number_of_preambles );
+
+ for (int i=0; i<ind->rach_indication_body.number_of_preambles; i++) {
+ if (ind->rach_indication_body.preamble_list[i].preamble_rel8.tl.tag == NFAPI_PREAMBLE_REL8_TAG) {
+
+ printf("preamble[%d]: rnti:%02x preamble:%d timing_advance:%d\n",
+ i,
+ ind->rach_indication_body.preamble_list[i].preamble_rel8.rnti,
+ ind->rach_indication_body.preamble_list[i].preamble_rel8.preamble,
+ ind->rach_indication_body.preamble_list[i].preamble_rel8.timing_advance
+ );
+ }
+ if(ind->rach_indication_body.preamble_list[i].preamble_rel13.tl.tag == NFAPI_PREAMBLE_REL13_TAG) {
+ printf("RACH PREAMBLE REL13 present\n");
+ }
+
+ UL_RCC_INFO.rach_ind[index].rach_indication_body.preamble_list[i] = ind->rach_indication_body.preamble_list[i];
+ }
+ }else{
eNB->UL_INFO.rach_ind = *ind;
eNB->UL_INFO.rach_ind.rach_indication_body.preamble_list = eNB->preamble_list;
@@ -443,7 +478,7 @@ int phy_rach_indication(struct nfapi_vnf_p7_config *config, nfapi_rach_indicatio
eNB->preamble_list[i] = ind->rach_indication_body.preamble_list[i];
}
-
+ }
pthread_mutex_unlock(&eNB->UL_INFO_mutex);
// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
//mac_rach_ind(p7_vnf->mac, ind);
@@ -454,13 +489,33 @@ int phy_harq_indication(struct nfapi_vnf_p7_config *config, nfapi_harq_indicatio
struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
LOG_D(MAC, "%s() NFAPI SFN/SF:%d number_of_harqs:%u\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->harq_indication_body.number_of_harqs);
pthread_mutex_lock(&eNB->UL_INFO_mutex);
+ if(NFAPI_MODE == NFAPI_MODE_VNF){
+ int8_t index = -1;
+ for(uint8_t i= 0;i< NUM_NFPAI_SUBFRAME;i++){
+ if((UL_RCC_INFO.harq_ind[i].header.message_id == 0) && (index == -1)){
+ index = i;
+ break;
+ }
+ }
+ if(index == -1){
+ LOG_E(MAC,"phy_harq_indication : num of harq reach max \n");
+ return 0;
+ }
+ UL_RCC_INFO.harq_ind[index] = *ind;
+
+ if (ind->harq_indication_body.number_of_harqs > 0)
+ UL_RCC_INFO.harq_ind[index].harq_indication_body.harq_pdu_list = malloc(sizeof(nfapi_harq_indication_pdu_t)*ind->harq_indication_body.number_of_harqs );
+ for (int i=0; i<ind->harq_indication_body.number_of_harqs; i++) {
+ memcpy(&UL_RCC_INFO.harq_ind[index].harq_indication_body.harq_pdu_list[i], &ind->harq_indication_body.harq_pdu_list[i], sizeof(nfapi_harq_indication_pdu_t));
+ }
+ }else{
eNB->UL_INFO.harq_ind = *ind;
eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list = eNB->harq_pdu_list;
for (int i=0; i<ind->harq_indication_body.number_of_harqs; i++) {
memcpy(&eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list[i], &ind->harq_indication_body.harq_pdu_list[i], sizeof(eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list[i]));
}
-
+ }
pthread_mutex_unlock(&eNB->UL_INFO_mutex);
// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
//mac_harq_ind(p7_vnf->mac, ind);
@@ -470,6 +525,37 @@ int phy_harq_indication(struct nfapi_vnf_p7_config *config, nfapi_harq_indicatio
int phy_crc_indication(struct nfapi_vnf_p7_config *config, nfapi_crc_indication_t *ind) {
struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
pthread_mutex_lock(&eNB->UL_INFO_mutex);
+ if(NFAPI_MODE == NFAPI_MODE_VNF){
+ int8_t index = -1;
+ for(uint8_t i= 0;i< NUM_NFPAI_SUBFRAME;i++){
+ if((UL_RCC_INFO.crc_ind[i].header.message_id == 0) && (index == -1)){
+ index = i;
+ }
+ if(UL_RCC_INFO.rx_ind[i].sfn_sf == ind->sfn_sf){
+ index = i;
+ break;
+ }
+ }
+ if(index == -1){
+ LOG_E(MAC,"phy_crc_indication : num of crc reach max \n");
+ return 0;
+ }
+ UL_RCC_INFO.crc_ind[index] = *ind;
+
+ if (ind->crc_indication_body.number_of_crcs > 0)
+ UL_RCC_INFO.crc_ind[index].crc_indication_body.crc_pdu_list = malloc(sizeof(nfapi_crc_indication_pdu_t)*ind->crc_indication_body.number_of_crcs );
+
+ for (int i=0; i<ind->crc_indication_body.number_of_crcs; i++) {
+ memcpy(&UL_RCC_INFO.crc_ind[index].crc_indication_body.crc_pdu_list[i], &ind->crc_indication_body.crc_pdu_list[i], sizeof(ind->crc_indication_body.crc_pdu_list[0]));
+
+ LOG_D(MAC, "%s() NFAPI SFN/SF:%d CRC_IND:number_of_crcs:%u UL_INFO:crcs:%d PDU[%d] rnti:%04x UL_INFO:rnti:%04x\n",
+ __FUNCTION__,
+ NFAPI_SFNSF2DEC(ind->sfn_sf), ind->crc_indication_body.number_of_crcs, UL_RCC_INFO.crc_ind[index].crc_indication_body.number_of_crcs,
+ i,
+ ind->crc_indication_body.crc_pdu_list[i].rx_ue_information.rnti,
+ UL_RCC_INFO.crc_ind[index].crc_indication_body.crc_pdu_list[i].rx_ue_information.rnti);
+ }
+ }else{
eNB->UL_INFO.crc_ind = *ind;
nfapi_crc_indication_t *dest_ind = &eNB->UL_INFO.crc_ind;
nfapi_crc_indication_pdu_t *dest_pdu_list = eNB->crc_pdu_list;
@@ -489,7 +575,7 @@ int phy_crc_indication(struct nfapi_vnf_p7_config *config, nfapi_crc_indication_
ind->crc_indication_body.crc_pdu_list[i].rx_ue_information.rnti,
eNB->UL_INFO.crc_ind.crc_indication_body.crc_pdu_list[i].rx_ue_information.rnti);
}
-
+ }
pthread_mutex_unlock(&eNB->UL_INFO_mutex);
// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
//mac_crc_ind(p7_vnf->mac, ind);
@@ -504,6 +590,52 @@ int phy_rx_indication(struct nfapi_vnf_p7_config *config, nfapi_rx_indication_t
}
pthread_mutex_lock(&eNB->UL_INFO_mutex);
+ if(NFAPI_MODE == NFAPI_MODE_VNF){
+ int8_t index = -1;
+ for(uint8_t i= 0;i< NUM_NFPAI_SUBFRAME;i++){
+ if((UL_RCC_INFO.rx_ind[i].header.message_id == 0) && (index == -1)){
+ index = i;
+ }
+ if(UL_RCC_INFO.crc_ind[i].sfn_sf == ind->sfn_sf){
+ index = i;
+ break;
+ }
+ }
+ if(index == -1){
+ LOG_E(MAC,"phy_rx_indication : num of rx reach max \n");
+ return 0;
+ }
+ UL_RCC_INFO.rx_ind[index] = *ind;
+
+ if (ind->rx_indication_body.number_of_pdus > 0)
+ UL_RCC_INFO.rx_ind[index].rx_indication_body.rx_pdu_list = malloc(sizeof(nfapi_rx_indication_pdu_t)*ind->rx_indication_body.number_of_pdus );
+
+ for (int i=0; i<ind->rx_indication_body.number_of_pdus; i++) {
+ nfapi_rx_indication_pdu_t *dest_pdu = &UL_RCC_INFO.rx_ind[index].rx_indication_body.rx_pdu_list[i];
+ nfapi_rx_indication_pdu_t *src_pdu = &ind->rx_indication_body.rx_pdu_list[i];
+
+ memcpy(dest_pdu, src_pdu, sizeof(*src_pdu));
+ // DJP - TODO FIXME - intentional memory leak
+ if(dest_pdu->rx_indication_rel8.length > 0){
+ dest_pdu->data = malloc(dest_pdu->rx_indication_rel8.length);
+ memcpy(dest_pdu->data, src_pdu->data, dest_pdu->rx_indication_rel8.length);
+ }else{
+ dest_pdu->data = NULL;
+ }
+
+ LOG_D(PHY, "%s() NFAPI SFN/SF:%d PDUs:%d [PDU:%d] handle:%d rnti:%04x length:%d offset:%d ul_cqi:%d ta:%d data:%p\n",
+ __FUNCTION__,
+ NFAPI_SFNSF2DEC(ind->sfn_sf), ind->rx_indication_body.number_of_pdus, i,
+ dest_pdu->rx_ue_information.handle,
+ dest_pdu->rx_ue_information.rnti,
+ dest_pdu->rx_indication_rel8.length,
+ dest_pdu->rx_indication_rel8.offset,
+ dest_pdu->rx_indication_rel8.ul_cqi,
+ dest_pdu->rx_indication_rel8.timing_advance,
+ dest_pdu->data
+ );
+ }
+ }else{
nfapi_rx_indication_t *dest_ind = &eNB->UL_INFO.rx_ind;
nfapi_rx_indication_pdu_t *dest_pdu_list = eNB->rx_pdu_list;
*dest_ind = *ind;
@@ -528,7 +660,7 @@ int phy_rx_indication(struct nfapi_vnf_p7_config *config, nfapi_rx_indication_t
dest_pdu->data
);
}
-
+ }
pthread_mutex_unlock(&eNB->UL_INFO_mutex);
// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
//mac_rx_ind(p7_vnf->mac, ind);
@@ -544,6 +676,32 @@ int phy_sr_indication(struct nfapi_vnf_p7_config *config, nfapi_sr_indication_t
struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
LOG_D(MAC, "%s() NFAPI SFN/SF:%d srs:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->sr_indication_body.number_of_srs);
pthread_mutex_lock(&eNB->UL_INFO_mutex);
+ if(NFAPI_MODE == NFAPI_MODE_VNF){
+ int8_t index = -1;
+ for(uint8_t i= 0;i< NUM_NFPAI_SUBFRAME;i++){
+ if((UL_RCC_INFO.sr_ind[i].header.message_id == 0) && (index == -1)){
+ index = i;
+ break;
+ }
+ }
+ if(index == -1){
+ LOG_E(MAC,"phy_sr_indication : num of sr reach max \n");
+ return 0;
+ }
+ UL_RCC_INFO.sr_ind[index] = *ind;
+ LOG_D(MAC,"%s() UL_INFO[%d].sr_ind.sr_indication_body.number_of_srs:%d\n", __FUNCTION__, index, eNB->UL_INFO.sr_ind.sr_indication_body.number_of_srs);
+ if (ind->sr_indication_body.number_of_srs > 0)
+ UL_RCC_INFO.sr_ind[index].sr_indication_body.sr_pdu_list = malloc(sizeof(nfapi_sr_indication_pdu_t)*ind->sr_indication_body.number_of_srs );
+
+ for (int i=0; i<ind->sr_indication_body.number_of_srs; i++) {
+ nfapi_sr_indication_pdu_t *dest_pdu = &UL_RCC_INFO.sr_ind[index].sr_indication_body.sr_pdu_list[i];
+ nfapi_sr_indication_pdu_t *src_pdu = &ind->sr_indication_body.sr_pdu_list[i];
+
+ LOG_D(MAC, "SR_IND[PDU:%d %d][rnti:%x cqi:%d channel:%d]\n", index, i, src_pdu->rx_ue_information.rnti, src_pdu->ul_cqi_information.ul_cqi, src_pdu->ul_cqi_information.channel);
+
+ memcpy(dest_pdu, src_pdu, sizeof(*src_pdu));
+ }
+ }else{
nfapi_sr_indication_t *dest_ind = &eNB->UL_INFO.sr_ind;
nfapi_sr_indication_pdu_t *dest_pdu_list = eNB->sr_pdu_list;
*dest_ind = *ind;
@@ -556,7 +714,7 @@ int phy_sr_indication(struct nfapi_vnf_p7_config *config, nfapi_sr_indication_t
LOG_D(MAC, "SR_IND[PDU:%d][rnti:%x cqi:%d channel:%d]\n", i, src_pdu->rx_ue_information.rnti, src_pdu->ul_cqi_information.ul_cqi, src_pdu->ul_cqi_information.channel);
memcpy(dest_pdu, src_pdu, sizeof(*src_pdu));
}
-
+ }
pthread_mutex_unlock(&eNB->UL_INFO_mutex);
// vnf_p7_info* p7_vnf = (vnf_p7_info*)(config->user_data);
//mac_sr_ind(p7_vnf->mac, ind);
@@ -569,7 +727,48 @@ int phy_cqi_indication(struct nfapi_vnf_p7_config *config, nfapi_cqi_indication_
struct PHY_VARS_eNB_s *eNB = RC.eNB[0][0];
LOG_D(MAC, "%s() NFAPI SFN/SF:%d number_of_cqis:%u\n", __FUNCTION__, NFAPI_SFNSF2DEC(ind->sfn_sf), ind->cqi_indication_body.number_of_cqis);
pthread_mutex_lock(&eNB->UL_INFO_mutex);
- eNB->UL_INFO.cqi_ind = ind->cqi_indication_body;
+ if(NFAPI_MODE == NFAPI_MODE_VNF){
+ int8_t index = -1;
+ for(uint8_t i= 0;i< NUM_NFPAI_SUBFRAME;i++){
+ if((UL_RCC_INFO.cqi_ind[i].header.message_id == 0) && (index == -1)){
+ index = i;
+ break;
+ }
+ }
+ if(index == -1){
+ LOG_E(MAC,"phy_cqi_indication : num of cqi reach max \n");
+ return 0;
+ }
+ UL_RCC_INFO.cqi_ind[index] = *ind;
+ if (ind->cqi_indication_body.number_of_cqis > 0){
+ UL_RCC_INFO.cqi_ind[index].cqi_indication_body.cqi_pdu_list = malloc(sizeof(nfapi_cqi_indication_pdu_t)*ind->cqi_indication_body.number_of_cqis );
+ UL_RCC_INFO.cqi_ind[index].cqi_indication_body.cqi_raw_pdu_list = malloc(sizeof(nfapi_cqi_indication_raw_pdu_t)*ind->cqi_indication_body.number_of_cqis );
+ }
+ for (int i=0; i<ind->cqi_indication_body.number_of_cqis; i++) {
+ nfapi_cqi_indication_pdu_t *src_pdu = &ind->cqi_indication_body.cqi_pdu_list[i];
+ LOG_D(MAC, "SR_IND[PDU:%d][rnti:%x cqi:%d channel:%d]\n", i, src_pdu->rx_ue_information.rnti,
+ src_pdu->ul_cqi_information.ul_cqi, src_pdu->ul_cqi_information.channel);
+ memcpy(&UL_RCC_INFO.cqi_ind[index].cqi_indication_body.cqi_pdu_list[i],
+ src_pdu, sizeof(nfapi_cqi_indication_pdu_t));
+
+ memcpy(&UL_RCC_INFO.cqi_ind[index].cqi_indication_body.cqi_raw_pdu_list[i],
+ &ind->cqi_indication_body.cqi_raw_pdu_list[i], sizeof(nfapi_cqi_indication_raw_pdu_t));
+ }
+ }else{
+ nfapi_cqi_indication_t *dest_ind = &eNB->UL_INFO.cqi_ind;
+ *dest_ind = *ind;
+ dest_ind->cqi_indication_body.cqi_pdu_list = ind->cqi_indication_body.cqi_pdu_list;
+ dest_ind->cqi_indication_body.cqi_raw_pdu_list = ind->cqi_indication_body.cqi_raw_pdu_list;
+ for(int i=0; i<ind->cqi_indication_body.number_of_cqis; i++) {
+ nfapi_cqi_indication_pdu_t *src_pdu = &ind->cqi_indication_body.cqi_pdu_list[i];
+ LOG_D(MAC, "SR_IND[PDU:%d][rnti:%x cqi:%d channel:%d]\n", i, src_pdu->rx_ue_information.rnti,
+ src_pdu->ul_cqi_information.ul_cqi, src_pdu->ul_cqi_information.channel);
+ memcpy(&dest_ind->cqi_indication_body.cqi_pdu_list[i],
+ src_pdu, sizeof(nfapi_cqi_indication_pdu_t));
+ memcpy(&dest_ind->cqi_indication_body.cqi_raw_pdu_list[i],
+ &ind->cqi_indication_body.cqi_raw_pdu_list[i], sizeof(nfapi_cqi_indication_raw_pdu_t));
+ }
+ }
pthread_mutex_unlock(&eNB->UL_INFO_mutex);
return 1;
}
@@ -947,6 +1146,7 @@ void configure_nfapi_vnf(char *vnf_addr, int vnf_p5_port) {
config->deallocate_p4_p5_vendor_ext = &vnf_deallocate_p4_p5_vendor_ext;
config->codec_config.allocate = &vnf_allocate;
config->codec_config.deallocate = &vnf_deallocate;
+ memset(&UL_RCC_INFO,0,sizeof(UL_RCC_IND_t));
NFAPI_TRACE(NFAPI_TRACE_INFO, "[VNF] Creating VNF NFAPI start thread %s\n", __FUNCTION__);
pthread_create(&vnf_start_pthread, NULL, (void *)&vnf_start_thread, config);
NFAPI_TRACE(NFAPI_TRACE_INFO, "[VNF] Created VNF NFAPI start thread %s\n", __FUNCTION__);
@@ -1021,3 +1221,21 @@ int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req) {
return retval;
}
+
+int oai_nfapi_ue_release_req(nfapi_ue_release_request_t *release_req){
+ if(release_req->ue_release_request_body.number_of_TLVs <= 0)
+ return 0;
+ nfapi_vnf_p7_config_t *p7_config = vnf.p7_vnfs[0].config;
+
+ release_req->header.phy_id = 1; // DJP HACK TODO FIXME - need to pass this around!!!!
+ release_req->header.message_id = NFAPI_UE_RELEASE_REQUEST;
+ release_req->ue_release_request_body.tl.tag = NFAPI_UE_RELEASE_BODY_TAG;
+
+ int retval = nfapi_vnf_p7_ue_release_req(p7_config, release_req);
+ if (retval!=0) {
+ LOG_E(PHY, "%s() Problem sending retval:%d\n", __FUNCTION__, retval);
+ } else {
+ release_req->ue_release_request_body.number_of_TLVs = 0;
+ }
+ return retval;
+}
diff --git a/nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h b/nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h
index 6a70e1f10afae444929d0ec07807318ee9f8f261..a1a0b6e7245ff7fc22963f6c9804a9a62716ee69 100644
--- a/nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h
+++ b/nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h
@@ -146,6 +146,8 @@ typedef enum {
NFAPI_LBT_DL_INDICATION,
NFAPI_NB_HARQ_INDICATION,
NFAPI_NRACH_INDICATION,
+ NFAPI_UE_RELEASE_REQUEST,
+ NFAPI_UE_RELEASE_RESPONSE,
NFAPI_PNF_PARAM_REQUEST = 0x0100,
NFAPI_PNF_PARAM_RESPONSE,
@@ -2392,6 +2394,19 @@ typedef struct {
} nfapi_tx_request_body_t;
#define NFAPI_TX_REQUEST_BODY_TAG 0x2022
+#define NFAPI_RELEASE_MAX_RNTI 256
+typedef struct {
+ uint32_t handle;
+ uint16_t rnti;
+} nfapi_ue_release_request_TLVs_t;
+
+typedef struct {
+ nfapi_tl_t tl;
+ uint16_t number_of_TLVs;
+ nfapi_ue_release_request_TLVs_t ue_release_request_TLVs_list[NFAPI_RELEASE_MAX_RNTI];
+} nfapi_ue_release_request_body_t;
+#define NFAPI_UE_RELEASE_BODY_TAG 0x2068
+
// P7 Message Structures
typedef struct {
nfapi_p7_message_header_t header;
@@ -3418,6 +3433,19 @@ typedef struct {
nfapi_vendor_extension_tlv_t vendor_extension;
} nfapi_error_indication_t;
+typedef struct {
+ nfapi_p7_message_header_t header;
+ uint16_t sfn_sf;
+ nfapi_ue_release_request_body_t ue_release_request_body;
+ nfapi_vendor_extension_tlv_t vendor_extension;
+} nfapi_ue_release_request_t;
+
+typedef struct {
+ nfapi_p7_message_header_t header;
+ uint32_t error_code;
+ nfapi_vendor_extension_tlv_t vendor_extension;
+} nfapi_ue_release_response_t;
+
//
// P4 Messages
//
diff --git a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c
old mode 100644
new mode 100755
index 2daf1450c852c9bbb7b5ff1003e308903b494ba4..be9205d035ea075803e8e548925f1c8f3a9f1e8c
--- a/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c
+++ b/nfapi/open-nFAPI/nfapi/src/nfapi_p7.c
@@ -81,13 +81,19 @@ void* nfapi_p7_allocate(size_t size, nfapi_p7_codec_config_t* config)
if(size == 0)
return 0;
+ void* buffer_p = NULL;
if(config && config->allocate)
{
- return (config->allocate)(size);
+ buffer_p = (config->allocate)(size);
+ if(buffer_p != NULL){
+ memset(buffer_p,0,size);
+ }
+ return buffer_p;
}
else
{
- return calloc(1, size);
+ buffer_p = calloc(1, size);
+ return buffer_p;
}
}
@@ -1577,7 +1583,43 @@ static uint8_t pack_tx_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *e
return x && y && z;
}
-
+
+static uint8_t pack_release_request_body_value(void* tlv, uint8_t **ppWritePackedMsg, uint8_t *end)
+{
+ nfapi_ue_release_request_body_t* value = (nfapi_ue_release_request_body_t*)tlv;
+ if(push16(value->number_of_TLVs, ppWritePackedMsg, end) == 0){
+ return 0;
+ }
+
+ uint8_t j;
+ uint16_t num = value->number_of_TLVs;
+ for(j = 0; j < num; ++j){
+ if(push16(value->ue_release_request_TLVs_list[j].rnti, ppWritePackedMsg, end) == 0){
+ return 0;
+ }
+ }
+ return 1;
+}
+
+static uint8_t pack_ue_release_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+{
+ nfapi_ue_release_request_t *pNfapiMsg = (nfapi_ue_release_request_t*)msg;
+ int x = push16(pNfapiMsg->sfn_sf, ppWritePackedMsg, end);
+ int y = pack_tlv(NFAPI_UE_RELEASE_BODY_TAG, &pNfapiMsg->ue_release_request_body, ppWritePackedMsg, end, &pack_release_request_body_value);
+ int z = pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config);
+ return x && y && z;
+}
+
+static uint8_t pack_ue_release_response(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+{
+
+ nfapi_ue_release_response_t *pNfapiMsg = (nfapi_ue_release_response_t*)msg;
+
+ int x = push32(pNfapiMsg->error_code, ppWritePackedMsg, end);
+ int z = pack_p7_vendor_extension_tlv(pNfapiMsg->vendor_extension, ppWritePackedMsg, end, config);
+ return x && z;
+}
+
static uint8_t pack_rx_ue_information_value(void* tlv, uint8_t **ppWritePackedMsg, uint8_t *end)
{
nfapi_rx_ue_information* value = (nfapi_rx_ue_information*)tlv;
@@ -2665,7 +2707,15 @@ int nfapi_p7_message_pack(void *pMessageBuf, void *pPackedBuf, uint32_t packedBu
//NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() NFAPI_TX_REQUEST\n", __FUNCTION__);
result = pack_tx_request(pMessageHeader, &pWritePackedMessage, end, config);
break;
-
+
+ case NFAPI_UE_RELEASE_REQUEST:
+ result =pack_ue_release_request(pMessageHeader, &pWritePackedMessage, end, config);
+ break;
+
+ case NFAPI_UE_RELEASE_RESPONSE:
+ result =pack_ue_release_response(pMessageHeader, &pWritePackedMessage, end, config);
+ break;
+
case NFAPI_HARQ_INDICATION:
result = pack_harq_indication(pMessageHeader, &pWritePackedMessage, end, config);
break;
@@ -4479,7 +4529,55 @@ static uint8_t unpack_tx_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *
return 1;
}
-
+
+static uint8_t unpack_ue_release_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t* config)
+{
+ uint8_t proceed = 1;
+ nfapi_ue_release_request_t *pNfapiMsg = (nfapi_ue_release_request_t*)msg;
+
+ if(pull16(ppReadPackedMsg, &pNfapiMsg->sfn_sf, end) == 0)
+ return 0;
+
+ while (((uint8_t*)(*ppReadPackedMsg) < end) && proceed)
+ {
+ nfapi_tl_t generic_tl;
+ if(unpack_tl(ppReadPackedMsg, &generic_tl, end) == 0)
+ return 0;
+
+ switch(generic_tl.tag)
+ {
+ case NFAPI_UE_RELEASE_BODY_TAG:
+ {
+ pNfapiMsg->ue_release_request_body.tl = generic_tl;
+ if( pull16(ppReadPackedMsg, &pNfapiMsg->ue_release_request_body.number_of_TLVs, end) == 0)
+ return 0;
+
+ if(pNfapiMsg->ue_release_request_body.number_of_TLVs > NFAPI_RELEASE_MAX_RNTI)
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s number of relese rnti's exceed maxium (count:%d max:%d)\n", __FUNCTION__, pNfapiMsg->ue_release_request_body.number_of_TLVs, NFAPI_RELEASE_MAX_RNTI);
+ return 0;
+ } else {
+ uint8_t j;
+ uint16_t num = pNfapiMsg->ue_release_request_body.number_of_TLVs;
+ for(j = 0; j < num; ++j){
+ if(pull16(ppReadPackedMsg, &pNfapiMsg->ue_release_request_body.ue_release_request_TLVs_list[j].rnti, end) == 0){
+ return 0;
+ }
+ }
+ }
+ }
+ break;
+ default:
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "unpack_ue_release_request FIXME : Invalid type %d \n", generic_tl.tag );
+ }
+ break;
+ };
+ }
+
+ return 1;
+}
+
static uint8_t unpack_harq_indication_tdd_harq_data_bundling(void* tlv, uint8_t **ppReadPackedMsg, uint8_t *end)
{
nfapi_harq_indication_tdd_harq_data_bundling_t* value = (nfapi_harq_indication_tdd_harq_data_bundling_t*)tlv;
@@ -5727,7 +5825,18 @@ static uint8_t unpack_nrach_indication_rel13_value(void *tlv, uint8_t **ppReadPa
pull8(ppReadPackedMsg, &value->nrach_ce_level, end));
}
-
+static uint8_t unpack_ue_release_resp(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t* config)
+{
+ nfapi_ue_release_response_t *pNfapiMsg = (nfapi_ue_release_response_t*)msg;
+ if(pull32(ppReadPackedMsg, &pNfapiMsg->error_code, end) == 0){
+ return 0;
+ }
+ else{
+ NFAPI_TRACE(NFAPI_TRACE_INFO, "ue_release_response:error_code = %d\n", pNfapiMsg->error_code);
+ }
+ return 1;
+}
+
static uint8_t unpack_nrach_indication_body_value(void* tlv, uint8_t **ppReadPackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
{
nfapi_nrach_indication_body_t* value = (nfapi_nrach_indication_body_t*)tlv;
@@ -5940,7 +6049,17 @@ static int check_unpack_length(nfapi_message_id_e msgId, uint32_t unpackedBufLen
if (unpackedBufLen >= sizeof(nfapi_timing_info_t))
retLen = sizeof(nfapi_timing_info_t);
break;
-
+
+ case NFAPI_UE_RELEASE_REQUEST:
+ if (unpackedBufLen >= sizeof(nfapi_ue_release_request_t))
+ retLen = sizeof(nfapi_ue_release_request_t);
+ break;
+
+ case NFAPI_UE_RELEASE_RESPONSE:
+ if (unpackedBufLen >= sizeof(nfapi_ue_release_response_t))
+ retLen = sizeof(nfapi_ue_release_response_t);
+ break;
+
default:
NFAPI_TRACE(NFAPI_TRACE_ERROR, "Unknown message ID %d\n", msgId);
break;
@@ -6060,7 +6179,14 @@ int nfapi_p7_message_unpack(void *pMessageBuf, uint32_t messageBufLen, void *pUn
else
return -1;
break;
-
+
+ case NFAPI_UE_RELEASE_REQUEST:
+ if (check_unpack_length(NFAPI_UE_RELEASE_REQUEST, unpackedBufLen))
+ result = unpack_ue_release_request(&pReadPackedMessage, end, pMessageHeader, config);
+ else
+ return -1;
+ break;
+
case NFAPI_HARQ_INDICATION:
if (check_unpack_length(NFAPI_HARQ_INDICATION, unpackedBufLen))
result = unpack_harq_indication(&pReadPackedMessage, end, pMessageHeader, config);
@@ -6158,7 +6284,14 @@ int nfapi_p7_message_unpack(void *pMessageBuf, uint32_t messageBufLen, void *pUn
else
return -1;
break;
-
+
+ case NFAPI_UE_RELEASE_RESPONSE:
+ if (check_unpack_length(NFAPI_UE_RELEASE_RESPONSE, unpackedBufLen))
+ result = unpack_ue_release_resp(&pReadPackedMessage, end, pMessageHeader, config);
+ else
+ return -1;
+ break;
+
default:
if(pMessageHeader->message_id >= NFAPI_VENDOR_EXT_MSG_MIN &&
diff --git a/nfapi/open-nFAPI/pnf/public_inc/nfapi_pnf_interface.h b/nfapi/open-nFAPI/pnf/public_inc/nfapi_pnf_interface.h
index b25caf28760ff6e06ef4607b2d49f7e1a46e1de5..8d17416a418a98a822494726b1f1261aa1f66e54 100644
--- a/nfapi/open-nFAPI/pnf/public_inc/nfapi_pnf_interface.h
+++ b/nfapi/open-nFAPI/pnf/public_inc/nfapi_pnf_interface.h
@@ -546,7 +546,7 @@ typedef struct
nfapi_hi_dci0_request_t* hi_dci0_req;
nfapi_tx_request_t* tx_req;
nfapi_lbt_dl_config_request_t* lbt_dl_config_req;
-
+ nfapi_ue_release_request_t* ue_release_req;
} nfapi_pnf_p7_subframe_buffer_t;
typedef struct nfapi_pnf_p7_config nfapi_pnf_p7_config_t;
@@ -652,6 +652,17 @@ typedef struct nfapi_pnf_p7_config
* \return not currently used
*/
int (*lbt_dl_config_req)(nfapi_pnf_p7_config_t* config, nfapi_lbt_dl_config_request_t* req);
+
+ /*! A callback for the UE_RELEASE_REQ.request
+ * \param config A poiner to the PNF P7 config
+ * \param req A pointer to the release rnti request message structure
+ * \return not currently used
+ *
+ * The release request contains pointers to the release rnti to be sent. In the case that the FAPI interface
+ * will 'keep' the pointers until they are transmitted the callee should set the pointers in the req to 0
+ * and then use the p7 codec config free function to release the rnti when appropriate.
+ */
+ int (*ue_release_req)(nfapi_pnf_p7_config_t* config, nfapi_ue_release_request_t* req);
/*! A callback for vendor extension messages
* \param config A poiner to the PNF P7 config
@@ -796,6 +807,7 @@ int nfapi_pnf_p7_nrach_ind(nfapi_pnf_p7_config_t* config, nfapi_nrach_indication
*/
int nfapi_pnf_p7_vendor_extension(nfapi_pnf_p7_config_t* config, nfapi_p7_message_header_t* msg);
+int nfapi_pnf_ue_release_resp(nfapi_pnf_p7_config_t* config, nfapi_ue_release_response_t* resp);
#if defined(__cplusplus)
}
#endif
diff --git a/nfapi/open-nFAPI/pnf/src/pnf_p7.c b/nfapi/open-nFAPI/pnf/src/pnf_p7.c
index 81abed81a95b27935df7b19bb21ddb8b5c25f97d..944673037500c6f8478b3352f0998f28e840cc07 100644
--- a/nfapi/open-nFAPI/pnf/src/pnf_p7.c
+++ b/nfapi/open-nFAPI/pnf/src/pnf_p7.c
@@ -36,7 +36,7 @@ extern uint16_t sf_ahead;
void add_sf(uint16_t *frameP, uint16_t *subframeP, int offset)
{
- *frameP = *frameP + ((*subframeP + offset) / 10);
+ *frameP = (*frameP + ((*subframeP + offset) / 10))%1024;
*subframeP = ((*subframeP + offset) % 10);
}
@@ -241,6 +241,16 @@ void deallocate_nfapi_lbt_dl_config_request(nfapi_lbt_dl_config_request_t* req,
pnf_p7_free(pnf_p7, req);
}
+nfapi_ue_release_request_t* allocate_nfapi_ue_release_request(pnf_p7_t* pnf_p7)
+{
+ return pnf_p7_malloc(pnf_p7, sizeof(nfapi_ue_release_request_t));
+}
+
+void deallocate_nfapi_ue_release_request(nfapi_ue_release_request_t* req, pnf_p7_t* pnf_p7)
+{
+ pnf_p7_free(pnf_p7, req);
+}
+
pnf_p7_rx_message_t* pnf_p7_rx_reassembly_queue_add_segment(pnf_p7_t* pnf_p7, pnf_p7_rx_reassembly_queue_t* queue, uint32_t rx_hr_time, uint16_t sequence_number, uint16_t segment_number, uint8_t m, uint8_t* data, uint16_t data_len)
{
pnf_p7_rx_message_t* msg = 0;
@@ -720,6 +730,21 @@ int pnf_p7_subframe_ind(pnf_p7_t* pnf_p7, uint16_t phy_id, uint16_t sfn_sf)
}
}
+ if(tx_subframe_buffer->ue_release_req != 0)
+ {
+ if(pnf_p7->_public.ue_release_req)
+ (pnf_p7->_public.ue_release_req)(&(pnf_p7->_public), tx_subframe_buffer->ue_release_req);
+ }
+ else
+ {
+ //send dummy
+ if(pnf_p7->_public.ue_release_req && pnf_p7->_public.dummy_subframe.ue_release_req)
+ {
+ pnf_p7->_public.dummy_subframe.ue_release_req->sfn_sf = sfn_sf_tx;
+ (pnf_p7->_public.ue_release_req)(&(pnf_p7->_public), pnf_p7->_public.dummy_subframe.ue_release_req);
+ }
+ }
+
if(tx_subframe_buffer->dl_config_req != 0)
{
deallocate_nfapi_dl_config_request(tx_subframe_buffer->dl_config_req, pnf_p7);
@@ -735,6 +760,10 @@ int pnf_p7_subframe_ind(pnf_p7_t* pnf_p7, uint16_t phy_id, uint16_t sfn_sf)
deallocate_nfapi_hi_dci0_request(tx_subframe_buffer->hi_dci0_req, pnf_p7);
tx_subframe_buffer->hi_dci0_req = 0;
}
+ if(tx_subframe_buffer->ue_release_req != 0){
+ deallocate_nfapi_ue_release_request(tx_subframe_buffer->ue_release_req, pnf_p7);
+ tx_subframe_buffer->ue_release_req = 0;
+ }
}
else
{
@@ -799,7 +828,7 @@ int pnf_p7_subframe_ind(pnf_p7_t* pnf_p7, uint16_t phy_id, uint16_t sfn_sf)
}
} // sfn_sf match
- if (subframe_buffer->dl_config_req == 0 && subframe_buffer->tx_req == 0 && subframe_buffer->ul_config_req == 0 && subframe_buffer->lbt_dl_config_req == 0)
+ if (subframe_buffer->dl_config_req == 0 && subframe_buffer->tx_req == 0 && subframe_buffer->ul_config_req == 0 && subframe_buffer->lbt_dl_config_req == 0 && subframe_buffer->ue_release_req == 0)
{
memset(&(pnf_p7->subframe_buffer[buffer_index]), 0, sizeof(nfapi_pnf_p7_subframe_buffer_t));
pnf_p7->subframe_buffer[buffer_index].sfn_sf = -1;
@@ -1310,6 +1339,80 @@ void pnf_handle_p7_vendor_extension(void* pRecvMsg, int recvMsgLen, pnf_p7_t* pn
}
+void pnf_handle_ue_release_request(void* pRecvMsg, int recvMsgLen, pnf_p7_t* pnf_p7)
+{
+ nfapi_ue_release_request_t* req = allocate_nfapi_ue_release_request(pnf_p7);
+ if(req == NULL)
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s failed to alloced nfapi_ue_release_request structure\n");
+ return;
+ }
+
+ int unpack_result = nfapi_p7_message_unpack(pRecvMsg, recvMsgLen, req, sizeof(nfapi_ue_release_request_t), &pnf_p7->_public.codec_config);
+ if(unpack_result == 0)
+ {
+ if(pthread_mutex_lock(&(pnf_p7->mutex)) != 0)
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "failed to lock mutex\n");
+ return;
+ }
+
+ if(is_p7_request_in_window(req->sfn_sf, "ue_release_request", pnf_p7))
+ {
+ uint32_t sfn_sf_dec = NFAPI_SFNSF2DEC(req->sfn_sf);
+ uint8_t buffer_index = sfn_sf_dec % pnf_p7->_public.subframe_buffer_size;
+
+ struct timespec t;
+ clock_gettime(CLOCK_MONOTONIC, &t);
+
+ NFAPI_TRACE(NFAPI_TRACE_INFO,"%s() %ld.%09ld POPULATE UE_RELEASE_REQ sfn_sf:%d buffer_index:%d\n", __FUNCTION__, t.tv_sec, t.tv_nsec, sfn_sf_dec, buffer_index);
+
+ if (0 && NFAPI_SFNSF2DEC(req->sfn_sf)%100==0) NFAPI_TRACE(NFAPI_TRACE_INFO, "%s() UE_RELEASE_REQ.req sfn_sf:%d rntis:%d - UE_RELEASE_REQ is within window\n",
+ __FUNCTION__,
+ NFAPI_SFNSF2DEC(req->sfn_sf),
+ req->ue_release_request_body.number_of_TLVs);
+
+ if(pnf_p7->subframe_buffer[buffer_index].ue_release_req != 0)
+ {
+ deallocate_nfapi_ue_release_request(pnf_p7->subframe_buffer[buffer_index].ue_release_req, pnf_p7);
+ }
+
+ pnf_p7->subframe_buffer[buffer_index].sfn_sf = req->sfn_sf;
+ pnf_p7->subframe_buffer[buffer_index].ue_release_req = req;
+
+ pnf_p7->stats.tx_ontime++;
+ }
+ else
+ {
+ NFAPI_TRACE(NFAPI_TRACE_INFO,"%s() UE_RELEASE_REQUEST Request is outside of window REQ:SFN_SF:%d CURR:SFN_SF:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(req->sfn_sf), NFAPI_SFNSF2DEC(pnf_p7->sfn_sf));
+
+ deallocate_nfapi_ue_release_request(req, pnf_p7);
+ if(pnf_p7->_public.timing_info_mode_aperiodic)
+ {
+ pnf_p7->timing_info_aperiodic_send = 1;
+ }
+
+ pnf_p7->stats.tx_late++;
+ }
+ nfapi_ue_release_response_t resp;
+ memset(&resp, 0, sizeof(resp));
+ resp.header.message_id = NFAPI_UE_RELEASE_RESPONSE;
+ resp.header.phy_id = req->header.phy_id;
+ resp.error_code = NFAPI_MSG_OK;
+ nfapi_pnf_ue_release_resp(&(pnf_p7->_public), &resp);
+ NFAPI_TRACE(NFAPI_TRACE_INFO, "do ue_release_response\n");
+
+ if(pthread_mutex_unlock(&(pnf_p7->mutex)) != 0)
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "failed to unlock mutex\n");
+ return;
+ }
+ }
+ else
+ {
+ deallocate_nfapi_ue_release_request(req, pnf_p7);
+ }
+}
uint32_t calculate_t2(uint32_t now_time_hr, uint16_t sfn_sf, uint32_t sf_start_time_hr)
{
@@ -1445,7 +1548,11 @@ void pnf_dispatch_p7_message(void *pRecvMsg, int recvMsgLen, pnf_p7_t* pnf_p7,
case NFAPI_LBT_DL_CONFIG_REQUEST:
pnf_handle_lbt_dl_config_request(pRecvMsg, recvMsgLen, pnf_p7);
break;
-
+
+ case NFAPI_UE_RELEASE_REQUEST:
+ pnf_handle_ue_release_request(pRecvMsg, recvMsgLen, pnf_p7);
+ break;
+
default:
{
if(header.message_id >= NFAPI_VENDOR_EXT_MSG_MIN &&
@@ -1536,7 +1643,7 @@ void pnf_handle_p7_message(void *pRecvMsg, int recvMsgLen, pnf_p7_t* pnf_p7, ui
NFAPI_TRACE(NFAPI_TRACE_NOTE, "Failed to allocate PNF_P7 reassemby buffer len:%d\n", length);
return;
}
-
+ memset(pnf_p7->reassemby_buffer, 0, length);
pnf_p7->reassemby_buffer_size = length;
}
diff --git a/nfapi/open-nFAPI/pnf/src/pnf_p7_interface.c b/nfapi/open-nFAPI/pnf/src/pnf_p7_interface.c
index 74de5e5d785e5d251dfcc65133fd2154219b7641..24e73ae9b3c6fb54efd362b6ed855a941b6cb932 100644
--- a/nfapi/open-nFAPI/pnf/src/pnf_p7_interface.c
+++ b/nfapi/open-nFAPI/pnf/src/pnf_p7_interface.c
@@ -223,3 +223,15 @@ int nfapi_pnf_p7_vendor_extension(nfapi_pnf_p7_config_t* config, nfapi_p7_messag
return pnf_p7_pack_and_send_p7_message(_this, msg, 0);
}
+int nfapi_pnf_ue_release_resp(nfapi_pnf_p7_config_t* config, nfapi_ue_release_response_t* resp)
+{
+ if (config == NULL || resp == NULL)
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s: NULL parameters\n", __FUNCTION__);
+ return -1;
+ }
+
+ pnf_p7_t* _this = (pnf_p7_t*)(config);
+
+ return pnf_p7_pack_and_send_p7_message(_this, &(resp->header), sizeof(nfapi_ue_release_response_t));
+}
diff --git a/nfapi/open-nFAPI/vnf/public_inc/nfapi_vnf_interface.h b/nfapi/open-nFAPI/vnf/public_inc/nfapi_vnf_interface.h
index 462901391a8cd63bfc9b25a239f8600870fdad52..ed8f6ba9688939bf953fc0f52729ba7877a86659 100644
--- a/nfapi/open-nFAPI/vnf/public_inc/nfapi_vnf_interface.h
+++ b/nfapi/open-nFAPI/vnf/public_inc/nfapi_vnf_interface.h
@@ -988,6 +988,15 @@ int nfapi_vnf_p7_lbt_dl_config_req(nfapi_vnf_p7_config_t* config, nfapi_lbt_dl_c
*/
int nfapi_vnf_p7_vendor_extension(nfapi_vnf_p7_config_t* config, nfapi_p7_message_header_t* msg);
+/*! Send the RELEASE_RNTI.request
+ * \param config A pointer to the vnf p7 configuration
+ * \param req A data structure for the decoded RELEASE_RNTI.request.
+ * \return A status value. 0 equal success, -1 indicates failure
+ *
+ * The caller is responsiable for memory management of any pointers set in the req, which
+ * may be released after this function call has returned or at a later pointer
+ */
+int nfapi_vnf_p7_ue_release_req(nfapi_vnf_p7_config_t* config, nfapi_ue_release_request_t* req);
#if defined(__cplusplus)
}
#endif
diff --git a/nfapi/open-nFAPI/vnf/src/vnf_p7.c b/nfapi/open-nFAPI/vnf/src/vnf_p7.c
index 4b7acabec3637af74e3d95f8d9d805ea3337b118..985a6f830a6835db67f38ff587c6e0d86f5a99b4 100644
--- a/nfapi/open-nFAPI/vnf/src/vnf_p7.c
+++ b/nfapi/open-nFAPI/vnf/src/vnf_p7.c
@@ -822,6 +822,28 @@ void vnf_handle_nrach_indication(void *pRecvMsg, int recvMsgLen, vnf_p7_t* vnf_p
}
}
+void vnf_handle_ue_release_resp(void *pRecvMsg, int recvMsgLen, vnf_p7_t* vnf_p7)
+{
+
+ // ensure it's valid
+ if (pRecvMsg == NULL || vnf_p7 == NULL)
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s: NULL parameters\n", __FUNCTION__);
+ }
+ else
+ {
+ nfapi_ue_release_response_t resp;
+
+ if(nfapi_p7_message_unpack(pRecvMsg, recvMsgLen, &resp, sizeof(resp), &vnf_p7->_public.codec_config) < 0)
+ {
+ NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s: Failed to unpack message\n", __FUNCTION__);
+ }
+
+
+ vnf_p7_codec_free(vnf_p7, resp.vendor_extension);
+ }
+}
+
void vnf_handle_p7_vendor_extension(void *pRecvMsg, int recvMsgLen, vnf_p7_t* vnf_p7, uint16_t message_id)
{
if (pRecvMsg == NULL || vnf_p7 == NULL)
@@ -1334,6 +1356,10 @@ void vnf_dispatch_p7_message(void *pRecvMsg, int recvMsgLen, vnf_p7_t* vnf_p7)
vnf_handle_nrach_indication(pRecvMsg, recvMsgLen, vnf_p7);
break;
+ case NFAPI_UE_RELEASE_RESPONSE:
+ vnf_handle_ue_release_resp(pRecvMsg, recvMsgLen, vnf_p7);
+ break;
+
default:
{
if(header.message_id >= NFAPI_VENDOR_EXT_MSG_MIN &&
@@ -1430,7 +1456,7 @@ void vnf_handle_p7_message(void *pRecvMsg, int recvMsgLen, vnf_p7_t* vnf_p7)
NFAPI_TRACE(NFAPI_TRACE_NOTE, "Failed to allocate VNF_P7 reassemby buffer len:%d\n", length);
return;
}
-
+ memset(phy->reassembly_buffer, 0, length);
phy->reassembly_buffer_size = length;
}
diff --git a/nfapi/open-nFAPI/vnf/src/vnf_p7_interface.c b/nfapi/open-nFAPI/vnf/src/vnf_p7_interface.c
index 4a85f7e4b3b9b245f5f5660e6c1a3a0dc8ce80eb..0444dca71d0f7d2d5973a123458be8b22df60a20 100644
--- a/nfapi/open-nFAPI/vnf/src/vnf_p7_interface.c
+++ b/nfapi/open-nFAPI/vnf/src/vnf_p7_interface.c
@@ -523,6 +523,14 @@ int nfapi_vnf_p7_vendor_extension(nfapi_vnf_p7_config_t* config, nfapi_p7_messag
return vnf_p7_pack_and_send_p7_msg(vnf_p7, header);
}
+int nfapi_vnf_p7_ue_release_req(nfapi_vnf_p7_config_t* config, nfapi_ue_release_request_t* req)
+{
+ if(config == 0 || req == 0)
+ return -1;
+
+ vnf_p7_t* vnf_p7 = (vnf_p7_t*)config;
+ return vnf_p7_pack_and_send_p7_msg(vnf_p7, &req->header);
+}
int nfapi_vnf_p7_release_msg(nfapi_vnf_p7_config_t* config, nfapi_p7_message_header_t* header)
{
diff --git a/openair1/PHY/INIT/lte_init.c b/openair1/PHY/INIT/lte_init.c
index fad4311714bfdb11bd2703e409c4c4629118dc77..61a58c1b1932aff02e5d0fe4d7ba9ad79adfe340 100644
--- a/openair1/PHY/INIT/lte_init.c
+++ b/openair1/PHY/INIT/lte_init.c
@@ -34,6 +34,7 @@
#include "common/utils/LOG/vcd_signal_dumper.h"
#include "assertions.h"
#include <math.h>
+#include "nfapi/oai_integration/vendor_ext.h"
extern uint32_t from_earfcn(int eutra_bandP,uint32_t dl_earfcn);
extern int32_t get_uldl_offset(int eutra_bandP);
@@ -408,6 +409,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
+ if (NFAPI_MODE!=NFAPI_MODE_VNF){
common_vars->rxdata = (int32_t **)NULL;
common_vars->txdataF = (int32_t **)malloc16(NB_ANTENNA_PORTS_ENB*sizeof(int32_t*));
common_vars->rxdataF = (int32_t **)malloc16(64*sizeof(int32_t*));
@@ -511,6 +513,7 @@ int phy_init_lte_eNB(PHY_VARS_eNB *eNB,
for (UE_id = 0; UE_id < NUMBER_OF_UE_MAX; UE_id++)
eNB->UE_stats_ptr[UE_id] = &eNB->UE_stats[UE_id];
+ }
eNB->pdsch_config_dedicated->p_a = dB0; //defaul value until overwritten by RRCConnectionReconfiguration
diff --git a/openair1/PHY/LTE_TRANSPORT/dci.h b/openair1/PHY/LTE_TRANSPORT/dci.h
index c5654aa7428203ca04b4c709eaedae3612adf84d..cd76f209197f3854948cb14854fb7985a56fef9b 100644
--- a/openair1/PHY/LTE_TRANSPORT/dci.h
+++ b/openair1/PHY/LTE_TRANSPORT/dci.h
@@ -38,7 +38,7 @@
#define CCEBITS 72
#define CCEPERSYMBOL 33 // This is for 1200 RE
#define CCEPERSYMBOL0 22 // This is for 1200 RE
-#define DCI_BITS_MAX ((2*CCEPERSYMBOL+CCEPERSYMBOL0)*CCEBITS)
+#define DCI_BITS_MAX ((2*CCEPERSYMBOL+CCEPERSYMBOL0)*CCEBITS + 64)
//#define Mquad (Msymb/4)
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c b/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c
index b14b9af8327fc42045cc3c1210863ec958fcc492..327b0cf57cd4223094a9ffea3ffbd9ace07d4d3d 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_coding.c
@@ -568,7 +568,12 @@ int dlsch_encoding_all(PHY_VARS_eNB *eNB,
time_stats_t *i_stats) {
int encoding_return = 0;
unsigned int L,C,B;
- B = dlsch->harq_processes[dlsch->harq_ids[frame%2][subframe]]->B;
+ uint8_t harq_pid = dlsch->harq_ids[frame%2][subframe];
+ if(harq_pid >= dlsch->Mdlharq) {
+ LOG_E(PHY,"dlsch_encoding_all illegal harq_pid %d\n", harq_pid);
+ return(-1);
+ }
+ B = dlsch->harq_processes[harq_pid]->B;
LOG_D(PHY,"B %d, harq_pid %d\n",B,dlsch->harq_ids[frame%2][subframe]);
diff --git a/openair1/PHY/LTE_TRANSPORT/transport_eNB.h b/openair1/PHY/LTE_TRANSPORT/transport_eNB.h
index 6c1f6747886ad9225482c5764c42a317147a01b6..9e8685732f9ce36cd4ca515c673251a77ac9b786 100644
--- a/openair1/PHY/LTE_TRANSPORT/transport_eNB.h
+++ b/openair1/PHY/LTE_TRANSPORT/transport_eNB.h
@@ -329,6 +329,8 @@ typedef struct {
uint8_t subframe;
/// corresponding UE RNTI
uint16_t rnti;
+ /// UE ID from Layer2
+ uint16_t ue_id;
/// Type (SR, HARQ, CQI, HARQ_SR, HARQ_CQI, SR_CQI, HARQ_SR_CQI)
UCI_type_t type;
/// SRS active flag
diff --git a/openair1/PHY/LTE_TRANSPORT/uci_tools.c b/openair1/PHY/LTE_TRANSPORT/uci_tools.c
index 88c652133b783bb627f708985c08c0d4004ca707..c301c8510f03f4ab7d22b50496cdf507435336de 100644
--- a/openair1/PHY/LTE_TRANSPORT/uci_tools.c
+++ b/openair1/PHY/LTE_TRANSPORT/uci_tools.c
@@ -41,7 +41,7 @@ int16_t find_uci(uint16_t rnti, int frame, int subframe, PHY_VARS_eNB *eNB,find_
uint16_t i;
int16_t first_free_index=-1;
AssertFatal(eNB!=NULL,"eNB is null\n");
- for (i=0; i<NUMBER_OF_UE_MAX; i++) {
+ for (i=0; i<NUMBER_OF_UCI_VARS_MAX; i++) {
if ((eNB->uci_vars[i].active >0) &&
(eNB->uci_vars[i].rnti==rnti) &&
(eNB->uci_vars[i].frame==frame) &&
diff --git a/openair1/PHY/defs_eNB.h b/openair1/PHY/defs_eNB.h
index e5ed607ea2f338582624fc9c3ac260ec8b5ee886..6036928a9078fb400c0720c31b285d30b8d490d5 100644
--- a/openair1/PHY/defs_eNB.h
+++ b/openair1/PHY/defs_eNB.h
@@ -1051,7 +1051,7 @@ typedef struct PHY_VARS_eNB_s {
LTE_eNB_PRACH prach_vars_br;
#endif
LTE_eNB_COMMON common_vars;
- LTE_eNB_UCI uci_vars[NUMBER_OF_UE_MAX];
+ LTE_eNB_UCI uci_vars[NUMBER_OF_UCI_VARS_MAX];
LTE_eNB_SRS srs_vars[NUMBER_OF_UE_MAX];
LTE_eNB_PBCH pbch;
LTE_eNB_PUSCH *pusch_vars[NUMBER_OF_UE_MAX];
diff --git a/openair1/PHY/phy_vars.h b/openair1/PHY/phy_vars.h
index ea7d2e5033f2d87504b1dbac7aa497e5f9d85542..272ca0a9ff73928c141d565fc0d3256bb3882e08 100644
--- a/openair1/PHY/phy_vars.h
+++ b/openair1/PHY/phy_vars.h
@@ -45,6 +45,7 @@ int16_t *primary_synch2_time;
#ifndef OCP_FRAMEWORK
PHY_VARS_UE ***PHY_vars_UE_g;
RAN_CONTEXT_t RC;
+UL_RCC_IND_t UL_RCC_INFO;
//PHY_VARS_eNB ***PHY_vars_eNB_g;
//PHY_VARS_RN **PHY_vars_RN_g;
diff --git a/openair1/SCHED/fapi_l1.c b/openair1/SCHED/fapi_l1.c
index 046a44bd4bf7d1bad9fd0cdb4fce1d5af7d19f7f..5f8b4ec3db810495192e35e18b601322fa92db17 100644
--- a/openair1/SCHED/fapi_l1.c
+++ b/openair1/SCHED/fapi_l1.c
@@ -42,7 +42,7 @@ int oai_nfapi_tx_req(nfapi_tx_request_t *tx_req);
int oai_nfapi_hi_dci0_req(nfapi_hi_dci0_request_t *hi_dci0_req);
int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req);
-
+int oai_nfapi_ue_release_req(nfapi_ue_release_request_t *release_req);
void handle_nfapi_dci_dl_pdu(PHY_VARS_eNB *eNB,
int frame, int subframe,
L1_rxtx_proc_t *proc,
@@ -578,6 +578,7 @@ void handle_uci_sr_pdu(PHY_VARS_eNB *eNB,
uci->frame = frame;
uci->subframe = subframe;
uci->rnti = ul_config_pdu->uci_sr_pdu.ue_information.ue_information_rel8.rnti;
+ uci->ue_id = find_dlsch(ul_config_pdu->uci_sr_pdu.ue_information.ue_information_rel8.rnti,eNB,SEARCH_EXIST_OR_FREE);
uci->type = SR;
uci->pucch_fmt = pucch_format1;
uci->num_antenna_ports = 1;
@@ -605,6 +606,7 @@ void handle_uci_sr_harq_pdu(PHY_VARS_eNB *eNB,int UE_id,nfapi_ul_config_request_
uci->frame = frame;
uci->subframe = subframe;
uci->rnti = ul_config_pdu->uci_sr_harq_pdu.ue_information.ue_information_rel8.rnti;
+ uci->ue_id = find_dlsch(ul_config_pdu->uci_sr_harq_pdu.ue_information.ue_information_rel8.rnti,eNB,SEARCH_EXIST_OR_FREE);
uci->type = HARQ_SR;
uci->num_antenna_ports = 1;
uci->num_pucch_resources = 1;
@@ -628,6 +630,7 @@ void handle_uci_harq_pdu(PHY_VARS_eNB *eNB,int UE_id,nfapi_ul_config_request_pdu
uci->frame = frame;
uci->subframe = subframe;
uci->rnti = ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel8.rnti;
+ uci->ue_id = find_dlsch(ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel8.rnti,eNB,SEARCH_EXIST_OR_FREE);
uci->type = HARQ;
uci->srs_active = srs_active;
uci->num_antenna_ports = ul_config_pdu->uci_harq_pdu.harq_information.harq_information_rel11.num_ant_ports;
@@ -799,7 +802,7 @@ void schedule_response(Sched_Rsp_t *Sched_INFO) {
harq_pid = subframe2harq_pid(fp,ul_frame,ul_subframe);
// clear DCI allocation maps for new subframe
-
+ if (NFAPI_MODE!=NFAPI_MODE_VNF)
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
if (eNB->ulsch[i]) {
ulsch_harq = eNB->ulsch[i]->harq_processes[harq_pid];
@@ -815,7 +818,8 @@ void schedule_response(Sched_Rsp_t *Sched_INFO) {
//LOG_D(PHY,"NFAPI: dl_pdu %d : type %d\n",i,dl_config_pdu->pdu_type);
switch (dl_config_pdu->pdu_type) {
case NFAPI_DL_CONFIG_DCI_DL_PDU_TYPE:
- handle_nfapi_dci_dl_pdu(eNB,NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),proc,dl_config_pdu);
+ if (NFAPI_MODE!=NFAPI_MODE_VNF)
+ handle_nfapi_dci_dl_pdu(eNB,NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),proc,dl_config_pdu);
eNB->pdcch_vars[NFAPI_SFNSF2SF(DL_req->sfn_sf)&1].num_dci++;
//LOG_E(PHY,"Incremented num_dci:%d but already set??? dl_config:num_dci:%d\n", eNB->pdcch_vars[subframe&1].num_dci, number_dci);
do_oai=1;
@@ -830,7 +834,8 @@ void schedule_response(Sched_Rsp_t *Sched_INFO) {
do_oai=1;
//LOG_D(PHY,"%s() NFAPI_DL_CONFIG_BCH_PDU_TYPE TX:%d/%d RX:%d/%d TXREQ:%d/%d\n",
//__FUNCTION__, proc->frame_tx, proc->subframe_tx, proc->frame_rx, proc->subframe_rx, NFAPI_SFNSF2SFN(TX_req->sfn_sf), NFAPI_SFNSF2SF(TX_req->sfn_sf));
- handle_nfapi_bch_pdu(eNB,proc,dl_config_pdu,
+ if (NFAPI_MODE!=NFAPI_MODE_VNF)
+ handle_nfapi_bch_pdu(eNB,proc,dl_config_pdu,
TX_req->tx_request_body.tx_pdu_list[dl_config_pdu->bch_pdu.bch_pdu_rel8.pdu_index].segments[0].segment_data);
break;
@@ -862,7 +867,8 @@ void schedule_response(Sched_Rsp_t *Sched_INFO) {
dlsch_pdu_rel8->transport_blocks);
if (1) { //sdu != NULL)
- handle_nfapi_dlsch_pdu(eNB,NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),proc,dl_config_pdu, dlsch_pdu_rel8->transport_blocks-1, sdu);
+ if (NFAPI_MODE!=NFAPI_MODE_VNF)
+ handle_nfapi_dlsch_pdu(eNB,NFAPI_SFNSF2SFN(DL_req->sfn_sf),NFAPI_SFNSF2SF(DL_req->sfn_sf),proc,dl_config_pdu, dlsch_pdu_rel8->transport_blocks-1, sdu);
} else {
dont_send=1;
LOG_E(MAC,"%s() NFAPI_DL_CONFIG_DLSCH_PDU_TYPE sdu is NULL DL_CFG:SFN/SF:%d:pdu_index:%d TX_REQ:SFN/SF:%d:pdus:%d\n", __FUNCTION__, NFAPI_SFNSF2DEC(DL_req->sfn_sf), pdu_index,
@@ -903,7 +909,8 @@ void schedule_response(Sched_Rsp_t *Sched_INFO) {
#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
case NFAPI_DL_CONFIG_MPDCCH_PDU_TYPE:
- handle_nfapi_mpdcch_pdu(eNB,proc,dl_config_pdu);
+ if (NFAPI_MODE!=NFAPI_MODE_VNF)
+ handle_nfapi_mpdcch_pdu(eNB,proc,dl_config_pdu);
eNB->mpdcch_vars[subframe&1].num_dci++;
break;
#endif
@@ -911,16 +918,24 @@ void schedule_response(Sched_Rsp_t *Sched_INFO) {
}
if ((NFAPI_MODE!=NFAPI_MONOLITHIC) && do_oai && !dont_send) {
- oai_nfapi_tx_req(Sched_INFO->TX_req);
+ if(Sched_INFO->TX_req->tx_request_body.number_of_pdus > 0){
+ Sched_INFO->TX_req->sfn_sf = frame << 4 | subframe;
+ oai_nfapi_tx_req(Sched_INFO->TX_req);
+ }
+ Sched_INFO->DL_req->sfn_sf = frame << 4 | subframe;
oai_nfapi_dl_config_req(Sched_INFO->DL_req); // DJP - .dl_config_request_body.dl_config_pdu_list[0]); // DJP - FIXME TODO - yuk - only copes with 1 pdu
+ Sched_INFO->UE_release_req->sfn_sf = frame << 4 | subframe;
+ oai_nfapi_ue_release_req(Sched_INFO->UE_release_req);
}
if ((NFAPI_MODE!=NFAPI_MONOLITHIC) && number_hi_dci0_pdu!=0) {
+ HI_DCI0_req->sfn_sf = frame << 4 | subframe;
oai_nfapi_hi_dci0_req(HI_DCI0_req);
eNB->pdcch_vars[NFAPI_SFNSF2SF(HI_DCI0_req->sfn_sf)&1].num_dci=0;
eNB->pdcch_vars[NFAPI_SFNSF2SF(HI_DCI0_req->sfn_sf)&1].num_pdcch_symbols=0;
}
+if (NFAPI_MODE!=NFAPI_MODE_VNF)
for (i=0; i<number_hi_dci0_pdu; i++) {
hi_dci0_req_pdu = &HI_DCI0_req->hi_dci0_request_body.hi_dci0_pdu_list[i];
LOG_D(PHY,"NFAPI: hi_dci0_pdu %d : type %d\n",i,hi_dci0_req_pdu->pdu_type);
@@ -945,6 +960,7 @@ void schedule_response(Sched_Rsp_t *Sched_INFO) {
if (NFAPI_MODE!=NFAPI_MONOLITHIC) {
if (number_ul_pdu>0) {
//LOG_D(PHY, "UL_CONFIG to send to PNF\n");
+ UL_req->sfn_sf = frame << 4 | subframe;
oai_nfapi_ul_config_req(UL_req);
UL_req->ul_config_request_body.number_of_pdus=0;
number_ul_pdu=0;
diff --git a/openair1/SCHED/phy_procedures_lte_eNb.c b/openair1/SCHED/phy_procedures_lte_eNb.c
index 64940c8ed0ef95ab8fae1d8dea2154d29557e644..f5a724e39c8e7bc5621f457ac0c116332140d958 100644
--- a/openair1/SCHED/phy_procedures_lte_eNb.c
+++ b/openair1/SCHED/phy_procedures_lte_eNb.c
@@ -47,8 +47,7 @@
#include "intertask_interface.h"
-
-
+nfapi_ue_release_request_body_t release_rntis;
int16_t get_hundred_times_delta_IF_eNB(PHY_VARS_eNB *eNB,uint16_t UE_id,uint8_t harq_pid, uint8_t bw_factor) {
uint32_t Nre,sumKr,MPR_x100,Kr,r;
@@ -459,6 +458,11 @@ void phy_procedures_eNB_TX(PHY_VARS_eNB *eNB,
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME(VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO,num_pdcch_symbols);
VCD_SIGNAL_DUMPER_DUMP_VARIABLE_BY_NAME (VCD_SIGNAL_DUMPER_VARIABLES_DCI_INFO, (frame * 10) + subframe);
+ if (num_pdcch_symbols == 0){
+ LOG_E(PHY,"[eNB %"PRIu8"] Frame %d, subframe %d: Calling generate_dci_top (pdcch) (num_dci %"PRIu8") num_pdcch_symbols:%d\n",eNB->Mod_id,frame, subframe, num_dci, num_pdcch_symbols);
+ return;
+ }
+
if (num_dci > 0)
LOG_D(PHY,"[eNB %"PRIu8"] Frame %d, subframe %d: Calling generate_dci_top (pdcch) (num_dci %"PRIu8") num_pdcch_symbols:%d\n",eNB->Mod_id,frame, subframe, num_dci, num_pdcch_symbols);
@@ -630,7 +634,7 @@ uci_procedures(PHY_VARS_eNB *eNB,
LTE_eNB_UCI *uci = NULL;
LTE_DL_FRAME_PARMS *fp = &(eNB->frame_parms);
- for (int i = 0; i < NUMBER_OF_UE_MAX; i++) {
+ for (int i = 0; i < NUMBER_OF_UCI_VARS_MAX; i++) {
uci = &(eNB->uci_vars[i]);
if ((uci->active == 1) && (uci->frame == frame) && (uci->subframe == subframe)) {
@@ -678,7 +682,7 @@ uci_procedures(PHY_VARS_eNB *eNB,
int pucch1_thres = (uci->ue_type == 0) ? eNB->pucch1_DTX_threshold : eNB->pucch1_DTX_threshold_emtc[0];
metric_SR = rx_pucch(eNB,
uci->pucch_fmt,
- i,
+ uci->ue_id,
uci->n_pucch_1_0_sr[0],
0, // n2_pucch
uci->srs_active, // shortened format
@@ -720,7 +724,7 @@ uci_procedures(PHY_VARS_eNB *eNB,
SR_payload);
metric[0] = rx_pucch(eNB,
uci->pucch_fmt,
- i,
+ uci->ue_id,
uci->n_pucch_1[0][0],
0, //n2_pucch
uci->srs_active, // shortened format
@@ -744,7 +748,7 @@ uci_procedures(PHY_VARS_eNB *eNB,
SR_payload = 1;
metric[0]=rx_pucch(eNB,
uci->pucch_fmt,
- i,
+ uci->ue_id,
uci->n_pucch_1_0_sr[0],
0, //n2_pucch
uci->srs_active, // shortened format
@@ -774,7 +778,7 @@ uci_procedures(PHY_VARS_eNB *eNB,
#if 1
metric[0] = rx_pucch(eNB,
uci->pucch_fmt,
- i,
+ uci->ue_id,
uci->n_pucch_1[0][0],
0, //n2_pucch
uci->srs_active, // shortened format
@@ -794,7 +798,7 @@ uci_procedures(PHY_VARS_eNB *eNB,
SR_payload = 1;
metric[0] = rx_pucch(eNB,
pucch_format1b,
- i,
+ uci->ue_id,
uci->n_pucch_1_0_sr[0],
0, //n2_pucch
uci->srs_active, // shortened format
@@ -1132,11 +1136,11 @@ uci_procedures(PHY_VARS_eNB *eNB,
if (SR_payload == 1) {
LOG_D (PHY, "[eNB %d][SR %x] Frame %d subframe %d Got SR for PUSCH, transmitting to MAC\n", eNB->Mod_id, uci->rnti, frame, subframe);
- if (eNB->first_sr[i] == 1) { // this is the first request for uplink after Connection Setup, so clear HARQ process 0 use for Msg4
- eNB->first_sr[i] = 0;
- eNB->dlsch[i][0]->harq_processes[0]->round = 0;
- eNB->dlsch[i][0]->harq_processes[0]->status = SCH_IDLE;
- LOG_D (PHY, "[eNB %d][SR %x] Frame %d subframe %d First SR\n", eNB->Mod_id, eNB->ulsch[i]->rnti, frame, subframe);
+ if (eNB->first_sr[uci->ue_id] == 1) { // this is the first request for uplink after Connection Setup, so clear HARQ process 0 use for Msg4
+ eNB->first_sr[uci->ue_id] = 0;
+ eNB->dlsch[uci->ue_id][0]->harq_processes[0]->round = 0;
+ eNB->dlsch[uci->ue_id][0]->harq_processes[0]->status = SCH_IDLE;
+ LOG_D (PHY, "[eNB %d][SR %x] Frame %d subframe %d First SR\n", eNB->Mod_id, eNB->ulsch[uci->ue_id]->rnti, frame, subframe);
}
}
}
@@ -1651,8 +1655,9 @@ int getM(PHY_VARS_eNB *eNB,int frame,int subframe) {
void fill_ulsch_cqi_indication (PHY_VARS_eNB *eNB, uint16_t frame, uint8_t subframe, LTE_UL_eNB_HARQ_t *ulsch_harq, uint16_t rnti) {
pthread_mutex_lock (&eNB->UL_INFO_mutex);
- nfapi_cqi_indication_pdu_t *pdu = &eNB->UL_INFO.cqi_ind.cqi_pdu_list[eNB->UL_INFO.cqi_ind.number_of_cqis];
- nfapi_cqi_indication_raw_pdu_t *raw_pdu = &eNB->UL_INFO.cqi_ind.cqi_raw_pdu_list[eNB->UL_INFO.cqi_ind.number_of_cqis];
+ nfapi_cqi_indication_pdu_t *pdu = &eNB->UL_INFO.cqi_ind.cqi_indication_body.cqi_pdu_list[eNB->UL_INFO.cqi_ind.cqi_indication_body.number_of_cqis];
+ nfapi_cqi_indication_raw_pdu_t *raw_pdu = &eNB->UL_INFO.cqi_ind.cqi_indication_body.cqi_raw_pdu_list[eNB->UL_INFO.cqi_ind.cqi_indication_body.number_of_cqis];
+ pdu->instance_length = 0;
pdu->rx_ue_information.tl.tag = NFAPI_RX_UE_INFORMATION_TAG;
pdu->rx_ue_information.rnti = rnti;
@@ -1678,9 +1683,11 @@ void fill_ulsch_cqi_indication (PHY_VARS_eNB *eNB, uint16_t frame, uint8_t subfr
pdu->cqi_indication_rel9.number_of_cc_reported = 1;
pdu->ul_cqi_information.channel = 1; // PUSCH
+ pdu->ul_cqi_information.tl.tag = NFAPI_UL_CQI_INFORMATION_TAG;
memcpy ((void *) raw_pdu->pdu, ulsch_harq->o, pdu->cqi_indication_rel9.length);
- eNB->UL_INFO.cqi_ind.number_of_cqis++;
- LOG_D(PHY,"eNB->UL_INFO.cqi_ind.number_of_cqis:%d\n", eNB->UL_INFO.cqi_ind.number_of_cqis);
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.tl.tag = NFAPI_CQI_INDICATION_BODY_TAG;
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.number_of_cqis++;
+ LOG_D(PHY,"eNB->UL_INFO.cqi_ind.cqi_indication_body.number_of_cqis:%d\n", eNB->UL_INFO.cqi_ind.cqi_indication_body.number_of_cqis);
pthread_mutex_unlock(&eNB->UL_INFO_mutex);
}
@@ -1997,3 +2004,44 @@ void phy_procedures_eNB_uespec_RX(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc) {
VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME( VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_PROCEDURES_ENB_RX_UESPEC, 0 );
}
+
+void release_rnti_of_phy(module_id_t mod_id){
+ int i,j;
+ int CC_id;
+ rnti_t rnti;
+ PHY_VARS_eNB *eNB_PHY = NULL;
+ LTE_eNB_ULSCH_t *ulsch = NULL;
+ LTE_eNB_DLSCH_t *dlsch = NULL;
+ for(i = 0; i< release_rntis.number_of_TLVs;i++){
+ for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
+ eNB_PHY = RC.eNB[mod_id][CC_id];
+ rnti = release_rntis.ue_release_request_TLVs_list[i].rnti;
+ for (j=0; j<NUMBER_OF_UE_MAX; j++) {
+ ulsch = eNB_PHY->ulsch[j];
+ if((ulsch != NULL) && (ulsch->rnti == rnti)){
+ LOG_I(PHY, "clean_eNb_ulsch ulsch[%d] UE %x\n", j, rnti);
+ clean_eNb_ulsch(ulsch);
+ }
+
+ dlsch = eNB_PHY->dlsch[j][0];
+ if((dlsch != NULL) && (dlsch->rnti == rnti)){
+ LOG_I(PHY, "clean_eNb_dlsch dlsch[%d] UE %x \n", j, rnti);
+ clean_eNb_dlsch(dlsch);
+ }
+ }
+ ulsch = eNB_PHY->ulsch[j];
+ if((ulsch != NULL) && (ulsch->rnti == rnti)){
+ LOG_I(PHY, "clean_eNb_ulsch ulsch[%d] UE %x\n", j, rnti);
+ clean_eNb_ulsch(ulsch);
+ }
+ for(j=0; j<NUMBER_OF_UCI_VARS_MAX; j++) {
+ if(eNB_PHY->uci_vars[j].rnti == rnti){
+ LOG_I(PHY, "clean eNb uci_vars[%d] UE %x \n",j, rnti);
+ memset(&eNB_PHY->uci_vars[i],0,sizeof(LTE_eNB_UCI));
+ }
+
+ }
+ }
+ }
+ memset(&release_rntis, 0, sizeof(nfapi_ue_release_request_body_t));
+}
diff --git a/openair1/SCHED/sched_eNB.h b/openair1/SCHED/sched_eNB.h
index dccfbf7c388ac204771e391eaa1044cffea9e4cd..7fcabdc5ddf8163b063edc655cdca442a0f0617c 100644
--- a/openair1/SCHED/sched_eNB.h
+++ b/openair1/SCHED/sched_eNB.h
@@ -219,6 +219,7 @@ int is_srs_occasion_common(LTE_DL_FRAME_PARMS *frame_parms,int frame_tx,int subf
void compute_srs_pos(lte_frame_type_t frameType,uint16_t isrs,uint16_t *psrsPeriodicity,uint16_t *psrsOffset);
+void release_rnti_of_phy(module_id_t mod_id);
/*@}*/
diff --git a/openair1/SIMULATION/LTE_PHY/dummy_functions.c b/openair1/SIMULATION/LTE_PHY/dummy_functions.c
index 7f5fa1fb75f42609e973948fb4805d122acbdf75..d3c6381d72ff863c25b5c8cee01d71db5af8a16c 100644
--- a/openair1/SIMULATION/LTE_PHY/dummy_functions.c
+++ b/openair1/SIMULATION/LTE_PHY/dummy_functions.c
@@ -91,5 +91,5 @@ int oai_nfapi_hi_dci0_req(nfapi_hi_dci0_request_t *hi_dci0_req) { return(0);}
int oai_nfapi_tx_req(nfapi_tx_request_t *tx_req) { return(0); }
int oai_nfapi_dl_config_req(nfapi_dl_config_request_t *dl_config_req) { return(0); }
-
+int oai_nfapi_ue_release_req(nfapi_ue_release_request_t *release_req){ return(0); }
int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req) { return(0); }
diff --git a/openair1/SIMULATION/LTE_PHY/ulsim.c b/openair1/SIMULATION/LTE_PHY/ulsim.c
index df6781cea24d1dec9dced771a23ead9b958b5629..a90d1995261e13f7d5e71695cd441ba7859ea354 100644
--- a/openair1/SIMULATION/LTE_PHY/ulsim.c
+++ b/openair1/SIMULATION/LTE_PHY/ulsim.c
@@ -618,8 +618,8 @@ int main(int argc, char **argv) {
eNB->UL_INFO.crc_ind.crc_indication_body.crc_pdu_list = eNB->crc_pdu_list;
eNB->UL_INFO.sr_ind.sr_indication_body.sr_pdu_list = eNB->sr_pdu_list;
eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list = eNB->harq_pdu_list;
- eNB->UL_INFO.cqi_ind.cqi_pdu_list = eNB->cqi_pdu_list;
- eNB->UL_INFO.cqi_ind.cqi_raw_pdu_list = eNB->cqi_raw_pdu_list;
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.cqi_pdu_list = eNB->cqi_pdu_list;
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.cqi_raw_pdu_list = eNB->cqi_raw_pdu_list;
printf("lte_param_init done\n");
// for a call to phy_reset_ue later we need PHY_vars_UE_g allocated and pointing to UE
PHY_vars_UE_g = (PHY_VARS_UE ** *)malloc(sizeof(PHY_VARS_UE **));
diff --git a/openair2/ENB_APP/enb_config.c b/openair2/ENB_APP/enb_config.c
index 265eb9aff0007df3f85f1330a563a53b34803033..a957e11bcda914c7af0f860c271bfcce73f9972c 100644
--- a/openair2/ENB_APP/enb_config.c
+++ b/openair2/ENB_APP/enb_config.c
@@ -160,7 +160,7 @@ void RCconfig_L1(void) {
LOG_I(PHY,"%s() NFAPI PNF mode - RC.nb_inst=1 this is because phy_init_RU() uses that to index and not RC.num_eNB - why the 2 similar variables?\n", __FUNCTION__);
LOG_I(PHY,"%s() NFAPI PNF mode - RC.nb_CC[0]=%d for init_eNB_afterRU()\n", __FUNCTION__, RC.nb_CC[0]);
LOG_I(PHY,"%s() NFAPI PNF mode - RC.nb_macrlc_inst:%d because used by mac_top_init_eNB()\n", __FUNCTION__, RC.nb_macrlc_inst);
- //mac_top_init_eNB();
+ mac_top_init_eNB();
configure_nfapi_pnf(RC.eNB[j][0]->eth_params_n.remote_addr, RC.eNB[j][0]->eth_params_n.remote_portc, RC.eNB[j][0]->eth_params_n.my_addr, RC.eNB[j][0]->eth_params_n.my_portd,
RC.eNB[j][0]->eth_params_n .remote_portd);
} else { // other midhaul
diff --git a/openair2/LAYER2/MAC/eNB_scheduler.c b/openair2/LAYER2/MAC/eNB_scheduler.c
index 65d8d2702e646b0d4a05c14a318df76b501bbf66..3a809c4327aa4dc6d13d992db87c8ed2c0453b94 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler.c
@@ -464,6 +464,7 @@ check_ul_failure(module_id_t module_idP, int CC_id, int UE_id,
DL_req[CC_id].dl_config_request_body.number_dci++;
DL_req[CC_id].dl_config_request_body.number_pdu++;
DL_req[CC_id].dl_config_request_body.tl.tag = NFAPI_DL_CONFIG_REQUEST_BODY_TAG;
+ DL_req[CC_id].sfn_sf = frameP<<4 | subframeP;
LOG_D(MAC,
"UE %d rnti %x: sending PDCCH order for RAPROC (failure timer %d), resource_block_coding %d \n",
UE_id, rnti,
diff --git a/openair2/LAYER2/MAC/eNB_scheduler_RA.c b/openair2/LAYER2/MAC/eNB_scheduler_RA.c
index 1e579e4921bb7c4ba6afd228a25c49b9aca82d3d..9a908313ba243247c1b9c770089d3117cc64149e 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler_RA.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler_RA.c
@@ -868,8 +868,10 @@ generate_Msg4(module_id_t module_idP,
ul_config_pdu = &ul_req_body->ul_config_pdu_list[ul_req_body->number_of_pdus];
ul_config_pdu->pdu_type = NFAPI_UL_CONFIG_UCI_HARQ_PDU_TYPE;
ul_config_pdu->pdu_size = (uint8_t) (2 + sizeof (nfapi_ul_config_uci_harq_pdu));
+ ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel8.tl.tag = NFAPI_UL_CONFIG_REQUEST_UE_INFORMATION_REL8_TAG;
ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel8.handle = 0; // don't know how to use this
ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel8.rnti = ra->rnti;
+ ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel13.tl.tag = NFAPI_UL_CONFIG_REQUEST_UE_INFORMATION_REL13_TAG;
ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel13.ue_type = (ra->rach_resource_type < 3) ? 1 : 2;
ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel13.empty_symbols = 0;
ul_config_pdu->uci_harq_pdu.ue_information.ue_information_rel13.total_number_of_repetitions = pucchreps[ra->rach_resource_type - 1];
@@ -1052,7 +1054,7 @@ generate_Msg4(module_id_t module_idP,
mac->TX_req[CC_idP].sfn_sf =
fill_nfapi_tx_req(&mac->TX_req[CC_idP].tx_request_body,
(frameP * 10) + subframeP,
- rrc_sdu_length,
+ rrc_sdu_length+offset,
mac->pdu_index[CC_idP],
mac->UE_list.
DLSCH_pdu[CC_idP][0][(unsigned char)UE_id].payload[0]);
diff --git a/openair2/LAYER2/MAC/eNB_scheduler_bch.c b/openair2/LAYER2/MAC/eNB_scheduler_bch.c
index fb80c9e1d6058a9c50b33c869063c4cb6da40929..d523fb4e17b6f7aa031b6b7849a4a9b51430f756 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler_bch.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler_bch.c
@@ -1158,6 +1158,7 @@ schedule_SI(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP)
LOG_D(MAC, "Frame %d: Subframe %d : Adding common DCI for S_RNTI\n", frameP, subframeP);
dl_req->number_dci++;
dl_req->number_pdu++;
+ dl_req->tl.tag = NFAPI_DL_CONFIG_REQUEST_BODY_TAG;
dl_config_pdu = &dl_req->dl_config_pdu_list[dl_req->number_pdu];
memset((void *) dl_config_pdu, 0,
sizeof(nfapi_dl_config_request_pdu_t));
@@ -1188,6 +1189,7 @@ schedule_SI(module_id_t module_idP, frame_t frameP, sub_frame_t subframeP)
dl_config_pdu->dlsch_pdu.dlsch_pdu_rel8.num_bf_vector = 1;
// dl_config_pdu->dlsch_pdu.dlsch_pdu_rel8.bf_vector = ;
dl_req->number_pdu++;
+ dl_req->tl.tag = NFAPI_DL_CONFIG_REQUEST_BODY_TAG;
// Rel10 fields
dl_config_pdu->dlsch_pdu.dlsch_pdu_rel10.tl.tag = NFAPI_DL_CONFIG_REQUEST_DLSCH_PDU_REL10_TAG;
diff --git a/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c b/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c
index 754ecc45ef0ebe40a17398cd35ed092fa4e17a5a..134089dbf4da98ef21e5d604ff6c67a2bfc2f516 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler_dlsch.c
@@ -736,7 +736,7 @@ schedule_ue_spec(module_id_t module_idP,
eNB_UE_stats->dl_cqi, MIN_CQI_VALUE, MAX_CQI_VALUE);
*/
if (NFAPI_MODE != NFAPI_MONOLITHIC) {
- eNB_UE_stats->dlsch_mcs1 = 10; // cqi_to_mcs[ue_sched_ctrl->dl_cqi[CC_id]];
+ eNB_UE_stats->dlsch_mcs1 = cqi_to_mcs[ue_sched_ctrl->dl_cqi[CC_id]];
} else { // this operation is also done in the preprocessor
eNB_UE_stats->dlsch_mcs1 = cmin(eNB_UE_stats->dlsch_mcs1,
eNB->slice_info.dl[slice_idxP].maxmcs); // cmin(eNB_UE_stats->dlsch_mcs1, openair_daq_vars.target_ue_dl_mcs);
diff --git a/openair2/LAYER2/MAC/eNB_scheduler_fairRR.c b/openair2/LAYER2/MAC/eNB_scheduler_fairRR.c
index ae72d460279898dd6e30cbd5fb86df4bd95285ed..c071c1f505d7aad17b990ff33b0b9a9b0e51e906 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler_fairRR.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler_fairRR.c
@@ -601,6 +601,7 @@ void dlsch_scheduler_pre_processor_fairRR (module_id_t Mod_id,
#endif
memset(rballoc_sub[0],0,(MAX_NUM_CCs)*(N_RBG_MAX)*sizeof(unsigned char));
memset(min_rb_unit,0,sizeof(min_rb_unit));
+ memset(MIMO_mode_indicator[0], 0, MAX_NUM_CCs*N_RBG_MAX*sizeof(unsigned char));
for (CC_id=0; CC_id<MAX_NUM_CCs; CC_id++) {
if (mbsfn_flag[CC_id] > 0) // If this CC is allocated for MBSFN skip it here
@@ -1029,7 +1030,7 @@ schedule_ue_spec_fairRR(module_id_t module_idP,
eNB_UE_stats->dl_cqi, MIN_CQI_VALUE, MAX_CQI_VALUE);
*/
if (NFAPI_MODE != NFAPI_MONOLITHIC) {
- eNB_UE_stats->dlsch_mcs1 = 10;//cqi_to_mcs[ue_sched_ctl->dl_cqi[CC_id]];
+ eNB_UE_stats->dlsch_mcs1 = cqi_to_mcs[ue_sched_ctl->dl_cqi[CC_id]];
} else {
eNB_UE_stats->dlsch_mcs1 = cqi_to_mcs[ue_sched_ctl->dl_cqi[CC_id]];
}
@@ -1781,6 +1782,7 @@ schedule_ue_spec_fairRR(module_id_t module_idP,
dl_config_pdu->pdu_size = (uint8_t)(2+sizeof(nfapi_dl_config_dci_dl_pdu));
dl_config_pdu->dci_dl_pdu.dci_dl_pdu_rel8.dci_format = NFAPI_DL_DCI_FORMAT_1;
dl_config_pdu->dci_dl_pdu.dci_dl_pdu_rel8.aggregation_level = get_aggregation(get_bw_index(module_idP,CC_id),ue_sched_ctl->dl_cqi[CC_id],format1);
+ dl_config_pdu->dci_dl_pdu.dci_dl_pdu_rel8.tl.tag = NFAPI_DL_CONFIG_REQUEST_DCI_DL_PDU_REL8_TAG;
dl_config_pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti = rnti;
dl_config_pdu->dci_dl_pdu.dci_dl_pdu_rel8.rnti_type = 1; // CRNTI : see Table 4-10 from SCF082 - nFAPI specifications
dl_config_pdu->dci_dl_pdu.dci_dl_pdu_rel8.transmission_power = 6000; // equal to RS power
@@ -2420,8 +2422,8 @@ void ulsch_scheduler_pre_processor_fairRR(module_id_t module_idP,
while ( (tbs < bytes_to_schedule) && (rb_table[rb_table_index]<(frame_parms->N_RB_UL-num_pucch_rb-first_rb[CC_id])) &&
((UE_template->phr_info - tx_power) > 0) && (rb_table_index < 32 )) {
rb_table_index++;
- tbs = get_TBS_UL(mcs,rb_table[rb_table_index])<<3;
- tx_power= estimate_ue_tx_power(tbs,rb_table[rb_table_index],0,frame_parms->Ncp,0);
+ tbs = get_TBS_UL(mcs,rb_table[rb_table_index]);
+ tx_power= estimate_ue_tx_power(tbs*8,rb_table[rb_table_index],0,frame_parms->Ncp,0);
}
if ( rb_table[rb_table_index]<3 ) {
@@ -2784,12 +2786,12 @@ void schedule_ulsch_rnti_fairRR(module_id_t module_idP,
if (cc->tdd_Config) {
switch (cc->tdd_Config->subframeAssignment) {
case 1:
- if( subframeP == 1 || subframeP == 6 ) cqi_req=0;
+ if( sched_subframeP == 1 || sched_subframeP == 6 ) cqi_req=0;
break;
case 3:
- if( subframeP == 1 ) cqi_req=0;
+ if( sched_subframeP == 1 ) cqi_req=0;
break;
@@ -2899,6 +2901,7 @@ void schedule_ulsch_rnti_fairRR(module_id_t module_idP,
memset((void *)hi_dci0_pdu,0,sizeof(nfapi_hi_dci0_request_pdu_t));
hi_dci0_pdu->pdu_type = NFAPI_HI_DCI0_DCI_PDU_TYPE;
hi_dci0_pdu->pdu_size = 2+sizeof(nfapi_hi_dci0_dci_pdu);
+ hi_dci0_pdu->dci_pdu.dci_pdu_rel8.tl.tag = NFAPI_HI_DCI0_REQUEST_DCI_PDU_REL8_TAG;
hi_dci0_pdu->dci_pdu.dci_pdu_rel8.dci_format = NFAPI_UL_DCI_FORMAT_0;
hi_dci0_pdu->dci_pdu.dci_pdu_rel8.aggregation_level = aggregation;
hi_dci0_pdu->dci_pdu.dci_pdu_rel8.rnti = rnti;
@@ -3056,6 +3059,7 @@ void schedule_ulsch_rnti_fairRR(module_id_t module_idP,
memset((void *)hi_dci0_pdu,0,sizeof(nfapi_hi_dci0_request_pdu_t));
hi_dci0_pdu->pdu_type = NFAPI_HI_DCI0_DCI_PDU_TYPE;
hi_dci0_pdu->pdu_size = 2+sizeof(nfapi_hi_dci0_dci_pdu);
+ hi_dci0_pdu->dci_pdu.dci_pdu_rel8.tl.tag = NFAPI_HI_DCI0_REQUEST_DCI_PDU_REL8_TAG;
hi_dci0_pdu->dci_pdu.dci_pdu_rel8.dci_format = NFAPI_UL_DCI_FORMAT_0;
hi_dci0_pdu->dci_pdu.dci_pdu_rel8.aggregation_level = aggregation;
hi_dci0_pdu->dci_pdu.dci_pdu_rel8.rnti = rnti;
diff --git a/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c b/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c
index 666948d5172a6dfb686058a3e4c7ffe96226f633..13736b4defef8d335b86f9d8d8fef510ed3abcfa 100644
--- a/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c
+++ b/openair2/LAYER2/MAC/eNB_scheduler_ulsch.c
@@ -475,6 +475,7 @@ rx_sdu(const module_id_t enb_mod_idP,
);
if (ret == 0) {
/* Received a new rnti */
+ if(ret == 0){
ra->state = MSGCRNTI;
LOG_I(MAC, "[eNB %d] Frame %d, Subframe %d CC_id %d : (rnti %x UE_id %d) Received rnti(Msg4)\n",
enb_mod_idP,
@@ -504,7 +505,7 @@ rx_sdu(const module_id_t enb_mod_idP,
UE_template_ptr->ul_SR = 1;
UE_scheduling_control->crnti_reconfigurationcomplete_flag = 1;
} else {
- cancel_ra_proc(enb_mod_idP, CC_idP, frameP,current_rnti);
+ cancel_ra_proc(enb_mod_idP, CC_idP, frameP, current_rnti);
}
// break;
}
diff --git a/openair2/LAYER2/MAC/mac.h b/openair2/LAYER2/MAC/mac.h
index 396dde7b8a3c9ce3b3ce3e6265c753117f5b9797..1760355f6152f12640c1916f84f6d3458032d567 100644
--- a/openair2/LAYER2/MAC/mac.h
+++ b/openair2/LAYER2/MAC/mac.h
@@ -1438,6 +1438,8 @@ typedef struct eNB_MAC_INST_s {
tx_request_pdu[NFAPI_CC_MAX][MAX_NUM_TX_REQUEST_PDU];
/// NFAPI DL PDU structure
nfapi_tx_request_t TX_req[NFAPI_CC_MAX];
+ /// NFAPI UE_release_req structure
+ nfapi_ue_release_request_t UE_release_req;
/// UL handle
uint32_t ul_handle;
UE_list_t UE_list;
diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c
index 2f001bdcfd82eef375e29051555a352289bbbe1f..4d34338ea98097d1229d9ee26e79624ff17a951a 100644
--- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c
+++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_retransmit.c
@@ -806,6 +806,7 @@ mem_block_t * rlc_am_get_pdu_to_retransmit(
rlc_sn_t sn = rlc_pP->vt_a;
rlc_sn_t sn_end = rlc_pP->vt_s;
mem_block_t* pdu_p = NULL;
+ mem_block_t* mb_p = NULL;
rlc_am_tx_data_pdu_management_t* tx_data_pdu_management;
//Assertion(eNB)_PRAN_DesignDocument_annex No.769
if((rlc_pP->retrans_num_pdus <= 0) || (rlc_pP->vt_a == rlc_pP->vt_s))
@@ -884,6 +885,18 @@ mem_block_t * rlc_am_get_pdu_to_retransmit(
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
tx_data_pdu_management->retx_count_next,
sn);
+ mb_p = rlc_pP->tx_data_pdu_buffer[sn % RLC_AM_WINDOW_SIZE].mem_block;
+ if(mb_p != NULL){
+ free_mem_block(mb_p, __func__);
+ tx_data_pdu_management->mem_block = NULL;
+ tx_data_pdu_management->flags.retransmit = 0;
+ tx_data_pdu_management->flags.ack = 1;
+ tx_data_pdu_management->flags.transmitted = 0;
+ rlc_pP->retrans_num_bytes_to_retransmit -= tx_data_pdu_management->retx_payload_size;
+ tx_data_pdu_management->retx_payload_size = 0;
+ tx_data_pdu_management->num_holes = 0;
+ rlc_pP->retrans_num_pdus --;
+ }
}
}
else if (rlc_pP->nb_bytes_requested_by_mac >= 5)
@@ -938,6 +951,18 @@ mem_block_t * rlc_am_get_pdu_to_retransmit(
PROTOCOL_RLC_AM_CTXT_ARGS(ctxt_pP,rlc_pP),
tx_data_pdu_management->retx_count_next,
sn);
+ mb_p = rlc_pP->tx_data_pdu_buffer[sn % RLC_AM_WINDOW_SIZE].mem_block;
+ if(mb_p != NULL){
+ free_mem_block(mb_p, __func__);
+ tx_data_pdu_management->mem_block = NULL;
+ tx_data_pdu_management->flags.retransmit = 0;
+ tx_data_pdu_management->flags.ack = 1;
+ tx_data_pdu_management->flags.transmitted = 0;
+ rlc_pP->retrans_num_bytes_to_retransmit -= tx_data_pdu_management->retx_payload_size;
+ tx_data_pdu_management->retx_payload_size = 0;
+ tx_data_pdu_management->num_holes = 0;
+ rlc_pP->retrans_num_pdus --;
+ }
}
}
diff --git a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c
index 9d69882923d84e02d97cde5047c4cb50f00a85af..4a065539013f323cb16a146cf2dd07b975ff7a6d 100644
--- a/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c
+++ b/openair2/LAYER2/RLC/AM_v9.3.0/rlc_am_rx_list.c
@@ -938,7 +938,7 @@ rlc_am_rx_check_all_byte_segments(
rlc_am_pdu_info_t *pdu_info_p = &((rlc_am_rx_pdu_management_t*)(tb_pP->data))->pdu_info;
mem_block_t *cursor_p = NULL;
mem_block_t *first_cursor_p = NULL;
- rlc_sn_t sn = pdu_info_p->sn;
+ rlc_usn_t sn = pdu_info_p->sn;
sdu_size_t next_waited_so;
sdu_size_t last_end_so;
@@ -969,6 +969,9 @@ rlc_am_rx_check_all_byte_segments(
// the so field of the first PDU should be 0
//cursor_p = list.head;
//we start from the first stored PDU segment of this SN
+ if(cursor_p->data == NULL){
+ return;
+ }
pdu_info_p = &((rlc_am_rx_pdu_management_t*)(cursor_p->data))->pdu_info;
// if the first segment does not have SO = 0 then no need to continue
@@ -985,6 +988,9 @@ rlc_am_rx_check_all_byte_segments(
while (cursor_p->next != NULL) {
//msg("rlc_am_rx_check_all_byte_segments(%d) @4\n",sn);
cursor_p = cursor_p->next;
+ if(cursor_p->data == NULL){
+ return;
+ }
pdu_info_p = &((rlc_am_rx_pdu_management_t*)(cursor_p->data))->pdu_info;
if (pdu_info_p->sn == sn) {
diff --git a/openair2/PHY_INTERFACE/IF_Module.c b/openair2/PHY_INTERFACE/IF_Module.c
index ad49a16cec2e52534bd4e8a1f318924c8b50878b..2cc43189c696134b92bf82d14c53411516c35f13 100644
--- a/openair2/PHY_INTERFACE/IF_Module.c
+++ b/openair2/PHY_INTERFACE/IF_Module.c
@@ -17,10 +17,34 @@ extern int oai_nfapi_sr_indication(nfapi_sr_indication_t *ind);
extern int oai_nfapi_rx_ind(nfapi_rx_indication_t *ind);
extern uint16_t sf_ahead;
+extern UL_RCC_IND_t UL_RCC_INFO;
+
uint16_t frame_cnt=0;
void handle_rach(UL_IND_t *UL_info) {
int i;
-
+ if(NFAPI_MODE == NFAPI_MODE_VNF){
+ for(uint8_t j = 0;j < NUM_NFPAI_SUBFRAME;j++){
+ if (UL_RCC_INFO.rach_ind[j].rach_indication_body.number_of_preambles>0) {
+
+ AssertFatal(UL_RCC_INFO.rach_ind[j].rach_indication_body.number_of_preambles==1,"More than 1 preamble not supported\n");
+ LOG_D(MAC,"UL_info[Frame %d, Subframe %d] Calling initiate_ra_proc RACH:SFN/SF:%d\n",UL_info->frame,UL_info->subframe, NFAPI_SFNSF2DEC(UL_RCC_INFO.rach_ind[j].sfn_sf));
+ initiate_ra_proc(UL_info->module_id,
+ UL_info->CC_id,
+ NFAPI_SFNSF2SFN(UL_RCC_INFO.rach_ind[j].sfn_sf),
+ NFAPI_SFNSF2SF(UL_RCC_INFO.rach_ind[j].sfn_sf),
+ UL_RCC_INFO.rach_ind[j].rach_indication_body.preamble_list[0].preamble_rel8.preamble,
+ UL_RCC_INFO.rach_ind[j].rach_indication_body.preamble_list[0].preamble_rel8.timing_advance,
+ UL_RCC_INFO.rach_ind[j].rach_indication_body.preamble_list[0].preamble_rel8.rnti
+#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
+ ,0
+#endif
+ );
+ free(UL_RCC_INFO.rach_ind[j].rach_indication_body.preamble_list);
+ UL_RCC_INFO.rach_ind[j].rach_indication_body.number_of_preambles = 0;
+ UL_RCC_INFO.rach_ind[j].header.message_id = 0;
+ }
+ }
+ }else{
if (UL_info->rach_ind.rach_indication_body.number_of_preambles>0) {
AssertFatal(UL_info->rach_ind.rach_indication_body.number_of_preambles==1,"More than 1 preamble not supported\n");
UL_info->rach_ind.rach_indication_body.number_of_preambles=0;
@@ -37,6 +61,7 @@ void handle_rach(UL_IND_t *UL_info) {
#endif
);
}
+ }
#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
@@ -72,6 +97,22 @@ void handle_sr(UL_IND_t *UL_info) {
if (UL_info->sr_ind.sr_indication_body.number_of_srs>0) {
oai_nfapi_sr_indication(&UL_info->sr_ind);
}
+ } else if(NFAPI_MODE == NFAPI_MODE_VNF){
+ for(uint8_t j = 0;j < NUM_NFPAI_SUBFRAME;j++){
+ if(UL_RCC_INFO.sr_ind[j].sr_indication_body.number_of_srs > 0){
+ for (i=0;i<UL_RCC_INFO.sr_ind[j].sr_indication_body.number_of_srs;i++){
+ SR_indication(UL_info->module_id,
+ UL_info->CC_id,
+ NFAPI_SFNSF2SFN(UL_RCC_INFO.sr_ind[j].sfn_sf),
+ NFAPI_SFNSF2SF(UL_RCC_INFO.sr_ind[j].sfn_sf),
+ UL_RCC_INFO.sr_ind[j].sr_indication_body.sr_pdu_list[i].rx_ue_information.rnti,
+ UL_RCC_INFO.sr_ind[j].sr_indication_body.sr_pdu_list[i].ul_cqi_information.ul_cqi);
+ }
+ free(UL_RCC_INFO.sr_ind[j].sr_indication_body.sr_pdu_list);
+ UL_RCC_INFO.sr_ind[j].sr_indication_body.number_of_srs=0;
+ UL_RCC_INFO.sr_ind[j].header.message_id = 0;
+ }
+ }
} else {
for (i=0; i<UL_info->sr_ind.sr_indication_body.number_of_srs; i++)
SR_indication(UL_info->module_id,
@@ -89,27 +130,46 @@ void handle_cqi(UL_IND_t *UL_info) {
int i;
if (NFAPI_MODE==NFAPI_MODE_PNF) {
- if (UL_info->cqi_ind.number_of_cqis>0) {
- LOG_D(PHY,"UL_info->cqi_ind.number_of_cqis:%d\n", UL_info->cqi_ind.number_of_cqis);
- nfapi_cqi_indication_t ind;
- ind.header.message_id = NFAPI_RX_CQI_INDICATION;
- ind.sfn_sf = UL_info->frame<<4 | UL_info->subframe;
- ind.cqi_indication_body = UL_info->cqi_ind;
- oai_nfapi_cqi_indication(&ind);
- UL_info->cqi_ind.number_of_cqis=0;
+ if (UL_info->cqi_ind.cqi_indication_body.number_of_cqis>0) {
+ LOG_D(PHY,"UL_info->cqi_ind.number_of_cqis:%d\n", UL_info->cqi_ind.cqi_indication_body.number_of_cqis);
+ UL_info->cqi_ind.header.message_id = NFAPI_RX_CQI_INDICATION;
+ UL_info->cqi_ind.sfn_sf = UL_info->frame<<4 | UL_info->subframe;
+
+ oai_nfapi_cqi_indication(&UL_info->cqi_ind);
+ UL_info->cqi_ind.cqi_indication_body.number_of_cqis=0;
+ }
+ } else if (NFAPI_MODE == NFAPI_MODE_VNF) {
+ for(uint8_t j = 0;j < NUM_NFPAI_SUBFRAME;j++){
+ if(UL_RCC_INFO.cqi_ind[j].cqi_indication_body.number_of_cqis > 0){
+ for (i=0;i<UL_RCC_INFO.cqi_ind[j].cqi_indication_body.number_of_cqis;i++){
+ cqi_indication(UL_info->module_id,
+ UL_info->CC_id,
+ NFAPI_SFNSF2SFN(UL_RCC_INFO.cqi_ind[j].sfn_sf),
+ NFAPI_SFNSF2SF(UL_RCC_INFO.cqi_ind[j].sfn_sf),
+ UL_RCC_INFO.cqi_ind[j].cqi_indication_body.cqi_pdu_list[i].rx_ue_information.rnti,
+ &UL_RCC_INFO.cqi_ind[j].cqi_indication_body.cqi_pdu_list[i].cqi_indication_rel9,
+ UL_RCC_INFO.cqi_ind[j].cqi_indication_body.cqi_raw_pdu_list[i].pdu,
+ &UL_RCC_INFO.cqi_ind[j].cqi_indication_body.cqi_pdu_list[i].ul_cqi_information);
+ }
+
+ free(UL_RCC_INFO.cqi_ind[j].cqi_indication_body.cqi_pdu_list);
+ free(UL_RCC_INFO.cqi_ind[j].cqi_indication_body.cqi_raw_pdu_list);
+ UL_RCC_INFO.cqi_ind[j].cqi_indication_body.number_of_cqis=0;
+ UL_RCC_INFO.cqi_ind[j].header.message_id = 0;
+ }
}
} else {
- for (i=0; i<UL_info->cqi_ind.number_of_cqis; i++)
+ for (i=0;i<UL_info->cqi_ind.cqi_indication_body.number_of_cqis;i++)
cqi_indication(UL_info->module_id,
UL_info->CC_id,
- UL_info->frame,
- UL_info->subframe,
- UL_info->cqi_ind.cqi_pdu_list[i].rx_ue_information.rnti,
- &UL_info->cqi_ind.cqi_pdu_list[i].cqi_indication_rel9,
- UL_info->cqi_ind.cqi_raw_pdu_list[i].pdu,
- &UL_info->cqi_ind.cqi_pdu_list[i].ul_cqi_information);
-
- UL_info->cqi_ind.number_of_cqis=0;
+ NFAPI_SFNSF2SFN(UL_info->cqi_ind.sfn_sf),
+ NFAPI_SFNSF2SF(UL_info->cqi_ind.sfn_sf),
+ UL_info->cqi_ind.cqi_indication_body.cqi_pdu_list[i].rx_ue_information.rnti,
+ &UL_info->cqi_ind.cqi_indication_body.cqi_pdu_list[i].cqi_indication_rel9,
+ UL_info->cqi_ind.cqi_indication_body.cqi_raw_pdu_list[i].pdu,
+ &UL_info->cqi_ind.cqi_indication_body.cqi_pdu_list[i].ul_cqi_information);
+
+ UL_info->cqi_ind.cqi_indication_body.number_of_cqis=0;
}
}
@@ -123,7 +183,22 @@ void handle_harq(UL_IND_t *UL_info) {
}
UL_info->harq_ind.harq_indication_body.number_of_harqs = 0;
+ }else if(NFAPI_MODE == NFAPI_MODE_VNF){
+ for(uint8_t j = 0;j < NUM_NFPAI_SUBFRAME;j++){
+ if(UL_RCC_INFO.harq_ind[j].harq_indication_body.number_of_harqs > 0){
+ for (int i=0;i<UL_RCC_INFO.harq_ind[j].harq_indication_body.number_of_harqs;i++){
+ harq_indication(UL_info->module_id,
+ UL_info->CC_id,
+ NFAPI_SFNSF2SFN(UL_RCC_INFO.harq_ind[j].sfn_sf),
+ NFAPI_SFNSF2SF(UL_RCC_INFO.harq_ind[j].sfn_sf),
+ &UL_RCC_INFO.harq_ind[j].harq_indication_body.harq_pdu_list[i]);
+ }
+ free(UL_RCC_INFO.harq_ind[j].harq_indication_body.harq_pdu_list);
+ UL_RCC_INFO.harq_ind[j].harq_indication_body.number_of_harqs=0;
+ UL_RCC_INFO.harq_ind[j].header.message_id = 0;
+ }
+ }
} else {
for (int i=0; i < UL_info->harq_ind.harq_indication_body.number_of_harqs; i++)
harq_indication(UL_info->module_id,
@@ -151,6 +226,56 @@ void handle_ulsch(UL_IND_t *UL_info) {
oai_nfapi_rx_ind(&UL_info->rx_ind);
UL_info->rx_ind.rx_indication_body.number_of_pdus = 0;
}
+ } else if(NFAPI_MODE == NFAPI_MODE_VNF){
+ for(uint8_t k = 0;k < NUM_NFPAI_SUBFRAME;k++){
+ if((UL_RCC_INFO.rx_ind[k].rx_indication_body.number_of_pdus>0) && (UL_RCC_INFO.crc_ind[k].crc_indication_body.number_of_crcs>0)){
+ for (i=0;i<UL_RCC_INFO.rx_ind[k].rx_indication_body.number_of_pdus;i++) {
+ for (j=0;j<UL_RCC_INFO.crc_ind[k].crc_indication_body.number_of_crcs;j++) {
+ // find crc_indication j corresponding rx_indication i
+ LOG_D(PHY,"UL_info->crc_ind.crc_indication_body.crc_pdu_list[%d].rx_ue_information.rnti:%04x UL_info->rx_ind.rx_indication_body.rx_pdu_list[%d].rx_ue_information.rnti:%04x\n",
+ j,UL_RCC_INFO.crc_ind[k].crc_indication_body.crc_pdu_list[j].rx_ue_information.rnti, i,UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_ue_information.rnti);
+ if (UL_RCC_INFO.crc_ind[k].crc_indication_body.crc_pdu_list[j].rx_ue_information.rnti == UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_ue_information.rnti) {
+ LOG_D(PHY, "UL_info->crc_ind.crc_indication_body.crc_pdu_list[%d].crc_indication_rel8.crc_flag:%d\n",
+ j, UL_RCC_INFO.crc_ind[k].crc_indication_body.crc_pdu_list[j].crc_indication_rel8.crc_flag);
+ if (UL_RCC_INFO.crc_ind[k].crc_indication_body.crc_pdu_list[j].crc_indication_rel8.crc_flag == 1) { // CRC error indication
+ LOG_D(MAC,"Frame %d, Subframe %d Calling rx_sdu (CRC error) \n",UL_info->frame,UL_info->subframe);
+ rx_sdu(UL_info->module_id,
+ UL_info->CC_id,
+ NFAPI_SFNSF2SFN(UL_RCC_INFO.rx_ind[k].sfn_sf), //UL_info->frame,
+ NFAPI_SFNSF2SF(UL_RCC_INFO.rx_ind[k].sfn_sf), //UL_info->subframe,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_ue_information.rnti,
+ (uint8_t *)NULL,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_indication_rel8.length,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_indication_rel8.timing_advance,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_indication_rel8.ul_cqi);
+ }
+ else {
+ LOG_D(MAC,"Frame %d, Subframe %d Calling rx_sdu (CRC ok) \n",UL_info->frame,UL_info->subframe);
+ rx_sdu(UL_info->module_id,
+ UL_info->CC_id,
+ NFAPI_SFNSF2SFN(UL_RCC_INFO.rx_ind[k].sfn_sf), //UL_info->frame,
+ NFAPI_SFNSF2SF(UL_RCC_INFO.rx_ind[k].sfn_sf), //UL_info->subframe,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_ue_information.rnti,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].data,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_indication_rel8.length,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_indication_rel8.timing_advance,
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].rx_indication_rel8.ul_cqi);
+ }
+ if(UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].data != NULL){
+ free(UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list[i].data);
+ }
+ break;
+ } //if (UL_info->crc_ind.crc_pdu_list[j].rx_ue_information.rnti == UL_info->rx_ind.rx_pdu_list[i].rx_ue_information.rnti)
+ } // for (j=0;j<UL_info->crc_ind.crc_indication_body.number_of_crcs;j++)
+ } // for (i=0;i<UL_info->rx_ind.number_of_pdus;i++)
+ free(UL_RCC_INFO.crc_ind[k].crc_indication_body.crc_pdu_list);
+ free(UL_RCC_INFO.rx_ind[k].rx_indication_body.rx_pdu_list);
+ UL_RCC_INFO.crc_ind[k].crc_indication_body.number_of_crcs = 0;
+ UL_RCC_INFO.crc_ind[k].header.message_id =0;
+ UL_RCC_INFO.rx_ind[k].rx_indication_body.number_of_pdus = 0;
+ UL_RCC_INFO.rx_ind[k].header.message_id = 0;
+ }
+ }
} else {
if (UL_info->rx_ind.rx_indication_body.number_of_pdus>0 && UL_info->crc_ind.crc_indication_body.number_of_crcs>0) {
for (i=0; i<UL_info->rx_ind.rx_indication_body.number_of_pdus; i++) {
@@ -574,11 +699,11 @@ void UL_indication(UL_IND_t *UL_info) {
Sched_Rsp_t *sched_info = &Sched_INFO[module_id][CC_id];
IF_Module_t *ifi = if_inst[module_id];
eNB_MAC_INST *mac = RC.mac[module_id];
+
LOG_D(PHY,"SFN/SF:%d%d module_id:%d CC_id:%d UL_info[rx_ind:%d harqs:%d crcs:%d cqis:%d preambles:%d sr_ind:%d]\n",
UL_info->frame,UL_info->subframe,
module_id,CC_id,
- UL_info->rx_ind.rx_indication_body.number_of_pdus, UL_info->harq_ind.harq_indication_body.number_of_harqs, UL_info->crc_ind.crc_indication_body.number_of_crcs, UL_info->cqi_ind.number_of_cqis,
- UL_info->rach_ind.rach_indication_body.number_of_preambles, UL_info->sr_ind.sr_indication_body.number_of_srs);
+ UL_info->rx_ind.rx_indication_body.number_of_pdus, UL_info->harq_ind.harq_indication_body.number_of_harqs, UL_info->crc_ind.crc_indication_body.number_of_crcs, UL_info->cqi_ind.cqi_indication_body.number_of_cqis, UL_info->rach_ind.rach_indication_body.number_of_preambles, UL_info->sr_ind.sr_indication_body.number_of_srs);
if(UL_info->frame==1023&&UL_info->subframe==6) { // dl scheduling (0,0)
frame_cnt= (frame_cnt + 1)%7; // to prevent frame_cnt get too big
@@ -604,6 +729,7 @@ void UL_indication(UL_IND_t *UL_info) {
handle_sr(UL_info);
handle_cqi(UL_info);
handle_harq(UL_info);
+
// clear HI prior to handling ULSCH
uint8_t sf_ahead_dl = ul_subframe2_k_phich(&mac->common_channels[CC_id], UL_info->subframe);
@@ -634,6 +760,9 @@ void UL_indication(UL_IND_t *UL_info) {
sched_info->UL_req = NULL;
sched_info->TX_req = &mac->TX_req[CC_id];
+ pthread_mutex_lock(&lock_ue_freelist);
+ sched_info->UE_release_req = &mac->UE_release_req;
+ pthread_mutex_unlock(&lock_ue_freelist);
#ifdef DUMP_FAPI
dump_dl(sched_info);
#endif
diff --git a/openair2/PHY_INTERFACE/IF_Module.h b/openair2/PHY_INTERFACE/IF_Module.h
index b6ede7d598a05f1e06e802fb0d52b46a96510b50..c42ba992c912c9e1c008b9e4dad89e08ff5c6ffa 100644
--- a/openair2/PHY_INTERFACE/IF_Module.h
+++ b/openair2/PHY_INTERFACE/IF_Module.h
@@ -71,7 +71,7 @@ typedef struct{
nfapi_sr_indication_t sr_ind;
/// CQI indication list
- nfapi_cqi_indication_body_t cqi_ind;
+ nfapi_cqi_indication_t cqi_ind;
/// RACH indication list
nfapi_rach_indication_t rach_ind;
@@ -90,7 +90,27 @@ typedef struct{
} UL_IND_t;
// Downlink subframe P7
+#define NUM_NFPAI_SUBFRAME 5
+typedef struct{
+ /// harq indication list
+ nfapi_harq_indication_t harq_ind[NUM_NFPAI_SUBFRAME];
+
+ /// crc indication list
+ nfapi_crc_indication_t crc_ind[NUM_NFPAI_SUBFRAME];
+
+ /// SR indication list
+ nfapi_sr_indication_t sr_ind[NUM_NFPAI_SUBFRAME];
+
+ /// CQI indication list
+ nfapi_cqi_indication_t cqi_ind[NUM_NFPAI_SUBFRAME];
+
+ /// RACH indication list
+ nfapi_rach_indication_t rach_ind[NUM_NFPAI_SUBFRAME];
+
+ /// RX indication
+ nfapi_rx_indication_t rx_ind[NUM_NFPAI_SUBFRAME];
+} UL_RCC_IND_t;
typedef struct{
/// Module ID
@@ -109,6 +129,8 @@ typedef struct{
nfapi_hi_dci0_request_t *HI_DCI0_req;
/// Pointers to DL SDUs
nfapi_tx_request_t *TX_req;
+ /// Pointers to ue_release
+ nfapi_ue_release_request_t *UE_release_req;
}Sched_Rsp_t;
typedef struct {
diff --git a/openair2/PHY_INTERFACE/phy_stub_UE.c b/openair2/PHY_INTERFACE/phy_stub_UE.c
index 8d625fbdc59337c86d4609e9a386314e411243c5..930387c742489c1a413cd76b3bb3a56bb3f74502 100644
--- a/openair2/PHY_INTERFACE/phy_stub_UE.c
+++ b/openair2/PHY_INTERFACE/phy_stub_UE.c
@@ -236,8 +236,8 @@ void fill_ulsch_cqi_indication_UE_MAC(int Mod_id, uint16_t frame,uint8_t subfram
// change for mutiple UE's simulation.
//pthread_mutex_lock(&UE_mac_inst[Mod_id].UL_INFO_mutex);
pthread_mutex_lock(&fill_ul_mutex.cqi_mutex);
- nfapi_cqi_indication_pdu_t *pdu = &UL_INFO->cqi_ind.cqi_pdu_list[UL_INFO->cqi_ind.number_of_cqis];
- nfapi_cqi_indication_raw_pdu_t *raw_pdu = &UL_INFO->cqi_ind.cqi_raw_pdu_list[UL_INFO->cqi_ind.number_of_cqis];
+ nfapi_cqi_indication_pdu_t *pdu = &UL_INFO->cqi_ind.cqi_indication_body.cqi_pdu_list[UL_INFO->cqi_ind.cqi_indication_body.number_of_cqis];
+ nfapi_cqi_indication_raw_pdu_t *raw_pdu = &UL_INFO->cqi_ind.cqi_indication_body.cqi_raw_pdu_list[UL_INFO->cqi_ind.cqi_indication_body.number_of_cqis];
pdu->rx_ue_information.tl.tag = NFAPI_RX_UE_INFORMATION_TAG;
pdu->rx_ue_information.rnti = rnti;
@@ -263,7 +263,7 @@ void fill_ulsch_cqi_indication_UE_MAC(int Mod_id, uint16_t frame,uint8_t subfram
- UL_INFO->cqi_ind.number_of_cqis++;
+ UL_INFO->cqi_ind.cqi_indication_body.number_of_cqis++;
// change for mutiple UE's simulation.
//pthread_mutex_unlock(&UE_mac_inst[Mod_id].UL_INFO_mutex);
pthread_mutex_unlock(&fill_ul_mutex.cqi_mutex);
diff --git a/openair2/RRC/LTE/rrc_eNB.c b/openair2/RRC/LTE/rrc_eNB.c
index 22b00721979ae3128dae985d996d02b6a6ccb93d..d93510ac5d0794941f64507d87cfd17aa1dae99e 100644
--- a/openair2/RRC/LTE/rrc_eNB.c
+++ b/openair2/RRC/LTE/rrc_eNB.c
@@ -1114,6 +1114,8 @@ void put_UE_in_freelist(module_id_t mod_id, rnti_t rnti, boolean_t removeFlag) {
free_list->UE_free_ctrl[free_list->tail_freelist].rnti = rnti;
free_list->UE_free_ctrl[free_list->tail_freelist].removeContextFlg = removeFlag;
free_list->num_UEs++;
+ eNB_MAC->UE_release_req.ue_release_request_body.ue_release_request_TLVs_list[eNB_MAC->UE_release_req.ue_release_request_body.number_of_TLVs].rnti = rnti;
+ eNB_MAC->UE_release_req.ue_release_request_body.number_of_TLVs++;
free_list->tail_freelist = (free_list->tail_freelist + 1) % (NUMBER_OF_UE_MAX+1);
pthread_mutex_unlock(&lock_ue_freelist);
}
@@ -1158,28 +1160,32 @@ void release_UE_in_freeList(module_id_t mod_id) {
for (i=0; i<MAX_MOBILES_PER_ENB; i++) {
ulsch = eNB_PHY->ulsch[i];
-
if((ulsch != NULL) && (ulsch->rnti == rnti)) {
void clean_eNb_ulsch(LTE_eNB_ULSCH_t *ulsch);
LOG_I(RRC, "clean_eNb_ulsch ulsch[%d] UE %x\n", i, rnti);
clean_eNb_ulsch(ulsch);
}
- if(eNB_PHY->uci_vars[i].rnti == rnti) {
- LOG_I(MAC, "clean eNb uci_vars[%d] UE %x \n",i, rnti);
- memset(&eNB_PHY->uci_vars[i],0,sizeof(LTE_eNB_UCI));
- }
- }
-
- for (i=0; i<MAX_MOBILES_PER_ENB; i++) {
dlsch = eNB_PHY->dlsch[i][0];
-
if((dlsch != NULL) && (dlsch->rnti == rnti)) {
void clean_eNb_dlsch(LTE_eNB_DLSCH_t *dlsch);
LOG_I(RRC, "clean_eNb_dlsch dlsch[%d] UE %x \n", i, rnti);
clean_eNb_dlsch(dlsch);
}
}
+ ulsch = eNB_PHY->ulsch[i];
+ if((ulsch != NULL) && (ulsch->rnti == rnti)) {
+ void clean_eNb_ulsch(LTE_eNB_ULSCH_t *ulsch);
+ LOG_I(RRC, "clean_eNb_ulsch ulsch[%d] UE %x\n", i, rnti);
+ clean_eNb_ulsch(ulsch);
+ }
+
+ for (i=0; i<NUMBER_OF_UCI_VARS_MAX; i++) {
+ if(eNB_PHY->uci_vars[i].rnti == rnti) {
+ LOG_I(MAC, "clean eNb uci_vars[%d] UE %x \n",i, rnti);
+ memset(&eNB_PHY->uci_vars[i],0,sizeof(LTE_eNB_UCI));
+ }
+ }
if (flexran_agent_get_rrc_xface(mod_id)) {
flexran_agent_get_rrc_xface(mod_id)->flexran_agent_notify_ue_state_change(
diff --git a/openair2/RRC/LTE/rrc_eNB_S1AP.c b/openair2/RRC/LTE/rrc_eNB_S1AP.c
index 8a6d2edb0e1393a1412125c4b1ff2f1c74c800bf..23284b4b4f190888800187165c873321c459101e 100644
--- a/openair2/RRC/LTE/rrc_eNB_S1AP.c
+++ b/openair2/RRC/LTE/rrc_eNB_S1AP.c
@@ -257,6 +257,15 @@ rrc_eNB_S1AP_get_ue_ids(
}
if (ue_desc_p != NULL) {
+ struct s1ap_eNB_ue_context_s *s1ap_ue_context_p = NULL;
+ if ((s1ap_ue_context_p = RB_REMOVE(s1ap_ue_map, &s1ap_eNB_instance_p->s1ap_ue_head, ue_desc_p)) != NULL) {
+ LOG_E(RRC, "Removed UE context eNB_ue_s1ap_id %u\n", s1ap_ue_context_p->eNB_ue_s1ap_id);
+ s1ap_eNB_free_ue_context(s1ap_ue_context_p);
+ } else {
+ LOG_E(RRC, "Removing UE context eNB_ue_s1ap_id %u: did not find context\n",ue_desc_p->eNB_ue_s1ap_id);
+ }
+ return NULL; //skip the operation below to avoid loop
+ result = rrc_eNB_S1AP_get_ue_ids(rrc_instance_pP, ue_desc_p->ue_initial_id, eNB_ue_s1ap_id);
if (ue_desc_p->ue_initial_id != UE_INITIAL_ID_INVALID) {
result = rrc_eNB_S1AP_get_ue_ids(rrc_instance_pP, ue_desc_p->ue_initial_id, eNB_ue_s1ap_id);
diff --git a/targets/COMMON/openairinterface5g_limits.h b/targets/COMMON/openairinterface5g_limits.h
index 644952ca794a041a046d86efdf054ccaff1b7c39..b81fd091471b135c9ebfe4fbec22a3134b7787a9 100644
--- a/targets/COMMON/openairinterface5g_limits.h
+++ b/targets/COMMON/openairinterface5g_limits.h
@@ -12,13 +12,16 @@
// This problem will be fixed in the future.
# ifndef UESIM_EXPANSION
# define NUMBER_OF_UE_MAX 16
+# define NUMBER_OF_UCI_VARS_MAX 56
# define NUMBER_OF_CONNECTED_eNB_MAX 3
# else
# define NUMBER_OF_UE_MAX 256
+# define NUMBER_OF_UCI_VARS_MAX 256
# define NUMBER_OF_CONNECTED_eNB_MAX 1
# endif
# else
# define NUMBER_OF_UE_MAX 256
+# define NUMBER_OF_UCI_VARS_MAX 256
# define NUMBER_OF_CONNECTED_eNB_MAX 1
# endif
#else
@@ -32,13 +35,16 @@ and the other are using MAX_MOBILES_PER_ENB in for-loop.
*/
# ifndef UESIM_EXPANSION
# define NUMBER_OF_UE_MAX 16
+# define NUMBER_OF_UCI_VARS_MAX 56
# define NUMBER_OF_CONNECTED_eNB_MAX 3
# else
# define NUMBER_OF_UE_MAX 256
+# define NUMBER_OF_UCI_VARS_MAX 256
# define NUMBER_OF_CONNECTED_eNB_MAX 1
# endif
# else
# define NUMBER_OF_UE_MAX 256
+# define NUMBER_OF_UCI_VARS_MAX 256
# define NUMBER_OF_CONNECTED_eNB_MAX 1
# endif
# if defined(STANDALONE) && STANDALONE==1
diff --git a/targets/RT/USER/lte-enb.c b/targets/RT/USER/lte-enb.c
index 76016ba0a654888c5ee14b75c9fc11ec7948e91a..1ad25febac2003cbbb260be42153e2c7a4b1ba2e 100644
--- a/targets/RT/USER/lte-enb.c
+++ b/targets/RT/USER/lte-enb.c
@@ -189,14 +189,14 @@ static inline int rxtx(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc, char *thread_name
eNB->UL_INFO.harq_ind.harq_indication_body.number_of_harqs ||
eNB->UL_INFO.crc_ind.crc_indication_body.number_of_crcs ||
eNB->UL_INFO.rach_ind.rach_indication_body.number_of_preambles ||
- eNB->UL_INFO.cqi_ind.number_of_cqis
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.number_of_cqis
) {
LOG_D(PHY, "UL_info[rx_ind:%05d:%d harqs:%05d:%d crcs:%05d:%d preambles:%05d:%d cqis:%d] RX:%04d%d TX:%04d%d num_pdcch_symbols:%d\n",
NFAPI_SFNSF2DEC(eNB->UL_INFO.rx_ind.sfn_sf), eNB->UL_INFO.rx_ind.rx_indication_body.number_of_pdus,
NFAPI_SFNSF2DEC(eNB->UL_INFO.harq_ind.sfn_sf), eNB->UL_INFO.harq_ind.harq_indication_body.number_of_harqs,
NFAPI_SFNSF2DEC(eNB->UL_INFO.crc_ind.sfn_sf), eNB->UL_INFO.crc_ind.crc_indication_body.number_of_crcs,
NFAPI_SFNSF2DEC(eNB->UL_INFO.rach_ind.sfn_sf), eNB->UL_INFO.rach_ind.rach_indication_body.number_of_preambles,
- eNB->UL_INFO.cqi_ind.number_of_cqis,
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.number_of_cqis,
proc->frame_rx, proc->subframe_rx,
proc->frame_tx, proc->subframe_tx, eNB->pdcch_vars[proc->subframe_tx&1].num_pdcch_symbols);
}
@@ -218,9 +218,11 @@ static inline int rxtx(PHY_VARS_eNB *eNB,L1_rxtx_proc_t *proc, char *thread_name
wakeup_prach_eNB_br(eNB,NULL,proc->frame_rx,proc->subframe_rx);
#endif
}
-
- release_UE_in_freeList(eNB->Mod_id);
-
+ if (NFAPI_MODE!=NFAPI_MODE_PNF) {
+ release_UE_in_freeList(eNB->Mod_id);
+ } else {
+ release_rnti_of_phy(eNB->Mod_id);
+ }
// UE-specific RX processing for subframe n
if (NFAPI_MODE==NFAPI_MONOLITHIC || NFAPI_MODE==NFAPI_MODE_PNF) {
phy_procedures_eNB_uespec_RX(eNB, proc);
@@ -429,13 +431,12 @@ static void *L1_thread( void *param ) {
}
LOG_D(PHY,"L1 RX %d.%d done\n",proc->frame_rx,proc->subframe_rx);
-
- if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) phy_procedures_eNB_TX(eNB, proc, 1);
-
-
if (NFAPI_MODE!=NFAPI_MODE_VNF) {
- if(get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) wakeup_tx(eNB,proc->frame_rx,proc->subframe_rx,proc->frame_tx,proc->subframe_tx,proc->timestamp_tx);
- else if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) wakeup_txfh(eNB,proc,proc->frame_tx,proc->subframe_tx,proc->timestamp_tx);
+ if(get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) wakeup_tx(eNB,proc->frame_rx,proc->subframe_rx,proc->frame_tx,proc->subframe_tx,proc->timestamp_tx);
+ else if(get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) {
+ phy_procedures_eNB_TX(eNB, proc, 1);
+ wakeup_txfh(eNB,proc,proc->frame_tx,proc->subframe_tx,proc->timestamp_tx);
+ }
}
if (release_thread(&proc->mutex,&proc->instance_cnt,thread_name)<0) break;
@@ -926,7 +927,9 @@ void init_eNB_proc(int inst) {
LOG_I(PHY,"eNB->single_thread_flag:%d\n", eNB->single_thread_flag);
- if ((get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT || get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) && NFAPI_MODE!=NFAPI_MODE_VNF) {
+ if ((get_thread_parallel_conf() == PARALLEL_RU_L1_SPLIT) && NFAPI_MODE!=NFAPI_MODE_VNF) {
+ pthread_create( &L1_proc->pthread, attr0, L1_thread, proc );
+ } else if ((get_thread_parallel_conf() == PARALLEL_RU_L1_TRX_SPLIT) && NFAPI_MODE!=NFAPI_MODE_VNF) {
pthread_create( &L1_proc->pthread, attr0, L1_thread, proc );
pthread_create( &L1_proc_tx->pthread, attr1, L1_thread_tx, proc);
} else if (NFAPI_MODE==NFAPI_MODE_VNF) { // this is neccesary in VNF or L2 FAPI simulator.
@@ -937,10 +940,12 @@ void init_eNB_proc(int inst) {
pthread_create( &L1_proc_tx->pthread, attr1, L1_thread, L1_proc_tx);
}
- pthread_create( &proc->pthread_prach, attr_prach, eNB_thread_prach, eNB );
+ if (NFAPI_MODE!=NFAPI_MODE_VNF) {
+ pthread_create( &proc->pthread_prach, attr_prach, eNB_thread_prach, eNB );
#if (LTE_RRC_VERSION >= MAKE_VERSION(14, 0, 0))
- pthread_create( &proc->pthread_prach_br, attr_prach_br, eNB_thread_prach_br, eNB );
+ pthread_create( &proc->pthread_prach_br, attr_prach_br, eNB_thread_prach_br, eNB );
#endif
+ }
AssertFatal(proc->instance_cnt_prach == -1,"instance_cnt_prach = %d\n",proc->instance_cnt_prach);
if (opp_enabled == 1) pthread_create(&proc->process_stats_thread,NULL,process_stats_thread,(void *)eNB);
@@ -1101,6 +1106,7 @@ void init_transport(PHY_VARS_eNB *eNB) {
LTE_DL_FRAME_PARMS *fp = &eNB->frame_parms;
LOG_I(PHY, "Initialise transport\n");
+if (NFAPI_MODE!=NFAPI_MODE_VNF) {
for (i=0; i<NUMBER_OF_UE_MAX; i++) {
LOG_D(PHY,"Allocating Transport Channel Buffers for DLSCH, UE %d\n",i);
@@ -1143,6 +1149,7 @@ void init_transport(PHY_VARS_eNB *eNB) {
LOG_D(PHY,"eNB %d.%d : RA %p\n",eNB->Mod_id,eNB->CC_id,eNB->dlsch_ra);
eNB->dlsch_MCH = new_eNB_dlsch(1,8,NSOFT,fp->N_RB_DL, 0, fp);
LOG_D(PHY,"eNB %d.%d : MCH %p\n",eNB->Mod_id,eNB->CC_id,eNB->dlsch_MCH);
+}
eNB->rx_total_gain_dB=130;
for(i=0; i<NUMBER_OF_UE_MAX; i++)
@@ -1280,8 +1287,8 @@ void init_eNB(int single_thread_flag,int wait_for_sync) {
eNB->UL_INFO.crc_ind.crc_indication_body.crc_pdu_list = eNB->crc_pdu_list;
eNB->UL_INFO.sr_ind.sr_indication_body.sr_pdu_list = eNB->sr_pdu_list;
eNB->UL_INFO.harq_ind.harq_indication_body.harq_pdu_list = eNB->harq_pdu_list;
- eNB->UL_INFO.cqi_ind.cqi_pdu_list = eNB->cqi_pdu_list;
- eNB->UL_INFO.cqi_ind.cqi_raw_pdu_list = eNB->cqi_raw_pdu_list;
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.cqi_pdu_list = eNB->cqi_pdu_list;
+ eNB->UL_INFO.cqi_ind.cqi_indication_body.cqi_raw_pdu_list = eNB->cqi_raw_pdu_list;
eNB->prach_energy_counter = 0;
}
}
diff --git a/targets/RT/USER/lte-softmodem-common.c b/targets/RT/USER/lte-softmodem-common.c
index dd91f540047e7108102f04bb6102216395ce60b7..a5fee5397fdd7cababcceb9dce14af44d273c6b5 100644
--- a/targets/RT/USER/lte-softmodem-common.c
+++ b/targets/RT/USER/lte-softmodem-common.c
@@ -62,6 +62,7 @@ void get_common_options(void) {
uint32_t nonbiot;
uint32_t rfsim;
uint32_t basicsim;
+ char *logmem_filename = NULL;
uint32_t do_forms;
paramdef_t cmdline_params[] =CMDLINE_PARAMS_DESC ;
paramdef_t cmdline_logparams[] =CMDLINE_LOGPARAMS_DESC ;
@@ -83,6 +84,13 @@ void get_common_options(void) {
load_module_shlib("telnetsrv",NULL,0,NULL);
}
+ if (logmem_filename != NULL && strlen(logmem_filename) > 0) {
+ log_mem_filename = &logmem_filename[0];
+ log_mem_flag = 1;
+ printf("Enabling OPT for log save at memory %s\n",log_mem_filename);
+ logInit_log_mem();
+ }
+
if (noS1) {
set_softmodem_optmask(SOFTMODEM_NOS1_BIT);
}
diff --git a/targets/RT/USER/lte-softmodem.c b/targets/RT/USER/lte-softmodem.c
index 119e0c39e448bb95ef2fad59848d6e112d5f3100..70b458a7fea8724c6542bcdf3025fc4cf7342a9c 100644
--- a/targets/RT/USER/lte-softmodem.c
+++ b/targets/RT/USER/lte-softmodem.c
@@ -261,7 +261,7 @@ void exit_function(const char *file, const char *function, const int line, const
if (s != NULL) {
printf("%s:%d %s() Exiting OAI softmodem: %s\n",file,line, function, s);
}
-
+ close_log_mem();
oai_exit = 1;
if (RC.ru == NULL)
@@ -524,6 +524,7 @@ int main( int argc, char **argv ) {
int i;
int CC_id = 0;
int ru_id;
+ int node_type = ngran_eNB;
if ( load_configmodule(argc,argv,0) == NULL) {
exit_fun("[SOFTMODEM] Error, configuration module init failed\n");
@@ -604,12 +605,13 @@ int main( int argc, char **argv ) {
RRC_CONFIGURATION_REQ(msg_p) = RC.rrc[enb_id]->configuration;
itti_send_msg_to_task (TASK_RRC_ENB, ENB_MODULE_ID_TO_INSTANCE(enb_id), msg_p);
}
+ node_type = RC.rrc[0]->node_type;
} else {
printf("RC.nb_inst = 0, Initializing L1\n");
RCconfig_L1();
}
- if (RC.nb_inst > 0 && NODE_IS_CU(RC.rrc[0]->node_type)) {
+ if (RC.nb_inst > 0 && NODE_IS_CU(node_type)) {
protocol_ctxt_t ctxt;
ctxt.module_id = 0 ;
ctxt.instance = 0;
@@ -621,7 +623,7 @@ int main( int argc, char **argv ) {
}
/* start threads if only L1 or not a CU */
- if (RC.nb_inst == 0 || !NODE_IS_CU(RC.rrc[0]->node_type)) {
+ if (RC.nb_inst == 0 || !NODE_IS_CU(node_type) || NFAPI_MODE == NFAPI_MODE_PNF || NFAPI_MODE == NFAPI_MODE_VNF) {
// init UE_PF_PO and mutex lock
pthread_mutex_init(&ue_pf_po_mutex, NULL);
memset (&UE_PF_PO[0][0], 0, sizeof(UE_PF_PO_t)*MAX_MOBILES_PER_ENB*MAX_NUM_CCs);
@@ -720,7 +722,7 @@ int main( int argc, char **argv ) {
LOG_I(ENB_APP,"oai_exit=%d\n",oai_exit);
// stop threads
- if (RC.nb_inst == 0 || !NODE_IS_CU(RC.rrc[0]->node_type)) {
+ if (RC.nb_inst == 0 || !NODE_IS_CU(node_type)) {
if(IS_SOFTMODEM_DOFORMS)
end_forms();
diff --git a/targets/RT/USER/lte-softmodem.h b/targets/RT/USER/lte-softmodem.h
index b9a775509dba534ae9a410db1dda70da47328218..15154fea0b0484c08c195beeaa33df0a46ad5c7d 100644
--- a/targets/RT/USER/lte-softmodem.h
+++ b/targets/RT/USER/lte-softmodem.h
@@ -225,6 +225,7 @@
{"g" , CONFIG_HLP_LOGL, 0, uptr:&glog_level, defintval:0, TYPE_UINT, 0}, \
{"telnetsrv", CONFIG_HLP_TELN, PARAMFLAG_BOOL, uptr:&start_telnetsrv, defintval:0, TYPE_UINT, 0}, \
{"msc", CONFIG_HLP_MSC, PARAMFLAG_BOOL, uptr:&START_MSC, defintval:0, TYPE_UINT, 0}, \
+ {"log-mem", NULL, 0, strptr:(char **)&logmem_filename, defstrval:NULL, TYPE_STRING, 0}, \
}
#define CMDLINE_ONLINELOG_IDX 0
#define CMDLINE_GLOGLEVEL_IDX 1
@@ -236,6 +237,7 @@
{ .s2= { config_check_intrange, {0,4}}}, \
{ .s5= {NULL }} , \
{ .s5= {NULL }} , \
+ { .s5= {NULL }} , \
}
/***************************************************************************************************************************************/
diff --git a/targets/RT/USER/lte-ue.c b/targets/RT/USER/lte-ue.c
index 89b58bd7764f451e8be236d19b095c03aca1b911..42ec7d216d7f33f650fe24daeba0d1f2d126b3c8 100644
--- a/targets/RT/USER/lte-ue.c
+++ b/targets/RT/USER/lte-ue.c
@@ -1053,9 +1053,9 @@ static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg) {
UL_INFO->harq_ind.harq_indication_body.number_of_harqs = 0;
UL_INFO->sr_ind.sr_indication_body.sr_pdu_list = (nfapi_sr_indication_pdu_t *)malloc(NB_UE_INST*sizeof(nfapi_sr_indication_pdu_t));
UL_INFO->sr_ind.sr_indication_body.number_of_srs = 0;
- UL_INFO->cqi_ind.cqi_pdu_list = (nfapi_cqi_indication_pdu_t *)malloc(NB_UE_INST*sizeof(nfapi_cqi_indication_pdu_t));
- UL_INFO->cqi_ind.cqi_raw_pdu_list = (nfapi_cqi_indication_raw_pdu_t *)malloc(NB_UE_INST*sizeof(nfapi_cqi_indication_raw_pdu_t));
- UL_INFO->cqi_ind.number_of_cqis = 0;
+ UL_INFO->cqi_ind.cqi_indication_body.cqi_pdu_list = (nfapi_cqi_indication_pdu_t *)malloc(NB_UE_INST*sizeof(nfapi_cqi_indication_pdu_t));
+ UL_INFO->cqi_ind.cqi_indication_body.cqi_raw_pdu_list = (nfapi_cqi_indication_raw_pdu_t *)malloc(NB_UE_INST*sizeof(nfapi_cqi_indication_raw_pdu_t));
+ UL_INFO->cqi_ind.cqi_indication_body.number_of_cqis = 0;
if (pthread_mutex_lock(&phy_stub_ticking->mutex_single_thread) != 0) {
LOG_E( MAC, "[SCHED][UE] error locking mutex for ue_thread_id %d (mutex_single_thread)\n",ue_thread_id);
@@ -1262,10 +1262,10 @@ static void *UE_phy_stub_single_thread_rxn_txnp4(void *arg) {
free(UL_INFO->sr_ind.sr_indication_body.sr_pdu_list);
UL_INFO->sr_ind.sr_indication_body.sr_pdu_list = NULL;
//}
- free(UL_INFO->cqi_ind.cqi_pdu_list);
- UL_INFO->cqi_ind.cqi_pdu_list = NULL;
- free(UL_INFO->cqi_ind.cqi_raw_pdu_list);
- UL_INFO->cqi_ind.cqi_raw_pdu_list = NULL;
+ free(UL_INFO->cqi_ind.cqi_indication_body.cqi_pdu_list);
+ UL_INFO->cqi_ind.cqi_indication_body.cqi_pdu_list = NULL;
+ free(UL_INFO->cqi_ind.cqi_indication_body.cqi_raw_pdu_list);
+ UL_INFO->cqi_ind.cqi_indication_body.cqi_raw_pdu_list = NULL;
free(UL_INFO);
UL_INFO = NULL;