fix issues about assert failed no free or exiting dlsch_context when repeating attach/detach

nfapi/oai_integration/nfapi_pnf.c

@@ -82,6 +82,7 @@ nfapi_tx_request_pdu_t* tx_request_pdu[1023][10][10]; // [frame][subframe][max_n
 
 uint8_t tx_pdus[32][8][4096];
 
+nfapi_release_rnti_request_body_t release_rntis;
 
 uint16_t phy_antenna_capability_values[] = { 1, 2, 4, 8, 16 };
 
@@ -983,6 +984,17 @@ int pnf_phy_lbt_dl_config_req(nfapi_pnf_p7_config_t* config, nfapi_lbt_dl_config
   return 0;
 }
 
+
+int pnf_phy_release_rnti_req(nfapi_pnf_p7_config_t* config, nfapi_release_rnti_request_t* req) {
+  //printf("[PNF] release rnti request\n");
+  if (req->release_rnti_request_body.number_of_rnti==0)
+    return -1;
+
+  release_rntis.number_of_rnti = req->release_rnti_request_body.number_of_rnti;
+  memcpy(&release_rntis.UE_free_rnti, req->release_rnti_request_body.UE_free_rnti, sizeof(uint16_t)*req->release_rnti_request_body.number_of_rnti);
+
+  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;
@@ -1119,6 +1131,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->release_rnti_req = &pnf_phy_release_rnti_req;
 
     if (nfapi_mode==3) {
     	p7_config->dl_config_req = &memcpy_dl_config_req;

nfapi/oai_integration/nfapi_vnf.c

@@ -1185,3 +1185,22 @@ int oai_nfapi_ul_config_req(nfapi_ul_config_request_t *ul_config_req) {
   }
   return retval;
 }
+int oai_nfapi_release_rnti_req(nfapi_release_rnti_request_t *release_req){
+    if(release_req->release_rnti_request_body.number_of_rnti <= 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_RELEASE_RNTI_REQUEST;
+    release_req->release_rnti_request_body.tl.tag = NFAPI_RELEASE_RNTI_BODY_TAG;
+
+    int retval = nfapi_vnf_p7_release_rnti_req(p7_config, release_req);
+
+    if (retval!=0) {
+      LOG_E(PHY, "%s() Problem sending retval:%d\n", __FUNCTION__, retval);
+    } else {
+        release_req->release_rnti_request_body.number_of_rnti = 0;
+    }
+    return retval;
+
+}

nfapi/open-nFAPI/common/public_inc/debug.h

@@ -40,7 +40,7 @@ extern nfapi_trace_level_t nfapi_trace_level_g;
 
 /*! NFAPI trace macro */
 //#define NFAPI_TRACE(level, format, ...) { if(nfapi_trace_g && ((nfapi_trace_level_t)level <= nfapi_trace_level_g)) (*nfapi_trace_g)(level, format, ##__VA_ARGS__); }
-#define NFAPI_TRACE(level, format, ...) { if (nfapi_trace_g) (*nfapi_trace_g)(level, format, ##__VA_ARGS__); }
+#define NFAPI_TRACE(level, format, ...) {}//{ if (nfapi_trace_g) (*nfapi_trace_g)(level, format, ##__VA_ARGS__); }
 
 /*! Function to change the trace level 
  * \param new_level The modified trace level

nfapi/open-nFAPI/nfapi/public_inc/nfapi_interface.h

@@ -146,6 +146,7 @@ typedef enum {
 	NFAPI_LBT_DL_INDICATION,
 	NFAPI_NB_HARQ_INDICATION,
 	NFAPI_NRACH_INDICATION,
+	NFAPI_RELEASE_RNTI_REQUEST,
 
 	NFAPI_PNF_PARAM_REQUEST = 0x0100,
 	NFAPI_PNF_PARAM_RESPONSE,
@@ -2378,6 +2379,14 @@ typedef struct {
 } nfapi_tx_request_body_t;
 #define NFAPI_TX_REQUEST_BODY_TAG 0x2022
 
+#define  NFAPI_RELEASE_MAX_RNTI  256
+typedef struct {
+    nfapi_tl_t tl;
+    uint16_t number_of_rnti;
+    uint16_t UE_free_rnti[NFAPI_RELEASE_MAX_RNTI];
+} nfapi_release_rnti_request_body_t;
+#define NFAPI_RELEASE_RNTI_BODY_TAG 0x2068
+
 // P7 Message Structures
 typedef struct {
 	nfapi_p7_message_header_t header;
@@ -3404,6 +3413,13 @@ 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_release_rnti_request_body_t release_rnti_request_body;
+    nfapi_vendor_extension_tlv_t vendor_extension;
+} nfapi_release_rnti_request_t;
+
 // 
 // P4 Messages
 // 

nfapi/open-nFAPI/nfapi/src/nfapi_p7.c

@@ -1578,6 +1578,31 @@ 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_release_rnti_request_body_t* value = (nfapi_release_rnti_request_body_t*)tlv;
+
+	if(push16(value->number_of_rnti, ppWritePackedMsg, end) == 0){
+		return 0;
+	}
+
+	if(pusharray16(value->UE_free_rnti, NFAPI_RELEASE_MAX_RNTI, value->number_of_rnti, ppWritePackedMsg, end) == 0){
+		return 0;
+	}
+
+	return 1;
+}
+
+static uint8_t pack_release_rnti_request(void *msg, uint8_t **ppWritePackedMsg, uint8_t *end, nfapi_p7_codec_config_t* config)
+{
+	nfapi_release_rnti_request_t *pNfapiMsg = (nfapi_release_rnti_request_t*)msg;
+
+	int x = push16(pNfapiMsg->sfn_sf, ppWritePackedMsg, end);
+	int y = pack_tlv(NFAPI_RELEASE_RNTI_BODY_TAG, &pNfapiMsg->release_rnti_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_rx_ue_information_value(void* tlv, uint8_t **ppWritePackedMsg, uint8_t *end)
 {
 	nfapi_rx_ue_information* value = (nfapi_rx_ue_information*)tlv;
@@ -2665,6 +2690,9 @@ 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_RELEASE_RNTI_REQUEST:
+			result =pack_release_rnti_request(pMessageHeader, &pWritePackedMessage, end, config);
+			break;
 
 		case NFAPI_HARQ_INDICATION:
 			result = pack_harq_indication(pMessageHeader, &pWritePackedMessage, end, config);
@@ -4477,6 +4505,50 @@ static uint8_t unpack_tx_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *
 	return 1;
 }
 
+static uint8_t unpack_release_rnti_request(uint8_t **ppReadPackedMsg, uint8_t *end, void *msg, nfapi_p7_codec_config_t* config)
+{
+    uint8_t proceed = 1;
+    nfapi_release_rnti_request_t *pNfapiMsg = (nfapi_release_rnti_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_RELEASE_RNTI_BODY_TAG:
+            {
+                pNfapiMsg->release_rnti_request_body.tl = generic_tl;
+
+                if( pull16(ppReadPackedMsg, &pNfapiMsg->release_rnti_request_body.number_of_rnti, end) == 0)
+                    return 0;
+
+                if(pNfapiMsg->release_rnti_request_body.number_of_rnti > NFAPI_RELEASE_MAX_RNTI)
+                {
+                    NFAPI_TRACE(NFAPI_TRACE_ERROR, "%s number of relese rnti's exceed maxium (count:%d max:%d)\n", __FUNCTION__, pNfapiMsg->release_rnti_request_body.number_of_rnti, NFAPI_RELEASE_MAX_RNTI);
+                    return 0;
+                } else {
+                    if(pullarray16(ppReadPackedMsg, pNfapiMsg->release_rnti_request_body.UE_free_rnti, NFAPI_RELEASE_MAX_RNTI, pNfapiMsg->release_rnti_request_body.number_of_rnti, end) == 0)
+                        return 0;
+                }
+            }
+            break;
+            default:
+            {
+                NFAPI_TRACE(NFAPI_TRACE_ERROR, "unpack_release_rnti_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;
@@ -5937,6 +6009,10 @@ 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_RELEASE_RNTI_REQUEST:
+			if (unpackedBufLen >= sizeof(nfapi_release_rnti_request_t))
+				retLen = sizeof(nfapi_release_rnti_request_t);
+			break;
 
 		default:
 			NFAPI_TRACE(NFAPI_TRACE_ERROR, "Unknown message ID %d\n", msgId);
@@ -6057,6 +6133,10 @@ int nfapi_p7_message_unpack(void *pMessageBuf, uint32_t messageBufLen, void *pUn
 			else
 				return -1;
 			break;
+		case NFAPI_RELEASE_RNTI_REQUEST:
+			if (check_unpack_length(NFAPI_RELEASE_RNTI_REQUEST, unpackedBufLen))
+				result = unpack_release_rnti_request(&pReadPackedMessage,  end, pMessageHeader, config);
+			break;
 
 		case NFAPI_HARQ_INDICATION:
 			if (check_unpack_length(NFAPI_HARQ_INDICATION, unpackedBufLen))

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_release_rnti_request_t* release_rnti_req;
 } nfapi_pnf_p7_subframe_buffer_t;
 
 typedef struct nfapi_pnf_p7_config nfapi_pnf_p7_config_t;
@@ -652,6 +652,16 @@ 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 RELEASE_RNTI_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 (*release_rnti_req)(nfapi_pnf_p7_config_t* config, nfapi_release_rnti_request_t* req);
 	
 	/*! A callback for vendor extension messages
 	 * \param config A poiner to the PNF P7 config

nfapi/open-nFAPI/pnf/src/pnf_p7.c

@@ -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_release_rnti_request_t* allocate_nfapi_release_rnti_request(pnf_p7_t* pnf_p7)
+{
+	return pnf_p7_malloc(pnf_p7, sizeof(nfapi_release_rnti_request_t));
+}
+
+void deallocate_nfapi_release_rnti_request(nfapi_release_rnti_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;
@@ -719,7 +729,20 @@ int pnf_p7_subframe_ind(pnf_p7_t* pnf_p7, uint16_t phy_id, uint16_t sfn_sf)
 					(pnf_p7->_public.hi_dci0_req)(&(pnf_p7->_public), pnf_p7->_public.dummy_subframe.hi_dci0_req);
 				}
 			}
-
+			if(tx_subframe_buffer->release_rnti_req != 0)
+			{
+				if(pnf_p7->_public.release_rnti_req)
+					(pnf_p7->_public.release_rnti_req)(&(pnf_p7->_public), tx_subframe_buffer->release_rnti_req);
+			}
+			else
+			{
+				//send dummy
+				if(pnf_p7->_public.release_rnti_req && pnf_p7->_public.dummy_subframe.release_rnti_req)
+				{
+					pnf_p7->_public.dummy_subframe.release_rnti_req->sfn_sf = sfn_sf_tx;
+					(pnf_p7->_public.release_rnti_req)(&(pnf_p7->_public), pnf_p7->_public.dummy_subframe.release_rnti_req);
+				}
+			}
                         if(tx_subframe_buffer->dl_config_req != 0)
                         {
                           deallocate_nfapi_dl_config_request(tx_subframe_buffer->dl_config_req, pnf_p7);
@@ -735,6 +758,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->release_rnti_req != 0){
+                            deallocate_nfapi_release_rnti_request(tx_subframe_buffer->release_rnti_req, pnf_p7);
+                            tx_subframe_buffer->release_rnti_req = 0;
+                        }
                 }
 		else
 		{
@@ -799,7 +826,8 @@ 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->release_rnti_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 +1338,75 @@ void pnf_handle_p7_vendor_extension(void* pRecvMsg, int recvMsgLen, pnf_p7_t* pn
 	
 }
 
+void pnf_handle_release_rnti_request(void* pRecvMsg, int recvMsgLen, pnf_p7_t* pnf_p7)
+{
+    nfapi_release_rnti_request_t* req = allocate_nfapi_release_rnti_request(pnf_p7);
+
+    if(req == NULL)
+    {
+        NFAPI_TRACE(NFAPI_TRACE_INFO, "%s failed to alloced nfapi_release_rnti_request structure\n");
+        return;
+    }
+
+    int unpack_result = nfapi_p7_message_unpack(pRecvMsg, recvMsgLen, req, sizeof(nfapi_release_rnti_request_t), &pnf_p7->_public.codec_config);
+    if(unpack_result == 0)
+    {
+        if(pthread_mutex_lock(&(pnf_p7->mutex)) != 0)
+        {
+            NFAPI_TRACE(NFAPI_TRACE_INFO, "failed to lock mutex\n");
+            return;
+        }
+
+        if(is_p7_request_in_window(req->sfn_sf, "release_rnti_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 RELEASE_RNTI_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() RELEASE_RNTI_REQ.req sfn_sf:%d rntis:%d - RELEASE_RNTI_REQ is within window\n",
+                            __FUNCTION__,
+                            NFAPI_SFNSF2DEC(req->sfn_sf),
+                            req->release_rnti_request_body.number_of_rnti);
+
+            if(pnf_p7->subframe_buffer[buffer_index].release_rnti_req != 0)
+            {
+                deallocate_nfapi_release_rnti_request(pnf_p7->subframe_buffer[buffer_index].release_rnti_req, pnf_p7);
+            }
+
+            pnf_p7->subframe_buffer[buffer_index].sfn_sf = req->sfn_sf;
+            pnf_p7->subframe_buffer[buffer_index].release_rnti_req = req;
+
+            pnf_p7->stats.tx_ontime++;
+        }
+        else
+        {
+            NFAPI_TRACE(NFAPI_TRACE_INFO,"%s() RELEASE_RNTI_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_release_rnti_request(req, pnf_p7);
+
+            if(pnf_p7->_public.timing_info_mode_aperiodic)
+            {
+                pnf_p7->timing_info_aperiodic_send = 1;
+            }
+
+            pnf_p7->stats.tx_late++;
+        }
+
+        if(pthread_mutex_unlock(&(pnf_p7->mutex)) != 0)
+        {
+            NFAPI_TRACE(NFAPI_TRACE_INFO, "failed to unlock mutex\n");
+            return;
+        }
+    }
+    else
+    {
+        deallocate_nfapi_release_rnti_request(req, pnf_p7);
+    }
+}
 
 uint32_t calculate_t2(uint32_t now_time_hr, uint16_t sfn_sf, uint32_t sf_start_time_hr)
 {
@@ -1446,6 +1543,9 @@ void pnf_dispatch_p7_message(void *pRecvMsg, int recvMsgLen, pnf_p7_t* pnf_p7,
 			pnf_handle_lbt_dl_config_request(pRecvMsg, recvMsgLen, pnf_p7);
 			break;
 		
+		case NFAPI_RELEASE_RNTI_REQUEST:
+			pnf_handle_release_rnti_request(pRecvMsg, recvMsgLen, pnf_p7);
+			break;
 		default:
 			{
 				if(header.message_id >= NFAPI_VENDOR_EXT_MSG_MIN &&

nfapi/open-nFAPI/vnf/public_inc/nfapi_vnf_interface.h

@@ -988,6 +988,16 @@ 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_release_rnti_req(nfapi_vnf_p7_config_t* config, nfapi_release_rnti_request_t* req);
+
 #if defined(__cplusplus)
 }
 #endif

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_release_rnti_req(nfapi_vnf_p7_config_t* config, nfapi_release_rnti_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)
 {

openair1/PHY/LTE_TRANSPORT/dlsch_coding.c

@@ -599,7 +599,12 @@ int dlsch_encoding_all(PHY_VARS_eNB *eNB,
 {
 	int encoding_return = 0;
 	unsigned int L,C,B;
-	B = dlsch->harq_processes[dlsch->harq_ids[frame%2][subframe]]->B;
+	unsigned char 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;
 	if(B<=6144)
 	{
 		L=0;

openair1/SCHED/fapi_l1.c

@@ -42,6 +42,7 @@ int oai_nfapi_dl_config_req(nfapi_dl_config_request_t *dl_config_req);
 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_release_rnti_req(nfapi_release_rnti_request_t *release_req);
 
 extern uint8_t nfapi_mode;
 
@@ -836,6 +837,8 @@ void schedule_response(Sched_Rsp_t *Sched_INFO)
     oai_nfapi_tx_req(Sched_INFO->TX_req);
 
     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->RELEASE_rnti_req->sfn_sf = frame << 4 | subframe;
+    oai_nfapi_release_rnti_req(Sched_INFO->RELEASE_rnti_req);
   }
 
   if (nfapi_mode && number_hi_dci0_pdu!=0) {

openair1/SCHED/phy_procedures_lte_eNb.c

@@ -51,6 +51,7 @@
 
 extern uint8_t nfapi_mode;
 
+extern nfapi_release_rnti_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)
@@ -1608,7 +1609,10 @@ static void do_release_harq(PHY_VARS_eNB *eNB,int UE_id,int tb,uint16_t frame,ui
     frame_tx = ul_ACK_subframe2_dl_frame(&eNB->frame_parms,frame,subframe,subframe_tx);
     harq_pid = dlsch0->harq_ids[frame_tx%2][subframe_tx]; // or just use 0 for fdd?
 
-    AssertFatal((harq_pid>=0) && (harq_pid<10),"harq_pid %d not in 0...9\n",harq_pid);
+    if(harq_pid >= dlsch0->Mdlharq) {
+        LOG_E(PHY,"frame %d subframe %d harq_pid %d not in 0...7\n", frame_tx, subframe_tx, harq_pid);
+        return;
+    }
     dlsch0_harq     = dlsch0->harq_processes[harq_pid];
     dlsch1_harq     = dlsch1->harq_processes[harq_pid];
     AssertFatal(dlsch0_harq!=NULL,"dlsch0_harq is null\n");
@@ -2092,3 +2096,38 @@ void phy_procedures_eNB_uespec_RX(PHY_VARS_eNB *eNB,eNB_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_rnti;i++){
+        for (CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
+          eNB_PHY = RC.eNB[mod_id][CC_id];
+          rnti = release_rntis.UE_free_rnti[i];
+          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);
+              }
+          }
+          for(j=0; j<NUMBER_OF_UE_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));
+              }
+
+              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);
+              }
+          }
+        }
+    }
+    memset(&release_rntis, 0, sizeof(nfapi_release_rnti_request_body_t));
+}

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);
 /*@}*/
 
 

openair2/LAYER2/MAC/eNB_scheduler_primitives.c

@@ -1517,6 +1517,18 @@ fill_nfapi_dlsch_config(eNB_MAC_INST * eNB,
   dl_config_pdu->dlsch_pdu.dlsch_pdu_rel8.transmission_mode                      = transmission_mode;
   dl_config_pdu->dlsch_pdu.dlsch_pdu_rel8.num_bf_prb_per_subband                 = num_bf_prb_per_subband;
   dl_config_pdu->dlsch_pdu.dlsch_pdu_rel8.num_bf_vector                          = num_bf_vector;
+  // Rel10 fields
+#if (LTE_RRC_VERSION >= MAKE_VERSION(10, 0, 0))
+  dl_config_pdu->dlsch_pdu.dlsch_pdu_rel10.tl.tag = NFAPI_DL_CONFIG_REQUEST_DLSCH_PDU_REL10_TAG;
+  dl_config_pdu->dlsch_pdu.dlsch_pdu_rel10.pdsch_start = 3;
+#endif
+  // Rel13 fields
+#if (LTE_RRC_VERSION >= MAKE_VERSION(13, 0, 0))
+  dl_config_pdu->dlsch_pdu.dlsch_pdu_rel13.tl.tag = NFAPI_DL_CONFIG_REQUEST_DLSCH_PDU_REL13_TAG;
+  dl_config_pdu->dlsch_pdu.dlsch_pdu_rel13.ue_type = 0; // regular UE
+  dl_config_pdu->dlsch_pdu.dlsch_pdu_rel13.pdsch_payload_type = 2; // not BR
+  dl_config_pdu->dlsch_pdu.dlsch_pdu_rel13.initial_transmission_sf_io = 0xFFFF; // absolute SF
+#endif
   dl_req->number_pdu++;
 }
 

openair2/LAYER2/MAC/mac.h

@@ -1353,6 +1353,9 @@ 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 release rnti structure
+  nfapi_release_rnti_request_t RELEASE_rnti_req;
   /// UL handle
   uint32_t ul_handle;
   UE_list_t UE_list;

openair2/PHY_INTERFACE/IF_Module.c

@@ -588,6 +588,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->RELEASE_rnti_req = &mac->RELEASE_rnti_req;
+      pthread_mutex_unlock(&lock_ue_freelist);
 
 #ifdef DUMP_FAPI
       dump_dl(sched_info);

openair2/PHY_INTERFACE/IF_Module.h

@@ -109,6 +109,8 @@ typedef struct{
   nfapi_hi_dci0_request_t *HI_DCI0_req;
   /// Pointers to DL SDUs
   nfapi_tx_request_t *TX_req;
+  /// Pointers to release rntis
+  nfapi_release_rnti_request_t *RELEASE_rnti_req;
 }Sched_Rsp_t;
 
 typedef struct {

openair2/RRC/LTE/rrc_eNB.c

@@ -896,6 +896,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->RELEASE_rnti_req.release_rnti_request_body.UE_free_rnti[eNB_MAC->RELEASE_rnti_req.release_rnti_request_body.number_of_rnti] = rnti;
+    eNB_MAC->RELEASE_rnti_req.release_rnti_request_body.number_of_rnti++;
     free_list->tail_freelist = (free_list->tail_freelist + 1) % (NUMBER_OF_UE_MAX+1);
     pthread_mutex_unlock(&lock_ue_freelist);
 }

targets/RT/USER/lte-enb.c

@@ -216,7 +216,10 @@ static inline int rxtx(PHY_VARS_eNB *eNB,eNB_rxtx_proc_t *proc, char *thread_nam
 #endif
   }
 
-  release_UE_in_freeList(eNB->Mod_id);
+  if(nfapi_mode != 1)
+    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 == 0 || nfapi_mode == 1) {