diff --git a/CORE/HDD/src/wlan_hdd_assoc.c b/CORE/HDD/src/wlan_hdd_assoc.c
index 2febc94..fde6de9 100644
--- a/CORE/HDD/src/wlan_hdd_assoc.c
+++ b/CORE/HDD/src/wlan_hdd_assoc.c
@@ -1641,9 +1641,6 @@
         else
             hddLog(VOS_TRACE_LEVEL_ERROR, "%s: Wrong Staid: %d", __func__, pRoamInfo->staId);
 
-#ifdef FEATURE_WLAN_TDLS
-        wlan_hdd_tdls_connection_callback(pAdapter);
-#endif
         //For reassoc, the station is already registered, all we need is to change the state
         //of the STA in TL.
         //If authentication is required (WPA/WPA2/DWEP), change TL to CONNECTED instead of AUTHENTICATED
@@ -1880,6 +1877,9 @@
         {
             vos_record_roam_event(e_HDD_ENABLE_TX_QUEUE, NULL, 0);
         }
+#ifdef FEATURE_WLAN_TDLS
+        wlan_hdd_tdls_connection_callback(pAdapter);
+#endif
     }
     else
     {
diff --git a/CORE/HDD/src/wlan_hdd_dev_pwr.c b/CORE/HDD/src/wlan_hdd_dev_pwr.c
index 6fcf9fd..c0c99e7 100644
--- a/CORE/HDD/src/wlan_hdd_dev_pwr.c
+++ b/CORE/HDD/src/wlan_hdd_dev_pwr.c
@@ -133,7 +133,7 @@
    INIT_COMPLETION(pHddCtx->tx_sus_event_var);
 
    /* Indicate Tx Thread to Suspend */
-   set_bit(TX_SUSPEND_EVENT_MASK, &vosSchedContext->txEventFlag);
+   set_bit(TX_SUSPEND_EVENT, &vosSchedContext->txEventFlag);
 
    wake_up_interruptible(&vosSchedContext->txWaitQueue);
 
@@ -151,7 +151,7 @@
        * Thread then it means it is going to suspend, so do not return failure
        * from here.
        */
-      if (!test_and_clear_bit(TX_SUSPEND_EVENT_MASK,
+      if (!test_and_clear_bit(TX_SUSPEND_EVENT,
                               &vosSchedContext->txEventFlag))
       {
          VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
@@ -169,7 +169,7 @@
    INIT_COMPLETION(pHddCtx->rx_sus_event_var);
 
    /* Indicate Rx Thread to Suspend */
-   set_bit(RX_SUSPEND_EVENT_MASK, &vosSchedContext->rxEventFlag);
+   set_bit(RX_SUSPEND_EVENT, &vosSchedContext->rxEventFlag);
 
    wake_up_interruptible(&vosSchedContext->rxWaitQueue);
 
@@ -186,7 +186,7 @@
         * Thread then it means it is going to suspend, so do not return failure
         * from here.
         */
-       if (!test_and_clear_bit(RX_SUSPEND_EVENT_MASK,
+       if (!test_and_clear_bit(RX_SUSPEND_EVENT,
                                &vosSchedContext->rxEventFlag))
        {
            VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
@@ -210,7 +210,7 @@
    INIT_COMPLETION(pHddCtx->mc_sus_event_var);
 
    /* Indicate MC Thread to Suspend */
-   set_bit(MC_SUSPEND_EVENT_MASK, &vosSchedContext->mcEventFlag);
+   set_bit(MC_SUSPEND_EVENT, &vosSchedContext->mcEventFlag);
 
    wake_up_interruptible(&vosSchedContext->mcWaitQueue);
 
@@ -229,7 +229,7 @@
         * Thread then it means it is going to suspend, so do not return failure
         * from here.
         */
-       if (!test_and_clear_bit(MC_SUSPEND_EVENT_MASK,
+       if (!test_and_clear_bit(MC_SUSPEND_EVENT,
                                &vosSchedContext->mcEventFlag))
        {
            VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
diff --git a/CORE/HDD/src/wlan_hdd_early_suspend.c b/CORE/HDD/src/wlan_hdd_early_suspend.c
index 1abcffa..e2aec64 100644
--- a/CORE/HDD/src/wlan_hdd_early_suspend.c
+++ b/CORE/HDD/src/wlan_hdd_early_suspend.c
@@ -1964,22 +1964,22 @@
     */
    /* Wait for MC to exit */
    hddLog(VOS_TRACE_LEVEL_FATAL, "%s: Shutting down MC thread",__func__);
-   set_bit(MC_SHUTDOWN_EVENT_MASK, &vosSchedContext->mcEventFlag);
-   set_bit(MC_POST_EVENT_MASK, &vosSchedContext->mcEventFlag);
+   set_bit(MC_SHUTDOWN_EVENT, &vosSchedContext->mcEventFlag);
+   set_bit(MC_POST_EVENT, &vosSchedContext->mcEventFlag);
    wake_up_interruptible(&vosSchedContext->mcWaitQueue);
    wait_for_completion(&vosSchedContext->McShutdown);
 
    /* Wait for TX to exit */
    hddLog(VOS_TRACE_LEVEL_FATAL, "%s: Shutting down TX thread",__func__);
-   set_bit(TX_SHUTDOWN_EVENT_MASK, &vosSchedContext->txEventFlag);
-   set_bit(TX_POST_EVENT_MASK, &vosSchedContext->txEventFlag);
+   set_bit(TX_SHUTDOWN_EVENT, &vosSchedContext->txEventFlag);
+   set_bit(TX_POST_EVENT, &vosSchedContext->txEventFlag);
    wake_up_interruptible(&vosSchedContext->txWaitQueue);
    wait_for_completion(&vosSchedContext->TxShutdown);
 
    /* Wait for RX to exit */
    hddLog(VOS_TRACE_LEVEL_FATAL, "%s: Shutting down RX thread",__func__);
-   set_bit(RX_SHUTDOWN_EVENT_MASK, &vosSchedContext->rxEventFlag);
-   set_bit(RX_POST_EVENT_MASK, &vosSchedContext->rxEventFlag);
+   set_bit(RX_SHUTDOWN_EVENT, &vosSchedContext->rxEventFlag);
+   set_bit(RX_POST_EVENT, &vosSchedContext->rxEventFlag);
    wake_up_interruptible(&vosSchedContext->rxWaitQueue);
 
    wait_for_completion(&vosSchedContext->RxShutdown);
diff --git a/CORE/SME/src/sme_common/sme_Api.c b/CORE/SME/src/sme_common/sme_Api.c
index 176caf9..9006254 100644
--- a/CORE/SME/src/sme_common/sme_Api.c
+++ b/CORE/SME/src/sme_common/sme_Api.c
@@ -2070,6 +2070,7 @@
    }
 
    sme_RrmProcessBeaconReportReqInd(pMac, pSmeBcnReportReq);
+   vos_mem_free(pSmeBcnReportReq);
    return status;
 }
 
@@ -11844,6 +11845,8 @@
 {
     tHalHandle hHal= (tHalHandle) userData;
     tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
+    tListElem *pEntry;
+    tSmeCmd *pTempCmd = NULL;
 
     if (NULL == pMac)
     {
@@ -11862,11 +11865,24 @@
         csrLLCount(&pMac->sme.smeCmdActiveList) );
     smeGetCommandQStatus(hHal);
 
+    pEntry = csrLLPeekHead(&pMac->sme.smeCmdActiveList, LL_ACCESS_LOCK);
+    if (pEntry) {
+        pTempCmd = GET_BASE_ADDR(pEntry, tSmeCmd, Link);
+    }
+    /* If user initiated scan took more than active list timeout
+     * abort it.
+     */
+    if (pTempCmd && (eSmeCommandScan == pTempCmd->command) &&
+        (eCsrScanUserRequest == pTempCmd->u.scanCmd.reason)) {
+        sme_AbortMacScan(hHal, pTempCmd->sessionId,
+                                 eCSR_SCAN_ABORT_DEFAULT);
+        return;
+    }
+
     /* Initiate SSR to recover */
     if (!(vos_isLoadUnloadInProgress() ||
         vos_is_logp_in_progress(VOS_MODULE_ID_SME, NULL)))
     {
-       vosTraceDumpAll(pMac,0,0,0,0);
        vos_wlanRestart();
     }
 }
@@ -11953,6 +11969,7 @@
         {
             VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
                     "Not able to post SIR_HAL_LL_STATS_SET message to HAL", __func__);
+            vos_mem_free(plinkLayerSetReq);
             status = eHAL_STATUS_FAILURE;
         }
         sme_ReleaseGlobalLock( &pMac->sme );
@@ -11961,6 +11978,8 @@
     {
         VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
                 "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(plinkLayerSetReq);
+        status = eHAL_STATUS_FAILURE;
     }
     return status;
 }
@@ -12006,6 +12025,7 @@
         {
             VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
                     "Not able to post SIR_HAL_LL_STATS_GET message to HAL", __func__);
+            vos_mem_free(pGetStatsReq);
             status = eHAL_STATUS_FAILURE;
         }
         sme_ReleaseGlobalLock( &pMac->sme );
@@ -12014,6 +12034,8 @@
     {
         VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
                 "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pGetStatsReq);
+        status = eHAL_STATUS_FAILURE;
     }
     return status;
 }
@@ -12063,6 +12085,7 @@
         {
             VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
                     "Not able to post SIR_HAL_LL_STATS_CLEAR message to HAL", __func__);
+            vos_mem_free(pClearStatsReq);
             status = eHAL_STATUS_FAILURE;
         }
         sme_ReleaseGlobalLock( &pMac->sme );
@@ -12071,6 +12094,8 @@
     {
         VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
                 "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pClearStatsReq);
+        status = eHAL_STATUS_FAILURE;
     }
 
     return status;
@@ -12408,11 +12433,23 @@
         MTRACE(vos_trace(VOS_MODULE_ID_SME,
                  TRACE_CODE_SME_TX_WDA_MSG, NO_SESSION, vosMessage.type));
         vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
-        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus)) {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
+                    "failed to post WDA_EXTSCAN_GET_CAPABILITIES_REQ ",
+                    __func__);
+           vos_mem_free(pGetEXTScanCapabilitiesReq);
            status = eHAL_STATUS_FAILURE;
+        }
 
         sme_ReleaseGlobalLock(&pMac->sme);
     }
+    else
+    {
+        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
+                "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pGetEXTScanCapabilitiesReq);
+        status = eHAL_STATUS_FAILURE;
+    }
     return(status);
 }
 
@@ -12454,11 +12491,21 @@
         MTRACE(vos_trace(VOS_MODULE_ID_SME,
                  TRACE_CODE_SME_TX_WDA_MSG, NO_SESSION, vosMessage.type));
         vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
-        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus)) {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
+                    "%s: failed to post WDA_EXTSCAN_START_REQ", __func__);
+           vos_mem_free(pextScanStartReq);
            status = eHAL_STATUS_FAILURE;
-
+        }
         sme_ReleaseGlobalLock(&pMac->sme);
     }
+    else
+    {
+        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
+                "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pextScanStartReq);
+        status = eHAL_STATUS_FAILURE;
+    }
     return(status);
 }
 
@@ -12501,10 +12548,20 @@
         vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
         if (!VOS_IS_STATUS_SUCCESS(vosStatus))
         {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
+                    "%s: failed to post WDA_EXTSCAN_STOP_REQ", __func__);
+           vos_mem_free(pEXTScanStopReq);
            status = eHAL_STATUS_FAILURE;
         }
         sme_ReleaseGlobalLock(&pMac->sme);
     }
+    else
+    {
+        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
+                "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pEXTScanStopReq);
+        status = eHAL_STATUS_FAILURE;
+    }
     return(status);
 }
 
@@ -12546,11 +12603,21 @@
         MTRACE(vos_trace(VOS_MODULE_ID_SME,
                  TRACE_CODE_SME_TX_WDA_MSG, NO_SESSION, vosMessage.type));
         vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
-        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus)) {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
+                    "%s: failed to post WDA_EXTSCAN_STOP_REQ", __func__);
+           vos_mem_free(pEXTScanSetBssidHotlistReq);
            status = eHAL_STATUS_FAILURE;
-
+        }
         sme_ReleaseGlobalLock(&pMac->sme);
     }
+    else
+    {
+        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
+                "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pEXTScanSetBssidHotlistReq);
+        status = eHAL_STATUS_FAILURE;
+    }
 
     return(status);
 }
@@ -12593,11 +12660,22 @@
         MTRACE(vos_trace(VOS_MODULE_ID_SME,
                  TRACE_CODE_SME_TX_WDA_MSG, NO_SESSION, vosMessage.type));
         vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
-        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus)) {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
+                    "%s: failed to post WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ",
+                     __func__);
+           vos_mem_free(pEXTScanHotlistResetReq);
            status = eHAL_STATUS_FAILURE;
-
+        }
         sme_ReleaseGlobalLock(&pMac->sme);
     }
+    else
+    {
+        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
+                "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pEXTScanHotlistResetReq);
+        status = eHAL_STATUS_FAILURE;
+    }
     return(status);
 }
 
@@ -12733,11 +12811,22 @@
         MTRACE(vos_trace(VOS_MODULE_ID_SME,
                  TRACE_CODE_SME_TX_WDA_MSG, NO_SESSION, vosMessage.type));
         vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
-        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus)) {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
+                "%s: failed tp post WDA_EXTSCAN_GET_CACHED_RESULTS_REQ",
+                __func__);
+           vos_mem_free(pEXTScanCachedResultsReq);
            status = eHAL_STATUS_FAILURE;
-
+        }
         sme_ReleaseGlobalLock(&pMac->sme);
     }
+    else
+    {
+        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
+            FL("Failed to acquire SME Global Lock"));
+        vos_mem_free(pEXTScanCachedResultsReq);
+        status = eHAL_STATUS_FAILURE;
+    }
     return(status);
 }
 
@@ -12838,11 +12927,21 @@
         MTRACE(vos_trace(VOS_MODULE_ID_SME,
                  TRACE_CODE_SME_TX_WDA_MSG, NO_SESSION, vosMessage.type));
         vosStatus = vos_mq_post_message(VOS_MQ_ID_WDA, &vosMessage);
-        if (!VOS_IS_STATUS_SUCCESS(vosStatus))
+        if (!VOS_IS_STATUS_SUCCESS(vosStatus)) {
+           VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
+            "%s: failed to post SIR_HAL_ENCRYPT_MSG_REQ", __func__);
+           vos_mem_free(pEncryptMsg);
            status = eHAL_STATUS_FAILURE;
-
+        }
         sme_ReleaseGlobalLock(&pMac->sme);
     }
+    else
+    {
+        VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, "%s: "
+                "sme_AcquireGlobalLock error", __func__);
+        vos_mem_free(pEncryptMsg);
+        status = eHAL_STATUS_FAILURE;
+    }
     return(status);
 }
 
diff --git a/CORE/SVC/src/logging/wlan_logging_sock_svc.c b/CORE/SVC/src/logging/wlan_logging_sock_svc.c
index 1c71310..cdfeade 100644
--- a/CORE/SVC/src/logging/wlan_logging_sock_svc.c
+++ b/CORE/SVC/src/logging/wlan_logging_sock_svc.c
@@ -56,10 +56,10 @@
 #define INVALID_PID -1
 
 #define MAX_LOGMSG_LENGTH 4096
-#define LOGGER_MGMT_DATA_PKT_POST_MASK   0x001
-#define HOST_LOG_POST_MASK   0x002
-#define LOGGER_FW_LOG_PKT_POST_MASK   0x003
-#define LOGGER_FATAL_EVENT_POST_MASK  0x004
+#define LOGGER_MGMT_DATA_PKT_POST        0x001
+#define HOST_LOG_POST                    0x002
+#define LOGGER_FW_LOG_PKT_POST           0x003
+#define LOGGER_FATAL_EVENT_POST          0x004
 
 #define LOGGER_MAX_DATA_MGMT_PKT_Q_LEN   (8)
 #define LOGGER_MAX_FW_LOG_PKT_Q_LEN   (16)
@@ -330,7 +330,6 @@
 	return ret;
 }
 
-
 int wlan_log_to_user(VOS_TRACE_LEVEL log_level, char *to_be_sent, int length)
 {
 	/* Add the current time stamp */
@@ -422,7 +421,7 @@
                  * thread
                  */
 
-			set_bit(HOST_LOG_POST_MASK, &gwlan_logging.event_flag);
+			set_bit(HOST_LOG_POST, &gwlan_logging.event_flag);
 			wake_up_interruptible(&gwlan_logging.wait_queue);
 	}
 
@@ -733,13 +732,13 @@
 	while (!gwlan_logging.exit) {
 		ret_wait_status = wait_event_interruptible(
 		  gwlan_logging.wait_queue,
-		  (test_bit(HOST_LOG_POST_MASK, &gwlan_logging.event_flag) ||
+		  (test_bit(HOST_LOG_POST, &gwlan_logging.event_flag) ||
 		   gwlan_logging.exit ||
-		   test_bit(LOGGER_MGMT_DATA_PKT_POST_MASK,
+		   test_bit(LOGGER_MGMT_DATA_PKT_POST,
 						&gwlan_logging.event_flag) ||
-		   test_bit(LOGGER_FW_LOG_PKT_POST_MASK,
+		   test_bit(LOGGER_FW_LOG_PKT_POST,
 						&gwlan_logging.event_flag) ||
-		   test_bit(LOGGER_FATAL_EVENT_POST_MASK,
+		   test_bit(LOGGER_FATAL_EVENT_POST,
 						&gwlan_logging.event_flag)));
 
 		if (ret_wait_status == -ERESTARTSYS) {
@@ -751,7 +750,7 @@
 		    break;
 		}
 
-		if (test_and_clear_bit(HOST_LOG_POST_MASK,
+		if (test_and_clear_bit(HOST_LOG_POST,
 			&gwlan_logging.event_flag)) {
 			ret = send_filled_buffers_to_user();
 			if (-ENOMEM == ret) {
@@ -759,17 +758,17 @@
 			}
 		}
 
-		if (test_and_clear_bit(LOGGER_FW_LOG_PKT_POST_MASK,
+		if (test_and_clear_bit(LOGGER_FW_LOG_PKT_POST,
 			&gwlan_logging.event_flag)) {
 			send_fw_log_pkt_to_user();
 		}
 
-		if (test_and_clear_bit(LOGGER_MGMT_DATA_PKT_POST_MASK,
+		if (test_and_clear_bit(LOGGER_MGMT_DATA_PKT_POST,
 			&gwlan_logging.event_flag)) {
 			send_data_mgmt_log_pkt_to_user();
 		}
 
-		if (test_and_clear_bit(LOGGER_FATAL_EVENT_POST_MASK,
+		if (test_and_clear_bit(LOGGER_FATAL_EVENT_POST,
 			&gwlan_logging.event_flag)) {
 			if (gwlan_logging.log_complete.is_flush_complete == true) {
 				gwlan_logging.log_complete.is_flush_complete = false;
@@ -777,9 +776,9 @@
 			}
 			else {
 				gwlan_logging.log_complete.is_flush_complete = true;
-				set_bit(HOST_LOG_POST_MASK,&gwlan_logging.event_flag);
-				set_bit(LOGGER_FW_LOG_PKT_POST_MASK,&gwlan_logging.event_flag);
-				set_bit(LOGGER_FATAL_EVENT_POST_MASK,&gwlan_logging.event_flag);
+				set_bit(HOST_LOG_POST, &gwlan_logging.event_flag);
+				set_bit(LOGGER_FW_LOG_PKT_POST,&gwlan_logging.event_flag);
+				set_bit(LOGGER_FATAL_EVENT_POST, &gwlan_logging.event_flag);
 				wake_up_interruptible(&gwlan_logging.wait_queue);
 			}
 		}
@@ -826,7 +825,7 @@
 			wlan_queue_logmsg_for_app();
 		}
 		spin_unlock_bh(&gwlan_logging.spin_lock);
-		set_bit(HOST_LOG_POST_MASK, &gwlan_logging.event_flag);
+		set_bit(HOST_LOG_POST, &gwlan_logging.event_flag);
 		wake_up_interruptible(&gwlan_logging.wait_queue);
 	} else {
 		/* This is to set the default levels (WLAN logging
@@ -940,10 +939,10 @@
 
 	init_waitqueue_head(&gwlan_logging.wait_queue);
 	gwlan_logging.exit = false;
-	clear_bit(HOST_LOG_POST_MASK, &gwlan_logging.event_flag);
-	clear_bit(LOGGER_MGMT_DATA_PKT_POST_MASK, &gwlan_logging.event_flag);
-	clear_bit(LOGGER_FW_LOG_PKT_POST_MASK, &gwlan_logging.event_flag);
-	clear_bit(LOGGER_FATAL_EVENT_POST_MASK, &gwlan_logging.event_flag);
+	clear_bit(HOST_LOG_POST, &gwlan_logging.event_flag);
+	clear_bit(LOGGER_MGMT_DATA_PKT_POST, &gwlan_logging.event_flag);
+	clear_bit(LOGGER_FW_LOG_PKT_POST, &gwlan_logging.event_flag);
+	clear_bit(LOGGER_FATAL_EVENT_POST, &gwlan_logging.event_flag);
 	init_completion(&gwlan_logging.shutdown_comp);
 	gwlan_logging.thread = kthread_create(wlan_logging_thread, NULL,
 					"wlan_logging_thread");
@@ -1101,7 +1100,7 @@
 
 	spin_unlock_irqrestore(&gwlan_logging.data_mgmt_pkt_lock, flags);
 
-	set_bit(LOGGER_MGMT_DATA_PKT_POST_MASK, &gwlan_logging.event_flag);
+	set_bit(LOGGER_MGMT_DATA_PKT_POST, &gwlan_logging.event_flag);
 	wake_up_interruptible(&gwlan_logging.wait_queue);
 
 	return VOS_STATUS_SUCCESS;
@@ -1166,7 +1165,7 @@
 
 	spin_unlock_irqrestore(&gwlan_logging.fw_log_pkt_lock, flags);
 
-	set_bit(LOGGER_FW_LOG_PKT_POST_MASK, &gwlan_logging.event_flag);
+	set_bit(LOGGER_FW_LOG_PKT_POST, &gwlan_logging.event_flag);
 	wake_up_interruptible(&gwlan_logging.wait_queue);
 
 	return VOS_STATUS_SUCCESS;
@@ -1214,7 +1213,7 @@
     if ((type == WLAN_QXDM_LOGGING) && (wlan_is_log_report_in_progress() == TRUE))
     {
         pr_info("%s: Setting LOGGER_FATAL_EVENT\n", __func__);
-        set_bit(LOGGER_FATAL_EVENT_POST_MASK, &gwlan_logging.event_flag);
+        set_bit(LOGGER_FATAL_EVENT_POST, &gwlan_logging.event_flag);
         wake_up_interruptible(&gwlan_logging.wait_queue);
     }
 }
diff --git a/CORE/VOSS/src/vos_api.c b/CORE/VOSS/src/vos_api.c
index 66ed456..bdd075d 100644
--- a/CORE/VOSS/src/vos_api.c
+++ b/CORE/VOSS/src/vos_api.c
@@ -1987,7 +1987,7 @@
 
   vos_mq_put(pTargetMq, pMsgWrapper);
 
-  set_bit(MC_POST_EVENT_MASK, &gpVosContext->vosSched.mcEventFlag);
+  set_bit(MC_POST_EVENT, &gpVosContext->vosSched.mcEventFlag);
   wake_up_interruptible(&gpVosContext->vosSched.mcWaitQueue);
 
   return VOS_STATUS_SUCCESS;
@@ -2123,7 +2123,7 @@
 
   vos_mq_put_front(pTargetMq, pMsgWrapper);
 
-  set_bit(MC_POST_EVENT_MASK, &gpVosContext->vosSched.mcEventFlag);
+  set_bit(MC_POST_EVENT, &gpVosContext->vosSched.mcEventFlag);
   wake_up_interruptible(&gpVosContext->vosSched.mcWaitQueue);
 
   return VOS_STATUS_SUCCESS;
@@ -2242,7 +2242,7 @@
 
   vos_mq_put(pTargetMq, pMsgWrapper);
 
-  set_bit(TX_POST_EVENT_MASK, &gpVosContext->vosSched.txEventFlag);
+  set_bit(TX_POST_EVENT, &gpVosContext->vosSched.txEventFlag);
   wake_up_interruptible(&gpVosContext->vosSched.txWaitQueue);
 
   return VOS_STATUS_SUCCESS;
@@ -2357,7 +2357,7 @@
 
   vos_mq_put(pTargetMq, pMsgWrapper);
 
-  set_bit(RX_POST_EVENT_MASK, &gpVosContext->vosSched.rxEventFlag);
+  set_bit(RX_POST_EVENT, &gpVosContext->vosSched.rxEventFlag);
   wake_up_interruptible(&gpVosContext->vosSched.rxWaitQueue);
 
   return VOS_STATUS_SUCCESS;
diff --git a/CORE/VOSS/src/vos_sched.c b/CORE/VOSS/src/vos_sched.c
index 4821e09..fc1aea4 100644
--- a/CORE/VOSS/src/vos_sched.c
+++ b/CORE/VOSS/src/vos_sched.c
@@ -251,16 +251,16 @@
 
 RX_THREAD_START_FAILURE:
     //Try and force the Tx thread controller to exit
-    set_bit(MC_SHUTDOWN_EVENT_MASK, &pSchedContext->txEventFlag);
-    set_bit(MC_POST_EVENT_MASK, &pSchedContext->txEventFlag);
+    set_bit(MC_SHUTDOWN_EVENT, &pSchedContext->txEventFlag);
+    set_bit(MC_POST_EVENT, &pSchedContext->txEventFlag);
     wake_up_interruptible(&pSchedContext->txWaitQueue);
      //Wait for TX to exit
     wait_for_completion_interruptible(&pSchedContext->TxShutdown);
 
 TX_THREAD_START_FAILURE:
     //Try and force the Main thread controller to exit
-    set_bit(MC_SHUTDOWN_EVENT_MASK, &pSchedContext->mcEventFlag);
-    set_bit(MC_POST_EVENT_MASK, &pSchedContext->mcEventFlag);
+    set_bit(MC_SHUTDOWN_EVENT, &pSchedContext->mcEventFlag);
+    set_bit(MC_POST_EVENT, &pSchedContext->mcEventFlag);
     wake_up_interruptible(&pSchedContext->mcWaitQueue);
     //Wait for MC to exit
     wait_for_completion_interruptible(&pSchedContext->McShutdown);
@@ -391,8 +391,8 @@
   {
     // This implements the execution model algorithm
     retWaitStatus = wait_event_interruptible(pSchedContext->mcWaitQueue,
-       test_bit(MC_POST_EVENT_MASK, &pSchedContext->mcEventFlag) || 
-       test_bit(MC_SUSPEND_EVENT_MASK, &pSchedContext->mcEventFlag));
+       test_bit(MC_POST_EVENT, &pSchedContext->mcEventFlag) ||
+       test_bit(MC_SUSPEND_EVENT, &pSchedContext->mcEventFlag));
 
     if(retWaitStatus == -ERESTARTSYS)
     {
@@ -400,18 +400,18 @@
          "%s: wait_event_interruptible returned -ERESTARTSYS", __func__);
       break;
     }
-    clear_bit(MC_POST_EVENT_MASK, &pSchedContext->mcEventFlag);
+    clear_bit(MC_POST_EVENT, &pSchedContext->mcEventFlag);
 
     while(1)
     {
       // Check if MC needs to shutdown
-      if(test_bit(MC_SHUTDOWN_EVENT_MASK, &pSchedContext->mcEventFlag))
+      if(test_bit(MC_SHUTDOWN_EVENT, &pSchedContext->mcEventFlag))
       {
         VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
                 "%s: MC thread signaled to shutdown", __func__);
         shutdown = VOS_TRUE;
         /* Check for any Suspend Indication */
-        if (test_and_clear_bit(MC_SUSPEND_EVENT_MASK,
+        if (test_and_clear_bit(MC_SUSPEND_EVENT,
                                &pSchedContext->mcEventFlag))
         {
            /* Unblock anyone waiting on suspend */
@@ -604,7 +604,7 @@
         continue;
       }
       /* Check for any Suspend Indication */
-      if (test_and_clear_bit(MC_SUSPEND_EVENT_MASK,
+      if (test_and_clear_bit(MC_SUSPEND_EVENT,
                              &pSchedContext->mcEventFlag))
       {
         spin_lock(&pSchedContext->McThreadLock);
@@ -726,9 +726,9 @@
   if (!(vos_is_logp_in_progress(VOS_MODULE_ID_SYS, NULL) ||
        vos_is_load_unload_in_progress(VOS_MODULE_ID_SYS, NULL)))
   {
-     set_bit(WD_WLAN_DETECT_THREAD_STUCK_MASK,
+     set_bit(WD_WLAN_DETECT_THREAD_STUCK,
                       &gpVosWatchdogContext->wdEventFlag);
-     set_bit(WD_POST_EVENT_MASK, &gpVosWatchdogContext->wdEventFlag);
+     set_bit(WD_POST_EVENT, &gpVosWatchdogContext->wdEventFlag);
      wake_up_interruptible(&gpVosWatchdogContext->wdWaitQueue);
   }
 }
@@ -836,14 +836,14 @@
   {
     // This implements the Watchdog execution model algorithm
     retWaitStatus = wait_event_interruptible(pWdContext->wdWaitQueue,
-       test_bit(WD_POST_EVENT_MASK, &pWdContext->wdEventFlag));
+       test_bit(WD_POST_EVENT, &pWdContext->wdEventFlag));
     if(retWaitStatus == -ERESTARTSYS)
     {
       VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
          "%s: wait_event_interruptible returned -ERESTARTSYS", __func__);
       break;
     }
-    clear_bit(WD_POST_EVENT_MASK, &pWdContext->wdEventFlag);
+    clear_bit(WD_POST_EVENT, &pWdContext->wdEventFlag);
     while(1)
     {
       /* Check for any Active Entry Points
@@ -874,20 +874,20 @@
                      __func__, atomic_read(&ssr_protect_entry_count));
       }
       // Check if Watchdog needs to shutdown
-      if(test_bit(WD_SHUTDOWN_EVENT_MASK, &pWdContext->wdEventFlag))
+      if(test_bit(WD_SHUTDOWN_EVENT, &pWdContext->wdEventFlag))
       {
         VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
                 "%s: Watchdog thread signaled to shutdown", __func__);
-        clear_bit(WD_SHUTDOWN_EVENT_MASK, &pWdContext->wdEventFlag);
+        clear_bit(WD_SHUTDOWN_EVENT, &pWdContext->wdEventFlag);
         shutdown = VOS_TRUE;
         break;
       }
       /* subsystem restart: shutdown event handler */
-      else if(test_bit(WD_WLAN_SHUTDOWN_EVENT_MASK, &pWdContext->wdEventFlag))
+      else if(test_bit(WD_WLAN_SHUTDOWN_EVENT, &pWdContext->wdEventFlag))
       {
         VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
                 "%s: Watchdog thread signaled to perform WLAN shutdown",__func__);
-        clear_bit(WD_WLAN_SHUTDOWN_EVENT_MASK, &pWdContext->wdEventFlag);
+        clear_bit(WD_WLAN_SHUTDOWN_EVENT, &pWdContext->wdEventFlag);
 
         //Perform WLAN shutdown
         if(!pWdContext->resetInProgress)
@@ -905,11 +905,11 @@
         }
       }
       /* subsystem restart: re-init event handler */
-      else if(test_bit(WD_WLAN_REINIT_EVENT_MASK, &pWdContext->wdEventFlag))
+      else if(test_bit(WD_WLAN_REINIT_EVENT, &pWdContext->wdEventFlag))
       {
         VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
                 "%s: Watchdog thread signaled to perform WLAN re-init",__func__);
-        clear_bit(WD_WLAN_REINIT_EVENT_MASK, &pWdContext->wdEventFlag);
+        clear_bit(WD_WLAN_REINIT_EVENT, &pWdContext->wdEventFlag);
 
         //Perform WLAN re-init
         if(!pWdContext->resetInProgress)
@@ -938,7 +938,7 @@
         complete(&pHddCtx->ssr_comp_var);
       }
       /* Post Msg to detect thread stuck */
-      else if(test_and_clear_bit(WD_WLAN_DETECT_THREAD_STUCK_MASK,
+      else if(test_and_clear_bit(WD_WLAN_DETECT_THREAD_STUCK,
                                           &pWdContext->wdEventFlag))
       {
         vos_wd_detect_thread_stuck();
@@ -1028,8 +1028,8 @@
   {
     // This implements the execution model algorithm
     retWaitStatus = wait_event_interruptible(pSchedContext->txWaitQueue,
-        test_bit(TX_POST_EVENT_MASK, &pSchedContext->txEventFlag) || 
-        test_bit(TX_SUSPEND_EVENT_MASK, &pSchedContext->txEventFlag));
+        test_bit(TX_POST_EVENT, &pSchedContext->txEventFlag) ||
+        test_bit(TX_SUSPEND_EVENT, &pSchedContext->txEventFlag));
 
 
     if(retWaitStatus == -ERESTARTSYS)
@@ -1038,17 +1038,17 @@
            "%s: wait_event_interruptible returned -ERESTARTSYS", __func__);
         break;
     }
-    clear_bit(TX_POST_EVENT_MASK, &pSchedContext->txEventFlag);
+    clear_bit(TX_POST_EVENT, &pSchedContext->txEventFlag);
 
     while(1)
     {
-      if(test_bit(TX_SHUTDOWN_EVENT_MASK, &pSchedContext->txEventFlag))
+      if(test_bit(TX_SHUTDOWN_EVENT, &pSchedContext->txEventFlag))
       {
         VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
                  "%s: TX thread signaled to shutdown", __func__);
         shutdown = VOS_TRUE;
         /* Check for any Suspend Indication */
-        if (test_and_clear_bit(TX_SUSPEND_EVENT_MASK,
+        if (test_and_clear_bit(TX_SUSPEND_EVENT,
                                &pSchedContext->txEventFlag))
         {
            /* Unblock anyone waiting on suspend */
@@ -1138,7 +1138,7 @@
         continue;
       }
       /* Check for any Suspend Indication */
-      if (test_and_clear_bit(TX_SUSPEND_EVENT_MASK,
+      if (test_and_clear_bit(TX_SUSPEND_EVENT,
                              &pSchedContext->txEventFlag))
       {
         spin_lock(&pSchedContext->TxThreadLock);
@@ -1221,8 +1221,8 @@
   {
     // This implements the execution model algorithm
     retWaitStatus = wait_event_interruptible(pSchedContext->rxWaitQueue,
-        test_bit(RX_POST_EVENT_MASK, &pSchedContext->rxEventFlag) || 
-        test_bit(RX_SUSPEND_EVENT_MASK, &pSchedContext->rxEventFlag));
+        test_bit(RX_POST_EVENT, &pSchedContext->rxEventFlag) ||
+        test_bit(RX_SUSPEND_EVENT, &pSchedContext->rxEventFlag));
 
 
     if(retWaitStatus == -ERESTARTSYS)
@@ -1231,17 +1231,17 @@
            "%s: wait_event_interruptible returned -ERESTARTSYS", __func__);
         break;
     }
-    clear_bit(RX_POST_EVENT_MASK, &pSchedContext->rxEventFlag);
+    clear_bit(RX_POST_EVENT, &pSchedContext->rxEventFlag);
 
     while(1)
     {
-      if(test_bit(RX_SHUTDOWN_EVENT_MASK, &pSchedContext->rxEventFlag))
+      if(test_bit(RX_SHUTDOWN_EVENT, &pSchedContext->rxEventFlag))
       {
         VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
                  "%s: RX thread signaled to shutdown", __func__);
         shutdown = VOS_TRUE;
         /* Check for any Suspend Indication */
-        if (test_and_clear_bit(RX_SUSPEND_EVENT_MASK,
+        if (test_and_clear_bit(RX_SUSPEND_EVENT,
                                &pSchedContext->rxEventFlag))
         {
            /* Unblock anyone waiting on suspend */
@@ -1337,7 +1337,7 @@
       }
 
       /* Check for any Suspend Indication */
-      if (test_and_clear_bit(RX_SUSPEND_EVENT_MASK,
+      if (test_and_clear_bit(RX_SUSPEND_EVENT,
                              &pSchedContext->rxEventFlag))
       {
         spin_lock(&pSchedContext->RxThreadLock);
@@ -1387,24 +1387,24 @@
     }
 
     // shut down MC Thread
-    set_bit(MC_SHUTDOWN_EVENT_MASK, &gpVosSchedContext->mcEventFlag);
-    set_bit(MC_POST_EVENT_MASK, &gpVosSchedContext->mcEventFlag);
+    set_bit(MC_SHUTDOWN_EVENT, &gpVosSchedContext->mcEventFlag);
+    set_bit(MC_POST_EVENT, &gpVosSchedContext->mcEventFlag);
     wake_up_interruptible(&gpVosSchedContext->mcWaitQueue);
     //Wait for MC to exit
     wait_for_completion(&gpVosSchedContext->McShutdown);
     gpVosSchedContext->McThread = 0;
 
     // shut down TX Thread
-    set_bit(TX_SHUTDOWN_EVENT_MASK, &gpVosSchedContext->txEventFlag);
-    set_bit(TX_POST_EVENT_MASK, &gpVosSchedContext->txEventFlag);
+    set_bit(TX_SHUTDOWN_EVENT, &gpVosSchedContext->txEventFlag);
+    set_bit(TX_POST_EVENT, &gpVosSchedContext->txEventFlag);
     wake_up_interruptible(&gpVosSchedContext->txWaitQueue);
     //Wait for TX to exit
     wait_for_completion(&gpVosSchedContext->TxShutdown);
     gpVosSchedContext->TxThread = 0;
 
     // shut down RX Thread
-    set_bit(RX_SHUTDOWN_EVENT_MASK, &gpVosSchedContext->rxEventFlag);
-    set_bit(RX_POST_EVENT_MASK, &gpVosSchedContext->rxEventFlag);
+    set_bit(RX_SHUTDOWN_EVENT, &gpVosSchedContext->rxEventFlag);
+    set_bit(RX_POST_EVENT, &gpVosSchedContext->rxEventFlag);
     wake_up_interruptible(&gpVosSchedContext->rxWaitQueue);
     //Wait for RX to exit
     wait_for_completion(&gpVosSchedContext->RxShutdown);
@@ -1431,8 +1431,8 @@
            "%s: gpVosWatchdogContext is NULL",__func__);
        return VOS_STATUS_E_FAILURE;
     }
-    set_bit(WD_SHUTDOWN_EVENT_MASK, &gpVosWatchdogContext->wdEventFlag);
-    set_bit(WD_POST_EVENT_MASK, &gpVosWatchdogContext->wdEventFlag);
+    set_bit(WD_SHUTDOWN_EVENT, &gpVosWatchdogContext->wdEventFlag);
+    set_bit(WD_POST_EVENT, &gpVosWatchdogContext->wdEventFlag);
     wake_up_interruptible(&gpVosWatchdogContext->wdWaitQueue);
     //Wait for Watchdog thread to exit
     wait_for_completion(&gpVosWatchdogContext->WdShutdown);
@@ -2061,8 +2061,8 @@
     }
 #endif
 
-    set_bit(WD_WLAN_SHUTDOWN_EVENT_MASK, &gpVosWatchdogContext->wdEventFlag);
-    set_bit(WD_POST_EVENT_MASK, &gpVosWatchdogContext->wdEventFlag);
+    set_bit(WD_WLAN_SHUTDOWN_EVENT, &gpVosWatchdogContext->wdEventFlag);
+    set_bit(WD_POST_EVENT, &gpVosWatchdogContext->wdEventFlag);
     wake_up_interruptible(&gpVosWatchdogContext->wdWaitQueue);
 
     return VOS_STATUS_SUCCESS;
@@ -2084,8 +2084,8 @@
 VOS_STATUS vos_watchdog_wlan_re_init(void)
 {
     /* watchdog task is still running, it is not closed in shutdown */
-    set_bit(WD_WLAN_REINIT_EVENT_MASK, &gpVosWatchdogContext->wdEventFlag);
-    set_bit(WD_POST_EVENT_MASK, &gpVosWatchdogContext->wdEventFlag);
+    set_bit(WD_WLAN_REINIT_EVENT, &gpVosWatchdogContext->wdEventFlag);
+    set_bit(WD_POST_EVENT, &gpVosWatchdogContext->wdEventFlag);
     wake_up_interruptible(&gpVosWatchdogContext->wdWaitQueue);
 
     return VOS_STATUS_SUCCESS;
diff --git a/CORE/VOSS/src/vos_sched.h b/CORE/VOSS/src/vos_sched.h
index f687aff..f1b680e 100644
--- a/CORE/VOSS/src/vos_sched.h
+++ b/CORE/VOSS/src/vos_sched.h
@@ -77,21 +77,22 @@
 #include <vos_timer.h>
 
 
-#define TX_POST_EVENT_MASK               0x001
-#define TX_SUSPEND_EVENT_MASK            0x002
-#define MC_POST_EVENT_MASK               0x001
-#define MC_SUSPEND_EVENT_MASK            0x002
-#define RX_POST_EVENT_MASK               0x001
-#define RX_SUSPEND_EVENT_MASK            0x002
-#define TX_SHUTDOWN_EVENT_MASK           0x010
-#define MC_SHUTDOWN_EVENT_MASK           0x010
-#define RX_SHUTDOWN_EVENT_MASK           0x010
-#define WD_POST_EVENT_MASK               0x001
-#define WD_SHUTDOWN_EVENT_MASK           0x002
-#define WD_CHIP_RESET_EVENT_MASK         0x004
-#define WD_WLAN_SHUTDOWN_EVENT_MASK      0x008
-#define WD_WLAN_REINIT_EVENT_MASK        0x010
-#define WD_WLAN_DETECT_THREAD_STUCK_MASK 0x020
+#define TX_POST_EVENT               0x000
+#define TX_SUSPEND_EVENT            0x001
+#define MC_POST_EVENT               0x000
+#define MC_SUSPEND_EVENT            0x001
+#define RX_POST_EVENT               0x000
+#define RX_SUSPEND_EVENT            0x001
+#define TX_SHUTDOWN_EVENT           0x002
+#define MC_SHUTDOWN_EVENT           0x002
+#define RX_SHUTDOWN_EVENT           0x002
+
+#define WD_POST_EVENT               0x000
+#define WD_SHUTDOWN_EVENT           0x001
+#define WD_CHIP_RESET_EVENT         0x002
+#define WD_WLAN_SHUTDOWN_EVENT      0x003
+#define WD_WLAN_REINIT_EVENT        0x004
+#define WD_WLAN_DETECT_THREAD_STUCK 0x005