MAC ACK RX guarantee update

MAC will allocate 1 buffer dynamically for RX ACK data.
Buffer is re-allocated if allocated size is too small.
MAC also have static Event structure for guarantee that ACK event is possible to send allways.

Author: Juha Heiuskanen

source/MAC/IEEE802_15_4/mac_defines.h

@@ -26,6 +26,7 @@
 struct cca_structure_s;
 struct buffer;
 struct mac_pre_build_frame;
+struct mac_pre_parsed_frame_s;
 struct mlme_key_descriptor_s;
 struct arm_device_driver_list;
 struct fhss_api;
@@ -204,6 +205,7 @@ typedef struct protocol_interface_rf_mac_setup {
     bool macBroadcastDisabled: 1;
     bool scan_active: 1;
     bool rf_csma_extension_supported: 1;
+    bool rf_pd_ack_buffer_is_in_use: 1;
     uint16_t mac_short_address;
     uint16_t pan_id;
     uint8_t mac64[8];
@@ -233,7 +235,9 @@ typedef struct protocol_interface_rf_mac_setup {
     struct mac_pre_build_frame *pd_data_request_queue_to_go;
     struct mac_pre_build_frame *pd_data_request_bc_queue_to_go;
     struct mac_pre_build_frame *active_pd_data_request;
+    struct mac_pre_parsed_frame_s *pd_rx_ack_buffer;
     /* MAC Beacon info */
+    uint16_t allocated_ack_buffer_length;
     uint16_t max_beacon_payload_length;
     uint8_t *mac_beacon_payload;
     uint8_t mac_beacon_payload_size;
@@ -253,6 +257,7 @@ typedef struct protocol_interface_rf_mac_setup {
     struct mac_pre_build_frame enhanced_ack_buffer;
     uint32_t enhanced_ack_handler_timestamp;
     arm_event_t mac_mcps_timer_event;
+    arm_event_storage_t mac_ack_event;
     uint16_t indirect_pending_bytes;
     arm_nwk_mlme_event_type_e mac_mlme_event;
     mac_event_t timer_mac_event;

source/MAC/IEEE802_15_4/mac_mcps_sap.c

@@ -2372,6 +2372,18 @@ static mac_pre_build_frame_t *mcps_sap_pd_req_queue_read(protocol_interface_rf_m
 
 void mcps_sap_pre_parsed_frame_buffer_free(mac_pre_parsed_frame_t *buf)
 {
+    if (!buf) {
+        return;
+    }
+
+    if (buf->mac_class_ptr && buf->fcf_dsn.frametype == FC_ACK_FRAME) {
+        struct protocol_interface_rf_mac_setup *rf_mac_setup = buf->mac_class_ptr;
+        if (rf_mac_setup->rf_pd_ack_buffer_is_in_use) {
+            rf_mac_setup->rf_pd_ack_buffer_is_in_use = false;
+            return;
+        }
+    }
+
     ns_dyn_mem_free(buf);
 }
 
@@ -2388,6 +2400,37 @@ mac_pre_parsed_frame_t *mcps_sap_pre_parsed_frame_buffer_get(const uint8_t *data
     return buffer;
 }
 
+mac_pre_parsed_frame_t *mcps_sap_pre_parsed_ack_buffer_get(protocol_interface_rf_mac_setup_s *rf_ptr, const uint8_t *data_ptr, uint16_t frame_length)
+{
+
+    if (rf_ptr->rf_pd_ack_buffer_is_in_use) {
+#ifdef __linux__
+        tr_debug("mac ACK buffer get fail: already active");
+#endif
+        return NULL;
+    }
+
+    if (frame_length > rf_ptr->allocated_ack_buffer_length) {
+        //Free Current
+        if (rf_ptr->pd_rx_ack_buffer) {
+            ns_dyn_mem_free(rf_ptr->pd_rx_ack_buffer);
+            rf_ptr->allocated_ack_buffer_length = 0;
+        }
+        rf_ptr->pd_rx_ack_buffer = ns_dyn_mem_alloc(sizeof(mac_pre_parsed_frame_t) + frame_length);
+        if (!rf_ptr->pd_rx_ack_buffer) {
+            return NULL;
+        }
+        rf_ptr->allocated_ack_buffer_length = frame_length;
+    }
+    memset(rf_ptr->pd_rx_ack_buffer, 0, sizeof(mac_pre_parsed_frame_t) + rf_ptr->allocated_ack_buffer_length);
+    rf_ptr->pd_rx_ack_buffer->frameLength = frame_length;
+    memcpy(mac_header_message_start_pointer(rf_ptr->pd_rx_ack_buffer), data_ptr, frame_length);
+    //Mark active ACK buffer state
+    rf_ptr->rf_pd_ack_buffer_is_in_use = true;
+    return rf_ptr->pd_rx_ack_buffer;
+}
+
+
 static void mac_set_active_event(protocol_interface_rf_mac_setup_s *rf_mac_setup, uint8_t event_type)
 {
     rf_mac_setup->active_mac_events |= (1 << event_type);
@@ -2458,21 +2501,36 @@ int8_t mcps_sap_pd_confirm_failure(void *mac_ptr)
     return eventOS_event_send(&event);
 }
 
-void mcps_sap_pd_ack(void *ack_ptr)
+int8_t mcps_sap_pd_ack(struct protocol_interface_rf_mac_setup *rf_ptr, mac_pre_parsed_frame_t *buffer)
 {
-    if (mac_tasklet_event_handler < 0  || !ack_ptr) {
-        return;
+    if (mac_tasklet_event_handler < 0  || !buffer) {
+        return -1;
+    }
+
+    if (buffer->fcf_dsn.frametype == FC_ACK_FRAME) {
+        arm_event_storage_t *event = &rf_ptr->mac_ack_event;
+        event->data.data_ptr = buffer;
+        event->data.event_data = 0;
+        event->data.event_id = 0;
+        event->data.event_type = MCPS_SAP_DATA_ACK_CNF_EVENT;
+        event->data.priority = ARM_LIB_HIGH_PRIORITY_EVENT;
+        event->data.sender = 0;
+        event->data.receiver = mac_tasklet_event_handler;
+        eventOS_event_send_user_allocated(event);
+
+        return 0;
     }
+
     arm_event_s event = {
         .receiver = mac_tasklet_event_handler,
         .sender = 0,
         .event_id = 0,
-        .data_ptr = ack_ptr,
+        .data_ptr = buffer,
         .event_type = MCPS_SAP_DATA_ACK_CNF_EVENT,
         .priority = ARM_LIB_HIGH_PRIORITY_EVENT,
     };
 
-    eventOS_event_send(&event);
+    return eventOS_event_send(&event);
 }
 
 void mcps_sap_trig_tx(void *mac_ptr)
@@ -2566,6 +2624,17 @@ void mac_mcps_buffer_queue_free(protocol_interface_rf_mac_setup_s *rf_mac_setup)
             mcps_sap_prebuild_frame_buffer_free(buffer);
         }
     }
+
+    if (rf_mac_setup->pd_rx_ack_buffer) {
+        if (rf_mac_setup->rf_pd_ack_buffer_is_in_use) {
+            eventOS_cancel(&rf_mac_setup->mac_ack_event);
+            rf_mac_setup->rf_pd_ack_buffer_is_in_use = false;
+        }
+        ns_dyn_mem_free(rf_mac_setup->pd_rx_ack_buffer);
+        rf_mac_setup->pd_rx_ack_buffer = NULL;
+        rf_mac_setup->allocated_ack_buffer_length = 0;
+    }
+
 }
 /**
  * Function return list start pointer

source/MAC/IEEE802_15_4/mac_mcps_sap.h

@@ -36,6 +36,7 @@ struct mcps_purge_s;
 struct mcps_data_req_ie_list;
 struct channel_list_s;
 struct mcps_enhanced_frame_response_s;
+struct mac_pre_parsed_frame_s;
 
 /** Address types */
 typedef enum {
@@ -100,6 +101,8 @@ void mcps_sap_pd_req_queue_write(struct protocol_interface_rf_mac_setup *rf_mac_
  */
 mac_pre_parsed_frame_t *mcps_sap_pre_parsed_frame_buffer_get(const uint8_t *data_ptr, uint16_t frame_length);
 
+mac_pre_parsed_frame_t *mcps_sap_pre_parsed_ack_buffer_get(struct protocol_interface_rf_mac_setup *rf_ptr, const uint8_t *data_ptr, uint16_t frame_length);
+
 /**
  * Forward Buffer for MAC MCPS SAP layer event handler
  */
@@ -112,7 +115,7 @@ int8_t mcps_sap_pd_confirm(void *mac_ptr);
 
 int8_t mcps_sap_pd_confirm_failure(void *mac_ptr);
 
-void mcps_sap_pd_ack(void *ack_ptr);
+int8_t mcps_sap_pd_ack(struct protocol_interface_rf_mac_setup *rf_ptr, struct mac_pre_parsed_frame_s *buffer);
 
 int8_t mac_virtual_sap_data_cb(void *identifier, struct arm_phy_sap_msg_s *message);
 

source/MAC/IEEE802_15_4/mac_pd_sap.c

@@ -631,14 +631,19 @@ static int8_t mac_data_interface_tx_done_cb(protocol_interface_rf_mac_setup_s *r
     return 0;
 }
 
-
-static int8_t mac_data_interface_tx_done_by_ack_cb(protocol_interface_rf_mac_setup_s *rf_ptr, mac_pre_parsed_frame_t *buf)
+static int8_t mac_data_interface_waiting_ack(protocol_interface_rf_mac_setup_s *rf_ptr, const mac_fcf_sequence_t *fcf_read)
 {
-
-    if (!rf_ptr->macRfRadioTxActive || !rf_ptr->active_pd_data_request || rf_ptr->active_pd_data_request->fcf_dsn.DSN != buf->fcf_dsn.DSN) {
+    if (!rf_ptr->macRfRadioTxActive || !rf_ptr->active_pd_data_request || rf_ptr->active_pd_data_request->fcf_dsn.DSN != fcf_read->DSN) {
         return -1;
     }
 
+    return 0;
+}
+
+
+static int8_t mac_data_interface_tx_done_by_ack_cb(protocol_interface_rf_mac_setup_s *rf_ptr, mac_pre_parsed_frame_t *buf)
+{
+
     timer_mac_stop(rf_ptr);
     if (buf->fcf_dsn.framePending) {
         rf_ptr->mac_tx_result = MAC_TX_DONE_PENDING;
@@ -647,7 +652,9 @@ static int8_t mac_data_interface_tx_done_by_ack_cb(protocol_interface_rf_mac_set
     }
     rf_ptr->macRfRadioTxActive = false;
     rf_ptr->macTxProcessActive = false;
-    mcps_sap_pd_ack(buf);
+    if (mcps_sap_pd_ack(rf_ptr, buf) != 0) {
+        mcps_sap_pre_parsed_frame_buffer_free(buf);
+    }
 
     if (rf_ptr->fhss_api) {
         rf_ptr->fhss_api->data_tx_done(rf_ptr->fhss_api, false, true, rf_ptr->active_pd_data_request->msduHandle);
@@ -891,22 +898,35 @@ static int8_t mac_pd_sap_generate_edfe_response(protocol_interface_rf_mac_setup_
 static mac_pre_parsed_frame_t *mac_pd_sap_allocate_receive_buffer(protocol_interface_rf_mac_setup_s *rf_ptr, const mac_fcf_sequence_t *fcf_read, arm_pd_sap_generic_ind_t *pd_data_ind)
 {
     // Unless receiving Ack, check that system has enough space to handle the new packet
-    if (fcf_read->frametype != FC_ACK_FRAME) {
-        if (!ns_monitor_packet_allocation_allowed()) {
+    mac_pre_parsed_frame_t *buffer = NULL;
+    if (fcf_read->frametype != FC_ACK_FRAME || rf_ptr->macProminousMode) {
+        if (!rf_ptr->macProminousMode && !ns_monitor_packet_allocation_allowed()) {
             // stack can not handle new packets for routing
 #ifdef __linux__
             tr_debug("Packet ingress drop buffer allocation");
 #endif
             return NULL;
         }
-    }
-    mac_pre_parsed_frame_t *buffer = mcps_sap_pre_parsed_frame_buffer_get(pd_data_ind->data_ptr, pd_data_ind->data_len);
-    if (!buffer) {
+
+        buffer = mcps_sap_pre_parsed_frame_buffer_get(pd_data_ind->data_ptr, pd_data_ind->data_len);
+        if (!buffer) {
 #ifdef __linux__
-        tr_debug("macPD buffer allocate fail %u", pd_data_ind->data_len);
+            tr_debug("macPD buffer allocate fail %u", pd_data_ind->data_len);
 #endif
-        return NULL;
+            return NULL;
+        }
+    } else {
+        //Allocate ACK buffer
+        buffer = mcps_sap_pre_parsed_ack_buffer_get(rf_ptr, pd_data_ind->data_ptr, pd_data_ind->data_len);
+        if (!buffer) {
+#ifdef __linux__
+            tr_debug("macPD ACK buffer allocate fail %u", pd_data_ind->data_len);
+#endif
+            return NULL;
+
+        }
     }
+
     //Copy Pre Parsed values
     buffer->fcf_dsn = *fcf_read;
     buffer->timestamp = mac_pd_sap_get_phy_rx_time(rf_ptr);
@@ -1034,6 +1054,13 @@ int8_t mac_pd_sap_data_cb(void *identifier, arm_phy_sap_msg_t *message)
 #endif
                 goto ERROR_HANDLER;
             }
+            if (fcf_read.frametype == FC_ACK_FRAME && mac_data_interface_waiting_ack(rf_ptr, &fcf_read)) {
+#ifdef __linux__
+                tr_debug("Drop a ACK not a proper DSN");
+#endif
+                goto ERROR_HANDLER;
+            }
+
         }
         //Allocate Buffer
         buffer = mac_pd_sap_allocate_receive_buffer(rf_ptr, &fcf_read, pd_data_ind);
@@ -1108,7 +1135,7 @@ int8_t mac_pd_sap_data_cb(void *identifier, arm_phy_sap_msg_t *message)
                             //Mark session closed
                             rf_ptr->mac_edfe_info->state = MAC_EDFE_FRAME_IDLE;
                             rf_ptr->mac_edfe_tx_active = false;
-                            if (mac_data_interface_tx_done_by_ack_cb(rf_ptr, buffer)) {
+                            if (mac_data_interface_waiting_ack(rf_ptr, &buffer->fcf_dsn) || mac_data_interface_tx_done_by_ack_cb(rf_ptr, buffer)) {
                                 mcps_sap_pre_parsed_frame_buffer_free(buffer);
                             }
                             return 0;

source/Service_Libs/utils/ns_conf.c

@@ -17,7 +17,7 @@
 
 #include "nsconfig.h"
 #include "ns_types.h"
-
+#include "eventOS_event.h"
 #include "Core/include/ns_monitor.h"
 #include "mac_api.h"    // for mcps_packet_ingress_rate_limit_by_memory
 #include "MAC/IEEE802_15_4/mac_mcps_sap.h" // for mcps_packet_ingress_rate_limit_by_memory

test/nanostack/unittest/mac/mac_mcps_sap/test_mac_mcps_sap.c

@@ -2225,7 +2225,7 @@ bool test_mcps_sap_ack_confirm()
 {
     protocol_interface_rf_mac_setup_s *rf_mac_setup = test_mac_rf_mac_class_allocate();
     mac_mcps_sap_tasklet_init();
-    mcps_sap_pd_ack(NULL);
+    mcps_sap_pd_ack(rf_mac_setup, NULL);
     uint8_t tx_buf[127];
     memset(tx_buf, 1, 127);
     mac_api_t mac_api;
@@ -2241,7 +2241,7 @@ bool test_mcps_sap_ack_confirm()
     buffer->fcf_dsn.frameVersion = FC_ACK_FRAME;
     buffer->mac_class_ptr = rf_mac_setup;
     //Test No active TX
-    mcps_sap_pd_ack(buffer);
+    mcps_sap_pd_ack(rf_mac_setup, buffer);
     buffer =  mcps_sap_pre_parsed_frame_buffer_get(tx_buf, 20);
     buffer->fcf_dsn.frameVersion = FC_ACK_FRAME;
     buffer->mac_class_ptr = rf_mac_setup;
@@ -2250,7 +2250,7 @@ bool test_mcps_sap_ack_confirm()
     buf->upper_layer_request = true;
     rf_mac_setup->active_pd_data_request = buf;
     buffer->mac_class_ptr = rf_mac_setup;
-    mcps_sap_pd_ack(buffer);
+    mcps_sap_pd_ack(rf_mac_setup, buffer);
     if (rf_mac_setup->active_pd_data_request) {
         return false;
     }

test/nanostack/unittest/mac/mac_pd_sap/test_mac_pd_sap.c

@@ -775,7 +775,7 @@ bool test_mac_ack_handler()
     }
 
     fcf.DSN = 0;
-
+    rf_ptr.macRfRadioTxActive = true;
     mac_header_helper_functions_stub.fcf = fcf;
     ret = mac_pd_sap_data_cb(&rf_ptr, &phy_message);
     if (ret != 0) {

test/nanostack/unittest/stub/mac_mcps_sap_stub.c

@@ -110,6 +110,16 @@ mac_pre_parsed_frame_t *mcps_sap_pre_parsed_frame_buffer_get(const uint8_t *data
     return mac_mcps_sap_stub.pre_parsed;
 }
 
+mac_pre_parsed_frame_t *mcps_sap_pre_parsed_ack_buffer_get(struct protocol_interface_rf_mac_setup *rf_ptr, const uint8_t *data_ptr, uint16_t frame_length)
+{
+    if (mac_mcps_sap_stub.pre_parsed) {
+        memset(mac_mcps_sap_stub.pre_parsed, 0, sizeof(mac_pre_parsed_frame_t) + frame_length);
+        mac_mcps_sap_stub.pre_parsed->frameLength = frame_length;
+        memcpy(mac_header_message_start_pointer(mac_mcps_sap_stub.pre_parsed), data_ptr, frame_length);
+    }
+    return mac_mcps_sap_stub.pre_parsed;
+}
+
 int8_t mcps_sap_pd_ind(mac_pre_parsed_frame_t *buffer)
 {
     return mac_mcps_sap_stub.int8_value;
@@ -125,8 +135,9 @@ int8_t mcps_sap_pd_confirm_failure(void *mac_ptr)
     return 0;
 }
 
-void mcps_sap_pd_ack(void *ack_ptr)
+int8_t mcps_sap_pd_ack(struct protocol_interface_rf_mac_setup *rf_ptr, struct mac_pre_parsed_frame_s *buffer)
 {
+    return 0;
 }