diff --git a/src/lynq/lib/liblynq-wifi6/libwifi6.c b/src/lynq/lib/liblynq-wifi6/libwifi6.c
index d2df291..e6c394b 100755
--- a/src/lynq/lib/liblynq-wifi6/libwifi6.c
+++ b/src/lynq/lib/liblynq-wifi6/libwifi6.c
@@ -22,6 +22,8 @@
 #include <netdb.h>
 #include <ifaddrs.h>
 #include "log/log.h"
+#include <sys/time.h>
+#include <asm/errno.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -73,6 +75,7 @@
     pthread_mutex_t mutex;
 };
 
+
 static pthread_mutex_t s_check_wpa_ctrl_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 static struct local_wpa_ctrl * g_lynq_wpa_ctrl[2] = {0};
@@ -91,6 +94,75 @@
     int net_no;
 }curr_status_info;
 
+typedef enum {
+    INNER_STA_STATUS_INIT = 0,
+    INNER_STA_STATUS_CONNECTING,
+    INNER_STA_STATUS_ASSOCIATING,
+    INNER_STA_STATUS_ASSOCIATED,
+    INNER_STA_STATUS_CONNECTED,
+    INNER_STA_STATUS_DISCONNECTING,
+    INNER_STA_STATUS_DISCONNECTED,
+    INNER_STA_STATUS_CANCEL,
+}inner_sta_status_s;
+
+static pthread_cond_t s_global_check_cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t s_global_check_mutex = PTHREAD_MUTEX_INITIALIZER;
+static inner_sta_status_s s_sta_status = INNER_STA_STATUS_INIT;
+static error_number_s s_sta_error_number = -1;
+static char s_sta_current_connecting_ssid[64] = {0};
+static struct timespec s_sta_connect_timeout;
+const int MAX_CONNNECT_TIME = 15; // second
+pthread_t g_global_watcher_pid = 0;
+static int s_service_invoke_timeout_cnt=0;
+const int FAKE_MAX_INT_VALUE = 99999;
+
+static void notify_service_invoke_fail(int error)
+{
+    struct local_wpa_ctrl *lynq_wpa_ctrl = NULL;
+    pthread_mutex_lock(&s_global_check_mutex);
+    if (error == -2) //timeout
+    {
+        s_service_invoke_timeout_cnt++;
+        if (s_service_invoke_timeout_cnt > 10)
+        {
+            pthread_cond_signal(&s_global_check_cond);
+        }
+    }
+    else if (error == -1)
+    {
+        // check if can connect wpa service
+        lynq_wpa_ctrl = wpa_ctrl_open(CTRL_PATH[0]);
+        if (lynq_wpa_ctrl == NULL)
+        {
+            s_service_invoke_timeout_cnt = FAKE_MAX_INT_VALUE;
+            pthread_cond_signal(&s_global_check_cond);
+        }
+        wpa_ctrl_close(lynq_wpa_ctrl);
+        lynq_wpa_ctrl = wpa_ctrl_open(CTRL_PATH[1]);
+        if (lynq_wpa_ctrl == NULL)
+        {
+            s_service_invoke_timeout_cnt = FAKE_MAX_INT_VALUE;
+            pthread_cond_signal(&s_global_check_cond);
+        }
+        wpa_ctrl_close(lynq_wpa_ctrl);
+    }
+
+    pthread_mutex_unlock(&s_global_check_mutex);
+}
+
+static void check_tether_and_notify()
+{
+    RLOGD("check_tether_and_notify called");
+    if (0 == system("ifconfig | grep tether"))
+    {
+        return;
+    }
+    pthread_mutex_lock(&s_global_check_mutex);
+    s_service_invoke_timeout_cnt = FAKE_MAX_INT_VALUE;
+    pthread_cond_signal(&s_global_check_cond);
+    pthread_mutex_unlock(&s_global_check_mutex);
+}
+
 static int local_wpa_ctrl_request(struct local_wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
                             char *reply, size_t *reply_len,
                                   void (*msg_cb)(char *msg, size_t len))
@@ -103,6 +175,10 @@
     pthread_mutex_lock(&ctrl->mutex);
     ret = wpa_ctrl_request(ctrl->ctrl, cmd, cmd_len, reply, reply_len, msg_cb);
     pthread_mutex_unlock(&ctrl->mutex);
+    if (ret != 0)
+    {
+        notify_service_invoke_fail(ret);
+    }
     return ret;
 }
 
@@ -197,6 +273,10 @@
     if (ret != 0 || reply_len < 4 || memcmp(cmd_reply, rsp_pong, 4) != 0)
     {
         RLOGE("check_connection error: ctrl [%p], ret [%d], reply_len [%d], rsp [%s]", wpa_ctrl, ret, reply_len, cmd_reply);
+        if (ret != 0)
+        {
+            notify_service_invoke_fail(ret);
+        }
         return -1;
     }
 
@@ -228,9 +308,11 @@
         }
         else
         {
+            RLOGE("[wifi error]sta watch thread wpa_ctrl_attach fail");
             wpa_ctrl_close(*pp_lynq_wpa_ctrl);
             *pp_lynq_wpa_ctrl = NULL;
             *idle_count = 0;
+            notify_service_invoke_fail(-2);
             usleep(SLEEP_TIME_ON_IDLE);
             return -1;
         }
@@ -262,6 +344,7 @@
         wpa_ctrl_close(*pp_lynq_wpa_ctrl);
         *pp_lynq_wpa_ctrl = NULL;
         *idle_count = 0;
+        notify_service_invoke_fail(ret);
         return -1;
     }
 
@@ -281,6 +364,11 @@
     {
         if (check_pending_msg(&lynq_wpa_ctrl, CTRL_AP, &idle_count, &g_ap_watcher_started_flag) != 1)
         {
+            if (g_ap_callback_func != NULL && idle_count == MAX_IDLE_COUNT - 100 )
+            {
+                check_tether_and_notify();
+            }
+
             continue;
         }
 
@@ -327,6 +415,47 @@
     }
 }
 
+static void inner_check_connect_error(const char * event_msg, lynq_wifi_sta_status_s state, error_number_s error_num)
+{
+    char * p;
+    const char * try_associat_flag = "Trying to associate";
+    const char * associated_flag = "Associated with ";
+
+    pthread_mutex_lock(&s_global_check_mutex);
+    if (s_sta_status < INNER_STA_STATUS_CONNECTING || s_sta_status >= INNER_STA_STATUS_CONNECTED) //not in connecting stage, egnore
+    {
+        pthread_mutex_unlock(&s_global_check_mutex);
+        return;
+    }
+
+    if (state == LYNQ_WIFI_STATUS_EGNORE)
+    {
+        if (strstr(event_msg, try_associat_flag) != NULL && strstr(event_msg, s_sta_current_connecting_ssid) != NULL) //associating request ssid
+        {
+            s_sta_status = INNER_STA_STATUS_ASSOCIATING;
+        }
+        else if (s_sta_status == INNER_STA_STATUS_ASSOCIATING && (p=strstr(event_msg, associated_flag)) != NULL)
+        {
+            s_sta_status = INNER_STA_STATUS_ASSOCIATED;
+        }
+    }
+    else if (state == LYNQ_WIFI_STA_STATUS_DISCONNECT)
+    {
+        s_sta_error_number = error_num;
+        if (s_sta_status >= INNER_STA_STATUS_ASSOCIATING && strstr(event_msg, "CTRL-EVENT-SSID-TEMP-DISABLED") != NULL && error_num != LYNQ_WAIT_CONNECT_ACTIVE)
+        {
+            s_sta_status = INNER_STA_STATUS_DISCONNECTED;
+            pthread_cond_signal(&s_global_check_cond);
+        }
+    }
+    else if (state == LYNQ_WIFI_STA_STATUS_CONNECT)
+    {
+        s_sta_status = INNER_STA_STATUS_CONNECTED;
+        pthread_cond_signal(&s_global_check_cond);
+    }
+    pthread_mutex_unlock(&s_global_check_mutex);
+}
+
 void get_state_error(const char* modify, lynq_wifi_sta_status_s* state, error_number_s* error)
 {
     char *pReason;
@@ -445,6 +574,16 @@
 
 }
 
+static void notify_connect_status(lynq_wifi_sta_status_s state, error_number_s error)
+{
+    if (g_sta_callback_func != NULL && state != LYNQ_WIFI_STATUS_EGNORE)
+    {
+        RLOGD("STAWatcherThreadProc callback begin ------> %d %d\n", state, error);
+        g_sta_callback_func(g_sta_callback_priv, state, error);
+        RLOGD("STAWatcherThreadProc callback end ------> %d %d\n", state, error);
+    }
+}
+
 static void STAWatcherThreadProc() {
     size_t len = MAX_RET;
     char msg_notify[MAX_RET];
@@ -455,6 +594,7 @@
     struct wpa_ctrl *lynq_wpa_ctrl = NULL;
     g_sta_watcher_stop_flag = 0;
 
+    RLOGD("STAWatcherThreadProc thread started ------");
     while (g_sta_watcher_stop_flag == 0)
     {
         if (check_pending_msg(&lynq_wpa_ctrl, CTRL_STA, &idle_count, &g_sta_watcher_started_flag) != 1)
@@ -478,11 +618,11 @@
                 continue;
             }
             get_state_error(msg_notify,&state,&error);
-            if (state != LYNQ_WIFI_STATUS_EGNORE)
+            notify_connect_status(state, error);
+
+            if (state != LYNQ_WIFI_STA_STATUS_SCAN_RESULT)
             {
-                RLOGD("STAWatcherThreadProc callback begin ------> %d %d\n", state, error);
-                g_sta_callback_func(g_sta_callback_priv, state, error);
-                RLOGD("STAWatcherThreadProc callback end ------> %d %d\n", state, error);
+                inner_check_connect_error(msg_notify, state, error);
             }
         }
     }
@@ -493,6 +633,128 @@
     }
 }
 
+// this thread will not exit when lynq_wifi_disable called,to avoid dead lock,take care
+static void GlobalWatcherThreadProc()
+{
+    int ret, connect_timeout, service_abnormal;
+    error_number_s error_num = -1;
+    inner_sta_status_s sta_status;
+    scan_info_s *scan_list = NULL;
+    int i, scan_len=0;
+    char connecting_ssid[64];
+    struct timeval now;
+
+    RLOGD("GlobalWatcherThreadProc start to run");
+
+    while (1)
+    {
+        pthread_mutex_lock(&s_global_check_mutex);
+        pthread_cond_wait(&s_global_check_cond,&s_global_check_mutex);
+        if (s_sta_status == INNER_STA_STATUS_CONNECTED)
+        {
+            pthread_mutex_unlock(&s_global_check_mutex);
+            usleep(50*1000);
+            notify_connect_status(LYNQ_WIFI_STA_STATUS_CONNECT, 0);
+            continue;
+        }
+
+        connect_timeout = 0;
+        service_abnormal = 0;
+        if (s_sta_status >= INNER_STA_STATUS_CONNECTING && s_sta_status < INNER_STA_STATUS_CONNECTED)
+        {
+            while (1)
+            {
+                ret = pthread_cond_timedwait(&s_global_check_cond, &s_global_check_mutex, &s_sta_connect_timeout);
+                if (ret == ETIME)
+                {
+                    connect_timeout = 1;
+                }
+                else if (ret != 0)
+                {
+                    gettimeofday(&now,NULL);
+                    if (now.tv_sec < s_sta_connect_timeout.tv_sec) //time not arrive
+                    {
+                        usleep(SLEEP_TIME_ON_IDLE);
+                        continue;
+                    }
+                    connect_timeout = 1;
+                }
+                sta_status = s_sta_status;
+                error_num = s_sta_error_number;
+                s_sta_status = INNER_STA_STATUS_INIT;
+                strcpy(connecting_ssid, s_sta_current_connecting_ssid);
+                memset(&s_sta_connect_timeout, 0, sizeof (s_sta_connect_timeout));
+                memset(&s_sta_current_connecting_ssid, 0, sizeof (s_sta_current_connecting_ssid));
+                break;
+            }
+        }
+        if (s_service_invoke_timeout_cnt > 10)
+        {
+            service_abnormal = 1;
+            s_service_invoke_timeout_cnt = 0;
+        }
+        pthread_mutex_unlock(&s_global_check_mutex);
+
+        if (service_abnormal == 1)
+        {
+            sleep(1);
+            RLOGE("wpa service is abnormal info app to exit");
+            notify_connect_status(LYNQ_WIFI_STA_SERVICE_ABNORMAL, -1);
+            if (g_ap_callback_func != NULL)
+            {
+                g_ap_callback_func(g_ap_callback_priv, LYNQ_WIFI_SERVICE_ABNORMAL);
+            }
+            sleep(FAKE_MAX_INT_VALUE); // wait process to exit
+        }
+
+        if (sta_status == INNER_STA_STATUS_CANCEL)
+        {
+            continue;
+        }
+        else if (sta_status == INNER_STA_STATUS_CONNECTED)
+        {
+            notify_connect_status(LYNQ_WIFI_STA_STATUS_CONNECT, 0);
+        }
+        else if (connect_timeout == 0 && error_num == LYNQ_NOT_FIND_AP) // not found ap maybe mismatch auth
+        {
+            if (0 == lynq_get_scan_list(0, &scan_list, &scan_len) && NULL != scan_list) // if not found, but scan result exist, maybe auth error
+            {
+                for(i=0; i < scan_len;i++)
+                {
+                    if (strcmp(scan_list[i].ssid, connecting_ssid) == 0)
+                    {
+                        error_num = LYNQ_AUTH_ERROR;
+                        break;
+                    }
+                }
+                free(scan_list);
+            }
+            notify_connect_status(LYNQ_WIFI_STA_STATUS_CONNECT_FAIL, error_num);
+        }
+        else if (connect_timeout == 0)
+        {
+            notify_connect_status(LYNQ_WIFI_STA_STATUS_CONNECT_FAIL, error_num);
+        }
+        else // wait timeout
+        {
+            if (0 != lynq_get_sta_status(LYNQ_WIFI_INTERFACE_0, &sta_status)) // get status fail
+            {
+                ; // wpa service abnormal
+            }
+            else if (sta_status == LYNQ_WIFI_STA_STATUS_ENABLE) // connect ok
+            {
+                RLOGD("GlobalWatcherThreadProc notify connected");
+                notify_connect_status(LYNQ_WIFI_STA_STATUS_CONNECT, 0);
+            }
+            else
+            {
+                RLOGD("GlobalWatcherThreadProc notify timeout");
+                notify_connect_status(LYNQ_WIFI_STA_STATUS_CONNECT_FAIL, LYNQ_TIME_OUT);
+            }
+        }
+    } // while (1)
+}
+
 int lynq_wifi_enable(void)
 {
     int ret = 0;
@@ -569,7 +831,7 @@
     {
         ret=pthread_create(&g_ap_watcher_pid,NULL,APWatcherThreadProc,NULL);
         if(ret<0)
-	{
+        {
             RLOGE("[wifi error]creat APWatcherThreadProc fail");
             ret = -1;
             goto out_enable;
@@ -580,19 +842,30 @@
     if (g_sta_watcher_pid == 0 ) {
         ret=pthread_create(&g_sta_watcher_pid,NULL,STAWatcherThreadProc,NULL);
         if(ret<0)
-	{
+        {
             RLOGE("[wifi error]creat STAWatcherThreadProc fail");
             ret = -1;
             goto out_enable;
         }
     }
 
+    if (g_global_watcher_pid == 0 ) // this thread will not exit when lynq_wifi_disable called,to avoid dead lock,take care
+    {
+        ret=pthread_create(&g_global_watcher_pid,NULL,GlobalWatcherThreadProc,NULL);
+        if(ret<0)
+        {
+            RLOGE("[wifi error]creat GlobalWatcherThreadProc fail");
+            ret = -1;
+            goto out_enable;
+        }
+    }
+
     RLOGD("creat STAWatcherTheradProc susccs");
     for (i=0; i<10; i++)
     {
         usleep(300*1000);
         if (g_ap_watcher_started_flag == 1 && g_sta_watcher_started_flag == 1)
-	{
+        {
             break;
         }
     }
@@ -1042,6 +1315,7 @@
     return -1;
 }
 
+static int inner_get_network_auth(int interface, int net_no, lynq_wifi_auth_s *auth);
 static int inner_get_status_info(int interface, curr_status_info *curr_state) {
     int i, count;
     char *p;
@@ -1072,24 +1346,24 @@
     for(i=0; i < count; i++)
     {
         if (curr_state->ap != NULL)
-	{
+        {
             p = strstr(split_lines[i], FLAG_SBSID);
             if (p != NULL)
-	    {
+            {
                 strncpy(curr_state->ap->ap_mac, p + strlen(FLAG_SBSID), sizeof(curr_state->ap->ap_mac));
                 ret = 0;
                 continue;
             }
             p = strstr(split_lines[i], FLAG_SSID);
             if (p != NULL)
-	    {
+            {
                 inner_copy_ssid(curr_state->ap->ap_ssid, p + strlen(FLAG_SSID), sizeof (curr_state->ap->ap_ssid));
                 ret = 0;
                 continue;
             }
             p = strstr(split_lines[i], FLAG_KEY_MGMT);
             if (p != NULL)
-	    {
+            {
                 curr_state->ap->auth = convert_auth_from_key_mgmt(p + strlen(FLAG_KEY_MGMT));
                 RLOGD("inner_get_status_info: key_mgmt %d, -- %s\n", curr_state->ap->auth, p);
                 ret = 0;
@@ -1097,24 +1371,24 @@
             }
             p = strstr(split_lines[i], FLAG_FREQ);
             if (p != NULL)
-	    {
+            {
                 curr_state->ap->band = convert_band_from_freq(atoi( p + strlen(FLAG_FREQ)));
                 ret = 0;
                 continue;
             }
             p = strstr(split_lines[i], FLAG_IPADDR);
             if (p != NULL)
-	    {
+            {
                 strncpy(curr_state->ap->ap_ip, p + strlen(FLAG_IPADDR), sizeof(curr_state->ap->ap_ip));
                 ret = 0;
                 continue;
             }
         } // end  if (ap != NULL)
         if (curr_state->state != NULL)
-	{
+        {
             p = strstr(split_lines[i], FLAG_STATE);
             if (p != NULL)
-	    {
+            {
                 strcpy(curr_state->state, p + strlen(FLAG_STATE));
                 ret = 0;
                 continue;
@@ -1122,17 +1396,21 @@
 
         } //end else if (state != NULL)
         if ((p = strstr(split_lines[i], FLAG_ID)) == split_lines[i])
-	{
+        {
             ret = 0;
             curr_state->net_no = atoi(p + strlen(FLAG_ID));
             RLOGD("inner_get_status_info:net_no %d, -- %s\n", curr_state->net_no, p);
         }
     }
 
+    if (ret == 0 && curr_state->ap != NULL && curr_state->net_no >= 0) // auth may not right when add wpa3
+    {
+        inner_get_network_auth(interface, curr_state->net_no, &curr_state->ap->auth);
+    }
+
     return ret;
 }
 
-
 int lynq_wifi_ap_ssid_set(lynq_wifi_index_e idx,char *ap_ssid)
 {
     RLOGD("enter lynq_wifi_ap_ssid_set");
@@ -1668,6 +1946,8 @@
     sprintf(LYNQ_WIFI_CMD,"SELECT_NETWORK %d",AP_NETWORK_0);
     DO_OK_FAIL_REQUEST(LYNQ_WIFI_CMD);
 
+    check_tether_and_notify();
+
     return 0;
 }
 
@@ -1904,24 +2184,33 @@
     if (*auth == LYNQ_WIFI_AUTH_WPA_PSK)
     {
         if (inner_get_param(interface, net_no, "proto", lynq_proto_str) == 0)
-	{
+        {
             if (strcmp(lynq_proto_str, "RSN") == 0)
-	    {
+            {
                 *auth = LYNQ_WIFI_AUTH_WPA2_PSK;
                 return 0;
             }
+            else if (strcmp(lynq_proto_str, "WPA") == 0) // need compare when wpa3 supported
+            {
+                return 0;
+            }
         }
     }
+    else if (*auth == LYNQ_WIFI_AUTH_OPEN || *auth == LYNQ_WIFI_AUTH_WEP)
+    {
+        return 0;
+    }
+
     if (inner_get_param(interface, net_no,"ieee80211w",lynq_auth_str) !=0)
     {
-	RLOGE("check ieee80211w error\n");
+        RLOGE("check ieee80211w error\n");
         return -1;
     }
     if ( strncmp(lynq_auth_str,"1",1) == 0 )
     {
 
-       *auth = LYNQ_WIFI_AUTH_WPA2_WPA3_PSK;
-       return 0;
+        *auth = LYNQ_WIFI_AUTH_WPA2_WPA3_PSK;
+        return 0;
     }else if( strncmp(lynq_auth_str,"2",1) == 0 )
     {
 
@@ -1929,6 +2218,7 @@
         return 0;
     }else
     {
+        RLOGE("check ieee80211w error, not 1 or 2\n");
         *auth = -1;
         return -1;
     }
@@ -2423,6 +2713,9 @@
     int count, net_no, index;
     int net_no_list[128];
     lynq_wifi_auth_s net_auth;
+    curr_status_info curr_state;
+    ap_info_s ap_info;
+    char status[64];
 
     if (ssid == NULL || *ssid == '\0')
     {
@@ -2433,39 +2726,77 @@
     if (LYNQ_WIFI_AUTH_OPEN != auth)
     {
         if (psw == NULL || strlen(psw) < 8 || strlen(psw) >= 64)
-	{
+        {
             RLOGE("bad password\n");
             return -1;
         }
     }
 
+
+    pthread_mutex_lock(&s_global_check_mutex);
+    if (s_sta_status != INNER_STA_STATUS_INIT)
+    {
+        s_sta_status = INNER_STA_STATUS_CANCEL;
+        pthread_cond_signal(&s_global_check_cond);
+    }
+    pthread_mutex_unlock(&s_global_check_mutex);
+
     CHECK_IDX(idx, CTRL_STA);
+    CHECK_WPA_CTRL(CTRL_STA);
 
     net_no = -1;
-    count = lynq_get_network_number_list(idx, CTRL_STA, net_no_list, ssid);
+    memset(&ap_info, 0, sizeof (ap_info));
+    memset(status, 0, sizeof (status));
 
-    for (index=0; index < count; index++)
+    curr_state.ap = &ap_info;
+    curr_state.state = status;
+
+    if (0 == inner_get_status_info(CTRL_STA, &curr_state) && curr_state.net_no >= 0)
     {
-        net_auth = -1;
-        if (0 == inner_get_network_auth(CTRL_STA, net_no_list[index], &net_auth) && net_auth == auth)
-	{
-            net_no = net_no_list[index];
-            break;
+        if (strcmp(status, STATE_COMPLETED) == 0 && strcmp(ap_info.ap_ssid, ssid) ==0 && ap_info.auth == auth)
+        {
+            net_no = curr_state.net_no;
+            if (0 == lynq_sta_ssid_password_get(idx, &ap_info, ap_info.psw)
+                    && strcmp(ap_info.psw, psw) == 0)
+            {
+                RLOGD("already connected\n");
+
+                pthread_mutex_lock(&s_global_check_mutex);
+                s_sta_status = INNER_STA_STATUS_CONNECTED;
+                pthread_cond_signal(&s_global_check_cond);
+                pthread_mutex_unlock(&s_global_check_mutex);
+                return 0;
+            }
         }
     }
 
-    if (net_no < 0)
+    if (net_no == -1)
     {
-        net_no = lynq_add_network(CTRL_STA);
-        if (net_no == -1)
-	{
-            return -1;
+        count = lynq_get_network_number_list(idx, CTRL_STA, net_no_list, ssid);
+
+        for (index=0; index < count; index++)
+        {
+            net_auth = -1;
+            if (0 == inner_get_network_auth(CTRL_STA, net_no_list[index], &net_auth) && net_auth == auth)
+            {
+                net_no = net_no_list[index];
+                break;
+            }
         }
 
-        RLOGD("net no is %d\n", net_no);
-        if (0 != inner_set_sta_ssid(net_no, ssid))
-	{
-            return -1;
+        if (net_no < 0)
+        {
+            net_no = lynq_add_network(CTRL_STA);
+            if (net_no == -1)
+            {
+                return -1;
+            }
+
+            RLOGD("net no is %d\n", net_no);
+            if (0 != inner_set_sta_ssid(net_no, ssid))
+            {
+                return -1;
+            }
         }
     }
 
@@ -2474,7 +2805,22 @@
         return -1;
     }
 
-    return inner_sta_start_stop(net_no, 1, 1);
+
+    DO_OK_FAIL_REQUEST(cmd_disconnect);
+    usleep(200*1000);
+
+    ret = inner_sta_start_stop(net_no, 1, 1);
+
+    pthread_mutex_lock(&s_global_check_mutex);
+    s_sta_status = INNER_STA_STATUS_CONNECTING;
+    strcpy(s_sta_current_connecting_ssid, ssid);
+    struct timeval now;
+    gettimeofday(&now,NULL);
+    s_sta_connect_timeout.tv_sec = now.tv_sec + MAX_CONNNECT_TIME;
+    s_sta_connect_timeout.tv_nsec = now.tv_usec*1000;
+    pthread_cond_signal(&s_global_check_cond);
+    pthread_mutex_unlock(&s_global_check_mutex);
+    return ret;
 }
 
 int lynq_wifi_sta_disconnect(lynq_wifi_index_e idx, char *ssid)
@@ -2504,6 +2850,9 @@
         return 0;
     }
 
+    pthread_mutex_lock(&s_global_check_mutex);
+    s_sta_status = INNER_STA_STATUS_DISCONNECTING;
+    pthread_mutex_unlock(&s_global_check_mutex);
     return inner_sta_start_stop(curr_state.net_no, 0, 0);
 }
 
@@ -2835,7 +3184,7 @@
 
     CHECK_WPA_CTRL(CTRL_STA);
 
-    system(clean_last_re);
+//    system(clean_last_re); // youchen @ 2023-04-14 temp delete ,next time to fix the orginal bug
     g_sta_scan_finish_flag = 0;
     DO_REQUEST(lynq_scan_cmd);
     if (reply_len >=9 && memcmp(cmd_reply, "FAIL-BUSY", 9) == 0 )