qcacld-3.0: HDD change for policy manager restructuring part 3

Modify HDD code to cope with the policy manager moving to host
common.

Change-Id: I21fe97b9ba924ede1040a4bcc56313f1101b59f2
CRs-Fixed: 2009818

core/hdd/src/wlan_hdd_hostapd.c

@@ -73,7 +73,7 @@
 #include "qdf_types.h"
 #include "qdf_trace.h"
 #include "wlan_hdd_cfg.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include "wlan_hdd_tsf.h"
 #include "wlan_hdd_green_ap.h"
 #include <cdp_txrx_misc.h>
@@ -514,6 +514,7 @@ static void hdd_hostapd_inactivity_timer_cb(void *context)
 	QDF_STATUS qdf_status;
 	hdd_adapter_t *pHostapdAdapter;
 	hdd_ap_ctx_t *pHddApCtx;
+	hdd_context_t *hdd_ctx;
 #endif /* DISABLE_CONCURRENCY_AUTOSAVE */
 
 	/* event_name space-delimiter driver_module_name
@@ -527,7 +528,8 @@ static void hdd_hostapd_inactivity_timer_cb(void *context)
 	ENTER_DEV(dev);
 
 #ifdef DISABLE_CONCURRENCY_AUTOSAVE
-	if (cds_concurrent_open_sessions_running()) {
+	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
+	if (policy_mgr_concurrent_open_sessions_running(hdd_ctx->hdd_psoc)) {
 		/*
 		 * This timer routine is going to be called only when AP
 		 * persona is up.
@@ -612,8 +614,9 @@ static int hdd_stop_bss_link(hdd_adapter_t *pHostapdAdapter,
 			hdd_err("Deleting SAP/P2P link!!!!!!");
 
 		clear_bit(SOFTAP_BSS_STARTED, &pHostapdAdapter->event_flags);
-		cds_decr_session_set_pcl(pHostapdAdapter->device_mode,
-					     pHostapdAdapter->sessionId);
+		policy_mgr_decr_session_set_pcl(pHddCtx->hdd_psoc,
+					pHostapdAdapter->device_mode,
+					pHostapdAdapter->sessionId);
 	}
 	EXIT();
 	return (status == QDF_STATUS_SUCCESS) ? 0 : -EBUSY;
@@ -1280,13 +1283,15 @@ QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 		/* Send SCC/MCC Switching event to IPA */
 		hdd_ipa_send_mcc_scc_msg(pHddCtx, pHddCtx->mcc_mode);
 
-		if (cds_is_hw_mode_change_after_vdev_up()) {
+		if (policy_mgr_is_hw_mode_change_after_vdev_up(
+			pHddCtx->hdd_psoc)) {
 			hdd_info("check for possible hw mode change");
-			status = cds_set_hw_mode_on_channel_switch(
-					pHostapdAdapter->sessionId);
+			status = policy_mgr_set_hw_mode_on_channel_switch(
+				pHddCtx->hdd_psoc, pHostapdAdapter->sessionId);
 			if (QDF_IS_STATUS_ERROR(status))
 				hdd_info("set hw mode change not done");
-			cds_set_do_hw_mode_change_flag(false);
+			policy_mgr_set_do_hw_mode_change_flag(
+					pHddCtx->hdd_psoc, false);
 		}
 		/*
 		 * set this event at the very end because once this events
@@ -1784,7 +1789,9 @@ QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 				 bytes[0], GFP_KERNEL);
 
 		/* Update the beacon Interval if it is P2P GO */
-		qdf_status = cds_change_mcc_go_beacon_interval(pHostapdAdapter);
+		qdf_status = policy_mgr_change_mcc_go_beacon_interval(
+			pHddCtx->hdd_psoc, pHostapdAdapter->sessionId,
+			pHostapdAdapter->device_mode);
 		if (QDF_STATUS_SUCCESS != qdf_status) {
 			hdd_err("failed to update Beacon interval %d",
 				qdf_status);
@@ -2112,7 +2119,8 @@ stopbss:
 		we_custom_event_generic = we_custom_event;
 		wireless_send_event(dev, we_event, &wrqu,
 				    (char *)we_custom_event_generic);
-		cds_decr_session_set_pcl(pHostapdAdapter->device_mode,
+		policy_mgr_decr_session_set_pcl(pHddCtx->hdd_psoc,
+					 pHostapdAdapter->device_mode,
 					 pHostapdAdapter->sessionId);
 
 		/* once the event is set, structure dev/pHostapdAdapter should
@@ -2858,7 +2866,7 @@ static __iw_softap_setparam(struct net_device *dev,
 	}
 	case QCSAP_PARAM_SET_MCC_CHANNEL_LATENCY:
 	{
-		cds_set_mcc_latency(pHostapdAdapter, set_value);
+		wlan_hdd_set_mcc_latency(pHostapdAdapter, set_value);
 		break;
 	}
 
@@ -2866,7 +2874,7 @@ static __iw_softap_setparam(struct net_device *dev,
 	{
 		hdd_notice("iwpriv cmd to set MCC quota value %dms",
 		       set_value);
-		ret = cds_go_set_mcc_p2p_quota(pHostapdAdapter,
+		ret = wlan_hdd_go_set_mcc_p2p_quota(pHostapdAdapter,
 						    set_value);
 		break;
 	}
@@ -4862,7 +4870,8 @@ __iw_softap_stopbss(struct net_device *dev,
 			}
 		}
 		clear_bit(SOFTAP_BSS_STARTED, &pHostapdAdapter->event_flags);
-		cds_decr_session_set_pcl(pHostapdAdapter->device_mode,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+					     pHostapdAdapter->device_mode,
 					     pHostapdAdapter->sessionId);
 		ret = qdf_status_to_os_return(status);
 	}
@@ -6077,9 +6086,10 @@ hdd_adapter_t *hdd_wlan_create_ap_dev(hdd_context_t *pHddCtx,
 		pHostapdAdapter->sessionId = HDD_SESSION_ID_INVALID;
 
 		hdd_info("pWlanHostapdDev = %p, pHostapdAdapter = %p, concurrency_mode=0x%x",
-		       pWlanHostapdDev,
-		       pHostapdAdapter,
-		       (int)cds_get_concurrency_mode());
+			pWlanHostapdDev,
+			pHostapdAdapter,
+			(int)policy_mgr_get_concurrency_mode(
+			pHddCtx->hdd_psoc));
 
 		/* Init the net_device structure */
 		strlcpy(pWlanHostapdDev->name, (const char *)iface_name,
@@ -7314,8 +7324,9 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 		return -EINVAL;
 	}
 
-	if (cds_is_hw_mode_change_in_progress()) {
-		status = qdf_wait_for_connection_update();
+	if (policy_mgr_is_hw_mode_change_in_progress(pHddCtx->hdd_psoc)) {
+		status = policy_mgr_wait_for_connection_update(
+			pHddCtx->hdd_psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("qdf wait for event failed!!");
 			return -EINVAL;
@@ -7798,8 +7809,8 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 	}
 
 	if (check_for_concurrency) {
-		if (!cds_allow_concurrency(
-					cds_convert_device_mode_to_qdf_type(
+		if (!policy_mgr_allow_concurrency(pHddCtx->hdd_psoc,
+				policy_mgr_convert_device_mode_to_qdf_type(
 					pHostapdAdapter->device_mode),
 					pConfig->channel, HW_MODE_20_MHZ)) {
 			hdd_warn("This concurrency combination is not allowed");
@@ -7854,7 +7865,8 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 	/* Initialize WMM configuation */
 	hdd_wmm_init(pHostapdAdapter);
 	if (pHostapdState->bssState == BSS_START)
-		cds_incr_active_session(pHostapdAdapter->device_mode,
+		policy_mgr_incr_active_session(pHddCtx->hdd_psoc,
+					pHostapdAdapter->device_mode,
 					pHostapdAdapter->sessionId);
 #ifdef DHCP_SERVER_OFFLOAD
 	if (iniConfig->enableDHCPServerOffload)
@@ -8039,7 +8051,8 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
 		}
 		clear_bit(SOFTAP_BSS_STARTED, &pAdapter->event_flags);
 		/*BSS stopped, clear the active sessions for this device mode*/
-		cds_decr_session_set_pcl(pAdapter->device_mode,
+		policy_mgr_decr_session_set_pcl(pHddCtx->hdd_psoc,
+						pAdapter->device_mode,
 						pAdapter->sessionId);
 		pAdapter->sessionCtx.ap.beacon = NULL;
 		qdf_mem_free(old);
@@ -8196,8 +8209,9 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 		return -EBUSY;
 	}
 
-	if (cds_is_hw_mode_change_in_progress()) {
-		status = qdf_wait_for_connection_update();
+	if (policy_mgr_is_hw_mode_change_in_progress(pHddCtx->hdd_psoc)) {
+		status = policy_mgr_wait_for_connection_update(
+			pHddCtx->hdd_psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("qdf wait for event failed!!");
 			return -EINVAL;
@@ -8245,8 +8259,8 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 	}
 
 	/* check if concurrency is allowed */
-	if (!cds_allow_concurrency(
-				cds_convert_device_mode_to_qdf_type(
+	if (!policy_mgr_allow_concurrency(pHddCtx->hdd_psoc,
+				policy_mgr_convert_device_mode_to_qdf_type(
 				pAdapter->device_mode),
 				channel,
 				channel_width)) {
@@ -8254,12 +8268,12 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 		return -EINVAL;
 	}
 
-	status = qdf_reset_connection_update();
+	status = policy_mgr_reset_connection_update(pHddCtx->hdd_psoc);
 	if (!QDF_IS_STATUS_SUCCESS(status))
 		hdd_err("ERR: clear event failed");
 
-	status = cds_current_connections_update(pAdapter->sessionId,
-			channel,
+	status = policy_mgr_current_connections_update(pHddCtx->hdd_psoc,
+			pAdapter->sessionId, channel,
 			SIR_UPDATE_REASON_START_AP);
 	if (QDF_STATUS_E_FAILURE == status) {
 		hdd_err("ERROR: connections update failed!!");
@@ -8267,7 +8281,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 	}
 
 	if (QDF_STATUS_SUCCESS == status) {
-		status = qdf_wait_for_connection_update();
+		status = policy_mgr_wait_for_connection_update(pHddCtx->hdd_psoc);
 		if (!QDF_IS_STATUS_SUCCESS(status)) {
 			hdd_err("ERROR: qdf wait for event failed!!");
 			return -EINVAL;

core/hdd/src/wlan_hdd_ioctl.c

@@ -34,7 +34,7 @@
 #include "wlan_hdd_power.h"
 #include "wlan_hdd_request_manager.h"
 #include "wlan_hdd_driver_ops.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include "wlan_hdd_hostapd.h"
 #include "scheduler_api.h"
 
@@ -4698,8 +4698,8 @@ static int drv_cmd_miracast(hdd_adapter_t *adapter,
 		return -EBUSY;
 	}
 
-	if (cds_is_mcc_in_24G())
-		return cds_set_mas(adapter, filterType);
+	if (policy_mgr_is_mcc_in_24G(hdd_ctx->hdd_psoc))
+		return wlan_hdd_set_mas(adapter, filterType);
 
 exit:
 	return ret;
@@ -6747,7 +6747,8 @@ static int drv_cmd_set_antenna_mode(hdd_adapter_t *adapter,
 
 	/* Check TDLS status and update antenna mode */
 	if ((QDF_STA_MODE == adapter->device_mode) &&
-	    cds_is_sta_active_connection_exists()) {
+		policy_mgr_is_sta_active_connection_exists(
+		hdd_ctx->hdd_psoc)) {
 		ret = wlan_hdd_tdls_antenna_switch(hdd_ctx, adapter,
 						   mode);
 		if (0 != ret)

core/hdd/src/wlan_hdd_lpass.c

@@ -85,7 +85,7 @@ static int wlan_hdd_gen_wlan_status_pack(struct wlan_status_data *data,
 	else
 		data->lpss_support = 0;
 	data->numChannels = WLAN_SVC_MAX_NUM_CHAN;
-	sme_get_cfg_valid_channels(hdd_ctx->hHal, data->channel_list,
+	sme_get_cfg_valid_channels(data->channel_list,
 				   &data->numChannels);
 	sme_get_country_code(hdd_ctx->hHal, data->country_code, &buflen);
 	data->is_on = is_on;

core/hdd/src/wlan_hdd_main.c

@@ -97,7 +97,7 @@
 #include <wlan_hdd_ipa.h>
 #include "hif.h"
 #include "wma.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include "wlan_hdd_tsf.h"
 #include "wlan_hdd_green_ap.h"
 #include "bmi.h"
@@ -3700,7 +3700,8 @@ hdd_adapter_t *hdd_open_adapter(hdd_context_t *hdd_ctx, uint8_t session_type,
 	}
 
 	if (QDF_STATUS_SUCCESS == status) {
-		cds_set_concurrency_mode(session_type);
+		policy_mgr_set_concurrency_mode(hdd_ctx->hdd_psoc,
+			session_type);
 
 		/* Initialize the WoWL service */
 		if (!hdd_init_wowl(adapter)) {
@@ -3755,7 +3756,8 @@ QDF_STATUS hdd_close_adapter(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter,
 	if (QDF_STATUS_SUCCESS == status) {
 		hdd_info("wait for bus bw work to flush");
 		cancel_work_sync(&hdd_ctx->bus_bw_work);
-		cds_clear_concurrency_mode(adapter->device_mode);
+		policy_mgr_clear_concurrency_mode(hdd_ctx->hdd_psoc,
+			adapter->device_mode);
 		hdd_cleanup_adapter(hdd_ctx, adapterNode->pAdapter, rtnl_held);
 
 		hdd_remove_adapter(hdd_ctx, adapterNode);
@@ -3985,9 +3987,9 @@ QDF_STATUS hdd_stop_adapter(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter,
 				hdd_err("failure in wlansap_stop_bss");
 			}
 			clear_bit(SOFTAP_BSS_STARTED, &adapter->event_flags);
-			cds_decr_session_set_pcl(
-						     adapter->device_mode,
-							adapter->sessionId);
+			policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+						adapter->device_mode,
+						adapter->sessionId);
 
 			qdf_copy_macaddr(&updateIE.bssid,
 					 &adapter->macAddressCurrent);
@@ -4117,8 +4119,8 @@ QDF_STATUS hdd_reset_all_adapters(hdd_context_t *hdd_ctx)
 		adapter->sessionCtx.station.hdd_ReassocScenario = false;
 
 		hdd_deinit_tx_rx(adapter);
-		cds_decr_session_set_pcl(adapter->device_mode,
-						adapter->sessionId);
+		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+				adapter->device_mode, adapter->sessionId);
 		if (test_bit(WMM_INIT_DONE, &adapter->event_flags)) {
 			hdd_wmm_adapter_close(adapter);
 			clear_bit(WMM_INIT_DONE, &adapter->event_flags);
@@ -6415,8 +6417,8 @@ static uint8_t hdd_get_safe_channel_from_pcl_and_acs_range(
 		return INVALID_CHANNEL_ID;
 	}
 
-	status = cds_get_pcl_for_existing_conn(CDS_SAP_MODE,
-			pcl.pcl_list, &pcl.pcl_len,
+	status = policy_mgr_get_pcl_for_existing_conn(hdd_ctx->hdd_psoc,
+			PM_SAP_MODE, pcl.pcl_list, &pcl.pcl_len,
 			pcl.weight_list, QDF_ARRAY_SIZE(pcl.weight_list));
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("Get PCL failed");
@@ -6448,7 +6450,7 @@ static uint8_t hdd_get_safe_channel_from_pcl_and_acs_range(
 
 	/* Try for safe channel from all valid channel */
 	pcl.pcl_len = MAX_NUM_CHAN;
-	status = sme_get_cfg_valid_channels(hal_handle, pcl.pcl_list,
+	status = sme_get_cfg_valid_channels(pcl.pcl_list,
 					&pcl.pcl_len);
 	if (QDF_IS_STATUS_ERROR(status)) {
 		hdd_err("error in getting valid channel list");
@@ -6496,6 +6498,7 @@ void hdd_switch_sap_channel(hdd_adapter_t *adapter, uint8_t channel)
 {
 	hdd_ap_ctx_t *hdd_ap_ctx;
 	tHalHandle *hal_handle;
+	hdd_context_t *hdd_ctx;
 
 	if (!adapter) {
 		hdd_err("invalid adapter");
@@ -6510,6 +6513,8 @@ void hdd_switch_sap_channel(hdd_adapter_t *adapter, uint8_t channel)
 		return;
 	}
 
+	hdd_ctx = WLAN_HDD_GET_CTX(adapter);
+
 	hdd_ap_ctx->sapConfig.channel = channel;
 	hdd_ap_ctx->sapConfig.ch_params.ch_width =
 		hdd_ap_ctx->sapConfig.ch_width_orig;
@@ -6521,7 +6526,9 @@ void hdd_switch_sap_channel(hdd_adapter_t *adapter, uint8_t channel)
 			hdd_ap_ctx->sapConfig.sec_ch,
 			&hdd_ap_ctx->sapConfig.ch_params);
 
-	cds_change_sap_channel_with_csa(adapter, hdd_ap_ctx);
+	policy_mgr_change_sap_channel_with_csa(hdd_ctx->hdd_psoc,
+		adapter->sessionId, channel,
+		hdd_ap_ctx->sapConfig.ch_width_orig);
 }
 
 int hdd_update_acs_timer_reason(hdd_adapter_t *adapter, uint8_t reason)
@@ -6977,7 +6984,7 @@ void hdd_acs_response_timeout_handler(void *context)
  */
 static QDF_STATUS wlan_hdd_disable_all_dual_mac_features(hdd_context_t *hdd_ctx)
 {
-	struct sir_dual_mac_config cfg;
+	struct policy_mgr_dual_mac_config cfg = {0};
 	QDF_STATUS status;
 
 	if (!hdd_ctx) {
@@ -6987,11 +6994,11 @@ static QDF_STATUS wlan_hdd_disable_all_dual_mac_features(hdd_context_t *hdd_ctx)
 
 	cfg.scan_config = 0;
 	cfg.fw_mode_config = 0;
-	cfg.set_dual_mac_cb = cds_soc_set_dual_mac_cfg_cb;
+	cfg.set_dual_mac_cb = policy_mgr_soc_set_dual_mac_cfg_cb;
 
 	hdd_debug("Disabling all dual mac features...");
 
-	status = sme_soc_set_dual_mac_config(hdd_ctx->hHal, cfg);
+	status = sme_soc_set_dual_mac_config(cfg);
 	if (status != QDF_STATUS_SUCCESS) {
 		hdd_err("sme_soc_set_dual_mac_config failed %d", status);
 		return status;
@@ -8015,8 +8022,15 @@ int hdd_pktlog_enable_disable(hdd_context_t *hdd_ctx, bool enable,
 QDF_STATUS hdd_register_for_sap_restart_with_channel_switch(void)
 {
 	QDF_STATUS status;
+	hdd_context_t *hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+	if (!hdd_ctx) {
+		hdd_err("hdd ctx is NULL");
+		return QDF_STATUS_E_FAILURE;
+	}
+
 
-	status = cds_register_sap_restart_channel_switch_cb(
+	status = policy_mgr_register_sap_restart_channel_switch_cb(
+			hdd_ctx->hdd_psoc,
 			(void *)hdd_sap_restart_with_channel_switch);
 	if (!QDF_IS_STATUS_SUCCESS(status))
 		hdd_err("restart cb registration failed");
@@ -8592,8 +8606,6 @@ int hdd_configure_cds(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter)
 {
 	int ret;
 	QDF_STATUS status;
-	/* structure of function pointers to be used by CDS */
-	struct cds_sme_cbacks sme_cbacks;
 
 	ret = hdd_pre_enable_configure(hdd_ctx);
 	if (ret) {
@@ -8638,19 +8650,9 @@ int hdd_configure_cds(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter)
 	if (ret)
 		goto cds_disable;
 
-	sme_cbacks.sme_get_valid_channels = sme_get_cfg_valid_channels;
-	sme_cbacks.sme_get_nss_for_vdev = sme_get_vdev_type_nss;
-	status = cds_init_policy_mgr(&sme_cbacks);
-	if (!QDF_IS_STATUS_SUCCESS(status)) {
-		hdd_err("Policy manager initialization failed");
-		goto hdd_features_deinit;
-	}
 
 	return 0;
 
-hdd_features_deinit:
-	hdd_deregister_cb(hdd_ctx);
-	wlan_hdd_cfg80211_deregister_frames(adapter);
 cds_disable:
 	cds_disable(hdd_ctx->hdd_psoc, hdd_ctx->pcds_context);
 
@@ -8675,13 +8677,6 @@ static int hdd_deconfigure_cds(hdd_context_t *hdd_ctx)
 	/* De-register the SME callbacks */
 	hdd_deregister_cb(hdd_ctx);
 
-	/* De-init Policy Manager */
-	if (!QDF_IS_STATUS_SUCCESS(cds_deinit_policy_mgr())) {
-		hdd_err("Failed to deinit policy manager");
-		/* Proceed and complete the clean up */
-		ret = -EINVAL;
-	}
-
 	qdf_status = cds_disable(hdd_ctx->hdd_psoc, hdd_ctx->pcds_context);
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hdd_err("Failed to Disable the CDS Modules! :%d",
@@ -9152,7 +9147,8 @@ int hdd_register_cb(hdd_context_t *hdd_ctx)
 	sme_ext_scan_register_callback(hdd_ctx->hHal,
 				       wlan_hdd_cfg80211_extscan_callback);
 
-	status = cds_register_sap_restart_channel_switch_cb(
+	status = policy_mgr_register_sap_restart_channel_switch_cb(
+			hdd_ctx->hdd_psoc,
 			(void *)hdd_sap_restart_with_channel_switch);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		hdd_err("restart cb registration failed");
@@ -9175,7 +9171,8 @@ int hdd_register_cb(hdd_context_t *hdd_ctx)
 	wlan_hdd_dcc_register_for_dcc_stats_event(hdd_ctx);
 
 	sme_register_set_connection_info_cb(hdd_ctx->hHal,
-				hdd_set_connection_in_progress);
+				hdd_set_connection_in_progress,
+				hdd_is_connection_in_progress);
 	EXIT();
 
 	return ret;
@@ -9203,7 +9200,8 @@ void hdd_deregister_cb(hdd_context_t *hdd_ctx)
 	sme_reset_link_layer_stats_ind_cb(hdd_ctx->hHal);
 	sme_reset_rssi_threshold_breached_cb(hdd_ctx->hHal);
 
-	status = cds_deregister_sap_restart_channel_switch_cb();
+	status = policy_mgr_deregister_sap_restart_channel_switch_cb(
+		hdd_ctx->hdd_psoc);
 	if (!QDF_IS_STATUS_SUCCESS(status))
 		hdd_err("De-register restart cb registration failed: %d",
 			status);
@@ -9329,9 +9327,10 @@ void wlan_hdd_disable_roaming(hdd_adapter_t *adapter)
 	QDF_STATUS status;
 
 	if (hdd_ctx->config->isFastRoamIniFeatureEnabled &&
-	    hdd_ctx->config->isRoamOffloadScanEnabled &&
-	    QDF_STA_MODE == adapter->device_mode &&
-	    cds_is_sta_active_connection_exists()) {
+		hdd_ctx->config->isRoamOffloadScanEnabled &&
+		QDF_STA_MODE == adapter->device_mode &&
+		policy_mgr_is_sta_active_connection_exists(
+		hdd_ctx->hdd_psoc)) {
 		hdd_notice("Connect received on STA sessionId(%d)",
 		       adapter->sessionId);
 		/*
@@ -9380,9 +9379,10 @@ void wlan_hdd_enable_roaming(hdd_adapter_t *adapter)
 	QDF_STATUS status;
 
 	if (hdd_ctx->config->isFastRoamIniFeatureEnabled &&
-	    hdd_ctx->config->isRoamOffloadScanEnabled &&
-	    QDF_STA_MODE == adapter->device_mode &&
-	    cds_is_sta_active_connection_exists()) {
+		hdd_ctx->config->isRoamOffloadScanEnabled &&
+		QDF_STA_MODE == adapter->device_mode &&
+		policy_mgr_is_sta_active_connection_exists(
+		hdd_ctx->hdd_psoc)) {
 		hdd_notice("Disconnect received on STA sessionId(%d)",
 		       adapter->sessionId);
 		/*
@@ -9558,7 +9558,8 @@ void wlan_hdd_auto_shutdown_enable(hdd_context_t *hdd_ctx, bool enable)
 	}
 
 	/* To enable shutdown timer check conncurrency */
-	if (cds_concurrent_open_sessions_running()) {
+	if (policy_mgr_concurrent_open_sessions_running(
+		hdd_ctx->hdd_psoc)) {
 		status = hdd_get_front_adapter(hdd_ctx, &adapterNode);
 
 		while (NULL != adapterNode && QDF_STATUS_SUCCESS == status) {
@@ -9669,7 +9670,8 @@ void hdd_stop_bus_bw_compute_timer(hdd_adapter_t *adapter)
 	}
 	qdf_spinlock_release(&hdd_ctx->bus_bw_timer_lock);
 
-	if (cds_concurrent_open_sessions_running()) {
+	if (policy_mgr_concurrent_open_sessions_running(
+		hdd_ctx->hdd_psoc)) {
 		status = hdd_get_front_adapter(hdd_ctx, &adapterNode);
 
 		while (NULL != adapterNode && QDF_STATUS_SUCCESS == status) {
@@ -9815,7 +9817,8 @@ void wlan_hdd_stop_sap(hdd_adapter_t *ap_adapter)
 			}
 		}
 		clear_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
-		cds_decr_session_set_pcl(ap_adapter->device_mode,
+		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
+						ap_adapter->device_mode,
 						ap_adapter->sessionId);
 		hdd_info("SAP Stop Success");
 	} else {
@@ -9883,7 +9886,8 @@ void wlan_hdd_start_sap(hdd_adapter_t *ap_adapter, bool reinit)
 	hdd_info("SAP Start Success");
 	set_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
 	if (hostapd_state->bssState == BSS_START)
-		cds_incr_active_session(ap_adapter->device_mode,
+		policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
+					ap_adapter->device_mode,
 					ap_adapter->sessionId);
 	hostapd_state->bCommit = true;
 
@@ -10985,7 +10989,7 @@ bool hdd_is_connection_in_progress(uint8_t *session_id,
 				adapter->sessionId);
 			if (session_id && reason) {
 				*session_id = adapter->sessionId;
-				*reason = eHDD_CONNECTION_IN_PROGRESS;
+				*reason = CONNECTION_IN_PROGRESS;
 			}
 			return true;
 		}
@@ -10998,7 +11002,7 @@ bool hdd_is_connection_in_progress(uint8_t *session_id,
 				adapter->sessionId);
 			if (session_id && reason) {
 				*session_id = adapter->sessionId;
-				*reason = eHDD_REASSOC_IN_PROGRESS;
+				*reason = REASSOC_IN_PROGRESS;
 			}
 			return true;
 		}
@@ -11018,7 +11022,7 @@ bool hdd_is_connection_in_progress(uint8_t *session_id,
 					MAC_ADDR_ARRAY(sta_mac));
 				if (session_id && reason) {
 					*session_id = adapter->sessionId;
-					*reason = eHDD_EAPOL_IN_PROGRESS;
+					*reason = EAPOL_IN_PROGRESS;
 				}
 				return true;
 			}
@@ -11039,7 +11043,7 @@ bool hdd_is_connection_in_progress(uint8_t *session_id,
 				MAC_ADDR_ARRAY(sta_mac));
 				if (session_id && reason) {
 					*session_id = adapter->sessionId;
-					*reason = eHDD_SAP_EAPOL_IN_PROGRESS;
+					*reason = SAP_EAPOL_IN_PROGRESS;
 				}
 				return true;
 			}
@@ -11092,7 +11096,7 @@ void hdd_restart_sap(hdd_adapter_t *ap_adapter)
 			}
 		}
 		clear_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
-		cds_decr_session_set_pcl(
+		policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
 			ap_adapter->device_mode, ap_adapter->sessionId);
 		cds_err("SAP Stop Success");
 
@@ -11126,7 +11130,8 @@ void hdd_restart_sap(hdd_adapter_t *ap_adapter)
 		cds_err("SAP Start Success");
 		set_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
 		if (hostapd_state->bssState == BSS_START)
-			cds_incr_active_session(ap_adapter->device_mode,
+			policy_mgr_incr_active_session(hdd_ctx->hdd_psoc,
+						ap_adapter->device_mode,
 						ap_adapter->sessionId);
 		hostapd_state->bCommit = true;
 	}
@@ -11161,7 +11166,8 @@ void hdd_check_and_restart_sap_with_non_dfs_acs(void)
 		return;
 	}
 
-	if (cds_get_concurrency_mode() != (QDF_STA_MASK | QDF_SAP_MASK)) {
+	if (policy_mgr_get_concurrency_mode(hdd_ctx->hdd_psoc)
+		!= (QDF_STA_MASK | QDF_SAP_MASK)) {
 		cds_info("Concurrency mode is not SAP");
 		return;
 	}
@@ -11179,7 +11185,7 @@ void hdd_check_and_restart_sap_with_non_dfs_acs(void)
 		ap_adapter->sessionCtx.ap.sapConfig.
 			acs_cfg.acs_mode = true;
 
-		cds_restart_sap(ap_adapter);
+		hdd_restart_sap(ap_adapter);
 	}
 }
 

core/hdd/src/wlan_hdd_oemdata.c

@@ -100,7 +100,7 @@ static int populate_oem_data_cap(hdd_adapter_t *adapter,
 
 	/* request for max num of channels */
 	num_chan = OEM_CAP_MAX_NUM_CHANNELS;
-	status = sme_get_cfg_valid_channels(hdd_ctx->hHal,
+	status = sme_get_cfg_valid_channels(
 					    &chan_list[0], &num_chan);
 	if (QDF_STATUS_SUCCESS != status) {
 		hdd_err("failed to get valid channel list, status: %d", status);

core/hdd/src/wlan_hdd_p2p.c

@@ -51,7 +51,7 @@
 #include "qdf_types.h"
 #include "qdf_trace.h"
 #include "cds_sched.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include "cds_utils.h"
 
 #ifdef CONVERGED_P2P_ENABLE

core/hdd/src/wlan_hdd_power.c

@@ -73,7 +73,7 @@
 #include <ol_txrx_osif_api.h>
 #include "hif.h"
 #include "sme_power_save_api.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include "cdp_txrx_flow_ctrl_v2.h"
 #include "pld_common.h"
 #include "wlan_hdd_driver_ops.h"
@@ -1268,7 +1268,7 @@ QDF_STATUS hdd_wlan_shutdown(void)
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	cds_clear_concurrent_session_count();
+	policy_mgr_clear_concurrent_session_count(pHddCtx->hdd_psoc);
 
 	hdd_info("Invoking packetdump deregistration API");
 	wlan_deregister_txrx_packetdump();

core/hdd/src/wlan_hdd_scan.c

@@ -43,7 +43,7 @@
 #include "wlan_hdd_p2p.h"
 #include "wlan_hdd_trace.h"
 #include "wlan_hdd_scan.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include "wma_api.h"
 #include "cds_utils.h"
 
@@ -1548,7 +1548,8 @@ static int __wlan_hdd_cfg80211_scan(struct wiphy *wiphy,
 			con_dfs_ch =
 				con_sap_adapter->sessionCtx.ap.operatingChannel;
 
-		if (!wma_is_hw_dbs_capable() && CDS_IS_DFS_CH(con_dfs_ch)) {
+		if (!policy_mgr_is_hw_dbs_capable(pHddCtx->hdd_psoc)
+			&& CDS_IS_DFS_CH(con_dfs_ch)) {
 			/* Provide empty scan result during DFS operation since
 			 * scanning not supported during DFS. Reason is
 			 * following case:

core/hdd/src/wlan_hdd_tdls.c

@@ -47,9 +47,9 @@
 #include "sme_api.h"
 #include "cds_sched.h"
 #include "wma_types.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include <qca_vendor.h>
-
+#include "wlan_hdd_ipa.h"
 
 static int32_t wlan_hdd_tdls_peer_reset_discovery_processed(tdlsCtx_t *
 							    pHddTdlsCtx);

core/hdd/src/wlan_hdd_wext.c

@@ -80,7 +80,7 @@
 #include "wlan_hdd_ioctl.h"
 #include "wlan_hdd_scan.h"
 #include "sme_power_save_api.h"
-#include "cds_concurrency.h"
+#include "wlan_policy_mgr_api.h"
 #include "wlan_hdd_conc_ut.h"
 #include "wlan_hdd_tsf.h"
 #include "wlan_hdd_ocb.h"
@@ -2241,7 +2241,7 @@ static const hdd_freq_chan_map_t freq_chan_map[] = {
  * @INPUT: dbs, system_pref
  * @dbs: Value of DBS capability to be set
  * @system_pref: System preference
- *     0:CDS_THROUGHPUT 1: CDS_POWERSAVE 2: CDS_LATENCY
+ *     0:PM_THROUGHPUT 1: PM_POWERSAVE 2: PM_LATENCY
  *
  * @OUTPUT: None
  *
@@ -2262,15 +2262,15 @@ static const hdd_freq_chan_map_t freq_chan_map[] = {
  * <ioctl>
  * pm_pcl - Set pcl for concurrency mode.
  *
- * @INPUT: cds_con_mode
- * @cds_con_mode: concurrency mode for PCL table
+ * @INPUT: policy_mgr_con_mode
+ * @policy_mgr_con_mode: concurrency mode for PCL table
  *     0:STA  1:SAP  2:P2P_Client  3:P2P_GO  4:IBSS
  *
  * @OUTPUT: None
  *
  * This IOCTL is used to set pcl for concurrency mode.
  *
- * @E.g: iwpriv wlan0 pm_pcl cds_con_mode
+ * @E.g: iwpriv wlan0 pm_pcl policy_mgr_con_mode
  * iwpriv wlan0 pm_pcl 0
  *
  * Supported Feature: DBS
@@ -8530,7 +8530,7 @@ static int __iw_setint_getnone(struct net_device *dev,
 
 	case WE_MCC_CONFIG_LATENCY:
 	{
-		cds_set_mcc_latency(pAdapter, set_value);
+		wlan_hdd_set_mcc_latency(pAdapter, set_value);
 		break;
 	}
 
@@ -8538,7 +8538,8 @@ static int __iw_setint_getnone(struct net_device *dev,
 	{
 		hdd_notice("iwpriv cmd to set MCC quota with val %dms",
 				set_value);
-		ret = cds_set_mcc_p2p_quota(pAdapter, set_value);
+		ret = wlan_hdd_set_mcc_p2p_quota(pAdapter,
+			set_value);
 		break;
 	}
 	case WE_SET_DEBUG_LOG:
@@ -8974,7 +8975,7 @@ static int __iw_setnone_getint(struct net_device *dev,
 
 	case WE_GET_CONCURRENCY_MODE:
 	{
-		*value = cds_get_concurrency_mode();
+		*value = policy_mgr_get_concurrency_mode(hdd_ctx->hdd_psoc);
 
 		hdd_notice("concurrency mode=%d", *value);
 		break;
@@ -9532,7 +9533,8 @@ static int __iw_set_three_ints_getnone(struct net_device *dev,
 			return -EPERM;
 		}
 		hdd_debug("%d %d %d", value[1], value[2], value[3]);
-		cds_set_dual_mac_scan_config(value[1], value[2], value[3]);
+		policy_mgr_set_dual_mac_scan_config(hdd_ctx->hdd_psoc,
+			value[1], value[2], value[3]);
 		break;
 	case WE_SET_FW_TEST:
 	{
@@ -10337,28 +10339,26 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 	case WE_POLICY_MANAGER_CLIST_CMD:
 	{
 		hdd_err("<iwpriv wlan0 pm_clist> is called");
-		cds_incr_connection_count_utfw(apps_args[0],
-			apps_args[1], apps_args[2], apps_args[3],
-			apps_args[4], apps_args[5], apps_args[6],
-			apps_args[7]);
+		policy_mgr_incr_connection_count_utfw(hdd_ctx->hdd_psoc,
+			apps_args[0], apps_args[1], apps_args[2], apps_args[3],
+			apps_args[4], apps_args[5], apps_args[6], apps_args[7]);
 	}
 	break;
 
 	case WE_POLICY_MANAGER_DLIST_CMD:
 	{
 		hdd_err("<iwpriv wlan0 pm_dlist> is called");
-		cds_decr_connection_count_utfw(apps_args[0],
-			apps_args[1]);
+		policy_mgr_decr_connection_count_utfw(hdd_ctx->hdd_psoc,
+			apps_args[0], apps_args[1]);
 	}
 	break;
 
 	case WE_POLICY_MANAGER_ULIST_CMD:
 	{
 		hdd_err("<iwpriv wlan0 pm_ulist> is called");
-		cds_update_connection_info_utfw(apps_args[0],
-			apps_args[1], apps_args[2], apps_args[3],
-			apps_args[4], apps_args[5], apps_args[6],
-			apps_args[7]);
+		policy_mgr_update_connection_info_utfw(hdd_ctx->hdd_psoc,
+			apps_args[0], apps_args[1], apps_args[2], apps_args[3],
+			apps_args[4], apps_args[5], apps_args[6], apps_args[7]);
 	}
 	break;
 
@@ -10370,8 +10370,8 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 		else
 			wma_set_dbs_capability_ut(1);
 
-		if (apps_args[1] >= CDS_THROUGHPUT &&
-			apps_args[1] <= CDS_LATENCY) {
+		if (apps_args[1] >= PM_THROUGHPUT &&
+			apps_args[1] <= PM_LATENCY) {
 			pr_info("setting system pref to [%d]\n", apps_args[1]);
 			hdd_ctx->config->conc_system_pref = apps_args[1];
 		}
@@ -10386,7 +10386,7 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 
 		hdd_err("<iwpriv wlan0 pm_pcl> is called");
 
-		cds_get_pcl(apps_args[0],
+		policy_mgr_get_pcl(hdd_ctx->hdd_psoc, apps_args[0],
 				pcl, &pcl_len,
 				weight_list, QDF_ARRAY_SIZE(weight_list));
 		pr_info("PCL list for role[%d] is {", apps_args[0]);
@@ -10400,7 +10400,7 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 	{
 		if (apps_args[0] == 0) {
 			hdd_err("set hw mode for single mac");
-			cds_pdev_set_hw_mode(
+			policy_mgr_pdev_set_hw_mode(hdd_ctx->hdd_psoc,
 					adapter->sessionId,
 					HW_MODE_SS_2x2,
 					HW_MODE_80_MHZ,
@@ -10411,7 +10411,7 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 					SIR_UPDATE_REASON_UT);
 		} else if (apps_args[0] == 1) {
 			hdd_err("set hw mode for dual mac");
-			cds_pdev_set_hw_mode(
+			policy_mgr_pdev_set_hw_mode(hdd_ctx->hdd_psoc,
 					adapter->sessionId,
 					HW_MODE_SS_1x1,
 					HW_MODE_80_MHZ,
@@ -10426,11 +10426,12 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 
 	case WE_POLICY_MANAGER_QUERY_ACTION_CMD:
 	{
-		enum cds_conc_next_action action;
+		enum policy_mgr_conc_next_action action;
 		hdd_notice("<iwpriv wlan0 pm_query_action> is called");
-		action = cds_current_connections_update(adapter->sessionId,
-						apps_args[0],
-						SIR_UPDATE_REASON_UT);
+		action = policy_mgr_current_connections_update(
+			hdd_ctx->hdd_psoc,
+			adapter->sessionId, apps_args[0],
+			SIR_UPDATE_REASON_UT);
 		pr_info("next action is %d {HDD_NOP = 0, HDD_DBS, HDD_DBS_DOWNGRADE, HDD_MCC, HDD_MCC_UPGRADE}", action);
 	}
 	break;
@@ -10439,7 +10440,7 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 	{
 		bool allow;
 		hdd_err("<iwpriv wlan0 pm_query_allow> is called");
-		allow = cds_allow_concurrency(
+		allow = policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
 				apps_args[0], apps_args[1], apps_args[2]);
 		pr_info("allow %d {0 = don't allow, 1 = allow}", allow);
 	}
@@ -10452,38 +10453,38 @@ static int iw_get_policy_manager_ut_ops(hdd_context_t *hdd_ctx,
 			wlan_hdd_one_connection_scenario(hdd_ctx);
 		} else if (apps_args[0] == 2) {
 			wlan_hdd_two_connections_scenario(hdd_ctx,
-				6, CDS_TWO_TWO);
+				6, POLICY_MGR_TWO_TWO);
 			wlan_hdd_two_connections_scenario(hdd_ctx,
-				36, CDS_TWO_TWO);
+				36, POLICY_MGR_TWO_TWO);
 			wlan_hdd_two_connections_scenario(hdd_ctx,
-				6, CDS_ONE_ONE);
+				6, POLICY_MGR_ONE_ONE);
 			wlan_hdd_two_connections_scenario(hdd_ctx,
-				36, CDS_ONE_ONE);
+				36, POLICY_MGR_ONE_ONE);
 		} else if (apps_args[0] == 3) {
 			/* MCC on same band with 2x2 same mac*/
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				6, 11, CDS_TWO_TWO, 0);
+				6, 11, POLICY_MGR_TWO_TWO, 0);
 			/* MCC on diff band with 2x2 same mac*/
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				6, 36, CDS_TWO_TWO, 0);
+				6, 36, POLICY_MGR_TWO_TWO, 0);
 			/* MCC on diff band with 1x1 diff mac */
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				36, 6, CDS_ONE_ONE, 0);
+				36, 6, POLICY_MGR_ONE_ONE, 0);
 			/* MCC on diff band with 1x1 same mac */
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				36, 6, CDS_ONE_ONE, 1);
+				36, 6, POLICY_MGR_ONE_ONE, 1);
 			/* SCC on same band with 2x2 same mac */
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				36, 36, CDS_TWO_TWO, 0);
+				36, 36, POLICY_MGR_TWO_TWO, 0);
 			/* SCC on same band with 1x1 same mac */
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				36, 36, CDS_ONE_ONE, 1);
+				36, 36, POLICY_MGR_ONE_ONE, 1);
 			/* MCC on same band with 2x2 same mac */
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				36, 149, CDS_TWO_TWO, 0);
+				36, 149, POLICY_MGR_TWO_TWO, 0);
 			/* MCC on same band with 1x1 same mac */
 			wlan_hdd_three_connections_scenario(hdd_ctx,
-				36, 149, CDS_ONE_ONE, 1);
+				36, 149, POLICY_MGR_ONE_ONE, 1);
 		}
 		print_report(hdd_ctx);
 	}
@@ -10600,11 +10601,11 @@ static int __iw_set_var_ints_getnone(struct net_device *dev,
 
 	case WE_POLICY_MANAGER_CINFO_CMD:
 	{
-		struct cds_conc_connection_info *conn_info;
+		struct policy_mgr_conc_connection_info *conn_info;
 		uint32_t i = 0, len = 0;
 
 		hdd_info("<iwpriv wlan0 pm_cinfo> is called");
-		conn_info = cds_get_conn_info(&len);
+		conn_info = policy_mgr_get_conn_info(&len);
 		pr_info("+--------------------------+\n");
 		for (i = 0; i < len; i++) {
 		     pr_info("|table_index[%d]\t\t\n", i);
@@ -12435,7 +12436,8 @@ static int __iw_set_two_ints_getnone(struct net_device *dev,
 			return -EPERM;
 		}
 		hdd_debug("%d %d", value[1], value[2]);
-		cds_set_dual_mac_fw_mode_config(value[1], value[2]);
+		policy_mgr_set_dual_mac_fw_mode_config(hdd_ctx->hdd_psoc,
+			value[1], value[2]);
 		break;
 	case WE_DUMP_DP_TRACE_LEVEL:
 		hdd_info("WE_DUMP_DP_TRACE_LEVEL: %d %d",