qcacld:HDD: Support for logging string conversion of device mode

This is prima to qcacld-2.0 propagation.

As a part of logging enhancement, to make logs more descriptive
convert device_mode from numerical value to human readable string.

Change-Id: I7d9b727dcd8278fc31c826ce3dae437cf0f52041
CRs-Fixed: 773315

8 files changed, 181 insertions, 131 deletions

diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index 80e926ecb265..4ca42baa6609 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -1518,6 +1518,8 @@ struct hdd_context_s
 void wlan_hdd_check_sta_ap_concurrent_ch_intf(void *sta_pAdapter);
 #endif
 
+const char* hdd_device_mode_to_string(uint8_t device_mode);
+
 VOS_STATUS hdd_get_front_adapter( hdd_context_t *pHddCtx,
                                   hdd_adapter_list_node_t** ppAdapterNode);
 
diff --git a/CORE/HDD/src/wlan_hdd_assoc.c b/CORE/HDD/src/wlan_hdd_assoc.c
index 76daa2454d2b..9b317f65d9f5 100644
--- a/CORE/HDD/src/wlan_hdd_assoc.c
+++ b/CORE/HDD/src/wlan_hdd_assoc.c
@@ -4375,8 +4375,9 @@ int iw_set_essid(struct net_device *dev,
 
     if (pAdapter->device_mode != WLAN_HDD_INFRA_STATION &&
         pAdapter->device_mode != WLAN_HDD_P2P_CLIENT) {
-        hddLog(LOGW, "%s device mode %d is not allowed.",
-               __func__, pAdapter->device_mode);
+        hddLog(LOGW, FL("Device mode %s(%d) is not allowed"),
+               hdd_device_mode_to_string(pAdapter->device_mode),
+               pAdapter->device_mode);
         return -EINVAL;
     }
 
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index c05b94dbebc8..656b7a94514c 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -5604,8 +5604,9 @@ void wlan_hdd_cfg80211_set_key_wapi(hdd_adapter_t* pAdapter, u8 key_index,
     tANI_U8 *pKeyPtr = NULL;
     int n = 0;
 
-    hddLog(VOS_TRACE_LEVEL_INFO, "%s: device_mode = %d",
-                                        __func__,pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     vos_mem_zero(&setKey, sizeof(tCsrRoamSetKey));
     setKey.keyId = key_index; // Store Key ID
@@ -6237,9 +6238,9 @@ static int wlan_hdd_cfg80211_set_channel( struct wiphy *wiphy, struct net_device
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_SET_CHANNEL, pAdapter->sessionId,
                      channel_type ));
-    hddLog(VOS_TRACE_LEVEL_INFO,
-                "%s: device_mode = %d  freq = %d",__func__,
-                            pAdapter->device_mode, chan->center_freq);
+    hddLog(LOG1, FL("Device_mode %s(%d) freq = %d"),
+                 hdd_device_mode_to_string(pAdapter->device_mode),
+                 pAdapter->device_mode, chan->center_freq);
 
     pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
     status = wlan_hdd_validate_context(pHddCtx);
@@ -6280,9 +6281,9 @@ static int wlan_hdd_cfg80211_set_channel( struct wiphy *wiphy, struct net_device
                     "%s: Invalid Channel [%d]", __func__, channel);
             return -EINVAL;
         }
-        hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
-                "%s: set channel to [%d] for device mode =%d",
-                          __func__, channel,pAdapter->device_mode);
+        hddLog(LOG2, FL("set channel to [%d] for device mode %s(%d)"),
+               channel, hdd_device_mode_to_string(pAdapter->device_mode),
+               pAdapter->device_mode);
     }
     if( (pAdapter->device_mode == WLAN_HDD_INFRA_STATION)
      || (pAdapter->device_mode == WLAN_HDD_P2P_CLIENT)
@@ -6336,9 +6337,10 @@ static int wlan_hdd_cfg80211_set_channel( struct wiphy *wiphy, struct net_device
             {
                 (WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->sapConfig.channel =
                                                           AUTO_CHANNEL_SELECT;
-                hddLog(VOS_TRACE_LEVEL_INFO_HIGH,
-                       "%s: set channel to auto channel (0) for device mode =%d",
-                       __func__, pAdapter->device_mode);
+                hddLog(LOG2,
+                       FL("set channel to auto channel (0) for device mode %s(%d)"),
+                       hdd_device_mode_to_string(pAdapter->device_mode),
+                       pAdapter->device_mode);
             }
             else
             {
@@ -7167,7 +7169,9 @@ static int wlan_hdd_cfg80211_add_beacon(struct wiphy *wiphy,
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_ADD_BEACON,
                      pAdapter->sessionId, params->interval));
-    hddLog(LOG2, FL("Device mode=%d"), pAdapter->device_mode);
+    hddLog(LOG2, FL("Device mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
     status = wlan_hdd_validate_context(pHddCtx);
@@ -7229,7 +7233,9 @@ static int wlan_hdd_cfg80211_set_beacon(struct wiphy *wiphy,
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_SET_BEACON,
                      pAdapter->sessionId, pHddStaCtx->conn_info.authType));
-    hddLog(LOG1, FL("Device_mode = %d"), pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
     status = wlan_hdd_validate_context(pHddCtx);
@@ -7308,7 +7314,9 @@ static int wlan_hdd_cfg80211_stop_ap (struct wiphy *wiphy,
         return -EOPNOTSUPP;
     }
 
-    hddLog(LOG1, FL("Device_mode = %d"), pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     status = hdd_get_front_adapter (pHddCtx, &pAdapterNode);
     while (NULL != pAdapterNode && VOS_STATUS_SUCCESS == status) {
@@ -7461,8 +7469,9 @@ static int wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
         return status;
     }
 
-    hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "%s: pAdapter = %p, device mode = %d",
-           __func__, pAdapter, pAdapter->device_mode);
+    hddLog(LOG2, FL("pAdapter = %p, device mode %s(%d)"),
+           pAdapter, hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     if (vos_max_concurrent_connections_reached()) {
         hddLog(VOS_TRACE_LEVEL_DEBUG, FL("Reached max concurrent connections"));
@@ -7533,7 +7542,9 @@ static int wlan_hdd_cfg80211_change_beacon(struct wiphy *wiphy,
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_CHANGE_BEACON,
                      pAdapter->sessionId, pAdapter->device_mode));
-    hddLog(VOS_TRACE_LEVEL_INFO, FL("device_mode = %d"), pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
     status = wlan_hdd_validate_context(pHddCtx);
@@ -7587,8 +7598,9 @@ static int __wlan_hdd_cfg80211_change_bss (struct wiphy *wiphy,
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_CHANGE_BSS,
                      pAdapter->sessionId, params->ap_isolate));
-    hddLog(VOS_TRACE_LEVEL_INFO, FL("device_mode = %d, ap_isolate = %d"),
-                               pAdapter->device_mode, params->ap_isolate);
+    hddLog(LOG1, FL("Device_mode %s(%d), ap_isolate = %d"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode, params->ap_isolate);
 
     pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
     ret = wlan_hdd_validate_context(pHddCtx);
@@ -7740,8 +7752,9 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
                      TRACE_CODE_HDD_CFG80211_CHANGE_IFACE,
                      pAdapter->sessionId, type));
 
-    hddLog(VOS_TRACE_LEVEL_INFO, FL("Device_mode = %d, IFTYPE = 0x%x"),
-                                 pAdapter->device_mode, type);
+    hddLog(LOG1, FL("Device_mode %s(%d), IFTYPE = 0x%x"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode, type);
 
     if (vos_max_concurrent_connections_reached()) {
         hddLog(VOS_TRACE_LEVEL_DEBUG, FL("Reached max concurrent connections"));
@@ -8500,8 +8513,9 @@ static int __wlan_hdd_cfg80211_add_key( struct wiphy *wiphy,
         return status;
     }
 
-    hddLog(VOS_TRACE_LEVEL_INFO, "%s: device_mode = %d",
-            __func__, pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     if (CSR_MAX_NUM_KEY <= key_index)
     {
@@ -8845,7 +8859,9 @@ static int __wlan_hdd_cfg80211_get_key(
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_GET_KEY,
                      pAdapter->sessionId, params.cipher));
-    hddLog(VOS_TRACE_LEVEL_INFO, FL("Device_mode = %d"), pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     memset(&params, 0, sizeof(params));
 
@@ -8937,8 +8953,9 @@ static int wlan_hdd_cfg80211_del_key( struct wiphy *wiphy,
 
     ENTER();
 
-    hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "%s: device_mode = %d",
-                                     __func__,pAdapter->device_mode);
+    hddLog(LOG2, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     if (CSR_MAX_NUM_KEY <= key_index)
     {
@@ -9071,7 +9088,8 @@ static int __wlan_hdd_cfg80211_set_default_key( struct wiphy *wiphy,
                      TRACE_CODE_HDD_CFG80211_SET_DEFAULT_KEY,
                      pAdapter->sessionId, key_index));
 
-    hddLog(LOG1, FL("Device_mode = %d key_index = %d"),
+    hddLog(LOG1, FL("Device_mode %s(%d) key_index = %d"),
+                 hdd_device_mode_to_string(pAdapter->device_mode),
                  pAdapter->device_mode, key_index);
 
     if (CSR_MAX_NUM_KEY <= key_index) {
@@ -9888,9 +9906,9 @@ v_BOOL_t hdd_isConnectionInProgress( hdd_context_t *pHddCtx )
 
         if( pAdapter )
         {
-            hddLog(VOS_TRACE_LEVEL_INFO,
-                    "%s: Adapter with device mode %d exists",
-                    __func__, pAdapter->device_mode);
+            hddLog(LOG1, FL("Adapter with device mode %s(%d) exists"),
+                   hdd_device_mode_to_string(pAdapter->device_mode),
+                   pAdapter->device_mode);
             if (((WLAN_HDD_INFRA_STATION == pAdapter->device_mode) ||
                  (WLAN_HDD_P2P_CLIENT == pAdapter->device_mode) ||
                  (WLAN_HDD_P2P_DEVICE == pAdapter->device_mode)) &&
@@ -9991,8 +10009,9 @@ int __wlan_hdd_cfg80211_scan( struct wiphy *wiphy,
                      TRACE_CODE_HDD_CFG80211_SCAN,
                      pAdapter->sessionId, request->n_channels));
 
-    hddLog(VOS_TRACE_LEVEL_INFO, "%s: device_mode = %d",
-           __func__, pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     status = wlan_hdd_validate_context(pHddCtx);
 
@@ -11392,8 +11411,9 @@ static int __wlan_hdd_cfg80211_connect( struct wiphy *wiphy,
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_CONNECT,
                      pAdapter->sessionId, pAdapter->device_mode));
-    hddLog(VOS_TRACE_LEVEL_INFO,
-             "%s: device_mode = %d",__func__,pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     if (pAdapter->device_mode != WLAN_HDD_INFRA_STATION &&
         pAdapter->device_mode != WLAN_HDD_P2P_CLIENT) {
@@ -11642,8 +11662,9 @@ static int __wlan_hdd_cfg80211_disconnect( struct wiphy *wiphy,
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_DISCONNECT,
                      pAdapter->sessionId, reason));
-    hddLog(VOS_TRACE_LEVEL_INFO, FL("device_mode (%d) reason code(%d)"),
-                                 pAdapter->device_mode, reason);
+    hddLog(LOG1, FL("Device_mode %s(%d) reason code(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode, reason);
 
     status = wlan_hdd_validate_context(pHddCtx);
 
@@ -11857,8 +11878,9 @@ static int __wlan_hdd_cfg80211_join_ibss(struct wiphy *wiphy,
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_CFG80211_JOIN_IBSS,
                      pAdapter->sessionId, pAdapter->device_mode));
-    hddLog(VOS_TRACE_LEVEL_INFO,
-                  "%s: device_mode = %d",__func__,pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
     status = wlan_hdd_validate_context(pHddCtx);
 
@@ -12065,7 +12087,9 @@ static int __wlan_hdd_cfg80211_leave_ibss(struct wiphy *wiphy,
         return status;
     }
 
-    hddLog(VOS_TRACE_LEVEL_INFO, FL("device_mode = %d"), pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
     if (NULL == pWextState) {
         hddLog(VOS_TRACE_LEVEL_ERROR, FL("Data Storage Corruption"));
         return -EIO;
@@ -14765,8 +14789,7 @@ static int wlan_hdd_cfg80211_set_mac_acl(struct wiphy *wiphy,
     VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,"acl policy: = %d"
              "no acl entries = %d", params->acl_policy, params->n_acl_entries);
 
-    if (WLAN_HDD_SOFTAP == pAdapter->device_mode)
-    {
+    if (WLAN_HDD_SOFTAP == pAdapter->device_mode) {
         pConfig = &pAdapter->sessionCtx.ap.sapConfig;
 
         /* default value */
@@ -14836,12 +14859,10 @@ static int wlan_hdd_cfg80211_set_mac_acl(struct wiphy *wiphy,
                        "%s: SAP Set Mac Acl fail", __func__);
             return -EINVAL;
         }
-    }
-    else
-    {
-        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
-                   "%s: Invalid device_mode = %d",
-                                 __func__, pAdapter->device_mode);
+    } else {
+        hddLog(LOGE, FL("Invalid device_mode %s(%d)"),
+               hdd_device_mode_to_string(pAdapter->device_mode),
+               pAdapter->device_mode);
         return -EINVAL;
     }
 
diff --git a/CORE/HDD/src/wlan_hdd_ipa.c b/CORE/HDD/src/wlan_hdd_ipa.c
index 1fa668901e4e..07abf2d02ffe 100644
--- a/CORE/HDD/src/wlan_hdd_ipa.c
+++ b/CORE/HDD/src/wlan_hdd_ipa.c
@@ -2813,9 +2813,11 @@ int hdd_ipa_send_mcc_scc_msg(hdd_context_t *hdd_ctx, bool mcc_mode)
 			pAdapter = adapter_node->pAdapter;
 			if (pAdapter->device_mode == WLAN_HDD_INFRA_STATION ||
 				pAdapter->device_mode == WLAN_HDD_SOFTAP) {
-				hddLog(VOS_TRACE_LEVEL_INFO,
-					"MCC->SCC: Flush TxRx queue(d_mode=%d)",
-					pAdapter->device_mode);
+				hddLog(LOG1,
+					"MCC->SCC: Flush TxRx queue(d_mode %s(%d))",
+					hdd_device_mode_to_string(
+						pAdapter->device_mode),
+                                        pAdapter->device_mode);
 				hdd_deinit_tx_rx(pAdapter);
 			}
 			status = hdd_get_next_adapter(
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index 8573ce6b46a2..a980f4055935 100755
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -388,7 +388,9 @@ static int hdd_is_auto_suspend_allowed(hdd_context_t *hdd_ctx)
         case WLAN_HDD_P2P_CLIENT:
         case WLAN_HDD_IBSS:
         default:
-             hddLog(LOG1, FL("Auto suspend denied %d"), adapter->device_mode);
+             hddLog(LOG1, FL("Auto suspend denied device_mode %s(%d)"),
+                    hdd_device_mode_to_string(adapter->device_mode),
+                    adapter->device_mode);
              perm = HDD_AUTO_SUSPEND_DENIED;
              break;
         }
@@ -666,6 +668,31 @@ static inline void hdd_deinit_auto_suspend_timer(hdd_context_t *hdd_ctx) {}
    can extract it from driver debug symbol and crashdump for post processing */
 tANI_U8 g_wlan_driver_version[ ] = QWLAN_VERSIONSTR;
 
+/**
+ * hdd_device_mode_to_string() - return string conversion of device mode
+ * @device_mode: device mode
+ *
+ * This utility function helps log string conversion of device mode.
+ *
+ * Return: string conversion of device mode, if match found;
+ *	   "Unknown" otherwise.
+ */
+const char* hdd_device_mode_to_string(uint8_t device_mode)
+{
+	switch (device_mode) {
+	CASE_RETURN_STRING(WLAN_HDD_INFRA_STATION);
+	CASE_RETURN_STRING(WLAN_HDD_SOFTAP);
+	CASE_RETURN_STRING(WLAN_HDD_P2P_CLIENT);
+	CASE_RETURN_STRING(WLAN_HDD_P2P_GO);
+	CASE_RETURN_STRING(WLAN_HDD_MONITOR);
+	CASE_RETURN_STRING(WLAN_HDD_FTM);
+	CASE_RETURN_STRING(WLAN_HDD_IBSS);
+	CASE_RETURN_STRING(WLAN_HDD_P2P_DEVICE);
+	CASE_RETURN_STRING(WLAN_HDD_OCB);
+	default:
+		return "Unknown";
+	}
+}
 
 #ifdef FEATURE_GREEN_AP
 
@@ -4292,29 +4319,28 @@ int wlan_hdd_set_mc_rate(hdd_adapter_t *pAdapter, int targetRate)
    hdd_config_t *pConfig = NULL;
 
    if (pHddCtx == NULL) {
-      VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
-         "%s: HDD context is null", __func__);
+      hddLog(LOGE, FL("HDD context is null"));
       return -EINVAL;
    }
+
    if ((WLAN_HDD_IBSS != pAdapter->device_mode) &&
        (WLAN_HDD_SOFTAP != pAdapter->device_mode) &&
-       (WLAN_HDD_INFRA_STATION != pAdapter->device_mode))
-   {
-      VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
-         "%s: Received SETMCRATE command in invalid mode %d"
-         "SETMCRATE command is only allowed in STA, IBSS or SOFTAP mode",
-         __func__, pAdapter->device_mode);
+       (WLAN_HDD_INFRA_STATION != pAdapter->device_mode)) {
+      hddLog(LOGE, FL("Received SETMCRATE cmd in invalid device mode %s(%d)"),
+             hdd_device_mode_to_string(pAdapter->device_mode),
+             pAdapter->device_mode);
+      hddLog(LOGE,
+             FL("SETMCRATE cmd is allowed only in STA, IBSS or SOFTAP mode"));
       return -EINVAL;
    }
+
    pConfig = pHddCtx->cfg_ini;
-   rateUpdate = (tSirRateUpdateInd *)vos_mem_malloc(sizeof(tSirRateUpdateInd));
-   if (NULL == rateUpdate)
-   {
-      hddLog(VOS_TRACE_LEVEL_ERROR,
-         "%s: SETMCRATE indication alloc fail", __func__);
-      return -EFAULT;
+   rateUpdate = vos_mem_malloc(sizeof(tSirRateUpdateInd));
+   if (NULL == rateUpdate) {
+      hddLog(LOGE, FL("SETMCRATE indication alloc fail"));
+      return -ENOMEM;
    }
-   vos_mem_zero(rateUpdate, sizeof(tSirRateUpdateInd ));
+   vos_mem_zero(rateUpdate, sizeof(tSirRateUpdateInd));
    rateUpdate->nss = (pConfig->enable2x2 == 0) ? 0 : 1;
    rateUpdate->dev_mode = pAdapter->device_mode;
    rateUpdate->mcastDataRate24GHz = targetRate;
@@ -4323,14 +4349,14 @@ int wlan_hdd_set_mc_rate(hdd_adapter_t *pAdapter, int targetRate)
    rateUpdate->bcastDataRate = -1;
    memcpy(rateUpdate->bssid, pAdapter->macAddressCurrent.bytes,
       sizeof(rateUpdate->bssid));
-   VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,
-      "%s: MC Target rate %d, mac = %pM, dev_mode = %d",
-      __func__, rateUpdate->mcastDataRate24GHz, rateUpdate->bssid,
+   hddLog(LOG1, FL("MC Target rate %d, mac = %pM, dev_mode %s(%d)"),
+      rateUpdate->mcastDataRate24GHz, rateUpdate->bssid,
+      hdd_device_mode_to_string(pAdapter->device_mode),
       pAdapter->device_mode);
+
    status = sme_SendRateUpdateInd(pHddCtx->hHal, rateUpdate);
    if (eHAL_STATUS_SUCCESS != status) {
-      hddLog(VOS_TRACE_LEVEL_ERROR,
-         "%s: SETMCRATE failed", __func__);
+      hddLog(LOGE, FL("SETMCRATE failed"));
       vos_mem_free(rateUpdate);
       return -EFAULT;
    }
@@ -10491,7 +10517,8 @@ void hdd_dump_concurrency_info(hdd_context_t *pHddCtx)
              /* Temporary set log level as error
               * TX Flow control feature settled down, will lower log level */
              hddLog(VOS_TRACE_LEVEL_ERROR,
-                    "MODE %d, CH %d, LWM %d, HWM %d, TXQDEP %d",
+                    "MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+                    hdd_device_mode_to_string(pAdapter->device_mode),
                     pAdapter->device_mode,
                     targetChannel,
                     pAdapter->tx_flow_low_watermark,
@@ -10515,8 +10542,9 @@ void hdd_dump_concurrency_info(hdd_context_t *pHddCtx)
                 WLANTL_SetAdapterMaxQDepth(pHddCtx->pvosContext,
                                            pAdapter->sessionId,
                                            pHddCtx->cfg_ini->TxHbwFlowMaxQueueDepth);
-                hddLog(VOS_TRACE_LEVEL_ERROR,
-                      "SCC: MODE %d, CH %d, LWM %d, HWM %d, TXQDEP %d",
+                hddLog(LOGE,
+                      "SCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+                      hdd_device_mode_to_string(pAdapter->device_mode),
                       pAdapter->device_mode,
                       targetChannel,
                       pAdapter->tx_flow_low_watermark,
@@ -10540,7 +10568,8 @@ void hdd_dump_concurrency_info(hdd_context_t *pHddCtx)
                 /* Temporary set log level as error
                  * TX Flow control feature settled down, will lower log level */
                 hddLog(VOS_TRACE_LEVEL_ERROR,
-                      "SCC: MODE %d, CH %d, LWM %d, HWM %d, TXQDEP %d",
+                      "SCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+                      hdd_device_mode_to_string(preAdapterContext->device_mode),
                       preAdapterContext->device_mode,
                       targetChannel,
                       preAdapterContext->tx_flow_low_watermark,
@@ -10583,8 +10612,9 @@ void hdd_dump_concurrency_info(hdd_context_t *pHddCtx)
                                         pHddCtx->cfg_ini->TxHbwFlowMaxQueueDepth);
                 /* Temporary set log level as error
                  * TX Flow control feature settled down, will lower log level */
-                hddLog(VOS_TRACE_LEVEL_ERROR,
-                    "MCC: MODE %d, CH %d, LWM %d, HWM %d, TXQDEP %d",
+                hddLog(LOGE,
+                    "MCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+                    hdd_device_mode_to_string(pAdapter5->device_mode),
                     pAdapter5->device_mode,
                     channel5,
                     pAdapter5->tx_flow_low_watermark,
@@ -10607,8 +10637,9 @@ void hdd_dump_concurrency_info(hdd_context_t *pHddCtx)
                                         pHddCtx->cfg_ini->TxLbwFlowMaxQueueDepth);
                 /* Temporary set log level as error
                  * TX Flow control feature settled down, will lower log level */
-                hddLog(VOS_TRACE_LEVEL_ERROR,
-                    "MCC: MODE %d, CH %d, LWM %d, HWM %d, TXQDEP %d",
+                hddLog(LOGE,
+                    "MCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+                    hdd_device_mode_to_string(pAdapter2_4->device_mode),
                     pAdapter2_4->device_mode,
                     channel24,
                     pAdapter2_4->tx_flow_low_watermark,
@@ -13705,13 +13736,13 @@ static VOS_STATUS wlan_hdd_framework_restart(hdd_context_t *pHddCtx)
    status =  hdd_get_front_adapter ( pHddCtx, &pAdapterNode );
    do
    {
-      if( (status == VOS_STATUS_SUCCESS) &&
+      if ((status == VOS_STATUS_SUCCESS) &&
                            pAdapterNode  &&
-                           pAdapterNode->pAdapter)
-      {
-         VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,
-               "restarting the driver(intf:\'%s\' mode:%d :try %d)",
+                           pAdapterNode->pAdapter) {
+         hddLog(LOGP,
+               "restarting the driver(intf:\'%s\' mode:%s(%d) :try %d)",
                pAdapterNode->pAdapter->dev->name,
+               hdd_device_mode_to_string(pAdapterNode->pAdapter->device_mode),
                pAdapterNode->pAdapter->device_mode,
                pHddCtx->hdd_restart_retries + 1);
          /*
diff --git a/CORE/HDD/src/wlan_hdd_p2p.c b/CORE/HDD/src/wlan_hdd_p2p.c
index 8ed75afc3d75..f0fa7fb393fe 100644
--- a/CORE/HDD/src/wlan_hdd_p2p.c
+++ b/CORE/HDD/src/wlan_hdd_p2p.c
@@ -681,8 +681,9 @@ static int wlan_hdd_request_remain_on_channel( struct wiphy *wiphy,
     hdd_roc_req_t* phdd_roc_req;
     VOS_STATUS status;
 
-    hddLog(VOS_TRACE_LEVEL_INFO, "%s: device_mode = %d",
-                                 __func__, pAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode);
 
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0))
     hddLog( LOG1,
@@ -1113,20 +1114,14 @@ int __wlan_hdd_cfg80211_cancel_remain_on_channel( struct wiphy *wiphy,
      * The remain on channel callback will make sure the remain_on_chan
      * expired event is sent.
      */
-    if ( ( WLAN_HDD_INFRA_STATION == pAdapter->device_mode ) ||
-         ( WLAN_HDD_P2P_CLIENT == pAdapter->device_mode ) ||
-         ( WLAN_HDD_P2P_DEVICE == pAdapter->device_mode )
-       )
-    {
-
+    if ((WLAN_HDD_INFRA_STATION == pAdapter->device_mode) ||
+        (WLAN_HDD_P2P_CLIENT == pAdapter->device_mode) ||
+        (WLAN_HDD_P2P_DEVICE == pAdapter->device_mode)) {
         tANI_U8 sessionId = pAdapter->sessionId;
         sme_CancelRemainOnChannel( WLAN_HDD_GET_HAL_CTX( pAdapter ),
                                             sessionId );
-    }
-    else if ( (WLAN_HDD_SOFTAP== pAdapter->device_mode) ||
-              (WLAN_HDD_P2P_GO == pAdapter->device_mode)
-            )
-    {
+    } else if ((WLAN_HDD_SOFTAP== pAdapter->device_mode) ||
+              (WLAN_HDD_P2P_GO == pAdapter->device_mode)) {
         WLANSAP_CancelRemainOnChannel(
 #ifdef WLAN_FEATURE_MBSSID
                                 WLAN_HDD_GET_SAP_CTX_PTR(pAdapter));
@@ -1134,11 +1129,10 @@ int __wlan_hdd_cfg80211_cancel_remain_on_channel( struct wiphy *wiphy,
                                 (WLAN_HDD_GET_CTX(pAdapter))->pvosContext);
 #endif
 
-    }
-    else
-    {
-       hddLog(VOS_TRACE_LEVEL_ERROR, "%s: Invalid device_mode = %d",
-                            __func__, pAdapter->device_mode);
+    } else {
+       hddLog(LOGE, FL("Invalid device_mode %s(%d)"),
+              hdd_device_mode_to_string(pAdapter->device_mode),
+              pAdapter->device_mode);
        return -EIO;
     }
     rc = wait_for_completion_timeout(&pAdapter->cancel_rem_on_chan_var,
@@ -1230,8 +1224,9 @@ int __wlan_hdd_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
         return status;
     }
 
-    hddLog(VOS_TRACE_LEVEL_INFO, "%s: device_mode = %d type: %d",
-                            __func__, pAdapter->device_mode, type);
+    hddLog(LOG1, FL("Device_mode %s(%d) type: %d"),
+           hdd_device_mode_to_string(pAdapter->device_mode),
+           pAdapter->device_mode, type);
 
 #ifdef WLAN_FEATURE_P2P_DEBUG
     if ((type == SIR_MAC_MGMT_FRAME) &&
@@ -2185,8 +2180,9 @@ int __wlan_hdd_del_virtual_intf(struct wiphy *wiphy, struct net_device *dev)
     MTRACE(vos_trace(VOS_MODULE_ID_HDD,
                      TRACE_CODE_HDD_DEL_VIRTUAL_INTF,
                      pAdapter->sessionId, pAdapter->device_mode));
-    hddLog(VOS_TRACE_LEVEL_INFO, "%s: device_mode = %d",
-           __func__,pVirtAdapter->device_mode);
+    hddLog(LOG1, FL("Device_mode %s(%d)"),
+           hdd_device_mode_to_string(pVirtAdapter->device_mode),
+           pVirtAdapter->device_mode);
 
     status = wlan_hdd_validate_context(pHddCtx);
 
diff --git a/CORE/HDD/src/wlan_hdd_tdls.c b/CORE/HDD/src/wlan_hdd_tdls.c
index 657d0879f119..ad5970047f22 100644
--- a/CORE/HDD/src/wlan_hdd_tdls.c
+++ b/CORE/HDD/src/wlan_hdd_tdls.c
@@ -793,14 +793,13 @@ void wlan_hdd_tdls_exit(hdd_adapter_t *pAdapter)
     }
 
     pHddTdlsCtx = WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter);
-    if (NULL == pHddTdlsCtx)
-    {
+    if (NULL == pHddTdlsCtx) {
        /* TDLS context can be null and might have been freed up during
         * cleanup for STA adapter
         */
-       VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_HIGH,
-                 FL("pHddTdlsCtx is NULL, adapter device mode: %d"),
-                 pAdapter->device_mode);
+       hddLog(LOG2, FL("pHddTdlsCtx is NULL, adapter device mode %s(%d)"),
+              hdd_device_mode_to_string(pAdapter->device_mode),
+              pAdapter->device_mode);
        return;
     }
 
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 851b4e083692..f1a3305c8e5f 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -7815,21 +7815,18 @@ static int __iw_set_var_ints_getnone(struct net_device *dev,
     if(( sub_cmd == WE_MCC_CONFIG_CREDENTIAL ) ||
         (sub_cmd == WE_MCC_CONFIG_PARAMS ))
     {
-        if(( pAdapter->device_mode == WLAN_HDD_INFRA_STATION )||
-           ( pAdapter->device_mode == WLAN_HDD_P2P_CLIENT ))
-        {
+        if ((pAdapter->device_mode == WLAN_HDD_INFRA_STATION) ||
+           (pAdapter->device_mode == WLAN_HDD_P2P_CLIENT)) {
             pStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(pAdapter);
             staId = pStaCtx->conn_info.staId[0];
-        }
-        else if (( pAdapter->device_mode == WLAN_HDD_P2P_GO ) ||
-                 ( pAdapter->device_mode == WLAN_HDD_SOFTAP ))
-        {
+        } else if ((pAdapter->device_mode == WLAN_HDD_P2P_GO) ||
+                 (pAdapter->device_mode == WLAN_HDD_SOFTAP)) {
             pAPCtx = WLAN_HDD_GET_AP_CTX_PTR(pAdapter);
             staId = pAPCtx->uBCStaId;
-        }
-        else
-        {
-            hddLog(LOGE, "%s: Device mode %d not recognised", __FUNCTION__, pAdapter->device_mode);
+        } else {
+            hddLog(LOGE, FL("Device mode %s(%d) not recognised"),
+                   hdd_device_mode_to_string(pAdapter->device_mode),
+                   pAdapter->device_mode);
             return 0;
         }
     }
@@ -9655,13 +9652,14 @@ int hdd_setBand(struct net_device *dev, u8 ui_band)
                  long lrc;
 
                  /* STA already connected on current band, So issue disconnect
-                  * first, then change the band*/
-
-                 hddLog(VOS_TRACE_LEVEL_INFO,
-                         "%s STA (Device mode=%d) connected in band %u, Changing band to %u, Issuing Disconnect"
-                         "Set HDD connState to eConnectionState_NotConnected",
-                            __func__, pAdapter->device_mode,
-                            currBand, band);
+                  * first, then change the band */
+
+                 hddLog(LOG1,
+                        FL("STA Device mode %s(%d) connected band %u, Changing band to %u, Issuing Disconnect"),
+                        hdd_device_mode_to_string(pAdapter->device_mode),
+                        pAdapter->device_mode, currBand, band);
+                 hddLog(LOG1,
+                        FL("Set HDD connState to eConnectionState_NotConnected"));
 
                  pHddStaCtx->conn_info.connState = eConnectionState_NotConnected;
                  INIT_COMPLETION(pAdapter->disconnect_comp_var);