FHSS: removed unnecessary state set handler

Jarkko Paso · Jarkko Paso · commit 316b007c4aae · 2018-02-14T13:30:52.000+02:00
diff --git a/source/Service_Libs/fhss/fhss.c b/source/Service_Libs/fhss/fhss.c
@@ -728,12 +728,16 @@ void fhss_failed_list_free(fhss_structure_t *fhss_structure)
     }
 }
 
-static int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)
+static void fhss_handle_state_set(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)
 {
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return;
+    }
     // State is already set
     if (fhss_structure->fhss_state == fhss_state) {
         tr_debug("Synch same state %u", fhss_state);
-        return -1;
+        return;
     }
 
     if (fhss_state == FHSS_UNSYNCHRONIZED) {
@@ -747,12 +751,12 @@ static int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states f
         // Do not synchronize to current pan
         if (fhss_structure->synch_panid == pan_id) {
             tr_debug("Synch same panid %u", pan_id);
-            return -1;
+            return;
         }
         if (fhss_structure->fhss_scramble_table == NULL) {
             if (fhss_generate_scramble_table(fhss_structure)) {
                 tr_error("Failed to generate scramble table");
-                return -1;
+                return;
             }
         }
         uint32_t datarate = fhss_structure->callbacks.read_datarate(fhss_structure->fhss_api);
@@ -778,10 +782,11 @@ static int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states f
             fhss_start_timer(fhss_structure, fhss_structure->synch_configuration.fhss_superframe_length, fhss_superframe_handler);
         } else {
             tr_error("Synch info not found");
-            return -1;
+            return;
         }
     }
-    return 0;
+    fhss_structure->fhss_state = fhss_state;
+    return;
 }
 
 static void fhss_destroy_scramble_table(fhss_structure_t *fhss_structure)
@@ -959,7 +964,7 @@ int fhss_set_callbacks(fhss_structure_t *fhss_structure)
     fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_cb;
     fhss_structure->fhss_api->data_tx_done = &fhss_data_tx_done_callback;
     fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_cb;
-    fhss_structure->fhss_api->synch_state_set = &fhss_synch_state_set_cb;
+    fhss_structure->fhss_api->synch_state_set = &fhss_handle_state_set;
     fhss_structure->fhss_api->read_timestamp = &fhss_read_timestamp_cb;
     fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_cb;
     fhss_structure->fhss_api->write_synch_info = &fhss_write_synch_info_callback;
@@ -968,6 +973,5 @@ int fhss_set_callbacks(fhss_structure_t *fhss_structure)
     fhss_structure->update_channel = fhss_update_channel_callback;
     fhss_structure->update_superframe = fhss_superframe_callback;
     fhss_structure->read_superframe_timeout = fhss_get_sf_timeout_callback;
-    fhss_structure->handle_state_set = fhss_handle_state_set;
     return 0;
 }
diff --git a/source/Service_Libs/fhss/fhss_common.c b/source/Service_Libs/fhss/fhss_common.c
@@ -152,7 +152,7 @@ int8_t fhss_disable(fhss_structure_t *fhss_structure)
     if (!fhss_structure) {
         return -1;
     }
-    fhss_structure->handle_state_set(fhss_structure, FHSS_UNSYNCHRONIZED, 0);
+    fhss_structure->fhss_api->synch_state_set(fhss_structure->fhss_api, FHSS_UNSYNCHRONIZED, 0);
     ns_dyn_mem_free(fhss_structure->ws);
     ns_dyn_mem_free(fhss_structure);
     fhss_structure = 0;
diff --git a/source/Service_Libs/fhss/fhss_common.h b/source/Service_Libs/fhss/fhss_common.h
@@ -43,15 +43,6 @@ typedef void fhss_update_superframe_cb(fhss_structure_t *fhss_structure);
  */
 typedef uint32_t fhss_read_superframe_timeout_cb(fhss_structure_t *fhss_structure);
 
-/**
- * @brief Set FHSS state.
- * @param fhss_structure FHSS structure.
- * @param fhss_state FHSS state to set.
- * @param pan_id Network PAN id.
- * @return 0 Success, -1 Failure.
- */
-typedef int fhss_handle_state_set_cb(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id);
-
 union fhss_conf {
     fhss_configuration_t fhss_configuration;
     fhss_ws_configuration_t fhss_ws_configuration;
@@ -121,7 +112,6 @@ struct fhss_structure
     fhss_update_channel_cb *update_channel;    /**< Update listening channel */
     fhss_update_superframe_cb *update_superframe;    /**< Update superframe */
     fhss_read_superframe_timeout_cb *read_superframe_timeout;    /**< Read next FHSS superframe timeout length */
-    fhss_handle_state_set_cb *handle_state_set;    /**< Set FHSS state */
 };
 
 fhss_structure_t *fhss_allocate_instance(fhss_api_t *fhss_api, const fhss_timer_t *fhss_timer);
diff --git a/source/Service_Libs/fhss/fhss_mac_interface.c b/source/Service_Libs/fhss/fhss_mac_interface.c
@@ -123,18 +123,6 @@ bool fhss_data_tx_fail_cb(const fhss_api_t *api, uint8_t handle, int frame_type)
     return true;
 }
 
-void fhss_synch_state_set_cb(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)
-{
-    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
-    if (!fhss_structure) {
-        return;
-    }
-    if (fhss_structure->handle_state_set) {
-        fhss_structure->handle_state_set(fhss_structure, fhss_state, pan_id);
-    }
-    fhss_structure->fhss_state = fhss_state;
-}
-
 uint32_t fhss_read_timestamp_cb(const fhss_api_t *api)
 {
     fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
diff --git a/source/Service_Libs/fhss/fhss_mac_interface.h b/source/Service_Libs/fhss/fhss_mac_interface.h
@@ -22,7 +22,6 @@ bool fhss_is_broadcast_channel_cb(const fhss_api_t *api);
 bool fhss_use_broadcast_queue_cb(const fhss_api_t *api, bool is_broadcast_addr, int frame_type);
 void fhss_receive_frame_cb(const fhss_api_t *api, uint16_t pan_id, uint8_t *source_address, uint32_t timestamp, uint8_t *synch_info, int frame_type);
 bool fhss_data_tx_fail_cb(const fhss_api_t *api, uint8_t handle, int frame_type);
-void fhss_synch_state_set_cb(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id);
 uint32_t fhss_read_timestamp_cb(const fhss_api_t *api);
 uint16_t fhss_get_retry_period_cb(const fhss_api_t *api, uint8_t *destination_address, uint16_t phy_mtu);
 int fhss_init_callbacks_cb(const fhss_api_t *api, fhss_callback_t *callbacks);
diff --git a/source/Service_Libs/fhss/fhss_ws.c b/source/Service_Libs/fhss/fhss_ws.c
@@ -107,9 +107,13 @@ static uint32_t fhss_ws_get_sf_timeout_callback(fhss_structure_t *fhss_structure
     return fhss_structure->fhss_conf.fhss_ws_configuration.fhss_uc_dwell_interval * 1000;
 }
 
-static int fhss_ws_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)
+static void fhss_ws_handle_state_set(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)
 {
     (void) pan_id;
+    fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);
+    if (!fhss_structure) {
+        return;
+    }
     if (fhss_state == FHSS_SYNCHRONIZED) {
         uint32_t fhss_broadcast_interval = fhss_structure->fhss_conf.fhss_ws_configuration.fhss_broadcast_interval;
         uint8_t fhss_bc_dwell_interval = fhss_structure->fhss_conf.fhss_ws_configuration.fhss_bc_dwell_interval;
@@ -123,7 +127,7 @@ static int fhss_ws_handle_state_set(fhss_structure_t *fhss_structure, fhss_state
     }
 
     fhss_structure->fhss_state = fhss_state;
-    return 0;
+    return;
 }
 
 static void fhss_ws_superframe_callback(fhss_structure_t *fhss_structure)
@@ -239,7 +243,7 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
     fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_cb;
     fhss_structure->fhss_api->data_tx_done = &fhss_ws_data_tx_done_callback;
     fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_cb;
-    fhss_structure->fhss_api->synch_state_set = &fhss_synch_state_set_cb;
+    fhss_structure->fhss_api->synch_state_set = &fhss_ws_handle_state_set;
     fhss_structure->fhss_api->read_timestamp = &fhss_read_timestamp_cb;
     fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_cb;
     fhss_structure->fhss_api->write_synch_info = &fhss_ws_write_synch_info_callback;
@@ -248,7 +252,6 @@ int fhss_ws_set_callbacks(fhss_structure_t *fhss_structure)
     fhss_structure->update_channel = fhss_ws_update_uc_channel_callback;
     fhss_structure->update_superframe = fhss_ws_superframe_callback;
     fhss_structure->read_superframe_timeout = fhss_ws_get_sf_timeout_callback;
-    fhss_structure->handle_state_set = fhss_ws_handle_state_set;
     fhss_structure->ws = ns_dyn_mem_alloc(sizeof(fhss_ws_t));
     if (!fhss_structure->ws) {
         return -1;
diff --git a/test/nanostack/unittest/service_libs/fhss_mac_interface/fhssmaciftest.cpp b/test/nanostack/unittest/service_libs/fhss_mac_interface/fhssmaciftest.cpp
@@ -49,11 +49,6 @@ TEST(fhss_mac_if, test_fhss_data_tx_fail_cb)
     CHECK(test_fhss_data_tx_fail_cb());
 }
 
-TEST(fhss_mac_if, test_fhss_synch_state_set_cb)
-{
-    CHECK(test_fhss_synch_state_set_cb());
-}
-
 TEST(fhss_mac_if, test_fhss_read_timestamp_cb)
 {
     CHECK(test_fhss_read_timestamp_cb());
diff --git a/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.c b/test/nanostack/unittest/service_libs/fhss_mac_interface/test_fhss_mac_interface.c
@@ -124,6 +124,7 @@ bool test_fhss_data_tx_fail_cb()
 {
     fhss_api_t fhss_api;
     uint8_t handle = 1;
+    fhss_stub.fhss_struct.fhss_state = FHSS_SYNCHRONIZED;
 
     // By setting bool value false, fhss_struct can not be found
     fhss_stub.bool_value = false;
@@ -158,44 +159,6 @@ bool test_fhss_data_tx_fail_cb()
 
     return true;
 }
-bool test_fhss_synch_state_set_cb()
-{
-	uint16_t panid = 0xacdc;
-    fhss_api_t fhss_api;
-    fhss_timer_t platform_functions;
-    fhss_stub.fhss_struct.callbacks.read_datarate = mac_read_phy_datarate;
-    fhss_stub.fhss_struct.callbacks.read_mac_address = mac_read_64bit_mac_address;
-    fhss_stub.fhss_struct.synch_panid = 0;
-    fhss_stub.fhss_struct.own_hop = 1;
-    platform_functions.fhss_get_timestamp = fhss_get_timestamp_stub;
-    fhss_stub.fhss_struct.platform_functions = platform_functions;
-    fhss_api.read_timestamp = fhss_read_timestamp_cb;
-
-    // By setting bool value false, fhss_struct can not be found
-    fhss_stub.bool_value = false;
-    fhss_synch_state_set_cb(&fhss_api, FHSS_UNSYNCHRONIZED, 0);
-    // By setting bool value true, fhss_struct can be found
-    fhss_stub.bool_value = true;
-    // Test setting current state again
-    fhss_stub.fhss_struct.fhss_state = FHSS_SYNCHRONIZED;
-    fhss_synch_state_set_cb(&fhss_api, FHSS_SYNCHRONIZED, 0);
-    // Test setting unsynchronized state
-    fhss_synch_state_set_cb(&fhss_api, FHSS_UNSYNCHRONIZED, 0);
-    // Test setting synchronized state
-    fhss_stub.fhss_struct.fhss_state = FHSS_UNSYNCHRONIZED;
-    fhss_synch_state_set_cb(&fhss_api, FHSS_SYNCHRONIZED, 0);
-    // Test finding beacon info
-    fhss_stub.beacon_info.pan_id = panid;
-    fhss_synch_state_set_cb(&fhss_api, FHSS_SYNCHRONIZED, panid);
-    // Test if device is synch root
-    fhss_stub.fhss_struct.own_hop = 0;
-    fhss_stub.fhss_struct.synch_panid = 0;
-    fhss_stub.beacon_info.pan_id = 1;
-    fhss_stub.fhss_struct.fhss_state = FHSS_UNSYNCHRONIZED;
-    fhss_synch_state_set_cb(&fhss_api, FHSS_SYNCHRONIZED, panid);
-
-    return true;
-}
 bool test_fhss_read_timestamp_cb()
 {
     fhss_api_t fhss_api;
diff --git a/test/nanostack/unittest/stub/fhss_stub.c b/test/nanostack/unittest/stub/fhss_stub.c
@@ -190,7 +190,7 @@ int fhss_generate_scramble_table(fhss_structure_t *fhss_structure)
     return 0;
 }
 
-int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)
+int fhss_handle_state_set(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)
 {
     return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -728,12 +728,16 @@ void fhss_failed_list_free(fhss_structure_t *fhss_structure)`
`728`	`728`	`}`
`729`	`729`	`}`
`730`	`730`
`731`		`-static int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)`
	`731`	`+static void fhss_handle_state_set(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)`
`732`	`732`	`{`
	`733`	`+ fhss_structure_t *fhss_structure = fhss_get_object_with_api(api);`
	`734`	`+ if (!fhss_structure) {`
	`735`	`+ return;`
	`736`	`+ }`
`733`	`737`	`// State is already set`
`734`	`738`	`if (fhss_structure->fhss_state == fhss_state) {`
`735`	`739`	`tr_debug("Synch same state %u", fhss_state);`
`736`		`- return -1;`
	`740`	`+ return;`
`737`	`741`	`}`
`738`	`742`
`739`	`743`	`if (fhss_state == FHSS_UNSYNCHRONIZED) {`
`@@ -747,12 +751,12 @@ static int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states f`
`747`	`751`	`// Do not synchronize to current pan`
`748`	`752`	`if (fhss_structure->synch_panid == pan_id) {`
`749`	`753`	`tr_debug("Synch same panid %u", pan_id);`
`750`		`- return -1;`
	`754`	`+ return;`
`751`	`755`	`}`
`752`	`756`	`if (fhss_structure->fhss_scramble_table == NULL) {`
`753`	`757`	`if (fhss_generate_scramble_table(fhss_structure)) {`
`754`	`758`	`tr_error("Failed to generate scramble table");`
`755`		`- return -1;`
	`759`	`+ return;`
`756`	`760`	`}`
`757`	`761`	`}`
`758`	`762`	`uint32_t datarate = fhss_structure->callbacks.read_datarate(fhss_structure->fhss_api);`
`@@ -778,10 +782,11 @@ static int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states f`
`778`	`782`	`fhss_start_timer(fhss_structure, fhss_structure->synch_configuration.fhss_superframe_length, fhss_superframe_handler);`
`779`	`783`	`} else {`
`780`	`784`	`tr_error("Synch info not found");`
`781`		`- return -1;`
	`785`	`+ return;`
`782`	`786`	`}`
`783`	`787`	`}`
`784`		`- return 0;`
	`788`	`+ fhss_structure->fhss_state = fhss_state;`
	`789`	`+ return;`
`785`	`790`	`}`
`786`	`791`
`787`	`792`	`static void fhss_destroy_scramble_table(fhss_structure_t *fhss_structure)`
`@@ -959,7 +964,7 @@ int fhss_set_callbacks(fhss_structure_t *fhss_structure)`
`959`	`964`	`fhss_structure->fhss_api->receive_frame = &fhss_receive_frame_cb;`
`960`	`965`	`fhss_structure->fhss_api->data_tx_done = &fhss_data_tx_done_callback;`
`961`	`966`	`fhss_structure->fhss_api->data_tx_fail = &fhss_data_tx_fail_cb;`
`962`		`- fhss_structure->fhss_api->synch_state_set = &fhss_synch_state_set_cb;`
	`967`	`+ fhss_structure->fhss_api->synch_state_set = &fhss_handle_state_set;`
`963`	`968`	`fhss_structure->fhss_api->read_timestamp = &fhss_read_timestamp_cb;`
`964`	`969`	`fhss_structure->fhss_api->get_retry_period = &fhss_get_retry_period_cb;`
`965`	`970`	`fhss_structure->fhss_api->write_synch_info = &fhss_write_synch_info_callback;`
`@@ -968,6 +973,5 @@ int fhss_set_callbacks(fhss_structure_t *fhss_structure)`
`968`	`973`	`fhss_structure->update_channel = fhss_update_channel_callback;`
`969`	`974`	`fhss_structure->update_superframe = fhss_superframe_callback;`
`970`	`975`	`fhss_structure->read_superframe_timeout = fhss_get_sf_timeout_callback;`
`971`		`- fhss_structure->handle_state_set = fhss_handle_state_set;`
`972`	`976`	`return 0;`
`973`	`977`	`}`
Original file line number	Diff line number	Diff line change
`@@ -152,7 +152,7 @@ int8_t fhss_disable(fhss_structure_t *fhss_structure)`
`152`	`152`	`if (!fhss_structure) {`
`153`	`153`	`return -1;`
`154`	`154`	`}`
`155`		`- fhss_structure->handle_state_set(fhss_structure, FHSS_UNSYNCHRONIZED, 0);`
	`155`	`+ fhss_structure->fhss_api->synch_state_set(fhss_structure->fhss_api, FHSS_UNSYNCHRONIZED, 0);`
`156`	`156`	`ns_dyn_mem_free(fhss_structure->ws);`
`157`	`157`	`ns_dyn_mem_free(fhss_structure);`
`158`	`158`	`fhss_structure = 0;`
Original file line number	Diff line number	Diff line change
`@@ -49,11 +49,6 @@ TEST(fhss_mac_if, test_fhss_data_tx_fail_cb)`
`49`	`49`	`CHECK(test_fhss_data_tx_fail_cb());`
`50`	`50`	`}`
`51`	`51`
`52`		`-TEST(fhss_mac_if, test_fhss_synch_state_set_cb)`
`53`		`-{`
`54`		`- CHECK(test_fhss_synch_state_set_cb());`
`55`		`-}`
`56`		`-`
`57`	`52`	`TEST(fhss_mac_if, test_fhss_read_timestamp_cb)`
`58`	`53`	`{`
`59`	`54`	`CHECK(test_fhss_read_timestamp_cb());`
Original file line number	Diff line number	Diff line change
`@@ -190,7 +190,7 @@ int fhss_generate_scramble_table(fhss_structure_t *fhss_structure)`
`190`	`190`	`return 0;`
`191`	`191`	`}`
`192`	`192`
`193`		`-int fhss_handle_state_set(fhss_structure_t *fhss_structure, fhss_states fhss_state, uint16_t pan_id)`
	`193`	`+int fhss_handle_state_set(const fhss_api_t *api, fhss_states fhss_state, uint16_t pan_id)`
`194`	`194`	`{`
`195`	`195`	`return 0;`
`196`	`196`	`}`