qcacld-2.0: Pass proper values to bit manipulation methods to avoid panic

prima to qcacld-2.0 propagation

Observed kernel panic due to improper arguments passed to kernel bit
manipulation functions (like set_bit, clear_bit etc.) i.e these
functions expects bit positions as its first argument but bit mask
values are being passed.

To fix these issues ensure below points:
   - Pass bit position as a first argument to bit manipulation
     functions.
   - Re-define MACROs which gives false impression of bit mask values
     with their naming convention.

Change-Id: Ief8cd83b05f01a0926f91c0e9fb461ddd498e05e
CRs-Fixed: 981050

5 files changed, 66 insertions, 66 deletions

diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index 2eabccd8cc90..e8e29397f793 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -24121,7 +24121,7 @@ int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
     }
 
     /* Suspend MC thread */
-    set_bit(MC_SUSPEND_EVENT_MASK, &vosSchedContext->mcEventFlag);
+    set_bit(MC_SUSPEND_EVENT, &vosSchedContext->mcEventFlag);
     wake_up_interruptible(&vosSchedContext->mcWaitQueue);
 
     /* Wait for suspend confirmation from MC thread */
@@ -24129,7 +24129,7 @@ int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
                                  msecs_to_jiffies(WLAN_WAIT_TIME_MCTHREAD_SUSPEND));
     if (!rc)
     {
-        clear_bit(MC_SUSPEND_EVENT_MASK, &vosSchedContext->mcEventFlag);
+        clear_bit(MC_SUSPEND_EVENT, &vosSchedContext->mcEventFlag);
         VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
                    "%s: Failed to stop mc thread", __func__);
         goto resume_tx;
@@ -24139,13 +24139,13 @@ int __wlan_hdd_cfg80211_suspend_wlan(struct wiphy *wiphy,
 
 #ifdef QCA_CONFIG_SMP
     /* Suspend tlshim rx thread */
-    set_bit(RX_SUSPEND_EVENT_MASK, &vosSchedContext->tlshimRxEvtFlg);
+    set_bit(RX_SUSPEND_EVENT, &vosSchedContext->tlshimRxEvtFlg);
     wake_up_interruptible(&vosSchedContext->tlshimRxWaitQueue);
     rc = wait_for_completion_timeout(
                      &vosSchedContext->SuspndTlshimRxEvent,
                      msecs_to_jiffies(RX_TLSHIM_SUSPEND_TIMEOUT));
     if (!rc) {
-        clear_bit(RX_SUSPEND_EVENT_MASK, &vosSchedContext->tlshimRxEvtFlg);
+        clear_bit(RX_SUSPEND_EVENT, &vosSchedContext->tlshimRxEvtFlg);
         VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
                    "%s: Failed to stop tl_shim rx thread", __func__);
         goto resume_all;
diff --git a/CORE/HDD/src/wlan_hdd_early_suspend.c b/CORE/HDD/src/wlan_hdd_early_suspend.c
index 1eda234e21a4..e62ddd1a772b 100644
--- a/CORE/HDD/src/wlan_hdd_early_suspend.c
+++ b/CORE/HDD/src/wlan_hdd_early_suspend.c
@@ -2036,8 +2036,8 @@ VOS_STATUS hdd_wlan_shutdown(void)
     */
    /* 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);
 
@@ -2046,8 +2046,8 @@ VOS_STATUS hdd_wlan_shutdown(void)
    hddLog(VOS_TRACE_LEVEL_FATAL, "%s: Shutting down TLshim RX thread",
           __func__);
    unregister_hotcpu_notifier(vosSchedContext->cpuHotPlugNotifier);
-   set_bit(RX_SHUTDOWN_EVENT_MASK, &vosSchedContext->tlshimRxEvtFlg);
-   set_bit(RX_POST_EVENT_MASK, &vosSchedContext->tlshimRxEvtFlg);
+   set_bit(RX_SHUTDOWN_EVENT, &vosSchedContext->tlshimRxEvtFlg);
+   set_bit(RX_POST_EVENT, &vosSchedContext->tlshimRxEvtFlg);
    wake_up_interruptible(&vosSchedContext->tlshimRxWaitQueue);
    hddLog(VOS_TRACE_LEVEL_FATAL, "%s: Waiting for TLshim RX thread to exit",
           __func__);
diff --git a/CORE/VOSS/src/vos_api.c b/CORE/VOSS/src/vos_api.c
index d02535b0e19d..02ee360aa946 100644
--- a/CORE/VOSS/src/vos_api.c
+++ b/CORE/VOSS/src/vos_api.c
@@ -1958,7 +1958,7 @@ VOS_STATUS vos_mq_post_message_by_priority(VOS_MQ_ID msgQueueId,
   else
       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;
diff --git a/CORE/VOSS/src/vos_sched.c b/CORE/VOSS/src/vos_sched.c
index ab1bdfe301ee..aa5607c2d933 100644
--- a/CORE/VOSS/src/vos_sched.c
+++ b/CORE/VOSS/src/vos_sched.c
@@ -626,8 +626,8 @@ TLSHIM_RX_THREAD_START_FAILURE:
 #endif
 MC_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);
@@ -764,8 +764,8 @@ VosMCThread
   {
     // 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)
     {
@@ -773,20 +773,20 @@ VosMCThread
          "%s: wait_event_interruptible returned -ERESTARTSYS", __func__);
       VOS_BUG(0);
     }
-    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_bit(MC_SUSPEND_EVENT_MASK, &pSchedContext->mcEventFlag))
+        if(test_bit(MC_SUSPEND_EVENT, &pSchedContext->mcEventFlag))
         {
-           clear_bit(MC_SUSPEND_EVENT_MASK, &pSchedContext->mcEventFlag);
+           clear_bit(MC_SUSPEND_EVENT, &pSchedContext->mcEventFlag);
 
            /* Unblock anyone waiting on suspend */
            complete(&pHddCtx->mc_sus_event_var);
@@ -939,9 +939,9 @@ VosMCThread
         continue;
       }
       /* Check for any Suspend Indication */
-      if(test_bit(MC_SUSPEND_EVENT_MASK, &pSchedContext->mcEventFlag))
+      if(test_bit(MC_SUSPEND_EVENT, &pSchedContext->mcEventFlag))
       {
-        clear_bit(MC_SUSPEND_EVENT_MASK, &pSchedContext->mcEventFlag);
+        clear_bit(MC_SUSPEND_EVENT, &pSchedContext->mcEventFlag);
         spin_lock(&pSchedContext->McThreadLock);
 
         INIT_COMPLETION(pSchedContext->ResumeMcEvent);
@@ -1038,9 +1038,9 @@ static void vos_wd_detect_thread_stuck_cb(void *priv)
 	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);
 	}
 }
@@ -1125,21 +1125,21 @@ VosWDThread
   {
     // 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)
     {
       /* Post Msg to detect thread stuck */
-      if (test_and_clear_bit(WD_WLAN_DETECT_THREAD_STUCK_MASK,
+      if (test_and_clear_bit(WD_WLAN_DETECT_THREAD_STUCK,
                                    &pWdContext->wdEventFlag)) {
 
-       if (!test_bit(MC_SUSPEND_EVENT_MASK, &gpVosSchedContext->mcEventFlag))
+       if (!test_bit(MC_SUSPEND_EVENT, &gpVosSchedContext->mcEventFlag))
             vos_wd_detect_thread_stuck();
        else
             VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
@@ -1179,21 +1179,21 @@ VosWDThread
                      __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)
@@ -1211,11 +1211,11 @@ VosWDThread
         }
       }
       /* 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)
@@ -1382,7 +1382,7 @@ void vos_indicate_rxpkt(pVosSchedContext pSchedContext,
    spin_lock_bh(&pSchedContext->TlshimRxQLock);
    list_add_tail(&pkt->list, &pSchedContext->tlshimRxQueue);
    spin_unlock_bh(&pSchedContext->TlshimRxQLock);
-   set_bit(RX_POST_EVENT_MASK, &pSchedContext->tlshimRxEvtFlg);
+   set_bit(RX_POST_EVENT, &pSchedContext->tlshimRxEvtFlg);
    wake_up_interruptible(&pSchedContext->tlshimRxWaitQueue);
 }
 
@@ -1495,22 +1495,22 @@ static int VosTlshimRxThread(void *arg)
 
    while (!shutdown) {
        status = wait_event_interruptible(pSchedContext->tlshimRxWaitQueue,
-                         test_bit(RX_POST_EVENT_MASK,
+                         test_bit(RX_POST_EVENT,
                                   &pSchedContext->tlshimRxEvtFlg) ||
-                         test_bit(RX_SUSPEND_EVENT_MASK,
+                         test_bit(RX_SUSPEND_EVENT,
                                   &pSchedContext->tlshimRxEvtFlg));
        if (status == -ERESTARTSYS)
            break;
 
-       clear_bit(RX_POST_EVENT_MASK, &pSchedContext->tlshimRxEvtFlg);
+       clear_bit(RX_POST_EVENT, &pSchedContext->tlshimRxEvtFlg);
        while (true) {
-           if (test_bit(RX_SHUTDOWN_EVENT_MASK,
+           if (test_bit(RX_SHUTDOWN_EVENT,
                       &pSchedContext->tlshimRxEvtFlg)) {
-               clear_bit(RX_SHUTDOWN_EVENT_MASK,
+               clear_bit(RX_SHUTDOWN_EVENT,
                          &pSchedContext->tlshimRxEvtFlg);
-               if (test_bit(RX_SUSPEND_EVENT_MASK,
+               if (test_bit(RX_SUSPEND_EVENT,
                             &pSchedContext->tlshimRxEvtFlg)) {
-                   clear_bit(RX_SUSPEND_EVENT_MASK,
+                   clear_bit(RX_SUSPEND_EVENT,
                              &pSchedContext->tlshimRxEvtFlg);
                    complete(&pSchedContext->SuspndTlshimRxEvent);
                }
@@ -1521,9 +1521,9 @@ static int VosTlshimRxThread(void *arg)
            }
            vos_rx_from_queue(pSchedContext);
 
-           if (test_bit(RX_SUSPEND_EVENT_MASK,
+           if (test_bit(RX_SUSPEND_EVENT,
                         &pSchedContext->tlshimRxEvtFlg)) {
-               clear_bit(RX_SUSPEND_EVENT_MASK,
+               clear_bit(RX_SUSPEND_EVENT,
                          &pSchedContext->tlshimRxEvtFlg);
                spin_lock(&pSchedContext->TlshimRxThreadLock);
                INIT_COMPLETION(pSchedContext->ResumeTlshimRxEvent);
@@ -1570,8 +1570,8 @@ VOS_STATUS vos_sched_close ( v_PVOID_t pVosContext )
     }
 
     // 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);
@@ -1586,8 +1586,8 @@ VOS_STATUS vos_sched_close ( v_PVOID_t pVosContext )
 #ifdef QCA_CONFIG_SMP
     vos_lock_destroy(&gpVosSchedContext->affinity_lock);
     // Shut down Tlshim Rx thread
-    set_bit(RX_SHUTDOWN_EVENT_MASK, &gpVosSchedContext->tlshimRxEvtFlg);
-    set_bit(RX_POST_EVENT_MASK, &gpVosSchedContext->tlshimRxEvtFlg);
+    set_bit(RX_SHUTDOWN_EVENT, &gpVosSchedContext->tlshimRxEvtFlg);
+    set_bit(RX_POST_EVENT, &gpVosSchedContext->tlshimRxEvtFlg);
     wake_up_interruptible(&gpVosSchedContext->tlshimRxWaitQueue);
     wait_for_completion(&gpVosSchedContext->TlshimRxShutdown);
     gpVosSchedContext->TlshimRxThread = NULL;
@@ -1608,8 +1608,8 @@ VOS_STATUS vos_watchdog_close ( v_PVOID_t pVosContext )
            "%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);
@@ -1955,8 +1955,8 @@ VOS_STATUS vos_watchdog_wlan_shutdown(void)
     }
 #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;
@@ -1984,8 +1984,8 @@ VOS_STATUS vos_watchdog_wlan_re_init(void)
         return VOS_STATUS_SUCCESS;
     }
     /* 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 ed39240d99f5..a2669424068d 100644
--- a/CORE/VOSS/src/vos_sched.h
+++ b/CORE/VOSS/src/vos_sched.h
@@ -73,21 +73,21 @@
 #include <vos_lock.h>
 #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