Implemented 802.15.4 mode setting (#2328)

* Implemented 802.15.4 mode setting

* Fixed unit tests

Author: Jarkko Paso

nanostack/mac_common_defines.h

@@ -43,6 +43,7 @@
 #define MAC_IEEE_802_15_4_MIN_MPDU_OVERHEAD             9       /**< Minimum overhead added by MAC to MPDU */
 #define MAC_IEEE_802_15_4_MAX_BEACON_OVERHEAD           75      /**< Maximum overhead which is added by the MAC for beacon */
 #define MAC_IEEE_802_15_4_MAX_PHY_PACKET_SIZE           127     /**< Maximum number of octets PHY layer is able to receive */
+#define MAC_IEEE_802_15_4G_MAX_PHY_PACKET_SIZE          2047    /**< Maximum number of octets PHY layer is able to receive */
 
 #define MAC_IEEE_802_15_4_MAX_BEACON_PAYLOAD_LENGTH \
     (MAC_IEEE_802_15_4_MAX_PHY_PACKET_SIZE - MAC_IEEE_802_15_4_MAX_BEACON_OVERHEAD) /**< Maximum size of beacon payload */

nanostack/mlme.h

@@ -264,6 +264,7 @@ typedef enum {
     macAutoRequestKeyIndex = 0x7b,  /*<The index of the key used for automatic data*/
     macDefaultKeySource = 0x7c,      /*<Default key source*/
     //NON standard extension
+    mac802_15_4Mode = 0xf6,         /*<IEEE 802.15.4 mode*/
     macDeviceDescriptionPanIDUpdate = 0xf7, /*<Thread pending link update case this will update device descrioton list pan-id to new one*/
     macTXPower = 0xf8,              /*<TX output power*/
     macCCAThreshold = 0xf9,         /*<CCA threshold*/

nanostack/platform/arm_hal_phy.h

@@ -79,7 +79,8 @@ typedef enum {
     PHY_EXTENSION_SET_RF_CONFIGURATION,  /**<  Set RF configuration using phy_rf_channel_configuration_s structure */
     PHY_EXTENSION_FILTERING_SUPPORT, /**<  Return filtering modes that can be supported by the PHY driver. See phy_link_filters_e */
     PHY_EXTENSION_SET_TX_POWER, /**<  Set TX output power which is given as percentage of maximum. 0 is the lowest possible TX power and 100 is the highest possible TX power */
-    PHY_EXTENSION_SET_CCA_THRESHOLD /**<  Set CCA threshold which is given as percentage of maximum threshold. 0 is the lowest(strictest) possible threshold and 100 is the highest possible threshold */
+    PHY_EXTENSION_SET_CCA_THRESHOLD, /**<  Set CCA threshold which is given as percentage of maximum threshold. 0 is the lowest(strictest) possible threshold and 100 is the highest possible threshold */
+    PHY_EXTENSION_SET_802_15_4_MODE /**<  Set IEEE 802.15.4 mode as defined by phy_802_15_4_mode_t*/
 } phy_extension_type_e;
 
 /** Address types */
@@ -172,6 +173,15 @@ typedef enum {
     MODULATION_INDEX_UNDEFINED  ///< Modulation index undefined
 } phy_modulation_index_e;
 
+/**
+ * @brief enum phy_802_15_4_mode_t IEEE 802.15.4 mode
+ *
+ */
+typedef enum {
+    IEEE_802_15_4_2011,    /**<IEEE 802.15.4-2011*/
+    IEEE_802_15_4G_2012    /**<IEEE 802.15.4g-2012*/
+} phy_802_15_4_mode_t;
+
 /** Channel configuration */
 typedef struct phy_rf_channel_configuration_s {
     uint32_t channel_0_center_frequency;        ///< Center frequency

source/6LoWPAN/ws/ws_bootstrap.c

@@ -1892,6 +1892,12 @@ int ws_bootstrap_restart_delayed(int8_t interface_id)
 int ws_bootstrap_set_rf_config(protocol_interface_info_entry_t *cur, phy_rf_channel_configuration_s rf_configs)
 {
     mlme_set_t set_request;
+    // Set MAC mode
+    phy_802_15_4_mode_t mac_mode = IEEE_802_15_4G_2012;
+    set_request.attr = mac802_15_4Mode;
+    set_request.value_pointer = &mac_mode;
+    set_request.value_size = sizeof(phy_802_15_4_mode_t);
+    cur->mac_api->mlme_req(cur->mac_api, MLME_SET, &set_request);
     // Set RF configuration
     set_request.attr = macRfConfiguration;
     set_request.value_pointer = &rf_configs;

source/MAC/IEEE802_15_4/mac_defines.h

@@ -225,6 +225,8 @@ typedef struct protocol_interface_rf_mac_setup {
     uint8_t aUnitBackoffPeriod;
     uint8_t number_of_csma_ca_periods;  /**< Number of CSMA-CA periods */
     uint16_t multi_cca_interval;        /**< Length of the additional CSMA-CA period(s) in microseconds */
+    uint16_t phy_mtu_size;
+    phy_802_15_4_mode_t current_mac_mode;
     /* Indirect queue parameters */
     struct mac_pre_build_frame *indirect_pd_data_request_queue;
     struct mac_pre_build_frame enhanced_ack_buffer;

source/MAC/IEEE802_15_4/mac_mcps_sap.c

@@ -228,8 +228,8 @@ void mcps_sap_data_req_handler_ext(protocol_interface_rf_mac_setup_s *rf_mac_set
         goto verify_status;
     }
 
-    if ((data_req->msduLength + ie_header_length + ie_payload_length) > rf_mac_setup->dev_driver->phy_driver->phy_MTU - MAC_DATA_PACKET_MIN_HEADER_LENGTH) {
-        tr_debug("packet %u, %u", data_req->msduLength, rf_mac_setup->dev_driver->phy_driver->phy_MTU);
+    if ((data_req->msduLength + ie_header_length + ie_payload_length) > rf_mac_setup->phy_mtu_size - MAC_DATA_PACKET_MIN_HEADER_LENGTH) {
+        tr_debug("packet %u, %u", data_req->msduLength, rf_mac_setup->phy_mtu_size);
         status = MLME_FRAME_TOO_LONG;
         goto verify_status;
     }
@@ -358,7 +358,7 @@ void mcps_sap_data_req_handler_ext(protocol_interface_rf_mac_setup_s *rf_mac_set
 static int8_t mac_virtual_data_req_handler(protocol_interface_rf_mac_setup_s *rf_mac_setup, const uint8_t *data_ptr, uint16_t data_length)
 {
 
-    if (!rf_mac_setup->macUpState || data_length > rf_mac_setup->dev_driver->phy_driver->phy_MTU) {
+    if (!rf_mac_setup->macUpState || data_length > rf_mac_setup->phy_mtu_size) {
         return -1;
     }
 
@@ -1576,7 +1576,7 @@ static int8_t mcps_generic_packet_build(protocol_interface_rf_mac_setup_s *rf_pt
     uint16_t mac_payload_length = frame_length;
 
     if (mac_payload_length > MAC_IEEE_802_15_4_MAX_MAC_SAFE_PAYLOAD_SIZE &&
-            dev_driver->phy_MTU == MAC_IEEE_802_15_4_MAX_PHY_PACKET_SIZE) {
+            rf_ptr->phy_mtu_size == MAC_IEEE_802_15_4_MAX_PHY_PACKET_SIZE) {
         /* IEEE 802.15.4-2003 only allowed unsecured payloads up to 102 bytes
         * (always leaving room for maximum MAC overhead).
         * IEEE 802.15.4-2006 allows bigger if MAC header is small enough, but
@@ -1596,8 +1596,8 @@ static int8_t mcps_generic_packet_build(protocol_interface_rf_mac_setup_s *rf_pt
 
     //Add MHR length to total length
     frame_length += buffer->mac_header_length_with_security + buffer->security_mic_len;
-    if ((frame_length) > dev_driver->phy_MTU - 2) {
-        tr_debug("Too Long %u, %u pa %u header %u mic %u", frame_length, mac_payload_length, buffer->mac_header_length_with_security,  buffer->security_mic_len, dev_driver->phy_MTU);
+    if ((frame_length) > rf_ptr->phy_mtu_size - 2) {
+        tr_debug("Too Long %u, %u pa %u header %u mic %u", frame_length, mac_payload_length, buffer->mac_header_length_with_security,  buffer->security_mic_len, rf_ptr->phy_mtu_size);
         buffer->status = MLME_FRAME_TOO_LONG;
         //decrement security counter
         if (key_desc) {
@@ -1745,8 +1745,8 @@ int8_t mcps_generic_ack_build(protocol_interface_rf_mac_setup_s *rf_ptr, bool in
     //Add MHR length to total length
     frame_length += buffer->mac_header_length_with_security + buffer->security_mic_len;
     uint16_t ack_mtu_size;
-    if (ENHANCED_ACK_MAX_LENGTH > dev_driver->phy_MTU) {
-        ack_mtu_size = dev_driver->phy_MTU;
+    if (ENHANCED_ACK_MAX_LENGTH > rf_ptr->phy_mtu_size) {
+        ack_mtu_size = rf_ptr->phy_mtu_size;
     } else {
         ack_mtu_size = ENHANCED_ACK_MAX_LENGTH;
     }

source/MAC/IEEE802_15_4/mac_mlme.c

@@ -69,6 +69,7 @@ static void mac_mlme_timer_cb(int8_t timer_id, uint16_t slots);
 static void mac_mlme_start_confirm_handler(protocol_interface_rf_mac_setup_s *rf_ptr, const mlme_start_conf_t *conf);
 static void mac_mlme_scan_confirm_handler(protocol_interface_rf_mac_setup_s *rf_ptr, const mlme_scan_conf_t *conf);
 static int mac_mlme_set_symbol_rate(protocol_interface_rf_mac_setup_s *rf_mac_setup);
+static int mac_mlme_allocate_tx_buffers(protocol_interface_rf_mac_setup_s *rf_mac_setup, arm_device_driver_list_s *dev_driver, uint16_t mtu_size);
 
 static void mac_mlme_energy_scan_start(protocol_interface_rf_mac_setup_s *rf_mac_setup, uint8_t channel)
 {
@@ -767,6 +768,29 @@ int8_t mac_mlme_set_req(protocol_interface_rf_mac_setup_s *rf_mac_setup, const m
                 memcpy(rf_mac_setup->coord_long_address, set_req->value_pointer, 8);
             }
             return 0;
+        case mac802_15_4Mode:
+            pu8 = (uint8_t *) set_req->value_pointer;
+            if (rf_mac_setup->current_mac_mode == *pu8) {
+                return -1;
+            }
+            rf_mac_setup->current_mac_mode = *pu8;
+            rf_mac_setup->dev_driver->phy_driver->extension(PHY_EXTENSION_SET_802_15_4_MODE, pu8);
+            uint16_t new_mtu_size = MAC_IEEE_802_15_4_MAX_PHY_PACKET_SIZE;
+            if (*pu8 == IEEE_802_15_4G_2012) {
+                new_mtu_size = MAC_IEEE_802_15_4G_MAX_PHY_PACKET_SIZE;
+            }
+            mac_api_t *mac_api = get_sw_mac_api(rf_mac_setup);
+            if (rf_mac_setup->dev_driver->phy_driver->phy_MTU > new_mtu_size) {
+                mac_api->phyMTU = rf_mac_setup->phy_mtu_size = new_mtu_size;
+            } else {
+                mac_api->phyMTU = rf_mac_setup->phy_mtu_size = rf_mac_setup->dev_driver->phy_driver->phy_MTU;
+            }
+            if (mac_mlme_allocate_tx_buffers(rf_mac_setup, rf_mac_setup->dev_driver, rf_mac_setup->phy_mtu_size)) {
+                tr_err("Failed to reallocate TX buffers");
+                return -1;
+            }
+            tr_debug("Set MAC mode to %s, MTU size: %u", *pu8 == IEEE_802_15_4G_2012 ? "IEEE 802.15.4G-2012" : "IEEE 802.15.4-2011", rf_mac_setup->phy_mtu_size);
+            return 0;
         case macTXPower:
             pu8 = (uint8_t *) set_req->value_pointer;
             rf_mac_setup->dev_driver->phy_driver->extension(PHY_EXTENSION_SET_TX_POWER, pu8);
@@ -1067,9 +1091,29 @@ static int mac_mlme_set_symbol_rate(protocol_interface_rf_mac_setup_s *rf_mac_se
     return -1;
 }
 
-protocol_interface_rf_mac_setup_s *mac_mlme_data_base_allocate(uint8_t *mac64, arm_device_driver_list_s *dev_driver, mac_description_storage_size_t *storage_sizes)
+static int mac_mlme_allocate_tx_buffers(protocol_interface_rf_mac_setup_s *rf_mac_setup, arm_device_driver_list_s *dev_driver, uint16_t mtu_size)
 {
+    ns_dyn_mem_free(rf_mac_setup->dev_driver_tx_buffer.buf);
+    ns_dyn_mem_free(rf_mac_setup->mac_beacon_payload);
     uint16_t total_length = 0;
+    //Allocate tx buffer by given MTU + header + tail
+    total_length = mtu_size;
+    total_length += (dev_driver->phy_driver->phy_header_length + dev_driver->phy_driver->phy_tail_length);
+    rf_mac_setup->dev_driver_tx_buffer.buf = ns_dyn_mem_alloc(total_length);
+    if (!rf_mac_setup->dev_driver_tx_buffer.buf) {
+        return -1;
+    }
+    //allocate Beacon Payload buffer
+    rf_mac_setup->max_beacon_payload_length = mtu_size - MAC_IEEE_802_15_4_MAX_BEACON_OVERHEAD;
+    rf_mac_setup->mac_beacon_payload = ns_dyn_mem_alloc(rf_mac_setup->max_beacon_payload_length);
+    if (!rf_mac_setup->mac_beacon_payload) {
+        return -1;
+    }
+    return 0;
+}
+
+protocol_interface_rf_mac_setup_s *mac_mlme_data_base_allocate(uint8_t *mac64, arm_device_driver_list_s *dev_driver, mac_description_storage_size_t *storage_sizes, uint16_t mtu_size)
+{
     //allocate security
     if (!dev_driver || !mac64 || !dev_driver->phy_driver || !storage_sizes) {
         return NULL;
@@ -1102,20 +1146,9 @@ protocol_interface_rf_mac_setup_s *mac_mlme_data_base_allocate(uint8_t *mac64, a
         mac_mlme_data_base_deallocate(entry);
         return NULL;
     }
+    entry->phy_mtu_size = mtu_size;
 
-    //Allocate tx buffer by given MTU + header + tail
-    total_length = dev_driver->phy_driver->phy_MTU;
-    total_length += (dev_driver->phy_driver->phy_header_length + dev_driver->phy_driver->phy_tail_length);
-    entry->dev_driver_tx_buffer.buf = ns_dyn_mem_alloc(total_length);
-    if (!entry->dev_driver_tx_buffer.buf) {
-        mac_mlme_data_base_deallocate(entry);
-        return NULL;
-    }
-
-    //allocate Beacon Payload buffer
-    entry->max_beacon_payload_length = dev_driver->phy_driver->phy_MTU - MAC_IEEE_802_15_4_MAX_BEACON_OVERHEAD;
-    entry->mac_beacon_payload = ns_dyn_mem_alloc(entry->max_beacon_payload_length);
-    if (!entry->mac_beacon_payload) {
+    if (mac_mlme_allocate_tx_buffers(entry, dev_driver, mtu_size)) {
         mac_mlme_data_base_deallocate(entry);
         return NULL;
     }

source/MAC/IEEE802_15_4/mac_mlme.h

@@ -106,7 +106,7 @@ void mac_mlme_event_cb(void *mac_ptr);
 
 void mac_mlme_set_active_state(struct protocol_interface_rf_mac_setup *entry, bool new_state);
 
-struct protocol_interface_rf_mac_setup *mac_mlme_data_base_allocate(uint8_t *mac64, struct arm_device_driver_list *dev_driver, struct mac_description_storage_size_s *storage_sizes);
+struct protocol_interface_rf_mac_setup *mac_mlme_data_base_allocate(uint8_t *mac64, struct arm_device_driver_list *dev_driver, struct mac_description_storage_size_s *storage_sizes, uint16_t mtu_size);
 void mac_mlme_data_base_deallocate(struct protocol_interface_rf_mac_setup *rf_mac);
 
 uint8_t mac_mlme_set_new_sqn(struct protocol_interface_rf_mac_setup *rf_setup);

source/MAC/IEEE802_15_4/mac_pd_sap.c

@@ -111,7 +111,7 @@ uint32_t mac_csma_backoff_get(protocol_interface_rf_mac_setup_s *rf_mac_setup)
             backoff_in_us += ((rf_mac_setup->multi_cca_interval * (rf_mac_setup->number_of_csma_ca_periods - 1)) - backoff_in_us);
         }
         if (rf_mac_setup->mac_tx_retry) {
-            backoff_in_us += rf_mac_setup->fhss_api->get_retry_period(rf_mac_setup->fhss_api, rf_mac_setup->active_pd_data_request->DstAddr, rf_mac_setup->dev_driver->phy_driver->phy_MTU);
+            backoff_in_us += rf_mac_setup->fhss_api->get_retry_period(rf_mac_setup->fhss_api, rf_mac_setup->active_pd_data_request->DstAddr, rf_mac_setup->phy_mtu_size);
         }
     }
     return backoff_in_us;

source/MAC/IEEE802_15_4/sw_mac.c

@@ -31,6 +31,9 @@
 #include "mac_fhss_callbacks.h"
 #include "eventOS_callback_timer.h"
 #include "common_functions.h"
+#include "ns_trace.h"
+
+#define TRACE_GROUP "swm"
 
 //TODO: create linked list of created MACs
 
@@ -96,13 +99,28 @@ mac_api_t *ns_sw_mac_create(int8_t rf_driver_id, mac_description_storage_size_t
     memset(this, 0, sizeof(mac_api_t));
     this->parent_id = -1;
     mac_store.dev_driver = driver;
-    mac_store.setup = mac_mlme_data_base_allocate(mac_store.dev_driver->phy_driver->PHY_MAC, mac_store.dev_driver, storage_sizes);
+
+    // Set default MTU size to 127 unless it is too much for PHY driver
+    if (driver->phy_driver->phy_MTU > MAC_IEEE_802_15_4_MAX_PHY_PACKET_SIZE) {
+        this->phyMTU = MAC_IEEE_802_15_4_MAX_PHY_PACKET_SIZE;
+    } else {
+        this->phyMTU = driver->phy_driver->phy_MTU;
+    }
+
+    mac_store.setup = mac_mlme_data_base_allocate(mac_store.dev_driver->phy_driver->PHY_MAC, mac_store.dev_driver, storage_sizes, this->phyMTU);
 
     if (!mac_store.setup) {
         ns_dyn_mem_free(this);
         return NULL;
     }
 
+    // Set MAC mode to PHY driver
+    mac_store.setup->current_mac_mode = IEEE_802_15_4_2011;
+    if (mac_store.setup->dev_driver->phy_driver->extension) {
+        mac_store.setup->dev_driver->phy_driver->extension(PHY_EXTENSION_SET_802_15_4_MODE, (uint8_t *) &mac_store.setup->current_mac_mode);
+    }
+    tr_debug("Set MAC mode to %s, MTU size: %u", "IEEE 802.15.4-2011", mac_store.setup->phy_mtu_size);
+
     arm_net_phy_init(driver->phy_driver, &sw_mac_net_phy_rx, &sw_mac_net_phy_tx_done);
     arm_net_virtual_config_rx_cb_set(driver->phy_driver, &sw_mac_net_phy_config_parser);
     arm_net_virtual_confirmation_rx_cb_set(driver->phy_driver, &mac_mlme_virtual_confirmation_handle);
@@ -116,10 +134,8 @@ mac_api_t *ns_sw_mac_create(int8_t rf_driver_id, mac_description_storage_size_t
     this->mac64_get = &macext_mac64_address_get;
     this->mac64_set = &macext_mac64_address_set;
     this->mac_storage_sizes_get = &sw_mac_storage_decription_sizes_get;
-    this->phyMTU = driver->phy_driver->phy_MTU;
 
     mac_store.mac_api = this;
-
     mac_store.virtual_driver = NULL;
     return this;
 }
@@ -279,8 +295,8 @@ static int8_t ns_sw_mac_api_enable_mcps_ext(mac_api_t *api, mcps_data_indication
         ns_dyn_mem_free(mac_store.setup->dev_driver_tx_buffer.enhanced_ack_buf);
 
         uint16_t total_length;
-        if (ENHANCED_ACK_MAX_LENGTH > dev_driver->phy_driver->phy_MTU) {
-            total_length = dev_driver->phy_driver->phy_MTU;
+        if (ENHANCED_ACK_MAX_LENGTH > mac_store.setup->phy_mtu_size) {
+            total_length = mac_store.setup->phy_mtu_size;
         } else {
             total_length = ENHANCED_ACK_MAX_LENGTH;
         }

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

@@ -245,6 +245,7 @@ static protocol_interface_rf_mac_setup_s *test_mac_rf_mac_class_allocate(void)
     memset(rf_mac_setup, 0, sizeof(protocol_interface_rf_mac_setup_s));
     rf_mac_setup->dev_driver_tx_buffer.buf = malloc(128);
     rf_mac_setup->dev_driver_tx_buffer.len = 127;
+    rf_mac_setup->phy_mtu_size = 127;
 
 
     arm_device_driver_list_s *driver = malloc(sizeof(arm_device_driver_list_s));
@@ -825,6 +826,7 @@ bool test_mac_mcps_data_confirmation()
 
     // Test FHSS channel retry
     rf_mac_setup->fhss_api = ns_fhss_create(0, 0, 0);
+    fhss_config_stub.fhss_api_ptr.check_tx_conditions = &fhss_check_tx_conditions_callback;
     nsdynmemlib_stub.returnCounter = 3;
     data_req.TxAckReq = true;
     fhss_tx_condition = true;