qcacld-3.0: Converge on wmi service/ext service is enable

Converge on wmi service/ext service is enable.

Change-Id: Ieed7a18f88806ed1e5b7fb012619ea67015cce2d
CRs-Fixed: 2152849

components/pmo/core/src/wlan_pmo_wow.c

@@ -254,8 +254,8 @@ static
 bool pmo_support_wow_for_beaconing(struct wlan_objmgr_psoc *psoc)
 {
 	/*
-	 * if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-	 *			WMI_SERVICE_BEACON_OFFLOAD))
+	 * if (wmi_service_enabled(wma->wmi_handle,
+	 *			wmi_service_beacon_offload))
 	 */
 	return pmo_is_beaconing_vdev_up(psoc);
 }

components/target_if/pmo/src/target_if_pmo_mc_addr_filtering.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
@@ -91,8 +91,10 @@ QDF_STATUS target_if_pmo_clear_mc_filter_req(
 bool target_if_pmo_get_multiple_mc_filter_support(
 		struct wlan_objmgr_psoc *psoc)
 {
-	return WMI_SERVICE_IS_ENABLED(psoc->service_param.service_bitmap,
-				      WMI_SERVICE_MULTIPLE_MCAST_FILTER_SET);
+	wmi_unified_t wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc);
+
+	return wmi_service_enabled(wmi_handle,
+				      wmi_service_multiple_mcast_filter_set);
 }
 
 QDF_STATUS target_if_pmo_set_multiple_mc_filter_req(

core/hdd/src/wlan_hdd_main.c

@@ -12533,7 +12533,7 @@ static int hdd_update_pmo_config(struct hdd_context *hdd_ctx)
 	psoc_cfg.ptrn_match_enable_all_vdev =
 		(hdd_ctx->config->wowEnable & 0x02) ? true : false;
 	psoc_cfg.ptrn_id_per_vdev = wma_is_service_enabled(
-		WMI_SERVICE_UNIFIED_WOW_CAPABILITY);
+		wmi_service_unified_wow_capability);
 	psoc_cfg.bpf_enable =
 		hdd_ctx->config->bpf_packet_filter_enable;
 	psoc_cfg.arp_offload_enable = hdd_ctx->config->fhostArpOffload;

core/wma/inc/wma_api.h

@@ -284,7 +284,7 @@ QDF_STATUS wma_set_sar_limit(WMA_HANDLE handle,
  */
 QDF_STATUS wma_set_qpower_config(uint8_t vdev_id, uint8_t qpower);
 
-bool wma_is_service_enabled(WMI_SERVICE service_type);
+bool wma_is_service_enabled(uint32_t service_type);
 
 #ifdef FEATURE_WLAN_D0WOW
 static inline bool wma_d0_wow_is_supported(void)

core/wma/src/wma_dev_if.c

@@ -456,8 +456,8 @@ static void wma_vdev_detach_callback(void *ctx)
 	iface->del_staself_req = NULL;
 	WMA_LOGD("%s: sending eWNI_SME_DEL_STA_SELF_RSP for vdev %d",
 		 __func__, param->session_id);
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_SYNC_DELETE_CMDS)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_sync_delete_cmds)) {
 		req_msg = wma_find_vdev_req(wma, param->session_id,
 					    WMA_TARGET_REQ_TYPE_VDEV_DEL,
 					    true);
@@ -530,8 +530,8 @@ static QDF_STATUS wma_self_peer_remove(tp_wma_handle wma_handle,
 			del_sta_self_req_param->self_mac_addr,
 			vdev_id, peer, false);
 
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				WMI_SERVICE_SYNC_DELETE_CMDS)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				wmi_service_sync_delete_cmds)) {
 		sta_self_wmi_rsp =
 			qdf_mem_malloc(sizeof(struct del_sta_self_rsp_params));
 		if (sta_self_wmi_rsp == NULL) {
@@ -608,8 +608,8 @@ static QDF_STATUS wma_handle_vdev_detach(tp_wma_handle wma_handle,
 	}
 
 	/* Acquire wake lock only when you expect a response from firmware */
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_SYNC_DELETE_CMDS)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_sync_delete_cmds)) {
 		wma_acquire_wakelock(&wma_handle->wmi_cmd_rsp_wake_lock,
 				     WMA_FW_RSP_EVENT_WAKE_LOCK_DURATION);
 	}
@@ -620,8 +620,8 @@ static QDF_STATUS wma_handle_vdev_detach(tp_wma_handle wma_handle,
 	 * send the response immediately if WMI_SERVICE_SYNC_DELETE_CMDS
 	 * service is not supported by firmware
 	 */
-	if (!WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				    WMI_SERVICE_SYNC_DELETE_CMDS))
+	if (!wmi_service_enabled(wma_handle->wmi_handle,
+				    wmi_service_sync_delete_cmds))
 		wma_vdev_detach_callback(iface);
 	return status;
 out:
@@ -713,8 +713,8 @@ QDF_STATUS wma_vdev_detach(tp_wma_handle wma_handle,
 	    (iface->sub_type == WMI_UNIFIED_VDEV_SUBTYPE_P2P_DEVICE)) {
 		wma_self_peer_remove(wma_handle, pdel_sta_self_req_param,
 					generateRsp);
-		if (!WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				WMI_SERVICE_SYNC_DELETE_CMDS))
+		if (!wmi_service_enabled(wma_handle->wmi_handle,
+				wmi_service_sync_delete_cmds))
 			status = wma_handle_vdev_detach(wma_handle,
 				pdel_sta_self_req_param, generateRsp);
 	} else {  /* other than P2P */
@@ -1644,9 +1644,9 @@ static int wma_remove_bss_peer(tp_wma_handle wma, void *pdev,
 	}
 
 	wma_remove_peer(wma, mac_addr, vdev_id, peer, false);
-	if (WMI_SERVICE_IS_ENABLED(
-	   wma->wmi_service_bitmap,
-	   WMI_SERVICE_SYNC_DELETE_CMDS)) {
+	if (wmi_service_enabled(
+	   wma->wmi_handle,
+	   wmi_service_sync_delete_cmds)) {
 		WMA_LOGD(FL("Wait for the peer delete. vdev_id %d"),
 				 req_msg->vdev_id);
 		del_req = wma_fill_hold_req(wma,
@@ -1936,9 +1936,9 @@ int wma_vdev_stop_resp_handler(void *handle, uint8_t *cmd_param_info,
 		if (status != 0)
 			goto free_req_msg;
 
-		if (WMI_SERVICE_IS_ENABLED(
-		   wma->wmi_service_bitmap,
-		   WMI_SERVICE_SYNC_DELETE_CMDS))
+		if (wmi_service_enabled(
+		   wma->wmi_handle,
+		   wmi_service_sync_delete_cmds))
 			goto free_req_msg;
 
 		wma_send_del_bss_response(wma, req_msg, resp_event->vdev_id);
@@ -1952,8 +1952,8 @@ int wma_vdev_stop_resp_handler(void *handle, uint8_t *cmd_param_info,
 				 params->bssid, req_msg->vdev_id);
 			wma_remove_peer(wma, params->bssid, req_msg->vdev_id,
 				peer, false);
-			if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_SYNC_DELETE_CMDS)) {
+			if (wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_sync_delete_cmds)) {
 				WMA_LOGI(FL("Wait for the peer delete. vdev_id %d"),
 						 req_msg->vdev_id);
 				del_req = wma_fill_hold_req(wma,
@@ -2128,8 +2128,8 @@ struct cdp_vdev *wma_vdev_attach(tp_wma_handle wma_handle,
 				       cfg_val, NULL, NULL, NULL);
 
 		/* offload STA SA query related params to fwr */
-		if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-			WMI_SERVICE_STA_PMF_OFFLOAD)) {
+		if (wmi_service_enabled(wma_handle->wmi_handle,
+			wmi_service_sta_pmf_offload)) {
 			wma_set_sta_sa_query_param(wma_handle,
 						   self_sta_req->session_id);
 		}
@@ -3180,9 +3180,9 @@ void wma_vdev_resp_timer(void *data)
 		if (status != 0)
 			goto free_tgt_req;
 
-		if (WMI_SERVICE_IS_ENABLED(
-		   wma->wmi_service_bitmap,
-		   WMI_SERVICE_SYNC_DELETE_CMDS))
+		if (wmi_service_enabled(
+		   wma->wmi_handle,
+		   wmi_service_sync_delete_cmds))
 			goto free_tgt_req;
 
 		if (wma_send_vdev_down_to_fw(wma, tgt_req->vdev_id) !=
@@ -3235,8 +3235,8 @@ void wma_vdev_resp_timer(void *data)
 		struct del_sta_self_params *params =
 			(struct del_sta_self_params *) iface->del_staself_req;
 
-		if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-					   WMI_SERVICE_SYNC_DELETE_CMDS)) {
+		if (wmi_service_enabled(wma->wmi_handle,
+					   wmi_service_sync_delete_cmds)) {
 			wma_release_wakelock(&wma->wmi_cmd_rsp_wake_lock);
 		}
 		params->status = QDF_STATUS_E_TIMEOUT;
@@ -3684,8 +3684,8 @@ static void wma_add_bss_ibss_mode(tp_wma_handle wma, tpAddBssParams add_bss)
 	 * If IBSS Power Save is supported by firmware
 	 * set the IBSS power save params to firmware.
 	 */
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				   WMI_SERVICE_IBSS_PWRSAVE)) {
+	if (wmi_service_enabled(wma->wmi_handle,
+				   wmi_service_ibss_pwrsave)) {
 		status = wma_set_ibss_pwrsave_params(wma, vdev_id);
 		if (status != QDF_STATUS_SUCCESS) {
 			WMA_LOGE("%s: Failed to Set IBSS Power Save Params to firmware",
@@ -4014,8 +4014,8 @@ send_bss_resp:
 	qdf_mem_copy(add_bss->staContext.staMac, add_bss->bssId,
 		     sizeof(add_bss->staContext.staMac));
 
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_PEER_ASSOC_CONF)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_peer_assoc_conf)) {
 		WMA_LOGE(FL("WMI_SERVICE_PEER_ASSOC_CONF not enabled"));
 		goto send_final_rsp;
 	}
@@ -4227,8 +4227,8 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 		}
 	}
 
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_PEER_ASSOC_CONF)) {
+	if (wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_peer_assoc_conf)) {
 		peer_assoc_cnf = true;
 		msg = wma_fill_hold_req(wma, add_sta->smesessionId,
 				   WMA_ADD_STA_REQ, WMA_PEER_ASSOC_CNF_START,
@@ -4263,8 +4263,8 @@ static void wma_add_sta_req_ap_mode(tp_wma_handle wma, tpAddStaParams add_sta)
 	 * firmware.
 	 */
 	if (wma_is_vdev_in_ibss_mode(wma, add_sta->smesessionId) &&
-	    WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				   WMI_SERVICE_IBSS_PWRSAVE)) {
+	    wmi_service_enabled(wma->wmi_handle,
+				   wmi_service_ibss_pwrsave)) {
 		/*
 		 * If ATIM Window is present in the peer
 		 * beacon then send it to firmware else
@@ -4438,8 +4438,8 @@ static void wma_add_tdls_sta(tp_wma_handle wma, tpAddStaParams add_sta)
 			goto send_rsp;
 		}
 
-		if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-					    WMI_SERVICE_PEER_ASSOC_CONF)) {
+		if (wmi_service_enabled(wma->wmi_handle,
+					    wmi_service_peer_assoc_conf)) {
 			WMA_LOGE(FL("WMI_SERVICE_PEER_ASSOC_CONF is enabled"));
 			peer_assoc_cnf = true;
 			msg = wma_fill_hold_req(wma, add_sta->smesessionId,
@@ -4593,8 +4593,8 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
 		}
 		wmi_unified_send_txbf(wma, params);
 
-		if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-					    WMI_SERVICE_PEER_ASSOC_CONF)) {
+		if (wmi_service_enabled(wma->wmi_handle,
+					    wmi_service_peer_assoc_conf)) {
 			WMA_LOGD(FL("WMI_SERVICE_PEER_ASSOC_CONF is enabled"));
 			peer_assoc_cnf = true;
 			msg = wma_fill_hold_req(wma, params->smesessionId,
@@ -4643,8 +4643,8 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
 				iface->llbCoexist, maxTxPower);
 
 	params->csaOffloadEnable = 0;
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				   WMI_SERVICE_CSA_OFFLOAD)) {
+	if (wmi_service_enabled(wma->wmi_handle,
+				   wmi_service_csa_offload)) {
 		params->csaOffloadEnable = 1;
 		if (wma_unified_csa_offload_enable(wma, params->smesessionId) <
 		    0) {
@@ -4653,8 +4653,8 @@ static void wma_add_sta_req_sta_mode(tp_wma_handle wma, tpAddStaParams params)
 		}
 	}
 
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				   WMI_SERVICE_FILTER_IPSEC_NATKEEPALIVE)) {
+	if (wmi_service_enabled(wma->wmi_handle,
+				   wmi_service_filter_ipsec_natkeepalive)) {
 		if (wmi_unified_nat_keepalive_enable(wma, params->smesessionId)
 		    < 0) {
 			WMA_LOGE("Unable to enable NAT keepalive for vdev_id:%d",
@@ -4765,8 +4765,8 @@ static void wma_delete_sta_req_ap_mode(tp_wma_handle wma,
 			false);
 	del_sta->status = QDF_STATUS_SUCCESS;
 
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_SYNC_DELETE_CMDS)) {
+	if (wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_sync_delete_cmds)) {
 		msg = wma_fill_hold_req(wma, del_sta->smesessionId,
 				   WMA_DELETE_STA_REQ,
 				   WMA_DELETE_STA_RSP_START, del_sta,
@@ -4842,8 +4842,8 @@ static void wma_del_tdls_sta(tp_wma_handle wma, tpDeleteStaParams del_sta)
 	}
 
 	if (del_sta->respReqd &&
-			WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				WMI_SERVICE_SYNC_DELETE_CMDS)) {
+			wmi_service_enabled(wma->wmi_handle,
+				wmi_service_sync_delete_cmds)) {
 		del_sta->status = QDF_STATUS_SUCCESS;
 		msg = wma_fill_hold_req(wma,
 				del_sta->smesessionId,
@@ -5004,8 +5004,8 @@ void wma_delete_sta(tp_wma_handle wma, tpDeleteStaParams del_sta)
 		wma_delete_sta_req_ap_mode(wma, del_sta);
 		/* free the memory here only if sync feature is not enabled */
 		if (!rsp_requested &&
-		    !WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				WMI_SERVICE_SYNC_DELETE_CMDS)) {
+		    !wmi_service_enabled(wma->wmi_handle,
+				wmi_service_sync_delete_cmds)) {
 			WMA_LOGD(FL("vdev_id %d status %d"),
 				 del_sta->smesessionId, del_sta->status);
 			qdf_mem_free(del_sta);

core/wma/src/wma_features.c

@@ -764,8 +764,8 @@ QDF_STATUS wma_get_link_speed(WMA_HANDLE handle, tSirLinkSpeedInfo *pLinkSpeed)
 			 __func__);
 		return QDF_STATUS_E_INVAL;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				    WMI_SERVICE_ESTIMATE_LINKSPEED)) {
+	if (!wmi_service_enabled(wma_handle->wmi_handle,
+				    wmi_service_estimate_linkspeed)) {
 		WMA_LOGE("%s: Linkspeed feature bit not enabled Sending value 0 as link speed.",
 			__func__);
 		wma_send_link_speed(0);
@@ -1116,8 +1116,8 @@ void wma_register_egap_event_handle(WMA_HANDLE handle)
 	tp_wma_handle wma_handle = (tp_wma_handle) handle;
 	QDF_STATUS status;
 
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_EGAP)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_egap)) {
 		status = wmi_unified_register_event_handler(
 						   wma_handle->wmi_handle,
 						   wmi_ap_ps_egap_info_event_id,
@@ -1210,9 +1210,8 @@ void wma_check_and_set_wake_timer(uint32_t time)
 		return;
 	}
 
-	if (!WMI_SERVICE_EXT_IS_ENABLED(wma->wmi_service_bitmap,
-		wma->wmi_service_ext_bitmap,
-		WMI_SERVICE_WOW_WAKEUP_BY_TIMER_PATTERN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+		wmi_service_wow_wakeup_by_timer_pattern)) {
 		WMA_LOGD("TIME_PATTERN is not enabled");
 		return;
 	}
@@ -4333,8 +4332,8 @@ QDF_STATUS wma_get_bpf_capabilities(tp_wma_handle wma)
 		return QDF_STATUS_E_INVAL;
 	}
 
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-		WMI_SERVICE_BPF_OFFLOAD)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+		wmi_service_bpf_offload)) {
 		WMA_LOGE(FL("BPF cababilities feature bit not enabled"));
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -4383,8 +4382,8 @@ QDF_STATUS wma_set_bpf_instructions(tp_wma_handle wma,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-		WMI_SERVICE_BPF_OFFLOAD)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+		wmi_service_bpf_offload)) {
 		WMA_LOGE(FL("BPF offload feature Disabled"));
 		return QDF_STATUS_E_NOSUPPORT;
 	}

core/wma/src/wma_he.c

@@ -915,7 +915,7 @@ void wma_update_target_ext_he_cap(tp_wma_handle wma_handle,
 
 void wma_he_update_tgt_services(tp_wma_handle wma, struct wma_tgt_services *cfg)
 {
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap, WMI_SERVICE_11AX)) {
+	if (wmi_service_enabled(wma->wmi_handle, wmi_service_11ax)) {
 		cfg->en_11ax = true;
 		wma_set_fw_wlan_feat_caps(DOT11AX);
 		WMA_LOGI(FL("11ax is enabled"));

core/wma/src/wma_main.c

@@ -2786,6 +2786,12 @@ static int wma_rx_service_available_event(void *handle, uint8_t *cmd_param_info,
 				&ev->wmi_service_segment_bitmap[0],
 				WMI_SERVICE_EXT_BM_SIZE32 * sizeof(A_UINT32));
 
+	if (wmi_save_ext_service_bitmap(wma_handle->wmi_handle,
+				cmd_param_info, NULL)
+			!= QDF_STATUS_SUCCESS)
+		qdf_print("Failed to save ext service bitmap\n");
+
+
 	return 0;
 }
 
@@ -3304,7 +3310,6 @@ QDF_STATUS wma_open(struct wlan_objmgr_psoc *psoc,
 	pmo_register_is_device_in_low_pwr_mode(wma_handle->psoc,
 		wma_vdev_is_device_in_low_pwr_mode);
 	wma_cbacks.wma_get_connection_info = wma_get_connection_info;
-	wma_cbacks.wma_is_service_enabled = wma_is_service_enabled;
 	qdf_status = policy_mgr_register_wma_cb(wma_handle->psoc, &wma_cbacks);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		WMA_LOGE("Failed to register wma cb with Policy Manager");
@@ -3947,8 +3952,8 @@ QDF_STATUS wma_start(void)
 		goto end;
 #endif /* QCA_WIFI_FTM */
 
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_RMC)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_rmc)) {
 
 		WMA_LOGD("FW supports cesium network, registering event handlers");
 
@@ -4483,8 +4488,8 @@ static void wma_update_fw_config(tp_wma_handle wma_handle,
 		tgt_cap->wlan_resource_config.max_frag_entries;
 
 	/* Update no. of maxWoWFilters depending on BPF service */
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_BPF_OFFLOAD))
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_bpf_offload))
 		tgt_cap->wlan_resource_config.num_wow_filters =
 					WMA_STA_WOW_DEFAULT_PTRN_MAX;
 }
@@ -4607,20 +4612,20 @@ static inline void wma_update_target_services(tp_wma_handle wh,
 					      struct wma_tgt_services *cfg)
 {
 	/* STA power save */
-	cfg->sta_power_save = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-						     WMI_SERVICE_STA_PWRSAVE);
+	cfg->sta_power_save = wmi_service_enabled(wh->wmi_handle,
+						     wmi_service_sta_pwrsave);
 
 	/* Enable UAPSD */
-	cfg->uapsd = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-					    WMI_SERVICE_AP_UAPSD);
+	cfg->uapsd = wmi_service_enabled(wh->wmi_handle,
+					    wmi_service_ap_uapsd);
 
 	/* Update AP DFS service */
-	cfg->ap_dfs = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-					     WMI_SERVICE_AP_DFS);
+	cfg->ap_dfs = wmi_service_enabled(wh->wmi_handle,
+					     wmi_service_ap_dfs);
 
 	/* Enable 11AC */
-	cfg->en_11ac = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-					      WMI_SERVICE_11AC);
+	cfg->en_11ac = wmi_service_enabled(wh->wmi_handle,
+					      wmi_service_11ac);
 	if (cfg->en_11ac)
 		g_fw_wlan_feat_caps |= (1 << DOT11AC);
 
@@ -4631,65 +4636,65 @@ static inline void wma_update_target_services(tp_wma_handle wh,
 	g_fw_wlan_feat_caps |= (1 << WOW);
 
 	/* ARP offload */
-	cfg->arp_offload = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-						  WMI_SERVICE_ARPNS_OFFLOAD);
+	cfg->arp_offload = wmi_service_enabled(wh->wmi_handle,
+						  wmi_service_arpns_offload);
 
 	/* Adaptive early-rx */
-	cfg->early_rx = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-					       WMI_SERVICE_EARLY_RX);
+	cfg->early_rx = wmi_service_enabled(wh->wmi_handle,
+					       wmi_service_early_rx);
 #ifdef FEATURE_WLAN_SCAN_PNO
 	/* PNO offload */
-	if (WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap, WMI_SERVICE_NLO))
+	if (wmi_service_enabled(wh->wmi_handle, wmi_service_nlo))
 		cfg->pno_offload = true;
 #endif /* FEATURE_WLAN_SCAN_PNO */
 
 #ifdef FEATURE_WLAN_EXTSCAN
-	if (WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap, WMI_SERVICE_EXTSCAN))
+	if (wmi_service_enabled(wh->wmi_handle, wmi_service_extscan))
 		g_fw_wlan_feat_caps |= (1 << EXTENDED_SCAN);
 #endif /* FEATURE_WLAN_EXTSCAN */
-	cfg->lte_coex_ant_share = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-					WMI_SERVICE_LTE_ANT_SHARE_SUPPORT);
+	cfg->lte_coex_ant_share = wmi_service_enabled(wh->wmi_handle,
+					wmi_service_lte_ant_share_support);
 #ifdef FEATURE_WLAN_TDLS
 	/* Enable TDLS */
-	if (WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap, WMI_SERVICE_TDLS)) {
+	if (wmi_service_enabled(wh->wmi_handle, wmi_service_tdls)) {
 		cfg->en_tdls = 1;
 		g_fw_wlan_feat_caps |= (1 << TDLS);
 	}
 	/* Enable advanced TDLS features */
-	if (WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-				   WMI_SERVICE_TDLS_OFFCHAN)) {
+	if (wmi_service_enabled(wh->wmi_handle,
+				   wmi_service_tdls_offchan)) {
 		cfg->en_tdls_offchan = 1;
 		g_fw_wlan_feat_caps |= (1 << TDLS_OFF_CHANNEL);
 	}
 
 	cfg->en_tdls_uapsd_buf_sta =
-		WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-				       WMI_SERVICE_TDLS_UAPSD_BUFFER_STA);
+		wmi_service_enabled(wh->wmi_handle,
+				       wmi_service_tdls_uapsd_buffer_sta);
 	cfg->en_tdls_uapsd_sleep_sta =
-		WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-				       WMI_SERVICE_TDLS_UAPSD_SLEEP_STA);
+		wmi_service_enabled(wh->wmi_handle,
+				       wmi_service_tdls_uapsd_sleep_sta);
 #endif /* FEATURE_WLAN_TDLS */
-	if (WMI_SERVICE_IS_ENABLED
-		    (wh->wmi_service_bitmap, WMI_SERVICE_BEACON_OFFLOAD))
+	if (wmi_service_enabled
+		    (wh->wmi_handle, wmi_service_beacon_offload))
 		cfg->beacon_offload = true;
-	if (WMI_SERVICE_IS_ENABLED
-		    (wh->wmi_service_bitmap, WMI_SERVICE_STA_PMF_OFFLOAD))
+	if (wmi_service_enabled
+		    (wh->wmi_handle, wmi_service_sta_pmf_offload))
 		cfg->pmf_offload = true;
 #ifdef WLAN_FEATURE_ROAM_OFFLOAD
 	/* Enable Roam Offload */
-	cfg->en_roam_offload = WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-					      WMI_SERVICE_ROAM_HO_OFFLOAD);
+	cfg->en_roam_offload = wmi_service_enabled(wh->wmi_handle,
+					      wmi_service_roam_ho_offload);
 #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
 #ifdef WLAN_FEATURE_NAN
-	if (WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap, WMI_SERVICE_NAN))
+	if (wmi_service_enabled(wh->wmi_handle, wmi_service_nan))
 		g_fw_wlan_feat_caps |= (1 << NAN);
 #endif /* WLAN_FEATURE_NAN */
 
-	if (WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap, WMI_SERVICE_RTT))
+	if (wmi_service_enabled(wh->wmi_handle, wmi_service_rtt))
 		g_fw_wlan_feat_caps |= (1 << RTT);
 
-	if (WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-			WMI_SERVICE_TX_MSDU_ID_NEW_PARTITION_SUPPORT)) {
+	if (wmi_service_enabled(wh->wmi_handle,
+			wmi_service_tx_msdu_id_new_partition_support)) {
 		wma_set_tx_partition_base(HTT_TX_IPA_NEW_MSDU_ID_SPACE_BEGIN);
 	} else {
 		wma_set_tx_partition_base(HTT_TX_IPA_MSDU_ID_SPACE_BEGIN);
@@ -4698,16 +4703,14 @@ static inline void wma_update_target_services(tp_wma_handle wh,
 	wma_he_update_tgt_services(wh, cfg);
 
 	cfg->get_peer_info_enabled =
-		WMI_SERVICE_IS_ENABLED(wh->wmi_service_bitmap,
-				       WMI_SERVICE_PEER_STATS_INFO);
-	if (WMI_SERVICE_EXT_IS_ENABLED(wh->wmi_service_bitmap,
-			wh->wmi_service_ext_bitmap,
-			WMI_SERVICE_FILS_SUPPORT))
+		wmi_service_enabled(wh->wmi_handle,
+				       wmi_service_peer_stats_info);
+	if (wmi_service_enabled(wh->wmi_handle,
+			wmi_service_fils_support))
 		cfg->is_fils_roaming_supported = true;
 
-	if (WMI_SERVICE_EXT_IS_ENABLED(wh->wmi_service_bitmap,
-				       wh->wmi_service_ext_bitmap,
-				       WMI_SERVICE_MAWC_SUPPORT))
+	if (wmi_service_enabled(wh->wmi_handle,
+				       wmi_service_mawc_support))
 		cfg->is_fw_mawc_capable = true;
 
 }
@@ -5540,8 +5543,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 		     sizeof(wma_handle->wmi_service_bitmap));
 
 	cdp_cfg_tx_set_is_mgmt_over_wmi_enabled(soc,
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				       WMI_SERVICE_MGMT_TX_WMI));
+		wmi_service_enabled(wma_handle->wmi_handle,
+				       wmi_service_mgmt_tx_wmi));
 	cdp_set_desc_global_pool_size(soc, ev->num_msdu_desc);
 	/* SWBA event handler for beacon transmission */
 	status = wmi_unified_register_event_handler(wma_handle->wmi_handle,
@@ -5554,8 +5557,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 	}
 #ifdef WLAN_FEATURE_LPSS
 	wma_handle->lpss_support =
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				       WMI_SERVICE_LPASS);
+		wmi_service_enabled(wma_handle->wmi_handle,
+				       wmi_service_lpass);
 #endif /* WLAN_FEATURE_LPSS */
 
 	/*
@@ -5563,15 +5566,15 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 	 * support for LL/HL targets
 	 */
 	wma_handle->ap_arpns_support =
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				WMI_SERVICE_AP_ARPNS_OFFLOAD);
+		wmi_service_enabled(wma_handle->wmi_handle,
+				wmi_service_ap_arpns_offload);
 
 	wma_handle->bpf_enabled = (wma_handle->bpf_packet_filter_enable &&
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				WMI_SERVICE_BPF_OFFLOAD));
+		wmi_service_enabled(wma_handle->wmi_handle,
+				wmi_service_bpf_offload));
 	wma_update_ra_limit(wma_handle);
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_CSA_OFFLOAD)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_csa_offload)) {
 		WMA_LOGD("%s: FW support CSA offload capability", __func__);
 		status = wmi_unified_register_event_handler(
 						wma_handle->wmi_handle,
@@ -5584,8 +5587,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 		}
 	}
 
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_MGMT_TX_WMI)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_mgmt_tx_wmi)) {
 		WMA_LOGD("Firmware supports management TX over WMI,use WMI interface instead of HTT for management Tx");
 		/*
 		 * Register Tx completion event handler for MGMT Tx over WMI
@@ -5615,8 +5618,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 		WMA_LOGE("FW doesnot support WMI_SERVICE_MGMT_TX_WMI, Use HTT interface for Management Tx");
 	}
 #ifdef WLAN_FEATURE_GTK_OFFLOAD
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_GTK_OFFLOAD)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_gtk_offload)) {
 		status =
 			wmi_unified_register_event_handler(
 					wma_handle->wmi_handle,
@@ -5639,8 +5642,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 		return -EINVAL;
 	}
 
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_RCPI_SUPPORT)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_rcpi_support)) {
 		/* register for rcpi response event */
 		status = wmi_unified_register_event_handler(
 							wma_handle->wmi_handle,
@@ -5662,8 +5665,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 	 * service is not set, then host shall not expect MAC ID from FW in
 	 * VDEV START RESPONSE event and host shall use PDEV ID.
 	 */
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-			WMI_SERVICE_DEPRECATED_REPLACE))
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+			wmi_service_deprecated_replace))
 		wma_handle->wlan_resource_config.use_pdev_id = true;
 	else
 		wma_handle->wlan_resource_config.use_pdev_id = false;
@@ -5685,14 +5688,14 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 	}
 
 	cdp_mark_first_wakeup_packet(soc,
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-			WMI_SERVICE_MARK_FIRST_WAKEUP_PACKET));
+		wmi_service_enabled(wma_handle->wmi_handle,
+			wmi_service_mark_first_wakeup_packet));
 	wma_handle->dfs_cac_offload =
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-			WMI_SERVICE_DFS_PHYERR_OFFLOAD);
+		wmi_service_enabled(wma_handle->wmi_handle,
+			wmi_service_dfs_phyerr_offload);
 	wma_handle->nan_datapath_enabled =
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-			WMI_SERVICE_NAN_DATA);
+		wmi_service_enabled(wma_handle->wmi_handle,
+			wmi_service_nan_data);
 	qdf_mem_copy(target_cap.wmi_service_bitmap,
 		     param_buf->wmi_service_bitmap,
 		     sizeof(wma_handle->wmi_service_bitmap));
@@ -5721,8 +5724,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 	 * this flag is set, then hold off on sending the WMI_INIT message until
 	 * WMI_SERVICE_READY_EXT_EVENTID is received.
 	 */
-	if (!WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				WMI_SERVICE_EXT_MSG)) {
+	if (!wmi_service_enabled(wma_handle->wmi_handle,
+				wmi_service_ext_msg)) {
 		/* No service extended message support.
 		 * Send INIT command immediately
 		 */
@@ -5748,8 +5751,8 @@ int wma_rx_service_ready_event(void *handle, uint8_t *cmd_param_info,
 				__func__);
 	}
 
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_8SS_TX_BFEE))
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_8ss_tx_bfee))
 		wma_handle->tx_bfee_8ss_enabled = true;
 	else
 		wma_handle->tx_bfee_8ss_enabled = false;
@@ -6541,8 +6544,8 @@ int wma_rx_ready_event(void *handle, uint8_t *cmd_param_info,
 	 * event was received
 	 */
 	wma_handle->sub_20_support =
-		WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				WMI_SERVICE_HALF_RATE_QUARTER_RATE_SUPPORT);
+		wmi_service_enabled(wma_handle->wmi_handle,
+				wmi_service_half_rate_quarter_rate_support);
 	wma_handle->wmi_ready = true;
 	wma_handle->wlan_init_status = ev->status;
 

core/wma/src/wma_mgmt.c

@@ -2652,8 +2652,8 @@ void wma_send_probe_rsp_tmpl(tp_wma_handle wma,
 		return;
 	}
 
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				   WMI_SERVICE_BEACON_OFFLOAD)) {
+	if (wmi_service_enabled(wma->wmi_handle,
+				   wmi_service_beacon_offload)) {
 		WMA_LOGD("Beacon Offload Enabled Sending Unified command");
 		if (wmi_unified_probe_rsp_tmpl_send(wma, vdev_id,
 						    probe_rsp_info) < 0) {
@@ -2689,8 +2689,8 @@ void wma_send_beacon(tp_wma_handle wma, tpSendbeaconParams bcn_info)
 		return;
 	}
 
-	if (WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				   WMI_SERVICE_BEACON_OFFLOAD)) {
+	if (wmi_service_enabled(wma->wmi_handle,
+				   wmi_service_beacon_offload)) {
 		WMA_LOGD("Beacon Offload Enabled Sending Unified command");
 		status = wma_unified_bcn_tmpl_send(wma, vdev_id, bcn_info, 4);
 		if (QDF_IS_STATUS_ERROR(status)) {
@@ -3316,8 +3316,8 @@ int wma_process_bip(tp_wma_handle wma_handle,
 
 	switch (iface->key.key_cipher) {
 	case WMI_CIPHER_AES_CMAC:
-		if ((WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-		   WMI_SERVICE_STA_PMF_OFFLOAD))) {
+		if (wmi_service_enabled(wma_handle->wmi_handle,
+				wmi_service_sta_pmf_offload)) {
 			/*
 			 * if 11w offload is enabled then mmie validation is
 			 * performed in firmware, host just need to trim the
@@ -4067,8 +4067,8 @@ QDF_STATUS wma_mgmt_unified_cmd_send(struct wlan_objmgr_vdev *vdev,
 
 	txrx_vdev = wma_handle->interfaces[mgmt_params->vdev_id].handle;
 
-	if (WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				   WMI_SERVICE_MGMT_TX_WMI)) {
+	if (wmi_service_enabled(wma_handle->wmi_handle,
+				   wmi_service_mgmt_tx_wmi)) {
 		status = wmi_mgmt_unified_cmd_send(wma_handle->wmi_handle,
 						   mgmt_params);
 	} else {

core/wma/src/wma_power.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.
  *
@@ -1058,10 +1058,10 @@ QDF_STATUS wma_trigger_uapsd_params(tp_wma_handle wma_handle, uint32_t vdev_id,
 		 trigger_uapsd_params->delay_interval,
 		 trigger_uapsd_params->suspend_interval);
 
-	if (!WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				    WMI_STA_UAPSD_BASIC_AUTO_TRIG) ||
-	    !WMI_SERVICE_IS_ENABLED(wma_handle->wmi_service_bitmap,
-				    WMI_STA_UAPSD_VAR_AUTO_TRIG)) {
+	if (!wmi_service_enabled(wma_handle->wmi_handle,
+				    wmi_sta_uapsd_basic_auto_trig) ||
+	    !wmi_service_enabled(wma_handle->wmi_handle,
+				    wmi_sta_uapsd_var_auto_trig)) {
 		WMA_LOGD("Trigger uapsd is not supported vdev id %d", vdev_id);
 		return QDF_STATUS_SUCCESS;
 	}

core/wma/src/wma_scan_roam.c

@@ -2004,9 +2004,8 @@ QDF_STATUS wma_process_roaming_config(tp_wma_handle wma_handle,
 						   roam_req->sessionId);
 		if (qdf_status != QDF_STATUS_SUCCESS)
 			break;
-		if (WMI_SERVICE_EXT_IS_ENABLED(wma_handle->wmi_service_bitmap,
-					wma_handle->wmi_service_ext_bitmap,
-					WMI_SERVICE_MAWC_SUPPORT)) {
+		if (wmi_service_enabled(wma_handle->wmi_handle,
+					wmi_service_mawc_support)) {
 			qdf_status =
 				wma_roam_scan_mawc_params(wma_handle, roam_req);
 			if (qdf_status != QDF_STATUS_SUCCESS) {
@@ -5199,8 +5198,8 @@ QDF_STATUS wma_start_extscan(tp_wma_handle wma,
 			 __func__);
 		return QDF_STATUS_E_INVAL;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan feature bit not enabled", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -5288,8 +5287,8 @@ QDF_STATUS wma_stop_extscan(tp_wma_handle wma,
 		WMA_LOGE("%s: WMA is closed, cannot issue cmd", __func__);
 		return QDF_STATUS_E_INVAL;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan not enabled", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -5409,8 +5408,8 @@ QDF_STATUS wma_extscan_stop_hotlist_monitor(tp_wma_handle wma,
 		WMA_LOGE("%s: Invalid reset hotlist buffer", __func__);
 		return QDF_STATUS_E_INVAL;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan not enabled", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -5577,8 +5576,8 @@ QDF_STATUS wma_extscan_stop_change_monitor(tp_wma_handle wma,
 		WMA_LOGE("%s: WMA is closed, can not issue  cmd", __func__);
 		return QDF_STATUS_E_INVAL;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_extscan)) {
 		WMA_LOGE("%s: ext scan not enabled", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -5609,8 +5608,8 @@ QDF_STATUS wma_extscan_get_cached_results(tp_wma_handle wma,
 		WMA_LOGE("%s: WMA is closed, cannot issue cmd", __func__);
 		return QDF_STATUS_E_INVAL;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan not enabled", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -5642,8 +5641,8 @@ QDF_STATUS wma_extscan_get_capabilities(tp_wma_handle wma,
 		WMA_LOGE("%s: WMA is closed, can not issue  cmd", __func__);
 		return QDF_STATUS_E_INVAL;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				    WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+				    wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan not enabled", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
@@ -5670,10 +5669,10 @@ QDF_STATUS  wma_ipa_offload_enable_disable(tp_wma_handle wma,
 		return QDF_STATUS_E_INVAL;
 	}
 
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
+	if (!wmi_service_enabled(wma->wmi_handle,
 			((ipa_offload->offload_type == AP_RX_DATA_OFFLOAD) ?
-			WMI_SERVICE_HSOFFLOAD :
-			WMI_SERVICE_STA_RX_IPA_OFFLOAD_SUPPORT))) {
+			wmi_service_hsoffload :
+			wmi_service_sta_rx_ipa_offload_support))) {
 		WMA_LOGE("%s: %s not supported", __func__,
 			((ipa_offload->offload_type == AP_RX_DATA_OFFLOAD) ?
 			"WMI_SERVICE_HSOFFLOAD" :
@@ -5751,8 +5750,8 @@ QDF_STATUS wma_set_epno_network_list(tp_wma_handle wma,
 		WMA_LOGE("%s: WMA is closed, can not issue cmd", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-			WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+			wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan not enabled", __func__);
 		return QDF_STATUS_E_NOSUPPORT;
 	}
@@ -5828,8 +5827,8 @@ QDF_STATUS wma_set_passpoint_network_list(tp_wma_handle wma,
 		WMA_LOGE("%s: WMA is closed, can not issue cmd", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-			WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+			wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan not enabled", __func__);
 		return QDF_STATUS_E_NOSUPPORT;
 	}
@@ -5894,8 +5893,8 @@ QDF_STATUS wma_reset_passpoint_network_list(tp_wma_handle wma,
 		WMA_LOGE("%s: WMA is closed, can not issue cmd", __func__);
 		return QDF_STATUS_E_FAILURE;
 	}
-	if (!WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-			WMI_SERVICE_EXTSCAN)) {
+	if (!wmi_service_enabled(wma->wmi_handle,
+			wmi_service_extscan)) {
 		WMA_LOGE("%s: extscan not enabled", __func__);
 		return QDF_STATUS_E_NOSUPPORT;
 	}

core/wma/src/wma_utils.c

@@ -4211,8 +4211,8 @@ bool wma_is_csa_offload_enabled(void)
 	if (!wma)
 		return false;
 
-	return WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap,
-				   WMI_SERVICE_CSA_OFFLOAD);
+	return wmi_service_enabled(wma->wmi_handle,
+				   wmi_service_csa_offload);
 }
 /**
  * wma_config_debug_module_cmd - set debug log config
@@ -4250,12 +4250,12 @@ wma_config_debug_module_cmd(wmi_unified_t wmi_handle, A_UINT32 param,
  */
 bool wma_is_p2p_lo_capable(void)
 {
-	return wma_is_service_enabled(WMI_SERVICE_P2P_LISTEN_OFFLOAD_SUPPORT);
+	return wma_is_service_enabled(wmi_service_p2p_listen_offload_support);
 }
 
 bool wma_capability_enhanced_mcast_filter(void)
 {
-	return wma_is_service_enabled(WMI_SERVICE_ENHANCED_MCAST_FILTER);
+	return wma_is_service_enabled(wmi_service_enhanced_mcast_filter);
 }
 
 
@@ -4444,7 +4444,7 @@ int wma_rcpi_event_handler(void *handle, uint8_t *cmd_param_info,
 	return 0;
 }
 
-bool wma_is_service_enabled(WMI_SERVICE service_type)
+bool wma_is_service_enabled(uint32_t service_type)
 {
 	tp_wma_handle wma;
 
@@ -4459,7 +4459,7 @@ bool wma_is_service_enabled(WMI_SERVICE service_type)
 		return false;
 	}
 
-	return WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap, service_type);
+	return wmi_service_enabled(wma->wmi_handle, service_type);
 }
 
 QDF_STATUS wma_send_vdev_up_to_fw(t_wma_handle *wma,