Wi-Fi Manager: rename some functions and variables, modify init() and deinit()

1. Rename some functions and variables to increase readability
2. Add checkpoint steps in init() and deinit() to check Wi-Fi is already initialized and deinitialized, respectively.
3. Free w_mutex in deinit() to avoid memory leak.

diff --git a/framework/include/wifi_manager/wifi_manager.h b/framework/include/wifi_manager/wifi_manager.h
index 9f3a8ef..b446134 100644 (file)
--- a/framework/include/wifi_manager/wifi_manager.h
+++ b/framework/include/wifi_manager/wifi_manager.h
@@ -43,13 +43,16 @@ typedef enum {
        WIFI_MANAGER_FAIL = -1,
        WIFI_MANAGER_SUCCESS,
        WIFI_MANAGER_INVALID_ARGS,
+       WIFI_MANAGER_INITIALIZED,
+       WIFI_MANAGER_DEINITIALIZED,
        WIFI_MANAGER_TIMEOUT,
        WIFI_MANAGER_BUSY,
 } wifi_manager_result_e;
 
 typedef enum {
+       WIFI_NONE = -1,
        STA_MODE,
-       SOFT_AP_MODE
+       SOFTAP_MODE
 } wifi_manager_mode_e;
 
 typedef struct {
@@ -138,7 +141,7 @@ wifi_manager_result_e wifi_manager_set_mode(wifi_manager_mode_e mode, wifi_manag
 
 /**
  * @brief Retrieve current status of Wi-Fi interface including mode, connection status, ssid, received signal strengh indication, and ip address.
- * @param[out] retrieved information including  mode, connection s    tatus, ssid, received signal strengh indication, and ip address.
+ * @param[out] retrieved information including  mode, connection status, ssid, received signal strengh indication, and ip address.
  * @return On success, WIFI_MANAGER_SUCCESS (i.e., 0) is returned. On failure, non-zero value is returned.
  * @since Tizen RT v1.1
  */

diff --git a/framework/src/wifi_manager/wifi_manager.c b/framework/src/wifi_manager/wifi_manager.c
index 82b29c9..33afe52 100644 (file)
--- a/framework/src/wifi_manager/wifi_manager.c
+++ b/framework/src/wifi_manager/wifi_manager.c
@@ -54,7 +54,7 @@ void __tizenrt_manual_linkset(const char *msg)
 
 static wifi_manager_info_s g_manager_info;
 
-static wifi_mutex w_mutex;
+static wifi_mutex *w_mutex = NULL;
 
 static wifi_utils_result_e start_dhcp_client(void)
 {
@@ -143,7 +143,7 @@ static void wifi_status_set(connect_status_e status)
        }
 }
 
-static void ap_connect_event_func(void)
+static void wifi_linkup_event_func(void)
 {
        wifi_manager_cb_s *wifi_cb = g_manager_info.wmcb;
        if (g_manager_info.mode == STA_MODE) {
@@ -164,7 +164,7 @@ static void ap_connect_event_func(void)
                } else {
                        ndbg("Callback wifimanager ap_connect failed\n");
                }
-       } else if (g_manager_info.mode == SOFT_AP_MODE) {
+       } else if (g_manager_info.mode == SOFTAP_MODE) {
                nvdbg("CONNECTED FROM CLIENT - SOFT AP MODE");
                wifi_status_set(CLIENT_CONNECTED);
 
@@ -180,7 +180,7 @@ static void ap_connect_event_func(void)
         */
 }
 
-static void ap_disconnect_event_func(void)
+static void wifi_linkdown_event_func(void)
 {
        wifi_manager_cb_s *wifi_cb = g_manager_info.wmcb;
        if (g_manager_info.mode == STA_MODE) {
@@ -195,7 +195,7 @@ static void ap_disconnect_event_func(void)
                } else {
                        ndbg("Callback wifimanager ap_disconnected failed\n");
                }
-       } else if (g_manager_info.mode == SOFT_AP_MODE) {
+       } else if (g_manager_info.mode == SOFTAP_MODE) {
                nvdbg("DISCONNECTED FROM CLIENT - SOFT AP MODE");
                wifi_status_set(CLIENT_DISCONNECTED);
                if (wifi_cb != NULL && wifi_cb->softap_sta_leave) {
@@ -228,12 +228,12 @@ wifi_manager_result_e wifi_manager_connect_ap(wifi_manager_ap_config_s *config)
 
        wifi_utils_get_info(&info);
 
-       if (info.wifi_status == WIFI_UTILS_SOFT_AP_MODE) {
+       if (info.wifi_status == WIFI_UTILS_SOFTAP_MODE) {
                ndbg("Current mode soft ap mode, can not connect ap");
                return WIFI_MANAGER_FAIL;
        }
 
-       wifi_mutex_acquire(&w_mutex, WIFI_UTILS_FOREVER);
+       wifi_mutex_acquire(w_mutex, WIFI_UTILS_FOREVER);
 
        strncpy(util_config.ssid, config->ssid, config->ssid_length);
        util_config.ssid_length = config->ssid_length;
@@ -245,7 +245,7 @@ wifi_manager_result_e wifi_manager_connect_ap(wifi_manager_ap_config_s *config)
        wifi_utils_result_e result = wifi_utils_connect_ap(&util_config);
        if (result != WIFI_UTILS_SUCCESS) {
                ndbg("Wifi AP connect fail");
-               wifi_mutex_release(&w_mutex);
+               wifi_mutex_release(w_mutex);
                return WIFI_MANAGER_FAIL;
        }
 
@@ -258,7 +258,7 @@ wifi_manager_result_e wifi_manager_connect_ap(wifi_manager_ap_config_s *config)
        strcpy(g_manager_info.ip4_address, ip4_add_str);
        g_manager_info.rssi = info.rssi;
 
-       wifi_mutex_release(&w_mutex);
+       wifi_mutex_release(w_mutex);
 
        return WIFI_MANAGER_SUCCESS;
 }
@@ -267,9 +267,9 @@ wifi_manager_result_e wifi_manager_disconnect_ap(void)
 {
        wifi_utils_result_e result = WIFI_UTILS_SUCCESS;
 
-       wifi_mutex_acquire(&w_mutex, WIFI_UTILS_FOREVER);
+       wifi_mutex_acquire(w_mutex, WIFI_UTILS_FOREVER);
        result = wifi_utils_disconnect_ap();
-       wifi_mutex_release(&w_mutex);
+       wifi_mutex_release(w_mutex);
 
        return result;
 }
@@ -278,9 +278,23 @@ wifi_manager_result_e wifi_manager_init(wifi_manager_cb_s *wmcb)
 {
        wifi_utils_result_e result = WIFI_UTILS_SUCCESS;
 
-       result = wifi_mutex_create(&w_mutex);
+       if (wmcb == NULL) {
+                       ndbg("Wi-Fi Manager init fail because of no callbacks");
+                       return WIFI_MANAGER_FAIL;
+       }
+
+       if (w_mutex != NULL) {
+               ndbg("WI-FI is already initialized.\n");
+               return WIFI_MANAGER_INITIALIZED;
+       }
+
+       w_mutex = (wifi_mutex *)malloc(sizeof(wifi_mutex));
+
+       result = wifi_mutex_create(w_mutex);
        if (result != WIFI_UTILS_SUCCESS) {
                ndbg("wifi_mutex_create fail");
+               free(w_mutex);
+               w_mutex = NULL;
                return WIFI_MANAGER_FAIL;
        }
 
@@ -288,15 +302,17 @@ wifi_manager_result_e wifi_manager_init(wifi_manager_cb_s *wmcb)
 
        if (result != WIFI_UTILS_SUCCESS) {
                ndbg("wifi_utils_init fail");
+               free(w_mutex);
+               w_mutex = NULL;
                return WIFI_MANAGER_FAIL;
        }
 
-       wifi_utils_register_connection_callback(ap_connect_event_func, ap_disconnect_event_func);
+       wifi_utils_register_callback(wifi_linkup_event_func, wifi_linkdown_event_func);
        strncpy(g_manager_info.ip4_address, "", 18);
        strcpy(g_manager_info.ssid, "");
        g_manager_info.rssi = 0;
        g_manager_info.mode = STA_MODE;
-       g_manager_info.mode = AP_DISCONNECTED;
+       wifi_status_set(AP_DISCONNECTED);
        g_manager_info.wmcb = wmcb;
 
 #ifdef CONFIG_ENABLE_IOTIVITY
@@ -308,6 +324,8 @@ wifi_manager_result_e wifi_manager_init(wifi_manager_cb_s *wmcb)
 
        if (g_dw_nwevent_mqfd == (mqd_t)ERROR) {
                ndbg("iotivity connect event message queue init fail");
+               free(w_mutex);
+               w_mutex = NULL;
                return WIFI_MANAGER_FAIL;
        }
 #endif
@@ -319,16 +337,25 @@ wifi_manager_result_e wifi_manager_deinit()
 {
        wifi_utils_result_e result = WIFI_UTILS_SUCCESS;
 
-       if ((g_manager_info.mode == SOFT_AP_MODE) && (stop_dhcp_server() != WIFI_UTILS_SUCCESS)) {
+       if (g_manager_info.mode == WIFI_NONE) {
+               ndbg("WI-FI is already deinitialized.\n");
+               return WIFI_MANAGER_DEINITIALIZED;
+       }
+
+       if ((g_manager_info.mode == SOFTAP_MODE) && (stop_dhcp_server() != WIFI_UTILS_SUCCESS)) {
                ndbg("dhcp server stop fail\n");
                return WIFI_MANAGER_FAIL;
        }
 
-       result = wifi_mutex_destroy(&w_mutex);
+       ndbg("w_mutex->semcount: %d, w_mutex->flags: %d\n", w_mutex->semcount, w_mutex->flags);
+
+       result = wifi_mutex_destroy(w_mutex);
        if (result != WIFI_UTILS_SUCCESS) {
-               ndbg("wifi_mutex_destroy fail");
+               ndbg("wifi_mutex_destroy fail %d", result);
                return WIFI_MANAGER_FAIL;
        }
+       free(w_mutex);
+       w_mutex = NULL;
 
        result = wifi_utils_deinit();
 
@@ -337,6 +364,8 @@ wifi_manager_result_e wifi_manager_deinit()
                return WIFI_MANAGER_FAIL;
        }
 
+       g_manager_info.mode = WIFI_NONE;
+
        return WIFI_MANAGER_SUCCESS;
 }
 
@@ -344,30 +373,39 @@ wifi_manager_result_e wifi_manager_set_mode(wifi_manager_mode_e mode, wifi_manag
 {
        wifi_utils_result_e result = WIFI_UTILS_SUCCESS;
 
-       if (mode != STA_MODE && mode != SOFT_AP_MODE) {
+       if (mode != STA_MODE && mode != SOFTAP_MODE) {
+               ndbg("wifi manager set mode failed: invalid mode\n");
                return WIFI_MANAGER_INVALID_ARGS;
        }
-       // STA mode -> SOFT AP mode
-       if (g_manager_info.mode == STA_MODE && mode == SOFT_AP_MODE) {
-               wifi_utils_softap_config_s soft_ap_config;
 
-               soft_ap_config.channel = config->channel;
-               soft_ap_config.ap_crypto_type = WIFI_UTILS_CRYPTO_AES;
-               soft_ap_config.ap_auth_type = WIFI_UTILS_AUTH_WPA2_PSK;
-               strncpy(soft_ap_config.ssid, config->ssid, sizeof(config->ssid));
-               soft_ap_config.ssid_length = strlen(config->ssid);
-               strncpy(soft_ap_config.passphrase, config->passphrase, sizeof(config->passphrase));
-               soft_ap_config.passphrase_length = strlen(config->passphrase);
-               soft_ap_config.inform_new_sta_join = g_manager_info.wmcb->softap_sta_join;
+       if (g_manager_info.mode == mode) {
+               ndbg("wifi manager set mode failed: current mode is the same as requested.\n");
+               return WIFI_MANAGER_SUCCESS;
+       }
 
-               wifi_mutex_acquire(&w_mutex, WIFI_UTILS_FOREVER);
+       ndbg("required config: %d %d %s\n", mode, config->channel, config->ssid);
 
-               g_new_sta_join = soft_ap_config.inform_new_sta_join;
-               result = wifi_utils_start_soft_ap(&soft_ap_config);
+       // Wifi mode is changed to SOFT AP
+       if ((mode == SOFTAP_MODE) && (config != NULL)) {
+               wifi_utils_softap_config_s softap_config;
+
+               softap_config.channel = config->channel;
+               softap_config.ap_crypto_type = WIFI_UTILS_CRYPTO_AES;
+               softap_config.ap_auth_type = WIFI_UTILS_AUTH_WPA2_PSK;
+               strncpy(softap_config.ssid, config->ssid, sizeof(config->ssid));
+               softap_config.ssid_length = strlen(config->ssid);
+               strncpy(softap_config.passphrase, config->passphrase, sizeof(config->passphrase));
+               softap_config.passphrase_length = strlen(config->passphrase);
+               softap_config.inform_new_sta_join = g_manager_info.wmcb->softap_sta_join;
+
+               wifi_mutex_acquire(w_mutex, WIFI_UTILS_FOREVER);
+
+               g_new_sta_join = softap_config.inform_new_sta_join;
+               result = wifi_utils_start_softap(&softap_config);
 
                if (result != WIFI_UTILS_SUCCESS) {
-                       ndbg("Start soft ap mode fail");
-                       wifi_mutex_release(&w_mutex);
+                       ndbg("Start softap mode fail");
+                       wifi_mutex_release(w_mutex);
                        return WIFI_MANAGER_FAIL;
                }
 
@@ -376,20 +414,21 @@ wifi_manager_result_e wifi_manager_set_mode(wifi_manager_mode_e mode, wifi_manag
                        return WIFI_MANAGER_FAIL;
                }
 
-               g_manager_info.mode = SOFT_AP_MODE;
-               g_manager_info.status = CLIENT_DISCONNECTED;
-               wifi_mutex_release(&w_mutex);
+               g_manager_info.mode = SOFTAP_MODE;
+               strncpy(g_manager_info.ssid, config->ssid, softap_config.ssid_length);
+               wifi_status_set(CLIENT_DISCONNECTED);
+               wifi_mutex_release(w_mutex);
 
-               nvdbg("Wifi Change STA MODE -> SOFT AP MODE");
+               nvdbg("Wifi mode is changed to SOFT AP");
        }
-       // SOFT AP mode -> STA mode
-       else if (g_manager_info.mode == SOFT_AP_MODE && mode == STA_MODE) {
-               wifi_mutex_acquire(&w_mutex, WIFI_UTILS_FOREVER);
+       // Wifi mode is changed to station
+       else if (mode == STA_MODE) {
+               wifi_mutex_acquire(w_mutex, WIFI_UTILS_FOREVER);
 
-               result = wifi_utils_stop();
+               result = wifi_utils_stop_softap();
                if (result != WIFI_UTILS_SUCCESS) {
                        ndbg("Wifi stop fail");
-                       wifi_mutex_release(&w_mutex);
+                       wifi_mutex_release(w_mutex);
                        return WIFI_MANAGER_FAIL;
                }
 
@@ -398,15 +437,19 @@ wifi_manager_result_e wifi_manager_set_mode(wifi_manager_mode_e mode, wifi_manag
                result = wifi_utils_start_sta();
                if (result != WIFI_UTILS_SUCCESS) {
                        ndbg("start STA fail (change STA mode fail)");
-                       wifi_mutex_release(&w_mutex);
+                       wifi_mutex_release(w_mutex);
                        return WIFI_MANAGER_FAIL;
                }
 
                g_manager_info.mode = STA_MODE;
-               g_manager_info.status = AP_DISCONNECTED;
-               wifi_mutex_release(&w_mutex);
+               wifi_status_set(AP_DISCONNECTED);
+               wifi_mutex_release(w_mutex);
 
-               nvdbg("Wifi Chnage SOFT AP MODE -> STA MODE");
+               nvdbg("Wifi mode is changed to station");
+       }
+       else {
+                       ndbg("Invalid config: %d %d %s\n", mode, config->channel, config->ssid);
+                       return WIFI_MANAGER_FAIL;
        }
 
        return WIFI_MANAGER_SUCCESS;
@@ -414,9 +457,14 @@ wifi_manager_result_e wifi_manager_set_mode(wifi_manager_mode_e mode, wifi_manag
 
 wifi_manager_result_e wifi_manager_get_info(wifi_manager_info_s *info)
 {
-       wifi_mutex_acquire(&w_mutex, WIFI_UTILS_FOREVER);
+       if (info == NULL) {
+               ndbg("info is null.");
+               return WIFI_MANAGER_FAIL;
+       }
+
+       wifi_mutex_acquire(w_mutex, WIFI_UTILS_FOREVER);
        *info = g_manager_info;
-       wifi_mutex_release(&w_mutex);
+       wifi_mutex_release(w_mutex);
 
        return WIFI_MANAGER_SUCCESS;
 }

diff --git a/framework/src/wifi_manager/wifi_utils.c b/framework/src/wifi_manager/wifi_utils.c
index 0b7a2b9..e2cfc61 100644 (file)
--- a/framework/src/wifi_manager/wifi_utils.c
+++ b/framework/src/wifi_manager/wifi_utils.c
@@ -38,7 +38,7 @@ static uint8_t g_join_result;
 static link_up_handler g_linkup = NULL;
 static link_down_handler g_linkdown = NULL;
 
-void LinkUpHandlerCb(slsi_reason_t *reason)
+void linkup_handler(slsi_reason_t *reason)
 {
        g_join_result = reason->reason_code;
        if ((reason->reason_code == SLSI_STATUS_SUCCESS) && g_linkup) {
@@ -46,7 +46,7 @@ void LinkUpHandlerCb(slsi_reason_t *reason)
        }
 }
 
-void LinkDownHandlerCb(slsi_reason_t *reason)
+void linkdown_handler(slsi_reason_t *reason)
 {
        if (g_linkdown) {
                g_linkdown(NULL);
@@ -68,7 +68,7 @@ wifi_utils_result_e wifi_utils_init(void)
        }
        g_mode = SLSI_WIFI_STATION_IF;
 
-       ret = WiFiRegisterLinkCallback(&LinkUpHandlerCb, &LinkDownHandlerCb);
+       ret = WiFiRegisterLinkCallback(&linkdown_handler, &linkdown_handler);
        if (ret != SLSI_STATUS_SUCCESS) {
                ndbg("Link callback handles: register failed !\n");
                return WIFI_UTILS_FAIL;
@@ -99,7 +99,7 @@ wifi_utils_result_e wifi_utils_deinit(void)
        return WIFI_UTILS_SUCCESS;
 }
 
-int8_t ScanResultHandlerCb(slsi_reason_t *reason)
+int8_t scan_result_handler(slsi_reason_t *reason)
 {
        if (reason->reason_code == 0) {
                /* Scan succeeded */
@@ -123,7 +123,7 @@ wifi_utils_result_e wifi_utils_scan_ap(wifi_utils_ap_scan_info_s *ap_list, unsig
        slsi_scan_info_t *head = NULL;
 
        // issue a scan request command and wait for the message return
-       WiFiRegisterScanCallback(ScanResultHandlerCb);
+       WiFiRegisterScanCallback(scan_result_handler);
        ret = WiFiScanNetwork();
        if (ret != SLSI_STATUS_SUCCESS) {
                return WIFI_UTILS_FAIL;
@@ -208,10 +208,10 @@ wifi_utils_result_e wifi_utils_scan_ap(wifi_utils_ap_scan_info_s *ap_list, unsig
        return WIFI_UTILS_SUCCESS;
 }
 
-wifi_utils_result_e wifi_utils_register_connection_callback(void *connect_event_func, void *disconnect_event_func)
+wifi_utils_result_e wifi_utils_register_callback(void *linkup_event_func, void *linkdown_event_func)
 {
-       g_linkup = connect_event_func;
-       g_linkdown = disconnect_event_func;
+       g_linkup = linkup_event_func;
+       g_linkdown = linkdown_event_func;
 
        return WIFI_UTILS_SUCCESS;
 }
@@ -334,7 +334,7 @@ wifi_utils_result_e wifi_utils_get_info(wifi_utils_info *wifi_info)
        wifi_info->rssi = (int)0;
 
        if (g_mode == SLSI_WIFI_SOFT_AP_IF) {
-               wifi_info->wifi_status = WIFI_UTILS_SOFT_AP_MODE;
+               wifi_info->wifi_status = WIFI_UTILS_SOFTAP_MODE;
        } else if (g_mode == SLSI_WIFI_STATION_IF) {
                uint8_t isConnected;
                if (WiFiIsConnected(&isConnected, NULL) == SLSI_STATUS_SUCCESS) {
@@ -351,17 +351,12 @@ wifi_utils_result_e wifi_utils_get_info(wifi_utils_info *wifi_info)
        return WIFI_UTILS_SUCCESS;
 }
 
-wifi_utils_result_e wifi_utils_start_soft_ap(wifi_utils_softap_config_s *soft_ap_config)
+wifi_utils_result_e wifi_utils_start_softap(wifi_utils_softap_config_s *softap_config)
 {
-       if (!soft_ap_config) {
+       if (!softap_config) {
                return WIFI_UTILS_INVALID_ARGS;
        }
 
-       if (g_mode != SLSI_WIFI_STATION_IF) {
-               ndbg("start softap failed: g_mode = %d\n", g_mode);
-               return WIFI_UTILS_FAIL;
-       }
-
        wifi_utils_result_e ret = WIFI_UTILS_FAIL;
        slsi_ap_config_t *ap_config = NULL;
        slsi_security_config_t *security_config = NULL;
@@ -377,21 +372,21 @@ wifi_utils_result_e wifi_utils_start_soft_ap(wifi_utils_softap_config_s *soft_ap
        ap_config->DTIM = 1;
        ap_config->phy_mode = 1;
 
-       if (soft_ap_config->channel > 14 || soft_ap_config->channel < 1) {
+       if (softap_config->channel > 14 || softap_config->channel < 1) {
                ndbg("Channel needs to be between 1 and 14" " (highest channel depends on regulatory of countries)\n");
                goto start_soft_ap_fail;
        } else {
-               ap_config->channel = soft_ap_config->channel;
+               ap_config->channel = softap_config->channel;
        }
 
-       if (soft_ap_config->ssid == NULL) {
+       if (softap_config->ssid == NULL) {
                goto start_soft_ap_fail;
        } else {
-               memcpy(&ap_config->ssid, soft_ap_config->ssid, soft_ap_config->ssid_length);
-               ap_config->ssid_len = soft_ap_config->ssid_length;
+               memcpy(&ap_config->ssid, softap_config->ssid, softap_config->ssid_length);
+               ap_config->ssid_len = softap_config->ssid_length;
        }
 
-       if (!soft_ap_config->passphrase || !soft_ap_config->passphrase_length) {
+       if (!softap_config->passphrase || !softap_config->passphrase_length) {
                goto start_soft_ap_fail;
        } else {
                security_config = (slsi_security_config_t *)zalloc(sizeof(slsi_security_config_t));
@@ -399,14 +394,14 @@ wifi_utils_result_e wifi_utils_start_soft_ap(wifi_utils_softap_config_s *soft_ap
                        ndbg("Memory allocation failed!\n");
                        goto start_soft_ap_fail;
                }
-               memcpy(security_config->passphrase, soft_ap_config->passphrase, soft_ap_config->passphrase_length);
+               memcpy(security_config->passphrase, softap_config->passphrase, softap_config->passphrase_length);
        }
 
-       if ((soft_ap_config->ap_auth_type == WIFI_UTILS_AUTH_WPA_PSK) && (soft_ap_config->ap_crypto_type == WIFI_UTILS_CRYPTO_TKIP)) {
+       if ((softap_config->ap_auth_type == WIFI_UTILS_AUTH_WPA_PSK) && (softap_config->ap_crypto_type == WIFI_UTILS_CRYPTO_TKIP)) {
                security_config->secmode = SLSI_SEC_MODE_WPA_TKIP;
-       } else if ((soft_ap_config->ap_auth_type == WIFI_UTILS_AUTH_WPA2_PSK) && (soft_ap_config->ap_crypto_type == WIFI_UTILS_CRYPTO_AES)) {
+       } else if ((softap_config->ap_auth_type == WIFI_UTILS_AUTH_WPA2_PSK) && (softap_config->ap_crypto_type == WIFI_UTILS_CRYPTO_AES)) {
                security_config->secmode = SLSI_SEC_MODE_WPA2_CCMP;
-       } else if ((soft_ap_config->ap_auth_type == WIFI_UTILS_AUTH_WPA_AND_WPA2_PSK) && (soft_ap_config->ap_crypto_type == WIFI_UTILS_CRYPTO_TKIP_AND_AES)) {
+       } else if ((softap_config->ap_auth_type == WIFI_UTILS_AUTH_WPA_AND_WPA2_PSK) && (softap_config->ap_crypto_type == WIFI_UTILS_CRYPTO_TKIP_AND_AES)) {
                security_config->secmode = (SLSI_SEC_MODE_WPA_MIXED | SLSI_SEC_MODE_WPA2_MIXED);
        } else {
                // if not WPA-TKIP, WPA2-AES, WPA/WPA2 TKIP/AES/MIXED, return fail.
@@ -420,9 +415,10 @@ wifi_utils_result_e wifi_utils_start_soft_ap(wifi_utils_softap_config_s *soft_ap
                goto start_soft_ap_fail;
        }
        g_mode = SLSI_WIFI_SOFT_AP_IF;
-       nvdbg("SoftAP with SSID: %s has successfully started!\n", soft_ap_config->ssid);
+       nvdbg("SoftAP with SSID: %s has successfully started!\n", softap_config->ssid);
 
        ret = WIFI_UTILS_SUCCESS;
+
 start_soft_ap_fail:
        if (ap_config) {
                free(ap_config);
@@ -448,7 +444,7 @@ wifi_utils_result_e wifi_utils_start_sta(void)
        return WIFI_UTILS_SUCCESS;
 }
 
-wifi_utils_result_e wifi_utils_stop(void)
+wifi_utils_result_e wifi_utils_stop_softap(void)
 {
        int ret;
 

diff --git a/framework/src/wifi_manager/wifi_utils.h b/framework/src/wifi_manager/wifi_utils.h
index 528268b..162ab68 100644 (file)
--- a/framework/src/wifi_manager/wifi_utils.h
+++ b/framework/src/wifi_manager/wifi_utils.h
@@ -52,7 +52,7 @@ typedef enum {
 typedef enum {
        WIFI_UTILS_DISCONNECTED,                        /**<  wifi is disconnected  */
        WIFI_UTILS_CONNECTED,                           /**<  connected             */
-       WIFI_UTILS_SOFT_AP_MODE,                        /**<  soft ap mode          */
+       WIFI_UTILS_SOFTAP_MODE,                 /**<  soft ap mode          */
 } wifi_utils_status_e;
 
 /**
@@ -167,14 +167,14 @@ wifi_utils_result_e wifi_utils_get_info(wifi_utils_info *wifi_info);
 /**
  * @brief register wifi connection event callback (connect/disconnect event)
  *
- * @param[in]   connect_event_func    :  when wifi connect event received, function start
- * @param[in]   disconnect_event_func :  when wifi disconnect event received, function start
+ * @param[in]   linkup_event_func    :  when wifi linkup event received, function start
+ * @param[in]   linkdown_event_func :  when wifi linkdown event received, function start
  *
  * @return WIFI_UTILS_SUCCESS       :  success
  * @return WIFI_UTILS_FAIL          :  fail
  * @return WIFI_UTILS_INVALID_ARGS  :  input parameter invalid
  */
-wifi_utils_result_e wifi_utils_register_connection_callback(void *connect_event_func, void *disconnect_event_func);
+wifi_utils_result_e wifi_utils_register_callback(void *linkup_event_func, void *linkdown_event_func);
 
 /**
  * @brief wifi start soft ap mode
@@ -185,7 +185,7 @@ wifi_utils_result_e wifi_utils_register_connection_callback(void *connect_event_
  * @return WIFI_UTILS_FAIL          :  fail
  * @return WIFI_UTILS_INVALID_ARGS  :  input parameter invalid
  */
-wifi_utils_result_e wifi_utils_start_soft_ap(wifi_utils_softap_config_s *soft_ap_config);
+wifi_utils_result_e wifi_utils_start_softap(wifi_utils_softap_config_s *softap_config);
 
 /**
  * @brief start wifi sta mode
@@ -196,11 +196,11 @@ wifi_utils_result_e wifi_utils_start_soft_ap(wifi_utils_softap_config_s *soft_ap
 wifi_utils_result_e wifi_utils_start_sta(void);
 
 /**
- * @brief stop wifi
+ * @brief stop wifi softap mode
  *
  * @return WIFI_UTILS_SUCCESS       :  success
  * @return WIFI_UTILS_FAIL          :  fail
  */
-wifi_utils_result_e wifi_utils_stop(void);
+wifi_utils_result_e wifi_utils_stop_softap(void);
 
 #endif                                                 //WIFI_UTILS_H