Merge "qcacld-2.0: Do not call kernel api spin_lock directly" into wlan-cld2.driver.lnx.1.0

52 files changed, 787 insertions, 833 deletions

diff --git a/CORE/HDD/inc/wlan_hdd_dp_utils.h b/CORE/HDD/inc/wlan_hdd_dp_utils.h
index 0a044784daf7..83bade36427a 100644
--- a/CORE/HDD/inc/wlan_hdd_dp_utils.h
+++ b/CORE/HDD/inc/wlan_hdd_dp_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -49,6 +49,7 @@
 #include <linux/spinlock.h>
 #include <vos_trace.h>
 #include <vos_list.h>
+#include <adf_os_lock.h>
 
 /**-----------------------------------------------------------------------------
   Preprocessor definitions and constants
@@ -64,7 +65,7 @@ typedef struct hdd_list_s
    hdd_list_node_t anchor;
    v_SIZE_t count;
    v_SIZE_t max_size;
-   spinlock_t lock;
+   adf_os_spinlock_t lock;
 } hdd_list_t;
 
 typedef struct
@@ -84,7 +85,7 @@ VOS_INLINE_FN v_VOID_t hdd_list_init( hdd_list_t *pList, v_SIZE_t max_size)
    INIT_LIST_HEAD( &pList->anchor );
    pList->count = 0;
    pList->max_size = max_size;
-   spin_lock_init(&pList->lock);
+   adf_os_spinlock_init(&pList->lock);
 }
 
 VOS_INLINE_FN v_VOID_t hdd_list_destroy( hdd_list_t *pList )
diff --git a/CORE/HDD/inc/wlan_hdd_hostapd.h b/CORE/HDD/inc/wlan_hdd_hostapd.h
index a45564def0d4..ea9a43683f36 100644
--- a/CORE/HDD/inc/wlan_hdd_hostapd.h
+++ b/CORE/HDD/inc/wlan_hdd_hostapd.h
@@ -151,9 +151,9 @@ static inline bool
 hdd_is_sta_connection_pending(hdd_context_t *hdd_ctx)
 {
     bool status;
-    spin_lock(&hdd_ctx->sta_update_info_lock);
+    adf_os_spin_lock(&hdd_ctx->sta_update_info_lock);
     status = hdd_ctx->is_sta_connection_pending;
-    spin_unlock(&hdd_ctx->sta_update_info_lock);
+    adf_os_spin_unlock(&hdd_ctx->sta_update_info_lock);
     return status;
 }
 
@@ -171,9 +171,9 @@ static inline void
 hdd_change_sta_conn_pending_status(hdd_context_t *hdd_ctx,
                                    bool value)
 {
-    spin_lock(&hdd_ctx->sta_update_info_lock);
+    adf_os_spin_lock(&hdd_ctx->sta_update_info_lock);
     hdd_ctx->is_sta_connection_pending = value;
-    spin_unlock(&hdd_ctx->sta_update_info_lock);
+    adf_os_spin_unlock(&hdd_ctx->sta_update_info_lock);
 }
 
 /**
@@ -189,10 +189,10 @@ static inline bool
 hdd_is_sap_restart_required(hdd_context_t *hdd_ctx)
 {
     bool status = false;
-    spin_lock(&hdd_ctx->sap_update_info_lock);
+    adf_os_spin_lock(&hdd_ctx->sap_update_info_lock);
     if (!hdd_ctx->is_ch_avoid_in_progress)
         status = hdd_ctx->is_sap_restart_required;
-    spin_unlock(&hdd_ctx->sap_update_info_lock);
+    adf_os_spin_unlock(&hdd_ctx->sap_update_info_lock);
     return status;
 }
 
@@ -211,9 +211,9 @@ static inline void
 hdd_change_sap_restart_required_status(hdd_context_t *hdd_ctx,
                                        bool value)
 {
-    spin_lock(&hdd_ctx->sap_update_info_lock);
+    adf_os_spin_lock(&hdd_ctx->sap_update_info_lock);
     hdd_ctx->is_sap_restart_required = value;
-    spin_unlock(&hdd_ctx->sap_update_info_lock);
+    adf_os_spin_unlock(&hdd_ctx->sap_update_info_lock);
 }
 
 /**
@@ -230,9 +230,9 @@ static inline void
 hdd_change_ch_avoidance_status(hdd_context_t *hdd_ctx,
                                bool value)
 {
-    spin_lock(&hdd_ctx->sap_update_info_lock);
+    adf_os_spin_lock(&hdd_ctx->sap_update_info_lock);
     hdd_ctx->is_ch_avoid_in_progress = value;
-    spin_unlock(&hdd_ctx->sap_update_info_lock);
+    adf_os_spin_unlock(&hdd_ctx->sap_update_info_lock);
     hddLog(LOG1, FL("is_ch_avoid_in_progress %d"), value);
 }
 
diff --git a/CORE/HDD/inc/wlan_hdd_main.h b/CORE/HDD/inc/wlan_hdd_main.h
index 63375984f4f3..de6e6cd77ff1 100644
--- a/CORE/HDD/inc/wlan_hdd_main.h
+++ b/CORE/HDD/inc/wlan_hdd_main.h
@@ -343,7 +343,7 @@ struct linkspeedContext
    unsigned int magic;
 };
 
-extern spinlock_t hdd_context_lock;
+extern adf_os_spinlock_t hdd_context_lock;
 
 #define STATS_CONTEXT_MAGIC 0x53544154   //STAT
 #define PEER_INFO_CONTEXT_MAGIC  0x52535349   /* PEER_INFO */
@@ -1301,7 +1301,7 @@ struct hdd_adapter_s
  */
     /** Multiple station supports */
    /** Per-station structure */
-   spinlock_t staInfo_lock; //To protect access to station Info
+   adf_os_spinlock_t staInfo_lock; //To protect access to station Info
    hdd_station_info_t aStaInfo[WLAN_MAX_STA_COUNT];
    //v_U8_t uNumActiveStation;
 
@@ -1335,7 +1335,7 @@ struct hdd_adapter_s
    vos_timer_t host_capture_req_timer;
 #ifdef WLAN_FEATURE_TSF_PLUS
    /* spin lock for read/write timestamps */
-   spinlock_t host_target_sync_lock;
+   adf_os_spinlock_t host_target_sync_lock;
    vos_timer_t host_target_sync_timer;
    uint64_t cur_host_time;
    uint64_t last_host_time;
@@ -1431,7 +1431,7 @@ struct hdd_adapter_s
 
     /* BITMAP indicating pause reason */
     uint32_t pause_map;
-    spinlock_t pause_map_lock;
+    adf_os_spinlock_t pause_map_lock;
 
     adf_os_time_t start_time;
     adf_os_time_t last_time;
@@ -1444,7 +1444,7 @@ struct hdd_adapter_s
     struct hdd_netif_queue_stats queue_oper_stats[WLAN_REASON_TYPE_MAX];
 
     /* random address management for management action frames */
-    spinlock_t random_mac_lock;
+    adf_os_spinlock_t random_mac_lock;
     struct action_frame_random_mac random_mac[MAX_RANDOM_MAC_ADDRS];
     /*
      * Store the restrict_offchannel count
@@ -1813,7 +1813,7 @@ struct hdd_context_s
 #ifdef FEATURE_WLAN_THERMAL_SHUTDOWN
    bool system_suspended;
    volatile int thermal_suspend_state;
-   spinlock_t thermal_suspend_lock;
+   adf_os_spinlock_t thermal_suspend_lock;
    struct workqueue_struct *thermal_suspend_wq;
    struct delayed_work thermal_suspend_work;
 #endif
@@ -1834,7 +1834,7 @@ struct hdd_context_s
    v_BOOL_t suspended;
    bool prevent_suspend;
 
-   spinlock_t filter_lock;
+   adf_os_spinlock_t filter_lock;
 
    /* Lock to avoid race condition during start/stop bss */
    struct mutex sap_lock;
@@ -1947,7 +1947,7 @@ struct hdd_context_s
     /* Use below lock to protect access to isSchedScanUpdatePending
      * since it will be accessed in two different contexts.
      */
-    spinlock_t schedScan_lock;
+    adf_os_spinlock_t schedScan_lock;
 
     // Flag keeps track of wiphy suspend/resume
     v_BOOL_t isWiphySuspended;
@@ -1959,7 +1959,7 @@ struct hdd_context_s
     /* DDR bus bandwidth compute timer */
     vos_timer_t    bus_bw_timer;
     int            cur_vote_level;
-    spinlock_t     bus_bw_lock;
+    adf_os_spinlock_t     bus_bw_lock;
     int            cur_rx_level;
     uint64_t       prev_rx;
     int            cur_tx_level;
@@ -2006,8 +2006,8 @@ struct hdd_context_s
     bool is_ch_avoid_in_progress;
 
     bool is_sta_connection_pending;
-    spinlock_t sap_update_info_lock;
-    spinlock_t sta_update_info_lock;
+    adf_os_spinlock_t sap_update_info_lock;
+    adf_os_spinlock_t sta_update_info_lock;
 
     v_U8_t dev_dfs_cac_status;
 
@@ -2021,7 +2021,7 @@ struct hdd_context_s
     v_U8_t skip_acs_scan_status;
     uint8_t *last_acs_channel_list;
     uint8_t num_of_channels;
-    spinlock_t acs_skip_lock;
+    adf_os_spinlock_t acs_skip_lock;
 #endif
 
     vos_wake_lock_t sap_dfs_wakelock;
@@ -2052,7 +2052,7 @@ struct hdd_context_s
      * radar found indication and application triggered channel
      * switch
      */
-    spinlock_t dfs_lock;
+    adf_os_spinlock_t dfs_lock;
 
 #ifdef FEATURE_WLAN_EXTSCAN
     struct hdd_ext_scan_context ext_scan_context;
@@ -2149,7 +2149,7 @@ struct hdd_context_s
     /* Lock to control access to dnbs avoid freq list */
     struct mutex avoid_freq_lock;
 #endif
-    spinlock_t restrict_offchan_lock;
+    adf_os_spinlock_t restrict_offchan_lock;
     bool  restrict_offchan_flag;
 
 };
diff --git a/CORE/HDD/src/wlan_hdd_assoc.c b/CORE/HDD/src/wlan_hdd_assoc.c
index 2571a7710e23..47dc56c7f98b 100644
--- a/CORE/HDD/src/wlan_hdd_assoc.c
+++ b/CORE/HDD/src/wlan_hdd_assoc.c
@@ -1298,13 +1298,13 @@ static void hdd_SendAssociationEvent(struct net_device *dev,tCsrRoamInfo *pCsrRo
 
 #ifdef FEATURE_BUS_BANDWIDTH
         /* start timer in sta/p2p_cli */
-        spin_lock_bh(&pHddCtx->bus_bw_lock);
+        adf_os_spin_lock_bh(&pHddCtx->bus_bw_lock);
         pAdapter->prev_tx_packets = pAdapter->stats.tx_packets;
         pAdapter->prev_rx_packets = pAdapter->stats.rx_packets;
         tlshim_get_intra_bss_fwd_pkts_count(pAdapter->sessionId,
              &pAdapter->prev_fwd_tx_packets, &pAdapter->prev_fwd_rx_packets);
         pAdapter->prev_tx_bytes = pAdapter->stats.tx_bytes;
-        spin_unlock_bh(&pHddCtx->bus_bw_lock);
+        adf_os_spin_unlock_bh(&pHddCtx->bus_bw_lock);
         hdd_start_bus_bw_compute_timer(pAdapter);
 #endif
         if (pHddCtx->cfg_ini->mon_on_sta_enable &&
@@ -1363,13 +1363,13 @@ static void hdd_SendAssociationEvent(struct net_device *dev,tCsrRoamInfo *pCsrRo
 
 #ifdef FEATURE_BUS_BANDWIDTH
         /* stop timer in sta/p2p_cli */
-        spin_lock_bh(&pHddCtx->bus_bw_lock);
+        adf_os_spin_lock_bh(&pHddCtx->bus_bw_lock);
         pAdapter->prev_tx_packets = 0;
         pAdapter->prev_rx_packets = 0;
         pAdapter->prev_fwd_tx_packets = 0;
         pAdapter->prev_fwd_rx_packets = 0;
         pAdapter->prev_tx_bytes = 0;
-        spin_unlock_bh(&pHddCtx->bus_bw_lock);
+        adf_os_spin_unlock_bh(&pHddCtx->bus_bw_lock);
         hdd_stop_bus_bw_compute_timer(pAdapter);
 #endif
         if (pHddCtx->cfg_ini->mon_on_sta_enable &&
diff --git a/CORE/HDD/src/wlan_hdd_cfg80211.c b/CORE/HDD/src/wlan_hdd_cfg80211.c
index 173d9a17a350..748e7be0d97d 100644
--- a/CORE/HDD/src/wlan_hdd_cfg80211.c
+++ b/CORE/HDD/src/wlan_hdd_cfg80211.c
@@ -2928,11 +2928,11 @@ static int __wlan_hdd_cfg80211_extscan_get_capabilities(struct wiphy *wiphy,
     pReqMsg->sessionId = pAdapter->sessionId;
     hddLog(VOS_TRACE_LEVEL_INFO, FL("Session Id %d"), pReqMsg->sessionId);
 
-    spin_lock(&hdd_context_lock);
+    adf_os_spin_lock(&hdd_context_lock);
     context = &pHddCtx->ext_scan_context;
     context->request_id = pReqMsg->requestId;
     INIT_COMPLETION(context->response_event);
-    spin_unlock(&hdd_context_lock);
+    adf_os_spin_unlock(&hdd_context_lock);
 
 
     status = sme_ExtScanGetCapabilities(pHddCtx->hHal, pReqMsg);
@@ -3075,12 +3075,12 @@ static int __wlan_hdd_cfg80211_extscan_get_cached_results(struct wiphy *wiphy,
 	hddLog(LOG1, FL("Req Id: %u Session Id: %d Flush: %d"),
 		pReqMsg->requestId, pReqMsg->sessionId, pReqMsg->flush);
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context = &pHddCtx->ext_scan_context;
 	context->request_id = pReqMsg->requestId;
 	context->ignore_cached_results = false;
 	INIT_COMPLETION(context->response_event);
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	status = sme_getCachedResults(pHddCtx->hHal, pReqMsg);
 	if (!HAL_STATUS_SUCCESS(status)) {
@@ -3094,13 +3094,13 @@ static int __wlan_hdd_cfg80211_extscan_get_cached_results(struct wiphy *wiphy,
 	if (!rc) {
 		hddLog(LOGE, FL("Target response timed out"));
 		retval = -ETIMEDOUT;
-		spin_lock(&hdd_context_lock);
+		adf_os_spin_lock(&hdd_context_lock);
 		context->ignore_cached_results = true;
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 	} else {
-		spin_lock(&hdd_context_lock);
+		adf_os_spin_lock(&hdd_context_lock);
 		retval = context->response_status;
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 	}
 	return retval;
 
@@ -3287,10 +3287,10 @@ static int __wlan_hdd_cfg80211_extscan_set_bssid_hotlist(struct wiphy *wiphy,
     }
 
     context = &pHddCtx->ext_scan_context;
-    spin_lock(&hdd_context_lock);
+    adf_os_spin_lock(&hdd_context_lock);
     INIT_COMPLETION(context->response_event);
     context->request_id = request_id = pReqMsg->requestId;
-    spin_unlock(&hdd_context_lock);
+    adf_os_spin_unlock(&hdd_context_lock);
 
     status = sme_SetBssHotlist(pHddCtx->hHal, pReqMsg);
     if (!HAL_STATUS_SUCCESS(status)) {
@@ -3306,12 +3306,12 @@ static int __wlan_hdd_cfg80211_extscan_set_bssid_hotlist(struct wiphy *wiphy,
        hddLog(LOGE, FL("sme_SetBssHotlist timed out"));
        retval = -ETIMEDOUT;
     } else {
-       spin_lock(&hdd_context_lock);
+       adf_os_spin_lock(&hdd_context_lock);
        if (context->request_id == request_id)
           retval = context->response_status;
        else
           retval = -EINVAL;
-       spin_unlock(&hdd_context_lock);
+       adf_os_spin_unlock(&hdd_context_lock);
     }
     EXIT();
     return retval;
@@ -3505,10 +3505,10 @@ static int __wlan_hdd_cfg80211_extscan_set_significant_change(
     }
 
     context = &pHddCtx->ext_scan_context;
-    spin_lock(&hdd_context_lock);
+    adf_os_spin_lock(&hdd_context_lock);
     INIT_COMPLETION(context->response_event);
     context->request_id = request_id = pReqMsg->requestId;
-    spin_unlock(&hdd_context_lock);
+    adf_os_spin_unlock(&hdd_context_lock);
 
     status = sme_SetSignificantChange(pHddCtx->hHal, pReqMsg);
     if (!HAL_STATUS_SUCCESS(status)) {
@@ -3524,12 +3524,12 @@ static int __wlan_hdd_cfg80211_extscan_set_significant_change(
        hddLog(LOGE, FL("sme_SetSignificantChange timed out"));
        retval = -ETIMEDOUT;
     } else {
-       spin_lock(&hdd_context_lock);
+       adf_os_spin_lock(&hdd_context_lock);
        if (context->request_id == request_id)
           retval = context->response_status;
        else
           retval = -EINVAL;
-       spin_unlock(&hdd_context_lock);
+       adf_os_spin_unlock(&hdd_context_lock);
     }
     EXIT();
     return retval;
@@ -4372,11 +4372,11 @@ static int __wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy,
 		goto fail;
 
 	context = &pHddCtx->ext_scan_context;
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	INIT_COMPLETION(context->response_event);
 	context->request_id = request_id = pReqMsg->requestId;
 	context->buckets_scanned = 0;
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	status = sme_ExtScanStart(pHddCtx->hHal, pReqMsg);
 	if (!HAL_STATUS_SUCCESS(status)) {
@@ -4397,12 +4397,12 @@ static int __wlan_hdd_cfg80211_extscan_start(struct wiphy *wiphy,
 		hddLog(LOGE, FL("sme_ExtScanStart timed out"));
 		retval = -ETIMEDOUT;
 	} else {
-		spin_lock(&hdd_context_lock);
+		adf_os_spin_lock(&hdd_context_lock);
 		if (context->request_id == request_id)
 			retval = context->response_status;
 		else
 			retval = -EINVAL;
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 	}
 	EXIT();
 	return retval;
@@ -4519,10 +4519,10 @@ static int __wlan_hdd_cfg80211_extscan_stop(struct wiphy *wiphy,
 		pReqMsg->requestId, pReqMsg->sessionId);
 
 	context = &pHddCtx->ext_scan_context;
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	INIT_COMPLETION(context->response_event);
 	context->request_id = request_id = pReqMsg->requestId;
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	status = sme_ExtScanStop(pHddCtx->hHal, pReqMsg);
 	if (!HAL_STATUS_SUCCESS(status)) {
@@ -4539,12 +4539,12 @@ static int __wlan_hdd_cfg80211_extscan_stop(struct wiphy *wiphy,
 		hddLog(LOGE, FL("sme_ExtScanStop timed out"));
 		retval = -ETIMEDOUT;
 	} else {
-		spin_lock(&hdd_context_lock);
+		adf_os_spin_lock(&hdd_context_lock);
 		if (context->request_id == request_id)
 			retval = context->response_status;
 		else
 			retval = -EINVAL;
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 	}
 	EXIT();
 	return retval;
@@ -4641,10 +4641,10 @@ static int __wlan_hdd_cfg80211_extscan_reset_bssid_hotlist(struct wiphy *wiphy,
                  pReqMsg->requestId, pReqMsg->sessionId);
 
     context = &pHddCtx->ext_scan_context;
-    spin_lock(&hdd_context_lock);
+    adf_os_spin_lock(&hdd_context_lock);
     INIT_COMPLETION(context->response_event);
     context->request_id = request_id = pReqMsg->requestId;
-    spin_unlock(&hdd_context_lock);
+    adf_os_spin_unlock(&hdd_context_lock);
 
     status = sme_ResetBssHotlist(pHddCtx->hHal, pReqMsg);
     if (!HAL_STATUS_SUCCESS(status)) {
@@ -4659,12 +4659,12 @@ static int __wlan_hdd_cfg80211_extscan_reset_bssid_hotlist(struct wiphy *wiphy,
        hddLog(LOGE, FL("sme_ResetBssHotlist timed out"));
        retval = -ETIMEDOUT;
     } else {
-       spin_lock(&hdd_context_lock);
+       adf_os_spin_lock(&hdd_context_lock);
        if (context->request_id == request_id)
           retval = context->response_status;
        else
           retval = -EINVAL;
-       spin_unlock(&hdd_context_lock);
+       adf_os_spin_unlock(&hdd_context_lock);
     }
     EXIT();
     return retval;
@@ -4756,10 +4756,10 @@ static int __wlan_hdd_cfg80211_extscan_reset_significant_change(
            pReqMsg->requestId, pReqMsg->sessionId);
 
     context = &pHddCtx->ext_scan_context;
-    spin_lock(&hdd_context_lock);
+    adf_os_spin_lock(&hdd_context_lock);
     INIT_COMPLETION(context->response_event);
     context->request_id = request_id = pReqMsg->requestId;
-    spin_unlock(&hdd_context_lock);
+    adf_os_spin_unlock(&hdd_context_lock);
 
     status = sme_ResetSignificantChange(pHddCtx->hHal, pReqMsg);
     if (!HAL_STATUS_SUCCESS(status)) {
@@ -4775,12 +4775,12 @@ static int __wlan_hdd_cfg80211_extscan_reset_significant_change(
        hddLog(LOGE, FL("sme_ResetSignificantChange timed out"));
        retval = -ETIMEDOUT;
     } else {
-       spin_lock(&hdd_context_lock);
+       adf_os_spin_lock(&hdd_context_lock);
        if (context->request_id == request_id)
           retval = context->response_status;
        else
           retval = -EINVAL;
-       spin_unlock(&hdd_context_lock);
+       adf_os_spin_unlock(&hdd_context_lock);
     }
     EXIT();
     return retval;
@@ -6354,19 +6354,19 @@ static void wlan_hdd_cfg80211_link_layer_stats_callback(void *ctx, int indType,
                  linkLayerStatsResults->num_radio,
                  linkLayerStatsResults->results);
 
-            spin_lock(&hdd_context_lock);
+            adf_os_spin_lock(&hdd_context_lock);
             context = &pHddCtx->ll_stats_context;
             /* validate response received from target */
             if ((context->request_id != linkLayerStatsResults->rspId) ||
                 !(context->request_bitmap & linkLayerStatsResults->paramId)) {
-                 spin_unlock(&hdd_context_lock);
+                 adf_os_spin_unlock(&hdd_context_lock);
                  hddLog(LOGE,
                      FL("Error : Request id %d response id %d request bitmap 0x%x response bitmap 0x%x"),
                      context->request_id, linkLayerStatsResults->rspId,
                      context->request_bitmap, linkLayerStatsResults->paramId);
                  return;
             }
-            spin_unlock(&hdd_context_lock);
+            adf_os_spin_unlock(&hdd_context_lock);
 
             if (linkLayerStatsResults->paramId & WMI_LINK_STATS_RADIO )
             {
@@ -6376,10 +6376,10 @@ static void wlan_hdd_cfg80211_link_layer_stats_callback(void *ctx, int indType,
                                    linkLayerStatsResults->results,
                                    linkLayerStatsResults->num_radio);
 
-                spin_lock(&hdd_context_lock);
+                adf_os_spin_lock(&hdd_context_lock);
                 if (!linkLayerStatsResults->moreResultToFollow)
                      context->request_bitmap &= ~(WMI_LINK_STATS_RADIO);
-                spin_unlock(&hdd_context_lock);
+                adf_os_spin_unlock(&hdd_context_lock);
 
             }
             else if (linkLayerStatsResults->paramId & WMI_LINK_STATS_IFACE )
@@ -6389,7 +6389,7 @@ static void wlan_hdd_cfg80211_link_layer_stats_callback(void *ctx, int indType,
                                    linkLayerStatsResults->results,
                                    linkLayerStatsResults->num_peers);
 
-                spin_lock(&hdd_context_lock);
+                adf_os_spin_lock(&hdd_context_lock);
                 /* Firmware doesn't send peerstats event if no peers are
                  * connected. HDD should not wait for any peerstats in this case
                  * and return the status to middlewre after receiving iface
@@ -6398,7 +6398,7 @@ static void wlan_hdd_cfg80211_link_layer_stats_callback(void *ctx, int indType,
                 if (!linkLayerStatsResults->num_peers)
                      context->request_bitmap &= ~(WMI_LINK_STATS_ALL_PEER);
                 context->request_bitmap &= ~(WMI_LINK_STATS_IFACE);
-                spin_unlock(&hdd_context_lock);
+                adf_os_spin_unlock(&hdd_context_lock);
 
             }
             else if (linkLayerStatsResults->paramId & WMI_LINK_STATS_ALL_PEER )
@@ -6408,10 +6408,10 @@ static void wlan_hdd_cfg80211_link_layer_stats_callback(void *ctx, int indType,
                                    (tpSirWifiPeerStat)
                                    linkLayerStatsResults->results);
 
-                spin_lock(&hdd_context_lock);
+                adf_os_spin_lock(&hdd_context_lock);
                 if (!linkLayerStatsResults->moreResultToFollow)
                      context->request_bitmap &= ~(WMI_LINK_STATS_ALL_PEER);
-                spin_unlock(&hdd_context_lock);
+                adf_os_spin_unlock(&hdd_context_lock);
 
             }
             else
@@ -6420,11 +6420,11 @@ static void wlan_hdd_cfg80211_link_layer_stats_callback(void *ctx, int indType,
                         FL("INVALID LL_STATS_NOTIFY RESPONSE ***********"));
             }
 
-            spin_lock(&hdd_context_lock);
+            adf_os_spin_lock(&hdd_context_lock);
             /* complete response event if all requests bitmaps are cleared */
             if (0 == context->request_bitmap)
                 complete(&context->response_event);
-            spin_unlock(&hdd_context_lock);
+            adf_os_spin_unlock(&hdd_context_lock);
 
             break;
         }
@@ -7763,12 +7763,12 @@ static int __wlan_hdd_cfg80211_ll_stats_get(struct wiphy *wiphy,
 
     LinkLayerStatsGetReq.staId = pAdapter->sessionId;
 
-    spin_lock(&hdd_context_lock);
+    adf_os_spin_lock(&hdd_context_lock);
     context = &pHddCtx->ll_stats_context;
     context->request_id = LinkLayerStatsGetReq.reqId;
     context->request_bitmap = LinkLayerStatsGetReq.paramIdMask;
     INIT_COMPLETION(context->response_event);
-    spin_unlock(&hdd_context_lock);
+    adf_os_spin_unlock(&hdd_context_lock);
 
     if (eHAL_STATUS_SUCCESS != sme_LLStatsGetReq(pHddCtx->hHal,
                                                 &LinkLayerStatsGetReq))
@@ -9854,13 +9854,13 @@ static int __wlan_hdd_cfg80211_do_acs(struct wiphy *wiphy,
 	}
 
 #ifdef FEATURE_WLAN_DISABLE_CHANNEL_SWITCH
-	spin_lock_bh(&hdd_ctx->restrict_offchan_lock);
+	adf_os_spin_lock_bh(&hdd_ctx->restrict_offchan_lock);
 	if(hdd_ctx->restrict_offchan_flag) {
 		hddLog(LOGE, FL("Channel switch is disabled, reject ACS"));
-		spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
+		adf_os_spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
 		return -EPERM;
 	}
-	spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
+	adf_os_spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
 #endif
 	/* ***Note*** Donot set SME config related to ACS operation here because
 	 * ACS operation is not synchronouse and ACS for Second AP may come when
@@ -10514,9 +10514,9 @@ static int wlan_hdd_handle_restrict_offchan_config(hdd_adapter_t *adapter,
 		int chan;
 		adapter->restrict_offchannel_cnt++;
 		if (adapter->restrict_offchannel_cnt == 1) {
-			spin_lock_bh(&hdd_ctx->restrict_offchan_lock);
+			adf_os_spin_lock_bh(&hdd_ctx->restrict_offchan_lock);
 			hdd_ctx->restrict_offchan_flag = true;
-			spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
+			adf_os_spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
 			chan = hdd_get_operating_channel(hdd_ctx, dev_mode);
 			hddLog(LOGE, FL("chan is %d"), chan);
 			if (!chan ||
@@ -10529,9 +10529,9 @@ static int wlan_hdd_handle_restrict_offchan_config(hdd_adapter_t *adapter,
 			(adapter->restrict_offchannel_cnt > 0)) {
 		adapter->restrict_offchannel_cnt--;
 		if (adapter->restrict_offchannel_cnt == 0) {
-			spin_lock_bh(&hdd_ctx->restrict_offchan_lock);
+			adf_os_spin_lock_bh(&hdd_ctx->restrict_offchan_lock);
 			hdd_ctx->restrict_offchan_flag = false;
-			spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
+			adf_os_spin_unlock_bh(&hdd_ctx->restrict_offchan_lock);
 			if (wlan_hdd_send_avoid_freq_for_dnbs(hdd_ctx, 0)) {
 				hddLog(LOGE, FL("unable to clear avoid_freq"));
 				ret_val = -EINVAL;
@@ -12712,12 +12712,12 @@ void hdd_get_bpf_offload_cb(void *hdd_context,
 		hddLog(LOGE, FL("Data is null"));
 		return;
 	}
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 
 	context = &bpf_context;
 	/* The caller presumably timed out so there is nothing we can do */
 	if (context->magic != BPF_CONTEXT_MAGIC) {
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 		return;
 	}
 
@@ -12728,7 +12728,7 @@ void hdd_get_bpf_offload_cb(void *hdd_context,
 	context->capability_response = *data;
 	complete(&context->completion);
 
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	return;
 }
@@ -12794,11 +12794,11 @@ static int hdd_get_bpf_offload(hdd_context_t *hdd_ctx)
 
 	ENTER();
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context = &bpf_context;
 	context->magic = BPF_CONTEXT_MAGIC;
 	INIT_COMPLETION(context->completion);
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	hstatus = sme_get_bpf_offload_capabilities(hdd_ctx->hHal);
 	if (!HAL_STATUS_SUCCESS(hstatus)) {
@@ -12810,9 +12810,9 @@ static int hdd_get_bpf_offload(hdd_context_t *hdd_ctx)
 			msecs_to_jiffies(WLAN_WAIT_TIME_BPF));
 	if (!rc) {
 		hddLog(LOGE, FL("Target response timed out"));
-		spin_lock(&hdd_context_lock);
+		adf_os_spin_lock(&hdd_context_lock);
 		context->magic = 0;
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 
 		return -ETIMEDOUT;
 	}
@@ -15279,11 +15279,11 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
 	memcpy(&req_msg.peer_macaddr,
 		nla_data(tb[QCA_WLAN_VENDOR_ATTR_MAC_ADDR]), mac_len);
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context = &hdd_ctx->chain_rssi_context;
 	INIT_COMPLETION(context->response_event);
 	context->ignore_result = false;
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	status = sme_get_chain_rssi(hdd_ctx->hHal, &req_msg);
 	if (!HAL_STATUS_SUCCESS(status)) {
@@ -15296,9 +15296,9 @@ static int __wlan_hdd_cfg80211_get_chain_rssi(struct wiphy *wiphy,
 			msecs_to_jiffies(WLAN_WAIT_TIME_CHAIN_RSSI));
 	if (!rc) {
 		hddLog(LOGE, FL("Target response timed out"));
-		spin_lock(&hdd_context_lock);
+		adf_os_spin_lock(&hdd_context_lock);
 		context->ignore_result = true;
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 		return -ETIMEDOUT;
 	}
 
@@ -22264,11 +22264,11 @@ static bool wlan_hdd_sap_skip_scan_check(hdd_context_t *hdd_ctx,
 		hdd_ctx->skip_acs_scan_status);
 	if (hdd_ctx->skip_acs_scan_status != eSAP_SKIP_ACS_SCAN)
 		return false;
-	spin_lock(&hdd_ctx->acs_skip_lock);
+	adf_os_spin_lock(&hdd_ctx->acs_skip_lock);
 	if (hdd_ctx->last_acs_channel_list == NULL ||
 	   hdd_ctx->num_of_channels == 0 ||
 	   request->n_channels == 0) {
-		spin_unlock(&hdd_ctx->acs_skip_lock);
+		adf_os_spin_unlock(&hdd_ctx->acs_skip_lock);
 		return false;
 	}
 	skip = true;
@@ -22288,7 +22288,7 @@ static bool wlan_hdd_sap_skip_scan_check(hdd_context_t *hdd_ctx,
 			break;
 		}
 	}
-	spin_unlock(&hdd_ctx->acs_skip_lock);
+	adf_os_spin_unlock(&hdd_ctx->acs_skip_lock);
 	return skip;
 }
 #else
@@ -28386,16 +28386,16 @@ void hdd_cfg80211_sched_scan_done_callback(void *callbackContext,
         return ;
     }
 
-    spin_lock(&pHddCtx->schedScan_lock);
+    adf_os_spin_lock(&pHddCtx->schedScan_lock);
     if (TRUE == pHddCtx->isWiphySuspended)
     {
         pHddCtx->isSchedScanUpdatePending = TRUE;
-        spin_unlock(&pHddCtx->schedScan_lock);
+        adf_os_spin_unlock(&pHddCtx->schedScan_lock);
         hddLog(VOS_TRACE_LEVEL_INFO,
                "%s: Update cfg80211 scan database after it resume", __func__);
         return ;
     }
-    spin_unlock(&pHddCtx->schedScan_lock);
+    adf_os_spin_unlock(&pHddCtx->schedScan_lock);
 
     ret = wlan_hdd_cfg80211_update_bss(pHddCtx->wiphy, pAdapter);
 
@@ -30949,16 +30949,16 @@ int __wlan_hdd_cfg80211_resume_wlan(struct wiphy *wiphy, bool thermal)
 
     MTRACE(vos_trace(VOS_MODULE_ID_HDD, TRACE_CODE_HDD_CFG80211_RESUME_WLAN,
                           NO_SESSION, pHddCtx->isWiphySuspended));
-    spin_lock(&pHddCtx->schedScan_lock);
+    adf_os_spin_lock(&pHddCtx->schedScan_lock);
     pHddCtx->isWiphySuspended = FALSE;
     if (TRUE != pHddCtx->isSchedScanUpdatePending) {
-        spin_unlock(&pHddCtx->schedScan_lock);
+        adf_os_spin_unlock(&pHddCtx->schedScan_lock);
         hddLog(LOG1, FL("Return resume is not due to PNO indication"));
         return 0;
     }
     /* Reset flag to avoid updating cfg80211 data old results again */
     pHddCtx->isSchedScanUpdatePending = FALSE;
-    spin_unlock(&pHddCtx->schedScan_lock);
+    adf_os_spin_unlock(&pHddCtx->schedScan_lock);
 
     status = hdd_get_front_adapter (pHddCtx, &pAdapterNode);
 
@@ -31427,12 +31427,12 @@ wlan_hdd_cfg80211_extscan_get_capabilities_rsp(void *ctx,
 		hddLog(LOGE, FL("data is null"));
 		return;
 	}
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 
 	context = &hdd_ctx->ext_scan_context;
 	/* validate response received from target*/
 	if (context->request_id != data->requestId) {
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 		hddLog(LOGE,
 			FL("Target response id did not match: request_id %d resposne_id %d"),
 			context->request_id, data->requestId);
@@ -31442,7 +31442,7 @@ wlan_hdd_cfg80211_extscan_get_capabilities_rsp(void *ctx,
 		complete(&context->response_event);
 	}
 
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	return;
 }
@@ -31571,10 +31571,10 @@ wlan_hdd_cfg80211_extscan_cached_results_ind(void *ctx,
 		hddLog(VOS_TRACE_LEVEL_ERROR, FL("data is null"));
 		return;
 	}
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context = &pHddCtx->ext_scan_context;
 	ignore_cached_results = context->ignore_cached_results;
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	if (ignore_cached_results) {
 		hddLog(LOGE,
@@ -31755,10 +31755,10 @@ wlan_hdd_cfg80211_extscan_cached_results_ind(void *ctx,
 	cfg80211_vendor_cmd_reply(skb);
 
 	if (!data->more_data) {
-		spin_lock(&hdd_context_lock);
+		adf_os_spin_lock(&hdd_context_lock);
 		context->response_status = 0;
 		complete(&context->response_event);
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 	}
 	return;
 
@@ -31766,9 +31766,9 @@ fail:
 	if (skb)
 		kfree_skb(skb);
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context->response_status = -EINVAL;
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 	return;
 }
 
@@ -31952,12 +31952,12 @@ wlan_hdd_cfg80211_extscan_generic_rsp
 	       response->request_id, response->status);
 
 	context = &hdd_ctx->ext_scan_context;
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	if (context->request_id == response->request_id) {
 		context->response_status = response->status ? -EINVAL : 0;
 		complete(&context->response_event);
 	}
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	return;
 }
@@ -32215,16 +32215,16 @@ wlan_hdd_cfg80211_extscan_full_scan_result_event(void *ctx,
 		goto nla_put_failure;
 	}
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context = &pHddCtx->ext_scan_context;
 	if (nla_put_u32(skb,
 		QCA_WLAN_VENDOR_ATTR_EXTSCAN_RESULTS_BUCKETS_SCANNED,
 		context->buckets_scanned)) {
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 		hddLog(LOGE, FL("Failed to include buckets_scanned"));
 		goto nla_put_failure;
 	}
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	cfg80211_vendor_event(skb, flags);
 	return;
@@ -32444,19 +32444,19 @@ wlan_hdd_cfg80211_extscan_scan_progress_event(void *ctx,
 		data->requestId, data->scanEventType, data->status,
 		data->buckets_scanned);
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context = &pHddCtx->ext_scan_context;
 	if (data->scanEventType == WIFI_EXTSCAN_CYCLE_COMPLETED_EVENT) {
 		context->buckets_scanned = 0;
 		data->scanEventType = WIFI_EXTSCAN_RESULTS_AVAILABLE;
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 	} else if (data->scanEventType == WIFI_EXTSCAN_CYCLE_STARTED_EVENT) {
 		context->buckets_scanned = data->buckets_scanned;
 		/* No need to report to user space */
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 		return;
 	} else {
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 	}
 
 	skb = cfg80211_vendor_event_alloc(pHddCtx->wiphy,
@@ -32721,20 +32721,20 @@ void wlan_hdd_cfg80211_chainrssi_callback(void *ctx, void *pmsg)
 	if (wlan_hdd_validate_context(hdd_ctx))
 		return;
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	context = &hdd_ctx->chain_rssi_context;
 	ignore_result = context->ignore_result;
 
 	if (ignore_result) {
 		hddLog(LOGE, FL("Ignore the result received after timeout"));
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 		return;
 	}
 
 	memcpy(&context->result, data, sizeof(*data));
 
 	complete(&context->response_event);
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	return;
 }
diff --git a/CORE/HDD/src/wlan_hdd_debugfs_ocb.c b/CORE/HDD/src/wlan_hdd_debugfs_ocb.c
index 9ea98101e1a5..e01b82425ebf 100644
--- a/CORE/HDD/src/wlan_hdd_debugfs_ocb.c
+++ b/CORE/HDD/src/wlan_hdd_debugfs_ocb.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
@@ -253,7 +253,7 @@ static int __wlan_hdd_read_dsrc_chan_stats_debugfs(struct file *file,
 	ptr = chan_stats_buf + sizeof(uint32_t);
 
 	chan_stats = ctx->chan_stats;
-	spin_lock(&ctx->chan_stats_lock);
+	adf_os_spin_lock(&ctx->chan_stats_lock);
 	/* Now only two channel stats supported */
 	for (i = 0; i < DSRC_MAX_CHAN_STATS_CNT; i++, chan_stats++) {
 		if (chan_stats->chan_freq == 0)
@@ -266,7 +266,7 @@ static int __wlan_hdd_read_dsrc_chan_stats_debugfs(struct file *file,
 		ptr += sizeof(*chan_stats);
 		chan_cnt++;
 	}
-	spin_unlock(&ctx->chan_stats_lock);
+	adf_os_spin_unlock(&ctx->chan_stats_lock);
 	vos_mem_copy(chan_stats_buf, &chan_cnt, sizeof(uint32_t));
 
 	ret_cnt = sizeof(uint32_t) + chan_cnt * sizeof(*chan_stats);
diff --git a/CORE/HDD/src/wlan_hdd_early_suspend.c b/CORE/HDD/src/wlan_hdd_early_suspend.c
index 24636720820c..52fc13cdc74f 100644
--- a/CORE/HDD/src/wlan_hdd_early_suspend.c
+++ b/CORE/HDD/src/wlan_hdd_early_suspend.c
@@ -1713,10 +1713,10 @@ static void hdd_PowerStateChangedCB
    {
        pHddCtx->hdd_ignore_dtim_enabled = TRUE;
    }
-   spin_lock(&pHddCtx->filter_lock);
+   adf_os_spin_lock(&pHddCtx->filter_lock);
    if ((newState == BMPS) &&  pHddCtx->hdd_wlan_suspended)
    {
-      spin_unlock(&pHddCtx->filter_lock);
+      adf_os_spin_unlock(&pHddCtx->filter_lock);
       if (VOS_FALSE == pHddCtx->sus_res_mcastbcast_filter_valid)
       {
           pHddCtx->sus_res_mcastbcast_filter =
@@ -1744,20 +1744,20 @@ static void hdd_PowerStateChangedCB
        * resume request will be lost. So reconfigure the filters on detecting
        * a change in the power state of the WCN chip.
        */
-      spin_unlock(&pHddCtx->filter_lock);
+      adf_os_spin_unlock(&pHddCtx->filter_lock);
       if (IMPS != newState)
       {
-           spin_lock(&pHddCtx->filter_lock);
+           adf_os_spin_lock(&pHddCtx->filter_lock);
            if (FALSE == pHddCtx->hdd_wlan_suspended)
            {
-                spin_unlock(&pHddCtx->filter_lock);
+                adf_os_spin_unlock(&pHddCtx->filter_lock);
                 hddLog(VOS_TRACE_LEVEL_INFO,
                           "Not in IMPS/BMPS and suspended state");
                 hdd_conf_mcastbcast_filter(pHddCtx, FALSE);
            }
            else
            {
-                spin_unlock(&pHddCtx->filter_lock);
+                adf_os_spin_unlock(&pHddCtx->filter_lock);
            }
       }
    }
@@ -1783,7 +1783,7 @@ void hdd_register_mcast_bcast_filter(hdd_context_t *pHddCtx)
       return;
    }
 
-   spin_lock_init(&pHddCtx->filter_lock);
+   adf_os_spinlock_init(&pHddCtx->filter_lock);
    if (WLAN_MAP_SUSPEND_TO_MCAST_BCAST_FILTER ==
                                             pHddCtx->cfg_ini->nEnableSuspend)
    {
diff --git a/CORE/HDD/src/wlan_hdd_ftm.c b/CORE/HDD/src/wlan_hdd_ftm.c
index acf8c77c0dd6..2ddb807e6dec 100644
--- a/CORE/HDD/src/wlan_hdd_ftm.c
+++ b/CORE/HDD/src/wlan_hdd_ftm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -71,6 +71,7 @@
 #include "wlan_nv.h"
 #include "wlan_qct_wda.h"
 #include "cfgApi.h"
+#include <adf_os_lock.h>
 
 #if  defined(QCA_WIFI_FTM)
 #include "bmi.h"
@@ -834,7 +835,7 @@ int wlan_hdd_ftm_close(hdd_context_t *pHddCtx)
     }
 
 #if defined(QCA_WIFI_FTM) && defined(LINUX_QCMBR)
-    spin_lock_bh(&qcmbr_queue_lock);
+    adf_os_raw_spin_lock_bh(&qcmbr_queue_lock);
     if (!list_empty(&qcmbr_queue_head)) {
         qcmbr_queue_t *msg_buf, *tmp_buf;
         list_for_each_entry_safe(msg_buf, tmp_buf, &qcmbr_queue_head, list) {
@@ -842,7 +843,7 @@ int wlan_hdd_ftm_close(hdd_context_t *pHddCtx)
             kfree(msg_buf);
         }
     }
-    spin_unlock_bh(&qcmbr_queue_lock);
+    adf_os_raw_spin_unlock_bh(&qcmbr_queue_lock);
 #endif
 
     return 0;
@@ -972,7 +973,7 @@ static int wlan_hdd_qcmbr_command(hdd_adapter_t *pAdapter, qcmbr_data_t *pqcmbr_
         case ATH_XIOCTL_UNIFIED_UTF_RSP: {
             pqcmbr_data->copy_to_user = 1;
 
-            spin_lock_bh(&qcmbr_queue_lock);
+            adf_os_raw_spin_lock_bh(&qcmbr_queue_lock);
             if (!list_empty(&qcmbr_queue_head)) {
                 qcmbr_buf = list_first_entry(&qcmbr_queue_head,
                                              qcmbr_queue_t, list);
@@ -981,7 +982,7 @@ static int wlan_hdd_qcmbr_command(hdd_adapter_t *pAdapter, qcmbr_data_t *pqcmbr_
             } else {
                 ret = -1;
             }
-            spin_unlock_bh(&qcmbr_queue_lock);
+            adf_os_raw_spin_unlock_bh(&qcmbr_queue_lock);
 
             if (!ret) {
                 memcpy(pqcmbr_data->buf, qcmbr_buf->utf_buf,
@@ -1085,9 +1086,9 @@ static void WLANQCMBR_McProcessMsg(v_VOID_t *message)
     qcmbr_buf = kzalloc(sizeof(qcmbr_queue_t), GFP_KERNEL);
     if (qcmbr_buf != NULL) {
         memcpy(qcmbr_buf->utf_buf, message, data_len);
-        spin_lock_bh(&qcmbr_queue_lock);
+        adf_os_raw_spin_lock_bh(&qcmbr_queue_lock);
         list_add_tail(&(qcmbr_buf->list), &qcmbr_queue_head);
-        spin_unlock_bh(&qcmbr_queue_lock);
+        adf_os_raw_spin_unlock_bh(&qcmbr_queue_lock);
     }
 }
 #endif /*LINUX_QCMBR*/
diff --git a/CORE/HDD/src/wlan_hdd_hostapd.c b/CORE/HDD/src/wlan_hdd_hostapd.c
index 46d06c180468..59c720332334 100644
--- a/CORE/HDD/src/wlan_hdd_hostapd.c
+++ b/CORE/HDD/src/wlan_hdd_hostapd.c
@@ -397,7 +397,7 @@ bool hdd_hostapd_sub20_channelwidth_can_switch(
 		return false;
 	}
 
-	spin_lock_bh(&adapter->staInfo_lock);
+	adf_os_spin_lock_bh(&adapter->staInfo_lock);
 	for (i = 0; i < WLAN_MAX_STA_COUNT; i++) {
 		sta = &adapter->aStaInfo[i];
 		if (sta->isUsed && (ap->uBCStaId != i)) {
@@ -406,7 +406,7 @@ bool hdd_hostapd_sub20_channelwidth_can_switch(
 				sta->sub20_dynamic_channelwidth;
 		}
 	}
-	spin_unlock_bh(&adapter->staInfo_lock);
+	adf_os_spin_unlock_bh(&adapter->staInfo_lock);
 
 	if (sta_count != 1) {
 		hddLog(VOS_TRACE_LEVEL_ERROR,
@@ -459,7 +459,7 @@ bool hdd_hostapd_sub20_channelwidth_can_restore(
 		hddLog(LOGE, FL("sub20 none"));
 		return false;
 	}
-	spin_lock_bh(&adapter->staInfo_lock);
+	adf_os_spin_lock_bh(&adapter->staInfo_lock);
 	for (i = 0; i < WLAN_MAX_STA_COUNT; i++) {
 		sta = &adapter->aStaInfo[i];
 		if (sta->isUsed && (ap->uBCStaId != i)) {
@@ -468,7 +468,7 @@ bool hdd_hostapd_sub20_channelwidth_can_restore(
 				sta->sub20_dynamic_channelwidth;
 		}
 	}
-	spin_unlock_bh(&adapter->staInfo_lock);
+	adf_os_spin_unlock_bh(&adapter->staInfo_lock);
 
 	if (sta_count != 0) {
 		hddLog(VOS_TRACE_LEVEL_ERROR,
@@ -566,7 +566,7 @@ bool hdd_sub20_channelwidth_can_set(
 		return false;
 	}
 
-	spin_lock_bh(&adapter->staInfo_lock);
+	adf_os_spin_lock_bh(&adapter->staInfo_lock);
 	for (i = 0; i < WLAN_MAX_STA_COUNT; i++) {
 		sta = &adapter->aStaInfo[i];
 		if (sta->isUsed && (ap->uBCStaId != i)) {
@@ -575,7 +575,7 @@ bool hdd_sub20_channelwidth_can_set(
 				sta->sub20_dynamic_channelwidth;
 		}
 	}
-	spin_unlock_bh(&adapter->staInfo_lock);
+	adf_os_spin_unlock_bh(&adapter->staInfo_lock);
 	if (sta_count >= 1 && !(sta_s20_caps & sub20_channel_width)) {
 		hddLog(VOS_TRACE_LEVEL_ERROR,
 		       "%d STAs connected with sub20 Channelwidth %d",
@@ -1903,7 +1903,7 @@ static VOS_STATUS hdd_handle_acs_scan_event(tpSap_Event sap_event,
 	}
 	comp_evt = &sap_event->sapevt.sap_acs_scan_comp;
 	hdd_ctx->skip_acs_scan_status = eSAP_SKIP_ACS_SCAN;
-	spin_lock(&hdd_ctx->acs_skip_lock);
+	adf_os_spin_lock(&hdd_ctx->acs_skip_lock);
 	vos_mem_free(hdd_ctx->last_acs_channel_list);
 	hdd_ctx->last_acs_channel_list = NULL;
 	hdd_ctx->num_of_channels = 0;
@@ -1923,7 +1923,7 @@ static VOS_STATUS hdd_handle_acs_scan_event(tpSap_Event sap_event,
 			hdd_ctx->num_of_channels = comp_evt->num_of_channels;
 		}
 	}
-	spin_unlock(&hdd_ctx->acs_skip_lock);
+	adf_os_spin_unlock(&hdd_ctx->acs_skip_lock);
 	/* Update ACS scan result to cfg80211. Then OBSS scan can reuse the
 	 * scan result.
 	 */
@@ -2375,9 +2375,9 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
                 }
            }
 
-            spin_lock_bh(&pHddCtx->dfs_lock);
+            adf_os_spin_lock_bh(&pHddCtx->dfs_lock);
             pHddCtx->dfs_radar_found = VOS_FALSE;
-            spin_unlock_bh(&pHddCtx->dfs_lock);
+            adf_os_spin_unlock_bh(&pHddCtx->dfs_lock);
             WLANSAP_Get_Dfs_Ignore_CAC(pHddCtx->hHal, &ignoreCAC);
             if ((NV_CHANNEL_DFS !=
                 vos_nv_getChannelEnabledState(pHddApCtx->operatingChannel))
@@ -2709,7 +2709,7 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
             /* start timer in sap/p2p_go */
             if (pHddApCtx->bApActive == VOS_FALSE)
             {
-                spin_lock_bh(&pHddCtx->bus_bw_lock);
+                adf_os_spin_lock_bh(&pHddCtx->bus_bw_lock);
                 pHostapdAdapter->prev_tx_packets = pHostapdAdapter->stats.tx_packets;
                 pHostapdAdapter->prev_rx_packets = pHostapdAdapter->stats.rx_packets;
                 tlshim_get_intra_bss_fwd_pkts_count(
@@ -2718,7 +2718,7 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
                        &pHostapdAdapter->prev_fwd_rx_packets);
                 pHostapdAdapter->prev_tx_bytes =
                         pHostapdAdapter->stats.tx_bytes;
-                spin_unlock_bh(&pHddCtx->bus_bw_lock);
+                adf_os_spin_unlock_bh(&pHddCtx->bus_bw_lock);
                 hdd_start_bus_bw_compute_timer(pHostapdAdapter);
             }
 #endif
@@ -2855,7 +2855,7 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
             hdd_softap_DeregisterSTA(pHostapdAdapter, staId);
 
             pHddApCtx->bApActive = VOS_FALSE;
-            spin_lock_bh( &pHostapdAdapter->staInfo_lock );
+            adf_os_spin_lock_bh( &pHostapdAdapter->staInfo_lock );
             for (i = 0; i < WLAN_MAX_STA_COUNT; i++)
             {
                 if (pHostapdAdapter->aStaInfo[i].isUsed && i != (WLAN_HDD_GET_AP_CTX_PTR(pHostapdAdapter))->uBCStaId)
@@ -2864,7 +2864,7 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
                     break;
                 }
             }
-            spin_unlock_bh( &pHostapdAdapter->staInfo_lock );
+            adf_os_spin_unlock_bh( &pHostapdAdapter->staInfo_lock );
 
             // Start AP inactivity timer if no stations associated with it
             if ((0 != (WLAN_HDD_GET_CTX(pHostapdAdapter))->cfg_ini->nAPAutoShutOff))
@@ -2929,13 +2929,13 @@ VOS_STATUS hdd_hostapd_SAPEventCB( tpSap_Event pSapEvent, v_PVOID_t usrDataForCa
             /*stop timer in sap/p2p_go */
             if (pHddApCtx->bApActive == FALSE)
             {
-                spin_lock_bh(&pHddCtx->bus_bw_lock);
+                adf_os_spin_lock_bh(&pHddCtx->bus_bw_lock);
                 pHostapdAdapter->prev_tx_packets = 0;
                 pHostapdAdapter->prev_rx_packets = 0;
                 pHostapdAdapter->prev_fwd_tx_packets = 0;
                 pHostapdAdapter->prev_fwd_rx_packets = 0;
                 pHostapdAdapter->prev_tx_bytes = 0;
-                spin_unlock_bh(&pHddCtx->bus_bw_lock);
+                adf_os_spin_unlock_bh(&pHddCtx->bus_bw_lock);
                 hdd_stop_bus_bw_compute_timer(pHostapdAdapter);
             }
 #endif
@@ -3372,10 +3372,10 @@ int hdd_softap_set_channel_change(struct net_device *dev, int target_channel)
         }
     }
 
-    spin_lock_bh(&pHddCtx->dfs_lock);
+    adf_os_spin_lock_bh(&pHddCtx->dfs_lock);
     if (pHddCtx->dfs_radar_found == VOS_TRUE)
     {
-        spin_unlock_bh(&pHddCtx->dfs_lock);
+        adf_os_spin_unlock_bh(&pHddCtx->dfs_lock);
         hddLog(VOS_TRACE_LEVEL_ERROR, "%s: Channel switch in progress!!",
                __func__);
         ret = -EBUSY;
@@ -3392,7 +3392,7 @@ int hdd_softap_set_channel_change(struct net_device *dev, int target_channel)
      */
     pHddCtx->dfs_radar_found = VOS_TRUE;
 
-    spin_unlock_bh(&pHddCtx->dfs_lock);
+    adf_os_spin_unlock_bh(&pHddCtx->dfs_lock);
     /*
      * Post the Channel Change request to SAP.
      */
@@ -3415,9 +3415,9 @@ int hdd_softap_set_channel_change(struct net_device *dev, int target_channel)
          * queues.
          */
 
-        spin_lock_bh(&pHddCtx->dfs_lock);
+        adf_os_spin_lock_bh(&pHddCtx->dfs_lock);
         pHddCtx->dfs_radar_found = VOS_FALSE;
-        spin_unlock_bh(&pHddCtx->dfs_lock);
+        adf_os_spin_unlock_bh(&pHddCtx->dfs_lock);
 
         ret = -EINVAL;
     }
@@ -3492,9 +3492,9 @@ int hdd_softap_set_channel_sub20_chanwidth_change(struct net_device *dev,
 		return -EINVAL;
 	}
 
-	spin_lock_bh(&hdd_ctx_ptr->dfs_lock);
+	adf_os_spin_lock_bh(&hdd_ctx_ptr->dfs_lock);
 	if (hdd_ctx_ptr->dfs_radar_found == VOS_TRUE) {
-		spin_unlock_bh(&hdd_ctx_ptr->dfs_lock);
+		adf_os_spin_unlock_bh(&hdd_ctx_ptr->dfs_lock);
 		hddLog(LOGE,
 		       FL("sub20 chan width switch in progress!!"));
 		return -EBUSY;
@@ -3509,7 +3509,7 @@ int hdd_softap_set_channel_sub20_chanwidth_change(struct net_device *dev,
 	 * post eSAP_START_BSS_EVENT success event to HDD.
 	 */
 	hdd_ctx_ptr->dfs_radar_found = VOS_TRUE;
-	spin_unlock_bh(&hdd_ctx_ptr->dfs_lock);
+	adf_os_spin_unlock_bh(&hdd_ctx_ptr->dfs_lock);
 
 	vos_ctx_ptr = WLAN_HDD_GET_SAP_CTX_PTR(hostapd_adapter);
 	status = WLANSAP_set_sub20_channelwidth_with_csa(vos_ctx_ptr,
@@ -3523,9 +3523,9 @@ int hdd_softap_set_channel_sub20_chanwidth_change(struct net_device *dev,
 		 * radar found flag and also restart the netif
 		 * queues.
 		 */
-		spin_lock_bh(&hdd_ctx_ptr->dfs_lock);
+		adf_os_spin_lock_bh(&hdd_ctx_ptr->dfs_lock);
 		hdd_ctx_ptr->dfs_radar_found = VOS_FALSE;
-		spin_unlock_bh(&hdd_ctx_ptr->dfs_lock);
+		adf_os_spin_unlock_bh(&hdd_ctx_ptr->dfs_lock);
 
 		ret = -EINVAL;
 	}
@@ -5293,7 +5293,7 @@ static __iw_softap_getassoc_stamacaddr(struct net_device *dev,
     maclist_index = sizeof(maclist_index);
     left = wrqu->data.length - maclist_index;
 
-    spin_lock_bh(&pHostapdAdapter->staInfo_lock);
+    adf_os_spin_lock_bh(&pHostapdAdapter->staInfo_lock);
     while ((cnt < WLAN_MAX_STA_COUNT) && (left >= VOS_MAC_ADDR_SIZE)) {
         if ((pStaInfo[cnt].isUsed) &&
             (!IS_BROADCAST_MAC(pStaInfo[cnt].macAddrSTA.bytes))) {
@@ -5304,7 +5304,7 @@ static __iw_softap_getassoc_stamacaddr(struct net_device *dev,
         }
         cnt++;
     }
-    spin_unlock_bh(&pHostapdAdapter->staInfo_lock);
+    adf_os_spin_unlock_bh(&pHostapdAdapter->staInfo_lock);
 
     *((u32 *)buf) = maclist_index;
     wrqu->data.length = maclist_index;
@@ -7967,7 +7967,7 @@ hdd_adapter_t* hdd_wlan_create_ap_dev(hdd_context_t *pHddCtx,
         pWlanHostapdDev->features |= NETIF_F_RXCSUM;
 
         SET_NETDEV_DEV(pWlanHostapdDev, pHddCtx->parent_dev);
-        spin_lock_init(&pHostapdAdapter->pause_map_lock);
+        adf_os_spinlock_init(&pHostapdAdapter->pause_map_lock);
         pHostapdAdapter->last_tx_jiffies = jiffies;
         pHostapdAdapter->bug_report_count = 0;
         pHostapdAdapter->start_time =
diff --git a/CORE/HDD/src/wlan_hdd_ipa.c b/CORE/HDD/src/wlan_hdd_ipa.c
index 61c5ad8d1da2..e3bf79a2c833 100644
--- a/CORE/HDD/src/wlan_hdd_ipa.c
+++ b/CORE/HDD/src/wlan_hdd_ipa.c
@@ -431,7 +431,7 @@ struct hdd_ipa_priv {
 
 	uint32_t pending_hw_desc_cnt;
 	uint32_t hw_desc_cnt;
-	spinlock_t q_lock;
+	adf_os_spinlock_t q_lock;
 	uint32_t freeq_cnt;
 	struct list_head free_desc_head;
 
@@ -595,7 +595,7 @@ static struct ipa_tx_data_desc *hdd_ipa_alloc_data_desc(
 {
 	struct ipa_tx_data_desc *desc = NULL;
 
-	spin_lock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 
 	/* Keep the descriptors for priority alloc which can be used for
 	 * anchor nodes
@@ -615,7 +615,7 @@ static struct ipa_tx_data_desc *hdd_ipa_alloc_data_desc(
 	}
 
 end:
-	spin_unlock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 
 	return desc;
 }
@@ -626,10 +626,10 @@ static void hdd_ipa_free_data_desc(struct hdd_ipa_priv *hdd_ipa,
 	desc->priv = NULL;
 	desc->pyld_buffer = NULL;
 	desc->pyld_len = 0;
-	spin_lock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 	list_add_tail(&desc->link, &hdd_ipa->free_desc_head);
 	hdd_ipa->freeq_cnt++;
-	spin_unlock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 }
 
 static struct iphdr * hdd_ipa_get_ip_pkt(void *data, uint16_t *eth_type)
@@ -2531,12 +2531,12 @@ static int hdd_ipa_rm_try_release(struct hdd_ipa_priv *hdd_ipa)
 		return -EAGAIN;
 
 #ifndef IPA_UC_STA_OFFLOAD
-	spin_lock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 	if (hdd_ipa->pending_hw_desc_cnt || hdd_ipa->pend_q_cnt) {
-		spin_unlock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 		return -EAGAIN;
 	}
-	spin_unlock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 #endif
 
 	adf_os_spin_lock_bh(&hdd_ipa->pm_lock);
@@ -2612,11 +2612,11 @@ static void hdd_ipa_send_pkt_to_ipa(struct hdd_ipa_priv *hdd_ipa)
 
 	INIT_LIST_HEAD(&send_desc_head->link);
 
-	spin_lock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 
 	if (hdd_ipa->pending_hw_desc_cnt >= hdd_ipa->hw_desc_cnt) {
 		hdd_ipa->stats.num_rx_ipa_hw_maxed_out++;
-		spin_unlock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 		hdd_ipa_free_data_desc(hdd_ipa, send_desc_head);
 		return;
 	}
@@ -2624,7 +2624,7 @@ static void hdd_ipa_send_pkt_to_ipa(struct hdd_ipa_priv *hdd_ipa)
 	pend_q_cnt = hdd_ipa->pend_q_cnt;
 
 	if (pend_q_cnt == 0) {
-		spin_unlock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 		hdd_ipa_free_data_desc(hdd_ipa, send_desc_head);
 		return;
 	}
@@ -2658,7 +2658,7 @@ static void hdd_ipa_send_pkt_to_ipa(struct hdd_ipa_priv *hdd_ipa)
 	}
 
 	hdd_ipa->pending_hw_desc_cnt += cur_send_cnt;
-	spin_unlock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 
 	if (ipa_tx_dp_mul(hdd_ipa->prod_client, send_desc_head) != 0) {
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_ERROR,
@@ -2676,9 +2676,9 @@ static void hdd_ipa_send_pkt_to_ipa(struct hdd_ipa_priv *hdd_ipa)
 
 ipa_tx_failed:
 
-	spin_lock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 	hdd_ipa->pending_hw_desc_cnt -= cur_send_cnt;
-	spin_unlock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 
 	list_for_each_entry_safe(desc, tmp, &send_desc_head->link, link) {
 		list_del(&desc->link);
@@ -3127,10 +3127,10 @@ VOS_STATUS hdd_ipa_process_rxt(v_VOID_t *vosContext, adf_nbuf_t rx_buf_list,
 		send_desc->priv = buf;
 		send_desc->pyld_buffer = buf->data;
 		send_desc->pyld_len = buf->len;
-		spin_lock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 		list_add_tail(&send_desc->link, &hdd_ipa->pend_desc_head);
 		hdd_ipa->pend_q_cnt++;
-		spin_unlock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 		cur_cnt++;
 		buf = next_buf;
 	}
@@ -3393,9 +3393,9 @@ static void hdd_ipa_w2i_cb(void *priv, enum ipa_dp_evt_type evt,
 			buf = done_desc->priv;
 			adf_nbuf_free(buf);
 			hdd_ipa_free_data_desc(hdd_ipa, done_desc);
-			spin_lock_bh(&hdd_ipa->q_lock);
+			adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 			hdd_ipa->pending_hw_desc_cnt--;
-			spin_unlock_bh(&hdd_ipa->q_lock);
+			adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 			hdd_ipa->stats.num_rx_ipa_write_done++;
 		}
 		/* add anchor node also back to free list */
@@ -4752,24 +4752,24 @@ static void hdd_ipa_rx_pipe_desc_free(void)
 
 	max_desc_cnt = hdd_ipa->hw_desc_cnt * HDD_IPA_DESC_BUFFER_RATIO;
 
-	spin_lock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 
 	list_for_each_entry_safe(desc, tmp, &hdd_ipa->pend_desc_head, link) {
 		list_del(&desc->link);
 		adf_nbuf_free(desc->priv);
-		spin_unlock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 		hdd_ipa_free_data_desc(hdd_ipa, desc);
-		spin_lock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 	}
 
 	list_for_each_entry_safe(desc, tmp, &hdd_ipa->free_desc_head, link) {
 		list_del(&desc->link);
-		spin_unlock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 		adf_os_mem_free(desc);
-		spin_lock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 		i++;
 	}
-	spin_unlock_bh(&hdd_ipa->q_lock);
+	adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 
 	if (i != max_desc_cnt)
 		HDD_IPA_LOG(VOS_TRACE_LEVEL_FATAL, "free desc leak: %u, %u", i,
@@ -4789,7 +4789,7 @@ static int hdd_ipa_rx_pipe_desc_alloc(void)
 				hdd_ipa->hdd_ctx->cfg_ini->IpaDescSize);
 	max_desc_cnt = hdd_ipa->hw_desc_cnt * HDD_IPA_DESC_BUFFER_RATIO;
 
-	spin_lock_init(&hdd_ipa->q_lock);
+	adf_os_spinlock_init(&hdd_ipa->q_lock);
 
 	INIT_LIST_HEAD(&hdd_ipa->free_desc_head);
 	INIT_LIST_HEAD(&hdd_ipa->pend_desc_head);
@@ -4804,9 +4804,9 @@ static int hdd_ipa_rx_pipe_desc_alloc(void)
 					"Descriptor allocation failed");
 			goto fail;
 		}
-		spin_lock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_lock_bh(&hdd_ipa->q_lock);
 		list_add_tail(&tmp_desc->link, &hdd_ipa->free_desc_head);
-		spin_unlock_bh(&hdd_ipa->q_lock);
+		adf_os_spin_unlock_bh(&hdd_ipa->q_lock);
 	}
 
 
diff --git a/CORE/HDD/src/wlan_hdd_main.c b/CORE/HDD/src/wlan_hdd_main.c
index 7916730d5edf..c7dae7df518a 100644
--- a/CORE/HDD/src/wlan_hdd_main.c
+++ b/CORE/HDD/src/wlan_hdd_main.c
@@ -196,8 +196,8 @@ static char fwpath_mode_local[BUF_LEN];
  * spinlock for synchronizing asynchronous request/response
  * (full description of use in wlan_hdd_main.h)
  */
-DEFINE_SPINLOCK(hdd_context_lock);
-
+//DEFINE_SPINLOCK(hdd_context_lock);
+adf_os_spinlock_t hdd_context_lock;
 /*
  * The rate at which the driver sends RESTART event to supplicant
  * once the function 'vos_wlanRestart()' is called
@@ -1793,12 +1793,11 @@ static void hdd_set_thermal_level_cb(hdd_context_t *pHddCtx, u_int8_t level)
 static bool
 hdd_system_suspend_state(hdd_context_t *hdd_ctx)
 {
-	unsigned long flags;
 	bool s;
 
-	spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock);
 	s = hdd_ctx->system_suspended;
-	spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock);
 	return s;
 }
 
@@ -1814,13 +1813,12 @@ hdd_system_suspend_state(hdd_context_t *hdd_ctx)
 bool
 hdd_system_suspend_state_set(hdd_context_t *hdd_ctx, bool state)
 {
-	unsigned long flags;
 	bool old;
 
-	spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock);
 	old = hdd_ctx->system_suspended;
 	hdd_ctx->system_suspended = state;
-	spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock);
 
 	return old;
 }
@@ -1836,12 +1834,11 @@ hdd_system_suspend_state_set(hdd_context_t *hdd_ctx, bool state)
 int
 hdd_thermal_suspend_state(hdd_context_t *hdd_ctx)
 {
-	unsigned long flags;
 	int s;
 
-	spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock);
 	s = hdd_ctx->thermal_suspend_state;
-	spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock);
 
 	return s;
 }
@@ -1849,11 +1846,10 @@ hdd_thermal_suspend_state(hdd_context_t *hdd_ctx)
 static bool
 hdd_thermal_suspend_transit(hdd_context_t *hdd_ctx, int target, int *old)
 {
-	unsigned long flags;
 	int s;
 	bool ret = false;
 
-	spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_lock_irqsave(&hdd_ctx->thermal_suspend_lock);
 
 	s = hdd_ctx->thermal_suspend_state;
 	if (old)
@@ -1887,7 +1883,7 @@ hdd_thermal_suspend_transit(hdd_context_t *hdd_ctx, int target, int *old)
 	if (ret)
 		hdd_ctx->thermal_suspend_state = target;
 
-	spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock, flags);
+	adf_os_spin_unlock_irqrestore(&hdd_ctx->thermal_suspend_lock);
 	return ret;
 }
 
@@ -9558,18 +9554,18 @@ bool hdd_dfs_indicate_radar(void *context, void *param)
 
     if (VOS_TRUE == hdd_radar_event->dfs_radar_status)
     {
-        spin_lock_bh(&pHddCtx->dfs_lock);
+        adf_os_spin_lock_bh(&pHddCtx->dfs_lock);
         if (pHddCtx->dfs_radar_found)
         {
             /* Application already triggered channel switch
              * on current channel, so return here
              */
-            spin_unlock_bh(&pHddCtx->dfs_lock);
+            adf_os_spin_unlock_bh(&pHddCtx->dfs_lock);
             return false;
         }
 
         pHddCtx->dfs_radar_found = VOS_TRUE;
-        spin_unlock_bh(&pHddCtx->dfs_lock);
+        adf_os_spin_unlock_bh(&pHddCtx->dfs_lock);
 
         status = hdd_get_front_adapter ( pHddCtx, &pAdapterNode );
         while ( NULL != pAdapterNode && VOS_STATUS_SUCCESS == status )
@@ -11007,7 +11003,7 @@ hdd_adapter_runtime_suspend_denit(hdd_adapter_t *adapter) { }
  */
 static void hdd_adapter_init_action_frame_random_mac(hdd_adapter_t *adapter)
 {
-	spin_lock_init(&adapter->random_mac_lock);
+	adf_os_spinlock_init(&adapter->random_mac_lock);
 	vos_mem_zero(adapter->random_mac, sizeof(adapter->random_mac));
 }
 
@@ -11076,7 +11072,7 @@ static hdd_adapter_t* hdd_alloc_station_adapter(hdd_context_t *pHddCtx,
       SET_NETDEV_DEV(pWlanDev, pHddCtx->parent_dev);
       hdd_wmm_init( pAdapter );
       hdd_adapter_runtime_suspend_init(pAdapter);
-      spin_lock_init(&pAdapter->pause_map_lock);
+      adf_os_spinlock_init(&pAdapter->pause_map_lock);
       pAdapter->last_tx_jiffies = jiffies;
       pAdapter->bug_report_count = 0;
       pAdapter->start_time = pAdapter->last_time = vos_system_ticks();
@@ -11149,7 +11145,7 @@ static hdd_adapter_t *hdd_alloc_monitor_adapter(hdd_context_t *pHddCtx,
 	   SET_NETDEV_DEV(pwlan_dev, pHddCtx->parent_dev);
 	   hdd_wmm_init(pAdapter);
 	   hdd_adapter_runtime_suspend_init(pAdapter);
-	   spin_lock_init(&pAdapter->pause_map_lock);
+	   adf_os_spinlock_init(&pAdapter->pause_map_lock);
 	   pAdapter->last_tx_jiffies = jiffies;
 	   pAdapter->bug_report_count = 0;
 	   pAdapter->start_time = pAdapter->last_time = vos_system_ticks();
@@ -13877,10 +13873,10 @@ VOS_STATUS hdd_get_front_adapter( hdd_context_t *pHddCtx,
                                   hdd_adapter_list_node_t** ppAdapterNode)
 {
     VOS_STATUS status;
-    spin_lock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_lock_bh(&pHddCtx->hddAdapters.lock);
     status =  hdd_list_peek_front ( &pHddCtx->hddAdapters,
                    (hdd_list_node_t**) ppAdapterNode );
-    spin_unlock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_unlock_bh(&pHddCtx->hddAdapters.lock);
     return status;
 }
 
@@ -13889,12 +13885,12 @@ VOS_STATUS hdd_get_next_adapter( hdd_context_t *pHddCtx,
                                  hdd_adapter_list_node_t** pNextAdapterNode)
 {
     VOS_STATUS status;
-    spin_lock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_lock_bh(&pHddCtx->hddAdapters.lock);
     status = hdd_list_peek_next ( &pHddCtx->hddAdapters,
                                   (hdd_list_node_t*) pAdapterNode,
                                   (hdd_list_node_t**)pNextAdapterNode );
 
-    spin_unlock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_unlock_bh(&pHddCtx->hddAdapters.lock);
     return status;
 }
 
@@ -13902,10 +13898,10 @@ VOS_STATUS hdd_remove_adapter( hdd_context_t *pHddCtx,
                                hdd_adapter_list_node_t* pAdapterNode)
 {
     VOS_STATUS status;
-    spin_lock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_lock_bh(&pHddCtx->hddAdapters.lock);
     status =  hdd_list_remove_node ( &pHddCtx->hddAdapters,
                                      &pAdapterNode->node );
-    spin_unlock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_unlock_bh(&pHddCtx->hddAdapters.lock);
     return status;
 }
 
@@ -13913,10 +13909,10 @@ VOS_STATUS hdd_remove_front_adapter( hdd_context_t *pHddCtx,
                                      hdd_adapter_list_node_t** ppAdapterNode)
 {
     VOS_STATUS status;
-    spin_lock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_lock_bh(&pHddCtx->hddAdapters.lock);
     status =  hdd_list_remove_front( &pHddCtx->hddAdapters,
                    (hdd_list_node_t**) ppAdapterNode );
-    spin_unlock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_unlock_bh(&pHddCtx->hddAdapters.lock);
     return status;
 }
 
@@ -13924,10 +13920,10 @@ VOS_STATUS hdd_add_adapter_back( hdd_context_t *pHddCtx,
                                  hdd_adapter_list_node_t* pAdapterNode)
 {
     VOS_STATUS status;
-    spin_lock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_lock_bh(&pHddCtx->hddAdapters.lock);
     status =  hdd_list_insert_back ( &pHddCtx->hddAdapters,
                    (hdd_list_node_t*) pAdapterNode );
-    spin_unlock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_unlock_bh(&pHddCtx->hddAdapters.lock);
     return status;
 }
 
@@ -13935,10 +13931,10 @@ VOS_STATUS hdd_add_adapter_front( hdd_context_t *pHddCtx,
                                   hdd_adapter_list_node_t* pAdapterNode)
 {
     VOS_STATUS status;
-    spin_lock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_lock_bh(&pHddCtx->hddAdapters.lock);
     status =  hdd_list_insert_front ( &pHddCtx->hddAdapters,
                    (hdd_list_node_t*) pAdapterNode );
-    spin_unlock_bh(&pHddCtx->hddAdapters.lock);
+    adf_os_spin_unlock_bh(&pHddCtx->hddAdapters.lock);
     return status;
 }
 
@@ -14251,12 +14247,12 @@ static void hdd_full_power_callback(void *callbackContext, eHalStatus status)
       function and the caller since the caller could time out either
       before or while this code is executing.  we use a spinlock to
       serialize these actions */
-   spin_lock(&hdd_context_lock);
+   adf_os_spin_lock(&hdd_context_lock);
 
    if (POWER_CONTEXT_MAGIC != pContext->magic)
    {
       /* the caller presumably timed out so there is nothing we can do */
-      spin_unlock(&hdd_context_lock);
+      adf_os_spin_unlock(&hdd_context_lock);
       hddLog(VOS_TRACE_LEVEL_WARN,
              "%s: Invalid context, magic [%08x]",
               __func__, pContext->magic);
@@ -14272,7 +14268,7 @@ static void hdd_full_power_callback(void *callbackContext, eHalStatus status)
    complete(&pContext->completion);
 
    /* serialization is complete */
-   spin_unlock(&hdd_context_lock);
+   adf_os_spin_unlock(&hdd_context_lock);
 }
 
 static inline VOS_STATUS hdd_UnregisterWext_all_adapters(hdd_context_t *pHddCtx)
@@ -14682,11 +14678,11 @@ void hdd_wlan_exit(hdd_context_t *pHddCtx)
        hddLog(VOS_TRACE_LEVEL_FATAL, "%s: deinit skip acs scan timer failed",
               __func__);
 
-   spin_lock(&pHddCtx->acs_skip_lock);
+   adf_os_spin_lock(&pHddCtx->acs_skip_lock);
    vos_mem_free(pHddCtx->last_acs_channel_list);
    pHddCtx->last_acs_channel_list = NULL;
    pHddCtx->num_of_channels = 0;
-   spin_unlock(&pHddCtx->acs_skip_lock);
+   adf_os_spin_unlock(&pHddCtx->acs_skip_lock);
 #endif
 
 
@@ -14740,9 +14736,9 @@ void hdd_wlan_exit(hdd_context_t *pHddCtx)
          serialize these activities by invalidating the magic while
          holding a shared spinlock which will cause us to block if the
          callback is currently executing */
-      spin_lock(&hdd_context_lock);
+      adf_os_spin_lock(&hdd_context_lock);
       powerContext.magic = 0;
-      spin_unlock(&hdd_context_lock);
+      adf_os_spin_unlock(&hdd_context_lock);
    }
    else
    {
@@ -14976,11 +14972,11 @@ void hdd_skip_acs_scan_timer_handler(void * data)
 
 	hddLog(LOG1, FL("ACS Scan result expired. Reset ACS scan skip"));
 	hdd_ctx->skip_acs_scan_status = eSAP_DO_NEW_ACS_SCAN;
-	spin_lock(&hdd_ctx->acs_skip_lock);
+	adf_os_spin_lock(&hdd_ctx->acs_skip_lock);
 	vos_mem_free(hdd_ctx->last_acs_channel_list);
 	hdd_ctx->last_acs_channel_list = NULL;
 	hdd_ctx->num_of_channels = 0;
-	spin_unlock(&hdd_ctx->acs_skip_lock);
+	adf_os_spin_unlock(&hdd_ctx->acs_skip_lock);
 
 	/* Get first SAP adapter to clear results */
 	ap_adapter = hdd_get_adapter(hdd_ctx, WLAN_HDD_SOFTAP);
@@ -15598,13 +15594,13 @@ static void hdd_bus_bw_compute_cbk(void *priv)
         total_tx += pAdapter->stats.tx_packets;
 
 
-        spin_lock_bh(&pHddCtx->bus_bw_lock);
+        adf_os_spin_lock_bh(&pHddCtx->bus_bw_lock);
         pAdapter->prev_tx_packets = pAdapter->stats.tx_packets;
         pAdapter->prev_tx_bytes = pAdapter->stats.tx_bytes;
         pAdapter->prev_rx_packets = pAdapter->stats.rx_packets;
         pAdapter->prev_fwd_tx_packets = fwd_tx_packets;
         pAdapter->prev_fwd_rx_packets = fwd_rx_packets;
-        spin_unlock_bh(&pHddCtx->bus_bw_lock);
+        adf_os_spin_unlock_bh(&pHddCtx->bus_bw_lock);
         connected = TRUE;
     }
 
@@ -16399,7 +16395,7 @@ static VOS_STATUS hdd_init_thermal_ctx(hdd_context_t *pHddCtx)
 {
 	pHddCtx->system_suspended = false;
 	pHddCtx->thermal_suspend_state = HDD_WLAN_THERMAL_ACTIVE;
-	spin_lock_init(&pHddCtx->thermal_suspend_lock);
+	adf_os_spinlock_init(&pHddCtx->thermal_suspend_lock);
 	INIT_DELAYED_WORK(&pHddCtx->thermal_suspend_work, hdd_thermal_suspend_work);
 	pHddCtx->thermal_suspend_wq = create_singlethread_workqueue("thermal_wq");
 	if (!pHddCtx->thermal_suspend_wq)
@@ -16611,7 +16607,7 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
 
    init_completion(&pHddCtx->chain_rssi_context.response_event);
 
-   spin_lock_init(&pHddCtx->schedScan_lock);
+   adf_os_spinlock_init(&pHddCtx->schedScan_lock);
 
    hdd_list_init( &pHddCtx->hddAdapters, MAX_NUMBER_OF_ADAPTERS );
 
@@ -16629,13 +16625,13 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
    }
 
 #ifdef FEATURE_WLAN_DISABLE_CHANNEL_SWITCH
-   spin_lock_init(&pHddCtx->restrict_offchan_lock);
+   adf_os_spinlock_init(&pHddCtx->restrict_offchan_lock);
    mutex_init(&pHddCtx->avoid_freq_lock);
 #endif
 
-   spin_lock_init(&pHddCtx->dfs_lock);
-   spin_lock_init(&pHddCtx->sap_update_info_lock);
-   spin_lock_init(&pHddCtx->sta_update_info_lock);
+   adf_os_spinlock_init(&pHddCtx->dfs_lock);
+   adf_os_spinlock_init(&pHddCtx->sap_update_info_lock);
+   adf_os_spinlock_init(&pHddCtx->sta_update_info_lock);
    hdd_init_offloaded_packets_ctx(pHddCtx);
    // Load all config first as TL config is needed during vos_open
    pHddCtx->cfg_ini = (hdd_config_t*) vos_mem_malloc(sizeof(hdd_config_t));
@@ -17435,7 +17431,7 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
                   hdd_skip_acs_scan_timer_handler, (void *)pHddCtx);
    if (!VOS_IS_STATUS_SUCCESS(status))
         hddLog(LOGE, FL("Failed to init ACS Skip timer\n"));
-   spin_lock_init(&pHddCtx->acs_skip_lock);
+   adf_os_spinlock_init(&pHddCtx->acs_skip_lock);
 #endif
 
 #ifdef WLAN_FEATURE_NAN
@@ -17522,7 +17518,7 @@ int hdd_wlan_startup(struct device *dev, v_VOID_t *hif_sc)
                   wlan_hdd_change_tdls_mode, (void *)pHddCtx);
 
 #ifdef FEATURE_BUS_BANDWIDTH
-   spin_lock_init(&pHddCtx->bus_bw_lock);
+   adf_os_spinlock_init(&pHddCtx->bus_bw_lock);
    vos_timer_init(&pHddCtx->bus_bw_timer,
                      VOS_TIMER_TYPE_SW,
                      hdd_bus_bw_compute_cbk,
@@ -17920,6 +17916,7 @@ static int hdd_driver_init( void)
 
    start = adf_get_boottime();
 
+   adf_os_spinlock_init(&hdd_context_lock);
 #ifdef WLAN_LOGGING_SOCK_SVC_ENABLE
    wlan_logging_sock_init_svc();
 #endif
diff --git a/CORE/HDD/src/wlan_hdd_ocb.c b/CORE/HDD/src/wlan_hdd_ocb.c
index 663e6cd8bcb0..07bfa11f4313 100644
--- a/CORE/HDD/src/wlan_hdd_ocb.c
+++ b/CORE/HDD/src/wlan_hdd_ocb.c
@@ -2325,10 +2325,10 @@ static void wlan_hdd_dsrc_update_radio_chan_stats(
 			 * entry in driver. If possible, driver can post
 			 * the recorders to application.
 			 */
-			spin_lock(&ctx->chan_stats_lock);
+			adf_os_spin_lock(&ctx->chan_stats_lock);
 			ctx->chan_stats_num = 0;
 			vos_mem_zero(dest, 2 * sizeof(*dest));
-			spin_unlock(&ctx->chan_stats_lock);
+			adf_os_spin_unlock(&ctx->chan_stats_lock);
 			hddLog(LOGE, FL("Old Chan Stats Data"));
 			return;
 		}
@@ -2337,15 +2337,15 @@ static void wlan_hdd_dsrc_update_radio_chan_stats(
 	/* Save the first channels statistics event in adapter. */
 	src = resp->chan_stats;
 	if (!ctx->chan_stats_num) {
-		spin_lock(&ctx->chan_stats_lock);
+		adf_os_spin_lock(&ctx->chan_stats_lock);
 		vos_mem_copy(dest, src, resp->num_chans * sizeof(*src));
 		ctx->chan_stats_num = resp->num_chans;
-		spin_unlock(&ctx->chan_stats_lock);
+		adf_os_spin_unlock(&ctx->chan_stats_lock);
 		return;
 	}
 
 	/* Merge new received channel statistics data to previous entry. */
-	spin_lock(&ctx->chan_stats_lock);
+	adf_os_spin_lock(&ctx->chan_stats_lock);
 	for (i = 0; i < resp->num_chans; i++, src++) {
 		struct radio_chan_stats_info *dest_entry = NULL;
 		struct radio_chan_stats_info *empty_entry = NULL;
@@ -2372,7 +2372,7 @@ static void wlan_hdd_dsrc_update_radio_chan_stats(
 			vos_mem_copy(empty_entry, src, sizeof(*src));
 			continue;
 		} else {
-			spin_unlock(&ctx->chan_stats_lock);
+			adf_os_spin_unlock(&ctx->chan_stats_lock);
 			hddLog(LOGE, FL("No entry found."));
 			return;
 		}
@@ -2404,7 +2404,7 @@ static void wlan_hdd_dsrc_update_radio_chan_stats(
 		dest->rx_succ_pkts += src->rx_succ_pkts;
 		dest->rx_fail_pkts += src->rx_fail_pkts;
 	}
-	spin_unlock(&ctx->chan_stats_lock);
+	adf_os_spin_unlock(&ctx->chan_stats_lock);
 
 	return;
 }
@@ -2446,9 +2446,9 @@ static void wlan_hdd_dsrc_radio_chan_stats_event_callback(void *context_ptr,
 	 * 2. Firmware response to the request from Host APP.
 	 * Need check whether current event is response for request.
 	 */
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	if ((ctx->magic != HDD_OCB_MAGIC) || (!ctx->cur_req)) {
-		spin_unlock(&hdd_context_lock);
+		adf_os_spin_unlock(&hdd_context_lock);
 		return;
 	}
 	req = ctx->cur_req;
@@ -2457,27 +2457,27 @@ static void wlan_hdd_dsrc_radio_chan_stats_event_callback(void *context_ptr,
 		if ((resp->num_chans == 1) &&
 		    (req->chan_freq == chan_stats->chan_freq)) {
 			complete(&ctx->completion_evt);
-			spin_unlock(&hdd_context_lock);
+			adf_os_spin_unlock(&hdd_context_lock);
 			return;
 		}
 		break;
 	case WLAN_DSRC_REQUEST_ALL_RADIO_CHAN_STATS:
 		if (resp->num_chans != ctx->config_chans_num) {
-			spin_unlock(&hdd_context_lock);
+			adf_os_spin_unlock(&hdd_context_lock);
 			return;
 		}
 		/* Check response channel is configured. */
 		for (i = 0; i < resp->num_chans; i++) {
 			if (chan_stats[i].chan_freq !=
 			    ctx->config_chans_freq[i]) {
-				spin_unlock(&hdd_context_lock);
+				adf_os_spin_unlock(&hdd_context_lock);
 				return;
 			}
 		}
 		complete(&ctx->completion_evt);
 		break;
 	}
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 
 	return;
 }
@@ -2510,7 +2510,7 @@ int wlan_hdd_dsrc_config_radio_chan_stats(hdd_adapter_t *adapter,
 	vos_mem_zero(chan_stats, DSRC_MAX_CHAN_STATS_CNT * sizeof(*chan_stats));
 
 	if (enable_chan_stats) {
-		spin_lock_init(&ctx->chan_stats_lock);
+		adf_os_spinlock_init(&ctx->chan_stats_lock);
 		ret = sme_register_radio_chan_stats_cb(
 			((hdd_context_t *)adapter->pHddCtx)->hHal, (void *)ctx,
 			wlan_hdd_dsrc_radio_chan_stats_event_callback);
@@ -2545,18 +2545,18 @@ int wlan_hdd_dsrc_request_radio_chan_stats(hdd_adapter_t *adapter,
 
 	ctx = &adapter->dsrc_chan_stats;
 	init_completion(&ctx->completion_evt);
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	ctx->magic = HDD_OCB_MAGIC;
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 	if (!wait_for_completion_timeout(&ctx->completion_evt,
 		msecs_to_jiffies(WLAN_WAIT_TIME_OCB_CMD))) {
 		hddLog(LOGE, FL("Wait for request completion timedout."));
 		ret = -ETIMEDOUT;
 	}
 
-	spin_lock(&hdd_context_lock);
+	adf_os_spin_lock(&hdd_context_lock);
 	ctx->magic = 0;
-	spin_unlock(&hdd_context_lock);
+	adf_os_spin_unlock(&hdd_context_lock);
 	return ret;
 }
 
diff --git a/CORE/HDD/src/wlan_hdd_p2p.c b/CORE/HDD/src/wlan_hdd_p2p.c
index 74108517c20b..763898dc6ec3 100644
--- a/CORE/HDD/src/wlan_hdd_p2p.c
+++ b/CORE/HDD/src/wlan_hdd_p2p.c
@@ -292,16 +292,16 @@ bool hdd_check_random_mac(hdd_adapter_t *adapter, uint8_t *random_mac_addr)
 {
 	uint32_t i = 0;
 
-	spin_lock(&adapter->random_mac_lock);
+	adf_os_spin_lock(&adapter->random_mac_lock);
 	for (i = 0; i < MAX_RANDOM_MAC_ADDRS; i++) {
 		if ((adapter->random_mac[i].in_use) &&
 		    (!memcmp(adapter->random_mac[i].addr, random_mac_addr,
 			     VOS_MAC_ADDR_SIZE))) {
-			spin_unlock(&adapter->random_mac_lock);
+			adf_os_spin_unlock(&adapter->random_mac_lock);
 			return true;
 		}
 	}
-	spin_unlock(&adapter->random_mac_lock);
+	adf_os_spin_unlock(&adapter->random_mac_lock);
 	return false;
 }
 
@@ -434,7 +434,7 @@ static int32_t hdd_set_action_frame_random_mac(hdd_adapter_t *adapter,
 	hddLog(LOG1, FL("mac_addr: " MAC_ADDRESS_STR " && cookie = %llu"),
 			MAC_ADDR_ARRAY(random_mac_addr), cookie);
 
-	spin_lock(&adapter->random_mac_lock);
+	adf_os_spin_lock(&adapter->random_mac_lock);
 	for (i = 0; i < MAX_RANDOM_MAC_ADDRS; i++) {
 		if (adapter->random_mac[i].in_use) {
 			in_use_cnt++;
@@ -448,7 +448,7 @@ static int32_t hdd_set_action_frame_random_mac(hdd_adapter_t *adapter,
 		append_ret = append_action_frame_cookie(
 					&adapter->random_mac[i].cookie_list,
 					cookie);
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 
 		if(append_ret == -ENOMEM) {
 			hddLog(LOGE, FL("No Sufficient memory for cookie"));
@@ -466,7 +466,7 @@ static int32_t hdd_set_action_frame_random_mac(hdd_adapter_t *adapter,
 
 	if ((in_use_cnt == MAX_RANDOM_MAC_ADDRS)
 		|| (i == MAX_RANDOM_MAC_ADDRS)) {
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		hddLog(LOGE, FL("Reached the limit of Max random addresses"));
 		return -EBUSY;
 	}
@@ -475,21 +475,21 @@ static int32_t hdd_set_action_frame_random_mac(hdd_adapter_t *adapter,
 	action_cookie = allocate_action_frame_cookie(&adapter->random_mac[i].cookie_list,
 					cookie);
 	if(!action_cookie) {
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		hddLog(LOGE, FL("No Sufficient memory for cookie"));
 		return -ENOMEM;
 	}
 	vos_mem_copy(adapter->random_mac[i].addr, random_mac_addr,
 		     VOS_MAC_ADDR_SIZE);
 	adapter->random_mac[i].in_use = true;
-	spin_unlock(&adapter->random_mac_lock);
+	adf_os_spin_unlock(&adapter->random_mac_lock);
 	/* Program random mac_addr */
 	if (!hdd_set_random_mac(adapter, adapter->random_mac[i].addr)) {
-		spin_lock(&adapter->random_mac_lock);
+		adf_os_spin_lock(&adapter->random_mac_lock);
 		/* clear the cookie */
 		delete_action_frame_cookie(action_cookie);
 		adapter->random_mac[i].in_use = false;
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		hddLog(LOGE, FL("random mac filter set failed for: "
 				MAC_ADDRESS_STR),
 				MAC_ADDR_ARRAY(adapter->random_mac[i].addr));
@@ -527,7 +527,7 @@ static int32_t hdd_reset_action_frame_random_mac(hdd_adapter_t *adapter,
 	hddLog(LOG1, FL("mac_addr: " MAC_ADDRESS_STR " && cookie = %llu"),
 			MAC_ADDR_ARRAY(random_mac_addr), cookie);
 
-	spin_lock(&adapter->random_mac_lock);
+	adf_os_spin_lock(&adapter->random_mac_lock);
 	for (i = 0; i < MAX_RANDOM_MAC_ADDRS; i++) {
 		if ((adapter->random_mac[i].in_use) &&
 		    (!memcmp(adapter->random_mac[i].addr,
@@ -536,7 +536,7 @@ static int32_t hdd_reset_action_frame_random_mac(hdd_adapter_t *adapter,
 	}
 
 	if (i == MAX_RANDOM_MAC_ADDRS) {
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		hddLog(LOGE, FL("trying to delete cookie of random mac-addr"
 				" for which entry is not present"));
 		return -EINVAL;
@@ -546,7 +546,7 @@ static int32_t hdd_reset_action_frame_random_mac(hdd_adapter_t *adapter,
 				    cookie);
 
 	if (!action_cookie) {
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		hddLog(LOG1, FL("No cookie matches"));
 		return 0;
 	}
@@ -554,7 +554,7 @@ static int32_t hdd_reset_action_frame_random_mac(hdd_adapter_t *adapter,
 	delete_action_frame_cookie(action_cookie);
 	if (list_empty(&adapter->random_mac[i].cookie_list)) {
 		adapter->random_mac[i].in_use = false;
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		hdd_clear_random_mac(adapter, random_mac_addr);
 		hddLog(LOG1, FL("Deleted random mac_addr:"
 				MAC_ADDRESS_STR),
@@ -562,7 +562,7 @@ static int32_t hdd_reset_action_frame_random_mac(hdd_adapter_t *adapter,
 		return 0;
 	}
 
-	spin_unlock(&adapter->random_mac_lock);
+	adf_os_spin_unlock(&adapter->random_mac_lock);
 	return 0;
 }
 
@@ -585,7 +585,7 @@ static int32_t hdd_delete_action_frame_cookie(hdd_adapter_t *adapter,
 
 	hddLog(LOG1, FL("Delete cookie = %llu"), cookie);
 
-        spin_lock(&adapter->random_mac_lock);
+        adf_os_spin_lock(&adapter->random_mac_lock);
         for (i = 0; i < MAX_RANDOM_MAC_ADDRS; i++) {
 		if (!adapter->random_mac[i].in_use)
 			continue;
@@ -600,18 +600,18 @@ static int32_t hdd_delete_action_frame_cookie(hdd_adapter_t *adapter,
 
 		if (list_empty(&adapter->random_mac[i].cookie_list)) {
 			adapter->random_mac[i].in_use = false;
-			spin_unlock(&adapter->random_mac_lock);
+			adf_os_spin_unlock(&adapter->random_mac_lock);
 			hdd_clear_random_mac(adapter,
 					     adapter->random_mac[i].addr);
 			hddLog(LOG1, FL("Deleted random addr "MAC_ADDRESS_STR),
 				MAC_ADDR_ARRAY(adapter->random_mac[i].addr));
 			return 0;
 		}
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		return 0;
 	}
 
-	spin_unlock(&adapter->random_mac_lock);
+	adf_os_spin_unlock(&adapter->random_mac_lock);
 	hddLog(LOG1, FL("Invalid cookie"));
 	return -EINVAL;
 }
@@ -632,7 +632,7 @@ static void hdd_delete_all_action_frame_cookies(hdd_adapter_t *adapter)
 	struct list_head *n;
 	struct list_head *temp;
 
-	spin_lock(&adapter->random_mac_lock);
+	adf_os_spin_lock(&adapter->random_mac_lock);
 
 	for (i = 0; i < MAX_RANDOM_MAC_ADDRS; i++) {
 
@@ -650,14 +650,14 @@ static void hdd_delete_all_action_frame_cookies(hdd_adapter_t *adapter)
 		}
 
 		adapter->random_mac[i].in_use = false;
-		spin_unlock(&adapter->random_mac_lock);
+		adf_os_spin_unlock(&adapter->random_mac_lock);
 		hdd_clear_random_mac(adapter, adapter->random_mac[i].addr);
 		hddLog(LOG1, FL("Deleted random addr " MAC_ADDRESS_STR),
 				MAC_ADDR_ARRAY(adapter->random_mac[i].addr));
-		spin_lock(&adapter->random_mac_lock);
+		adf_os_spin_lock(&adapter->random_mac_lock);
 	}
 
-	spin_unlock(&adapter->random_mac_lock);
+	adf_os_spin_unlock(&adapter->random_mac_lock);
 }
 
 static eHalStatus
@@ -1286,10 +1286,10 @@ static int wlan_hdd_roc_request_enqueue(hdd_adapter_t *adapter,
 	hdd_roc_req->pRemainChanCtx = remain_chan_ctx;
 
 	/* Enqueue this RoC request */
-	spin_lock(&hdd_ctx->hdd_roc_req_q.lock);
+	adf_os_spin_lock(&hdd_ctx->hdd_roc_req_q.lock);
 	status = hdd_list_insert_back(&hdd_ctx->hdd_roc_req_q,
 					&hdd_roc_req->node);
-	spin_unlock(&hdd_ctx->hdd_roc_req_q.lock);
+	adf_os_spin_unlock(&hdd_ctx->hdd_roc_req_q.lock);
 
 	if (VOS_STATUS_SUCCESS != status) {
 		hddLog(LOGP, FL("Not able to enqueue RoC Req context"));
@@ -1368,14 +1368,14 @@ void wlan_hdd_roc_request_dequeue(struct work_struct *work)
 	 * that any pending roc in the queue will be scheduled
 	 * on the current roc completion by scheduling the work queue.
 	 */
-	spin_lock(&hdd_ctx->hdd_roc_req_q.lock);
+	adf_os_spin_lock(&hdd_ctx->hdd_roc_req_q.lock);
 	if (list_empty(&hdd_ctx->hdd_roc_req_q.anchor)) {
-		spin_unlock(&hdd_ctx->hdd_roc_req_q.lock);
+		adf_os_spin_unlock(&hdd_ctx->hdd_roc_req_q.lock);
 		return;
 	}
 	status = hdd_list_remove_front(&hdd_ctx->hdd_roc_req_q,
 			(hdd_list_node_t **) &hdd_roc_req);
-	spin_unlock(&hdd_ctx->hdd_roc_req_q.lock);
+	adf_os_spin_unlock(&hdd_ctx->hdd_roc_req_q.lock);
 	if (VOS_STATUS_SUCCESS != status) {
 		hddLog(LOG1, FL("unable to remove roc element from list"));
 		return;
@@ -1756,13 +1756,13 @@ int __wlan_hdd_cfg80211_cancel_remain_on_channel( struct wiphy *wiphy,
     }
 
     /* Remove RoC request inside queue */
-    spin_lock(&pHddCtx->hdd_roc_req_q.lock);
+    adf_os_spin_lock(&pHddCtx->hdd_roc_req_q.lock);
     list_for_each_safe(tmp, q, &pHddCtx->hdd_roc_req_q.anchor) {
         curr_roc_req = list_entry(tmp, hdd_roc_req_t, node);
         if ((uintptr_t)curr_roc_req->pRemainChanCtx == cookie) {
             status = hdd_list_remove_node(&pHddCtx->hdd_roc_req_q,
                                    (hdd_list_node_t*)curr_roc_req);
-            spin_unlock(&pHddCtx->hdd_roc_req_q.lock);
+            adf_os_spin_unlock(&pHddCtx->hdd_roc_req_q.lock);
             if (status == VOS_STATUS_SUCCESS) {
                 vos_mem_free(curr_roc_req->pRemainChanCtx);
                 vos_mem_free(curr_roc_req);
@@ -1770,7 +1770,7 @@ int __wlan_hdd_cfg80211_cancel_remain_on_channel( struct wiphy *wiphy,
             return 0;
         }
     }
-    spin_unlock(&pHddCtx->hdd_roc_req_q.lock);
+    adf_os_spin_unlock(&pHddCtx->hdd_roc_req_q.lock);
 
     /* FIXME cancel currently running remain on chan.
      * Need to check cookie and cancel accordingly
diff --git a/CORE/HDD/src/wlan_hdd_softap_tx_rx.c b/CORE/HDD/src/wlan_hdd_softap_tx_rx.c
index 9a370a153561..e1e10f78e72f 100644
--- a/CORE/HDD/src/wlan_hdd_softap_tx_rx.c
+++ b/CORE/HDD/src/wlan_hdd_softap_tx_rx.c
@@ -82,7 +82,7 @@ static VOS_STATUS hdd_softap_flush_tx_queues( hdd_adapter_t *pAdapter )
    skb_list_node_t *pktNode = NULL;
    struct sk_buff *skb = NULL;
 
-   spin_lock_bh( &pAdapter->staInfo_lock );
+   adf_os_spin_lock_bh( &pAdapter->staInfo_lock );
    for (STAId = 0; STAId < WLAN_MAX_STA_COUNT; STAId++)
    {
       if (FALSE == pAdapter->aStaInfo[STAId].isUsed)
@@ -92,7 +92,7 @@ static VOS_STATUS hdd_softap_flush_tx_queues( hdd_adapter_t *pAdapter )
 
       for (i = 0; i < NUM_TX_QUEUES; i ++)
       {
-         spin_lock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
+         adf_os_spin_lock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
          while (true)
          {
             status = hdd_list_remove_front ( &pAdapter->aStaInfo[STAId].wmm_tx_queue[i], &anchor);
@@ -111,12 +111,12 @@ static VOS_STATUS hdd_softap_flush_tx_queues( hdd_adapter_t *pAdapter )
             break;
          }
          pAdapter->aStaInfo[STAId].txSuspended[i] = VOS_FALSE;
-         spin_unlock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
+         adf_os_spin_unlock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
       }
       pAdapter->aStaInfo[STAId].vosLowResource = VOS_FALSE;
    }
 
-   spin_unlock_bh( &pAdapter->staInfo_lock );
+   adf_os_spin_unlock_bh( &pAdapter->staInfo_lock );
 
    return status;
 }
@@ -628,7 +628,7 @@ VOS_STATUS hdd_softap_init_tx_rx( hdd_adapter_t *pAdapter )
    pAdapter->aTxQueueLimit[WLANTL_AC_VI] = HDD_SOFTAP_TX_VI_QUEUE_MAX_LEN;
    pAdapter->aTxQueueLimit[WLANTL_AC_VO] = HDD_SOFTAP_TX_VO_QUEUE_MAX_LEN;
 
-   spin_lock_init( &pAdapter->staInfo_lock );
+   adf_os_spinlock_init( &pAdapter->staInfo_lock );
 
    for (STAId = 0; STAId < WLAN_MAX_STA_COUNT; STAId++)
    {
@@ -680,7 +680,7 @@ static void hdd_softap_flush_tx_queues_sta( hdd_adapter_t *pAdapter, v_U8_t STAI
 
    for (i = 0; i < NUM_TX_QUEUES; i ++)
    {
-      spin_lock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
+      adf_os_spin_lock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
       while (true)
       {
          if (VOS_STATUS_E_EMPTY !=
@@ -698,7 +698,7 @@ static void hdd_softap_flush_tx_queues_sta( hdd_adapter_t *pAdapter, v_U8_t STAI
          //current list is empty
          break;
       }
-      spin_unlock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
+      adf_os_spin_unlock_bh(&pAdapter->aStaInfo[STAId].wmm_tx_queue[i].lock);
    }
 
    return;
@@ -717,12 +717,12 @@ static void hdd_softap_flush_tx_queues_sta( hdd_adapter_t *pAdapter, v_U8_t STAI
 VOS_STATUS hdd_softap_init_tx_rx_sta( hdd_adapter_t *pAdapter, v_U8_t STAId, v_MACADDR_t *pmacAddrSTA)
 {
    v_U8_t i = 0;
-   spin_lock_bh( &pAdapter->staInfo_lock );
+   adf_os_spin_lock_bh( &pAdapter->staInfo_lock );
    if (pAdapter->aStaInfo[STAId].isUsed)
    {
       VOS_TRACE( VOS_MODULE_ID_HDD_SAP_DATA, VOS_TRACE_LEVEL_ERROR,
                  "%s: Reinit station %d", __func__, STAId );
-      spin_unlock_bh( &pAdapter->staInfo_lock );
+      adf_os_spin_unlock_bh( &pAdapter->staInfo_lock );
       return VOS_STATUS_E_FAILURE;
    }
 
@@ -736,7 +736,7 @@ VOS_STATUS hdd_softap_init_tx_rx_sta( hdd_adapter_t *pAdapter, v_U8_t STAId, v_M
    pAdapter->aStaInfo[STAId].isDeauthInProgress = FALSE;
    vos_copy_macaddr( &pAdapter->aStaInfo[STAId].macAddrSTA, pmacAddrSTA);
 
-   spin_unlock_bh( &pAdapter->staInfo_lock );
+   adf_os_spin_unlock_bh( &pAdapter->staInfo_lock );
    return VOS_STATUS_SUCCESS;
 }
 
@@ -761,12 +761,12 @@ VOS_STATUS hdd_softap_deinit_tx_rx_sta ( hdd_adapter_t *pAdapter, v_U8_t STAId )
 
    pHostapdState = WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter);
 
-   spin_lock_bh( &pAdapter->staInfo_lock );
+   adf_os_spin_lock_bh( &pAdapter->staInfo_lock );
    if (FALSE == pAdapter->aStaInfo[STAId].isUsed)
    {
       VOS_TRACE( VOS_MODULE_ID_HDD_SAP_DATA, VOS_TRACE_LEVEL_ERROR,
                  "%s: Deinit station not inited %d", __func__, STAId );
-      spin_unlock_bh( &pAdapter->staInfo_lock );
+      adf_os_spin_unlock_bh( &pAdapter->staInfo_lock );
       return VOS_STATUS_E_FAILURE;
    }
 
@@ -814,7 +814,7 @@ VOS_STATUS hdd_softap_deinit_tx_rx_sta ( hdd_adapter_t *pAdapter, v_U8_t STAId )
       }
    }
 
-   spin_unlock_bh( &pAdapter->staInfo_lock );
+   adf_os_spin_unlock_bh( &pAdapter->staInfo_lock );
    return status;
 }
 
@@ -1009,7 +1009,7 @@ VOS_STATUS hdd_softap_DeregisterSTA( hdd_adapter_t *pAdapter, tANI_U8 staId )
     }
 
     if (pAdapter->aStaInfo[staId].isUsed) {
-        spin_lock_bh( &pAdapter->staInfo_lock );
+        adf_os_spin_lock_bh( &pAdapter->staInfo_lock );
         vos_mem_zero(&pAdapter->aStaInfo[staId], sizeof(hdd_station_info_t));
 
         /* re-init spin lock, since netdev can still open adapter until
@@ -1020,7 +1020,7 @@ VOS_STATUS hdd_softap_DeregisterSTA( hdd_adapter_t *pAdapter, tANI_U8 staId )
             hdd_list_init(&pAdapter->aStaInfo[staId].wmm_tx_queue[i],
                           HDD_TX_QUEUE_MAX_LEN);
         }
-        spin_unlock_bh( &pAdapter->staInfo_lock );
+        adf_os_spin_unlock_bh( &pAdapter->staInfo_lock );
    }
     pHddCtx->sta_to_adapter[staId] = NULL;
 
diff --git a/CORE/HDD/src/wlan_hdd_tsf.c b/CORE/HDD/src/wlan_hdd_tsf.c
index 8ce23b344f49..31d902fbb422 100644
--- a/CORE/HDD/src/wlan_hdd_tsf.c
+++ b/CORE/HDD/src/wlan_hdd_tsf.c
@@ -345,12 +345,12 @@ enum hdd_tsf_op_result __hdd_stop_tsf_sync(hdd_adapter_t *adapter)
 
 static inline void hdd_reset_timestamps(hdd_adapter_t *adapter)
 {
-	spin_lock_bh(&adapter->host_target_sync_lock);
+	adf_os_spin_lock_bh(&adapter->host_target_sync_lock);
 	adapter->cur_host_time = 0;
 	adapter->cur_target_time = 0;
 	adapter->last_host_time = 0;
 	adapter->last_target_time = 0;
-	spin_unlock_bh(&adapter->host_target_sync_lock);
+	adf_os_spin_unlock_bh(&adapter->host_target_sync_lock);
 }
 
 /**
@@ -441,7 +441,7 @@ static void hdd_update_timestamp(hdd_adapter_t *adapter,
 		return;
 	}
 
-	spin_lock_bh(&adapter->host_target_sync_lock);
+	adf_os_spin_lock_bh(&adapter->host_target_sync_lock);
 	if (target_time > 0)
 		adapter->cur_target_time = target_time;
 
@@ -494,7 +494,7 @@ static void hdd_update_timestamp(hdd_adapter_t *adapter,
 		interval = 0;
 		break;
 	}
-	spin_unlock_bh(&adapter->host_target_sync_lock);
+	adf_os_spin_unlock_bh(&adapter->host_target_sync_lock);
 
 	if (interval > 0)
 		vos_timer_start(&adapter->host_target_sync_timer, interval);
@@ -570,7 +570,7 @@ static inline int32_t hdd_get_hosttime_from_targettime(
 	 * (the tstamp-pair won't be changed)
 	 */
 	if (in_cap_state)
-		spin_lock_bh(&adapter->host_target_sync_lock);
+		adf_os_spin_lock_bh(&adapter->host_target_sync_lock);
 
 	/* at present, target_time is only 32bit in fact */
 	delta32_target = (int64_t)((target_time & MASK_UINT32) -
@@ -593,7 +593,7 @@ static inline int32_t hdd_get_hosttime_from_targettime(
 			     host_time);
 
 	if (in_cap_state)
-		spin_unlock_bh(&adapter->host_target_sync_lock);
+		adf_os_spin_unlock_bh(&adapter->host_target_sync_lock);
 
 	return ret;
 }
@@ -610,7 +610,7 @@ static inline int32_t hdd_get_targettime_from_hosttime(
 
 	in_cap_state = hdd_tsf_is_in_cap(adapter);
 	if (in_cap_state)
-		spin_lock_bh(&adapter->host_target_sync_lock);
+		adf_os_spin_lock_bh(&adapter->host_target_sync_lock);
 
 	if (host_time < adapter->last_host_time)
 		ret = hdd_uint64_minus(adapter->last_target_time,
@@ -626,7 +626,7 @@ static inline int32_t hdd_get_targettime_from_hosttime(
 				      target_time);
 
 	if (in_cap_state)
-		spin_unlock_bh(&adapter->host_target_sync_lock);
+		adf_os_spin_unlock_bh(&adapter->host_target_sync_lock);
 
 	return ret;
 }
@@ -760,10 +760,10 @@ static void hdd_capture_req_timer_expired_handler(void *arg)
 		return;
 	}
 
-	spin_lock_bh(&adapter->host_target_sync_lock);
+	adf_os_spin_lock_bh(&adapter->host_target_sync_lock);
 	adapter->cur_host_time = 0;
 	adapter->cur_target_time = 0;
-	spin_unlock_bh(&adapter->host_target_sync_lock);
+	adf_os_spin_unlock_bh(&adapter->host_target_sync_lock);
 
 	ret = hdd_reset_tsf_gpio(adapter);
 	if (0 != ret)
@@ -812,7 +812,7 @@ static enum hdd_tsf_op_result hdd_tsf_sync_init(hdd_adapter_t *adapter)
 		return HDD_TSF_OP_SUCC;
 	}
 
-	spin_lock_init(&adapter->host_target_sync_lock);
+	adf_os_spinlock_init(&adapter->host_target_sync_lock);
 
 	hdd_reset_timestamps(adapter);
 
diff --git a/CORE/HDD/src/wlan_hdd_tx_rx.c b/CORE/HDD/src/wlan_hdd_tx_rx.c
index d803c5d9ee93..c720f42b0f9f 100644
--- a/CORE/HDD/src/wlan_hdd_tx_rx.c
+++ b/CORE/HDD/src/wlan_hdd_tx_rx.c
@@ -114,7 +114,7 @@ static VOS_STATUS hdd_flush_tx_queues( hdd_adapter_t *pAdapter )
    while (++i != NUM_TX_QUEUES)
    {
       //Free up any packets in the Tx queue
-      spin_lock_bh(&pAdapter->wmm_tx_queue[i].lock);
+      adf_os_spin_lock_bh(&pAdapter->wmm_tx_queue[i].lock);
       while (true)
       {
          status = hdd_list_remove_front( &pAdapter->wmm_tx_queue[i], &anchor );
@@ -128,7 +128,7 @@ static VOS_STATUS hdd_flush_tx_queues( hdd_adapter_t *pAdapter )
          }
          break;
       }
-      spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
+      adf_os_spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
       /* Back pressure is no longer in effect */
       pAdapter->isTxSuspended[i] = VOS_FALSE;
    }
@@ -165,11 +165,11 @@ void hdd_flush_ibss_tx_queues( hdd_adapter_t *pAdapter, v_U8_t STAId)
 
    for (i = 0; i < NUM_TX_QUEUES; i++)
    {
-      spin_lock_bh(&pAdapter->wmm_tx_queue[i].lock);
+      adf_os_spin_lock_bh(&pAdapter->wmm_tx_queue[i].lock);
 
       if ( list_empty( &pAdapter->wmm_tx_queue[i].anchor ) )
       {
-         spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
+         adf_os_spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
          continue;
       }
 
@@ -204,7 +204,7 @@ void hdd_flush_ibss_tx_queues( hdd_adapter_t *pAdapter, v_U8_t STAId)
          pAdapter->isTxSuspended[i] = VOS_FALSE;
       }
 
-      spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
+      adf_os_spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
    }
 }
 
@@ -1726,38 +1726,38 @@ void wlan_hdd_netif_queue_control(hdd_adapter_t *adapter,
 		break;
 
 	case WLAN_STOP_ALL_NETIF_QUEUE:
-		spin_lock_bh(&adapter->pause_map_lock);
+		adf_os_spin_lock_bh(&adapter->pause_map_lock);
 		if (!adapter->pause_map) {
 			netif_tx_stop_all_queues(adapter->dev);
 			wlan_hdd_update_txq_timestamp(adapter->dev);
 			wlan_hdd_update_unpause_time(adapter);
 		}
 		adapter->pause_map |= (1 << reason);
-		spin_unlock_bh(&adapter->pause_map_lock);
+		adf_os_spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	case WLAN_START_ALL_NETIF_QUEUE:
-		spin_lock_bh(&adapter->pause_map_lock);
+		adf_os_spin_lock_bh(&adapter->pause_map_lock);
 		adapter->pause_map &= ~(1 << reason);
 		if (!adapter->pause_map) {
 			netif_tx_start_all_queues(adapter->dev);
 			wlan_hdd_update_pause_time(adapter);
 		}
-		spin_unlock_bh(&adapter->pause_map_lock);
+		adf_os_spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	case WLAN_WAKE_ALL_NETIF_QUEUE:
-		spin_lock_bh(&adapter->pause_map_lock);
+		adf_os_spin_lock_bh(&adapter->pause_map_lock);
 		adapter->pause_map &= ~(1 << reason);
 		if (!adapter->pause_map) {
 			netif_tx_wake_all_queues(adapter->dev);
 			wlan_hdd_update_pause_time(adapter);
 		}
-		spin_unlock_bh(&adapter->pause_map_lock);
+		adf_os_spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	case WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER:
-		spin_lock_bh(&adapter->pause_map_lock);
+		adf_os_spin_lock_bh(&adapter->pause_map_lock);
 		if (!adapter->pause_map) {
 			netif_tx_stop_all_queues(adapter->dev);
 			wlan_hdd_update_txq_timestamp(adapter->dev);
@@ -1765,33 +1765,33 @@ void wlan_hdd_netif_queue_control(hdd_adapter_t *adapter,
 		}
 		adapter->pause_map |= (1 << reason);
 		netif_carrier_off(adapter->dev);
-		spin_unlock_bh(&adapter->pause_map_lock);
+		adf_os_spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	case WLAN_START_ALL_NETIF_QUEUE_N_CARRIER:
-		spin_lock_bh(&adapter->pause_map_lock);
+		adf_os_spin_lock_bh(&adapter->pause_map_lock);
 		netif_carrier_on(adapter->dev);
 		adapter->pause_map &= ~(1 << reason);
 		if (!adapter->pause_map) {
 			netif_tx_start_all_queues(adapter->dev);
 			wlan_hdd_update_pause_time(adapter);
 		}
-		spin_unlock_bh(&adapter->pause_map_lock);
+		adf_os_spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	case WLAN_NETIF_TX_DISABLE:
-		spin_lock_bh(&adapter->pause_map_lock);
+		adf_os_spin_lock_bh(&adapter->pause_map_lock);
 		if (!adapter->pause_map) {
 			netif_tx_disable(adapter->dev);
 			wlan_hdd_update_txq_timestamp(adapter->dev);
 			wlan_hdd_update_unpause_time(adapter);
 		}
 		adapter->pause_map |= (1 << reason);
-		spin_unlock_bh(&adapter->pause_map_lock);
+		adf_os_spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	case WLAN_NETIF_TX_DISABLE_N_CARRIER:
-		spin_lock_bh(&adapter->pause_map_lock);
+		adf_os_spin_lock_bh(&adapter->pause_map_lock);
 		if (!adapter->pause_map) {
 			netif_tx_disable(adapter->dev);
 			wlan_hdd_update_txq_timestamp(adapter->dev);
@@ -1799,7 +1799,7 @@ void wlan_hdd_netif_queue_control(hdd_adapter_t *adapter,
 		}
 		adapter->pause_map |= (1 << reason);
 		netif_carrier_off(adapter->dev);
-		spin_unlock_bh(&adapter->pause_map_lock);
+		adf_os_spin_unlock_bh(&adapter->pause_map_lock);
 		break;
 
 	default:
diff --git a/CORE/HDD/src/wlan_hdd_wext.c b/CORE/HDD/src/wlan_hdd_wext.c
index 8625675680b6..d65b2bc7bd73 100644
--- a/CORE/HDD/src/wlan_hdd_wext.c
+++ b/CORE/HDD/src/wlan_hdd_wext.c
@@ -8746,11 +8746,11 @@ void hdd_wmm_tx_snapshot(hdd_adapter_t *pAdapter)
     int i = 0, j = 0;
     for ( i=0; i< NUM_TX_QUEUES; i++)
     {
-        spin_lock_bh(&pAdapter->wmm_tx_queue[i].lock);
+        adf_os_spin_lock_bh(&pAdapter->wmm_tx_queue[i].lock);
         hddLog(LOGE, "HDD WMM TxQueue Info For AC: %d Count: %d PrevAdress:%pK, NextAddress:%pK",
                i, pAdapter->wmm_tx_queue[i].count,
                pAdapter->wmm_tx_queue[i].anchor.prev, pAdapter->wmm_tx_queue[i].anchor.next);
-        spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
+        adf_os_spin_unlock_bh(&pAdapter->wmm_tx_queue[i].lock);
     }
 
     for(i =0; i<WLAN_MAX_STA_COUNT; i++)
@@ -8760,12 +8760,12 @@ void hdd_wmm_tx_snapshot(hdd_adapter_t *pAdapter)
              hddLog(LOGE, "******STAIndex: %d*********", i);
              for ( j=0; j< NUM_TX_QUEUES; j++)
              {
-                spin_lock_bh(&pAdapter->aStaInfo[i].wmm_tx_queue[j].lock);
+                adf_os_spin_lock_bh(&pAdapter->aStaInfo[i].wmm_tx_queue[j].lock);
                 hddLog(LOGE, "HDD TxQueue Info For AC: %d Count: %d PrevAdress:%pK, NextAddress:%pK",
                        j, pAdapter->aStaInfo[i].wmm_tx_queue[j].count,
                        pAdapter->aStaInfo[i].wmm_tx_queue[j].anchor.prev,
                        pAdapter->aStaInfo[i].wmm_tx_queue[j].anchor.next);
-                spin_unlock_bh(&pAdapter->aStaInfo[i].wmm_tx_queue[j].lock);
+                adf_os_spin_unlock_bh(&pAdapter->aStaInfo[i].wmm_tx_queue[j].lock);
              }
         }
     }
diff --git a/CORE/MAC/inc/sirApi.h b/CORE/MAC/inc/sirApi.h
index d95f0490da78..a023876cdf7f 100644
--- a/CORE/MAC/inc/sirApi.h
+++ b/CORE/MAC/inc/sirApi.h
@@ -7528,7 +7528,7 @@ struct dsrc_radio_chan_stats_ctxt {
 	struct completion completion_evt;
 	uint32_t config_chans_num;
 	uint32_t config_chans_freq[DSRC_MAX_CHAN_STATS_CNT];
-	spinlock_t chan_stats_lock;
+	adf_os_spinlock_t chan_stats_lock;
 	uint32_t chan_stats_num;
 	struct radio_chan_stats_info chan_stats[DSRC_MAX_CHAN_STATS_CNT];
 };
diff --git a/CORE/SERVICES/COMMON/adf/adf_nbuf.c b/CORE/SERVICES/COMMON/adf/adf_nbuf.c
index d6a5cee88d42..fa7286b76a3a 100644
--- a/CORE/SERVICES/COMMON/adf/adf_nbuf.c
+++ b/CORE/SERVICES/COMMON/adf/adf_nbuf.c
@@ -1703,13 +1703,13 @@ struct adf_nbuf_track_t {
 	size_t size;
 };
 
-static spinlock_t g_adf_net_buf_track_lock[ADF_NET_BUF_TRACK_MAX_SIZE];
+static adf_os_spinlock_t g_adf_net_buf_track_lock[ADF_NET_BUF_TRACK_MAX_SIZE];
 typedef struct adf_nbuf_track_t ADF_NBUF_TRACK;
 
 static ADF_NBUF_TRACK *gp_adf_net_buf_track_tbl[ADF_NET_BUF_TRACK_MAX_SIZE];
 static struct kmem_cache *nbuf_tracking_cache;
 static ADF_NBUF_TRACK *adf_net_buf_track_free_list;
-static spinlock_t adf_net_buf_track_free_list_lock;
+static adf_os_spinlock_t adf_net_buf_track_free_list_lock;
 static uint32_t adf_net_buf_track_free_list_count;
 static uint32_t adf_net_buf_track_used_list_count;
 static uint32_t adf_net_buf_track_max_used;
@@ -1763,10 +1763,9 @@ static inline void adf_update_max_free(void)
 static ADF_NBUF_TRACK *adf_nbuf_track_alloc(void)
 {
 	int flags = GFP_KERNEL;
-	unsigned long irq_flag;
 	ADF_NBUF_TRACK *new_node = NULL;
 
-	spin_lock_irqsave(&adf_net_buf_track_free_list_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&adf_net_buf_track_free_list_lock);
 	adf_net_buf_track_used_list_count++;
 	if (adf_net_buf_track_free_list != NULL) {
 		new_node = adf_net_buf_track_free_list;
@@ -1775,7 +1774,7 @@ static ADF_NBUF_TRACK *adf_nbuf_track_alloc(void)
 		adf_net_buf_track_free_list_count--;
 	}
 	adf_update_max_used();
-	spin_unlock_irqrestore(&adf_net_buf_track_free_list_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&adf_net_buf_track_free_list_lock);
 
 	if (new_node != NULL)
 		return new_node;
@@ -1801,8 +1800,6 @@ static ADF_NBUF_TRACK *adf_nbuf_track_alloc(void)
  */
 static void adf_nbuf_track_free(ADF_NBUF_TRACK *node)
 {
-	unsigned long irq_flag;
-
 	if (!node)
 		return;
 
@@ -1814,7 +1811,7 @@ static void adf_nbuf_track_free(ADF_NBUF_TRACK *node)
 	 * traffic occurs.
 	 */
 
-	spin_lock_irqsave(&adf_net_buf_track_free_list_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&adf_net_buf_track_free_list_lock);
 
 	adf_net_buf_track_used_list_count--;
 	if (adf_net_buf_track_free_list_count > FREEQ_POOLSIZE &&
@@ -1827,7 +1824,7 @@ static void adf_nbuf_track_free(ADF_NBUF_TRACK *node)
 		adf_net_buf_track_free_list_count++;
 	}
 	adf_update_max_free();
-	spin_unlock_irqrestore(&adf_net_buf_track_free_list_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&adf_net_buf_track_free_list_lock);
 }
 
 /**
@@ -1873,7 +1870,7 @@ static void adf_nbuf_track_prefill(void)
  */
 static void adf_nbuf_track_memory_manager_create(void)
 {
-	spin_lock_init(&adf_net_buf_track_free_list_lock);
+	adf_os_spinlock_init(&adf_net_buf_track_free_list_lock);
 	nbuf_tracking_cache = kmem_cache_create("adf_nbuf_tracking_cache",
 						sizeof(ADF_NBUF_TRACK),
 						0, 0, NULL);
@@ -1893,7 +1890,6 @@ static void adf_nbuf_track_memory_manager_create(void)
 static void adf_nbuf_track_memory_manager_destroy(void)
 {
 	ADF_NBUF_TRACK *node, *tmp;
-	unsigned long irq_flag;
 
 	adf_print("%s: %d residual freelist size",
 			  __func__, adf_net_buf_track_free_list_count);
@@ -1907,7 +1903,7 @@ static void adf_nbuf_track_memory_manager_destroy(void)
 	adf_print("%s: %d max buffers allocated observed",
 			  __func__, adf_net_buf_track_max_allocated);
 
-	spin_lock_irqsave(&adf_net_buf_track_free_list_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&adf_net_buf_track_free_list_lock);
 	node = adf_net_buf_track_free_list;
 
 	while (node) {
@@ -1932,7 +1928,7 @@ static void adf_nbuf_track_memory_manager_destroy(void)
 	adf_net_buf_track_max_free = 0;
 	adf_net_buf_track_max_allocated = 0;
 
-	spin_unlock_irqrestore(&adf_net_buf_track_free_list_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&adf_net_buf_track_free_list_lock);
 	kmem_cache_destroy(nbuf_tracking_cache);
 }
 
@@ -1969,7 +1965,7 @@ void adf_net_buf_debug_init(void)
 
 	for (i = 0; i < ADF_NET_BUF_TRACK_MAX_SIZE; i++) {
 		gp_adf_net_buf_track_tbl[i] = NULL;
-		spin_lock_init(&g_adf_net_buf_track_lock[i]);
+		adf_os_spinlock_init(&g_adf_net_buf_track_lock[i]);
 	}
 
 	return;
@@ -1987,12 +1983,11 @@ void adf_net_buf_debug_init(void)
 void adf_net_buf_debug_exit(void)
 {
 	uint32_t i;
-	unsigned long irq_flag;
 	ADF_NBUF_TRACK *p_node;
 	ADF_NBUF_TRACK *p_prev;
 
 	for (i = 0; i < ADF_NET_BUF_TRACK_MAX_SIZE; i++) {
-		spin_lock_irqsave(&g_adf_net_buf_track_lock[i], irq_flag);
+		adf_os_spin_lock_irqsave(&g_adf_net_buf_track_lock[i]);
 		p_node = gp_adf_net_buf_track_tbl[i];
 		while (p_node) {
 			p_prev = p_node;
@@ -2002,7 +1997,7 @@ void adf_net_buf_debug_exit(void)
 				  p_prev->size);
 			adf_nbuf_track_free(p_prev);
 		}
-		spin_unlock_irqrestore(&g_adf_net_buf_track_lock[i], irq_flag);
+		adf_os_spin_unlock_irqrestore(&g_adf_net_buf_track_lock[i]);
 	}
 
 	adf_nbuf_track_memory_manager_destroy();
@@ -2059,14 +2054,13 @@ void adf_net_buf_debug_add_node(adf_nbuf_t net_buf, size_t size,
 				uint8_t *file_name, uint32_t line_num)
 {
 	uint32_t i;
-	unsigned long irq_flag;
 	ADF_NBUF_TRACK *p_node;
 	ADF_NBUF_TRACK *new_node;
 
 	new_node = adf_nbuf_track_alloc();
 
 	i = adf_net_buf_debug_hash(net_buf);
-	spin_lock_irqsave(&g_adf_net_buf_track_lock[i], irq_flag);
+	adf_os_spin_lock_irqsave(&g_adf_net_buf_track_lock[i]);
 
 	p_node = adf_net_buf_debug_look_up(net_buf);
 
@@ -2095,7 +2089,7 @@ void adf_net_buf_debug_add_node(adf_nbuf_t net_buf, size_t size,
 	}
 
 done:
-	spin_unlock_irqrestore(&g_adf_net_buf_track_lock[i], irq_flag);
+	adf_os_spin_unlock_irqrestore(&g_adf_net_buf_track_lock[i]);
 
 	return;
 }
@@ -2111,11 +2105,10 @@ void adf_net_buf_debug_delete_node(adf_nbuf_t net_buf)
 	bool found = false;
 	ADF_NBUF_TRACK *p_head;
 	ADF_NBUF_TRACK *p_node;
-	unsigned long irq_flag;
 	ADF_NBUF_TRACK *p_prev;
 
 	i = adf_net_buf_debug_hash(net_buf);
-	spin_lock_irqsave(&g_adf_net_buf_track_lock[i], irq_flag);
+	adf_os_spin_lock_irqsave(&g_adf_net_buf_track_lock[i]);
 
 	p_head = gp_adf_net_buf_track_tbl[i];
 
@@ -2143,7 +2136,7 @@ void adf_net_buf_debug_delete_node(adf_nbuf_t net_buf)
 	}
 
 done:
-	spin_unlock_irqrestore(&g_adf_net_buf_track_lock[i], irq_flag);
+	adf_os_spin_unlock_irqrestore(&g_adf_net_buf_track_lock[i]);
 
 	if (!found) {
 		adf_print("Unallocated buffer ! Double free of net_buf %pK ?",
diff --git a/CORE/SERVICES/COMMON/adf/adf_os_lock.h b/CORE/SERVICES/COMMON/adf/adf_os_lock.h
index 545e62cb3379..819285bd548a 100644
--- a/CORE/SERVICES/COMMON/adf/adf_os_lock.h
+++ b/CORE/SERVICES/COMMON/adf/adf_os_lock.h
@@ -126,6 +126,14 @@ adf_os_spinlock_destroy(adf_os_spinlock_t *lock)
     __adf_os_spinlock_destroy(lock);
 }
 
+#define adf_os_raw_spin_lock(_lock) __adf_os_raw_spin_lock(_lock)
+#define adf_os_raw_spin_unlock(_lock) __adf_os_raw_spin_unlock(_lock)
+#define adf_os_raw_spin_lock_bh(_lock) __adf_os_raw_spin_lock_bh(_lock)
+#define adf_os_raw_spin_unlock_bh(_lock) __adf_os_raw_spin_unlock_bh(_lock)
+#define adf_os_raw_spin_lock_irqsave( _lock, flag) __adf_os_raw_spin_lock_irqsave(_lock, flag)
+#define adf_os_raw_spin_unlock_irqrestore( _lock, flag) \
+	__adf_os_raw_spin_unlock_irqrestore(_lock, flag)
+
 #define adf_os_spin_lock( _lock) __adf_os_spin_lock(_lock)
 #define adf_os_spin_unlock( _lock ) __adf_os_spin_unlock(_lock)
 #define adf_os_spin_lock_irqsave( _lock) __adf_os_spin_lock_irqsave(_lock)
diff --git a/CORE/SERVICES/COMMON/adf/adf_trace.c b/CORE/SERVICES/COMMON/adf/adf_trace.c
index 4a7b30aea52c..fbe623564aee 100644
--- a/CORE/SERVICES/COMMON/adf/adf_trace.c
+++ b/CORE/SERVICES/COMMON/adf/adf_trace.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -46,7 +46,7 @@
 #include "vos_timer.h"
 
 /* Static and Global variables */
-static spinlock_t l_dp_trace_lock;
+static adf_os_spinlock_t l_dp_trace_lock;
 
 static struct adf_dp_trace_record_s
 			g_adf_dp_trace_tbl[MAX_ADF_DP_TRACE_RECORDS];
@@ -72,7 +72,7 @@ void adf_dp_trace_init(void)
 {
 	uint8_t i;
 
-	spin_lock_init(&l_dp_trace_lock);
+	adf_os_spinlock_init(&l_dp_trace_lock);
 	g_adf_dp_trace_data.head = INVALID_ADF_DP_TRACE_ADDR;
 	g_adf_dp_trace_data.tail = INVALID_ADF_DP_TRACE_ADDR;
 	g_adf_dp_trace_data.num = 0;
@@ -114,11 +114,11 @@ void adf_dp_trace_init(void)
 void adf_dp_trace_set_value(uint8_t proto_bitmap, uint8_t no_of_record,
 			 uint8_t verbosity)
 {
-	spin_lock_bh(&l_dp_trace_lock);
+	adf_os_spin_lock_bh(&l_dp_trace_lock);
 	g_adf_dp_trace_data.proto_bitmap = proto_bitmap;
 	g_adf_dp_trace_data.no_of_record = no_of_record;
 	g_adf_dp_trace_data.verbosity    = verbosity;
-	spin_unlock_bh(&l_dp_trace_lock);
+	adf_os_spin_unlock_bh(&l_dp_trace_lock);
 }
 
 /**
@@ -173,7 +173,7 @@ void adf_dp_trace_set_track(adf_nbuf_t nbuf,  enum adf_proto_dir dir)
 {
 	uint32_t count = 0;
 
-	spin_lock_bh(&l_dp_trace_lock);
+	adf_os_spin_lock_bh(&l_dp_trace_lock);
 	if (ADF_TX == dir)
 		count = ++g_adf_dp_trace_data.tx_count;
 	else if (ADF_RX == dir)
@@ -186,7 +186,7 @@ void adf_dp_trace_set_track(adf_nbuf_t nbuf,  enum adf_proto_dir dir)
 		else if (ADF_RX == dir)
 			ADF_NBUF_CB_RX_DP_TRACE(nbuf) = 1;
 	}
-	spin_unlock_bh(&l_dp_trace_lock);
+	adf_os_spin_unlock_bh(&l_dp_trace_lock);
 }
 
 #define DPTRACE_PRINT(args...) \
@@ -415,7 +415,7 @@ void adf_dp_add_record(enum ADF_DP_TRACE_ID code,
 	struct adf_dp_trace_record_s *rec = NULL;
 	int index;
 
-	spin_lock_bh(&l_dp_trace_lock);
+	adf_os_spin_lock_bh(&l_dp_trace_lock);
 
 	g_adf_dp_trace_data.num++;
 
@@ -456,7 +456,7 @@ void adf_dp_add_record(enum ADF_DP_TRACE_ID code,
 	vos_get_time_of_the_day_in_hr_min_sec_usec(rec->time,
 					sizeof(rec->time));
 	rec->pid = (in_interrupt() ? 0 : current->pid);
-	spin_unlock_bh(&l_dp_trace_lock);
+	adf_os_spin_unlock_bh(&l_dp_trace_lock);
 
 	if ((g_adf_dp_trace_data.live_mode || print == true) &&
 	    (rec->code < ADF_DP_TRACE_MAX))
@@ -874,7 +874,7 @@ void adf_dp_trace_dump_all(uint32_t count)
 	/* aquire the lock so that only one thread at a time can read
 	 * the ring buffer
 	 */
-	spin_lock_bh(&l_dp_trace_lock);
+	adf_os_spin_lock_bh(&l_dp_trace_lock);
 
 	if (g_adf_dp_trace_data.head != INVALID_ADF_DP_TRACE_ADDR) {
 		i = g_adf_dp_trace_data.head;
@@ -891,7 +891,7 @@ void adf_dp_trace_dump_all(uint32_t count)
 		}
 
 		pRecord = g_adf_dp_trace_tbl[i];
-		spin_unlock_bh(&l_dp_trace_lock);
+		adf_os_spin_unlock_bh(&l_dp_trace_lock);
 		for (;; ) {
 			adf_dp_trace_cb_table[pRecord.
 					   code] (&pRecord, (uint16_t)i);
@@ -899,14 +899,14 @@ void adf_dp_trace_dump_all(uint32_t count)
 				break;
 			i += 1;
 
-			spin_lock_bh(&l_dp_trace_lock);
+			adf_os_spin_lock_bh(&l_dp_trace_lock);
 			if (MAX_ADF_DP_TRACE_RECORDS == i)
 				i = 0;
 
 			pRecord = g_adf_dp_trace_tbl[i];
-			spin_unlock_bh(&l_dp_trace_lock);
+			adf_os_spin_unlock_bh(&l_dp_trace_lock);
 		}
 	} else {
-		spin_unlock_bh(&l_dp_trace_lock);
+		adf_os_spin_unlock_bh(&l_dp_trace_lock);
 	}
 }
diff --git a/CORE/SERVICES/COMMON/adf/linux/adf_os_lock_pvt.h b/CORE/SERVICES/COMMON/adf/linux/adf_os_lock_pvt.h
index 123e248e6a7b..326502a7fabc 100644
--- a/CORE/SERVICES/COMMON/adf/linux/adf_os_lock_pvt.h
+++ b/CORE/SERVICES/COMMON/adf/linux/adf_os_lock_pvt.h
@@ -102,31 +102,14 @@ __adf_os_spinlock_init(__adf_os_spinlock_t *lock)
     return A_STATUS_OK;
 }
 
-#define __adf_os_spinlock_destroy(lock)
-/**
- * @brief Acquire a Spinlock (SMP) & disable Preemption (Preemptive)
- *
- * @param lock      (Lock object)
- * @param flags     (Current IRQ mask)
- */
-static inline void
-__adf_os_spin_lock(__adf_os_spinlock_t *lock)
-{
-    spin_lock(&lock->spinlock);
-}
-
-/**
- * @brief Unlock the spinlock and enables the Preemption
- *
- * @param lock
- * @param flags
- */
-static inline void
-__adf_os_spin_unlock(__adf_os_spinlock_t *lock)
-{
-    spin_unlock(&lock->spinlock);
-}
+#define __adf_os_raw_spin_lock(_lock) spin_lock(_lock)
+#define __adf_os_raw_spin_unlock(_lock) spin_unlock(_lock)
+#define __adf_os_raw_spin_lock_bh(_lock) spin_lock_bh(_lock)
+#define __adf_os_raw_spin_unlock_bh(_lock) spin_unlock_bh(_lock)
+#define  __adf_os_raw_spin_lock_irqsave(_lock, flag) spin_lock_irqsave(_lock, flag)
+#define __adf_os_raw_spin_unlock_irqrestore(_lock, flag) spin_unlock_irqrestore(_lock, flag)
 
+#define __adf_os_spinlock_destroy(lock)
 /**
  * @brief Acquire a Spinlock (SMP) & disable Preemption (Preemptive)
  *        Disable IRQs
@@ -182,6 +165,45 @@ __adf_os_spin_unlock_bh(__adf_os_spinlock_t *lock)
 		spin_unlock(&lock->spinlock);
 }
 
+/**
+ * @brief Acquire a Spinlock (SMP) & disable Preemption (Preemptive)
+ *
+ * @param lock      (Lock object)
+ * @param flags     (Current IRQ mask)
+ */
+#ifdef CONFIG_SMP
+static inline void
+__adf_os_spin_lock(__adf_os_spinlock_t *lock)
+{
+	__adf_os_spin_lock_bh(lock);
+}
+
+static inline void
+__adf_os_spin_unlock(__adf_os_spinlock_t *lock)
+{
+	__adf_os_spin_unlock_bh(lock);
+}
+
+#else
+static inline void
+__adf_os_spin_lock(__adf_os_spinlock_t *lock)
+{
+    spin_lock(&lock->spinlock);
+}
+
+/**
+ * @brief Unlock the spinlock and enables the Preemption
+ *
+ * @param lock
+ * @param flags
+ */
+static inline void
+__adf_os_spin_unlock(__adf_os_spinlock_t *lock)
+{
+    spin_unlock(&lock->spinlock);
+}
+#endif
+
 static inline a_bool_t
 __adf_os_spinlock_irq_exec(adf_os_handle_t  hdl,
                            __adf_os_spinlock_t      *lock,
diff --git a/CORE/SERVICES/COMMON/osdep_adf.h b/CORE/SERVICES/COMMON/osdep_adf.h
index 4e2ff99eb516..2ae84e03b382 100644
--- a/CORE/SERVICES/COMMON/osdep_adf.h
+++ b/CORE/SERVICES/COMMON/osdep_adf.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014, 2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014, 2017-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -65,6 +65,7 @@
 
 #include "if_upperproto.h"
 #include "ah_osdep.h"
+#include <adf_os_lock.h>
 
 #ifdef AR9100
 #include <ar9100.h>
@@ -277,6 +278,7 @@ typedef rwlock_t usb_readwrite_lock_t;
 
 #ifdef CONFIG_SMP
 /* Undo the one provided by the kernel to debug spin locks */
+#if 0
 #undef spin_lock
 #undef spin_unlock
 #undef spin_trylock
@@ -297,6 +299,7 @@ spin_unlock_bh(x);\
 } while (0)
 
 #define spin_trylock(x) spin_trylock_bh(x)
+#endif
 
 #define OS_SUPPORT_ASYNC_Q 1 /* support for handling asyn function calls */
 
@@ -465,7 +468,7 @@ typedef struct {
     os_tasklet_routine_t    routine;
     atomic_t                queued;
     void                    *data;
-    spinlock_t              lock;
+    adf_os_spinlock_t              lock;
 } os_task_t;
 
 typedef struct _os_schedule_routing_mesg {
@@ -492,8 +495,8 @@ typedef struct {
     u_int8_t                    *mesg_queue_buf;
     STAILQ_HEAD(, _os_mesg_t)    mesg_head;        /* queued mesg buffers */
     STAILQ_HEAD(, _os_mesg_t)    mesg_free_head;   /* free mesg buffers  */
-    spinlock_t                  lock;
-    spinlock_t                  ev_handler_lock;
+    adf_os_spinlock_t           lock;
+    adf_os_spinlock_t           ev_handler_lock;
 #ifdef USE_SOFTINTR
     void                        *_task;
 #else
@@ -686,7 +689,7 @@ os_mesgq_handler(void *timer_arg)
     /*
      * Request access to message queue to retrieve message for processing
      */
-    spin_lock(&(queue->lock));
+    adf_os_spin_lock(&(queue->lock));
 
     mesg = STAILQ_FIRST(&queue->mesg_head);
     while(mesg) {
@@ -699,19 +702,19 @@ os_mesgq_handler(void *timer_arg)
         /*
          * Release access to message queue before processing message
          */
-        spin_unlock(&(queue->lock));
+        adf_os_spin_unlock(&(queue->lock));
 
         /*
          * Ensure just one message can be processes at a time.
          */
-        spin_lock(&(queue->ev_handler_lock));
+        adf_os_spin_lock(&(queue->ev_handler_lock));
         queue->handler(queue->ctx,mesg->mesg_type,mesg->mesg_len, msg);
-        spin_unlock(&(queue->ev_handler_lock));
+        adf_os_spin_unlock(&(queue->ev_handler_lock));
 
         /*
          * Request access to message queue to retrieve next message
          */
-        spin_lock(&(queue->lock));
+        adf_os_spin_lock(&(queue->lock));
         queue->num_queued--;
         STAILQ_INSERT_TAIL(&queue->mesg_free_head,mesg, mesg_next);
         mesg = STAILQ_FIRST(&queue->mesg_head);
@@ -720,7 +723,7 @@ os_mesgq_handler(void *timer_arg)
     /*
      * Release message queue
      */
-    spin_unlock(&(queue->lock));
+    adf_os_spin_unlock(&(queue->lock));
 }
 
 /*
@@ -748,8 +751,8 @@ static INLINE int OS_MESGQ_INIT(osdev_t devhandle, os_mesg_queue_t *queue,
     queue->dev_handle = devhandle;
     STAILQ_INIT(&queue->mesg_head);
     STAILQ_INIT(&queue->mesg_free_head);
-    spin_lock_init(&(queue->lock));
-    spin_lock_init(&(queue->ev_handler_lock));
+    adf_os_spinlock_init(&(queue->lock));
+    adf_os_spinlock_init(&(queue->ev_handler_lock));
     mesg = (os_mesg_t *)queue->mesg_queue_buf;
     for (i=0;i<max_queued;++i) {
         STAILQ_INSERT_TAIL(&queue->mesg_free_head,mesg,mesg_next);
@@ -785,7 +788,7 @@ static INLINE int OS_MESGQ_SEND(os_mesg_queue_t *queue,u_int16_t type, u_int16_t
 {
     os_mesg_t *mesg;
 
-    spin_lock(&(queue->lock));
+    adf_os_spin_lock(&(queue->lock));
     if (queue->is_synchronous ) {
         queue->handler(queue->ctx,type,len, msg);
     } else {
@@ -801,7 +804,7 @@ static INLINE int OS_MESGQ_SEND(os_mesg_queue_t *queue,u_int16_t type, u_int16_t
             STAILQ_INSERT_TAIL(&queue->mesg_head, mesg, mesg_next);
             queue->num_queued++;
         } else {
-            spin_unlock(&(queue->lock));
+            adf_os_spin_unlock(&(queue->lock));
             printk("No more message queue buffers !!! \n");
             return -ENOMEM;
         }
@@ -814,7 +817,7 @@ static INLINE int OS_MESGQ_SEND(os_mesg_queue_t *queue,u_int16_t type, u_int16_t
 #endif
         }
     }
-    spin_unlock(&(queue->lock));
+    adf_os_spin_unlock(&(queue->lock));
     return 0;
 }
 
@@ -842,7 +845,7 @@ static INLINE void OS_MESGQ_DRAIN(os_mesg_queue_t *queue, os_mesg_handler_t msg_
     os_mesg_t *mesg = NULL;
     void *msg;
 
-    spin_lock(&(queue->lock));
+    adf_os_spin_lock(&(queue->lock));
 #ifndef USE_SOFTINTR
     OS_CANCEL_TIMER(&queue->_timer);
 #endif
@@ -862,7 +865,7 @@ static INLINE void OS_MESGQ_DRAIN(os_mesg_queue_t *queue, os_mesg_handler_t msg_
         mesg = STAILQ_FIRST(&queue->mesg_head);
     };
     STAILQ_INIT(&queue->mesg_head);
-    spin_unlock(&(queue->lock));
+    adf_os_spin_unlock(&(queue->lock));
 }
 
 
@@ -874,7 +877,7 @@ static INLINE void OS_MESGQ_DRAIN(os_mesg_queue_t *queue, os_mesg_handler_t msg_
 
 static INLINE void OS_MESGQ_DESTROY(os_mesg_queue_t *queue)
 {
-    spin_lock(&(queue->lock));
+    adf_os_spin_lock(&(queue->lock));
 #ifdef USE_SOFTINTR
     softintr_disestablish(queue->_task);
 #else
@@ -887,9 +890,9 @@ static INLINE void OS_MESGQ_DESTROY(os_mesg_queue_t *queue)
 #ifndef USE_SOFTINTR
     OS_FREE_TIMER(&queue->_timer);
 #endif
-    spin_unlock(&(queue->lock));
-    spin_lock_destroy(&(queue->lock));
-    spin_lock_destroy(&(queue->ev_handler_lock));
+    adf_os_spin_unlock(&(queue->lock));
+    adf_os_spinlock_destroy(&(queue->lock));
+    adf_os_spinlock_destroy(&(queue->ev_handler_lock));
 }
 
 
diff --git a/CORE/SERVICES/HIF/PCIe/hif_pci.c b/CORE/SERVICES/HIF/PCIe/hif_pci.c
index 280976459e56..0511191e3175 100644
--- a/CORE/SERVICES/HIF/PCIe/hif_pci.c
+++ b/CORE/SERVICES/HIF/PCIe/hif_pci.c
@@ -91,7 +91,7 @@ ATH_DEBUG_INSTANTIATE_MODULE_VAR(hif,
 
 
 #ifdef CONFIG_ATH_PCIE_ACCESS_DEBUG
-spinlock_t pcie_access_log_lock;
+adf_os_spinlock_t pcie_access_log_lock;
 unsigned int pcie_access_log_seqnum = 0;
 HIF_ACCESS_LOG pcie_access_log[PCIE_ACCESS_LOG_NUM];
 static void HIFTargetDumpAccessLog(void);
@@ -255,14 +255,14 @@ WAR_PCI_WRITE32(char *addr, u32 offset, u32 value)
     if (hif_pci_war1) {
         unsigned long irq_flags;
 
-        spin_lock_irqsave(&pciwar_lock, irq_flags);
+        adf_os_raw_spin_lock_irqsave(&pciwar_lock, irq_flags);
 
         (void)ioread32((void __iomem *)(addr+offset+4)); /* 3rd read prior to write */
         (void)ioread32((void __iomem *)(addr+offset+4)); /* 2nd read prior to write */
         (void)ioread32((void __iomem *)(addr+offset+4)); /* 1st read prior to write */
         iowrite32((u32)(value), (void __iomem *)(addr+offset));
 
-        spin_unlock_irqrestore(&pciwar_lock, irq_flags);
+        adf_os_raw_spin_unlock_irqrestore(&pciwar_lock, irq_flags);
     } else {
         iowrite32((u32)(value), (void __iomem *)(addr+offset));
     }
@@ -619,7 +619,7 @@ HIFPostInit(HIF_DEVICE *hif_device, void *unused, MSG_BASED_HIF_CALLBACKS *callb
 
     AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+%s\n",__FUNCTION__));
 #ifdef CONFIG_ATH_PCIE_ACCESS_DEBUG
-    spin_lock_init(&pcie_access_log_lock);
+    adf_os_spinlock_init(&pcie_access_log_lock);
 #endif
     /* Save callbacks for later installation */
     A_MEMCPY(&hif_state->msg_callbacks_pending, callbacks, sizeof(hif_state->msg_callbacks_pending));
@@ -2979,16 +2979,15 @@ HIFTargetReadChecked(A_target_id_t targid, A_UINT32 offset)
     value = A_PCI_READ32(addr);
 
     {
-    unsigned long irq_flags;
     int idx = pcie_access_log_seqnum % PCIE_ACCESS_LOG_NUM;
 
-    spin_lock_irqsave(&pcie_access_log_lock, irq_flags);
+    adf_os_spin_lock_irqsave(&pcie_access_log_lock);
     pcie_access_log[idx].seqnum = pcie_access_log_seqnum;
     pcie_access_log[idx].is_write = FALSE;
     pcie_access_log[idx].addr = addr;
     pcie_access_log[idx].value = value;
     pcie_access_log_seqnum++;
-    spin_unlock_irqrestore(&pcie_access_log_lock, irq_flags);
+    adf_os_spin_unlock_irqrestore(&pcie_access_log_lock);
     }
 
     return value;
@@ -3007,16 +3006,15 @@ HIFTargetWriteChecked(A_target_id_t targid, A_UINT32 offset, A_UINT32 value)
     A_PCI_WRITE32(addr, value);
 
     {
-    unsigned long irq_flags;
     int idx = pcie_access_log_seqnum % PCIE_ACCESS_LOG_NUM;
 
-    spin_lock_irqsave(&pcie_access_log_lock, irq_flags);
+    adf_os_spin_lock_irqsave(&pcie_access_log_lock);
     pcie_access_log[idx].seqnum = pcie_access_log_seqnum;
     pcie_access_log[idx].is_write = TRUE;
     pcie_access_log[idx].addr = addr;
     pcie_access_log[idx].value = value;
     pcie_access_log_seqnum++;
-    spin_unlock_irqrestore(&pcie_access_log_lock, irq_flags);
+    adf_os_spin_unlock_irqrestore(&pcie_access_log_lock);
     }
 }
 
@@ -3031,9 +3029,8 @@ void
 HIFTargetDumpAccessLog(void)
 {
     int idx, len, start_idx, cur_idx;
-    unsigned long irq_flags;
 
-    spin_lock_irqsave(&pcie_access_log_lock, irq_flags);
+    adf_os_spin_lock_irqsave(&pcie_access_log_lock);
     if (pcie_access_log_seqnum > PCIE_ACCESS_LOG_NUM)
     {
         len = PCIE_ACCESS_LOG_NUM;
@@ -3057,7 +3054,7 @@ HIFTargetDumpAccessLog(void)
     }
 
     pcie_access_log_seqnum = 0;
-    spin_unlock_irqrestore(&pcie_access_log_lock, irq_flags);
+    adf_os_spin_unlock_irqrestore(&pcie_access_log_lock);
 }
 #endif
 
@@ -3379,7 +3376,7 @@ void hif_pci_runtime_pm_timeout_fn(unsigned long data)
 	unsigned long timer_expires;
 	struct hif_pm_runtime_context *context, *temp;
 
-	spin_lock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_lock_bh(&hif_sc->runtime_lock);
 
 	timer_expires = hif_sc->runtime_timer_expires;
 
@@ -3407,7 +3404,7 @@ void hif_pci_runtime_pm_timeout_fn(unsigned long data)
 		}
 	}
 
-	spin_unlock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_unlock_bh(&hif_sc->runtime_lock);
 }
 
 int hif_pm_runtime_prevent_suspend(void *ol_sc, void *data)
@@ -3425,10 +3422,10 @@ int hif_pm_runtime_prevent_suspend(void *ol_sc, void *data)
 	if (in_irq())
 		WARN_ON(1);
 
-	spin_lock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_lock_bh(&hif_sc->runtime_lock);
 	context->timeout = 0;
 	__hif_pm_runtime_prevent_suspend(hif_sc, context);
-	spin_unlock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_unlock_bh(&hif_sc->runtime_lock);
 
 	return 0;
 }
@@ -3448,7 +3445,7 @@ int hif_pm_runtime_allow_suspend(void *ol_sc, void *data)
 	if (in_irq())
 		WARN_ON(1);
 
-	spin_lock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_lock_bh(&hif_sc->runtime_lock);
 
 	__hif_pm_runtime_allow_suspend(hif_sc, context);
 
@@ -3464,7 +3461,7 @@ int hif_pm_runtime_allow_suspend(void *ol_sc, void *data)
 		hif_sc->runtime_timer_expires = 0;
 	}
 
-	spin_unlock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_unlock_bh(&hif_sc->runtime_lock);
 
 	return 0;
 }
@@ -3528,7 +3525,7 @@ int hif_pm_runtime_prevent_suspend_timeout(void *ol_sc, void *data,
 	expires = jiffies + msecs_to_jiffies(delay);
 	expires += !expires;
 
-	spin_lock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_lock_bh(&hif_sc->runtime_lock);
 
 	context->timeout = delay;
 	ret = __hif_pm_runtime_prevent_suspend(hif_sc, context);
@@ -3542,7 +3539,7 @@ int hif_pm_runtime_prevent_suspend_timeout(void *ol_sc, void *data,
 		hif_sc->runtime_timer_expires = expires;
 	}
 
-	spin_unlock_bh(&hif_sc->runtime_lock);
+	adf_os_spin_unlock_bh(&hif_sc->runtime_lock);
 
 	VOS_TRACE(VOS_MODULE_ID_HIF, VOS_TRACE_LEVEL_INFO,
 		  "%s: pm_state: %d delay: %dms ret: %d\n", __func__,
@@ -3606,9 +3603,9 @@ void hif_runtime_pm_prevent_suspend_deinit(void *data)
 	 * Ensure to delete the context list entry and reduce the usage count
 	 * before freeing the context if context is active.
 	 */
-	spin_lock_bh(&sc->runtime_lock);
+	adf_os_spin_lock_bh(&sc->runtime_lock);
 	__hif_pm_runtime_allow_suspend(sc, context);
-	spin_unlock_bh(&sc->runtime_lock);
+	adf_os_spin_unlock_bh(&sc->runtime_lock);
 
 	adf_os_mem_free(context);
 }
diff --git a/CORE/SERVICES/HIF/PCIe/if_pci.c b/CORE/SERVICES/HIF/PCIe/if_pci.c
index 470c7244f8df..9a937b60eda8 100644
--- a/CORE/SERVICES/HIF/PCIe/if_pci.c
+++ b/CORE/SERVICES/HIF/PCIe/if_pci.c
@@ -943,9 +943,9 @@ static int hif_pci_autopm_debugfs_show(struct seq_file *s, void *data)
 				msecs_age / 1000, msecs_age % 1000);
 	}
 
-	spin_lock_bh(&sc->runtime_lock);
+	adf_os_spin_lock_bh(&sc->runtime_lock);
 	if (list_empty(&sc->prevent_suspend_list)) {
-		spin_unlock_bh(&sc->runtime_lock);
+		adf_os_spin_unlock_bh(&sc->runtime_lock);
 		return 0;
 	}
 
@@ -957,7 +957,7 @@ static int hif_pci_autopm_debugfs_show(struct seq_file *s, void *data)
 		seq_puts(s, " ");
 	}
 	seq_puts(s, "\n");
-	spin_unlock_bh(&sc->runtime_lock);
+	adf_os_spin_unlock_bh(&sc->runtime_lock);
 
 	return 0;
 #undef HIF_PCI_AUTOPM_STATS
@@ -1431,7 +1431,7 @@ static inline void hif_pci_pm_debugfs(struct hif_pci_softc *sc, bool init)
 
 static void hif_pci_pm_runtime_pre_init(struct hif_pci_softc *sc)
 {
-	spin_lock_init(&sc->runtime_lock);
+	adf_os_spinlock_init(&sc->runtime_lock);
 	setup_timer(&sc->runtime_timer, hif_pci_runtime_pm_timeout_fn,
 			(unsigned long)sc);
 
@@ -1514,13 +1514,13 @@ static void hif_pci_pm_runtime_post_exit(struct hif_pci_softc *sc)
 	else
 		return;
 
-	spin_lock_bh(&sc->runtime_lock);
+	adf_os_spin_lock_bh(&sc->runtime_lock);
 	list_for_each_entry_safe(ctx, tmp, &sc->prevent_suspend_list, list) {
-		spin_unlock_bh(&sc->runtime_lock);
+		adf_os_spin_unlock_bh(&sc->runtime_lock);
 		hif_runtime_pm_prevent_suspend_deinit(ctx);
-		spin_lock_bh(&sc->runtime_lock);
+		adf_os_spin_lock_bh(&sc->runtime_lock);
 	}
-	spin_unlock_bh(&sc->runtime_lock);
+	adf_os_spin_unlock_bh(&sc->runtime_lock);
 	/*
 	 * This is totally a preventive measure to ensure Runtime PM
 	 * isn't disabled for life time.
@@ -1549,11 +1549,11 @@ static void hif_pci_pm_runtime_ssr_post_exit(struct hif_pci_softc *sc)
 {
 	struct hif_pm_runtime_context *ctx, *tmp;
 
-	spin_lock_bh(&sc->runtime_lock);
+	adf_os_spin_lock_bh(&sc->runtime_lock);
 	list_for_each_entry_safe(ctx, tmp, &sc->prevent_suspend_list, list) {
 		hif_pm_ssr_runtime_allow_suspend(sc, ctx);
 	}
-	spin_unlock_bh(&sc->runtime_lock);
+	adf_os_spin_unlock_bh(&sc->runtime_lock);
 }
 
 #else
diff --git a/CORE/SERVICES/HIF/PCIe/if_pci.h b/CORE/SERVICES/HIF/PCIe/if_pci.h
index 0abd26a6adff..4ab0749b832e 100644
--- a/CORE/SERVICES/HIF/PCIe/if_pci.h
+++ b/CORE/SERVICES/HIF/PCIe/if_pci.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -125,7 +125,7 @@ struct hif_pci_softc {
     uint32_t prevent_suspend_cnt;
     struct hif_pci_pm_stats pm_stats;
     struct work_struct pm_work;
-    struct spinlock runtime_lock;
+    adf_os_spinlock_t  runtime_lock;
     struct timer_list runtime_timer;
     struct list_head prevent_suspend_list;
     unsigned long runtime_timer_expires;
diff --git a/CORE/SERVICES/HIF/USB/hif_usb.c b/CORE/SERVICES/HIF/USB/hif_usb.c
index c7eecb700518..0fad77b8955a 100644
--- a/CORE/SERVICES/HIF/USB/hif_usb.c
+++ b/CORE/SERVICES/HIF/USB/hif_usb.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -479,10 +479,10 @@ static HIF_DEVICE_USB *usb_hif_create(struct usb_interface *interface)
 
 		adf_os_mem_zero(device, sizeof(*device));
 		usb_set_intfdata(interface, device);
-		spin_lock_init(&(device->cs_lock));
-		spin_lock_init(&(device->rx_lock));
-		spin_lock_init(&(device->tx_lock));
-		spin_lock_init(&(device->rx_prestart_lock));
+		adf_os_spinlock_init(&(device->cs_lock));
+		adf_os_spinlock_init(&(device->rx_lock));
+		adf_os_spinlock_init(&(device->tx_lock));
+		adf_os_spinlock_init(&(device->rx_prestart_lock));
 		device->udev = dev;
 		device->interface = interface;
 
diff --git a/CORE/SERVICES/HIF/USB/hif_usb_internal.h b/CORE/SERVICES/HIF/USB/hif_usb_internal.h
index cfe8613bb682..807329be69bd 100644
--- a/CORE/SERVICES/HIF/USB/hif_usb_internal.h
+++ b/CORE/SERVICES/HIF/USB/hif_usb_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2016 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -114,10 +114,10 @@ typedef struct _HIF_USB_PIPE {
 } HIF_USB_PIPE;
 
 typedef struct _HIF_DEVICE_USB {
-	spinlock_t cs_lock;
-	spinlock_t tx_lock;
-	spinlock_t rx_lock;
-	spinlock_t rx_prestart_lock;
+	adf_os_spinlock_t cs_lock;
+	adf_os_spinlock_t tx_lock;
+	adf_os_spinlock_t rx_lock;
+	adf_os_spinlock_t rx_prestart_lock;
 	MSG_BASED_HIF_CALLBACKS htcCallbacks;
 	struct usb_device *udev;
 	struct usb_interface *interface;
diff --git a/CORE/SERVICES/HIF/USB/usbdrv.c b/CORE/SERVICES/HIF/USB/usbdrv.c
index e5011302e40b..86e38656fbf2 100644
--- a/CORE/SERVICES/HIF/USB/usbdrv.c
+++ b/CORE/SERVICES/HIF/USB/usbdrv.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -60,27 +60,24 @@ static void usb_hif_cleanup_recv_urb(HIF_URB_CONTEXT *urb_context);
 static void usb_hif_free_urb_to_pipe(HIF_USB_PIPE *pipe,
 				     HIF_URB_CONTEXT *urb_context)
 {
-	unsigned long flags;
-
-	spin_lock_irqsave(&pipe->device->cs_lock, flags);
+	adf_os_spin_lock_irqsave(&pipe->device->cs_lock);
 	pipe->urb_cnt++;
 	DL_ListAdd(&pipe->urb_list_head, &urb_context->link);
-	spin_unlock_irqrestore(&pipe->device->cs_lock, flags);
+	adf_os_spin_unlock_irqrestore(&pipe->device->cs_lock);
 }
 
 HIF_URB_CONTEXT *usb_hif_alloc_urb_from_pipe(HIF_USB_PIPE *pipe)
 {
 	HIF_URB_CONTEXT *urb_context = NULL;
 	DL_LIST *item;
-	unsigned long flags;
 
-	spin_lock_irqsave(&pipe->device->cs_lock, flags);
+	adf_os_spin_lock_irqsave(&pipe->device->cs_lock);
 	item = DL_ListRemoveItemFromHead(&pipe->urb_list_head);
 	if (item != NULL) {
 		urb_context = A_CONTAINING_STRUCT(item, HIF_URB_CONTEXT, link);
 		pipe->urb_cnt--;
 	}
-	spin_unlock_irqrestore(&pipe->device->cs_lock, flags);
+	adf_os_spin_unlock_irqrestore(&pipe->device->cs_lock);
 
 	return urb_context;
 }
@@ -89,13 +86,12 @@ static HIF_URB_CONTEXT *usb_hif_dequeue_pending_transfer(HIF_USB_PIPE *pipe)
 {
 	HIF_URB_CONTEXT *urb_context = NULL;
 	DL_LIST *item;
-	unsigned long flags;
 
-	spin_lock_irqsave(&pipe->device->cs_lock, flags);
+	adf_os_spin_lock_irqsave(&pipe->device->cs_lock);
 	item = DL_ListRemoveItemFromHead(&pipe->urb_pending_list);
 	if (item != NULL)
 		urb_context = A_CONTAINING_STRUCT(item, HIF_URB_CONTEXT, link);
-	spin_unlock_irqrestore(&pipe->device->cs_lock, flags);
+	adf_os_spin_unlock_irqrestore(&pipe->device->cs_lock);
 
 	return urb_context;
 }
@@ -103,20 +99,16 @@ static HIF_URB_CONTEXT *usb_hif_dequeue_pending_transfer(HIF_USB_PIPE *pipe)
 void usb_hif_enqueue_pending_transfer(HIF_USB_PIPE *pipe,
 				      HIF_URB_CONTEXT *urb_context)
 {
-	unsigned long flags;
-
-	spin_lock_irqsave(&pipe->device->cs_lock, flags);
+	adf_os_spin_lock_irqsave(&pipe->device->cs_lock);
 	DL_ListInsertTail(&pipe->urb_pending_list, &urb_context->link);
-	spin_unlock_irqrestore(&pipe->device->cs_lock, flags);
+	adf_os_spin_unlock_irqrestore(&pipe->device->cs_lock);
 }
 
 void usb_hif_remove_pending_transfer(HIF_URB_CONTEXT *urb_context)
 {
-	unsigned long flags;
-
-	spin_lock_irqsave(&urb_context->pipe->device->cs_lock, flags);
+	adf_os_spin_lock_irqsave(&urb_context->pipe->device->cs_lock);
 	DL_ListRemove(&urb_context->link);
-	spin_unlock_irqrestore(&urb_context->pipe->device->cs_lock, flags);
+	adf_os_spin_unlock_irqrestore(&urb_context->pipe->device->cs_lock);
 }
 
 static A_STATUS usb_hif_alloc_pipe_resources(HIF_USB_PIPE *pipe, int urb_cnt)
@@ -439,7 +431,6 @@ static void usb_hif_usb_recv_prestart_complete(struct urb *urb)
 	A_STATUS status = A_OK;
 	adf_nbuf_t buf = NULL;
 	HIF_USB_PIPE *pipe = urb_context->pipe;
-	unsigned long flags;
 
 	AR_DEBUG_PRINTF(USB_HIF_DEBUG_BULK_IN, (
 				"+%s: recv pipe: %d, stat:%d,len:%d urb:0x%pK\n",
@@ -502,11 +493,11 @@ static void usb_hif_usb_recv_prestart_complete(struct urb *urb)
 	usb_hif_cleanup_recv_urb(urb_context);
 
 	/* Prestart URBs runs out and now start working receive pipe. */
-	spin_lock_irqsave(&pipe->device->rx_prestart_lock, flags);
+	adf_os_spin_lock_irqsave(&pipe->device->rx_prestart_lock);
 	if (--pipe->urb_prestart_cnt == 0) {
 		usb_hif_start_recv_pipes(pipe->device);
 	}
-	spin_unlock_irqrestore(&pipe->device->rx_prestart_lock, flags);
+	adf_os_spin_unlock_irqrestore(&pipe->device->rx_prestart_lock);
 
 	AR_DEBUG_PRINTF(USB_HIF_DEBUG_BULK_IN, ("-%s\n", __func__));
 }
@@ -761,11 +752,10 @@ static void usb_hif_post_recv_prestart_transfers(HIF_USB_PIPE *recv_pipe,
 	a_uint32_t len;
 	struct urb *urb;
 	int i, usb_status, buffer_length = HIF_USB_RX_BUFFER_SIZE;
-	unsigned long flags;
 
 	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("+%s\n", __func__));
 
-	spin_lock_irqsave(&recv_pipe->device->rx_prestart_lock, flags);
+	adf_os_spin_lock_irqsave(&recv_pipe->device->rx_prestart_lock);
 	for (i = 0; i < prestart_urb; i++) {
 		urb_context = usb_hif_alloc_urb_from_pipe(recv_pipe);
 		if (NULL == urb_context)
@@ -812,7 +802,7 @@ static void usb_hif_post_recv_prestart_transfers(HIF_USB_PIPE *recv_pipe,
 			recv_pipe->urb_prestart_cnt++;
 
 	}
-	spin_unlock_irqrestore(&recv_pipe->device->rx_prestart_lock, flags);
+	adf_os_spin_unlock_irqrestore(&recv_pipe->device->rx_prestart_lock);
 
 	AR_DEBUG_PRINTF(ATH_DEBUG_TRC, ("-%s\n", __func__));
 }
diff --git a/CORE/SERVICES/HIF/sdio/hif_sdio_dev.c b/CORE/SERVICES/HIF/sdio/hif_sdio_dev.c
index 8d215633d80d..4fb73c08dd66 100644
--- a/CORE/SERVICES/HIF/sdio/hif_sdio_dev.c
+++ b/CORE/SERVICES/HIF/sdio/hif_sdio_dev.c
@@ -176,8 +176,8 @@ HTC_PACKET *HIFDevAllocRxBuffer(HIF_SDIO_DEVICE *pDev, size_t length)
  */
 static inline void rx_completion_sem_init(HIF_SDIO_DEVICE *pDev)
 {
-	spin_lock_init(&pDev->pRecvTask->rx_bundle_lock);
-	spin_lock_init(&pDev->pRecvTask->rx_sync_completion_lock);
+	adf_os_spinlock_init(&pDev->pRecvTask->rx_bundle_lock);
+	adf_os_spinlock_init(&pDev->pRecvTask->rx_sync_completion_lock);
 	sema_init(&pDev->pRecvTask->sem_rx_completion, 0);
 }
 extern int rx_completion_task(void *param);
@@ -273,7 +273,7 @@ HIF_SDIO_DEVICE* HIFDevCreate(HIF_DEVICE *hif_device,
     INIT_HTC_PACKET_QUEUE(&pDev->pRecvTask->rxBundleQueue);
     INIT_HTC_PACKET_QUEUE(&pDev->pRecvTask->rxSyncCompletionQueue);
     hif_start_rx_completion_thread(pDev);
-    spin_lock_init(&pDev->pRecvTask->rx_alloc_lock);
+    adf_os_spinlock_init(&pDev->pRecvTask->rx_alloc_lock);
     INIT_HTC_PACKET_QUEUE(&pDev->pRecvTask->rxAllocQueue);
 #endif
 
diff --git a/CORE/SERVICES/HIF/sdio/hif_sdio_internal.h b/CORE/SERVICES/HIF/sdio/hif_sdio_internal.h
index 842d9e8f2e91..6046e1fd8b8e 100644
--- a/CORE/SERVICES/HIF/sdio/hif_sdio_internal.h
+++ b/CORE/SERVICES/HIF/sdio/hif_sdio_internal.h
@@ -123,11 +123,11 @@ struct hif_recv_task {
     struct semaphore sem_rx_completion;
     int    rx_completion_shutdown;
     struct completion rx_completion_exit;
-    spinlock_t rx_bundle_lock;
-    spinlock_t rx_sync_completion_lock;
+    adf_os_spinlock_t rx_bundle_lock;
+    adf_os_spinlock_t rx_sync_completion_lock;
     HTC_PACKET_QUEUE rxBundleQueue;
     HTC_PACKET_QUEUE rxSyncCompletionQueue;
-    spinlock_t rx_alloc_lock;
+    adf_os_spinlock_t rx_alloc_lock;
     HTC_PACKET_QUEUE rxAllocQueue;
 };
 #endif
diff --git a/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c b/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c
index 0cf998fe5c18..fe3ba3338303 100644
--- a/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c
+++ b/CORE/SERVICES/HIF/sdio/hif_sdio_recv.c
@@ -125,9 +125,6 @@ static A_STATUS HIFDevAllocAndPrepareRxPackets(HIF_SDIO_DEVICE *pDev,
     int numMessages;
     int fullLength;
     A_BOOL noRecycle;
-#ifdef HIF_RX_THREAD
-    unsigned long flags;
-#endif
     HTC_TARGET *target = NULL;
     target = (HTC_TARGET *)pDev->pTarget;
     /* lock RX while we assemble the packet buffers */
@@ -186,7 +183,7 @@ static A_STATUS HIFDevAllocAndPrepareRxPackets(HIF_SDIO_DEVICE *pDev,
         /* get packet buffers for each message, if there was a bundle detected in the header,
          * use pHdr as a template to fetch all packets in the bundle */
 #ifdef HIF_RX_THREAD
-        spin_lock_irqsave(&pDev->pRecvTask->rx_alloc_lock, flags);
+        adf_os_spin_lock_irqsave(&pDev->pRecvTask->rx_alloc_lock);
 #endif
         for (j = 0; j < numMessages; j++) {
 
@@ -275,7 +272,7 @@ static A_STATUS HIFDevAllocAndPrepareRxPackets(HIF_SDIO_DEVICE *pDev,
             pPacket->Completion = NULL;
         }
 #ifdef HIF_RX_THREAD
-        spin_unlock_irqrestore(&pDev->pRecvTask->rx_alloc_lock, flags);
+        adf_os_spin_unlock_irqrestore(&pDev->pRecvTask->rx_alloc_lock);
 #endif
 
         if (A_FAILED(status)) {
@@ -863,7 +860,6 @@ int rx_completion_task(void *param)
 {
     HIF_SDIO_DEVICE *device;
     HTC_PACKET *pPacket = NULL;
-    unsigned long flags;
     HTC_PACKET *pPacketRxBundle;
     A_UINT32 paddedLength;
     unsigned char    *pBundleBuffer = NULL;
@@ -897,9 +893,9 @@ int rx_completion_task(void *param)
         }
 
         //process single packet
-        spin_lock_irqsave(&device->pRecvTask->rx_bundle_lock, flags);
+        adf_os_spin_lock_irqsave(&device->pRecvTask->rx_bundle_lock);
         if(HTC_QUEUE_EMPTY(&device->pRecvTask->rxBundleQueue)) {
-            spin_lock_irqsave(&device->pRecvTask->rx_sync_completion_lock, flags);
+            adf_os_spin_lock_irqsave(&device->pRecvTask->rx_sync_completion_lock);
             while(!HTC_QUEUE_EMPTY(&device->pRecvTask->rxSyncCompletionQueue)) {
                 pPacket = HTC_PACKET_DEQUEUE(&device->pRecvTask->rxSyncCompletionQueue);
                 if(pPacket == NULL) {
@@ -911,7 +907,7 @@ int rx_completion_task(void *param)
                     break;
                 }
             }
-            spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock, flags);
+            adf_os_spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock);
         }
         else {
             //1. Dequeue from bundle buffer queue, scatter data to sync completion queue
@@ -924,20 +920,20 @@ int rx_completion_task(void *param)
                     AR_DEBUG_PRINTF(ATH_DEBUG_WARN, ("Packets in bundle buffer is < 1"));
                     break;
                 }
-                spin_lock_irqsave(&device->pRecvTask->rx_sync_completion_lock, flags);
+                adf_os_spin_lock_irqsave(&device->pRecvTask->rx_sync_completion_lock);
                 if(HTC_PACKET_QUEUE_DEPTH(&device->pRecvTask->rxSyncCompletionQueue) < pPacketRxBundle->BundlePktnum) {
                     // corner case: the sync queue depth is not enough for processing this bundle pkt, push it back
                     HTC_PACKET_ENQUEUE_TO_HEAD(&device->pRecvTask->rxBundleQueue, pPacketRxBundle);
-                    spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock, flags);
+                    adf_os_spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock);
                     break;
                 }
-                spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock, flags);
+                adf_os_spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock);
                 pBundleBuffer = pPacketRxBundle->pBuffer;
                 pBuffer = pBundleBuffer;
                 if(pPacketRxBundle == NULL)
                     break;
 
-                spin_lock_irqsave(&device->pRecvTask->rx_sync_completion_lock, flags);
+                adf_os_spin_lock_irqsave(&device->pRecvTask->rx_sync_completion_lock);
                 //if the next pkt is single, dequeue it and process it, until the bundle pkts
                 while(TRUE) {
                     nextIsSingle = 0;
@@ -1011,13 +1007,13 @@ int rx_completion_task(void *param)
                     else
                         break;
                 }
-                spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock, flags);
+                adf_os_spin_unlock_irqrestore(&device->pRecvTask->rx_sync_completion_lock);
                 FreeHTCBundleRxPacket(target, pPacketRxBundle);
             }
         }
-        spin_unlock_irqrestore(&device->pRecvTask->rx_bundle_lock, flags);
+        adf_os_spin_unlock_irqrestore(&device->pRecvTask->rx_bundle_lock);
         //alloc skb for next bundle
-        spin_lock_irqsave(&device->pRecvTask->rx_alloc_lock, flags);
+        adf_os_spin_lock_irqsave(&device->pRecvTask->rx_alloc_lock);
         while(HTC_PACKET_QUEUE_DEPTH(&device->pRecvTask->rxAllocQueue) < 64) {
             pPacket = HIFDevAllocRxBuffer(device, 2048);
             if(pPacket == NULL) {
@@ -1026,7 +1022,7 @@ int rx_completion_task(void *param)
             }
             HTC_PACKET_ENQUEUE(&device->pRecvTask->rxAllocQueue, pPacket);
         }
-        spin_unlock_irqrestore(&device->pRecvTask->rx_alloc_lock, flags);
+        adf_os_spin_unlock_irqrestore(&device->pRecvTask->rx_alloc_lock);
     }
     complete_and_exit(&device->pRecvTask->rx_completion_exit, 0);
     return 0;
@@ -1052,7 +1048,6 @@ static A_STATUS HIFDevIssueRecvPacketBundle(HIF_SDIO_DEVICE *pDev,
     HTC_TARGET *target = NULL;
     A_UINT32 paddedLength;
 #ifdef HIF_RX_THREAD
-    unsigned long flags;
 #else
     unsigned char *pBuffer = NULL;
     A_UINT16 curPayloadLen = 0;
@@ -1145,14 +1140,14 @@ static A_STATUS HIFDevIssueRecvPacketBundle(HIF_SDIO_DEVICE *pDev,
                                 pNumLookAheads, lookAhead_part2);
         *pNumPacketsFetched = i;
         pPacketRxBundle->BundlePktnum = i;
-        spin_lock_irqsave(&pDev->pRecvTask->rx_bundle_lock, flags);
+        adf_os_spin_lock_irqsave(&pDev->pRecvTask->rx_bundle_lock);
         HTC_PACKET_ENQUEUE(&pDev->pRecvTask->rxBundleQueue, pPacketRxBundle);
-        spin_unlock_irqrestore(&pDev->pRecvTask->rx_bundle_lock, flags);
+        adf_os_spin_unlock_irqrestore(&pDev->pRecvTask->rx_bundle_lock);
 
-        spin_lock_irqsave(&pDev->pRecvTask->rx_sync_completion_lock, flags);
+        adf_os_spin_lock_irqsave(&pDev->pRecvTask->rx_sync_completion_lock);
         HTC_PACKET_QUEUE_TRANSFER_TO_TAIL(&pDev->pRecvTask->rxSyncCompletionQueue,
                                           pSyncCompletionQueue);
-        spin_unlock_irqrestore(&pDev->pRecvTask->rx_sync_completion_lock, flags);
+        adf_os_spin_unlock_irqrestore(&pDev->pRecvTask->rx_sync_completion_lock);
 #else
         *pNumPacketsFetched = i;
         pBuffer = pBundleBuffer;
@@ -1198,9 +1193,6 @@ A_STATUS HIFDevRecvMessagePendingHandler(HIF_SDIO_DEVICE *pDev,
     A_BOOL partialBundle;
     HTC_ENDPOINT_ID id;
     int totalFetched = 0;
-#ifdef HIF_RX_THREAD
-    unsigned long flags;
-#endif
 
     HTC_TARGET *target = NULL;
 
@@ -1365,9 +1357,9 @@ A_STATUS HIFDevRecvMessagePendingHandler(HIF_SDIO_DEVICE *pDev,
                 HIFDevPreprocessTrailer(pDev, pPacket, lookAheads,
                                         &NumLookAheads, lookAhead_part2);
                 pPacket->BundlePktnum = 1;
-                spin_lock_irqsave(&pDev->pRecvTask->rx_sync_completion_lock, flags);
+                adf_os_spin_lock_irqsave(&pDev->pRecvTask->rx_sync_completion_lock);
                 HTC_PACKET_ENQUEUE(&pDev->pRecvTask->rxSyncCompletionQueue, pPacket);
-                spin_unlock_irqrestore(&pDev->pRecvTask->rx_sync_completion_lock, flags);
+                adf_os_spin_unlock_irqrestore(&pDev->pRecvTask->rx_sync_completion_lock);
 #else
                 HTC_PACKET_ENQUEUE(&syncCompletedPktsQueue, pPacket);
 #endif
diff --git a/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.c b/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.c
index c8f74c84cd3b..12c5fd47dbb3 100644
--- a/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.c
+++ b/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.c
@@ -159,7 +159,7 @@ ath_hif_sdio_probe(void *context, void *hif_handle)
 
     sc->aps_osdev.device = os_dev_info.pOSDevice;
     sc->aps_osdev.bc.bc_bustype = HAL_BUS_TYPE_SDIO;
-    spin_lock_init(&sc->target_lock);
+    adf_os_spinlock_init(&sc->target_lock);
 
     {
         /*
diff --git a/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.h b/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.h
index 391658b5091f..198d40c2c907 100644
--- a/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.h
+++ b/CORE/SERVICES/HIF/sdio/linux/if_ath_sdio.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -68,7 +68,7 @@ struct ath_hif_sdio_softc {
     * Guard changes to Target HW state and to software
     * structures that track hardware state.
     */
-    spinlock_t target_lock;
+    adf_os_spinlock_t target_lock;
     void *hif_handle;
     struct targetdef_s *targetdef;
     struct hostdef_s *hostdef;
diff --git a/CORE/SERVICES/HIF/sdio/linux/native_sdio/include/hif_internal.h b/CORE/SERVICES/HIF/sdio/linux/native_sdio/include/hif_internal.h
index 4b67e17049c6..9d3ae4f07093 100644
--- a/CORE/SERVICES/HIF/sdio/linux/native_sdio/include/hif_internal.h
+++ b/CORE/SERVICES/HIF/sdio/linux/native_sdio/include/hif_internal.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014, 2016-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014, 2016-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -33,6 +33,7 @@
 #include "a_osapi.h"
 #include "adf_os_timer.h"
 #include "adf_os_atomic.h"
+#include <adf_os_lock.h>
 #include "hif.h"
 #include "hif_sdio_common.h"
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
@@ -93,7 +94,7 @@ typedef enum {
 
 struct hif_device {
     struct sdio_func *func;
-    spinlock_t asynclock;
+    adf_os_spinlock_t asynclock;
     struct task_struct* async_task;             /* task to handle async commands */
     struct semaphore sem_async;                 /* wake up for async task */
     int    async_shutdown;                      /* stop the async task */
@@ -105,11 +106,11 @@ struct hif_device {
     struct semaphore sem_tx_completion;
     int    tx_completion_shutdown;
     struct completion tx_completion_exit;
-    spinlock_t tx_completion_lock;
+    adf_os_spinlock_t tx_completion_lock;
     BUS_REQUEST *tx_completion_req;
     BUS_REQUEST **last_tx_completion;
 #endif
-    spinlock_t lock;
+    adf_os_spinlock_t lock;
     BUS_REQUEST *s_busRequestFreeQueue;         /* free list */
     BUS_REQUEST busRequest[BUS_REQUEST_MAX_NUM]; /* available bus requests */
     void     *claimedContext;
diff --git a/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c b/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c
index 656234fa6c6c..894f20b6b44a 100644
--- a/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c
+++ b/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif.c
@@ -50,13 +50,12 @@
 
 #define BUS_REQ_RECORD_SIZE 100
 u_int32_t g_bus_req_buf_idx = 0;
-spinlock_t g_bus_request_record_lock;
+adf_os_spinlock_t g_bus_request_record_lock;
 
 struct bus_request_record bus_request_record_buf[BUS_REQ_RECORD_SIZE];
 
 #define BUS_REQUEST_RECORD(r, a, l) { \
-	unsigned long flag; \
-	spin_lock_irqsave(&g_bus_request_record_lock, flag); \
+	adf_os_spin_lock_irqsave(&g_bus_request_record_lock); \
 	if (g_bus_req_buf_idx == BUS_REQ_RECORD_SIZE) \
 		g_bus_req_buf_idx = 0; \
 	bus_request_record_buf[g_bus_req_buf_idx].request = r;  \
@@ -64,7 +63,7 @@ struct bus_request_record bus_request_record_buf[BUS_REQ_RECORD_SIZE];
 	bus_request_record_buf[g_bus_req_buf_idx].len = l; \
 	bus_request_record_buf[g_bus_req_buf_idx].time = adf_get_boottime(); \
 	g_bus_req_buf_idx++; \
-	spin_unlock_irqrestore(&g_bus_request_record_lock, flag); \
+	adf_os_spin_unlock_irqrestore(&g_bus_request_record_lock); \
 }
 
 #if HIF_USE_DMA_BOUNCE_BUFFER
@@ -602,11 +601,10 @@ __HIFReadWrite(HIF_DEVICE *device,
 
 void AddToAsyncList(HIF_DEVICE *device, BUS_REQUEST *busrequest)
 {
-    unsigned long flags;
     BUS_REQUEST *async;
     BUS_REQUEST *active;
 
-    spin_lock_irqsave(&device->asynclock, flags);
+    adf_os_spin_lock_irqsave(&device->asynclock);
     active = device->asyncreq;
     if (active == NULL) {
         device->asyncreq = busrequest;
@@ -620,7 +618,7 @@ void AddToAsyncList(HIF_DEVICE *device, BUS_REQUEST *busrequest)
         active->inusenext = busrequest;
         busrequest->inusenext = NULL;
     }
-    spin_unlock_irqrestore(&device->asynclock, flags);
+    adf_os_spin_unlock_irqrestore(&device->asynclock);
 }
 
 A_STATUS
@@ -758,13 +756,11 @@ static inline void _hif_free_bus_request(HIF_DEVICE *device,
 static void add_to_tx_completion_list(HIF_DEVICE *device,
 		BUS_REQUEST *tx_comple)
 {
-	unsigned long flags;
-
-	spin_lock_irqsave(&device->tx_completion_lock, flags);
+	adf_os_spin_lock_irqsave(&device->tx_completion_lock);
 	tx_comple->inusenext = NULL;
 	*device->last_tx_completion = tx_comple;
 	device->last_tx_completion = &tx_comple->inusenext;
-	spin_unlock_irqrestore(&device->tx_completion_lock, flags);
+	adf_os_spin_unlock_irqrestore(&device->tx_completion_lock);
 }
 
 /**
@@ -777,15 +773,14 @@ static void add_to_tx_completion_list(HIF_DEVICE *device,
  */
 static void tx_clean_completion_list(HIF_DEVICE *device)
 {
-	unsigned long flags;
 	BUS_REQUEST *comple;
 	BUS_REQUEST *request;
 
-	spin_lock_irqsave(&device->tx_completion_lock, flags);
+	adf_os_spin_lock_irqsave(&device->tx_completion_lock);
 	request = device->tx_completion_req;
 	device->tx_completion_req = NULL;
 	device->last_tx_completion = &device->tx_completion_req;
-	spin_unlock_irqrestore(&device->tx_completion_lock, flags);
+	adf_os_spin_unlock_irqrestore(&device->tx_completion_lock);
 
 	while (request != NULL) {
 		comple = request->inusenext;
@@ -851,7 +846,7 @@ static int tx_completion_task(void *param)
  */
 static inline void tx_completion_sem_init(HIF_DEVICE *device)
 {
-	spin_lock_init(&device->tx_completion_lock);
+	adf_os_spinlock_init(&device->tx_completion_lock);
 	sema_init(&device->sem_tx_completion, 0);
 }
 
@@ -994,7 +989,6 @@ static int async_task(void *param)
     HIF_DEVICE *device;
     BUS_REQUEST *request;
     A_STATUS status;
-    unsigned long flags;
 
     set_user_nice(current, -3);
     device = (HIF_DEVICE *)param;
@@ -1021,7 +1015,7 @@ static int async_task(void *param)
 #endif
         /* we want to hold the host over multiple cmds if possible, but holding the host blocks card interrupts */
         sdio_claim_host(device->func);
-        spin_lock_irqsave(&device->asynclock, flags);
+        adf_os_spin_lock_irqsave(&device->asynclock);
         /* pull the request to work on */
         while (device->asyncreq != NULL) {
             request = device->asyncreq;
@@ -1030,7 +1024,7 @@ static int async_task(void *param)
             } else {
                 device->asyncreq = NULL;
             }
-            spin_unlock_irqrestore(&device->asynclock, flags);
+            adf_os_spin_unlock_irqrestore(&device->asynclock);
             AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: async_task processing req: 0x%lX\n", (unsigned long)request));
 #ifdef HIF_MBOX_SLEEP_WAR
             /* write request pending for mailbox(1-3),
@@ -1064,9 +1058,9 @@ static int async_task(void *param)
                     up(&request->sem_req);
                 }
             }
-            spin_lock_irqsave(&device->asynclock, flags);
+            adf_os_spin_lock_irqsave(&device->asynclock);
         }
-        spin_unlock_irqrestore(&device->asynclock, flags);
+        adf_os_spin_unlock_irqrestore(&device->asynclock);
         sdio_release_host(device->func);
     }
 
@@ -1821,8 +1815,8 @@ TODO: MMC SDIO3.0 Setting should also be modified in ReInit() function when Powe
             sdio_release_host(func);
         }
 
-        spin_lock_init(&device->asynclock);
-        spin_lock_init(&g_bus_request_record_lock);
+        adf_os_spinlock_init(&device->asynclock);
+        adf_os_spinlock_init(&g_bus_request_record_lock);
 
         DL_LIST_INIT(&device->ScatterReqHead);
 
@@ -1947,31 +1941,29 @@ void HIFMaskInterrupt(HIF_DEVICE *device)
 void hif_release_bus_requests(HIF_DEVICE *device)
 {
 	BUS_REQUEST *bus_req;
-	unsigned long  flag;
 
 	AR_DEBUG_PRINTF(ATH_DEBUG_TRACE,
 			("AR6000: Release busrequest queue\n"));
-	spin_lock_irqsave(&device->lock, flag);
+	adf_os_spin_lock_irqsave(&device->lock);
 
 	while ((bus_req = device->s_busRequestFreeQueue) != NULL) {
 		device->s_busRequestFreeQueue = bus_req->next;
-		spin_unlock_irqrestore(&device->lock, flag);
+		adf_os_spin_unlock_irqrestore(&device->lock);
 
 		A_FREE(bus_req);
 
-		spin_lock_irqsave(&device->lock, flag);
+		adf_os_spin_lock_irqsave(&device->lock);
 	}
 
-	spin_unlock_irqrestore(&device->lock, flag);
+	adf_os_spin_unlock_irqrestore(&device->lock);
 }
 
 BUS_REQUEST *hifAllocateBusRequest(HIF_DEVICE *device)
 {
     BUS_REQUEST *busrequest;
-    unsigned long flag;
 
     /* Acquire lock */
-    spin_lock_irqsave(&device->lock, flag);
+    adf_os_spin_lock_irqsave(&device->lock);
 
     /* Remove first in list */
     if((busrequest = device->s_busRequestFreeQueue) != NULL)
@@ -1979,7 +1971,7 @@ BUS_REQUEST *hifAllocateBusRequest(HIF_DEVICE *device)
         device->s_busRequestFreeQueue = busrequest->next;
     }
     /* Release lock */
-    spin_unlock_irqrestore(&device->lock, flag);
+    adf_os_spin_unlock_irqrestore(&device->lock);
 
     if (adf_os_unlikely(!busrequest) && dynamic_busreq) {
         AR_DEBUG_PRINTF(ATH_DEBUG_ERROR,
@@ -1997,13 +1989,11 @@ BUS_REQUEST *hifAllocateBusRequest(HIF_DEVICE *device)
 void
 hifFreeBusRequest(HIF_DEVICE *device, BUS_REQUEST *busrequest)
 {
-    unsigned long flag;
-
     if (busrequest == NULL)
        return;
     //AR_DEBUG_PRINTF(ATH_DEBUG_TRACE, ("AR6000: hifFreeBusRequest: 0x%pK\n", busrequest));
     /* Acquire lock */
-    spin_lock_irqsave(&device->lock, flag);
+    adf_os_spin_lock_irqsave(&device->lock);
 
 
     /* Insert first in list */
@@ -2012,7 +2002,7 @@ hifFreeBusRequest(HIF_DEVICE *device, BUS_REQUEST *busrequest)
     device->s_busRequestFreeQueue = busrequest;
 
     /* Release lock */
-    spin_unlock_irqrestore(&device->lock, flag);
+    adf_os_spin_unlock_irqrestore(&device->lock);
 }
 
 static A_STATUS hifDisableFunc(HIF_DEVICE *device, struct sdio_func *func)
@@ -2642,7 +2632,7 @@ addHifDevice(struct sdio_func *func)
     hifdevice->func = func;
     hifdevice->powerConfig = HIF_DEVICE_POWER_UP;
     hifdevice->DeviceState = HIF_DEVICE_STATE_ON;
-    spin_lock_init(&hifdevice->lock);
+    adf_os_spinlock_init(&hifdevice->lock);
 
     if (dynamic_busreq) {
         for (count = 0; count < BUS_REQUEST_MAX_NUM; count++) {
diff --git a/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif_scatter.c b/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif_scatter.c
index 978a8b6972f2..e9b3c0c3daba 100644
--- a/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif_scatter.c
+++ b/CORE/SERVICES/HIF/sdio/linux/native_sdio/src/hif_scatter.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2013-2014 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -33,6 +33,7 @@
 #include <linux/kthread.h>
 #include "hif_internal.h"
 #include <adf_os_mem.h>
+#include <adf_os_lock.h>
 #define ATH_MODULE_NAME hif
 #include "a_debug.h"
 
@@ -54,26 +55,23 @@
 
 static void FreeScatterReq(HIF_DEVICE *device, HIF_SCATTER_REQ *pReq)
 {
-    unsigned long flag;
-
-    spin_lock_irqsave(&device->lock, flag);
+    adf_os_spin_lock_irqsave(&device->lock);
 
     DL_ListInsertTail(&device->ScatterReqHead, &pReq->ListLink);
 
-    spin_unlock_irqrestore(&device->lock, flag);
+    adf_os_spin_unlock_irqrestore(&device->lock);
 
 }
 
 static HIF_SCATTER_REQ *AllocScatterReq(HIF_DEVICE *device)
 {
     DL_LIST       *pItem;
-    unsigned long flag;
 
-    spin_lock_irqsave(&device->lock, flag);
+    adf_os_spin_lock_irqsave(&device->lock);
 
     pItem = DL_ListRemoveItemFromHead(&device->ScatterReqHead);
 
-    spin_unlock_irqrestore(&device->lock, flag);
+    adf_os_spin_unlock_irqrestore(&device->lock);
 
     if (pItem != NULL) {
         return A_CONTAINING_STRUCT(pItem, HIF_SCATTER_REQ, ListLink);
diff --git a/CORE/SVC/src/logging/wlan_logging_sock_svc.c b/CORE/SVC/src/logging/wlan_logging_sock_svc.c
index ff1fca24b368..51a9a0812c0a 100644
--- a/CORE/SVC/src/logging/wlan_logging_sock_svc.c
+++ b/CORE/SVC/src/logging/wlan_logging_sock_svc.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -142,7 +142,7 @@ struct wlan_logging {
 	/* Number of buffers to be used for logging */
 	int num_buf;
 	/* Lock to synchronize access to shared logging resource */
-	spinlock_t spin_lock;
+	adf_os_spinlock_t spin_lock;
 	/* Holds the free node which can be used for filling logs */
 	struct list_head free_list;
 	/* Holds the filled nodes which needs to be indicated to APP */
@@ -170,7 +170,7 @@ struct wlan_logging {
 	struct list_head pkt_stat_filled_list;
 	struct pkt_stats_msg *pkt_stats_pcur_node;
 	unsigned int pkt_stat_drop_cnt;
-	spinlock_t pkt_stats_lock;
+	adf_os_spinlock_t pkt_stats_lock;
 	unsigned int pkt_stats_msg_idx;
 };
 
@@ -282,7 +282,6 @@ int wlan_log_to_user(VOS_TRACE_LEVEL log_level, char *to_be_sent, int length)
 	int total_log_len;
 	unsigned int *pfilled_length;
 	bool wake_up_thread = false;
-	unsigned long flags;
 	struct timeval tv;
 	struct rtc_time tm;
 	unsigned long local_time;
@@ -323,10 +322,10 @@ int wlan_log_to_user(VOS_TRACE_LEVEL log_level, char *to_be_sent, int length)
 		/* 1+1 indicate '\n'+'\0' */
 		total_log_len = length + tlen + 1 + 1;
 
-		spin_lock_irqsave(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 		// wlan logging svc resources are not yet initialized
 		if (!gwlan_logging.pcur_node) {
-			spin_unlock_irqrestore(&gwlan_logging.spin_lock, flags);
+			adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 			return -EIO;
 		}
 
@@ -367,7 +366,7 @@ int wlan_log_to_user(VOS_TRACE_LEVEL log_level, char *to_be_sent, int length)
 		ptr[*pfilled_length] = '\n';
 		*pfilled_length += 1;
 
-		spin_unlock_irqrestore(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 
 		/* Wakeup logger thread */
 		if ((true == wake_up_thread)) {
@@ -503,7 +502,6 @@ int pktlog_send_per_pkt_stats_to_user(void)
 {
 	int ret = -1;
 	struct pkt_stats_msg *pstats_msg;
-	unsigned long flags;
 	struct sk_buff *skb_new = NULL;
 	static int rate_limit;
 	bool free_old_skb = false;
@@ -522,12 +520,12 @@ int pktlog_send_per_pkt_stats_to_user(void)
 			break;
 		}
 
-		spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, flags);
+		adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 
 		pstats_msg = (struct pkt_stats_msg *)
 			(gwlan_logging.pkt_stat_filled_list.next);
 		list_del_init(gwlan_logging.pkt_stat_filled_list.next);
-		spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, flags);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 
 		ret = pkt_stats_fill_headers(pstats_msg->skb);
 		if (ret < 0) {
@@ -552,11 +550,11 @@ err:
 	if (free_old_skb)
 		dev_kfree_skb(pstats_msg->skb);
 
-		spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, flags);
+		adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 		pstats_msg->skb = skb_new;
 		list_add_tail(&pstats_msg->node,
 				&gwlan_logging.pkt_stat_free_list);
-		spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, flags);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 		ret = 0;
 	}
 
@@ -574,7 +572,6 @@ static int send_filled_buffers_to_user(void)
 	struct sk_buff *skb = NULL;
 	struct nlmsghdr *nlh;
 	static int nlmsg_seq;
-	unsigned long flags;
 	static int rate_limit;
 
 	while (!list_empty(&gwlan_logging.filled_list)
@@ -593,12 +590,12 @@ static int send_filled_buffers_to_user(void)
 		}
 		rate_limit = 0;
 
-		spin_lock_irqsave(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 
 		plog_msg = (struct log_msg *)
 			(gwlan_logging.filled_list.next);
 		list_del_init(gwlan_logging.filled_list.next);
-		spin_unlock_irqrestore(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 		/* 4 extra bytes for the radio idx */
 		payload_len = plog_msg->filled_length +
 			sizeof(wnl->radio) + sizeof(tAniHdr);
@@ -608,11 +605,10 @@ static int send_filled_buffers_to_user(void)
 				ANI_NL_MSG_LOG, payload_len,
 				NLM_F_REQUEST);
 		if (NULL == nlh) {
-			spin_lock_irqsave(&gwlan_logging.spin_lock, flags);
+			adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 			list_add_tail(&plog_msg->node,
 				&gwlan_logging.free_list);
-			spin_unlock_irqrestore(&gwlan_logging.spin_lock,
-							flags);
+			adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 			pr_err("%s: drop_count = %u\n", __func__,
 				++gwlan_logging.drop_count);
 			pr_err("%s: nlmsg_put() failed for msg size[%d]\n",
@@ -629,10 +625,10 @@ static int send_filled_buffers_to_user(void)
 				plog_msg->filled_length +
 				sizeof(tAniHdr));
 
-		spin_lock_irqsave(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 		list_add_tail(&plog_msg->node,
 				&gwlan_logging.free_list);
-		spin_unlock_irqrestore(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 
 		ret = nl_srv_bcast_host_logs(skb);
 		/* print every 64th drop count */
@@ -709,7 +705,6 @@ static int wlan_logging_thread(void *Arg)
 {
 	int ret_wait_status = 0;
 	int ret = 0;
-	unsigned long flags;
 
 	set_user_nice(current, -2);
 
@@ -771,11 +766,9 @@ static int wlan_logging_thread(void *Arg)
 			} else {
 				gwlan_logging.is_flush_complete = true;
 				/* Flush all current host logs*/
-				spin_lock_irqsave(&gwlan_logging.spin_lock,
-						  flags);
+				adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 				wlan_queue_logmsg_for_app();
-				spin_unlock_irqrestore(&gwlan_logging.spin_lock,
-						       flags);
+				adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 				set_bit(HOST_LOG_DRIVER_MSG,
 						&gwlan_logging.eventFlag);
 				set_bit(HOST_LOG_PER_PKT_STATS,
@@ -798,7 +791,6 @@ static int wlan_logging_thread(void *Arg)
 int wlan_logging_sock_activate_svc(int log_fe_to_console, int num_buf)
 {
 	int i, j, pkt_stats_size;
-	unsigned long irq_flag;
 
 	gplog_msg = (struct log_msg *) vmalloc(
 			num_buf * sizeof(struct log_msg));
@@ -812,7 +804,7 @@ int wlan_logging_sock_activate_svc(int log_fe_to_console, int num_buf)
 	gwlan_logging.log_fe_to_console = !!log_fe_to_console;
 	gwlan_logging.num_buf = num_buf;
 
-	spin_lock_irqsave(&gwlan_logging.spin_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 	INIT_LIST_HEAD(&gwlan_logging.free_list);
 	INIT_LIST_HEAD(&gwlan_logging.filled_list);
 
@@ -823,7 +815,7 @@ int wlan_logging_sock_activate_svc(int log_fe_to_console, int num_buf)
 	gwlan_logging.pcur_node = (struct log_msg *)
 		(gwlan_logging.free_list.next);
 	list_del_init(gwlan_logging.free_list.next);
-	spin_unlock_irqrestore(&gwlan_logging.spin_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 
 	/* Initialize the pktStats data structure here */
 	pkt_stats_size = sizeof(struct pkt_stats_msg);
@@ -836,11 +828,11 @@ int wlan_logging_sock_activate_svc(int log_fe_to_console, int num_buf)
 	vos_mem_zero(gpkt_stats_buffers,
 			MAX_PKTSTATS_BUFF * pkt_stats_size);
 
-	spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 	gwlan_logging.pkt_stats_msg_idx = 0;
 	INIT_LIST_HEAD(&gwlan_logging.pkt_stat_free_list);
 	INIT_LIST_HEAD(&gwlan_logging.pkt_stat_filled_list);
-	spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 
 
 	for (i = 0; i < MAX_PKTSTATS_BUFF; i++) {
@@ -853,16 +845,16 @@ int wlan_logging_sock_activate_svc(int log_fe_to_console, int num_buf)
 			}
 			goto err2;
 		}
-		spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, irq_flag);
+		adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 		list_add(&gpkt_stats_buffers[i].node,
 			&gwlan_logging.pkt_stat_free_list);
-		spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, irq_flag);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 	}
-	spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 	gwlan_logging.pkt_stats_pcur_node = (struct pkt_stats_msg *)
 		(gwlan_logging.pkt_stat_free_list.next);
 	list_del_init(gwlan_logging.pkt_stat_free_list.next);
-	spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 	/* Pkt Stats intialization done */
 
 	init_waitqueue_head(&gwlan_logging.wait_queue);
@@ -890,15 +882,15 @@ err3:
 			dev_kfree_skb(gpkt_stats_buffers[i].skb);
 	}
 err2:
-	spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 	gwlan_logging.pkt_stats_pcur_node = NULL;
-	spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 	vfree(gpkt_stats_buffers);
 	gpkt_stats_buffers = NULL;
 err1:
-	spin_lock_irqsave(&gwlan_logging.spin_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 	gwlan_logging.pcur_node = NULL;
-	spin_unlock_irqrestore(&gwlan_logging.spin_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 	vfree(gplog_msg);
 	gplog_msg = NULL;
 	return -ENOMEM;
@@ -906,7 +898,6 @@ err1:
 
 int wlan_logging_sock_deactivate_svc(void)
 {
-	unsigned long irq_flag;
 	int i = 0;
 	if (!gplog_msg)
 		return 0;
@@ -924,13 +915,13 @@ int wlan_logging_sock_deactivate_svc(void)
 	wake_up_interruptible(&gwlan_logging.wait_queue);
 	wait_for_completion(&gwlan_logging.shutdown_comp);
 
-	spin_lock_irqsave(&gwlan_logging.spin_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 	gwlan_logging.pcur_node = NULL;
-	spin_unlock_irqrestore(&gwlan_logging.spin_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 	vfree(gplog_msg);
 	gplog_msg = NULL;
 
-	spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 	gwlan_logging.pkt_stats_pcur_node = NULL;
 	gwlan_logging.pkt_stats_msg_idx = 0;
 	gwlan_logging.pkt_stat_drop_cnt = 0;
@@ -938,7 +929,7 @@ int wlan_logging_sock_deactivate_svc(void)
 		if (gpkt_stats_buffers[i].skb)
 			dev_kfree_skb(gpkt_stats_buffers[i].skb);
 	}
-	spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, irq_flag);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 
 	vfree(gpkt_stats_buffers);
 	gpkt_stats_buffers = NULL;
@@ -948,8 +939,8 @@ int wlan_logging_sock_deactivate_svc(void)
 
 int wlan_logging_sock_init_svc(void)
 {
-	spin_lock_init(&gwlan_logging.spin_lock);
-	spin_lock_init(&gwlan_logging.pkt_stats_lock);
+	adf_os_spinlock_init(&gwlan_logging.spin_lock);
+	adf_os_spinlock_init(&gwlan_logging.pkt_stats_lock);
 	gwlan_logging.pcur_node = NULL;
 	gwlan_logging.pkt_stats_pcur_node = NULL;
 	return 0;
@@ -1074,7 +1065,6 @@ void wlan_pkt_stats_to_logger_thread(void *pl_hdr, void *pkt_dump, void *data)
 	struct packet_dump *pkt_stats_dump;
 	int total_stats_len = 0;
 	bool wake_up_thread = false;
-	unsigned long flags;
 	struct sk_buff *ptr;
 	int hdr_size;
 
@@ -1089,10 +1079,10 @@ void wlan_pkt_stats_to_logger_thread(void *pl_hdr, void *pkt_dump, void *data)
 	total_stats_len = sizeof(struct ath_pktlog_hdr) +
 					pktlog_hdr->size;
 
-	spin_lock_irqsave(&gwlan_logging.pkt_stats_lock, flags);
+	adf_os_spin_lock_irqsave(&gwlan_logging.pkt_stats_lock);
 
 	if (!gwlan_logging.pkt_stats_pcur_node) {
-		spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, flags);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 		return;
 	}
 
@@ -1130,7 +1120,7 @@ void wlan_pkt_stats_to_logger_thread(void *pl_hdr, void *pkt_dump, void *data)
 		wlan_get_pkt_stats_free_node();
 	}
 
-	spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock, flags);
+	adf_os_spin_unlock_irqrestore(&gwlan_logging.pkt_stats_lock);
 
 	/* Wakeup logger thread */
 	if (true == wake_up_thread) {
@@ -1384,14 +1374,12 @@ void wlan_register_txrx_packetdump(void)
  */
 void wlan_flush_host_logs_for_fatal(void)
 {
-	unsigned long flags;
-
 	if (vos_is_log_report_in_progress()) {
 		pr_info("%s:flush all host logs Setting HOST_LOG_POST_MASK\n",
 			 __func__);
-		spin_lock_irqsave(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_lock_irqsave(&gwlan_logging.spin_lock);
 		wlan_queue_logmsg_for_app();
-		spin_unlock_irqrestore(&gwlan_logging.spin_lock, flags);
+		adf_os_spin_unlock_irqrestore(&gwlan_logging.spin_lock);
 		set_bit(HOST_LOG_DRIVER_MSG, &gwlan_logging.eventFlag);
 		wake_up_interruptible(&gwlan_logging.wait_queue);
 	}
diff --git a/CORE/UTILS/FWLOG/dbglog_host.c b/CORE/UTILS/FWLOG/dbglog_host.c
index 289690985276..d94165e3bbd5 100644
--- a/CORE/UTILS/FWLOG/dbglog_host.c
+++ b/CORE/UTILS/FWLOG/dbglog_host.c
@@ -2039,7 +2039,7 @@ dbglog_debugfs_raw_data(wmi_unified_t wmi_handle, const u_int8_t *buf, A_UINT32
     /* Need to pad each record to fixed length ATH6KL_FWLOG_PAYLOAD_SIZE */
     memset(slot->payload + length, 0, ATH6KL_FWLOG_PAYLOAD_SIZE - length);
 
-    spin_lock(&fwlog->fwlog_queue.lock);
+    adf_os_raw_spin_lock(&fwlog->fwlog_queue.lock);
 
     __skb_queue_tail(&fwlog->fwlog_queue, skb);
 
@@ -2052,7 +2052,7 @@ dbglog_debugfs_raw_data(wmi_unified_t wmi_handle, const u_int8_t *buf, A_UINT32
         kfree_skb(skb);
     }
 
-    spin_unlock(&fwlog->fwlog_queue.lock);
+    adf_os_raw_spin_unlock(&fwlog->fwlog_queue.lock);
 
     return TRUE;
 }
@@ -4360,13 +4360,13 @@ static ssize_t dbglog_block_read(struct file *file,
     if (!buf)
        return -ENOMEM;
 
-    spin_lock_bh(&fwlog->fwlog_queue.lock);
+    adf_os_raw_spin_lock_bh(&fwlog->fwlog_queue.lock);
 
     if (skb_queue_len(&fwlog->fwlog_queue) == 0) {
        /* we must init under queue lock */
        init_completion(&fwlog->fwlog_completion);
 
-       spin_unlock_bh(&fwlog->fwlog_queue.lock);
+       adf_os_raw_spin_unlock_bh(&fwlog->fwlog_queue.lock);
 
        ret = wait_for_completion_interruptible(
                     &fwlog->fwlog_completion);
@@ -4375,7 +4375,7 @@ static ssize_t dbglog_block_read(struct file *file,
                return ret;
        }
 
-       spin_lock_bh(&fwlog->fwlog_queue.lock);
+       adf_os_raw_spin_lock_bh(&fwlog->fwlog_queue.lock);
     }
 
     while ((skb = __skb_dequeue(&fwlog->fwlog_queue))) {
@@ -4391,7 +4391,7 @@ static ssize_t dbglog_block_read(struct file *file,
        kfree_skb(skb);
     }
 
-    spin_unlock_bh(&fwlog->fwlog_queue.lock);
+    adf_os_raw_spin_unlock_bh(&fwlog->fwlog_queue.lock);
 
     /* FIXME: what to do if len == 0? */
     not_copied = copy_to_user(user_buf, buf, len);
diff --git a/CORE/UTILS/PKTLOG/include/pktlog_ac.h b/CORE/UTILS/PKTLOG/include/pktlog_ac.h
index 4e3d34a2f19a..a64a56dbb524 100644
--- a/CORE/UTILS/PKTLOG/include/pktlog_ac.h
+++ b/CORE/UTILS/PKTLOG/include/pktlog_ac.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013, 2016 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2013, 2016, 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -40,10 +40,10 @@
 #define NO_REG_FUNCS	4
 
 /* Locking interface for pktlog */
-#define PKTLOG_LOCK_INIT(_pl_info)	spin_lock_init(&(_pl_info)->log_lock)
+#define PKTLOG_LOCK_INIT(_pl_info)	adf_os_spinlock_init(&(_pl_info)->log_lock)
 #define	PKTLOG_LOCK_DESTROY(_pl_info)
-#define PKTLOG_LOCK(_pl_info)		spin_lock(&(_pl_info)->log_lock)
-#define PKTLOG_UNLOCK(_pl_info)		spin_unlock(&(_pl_info)->log_lock)
+#define PKTLOG_LOCK(_pl_info)		adf_os_spin_lock(&(_pl_info)->log_lock)
+#define PKTLOG_UNLOCK(_pl_info)		adf_os_spin_unlock(&(_pl_info)->log_lock)
 
 #define PKTLOG_MODE_SYSTEM	1
 #define PKTLOG_MODE_ADAPTER	2
diff --git a/CORE/UTILS/PKTLOG/include/pktlog_ac_api.h b/CORE/UTILS/PKTLOG/include/pktlog_ac_api.h
index 5fdc83c575b5..55afc1e6037e 100644
--- a/CORE/UTILS/PKTLOG/include/pktlog_ac_api.h
+++ b/CORE/UTILS/PKTLOG/include/pktlog_ac_api.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -71,7 +71,7 @@ struct ath_pktlog_info {
 
 	/* Size of buffer in bytes */
 	int32_t buf_size;
-	spinlock_t log_lock;
+	adf_os_spinlock_t log_lock;
 	struct mutex pktlog_mutex;
 	/* Threshold of TCP SACK packets for triggered stop */
 	int sack_thr;
diff --git a/CORE/UTILS/PKTLOG/linux_ac.c b/CORE/UTILS/PKTLOG/linux_ac.c
index ed6db1766188..0560288ac888 100644
--- a/CORE/UTILS/PKTLOG/linux_ac.c
+++ b/CORE/UTILS/PKTLOG/linux_ac.c
@@ -136,13 +136,13 @@ int pktlog_alloc_buf(struct ol_softc *scn)
 
 	page_cnt = (sizeof(*(pl_info->buf)) + pl_info->buf_size) / PAGE_SIZE;
 
-	spin_lock_bh(&pl_info->log_lock);
+	adf_os_spin_lock_bh(&pl_info->log_lock);
 	if(pl_info->buf != NULL) {
 		printk("Buffer is already in use\n");
-		spin_unlock_bh(&pl_info->log_lock);
+		adf_os_spin_unlock_bh(&pl_info->log_lock);
 		return -EINVAL;
 	}
-	spin_unlock_bh(&pl_info->log_lock);
+	adf_os_spin_unlock_bh(&pl_info->log_lock);
 
 	if ((buffer = vmalloc((page_cnt + 2) * PAGE_SIZE)) == NULL) {
 		printk(PKTLOG_TAG
@@ -167,12 +167,12 @@ int pktlog_alloc_buf(struct ol_softc *scn)
 		SetPageReserved(vpg);
 	}
 
-	spin_lock_bh(&pl_info->log_lock);
+	adf_os_spin_lock_bh(&pl_info->log_lock);
 	if(pl_info->buf != NULL)
 		pktlog_release_buf(scn);
 
 	pl_info->buf =  buffer;
-	spin_unlock_bh(&pl_info->log_lock);
+	adf_os_spin_unlock_bh(&pl_info->log_lock);
 	return 0;
 }
 
@@ -574,10 +574,10 @@ static void pktlog_detach(struct ol_softc *scn)
 	remove_proc_entry(WLANDEV_BASENAME, g_pktlog_pde);
 	pktlog_sysctl_unregister(pl_dev);
 
-	spin_lock_bh(&pl_info->log_lock);
+	adf_os_spin_lock_bh(&pl_info->log_lock);
 	if (pl_info->buf)
 		pktlog_release_buf(scn);
-	spin_unlock_bh(&pl_info->log_lock);
+	adf_os_spin_unlock_bh(&pl_info->log_lock);
 	pktlog_cleanup(pl_info);
 
 	if (pl_dev) {
@@ -630,14 +630,14 @@ pktlog_read_proc_entry(char *buf, size_t nbytes, loff_t *ppos,
 	int fold_offset, ppos_data, cur_rd_offset, cur_wr_offset;
 	struct ath_pktlog_buf *log_buf;
 
-	spin_lock_bh(&pl_info->log_lock);
+	adf_os_spin_lock_bh(&pl_info->log_lock);
 	log_buf = pl_info->buf;
 
 	*read_complete = false;
 
 	if (log_buf == NULL) {
 		*read_complete = true;
-		spin_unlock_bh(&pl_info->log_lock);
+		adf_os_spin_unlock_bh(&pl_info->log_lock);
 		return 0;
 	}
 
@@ -754,7 +754,7 @@ rd_done:
 			*read_complete = true;
 		}
 	}
-	spin_unlock_bh(&pl_info->log_lock);
+	adf_os_spin_unlock_bh(&pl_info->log_lock);
 	return ret_val;
 }
 
@@ -776,11 +776,11 @@ __pktlog_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
 #endif
 	struct ath_pktlog_buf *log_buf;
 
-	spin_lock_bh(&pl_info->log_lock);
+	adf_os_spin_lock_bh(&pl_info->log_lock);
 	log_buf = pl_info->buf;
 
 	if (log_buf == NULL) {
-		spin_unlock_bh(&pl_info->log_lock);
+		adf_os_spin_unlock_bh(&pl_info->log_lock);
 		return 0;
 	}
 
@@ -797,13 +797,13 @@ __pktlog_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
 
 	if (*ppos < bufhdr_size) {
 		count = MIN((bufhdr_size - *ppos), rem_len);
-		spin_unlock_bh(&pl_info->log_lock);
+		adf_os_spin_unlock_bh(&pl_info->log_lock);
 		if (copy_to_user(buf, ((char *)&log_buf->bufhdr) + *ppos,
 				 count))
 			return -EFAULT;
 		rem_len -= count;
 		ret_val += count;
-		spin_lock_bh(&pl_info->log_lock);
+		adf_os_spin_lock_bh(&pl_info->log_lock);
 	}
 
 	start_offset = log_buf->rd_offset;
@@ -845,25 +845,25 @@ __pktlog_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
 			goto rd_done;
 
 		count = MIN(rem_len, (end_offset - ppos_data + 1));
-		spin_unlock_bh(&pl_info->log_lock);
+		adf_os_spin_unlock_bh(&pl_info->log_lock);
 		if (copy_to_user(buf + ret_val,
 				 log_buf->log_data + ppos_data,
 				 count))
 			return -EFAULT;
 		ret_val += count;
 		rem_len -= count;
-		spin_lock_bh(&pl_info->log_lock);
+		adf_os_spin_lock_bh(&pl_info->log_lock);
 	} else {
 		if (ppos_data <= fold_offset) {
 			count = MIN(rem_len, (fold_offset - ppos_data + 1));
-			spin_unlock_bh(&pl_info->log_lock);
+			adf_os_spin_unlock_bh(&pl_info->log_lock);
 			if (copy_to_user(buf + ret_val,
 					 log_buf->log_data + ppos_data,
 					 count))
 				return -EFAULT;
 			ret_val += count;
 			rem_len -= count;
-			spin_lock_bh(&pl_info->log_lock);
+			adf_os_spin_lock_bh(&pl_info->log_lock);
 		}
 
 		if (rem_len == 0)
@@ -875,14 +875,14 @@ __pktlog_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
 
 		if (ppos_data <= end_offset) {
 			count = MIN(rem_len, (end_offset - ppos_data + 1));
-			spin_unlock_bh(&pl_info->log_lock);
+			adf_os_spin_unlock_bh(&pl_info->log_lock);
 			if (copy_to_user(buf + ret_val,
 					 log_buf->log_data + ppos_data,
 					 count))
 				return -EFAULT;
 			ret_val += count;
 			rem_len -= count;
-			spin_lock_bh(&pl_info->log_lock);
+			adf_os_spin_lock_bh(&pl_info->log_lock);
 		}
 	}
 
@@ -893,7 +893,7 @@ rd_done:
 	}
 	*ppos += ret_val;
 
-	spin_unlock_bh(&pl_info->log_lock);
+	adf_os_spin_unlock_bh(&pl_info->log_lock);
 	return ret_val;
 }
 
diff --git a/CORE/UTILS/PKTLOG/pktlog_ac.c b/CORE/UTILS/PKTLOG/pktlog_ac.c
index 9141a2ba85ae..2f2ba4e1b4eb 100644
--- a/CORE/UTILS/PKTLOG/pktlog_ac.c
+++ b/CORE/UTILS/PKTLOG/pktlog_ac.c
@@ -351,7 +351,7 @@ __pktlog_enable(struct ol_softc *scn, int32_t log_state)
 			}
 		}
 
-		spin_lock_bh(&pl_info->log_lock);
+		adf_os_spin_lock_bh(&pl_info->log_lock);
 		pl_info->buf->bufhdr.version = CUR_PKTLOG_VER;
 		pl_info->buf->bufhdr.magic_num = PKTLOG_MAGIC_NUM;
 		pl_info->buf->wr_offset = 0;
@@ -360,7 +360,7 @@ __pktlog_enable(struct ol_softc *scn, int32_t log_state)
 		pl_info->buf->bytes_written = 0;
 		pl_info->buf->msg_index = 1;
 		pl_info->buf->offset = PKTLOG_READ_OFFSET;
-		spin_unlock_bh(&pl_info->log_lock);
+		adf_os_spin_unlock_bh(&pl_info->log_lock);
 
 		pl_info->start_time_thruput = OS_GET_TIMESTAMP();
 		pl_info->start_time_per = pl_info->start_time_thruput;
@@ -450,13 +450,13 @@ __pktlog_setsize(struct ol_softc *scn, int32_t size)
 		return -EINVAL;
 	}
 
-	spin_lock_bh(&pl_info->log_lock);
+	adf_os_spin_lock_bh(&pl_info->log_lock);
 	if (pl_info->buf != NULL)
 		pktlog_release_buf(scn);
 
 	if (size != 0)
 		pl_info->buf_size = size;
-	spin_unlock_bh(&pl_info->log_lock);
+	adf_os_spin_unlock_bh(&pl_info->log_lock);
 
 	return 0;
 }
diff --git a/CORE/VOSS/inc/i_vos_timer.h b/CORE/VOSS/inc/i_vos_timer.h
index f96efc2d2672..af63928deaa5 100644
--- a/CORE/VOSS/inc/i_vos_timer.h
+++ b/CORE/VOSS/inc/i_vos_timer.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -46,6 +46,7 @@
 #include <linux/timer.h>
 #include <linux/time.h>
 #include <linux/jiffies.h>
+#include <adf_os_lock.h>
 
 /*--------------------------------------------------------------------------
   Preprocessor definitions and constants
@@ -63,7 +64,7 @@ typedef struct vos_timer_platform_s
    struct timer_list Timer;
    int threadID;
    v_U32_t cookie;
-   spinlock_t  spinlock;
+   adf_os_spinlock_t  spinlock;
 
 } vos_timer_platform_t;
 
diff --git a/CORE/VOSS/src/vos_api.c b/CORE/VOSS/src/vos_api.c
index 393b7699b887..825cfd88d815 100644
--- a/CORE/VOSS/src/vos_api.c
+++ b/CORE/VOSS/src/vos_api.c
@@ -3515,18 +3515,18 @@ bool vos_is_chan_ok_for_dnbs(uint8_t channel)
 	  return false;
 	}
 
-	spin_lock_bh(&pHddCtx->restrict_offchan_lock);
+	adf_os_spin_lock_bh(&pHddCtx->restrict_offchan_lock);
 	if (pHddCtx->restrict_offchan_flag) {
 		VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
 				"%s: flag is set", __func__);
 		wlansap_channel_compare(gpVosContext->pMACContext, channel, &equal);
-		spin_unlock_bh(&pHddCtx->restrict_offchan_lock);
+		adf_os_spin_unlock_bh(&pHddCtx->restrict_offchan_lock);
 		return equal;
 	}
 	else
 		VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
 				"%s: flag is not set", __func__);
-	spin_unlock_bh(&pHddCtx->restrict_offchan_lock);
+	adf_os_spin_unlock_bh(&pHddCtx->restrict_offchan_lock);
 	return true;
 }
 #endif
diff --git a/CORE/VOSS/src/vos_memory.c b/CORE/VOSS/src/vos_memory.c
index 4a3ce77cf510..e58ef1ef2c84 100644
--- a/CORE/VOSS/src/vos_memory.c
+++ b/CORE/VOSS/src/vos_memory.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -233,7 +233,7 @@ void vos_mem_trace_dump(int level)
 	VOS_STATUS vosStatus;
 	struct s_vos_mem_struct *memStruct;
 
-	spin_lock(&vosMemList.lock);
+	adf_os_spin_lock(&vosMemList.lock);
 	hdd_list_peek_front(&vosMemList, &pNodeNext);
 	do {
 		if (pNodeNext == NULL)
@@ -251,7 +251,7 @@ void vos_mem_trace_dump(int level)
 		pNodeNext = NULL;
 	} while ((vosStatus = hdd_list_peek_next(&vosMemList,
 		pNode, &pNodeNext)) == VOS_STATUS_SUCCESS);
-	spin_unlock(&vosMemList.lock);
+	adf_os_spin_unlock(&vosMemList.lock);
 	VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
 		"vos_mem [total active] count %d size %d", i, totalUsed);
 
@@ -332,9 +332,9 @@ void vos_mem_clean()
 
        do
        {
-          spin_lock(&vosMemList.lock);
+          adf_os_spin_lock(&vosMemList.lock);
           vosStatus = hdd_list_remove_front(&vosMemList, &pNode);
-          spin_unlock(&vosMemList.lock);
+          adf_os_spin_unlock(&vosMemList.lock);
           if(VOS_STATUS_SUCCESS == vosStatus)
           {
              memStruct = (struct s_vos_mem_struct*)pNode;
@@ -396,7 +396,6 @@ v_VOID_t *vos_mem_malloc_debug(v_SIZE_t size, const char *fileName,
    v_VOID_t* memPtr = NULL;
    v_SIZE_t new_size;
    int flags = GFP_KERNEL;
-   unsigned long IrqFlags;
    unsigned long  time_before_kmalloc;
 
 
@@ -452,10 +451,10 @@ v_VOID_t *vos_mem_malloc_debug(v_SIZE_t size, const char *fileName,
       vos_mem_copy(&memStruct->header[0], &WLAN_MEM_HEADER[0], sizeof(WLAN_MEM_HEADER));
       vos_mem_copy( (v_U8_t*)(memStruct + 1) + size, &WLAN_MEM_TAIL[0], sizeof(WLAN_MEM_TAIL));
 
-      spin_lock_irqsave(&vosMemList.lock, IrqFlags);
+      adf_os_spin_lock_irqsave(&vosMemList.lock);
       vosStatus = hdd_list_insert_front(&vosMemList, &memStruct->pNode);
       alloc_trace_usage(fileName, lineNum, size);
-      spin_unlock_irqrestore(&vosMemList.lock, IrqFlags);
+      adf_os_spin_unlock_irqrestore(&vosMemList.lock);
       if(VOS_STATUS_SUCCESS != vosStatus)
       {
          VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
@@ -470,8 +469,6 @@ v_VOID_t *vos_mem_malloc_debug(v_SIZE_t size, const char *fileName,
 
 v_VOID_t vos_mem_free( v_VOID_t *ptr )
 {
-    unsigned long IrqFlags;
-
     if (ptr != NULL)
     {
         VOS_STATUS vosStatus;
@@ -482,11 +479,11 @@ v_VOID_t vos_mem_free( v_VOID_t *ptr )
             return;
 #endif
 
-        spin_lock_irqsave(&vosMemList.lock, IrqFlags);
+        adf_os_spin_lock_irqsave(&vosMemList.lock);
         vosStatus = hdd_list_remove_node(&vosMemList, &memStruct->pNode);
         free_trace_usage(memStruct->fileName, memStruct->lineNum,
                          memStruct->size);
-        spin_unlock_irqrestore(&vosMemList.lock, IrqFlags);
+        adf_os_spin_unlock_irqrestore(&vosMemList.lock);
 
         if(VOS_STATUS_SUCCESS == vosStatus)
         {
@@ -726,10 +723,10 @@ v_VOID_t * vos_mem_dma_malloc_debug( v_SIZE_t size, char* fileName, v_U32_t line
       vos_mem_copy(&memStruct->header[0], &WLAN_MEM_HEADER[0], sizeof(WLAN_MEM_HEADER));
       vos_mem_copy( (v_U8_t*)(memStruct + 1) + size, &WLAN_MEM_TAIL[0], sizeof(WLAN_MEM_TAIL));
 
-      spin_lock(&vosMemList.lock);
+      adf_os_spin_lock(&vosMemList.lock);
       vosStatus = hdd_list_insert_front(&vosMemList, &memStruct->pNode);
       alloc_trace_usage(fileName, lineNum, size);
-      spin_unlock(&vosMemList.lock);
+      adf_os_spin_unlock(&vosMemList.lock);
       if(VOS_STATUS_SUCCESS != vosStatus)
       {
          VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
@@ -749,11 +746,11 @@ v_VOID_t vos_mem_dma_free( v_VOID_t *ptr )
         VOS_STATUS vosStatus;
         struct s_vos_mem_struct* memStruct = ((struct s_vos_mem_struct*)ptr) - 1;
 
-        spin_lock(&vosMemList.lock);
+        adf_os_spin_lock(&vosMemList.lock);
         vosStatus = hdd_list_remove_node(&vosMemList, &memStruct->pNode);
         free_trace_usage(memStruct->fileName, memStruct->lineNum,
                              memStruct->size);
-        spin_unlock(&vosMemList.lock);
+        adf_os_spin_unlock(&vosMemList.lock);
 
         if(VOS_STATUS_SUCCESS == vosStatus)
         {
diff --git a/CORE/VOSS/src/vos_mq.c b/CORE/VOSS/src/vos_mq.c
index 81c43598594e..78358597aa5f 100644
--- a/CORE/VOSS/src/vos_mq.c
+++ b/CORE/VOSS/src/vos_mq.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2016 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014, 2016, 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -86,7 +86,7 @@ __inline VOS_STATUS vos_mq_init(pVosMqType pMq)
   /*
   ** Now initialize the lock
   */
-  spin_lock_init(&pMq->mqLock);
+  adf_os_spinlock_init(&pMq->mqLock);
 
   /*
   ** Now initialize the List data structure
@@ -143,8 +143,6 @@ __inline void vos_mq_deinit(pVosMqType pMq)
 ---------------------------------------------------------------------------*/
 __inline void vos_mq_put(pVosMqType pMq, pVosMsgWrapper pMsgWrapper)
 {
-  unsigned long flags;
-
   /*
   ** Some quick sanity check
   */
@@ -154,11 +152,11 @@ __inline void vos_mq_put(pVosMqType pMq, pVosMsgWrapper pMsgWrapper)
      return ;
   }
 
-  spin_lock_irqsave(&pMq->mqLock, flags);
+  adf_os_spin_lock_irqsave(&pMq->mqLock);
 
   list_add_tail(&pMsgWrapper->msgNode, &pMq->mqList);
 
-  spin_unlock_irqrestore(&pMq->mqLock, flags);
+  adf_os_spin_unlock_irqrestore(&pMq->mqLock);
 
 } /* vos_mq_put() */
 
@@ -173,17 +171,15 @@ __inline void vos_mq_put(pVosMqType pMq, pVosMsgWrapper pMsgWrapper)
  */
 void vos_mq_put_front(pVosMqType mq, pVosMsgWrapper msg_wrapper)
 {
-	unsigned long flags;
-
 	if ((mq == NULL) || (msg_wrapper == NULL)) {
 		VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
 			"%s: NULL pointer passed", __func__);
 		return;
 	}
 
-	spin_lock_irqsave(&mq->mqLock, flags);
+	adf_os_spin_lock_irqsave(&mq->mqLock);
 	list_add(&msg_wrapper->msgNode, &mq->mqList);
-	spin_unlock_irqrestore(&mq->mqLock, flags);
+	adf_os_spin_unlock_irqrestore(&mq->mqLock);
 }
 
 /*---------------------------------------------------------------------------
@@ -208,7 +204,6 @@ __inline pVosMsgWrapper vos_mq_get(pVosMqType pMq)
   ** Some quick sanity check
   */
   struct list_head * listptr;
-  unsigned long flags;
 
   if (pMq == NULL) {
      VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
@@ -216,7 +211,7 @@ __inline pVosMsgWrapper vos_mq_get(pVosMqType pMq)
      return NULL;
   }
 
-  spin_lock_irqsave(&pMq->mqLock, flags);
+  adf_os_spin_lock_irqsave(&pMq->mqLock);
 
   if( list_empty(&pMq->mqList) )
   {
@@ -230,7 +225,7 @@ __inline pVosMsgWrapper vos_mq_get(pVosMqType pMq)
     list_del(pMq->mqList.next);
   }
 
-  spin_unlock_irqrestore(&pMq->mqLock, flags);
+  adf_os_spin_unlock_irqrestore(&pMq->mqLock);
 
   return pMsgWrapper;
 
@@ -253,7 +248,6 @@ __inline pVosMsgWrapper vos_mq_get(pVosMqType pMq)
 __inline v_BOOL_t vos_is_mq_empty(pVosMqType pMq)
 {
   v_BOOL_t  state = VOS_FALSE;
-  unsigned long flags;
 
   /*
   ** Some quick sanity check
@@ -265,9 +259,9 @@ __inline v_BOOL_t vos_is_mq_empty(pVosMqType pMq)
      return VOS_STATUS_E_FAILURE;
   }
 
-  spin_lock_irqsave(&pMq->mqLock, flags);
+  adf_os_spin_lock_irqsave(&pMq->mqLock);
   state = list_empty(&pMq->mqList)?VOS_TRUE:VOS_FALSE;
-  spin_unlock_irqrestore(&pMq->mqLock, flags);
+  adf_os_spin_unlock_irqrestore(&pMq->mqLock);
 
   return state;
 
diff --git a/CORE/VOSS/src/vos_packet.c b/CORE/VOSS/src/vos_packet.c
index db8e10dc3977..f2fed19b59f6 100644
--- a/CORE/VOSS/src/vos_packet.c
+++ b/CORE/VOSS/src/vos_packet.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2014, 2016 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2014, 2016, 2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -75,7 +75,7 @@ typedef struct
 vos_pkt_proto_trace_t   *trace_buffer = NULL;
 unsigned int            trace_buffer_order = 0;
 unsigned int trace_dump_order = 0;
-spinlock_t              trace_buffer_lock;
+adf_os_spinlock_t              trace_buffer_lock;
 #endif /* QCA_PKT_PROTO_TRACE */
 
 /**
@@ -342,11 +342,11 @@ void vos_pkt_trace_buf_update
       return;
    }
 
-   spin_lock_bh(&trace_buffer_lock);
+   adf_os_spin_lock_bh(&trace_buffer_lock);
    slot = trace_buffer_order % VOS_PKT_TRAC_MAX_TRACE_BUF;
    trace_buffer[slot].order = trace_buffer_order;
    trace_buffer_order++;
-   spin_unlock_bh(&trace_buffer_lock);
+   adf_os_spin_unlock_bh(&trace_buffer_lock);
    do_gettimeofday(&tv);
    trace_buffer[slot].event_sec_time = tv.tv_sec;
    trace_buffer[slot].event_msec_time = tv.tv_usec;
@@ -436,7 +436,7 @@ void vos_pkt_proto_trace_init
 )
 {
    /* Init spin lock to protect global memory */
-   spin_lock_init(&trace_buffer_lock);
+   adf_os_spinlock_init(&trace_buffer_lock);
    trace_buffer_order = 0;
    trace_buffer = vos_mem_malloc(
        VOS_PKT_TRAC_MAX_TRACE_BUF * sizeof(vos_pkt_proto_trace_t));
@@ -462,10 +462,10 @@ void vos_pkt_proto_trace_close
 {
    VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
              "%s %d", __func__, __LINE__);
-   spin_lock_bh(&trace_buffer_lock);
+   adf_os_spin_lock_bh(&trace_buffer_lock);
    vos_mem_free(trace_buffer);
    trace_buffer = NULL;
-   spin_unlock_bh(&trace_buffer_lock);
+   adf_os_spin_unlock_bh(&trace_buffer_lock);
 
    return;
 }
diff --git a/CORE/VOSS/src/vos_sched.c b/CORE/VOSS/src/vos_sched.c
index a190ed3f3833..dc89f52626b4 100644
--- a/CORE/VOSS/src/vos_sched.c
+++ b/CORE/VOSS/src/vos_sched.c
@@ -88,7 +88,7 @@ struct ssr_protect {
    uint32_t pid;
 };
 
-static spinlock_t ssr_protect_lock;
+static adf_os_spinlock_t ssr_protect_lock;
 static struct ssr_protect ssr_protect_log[MAX_SSR_PROTECT_LOG];
 
 /*---------------------------------------------------------------------------
@@ -535,9 +535,9 @@ vos_sched_open
   init_completion(&pSchedContext->McShutdown);
   init_completion(&pSchedContext->ResumeMcEvent);
 
-  spin_lock_init(&pSchedContext->McThreadLock);
+  adf_os_spinlock_init(&pSchedContext->McThreadLock);
 #ifdef QCA_CONFIG_SMP
-  spin_lock_init(&pSchedContext->TlshimRxThreadLock);
+  adf_os_spinlock_init(&pSchedContext->TlshimRxThreadLock);
 #endif
 
   init_waitqueue_head(&pSchedContext->mcWaitQueue);
@@ -550,17 +550,17 @@ vos_sched_open
   init_completion(&pSchedContext->ResumeTlshimRxEvent);
   init_completion(&pSchedContext->TlshimRxShutdown);
   pSchedContext->tlshimRxEvtFlg = 0;
-  spin_lock_init(&pSchedContext->TlshimRxQLock);
-  spin_lock_init(&pSchedContext->VosTlshimPktFreeQLock);
+  adf_os_spinlock_init(&pSchedContext->TlshimRxQLock);
+  adf_os_spinlock_init(&pSchedContext->VosTlshimPktFreeQLock);
   INIT_LIST_HEAD(&pSchedContext->tlshimRxQueue);
-  spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+  adf_os_spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
   INIT_LIST_HEAD(&pSchedContext->VosTlshimPktFreeQ);
   if (vos_alloc_tlshim_pkt_freeq(pSchedContext) !=  VOS_STATUS_SUCCESS)
   {
-       spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+       adf_os_spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
        return VOS_STATUS_E_FAILURE;
   }
-  spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+  adf_os_spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4,10,0))
   register_hotcpu_notifier(&vos_cpu_hotplug_notifier);
   pSchedContext->cpuHotPlugNotifier = &vos_cpu_hotplug_notifier;
@@ -691,8 +691,8 @@ VOS_STATUS vos_watchdog_open
   pWdContext->wdEventFlag = 0;
 
   // Initialize the lock
-  spin_lock_init(&pWdContext->wdLock);
-  spin_lock_init(&pWdContext->thread_stuck_lock);
+  adf_os_spinlock_init(&pWdContext->wdLock);
+  adf_os_spinlock_init(&pWdContext->thread_stuck_lock);
 
   //Create the Watchdog thread
   pWdContext->WdThread = kthread_create(VosWDThread, pWdContext,"VosWDThread");
@@ -955,13 +955,13 @@ VosMCThread
       if(test_bit(MC_SUSPEND_EVENT, &pSchedContext->mcEventFlag))
       {
         clear_bit(MC_SUSPEND_EVENT, &pSchedContext->mcEventFlag);
-        spin_lock(&pSchedContext->McThreadLock);
+        adf_os_spin_lock(&pSchedContext->McThreadLock);
 
         INIT_COMPLETION(pSchedContext->ResumeMcEvent);
         /* Mc Thread Suspended */
         complete(&pHddCtx->mc_sus_event_var);
 
-        spin_unlock(&pSchedContext->McThreadLock);
+        adf_os_spin_unlock(&pSchedContext->McThreadLock);
 
         /* Wait foe Resume Indication */
         wait_for_completion_interruptible(&pSchedContext->ResumeMcEvent);
@@ -998,14 +998,11 @@ v_BOOL_t isWDresetInProgress(void)
  */
 static void vos_wd_detect_thread_stuck(void)
 {
-	unsigned long flags;
-
-	spin_lock_irqsave(&gpVosWatchdogContext->thread_stuck_lock, flags);
+	adf_os_spin_lock_irqsave(&gpVosWatchdogContext->thread_stuck_lock);
 
 	if (gpVosWatchdogContext->mc_thread_stuck_count ==
 				THREAD_STUCK_THRESHOLD) {
-		spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock,
-				flags);
+		adf_os_spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock);
 		hddLog(LOGE, FL("MC Thread Stuck!!!"));
 
 		vos_dump_stack(gpVosSchedContext->McThread);
@@ -1013,8 +1010,7 @@ static void vos_wd_detect_thread_stuck(void)
 			       WLAN_LOG_INDICATOR_HOST_ONLY,
 			       WLAN_LOG_REASON_THREAD_STUCK,
 			       DUMP_VOS_TRACE);
-		spin_lock_irqsave(&gpVosWatchdogContext->thread_stuck_lock,
-			flags);
+		adf_os_spin_lock_irqsave(&gpVosWatchdogContext->thread_stuck_lock);
 	}
 
 	/* Increment the thread stuck count for all threads */
@@ -1022,12 +1018,10 @@ static void vos_wd_detect_thread_stuck(void)
 
 	if (gpVosWatchdogContext->mc_thread_stuck_count <=
 				THREAD_STUCK_THRESHOLD) {
-		spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock,
-				flags);
+		adf_os_spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock);
 		vos_probe_threads();
 	} else
-		spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock,
-				flags);
+		adf_os_spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock);
 
 	/* Restart the timer */
 	if (VOS_STATUS_SUCCESS !=
@@ -1094,13 +1088,11 @@ void vos_thread_stuck_timer_init(pVosWatchdogContext wd_ctx)
  */
 void vos_wd_reset_thread_stuck_count(int thread_id)
 {
-	unsigned long flags;
-
-	spin_lock_irqsave(&gpVosWatchdogContext->thread_stuck_lock, flags);
+	adf_os_spin_lock_irqsave(&gpVosWatchdogContext->thread_stuck_lock);
 	if (vos_sched_is_mc_thread(thread_id))
 		gpVosWatchdogContext->mc_thread_stuck_count = 0;
 
-	spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock, flags);
+	adf_os_spin_unlock_irqrestore(&gpVosWatchdogContext->thread_stuck_lock);
 }
 
 /*---------------------------------------------------------------------------
@@ -1296,16 +1288,16 @@ void vos_free_tlshim_pkt_freeq(pVosSchedContext pSchedContext)
 {
    struct VosTlshimPkt *pkt;
 
-   spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+   adf_os_spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
    while (!list_empty(&pSchedContext->VosTlshimPktFreeQ)) {
        pkt = list_entry((&pSchedContext->VosTlshimPktFreeQ)->next,
                      typeof(*pkt), list);
        list_del(&pkt->list);
-       spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+       adf_os_spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
        vos_mem_free(pkt);
-       spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+       adf_os_spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
    }
-   spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+   adf_os_spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
 
 }
 
@@ -1360,9 +1352,9 @@ void vos_free_tlshim_pkt(pVosSchedContext pSchedContext,
                          struct VosTlshimPkt *pkt)
 {
    memset(pkt, 0, sizeof(*pkt));
-   spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+   adf_os_spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
    list_add_tail(&pkt->list, &pSchedContext->VosTlshimPktFreeQ);
-   spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+   adf_os_spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
 }
 
 /*---------------------------------------------------------------------------
@@ -1378,15 +1370,15 @@ struct VosTlshimPkt *vos_alloc_tlshim_pkt(pVosSchedContext pSchedContext)
 {
    struct VosTlshimPkt *pkt;
 
-   spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+   adf_os_spin_lock_bh(&pSchedContext->VosTlshimPktFreeQLock);
    if (list_empty(&pSchedContext->VosTlshimPktFreeQ)) {
-       spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+       adf_os_spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
        return NULL;
    }
    pkt = list_first_entry(&pSchedContext->VosTlshimPktFreeQ,
                           struct VosTlshimPkt, list);
    list_del(&pkt->list);
-   spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
+   adf_os_spin_unlock_bh(&pSchedContext->VosTlshimPktFreeQLock);
    return pkt;
 }
 
@@ -1403,9 +1395,9 @@ struct VosTlshimPkt *vos_alloc_tlshim_pkt(pVosSchedContext pSchedContext)
 void vos_indicate_rxpkt(pVosSchedContext pSchedContext,
                         struct VosTlshimPkt *pkt)
 {
-   spin_lock_bh(&pSchedContext->TlshimRxQLock);
+   adf_os_spin_lock_bh(&pSchedContext->TlshimRxQLock);
    list_add_tail(&pkt->list, &pSchedContext->tlshimRxQueue);
-   spin_unlock_bh(&pSchedContext->TlshimRxQLock);
+   adf_os_spin_unlock_bh(&pSchedContext->TlshimRxQLock);
    set_bit(RX_POST_EVENT, &pSchedContext->tlshimRxEvtFlg);
    wake_up_interruptible(&pSchedContext->tlshimRxWaitQueue);
 }
@@ -1427,16 +1419,16 @@ void vos_drop_rxpkt_by_staid(pVosSchedContext pSchedContext, u_int16_t staId)
    adf_nbuf_t buf, next_buf;
 
    INIT_LIST_HEAD(&local_list);
-   spin_lock_bh(&pSchedContext->TlshimRxQLock);
+   adf_os_spin_lock_bh(&pSchedContext->TlshimRxQLock);
    if (list_empty(&pSchedContext->tlshimRxQueue)) {
-       spin_unlock_bh(&pSchedContext->TlshimRxQLock);
+       adf_os_spin_unlock_bh(&pSchedContext->TlshimRxQLock);
        return;
    }
    list_for_each_entry_safe(pkt, tmp, &pSchedContext->tlshimRxQueue, list) {
        if (pkt->staId == staId || staId == WLAN_MAX_STA_COUNT)
            list_move_tail(&pkt->list, &local_list);
    }
-   spin_unlock_bh(&pSchedContext->TlshimRxQLock);
+   adf_os_spin_unlock_bh(&pSchedContext->TlshimRxQLock);
 
    list_for_each_entry_safe(pkt, tmp, &local_list, list) {
        list_del(&pkt->list);
@@ -1464,18 +1456,18 @@ static void vos_rx_from_queue(pVosSchedContext pSchedContext)
    struct VosTlshimPkt *pkt;
    u_int16_t sta_id;
 
-   spin_lock_bh(&pSchedContext->TlshimRxQLock);
+   adf_os_spin_lock_bh(&pSchedContext->TlshimRxQLock);
    while (!list_empty(&pSchedContext->tlshimRxQueue)) {
            pkt = list_first_entry(&pSchedContext->tlshimRxQueue,
                                   struct VosTlshimPkt, list);
            list_del(&pkt->list);
-           spin_unlock_bh(&pSchedContext->TlshimRxQLock);
+           adf_os_spin_unlock_bh(&pSchedContext->TlshimRxQLock);
            sta_id = pkt->staId;
            pkt->callback(pkt->context, pkt->Rxpkt, sta_id);
            vos_free_tlshim_pkt(pSchedContext, pkt);
-           spin_lock_bh(&pSchedContext->TlshimRxQLock);
+           adf_os_spin_lock_bh(&pSchedContext->TlshimRxQLock);
    }
-   spin_unlock_bh(&pSchedContext->TlshimRxQLock);
+   adf_os_spin_unlock_bh(&pSchedContext->TlshimRxQLock);
 }
 
 /*---------------------------------------------------------------------------
@@ -1549,10 +1541,10 @@ static int VosTlshimRxThread(void *arg)
                         &pSchedContext->tlshimRxEvtFlg)) {
                clear_bit(RX_SUSPEND_EVENT,
                          &pSchedContext->tlshimRxEvtFlg);
-               spin_lock(&pSchedContext->TlshimRxThreadLock);
+               adf_os_spin_lock(&pSchedContext->TlshimRxThreadLock);
                INIT_COMPLETION(pSchedContext->ResumeTlshimRxEvent);
                complete(&pSchedContext->SuspndTlshimRxEvent);
-               spin_unlock(&pSchedContext->TlshimRxThreadLock);
+               adf_os_spin_unlock(&pSchedContext->TlshimRxThreadLock);
                wait_for_completion_interruptible(
                               &pSchedContext->ResumeTlshimRxEvent);
            }
@@ -1930,7 +1922,7 @@ VOS_STATUS vos_watchdog_wlan_shutdown(void)
     }
 
     /* Take the lock here */
-    spin_lock(&gpVosWatchdogContext->wdLock);
+    adf_os_spin_lock(&gpVosWatchdogContext->wdLock);
 
     /* reuse the existing 'reset in progress' */
     if (gpVosWatchdogContext->resetInProgress)
@@ -1939,7 +1931,7 @@ VOS_STATUS vos_watchdog_wlan_shutdown(void)
             "%s: Shutdown already in Progress. Ignoring signaling Watchdog",
                                                            __func__);
         /* Release the lock here */
-        spin_unlock(&gpVosWatchdogContext->wdLock);
+        adf_os_spin_unlock(&gpVosWatchdogContext->wdLock);
         return VOS_STATUS_E_FAILURE;
     }
     /* reuse the existing 'logp in progress', eventhough it is not
@@ -1950,7 +1942,7 @@ VOS_STATUS vos_watchdog_wlan_shutdown(void)
             "%s: shutdown/re-init already in Progress. Ignoring signaling Watchdog",
                                                            __func__);
         /* Release the lock here */
-        spin_unlock(&gpVosWatchdogContext->wdLock);
+        adf_os_spin_unlock(&gpVosWatchdogContext->wdLock);
         return VOS_STATUS_E_FAILURE;
     }
 
@@ -1960,7 +1952,7 @@ VOS_STATUS vos_watchdog_wlan_shutdown(void)
     pHddCtx->isLogpInProgress = TRUE;
 
     /* Release the lock here */
-    spin_unlock(&gpVosWatchdogContext->wdLock);
+    adf_os_spin_unlock(&gpVosWatchdogContext->wdLock);
 
     if ((pHddCtx->isLoadInProgress) ||
         (pHddCtx->isUnloadInProgress))
@@ -2028,7 +2020,7 @@ void vos_ssr_protect_init(void)
 {
     int i = 0;
 
-    spin_lock_init(&ssr_protect_lock);
+    adf_os_spinlock_init(&ssr_protect_lock);
 
     while (i < MAX_SSR_PROTECT_LOG) {
        ssr_protect_log[i].func = NULL;
@@ -2048,9 +2040,8 @@ void vos_ssr_protect_init(void)
 static void vos_print_external_threads(void)
 {
     int i = 0;
-    unsigned long irq_flags;
 
-    spin_lock_irqsave(&ssr_protect_lock, irq_flags);
+    adf_os_spin_lock_irqsave(&ssr_protect_lock);
 
     while (i < MAX_SSR_PROTECT_LOG) {
         if (!ssr_protect_log[i].free) {
@@ -2061,7 +2052,7 @@ static void vos_print_external_threads(void)
         i++;
     }
 
-    spin_unlock_irqrestore(&ssr_protect_lock, irq_flags);
+    adf_os_spin_unlock_irqrestore(&ssr_protect_lock);
 }
 
 
@@ -2146,11 +2137,10 @@ void vos_ssr_protect(const char *caller_func)
      int count;
      int i = 0;
      bool status = false;
-     unsigned long irq_flags;
 
      count = atomic_inc_return(&ssr_protect_entry_count);
 
-     spin_lock_irqsave(&ssr_protect_lock, irq_flags);
+     adf_os_spin_lock_irqsave(&ssr_protect_lock);
 
      while (i < MAX_SSR_PROTECT_LOG) {
          if (ssr_protect_log[i].free) {
@@ -2163,7 +2153,7 @@ void vos_ssr_protect(const char *caller_func)
          i++;
      }
 
-     spin_unlock_irqrestore(&ssr_protect_lock, irq_flags);
+     adf_os_spin_unlock_irqrestore(&ssr_protect_lock);
 
      if (!status)
          VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
@@ -2185,11 +2175,10 @@ void vos_ssr_unprotect(const char *caller_func)
    int count;
    int i = 0;
    bool status = false;
-   unsigned long irq_flags;
 
    count = atomic_dec_return(&ssr_protect_entry_count);
 
-   spin_lock_irqsave(&ssr_protect_lock, irq_flags);
+   adf_os_spin_lock_irqsave(&ssr_protect_lock);
 
    while (i < MAX_SSR_PROTECT_LOG) {
       if (!ssr_protect_log[i].free) {
@@ -2205,7 +2194,7 @@ void vos_ssr_unprotect(const char *caller_func)
       i++;
    }
 
-   spin_unlock_irqrestore(&ssr_protect_lock, irq_flags);
+   adf_os_spin_unlock_irqrestore(&ssr_protect_lock);
 
    if (!status)
        VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
diff --git a/CORE/VOSS/src/vos_sched.h b/CORE/VOSS/src/vos_sched.h
index 474bf24b2595..c1139eb9eb94 100644
--- a/CORE/VOSS/src/vos_sched.h
+++ b/CORE/VOSS/src/vos_sched.h
@@ -72,6 +72,7 @@
 #include <adf_os_types.h>
 #include <vos_lock.h>
 #include <vos_timer.h>
+#include <adf_os_lock.h>
 
 #define TX_POST_EVENT               0x000
 #define TX_SUSPEND_EVENT            0x001
@@ -119,7 +120,7 @@ typedef void (*vos_tlshim_cb) (void *context, void *rxpkt, u_int16_t staid);
 typedef struct _VosMqType
 {
   /* Lock use to synchronize access to this message queue */
-  spinlock_t       mqLock;
+  adf_os_spinlock_t       mqLock;
 
   /* List of vOS Messages waiting on this queue */
   struct list_head  mqList;
@@ -196,9 +197,9 @@ typedef struct _VosSchedContext
    struct completion ResumeMcEvent;
 
    /* lock to make sure that McThread and TxThread Suspend/resume mechanism is in sync*/
-   spinlock_t McThreadLock;
+   adf_os_spinlock_t McThreadLock;
 #ifdef QCA_CONFIG_SMP
-   spinlock_t TlshimRxThreadLock;
+   adf_os_spinlock_t TlshimRxThreadLock;
 
    /* Tlshim Rx thread handle */
    struct task_struct *TlshimRxThread;
@@ -224,13 +225,13 @@ typedef struct _VosSchedContext
    struct list_head tlshimRxQueue;
 
    /* Spinlock to synchronize between tasklet and thread */
-   spinlock_t TlshimRxQLock;
+   adf_os_spinlock_t TlshimRxQLock;
 
    /* Rx queue length */
    unsigned int TlshimRxQlen;
 
    /* Lock to synchronize free buffer queue access */
-   spinlock_t VosTlshimPktFreeQLock;
+   adf_os_spinlock_t VosTlshimPktFreeQLock;
 
    /* Free message queue for Tlshim Rx processing */
    struct list_head VosTlshimPktFreeQ;
@@ -282,13 +283,13 @@ typedef struct _VosWatchdogContext
    v_BOOL_t resetInProgress;
 
    /* Lock for preventing multiple reset being triggered simultaneously */
-   spinlock_t wdLock;
+   adf_os_spinlock_t wdLock;
    /* Timer to detect thread stuck issue */
    vos_timer_t thread_stuck_timer;
    /* Count to determine thread stuck */
    unsigned int mc_thread_stuck_count;
    /* lock to synchronize access to the thread stuck counts */
-   spinlock_t thread_stuck_lock;
+   adf_os_spinlock_t thread_stuck_lock;
 
 } VosWatchdogContext, *pVosWatchdogContext;
 
@@ -416,7 +417,7 @@ typedef struct _VosContextType
    struct vos_wdthread_timer_work wdthread_timer_work;
    struct list_head wdthread_timer_work_list;
    struct work_struct wdthread_work;
-   spinlock_t wdthread_work_lock;
+   adf_os_spinlock_t wdthread_work_lock;
    bool is_closed;
 } VosContextType, *pVosContextType;
 
diff --git a/CORE/VOSS/src/vos_timer.c b/CORE/VOSS/src/vos_timer.c
index f17539abcb55..42654ce65dbd 100644
--- a/CORE/VOSS/src/vos_timer.c
+++ b/CORE/VOSS/src/vos_timer.c
@@ -117,7 +117,6 @@ static void vos_linux_timer_callback (unsigned long data)
    vos_timer_t *timer = ( vos_timer_t *)data;
    vos_msg_t msg;
    VOS_STATUS vStatus;
-   unsigned long flags;
 
    vos_timer_callback_t callback=NULL;
    v_PVOID_t userData=NULL;
@@ -136,7 +135,7 @@ static void vos_linux_timer_callback (unsigned long data)
    }
 
    threadId = timer->platformInfo.threadID;
-   spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_lock_irqsave( &timer->platformInfo.spinlock);
 
    switch ( timer->state )
    {
@@ -172,7 +171,7 @@ static void vos_linux_timer_callback (unsigned long data)
       break;
    }
 
-   spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
 
    if ( VOS_STATUS_SUCCESS != vStatus )
    {
@@ -209,10 +208,10 @@ static void vos_linux_timer_callback (unsigned long data)
       }
       wdthread_timer_work->callback = callback;
       wdthread_timer_work->userdata = userData;
-      spin_lock(&vos_global_context->wdthread_work_lock);
+      adf_os_spin_lock(&vos_global_context->wdthread_work_lock);
       list_add(&wdthread_timer_work->node,
                     &vos_global_context->wdthread_timer_work_list);
-      spin_unlock(&vos_global_context->wdthread_work_lock);
+      adf_os_spin_unlock(&vos_global_context->wdthread_work_lock);
 
       schedule_work(&vos_global_context->wdthread_work);
       return;
@@ -302,7 +301,6 @@ void vos_timer_manager_init()
 static void vos_timer_clean()
 {
     v_SIZE_t listSize;
-    unsigned long flags;
 
     hdd_list_size(&vosTimerList, &listSize);
 
@@ -318,9 +316,9 @@ static void vos_timer_clean()
 
        do
        {
-          spin_lock_irqsave(&vosTimerList.lock, flags);
+          adf_os_spin_lock_irqsave(&vosTimerList.lock);
           vosStatus = hdd_list_remove_front(&vosTimerList, &pNode);
-          spin_unlock_irqrestore(&vosTimerList.lock, flags);
+          adf_os_spin_unlock_irqrestore(&vosTimerList.lock);
           if (VOS_STATUS_SUCCESS == vosStatus)
           {
              ptimerNode = (timer_node_t*)pNode;
@@ -405,7 +403,6 @@ VOS_STATUS vos_timer_init_debug( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
                            char* fileName, v_U32_t lineNum )
 {
    VOS_STATUS vosStatus;
-    unsigned long flags;
    // Check for invalid pointer
    if ((timer == NULL) || (callback == NULL))
    {
@@ -431,9 +428,9 @@ VOS_STATUS vos_timer_init_debug( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
     timer->ptimerNode->lineNum   = lineNum;
     timer->ptimerNode->vosTimer = timer;
 
-    spin_lock_irqsave(&vosTimerList.lock, flags);
+    adf_os_spin_lock_irqsave(&vosTimerList.lock);
     vosStatus = hdd_list_insert_front(&vosTimerList, &timer->ptimerNode->pNode);
-    spin_unlock_irqrestore(&vosTimerList.lock, flags);
+    adf_os_spin_unlock_irqrestore(&vosTimerList.lock);
     if(VOS_STATUS_SUCCESS != vosStatus)
     {
          VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
@@ -442,7 +439,7 @@ VOS_STATUS vos_timer_init_debug( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
 
    // set the various members of the timer structure
    // with arguments passed or with default values
-   spin_lock_init(&timer->platformInfo.spinlock);
+   adf_os_spinlock_init(&timer->platformInfo.spinlock);
    if (VOS_TIMER_TYPE_SW == timerType)
       init_timer_deferrable(&(timer->platformInfo.Timer));
    else
@@ -473,7 +470,7 @@ VOS_STATUS vos_timer_init( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
 
    // set the various members of the timer structure
    // with arguments passed or with default values
-   spin_lock_init(&timer->platformInfo.spinlock);
+   adf_os_spinlock_init(&timer->platformInfo.spinlock);
    if (VOS_TIMER_TYPE_SW == timerType)
       init_timer_deferrable(&(timer->platformInfo.Timer));
    else
@@ -528,7 +525,6 @@ VOS_STATUS vos_timer_init( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
 VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
 {
    VOS_STATUS vStatus=VOS_STATUS_SUCCESS;
-   unsigned long flags;
 
    // Check for invalid pointer
    if ( NULL == timer )
@@ -548,9 +544,9 @@ VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
       return VOS_STATUS_E_INVAL;
    }
 
-   spin_lock_irqsave(&vosTimerList.lock, flags);
+   adf_os_spin_lock_irqsave(&vosTimerList.lock);
    vStatus = hdd_list_remove_node(&vosTimerList, &timer->ptimerNode->pNode);
-   spin_unlock_irqrestore(&vosTimerList.lock, flags);
+   adf_os_spin_unlock_irqrestore(&vosTimerList.lock);
    if(vStatus != VOS_STATUS_SUCCESS)
    {
       VOS_ASSERT(0);
@@ -559,7 +555,7 @@ VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
    vos_mem_free(timer->ptimerNode);
 
 
-   spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_lock_irqsave( &timer->platformInfo.spinlock);
 
    switch ( timer->state )
    {
@@ -586,11 +582,11 @@ VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
    {
       timer->platformInfo.cookie = LINUX_INVALID_TIMER_COOKIE;
       timer->state = VOS_TIMER_STATE_UNUSED;
-      spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+      adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
       return vStatus;
    }
 
-   spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
 
 
    VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
@@ -604,7 +600,6 @@ VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
 VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
 {
    VOS_STATUS vStatus=VOS_STATUS_SUCCESS;
-   unsigned long flags;
 
    // Check for invalid pointer
    if ( NULL == timer )
@@ -623,7 +618,7 @@ VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
       VOS_ASSERT(0);
       return VOS_STATUS_E_INVAL;
    }
-   spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_lock_irqsave( &timer->platformInfo.spinlock);
 
    switch ( timer->state )
    {
@@ -650,11 +645,11 @@ VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
    {
       timer->platformInfo.cookie = LINUX_INVALID_TIMER_COOKIE;
       timer->state = VOS_TIMER_STATE_UNUSED;
-      spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+      adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
       return vStatus;
    }
 
-   spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
 
    VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
              "%s: Cannot destroy timer in state = %d",__func__, timer->state);
@@ -694,7 +689,6 @@ VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
   -------------------------------------------------------------------------*/
 VOS_STATUS vos_timer_start( vos_timer_t *timer, v_U32_t expirationTime )
 {
-   unsigned long flags;
 
    VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
              "Timer Addr inside voss_start : 0x%pK ", timer );
@@ -728,12 +722,12 @@ VOS_STATUS vos_timer_start( vos_timer_t *timer, v_U32_t expirationTime )
    }
 
    // make sure the remainer of the logic isn't interrupted
-   spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_lock_irqsave( &timer->platformInfo.spinlock);
 
    // Ensure if the timer can be started
    if ( VOS_TIMER_STATE_STOPPED != timer->state )
    {
-      spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+      adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
       VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
                 "%s: Cannot start timer in state = %d ",__func__, timer->state);
       return VOS_STATUS_E_ALREADY;
@@ -758,7 +752,7 @@ VOS_STATUS vos_timer_start( vos_timer_t *timer, v_U32_t expirationTime )
       }
    }
 
-   spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
 
    return VOS_STATUS_SUCCESS;
 }
@@ -786,8 +780,6 @@ VOS_STATUS vos_timer_start( vos_timer_t *timer, v_U32_t expirationTime )
   ------------------------------------------------------------------------*/
 VOS_STATUS vos_timer_stop ( vos_timer_t *timer )
 {
-   unsigned long flags;
-
    VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
                "%s: Timer Addr inside voss_stop : 0x%pK",__func__,timer );
 
@@ -810,11 +802,11 @@ VOS_STATUS vos_timer_stop ( vos_timer_t *timer )
    }
 
    // Ensure the timer state is correct
-   spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_lock_irqsave( &timer->platformInfo.spinlock);
 
    if ( VOS_TIMER_STATE_RUNNING != timer->state )
    {
-      spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+      adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
       VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
                 "%s: Cannot stop timer in state = %d",
                 __func__, timer->state);
@@ -825,7 +817,7 @@ VOS_STATUS vos_timer_stop ( vos_timer_t *timer )
 
    del_timer(&(timer->platformInfo.Timer));
 
-   spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
+   adf_os_spin_unlock_irqrestore( &timer->platformInfo.spinlock);
 
    tryAllowingSleep( timer->type );
 
@@ -929,7 +921,7 @@ void vos_wdthread_init_timer_work(void *callbackptr)
 		return;
 	}
 
-	spin_lock_init(&context->wdthread_work_lock);
+	adf_os_spinlock_init(&context->wdthread_work_lock);
 	INIT_LIST_HEAD(&context->wdthread_timer_work_list);
 	vos_init_work(&context->wdthread_work, callbackptr);
 }
@@ -977,21 +969,21 @@ static void __vos_process_wd_timer(void)
 
 	vos_global_context = (pVosContextType)vos_context;
 
-	spin_lock(&vos_global_context->wdthread_work_lock);
+	adf_os_spin_lock(&vos_global_context->wdthread_work_lock);
 	list_for_each_safe(pos, next,
 			&vos_global_context->wdthread_timer_work_list) {
 		wdthread_timer_work = list_entry(pos,
 						struct vos_wdthread_timer_work,
 						node);
 		list_del(pos);
-		spin_unlock(&vos_global_context->wdthread_work_lock);
+		adf_os_spin_unlock(&vos_global_context->wdthread_work_lock);
 		if (NULL != wdthread_timer_work->callback)
 			wdthread_timer_work->callback(
 				wdthread_timer_work->userdata);
 		vos_mem_free(wdthread_timer_work);
-		spin_lock(&vos_global_context->wdthread_work_lock);
+		adf_os_spin_lock(&vos_global_context->wdthread_work_lock);
 	}
-	spin_unlock(&vos_global_context->wdthread_work_lock);
+	adf_os_spin_unlock(&vos_global_context->wdthread_work_lock);
 
 	return;
 }
diff --git a/CORE/VOSS/src/vos_trace.c b/CORE/VOSS/src/vos_trace.c
index b25ef46a6d2f..fec44079a090 100644
--- a/CORE/VOSS/src/vos_trace.c
+++ b/CORE/VOSS/src/vos_trace.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2014, 2016-2017 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2014, 2016-2018 The Linux Foundation. All rights reserved.
  *
  * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  *
@@ -120,7 +120,7 @@ moduleTraceInfo gVosTraceInfo[ VOS_MODULE_ID_MAX ] =
 /*-------------------------------------------------------------------------
   Static and Global variables
   ------------------------------------------------------------------------*/
-static spinlock_t ltraceLock;
+static adf_os_spinlock_t ltraceLock;
 
 static tvosTraceRecord gvosTraceTbl[MAX_VOS_TRACE_RECORDS];
 // Global vosTraceData
@@ -498,7 +498,6 @@ void vos_register_debugcb_init(void)
 void vos_trace(v_U8_t module, v_U8_t code, v_U16_t session, v_U32_t data)
 {
     tpvosTraceRecord rec = NULL;
-    unsigned long flags;
     char time[20];
 
     if (!gvosTraceData.enable)
@@ -514,7 +513,7 @@ void vos_trace(v_U8_t module, v_U8_t code, v_U16_t session, v_U32_t data)
     vos_get_time_of_the_day_in_hr_min_sec_usec(time, sizeof(time));
 
     /* Aquire the lock so that only one thread at a time can fill the ring buffer */
-    spin_lock_irqsave(&ltraceLock, flags);
+    adf_os_spin_lock_irqsave(&ltraceLock);
 
     gvosTraceData.num++;
 
@@ -558,7 +557,7 @@ void vos_trace(v_U8_t module, v_U8_t code, v_U16_t session, v_U32_t data)
     rec->module = module;
     rec->pid = (in_interrupt() ? 0 : current->pid);
     gvosTraceData.numSinceLastDump ++;
-    spin_unlock_irqrestore(&ltraceLock, flags);
+    adf_os_spin_unlock_irqrestore(&ltraceLock);
 }
 
 
@@ -570,7 +569,7 @@ void vos_trace(v_U8_t module, v_U8_t code, v_U16_t session, v_U32_t data)
   ----------------------------------------------------------------------------*/
 VOS_STATUS vos_trace_spin_lock_init()
 {
-    spin_lock_init(&ltraceLock);
+    adf_os_spinlock_init(&ltraceLock);
 
     return VOS_STATUS_SUCCESS;
 }
@@ -628,7 +627,7 @@ void vosTraceDumpAll(void *pMac, v_U8_t code, v_U8_t session,
                gvosTraceData.num, gvosTraceData.head, gvosTraceData.tail);
 
     /* Aquire the lock so that only one thread at a time can read the ring buffer */
-    spin_lock(&ltraceLock);
+    adf_os_spin_lock(&ltraceLock);
 
     if (gvosTraceData.head != INVALID_VOS_TRACE_ADDR)
     {
@@ -656,7 +655,7 @@ void vosTraceDumpAll(void *pMac, v_U8_t code, v_U8_t session,
            we might re-visit and use this member to track how many latest
            messages got added while we were dumping from ring buffer */
         gvosTraceData.numSinceLastDump = 0;
-        spin_unlock(&ltraceLock);
+        adf_os_spin_unlock(&ltraceLock);
         for (;;)
         {
             if ((code == 0 || (code == pRecord.code)) &&
@@ -681,7 +680,7 @@ void vosTraceDumpAll(void *pMac, v_U8_t code, v_U8_t session,
             }
             i += 1;
 
-            spin_lock(&ltraceLock);
+            adf_os_spin_lock(&ltraceLock);
             if (MAX_VOS_TRACE_RECORDS == i)
             {
                 i = 0;
@@ -691,12 +690,12 @@ void vosTraceDumpAll(void *pMac, v_U8_t code, v_U8_t session,
             {
                 pRecord = gvosTraceTbl[i];
             }
-            spin_unlock(&ltraceLock);
+            adf_os_spin_unlock(&ltraceLock);
         }
     }
     else
     {
-        spin_unlock(&ltraceLock);
+        adf_os_spin_unlock(&ltraceLock);
     }
 }