qcacld-3.0: legacy code change for policy manager restructuring

Modify legacy code to cope with the policy manager moving to host
common

CRs-Fixed: 2009818
Change-Id: Ifa27ecdf1e37eda6f929f89da603bc356e9cb7fd

core/cds/inc/cds_api.h

@@ -288,4 +288,5 @@ bool cds_is_10_mhz_enabled(void);
 bool cds_is_sub_20_mhz_enabled(void);
 bool cds_is_self_recovery_enabled(void);
 void cds_pkt_stats_to_logger_thread(void *pl_hdr, void *pkt_dump, void *data);
+enum tQDF_GLOBAL_CON_MODE cds_get_conparam(void);
 #endif /* if !defined __CDS_API_H */

core/cds/inc/cds_concurrency.h

@@ -37,87 +37,8 @@
 /* Include files */
 
 #include "wlan_hdd_main.h"
-
-#define MAX_NUMBER_OF_CONC_CONNECTIONS 3
-#define DBS_OPPORTUNISTIC_TIME    10
-#ifdef QCA_WIFI_3_0_EMU
-#define CONNECTION_UPDATE_TIMEOUT 3000
-#else
-#define CONNECTION_UPDATE_TIMEOUT 1000
-#endif
-
-/* Some max value greater than the max length of the channel list */
-#define MAX_WEIGHT_OF_PCL_CHANNELS 255
-/* Some fixed weight difference between the groups */
-#define PCL_GROUPS_WEIGHT_DIFFERENCE 20
-
-/* Currently max, only 3 groups are possible as per 'enum cds_pcl_type'.
- * i.e., in a PCL only 3 groups of channels can be present
- * e.g., SCC channel on 2.4 Ghz, SCC channel on 5 Ghz & 5 Ghz channels.
- * Group 1 has highest priority, group 2 has the next higher priority
- * and so on.
- */
-#define WEIGHT_OF_GROUP1_PCL_CHANNELS MAX_WEIGHT_OF_PCL_CHANNELS
-#define WEIGHT_OF_GROUP2_PCL_CHANNELS \
-		(WEIGHT_OF_GROUP1_PCL_CHANNELS - PCL_GROUPS_WEIGHT_DIFFERENCE)
-#define WEIGHT_OF_GROUP3_PCL_CHANNELS \
-		(WEIGHT_OF_GROUP2_PCL_CHANNELS - PCL_GROUPS_WEIGHT_DIFFERENCE)
-#define WEIGHT_OF_GROUP4_PCL_CHANNELS \
-		(WEIGHT_OF_GROUP3_PCL_CHANNELS - PCL_GROUPS_WEIGHT_DIFFERENCE)
-
-#define WEIGHT_OF_NON_PCL_CHANNELS 1
-#define WEIGHT_OF_DISALLOWED_CHANNELS 0
-
-/**
- * enum hw_mode_ss_config - Possible spatial stream configuration
- * @SS_0x0: Unused Tx and Rx of MAC
- * @SS_1x1: 1 Tx SS and 1 Rx SS
- * @SS_2x2: 2 Tx SS and 2 Rx SS
- * @SS_3x3: 3 Tx SS and 3 Rx SS
- * @SS_4x4: 4 Tx SS and 4 Rx SS
- *
- * Note: Right now only 1x1 and 2x2 are being supported. Other modes should
- * be added when supported. Asymmetric configuration like 1x2, 2x1 are also
- * not supported now. But, they are still valid. Right now, Tx/Rx SS support is
- * 4 bits long. So, we can go upto 15x15
- */
-enum hw_mode_ss_config {
-	HW_MODE_SS_0x0,
-	HW_MODE_SS_1x1,
-	HW_MODE_SS_2x2,
-	HW_MODE_SS_3x3,
-	HW_MODE_SS_4x4,
-};
-
-/**
- * enum hw_mode_dbs_capab - DBS HW mode capability
- * @HW_MODE_DBS_NONE: Non DBS capable
- * @HW_MODE_DBS: DBS capable
- */
-enum hw_mode_dbs_capab {
-	HW_MODE_DBS_NONE,
-	HW_MODE_DBS,
-};
-
-/**
- * enum hw_mode_agile_dfs_capab - Agile DFS HW mode capability
- * @HW_MODE_AGILE_DFS_NONE: Non Agile DFS capable
- * @HW_MODE_AGILE_DFS: Agile DFS capable
- */
-enum hw_mode_agile_dfs_capab {
-	HW_MODE_AGILE_DFS_NONE,
-	HW_MODE_AGILE_DFS,
-};
-
-/**
- * enum hw_mode_sbs_capab - SBS HW mode capability
- * @HW_MODE_SBS_NONE: Non SBS capable
- * @HW_MODE_SBS: SBS capable
- */
-enum hw_mode_sbs_capab {
-	HW_MODE_SBS_NONE,
-	HW_MODE_SBS,
-};
+#include "wlan_policy_mgr_api.h"
+#include "wlan_policy_mgr_i.h"
 
 /**
  * enum cds_pcl_group_id - Identifies the pcl groups to be used
@@ -936,7 +857,6 @@ bool cds_map_concurrency_mode(enum tQDF_ADAPTER_MODE *old_mode,
 QDF_STATUS cds_get_channel_from_scan_result(hdd_adapter_t *adapter,
 		tCsrRoamProfile *roam_profile, uint8_t *channel);
 
-enum tQDF_GLOBAL_CON_MODE cds_get_conparam(void);
 bool cds_concurrent_open_sessions_running(void);
 bool cds_max_concurrent_connections_reached(void);
 void cds_clear_concurrent_session_count(void);

core/cds/inc/cds_sched.h

@@ -222,31 +222,10 @@ typedef struct _cds_context_type {
 	uint32_t fw_debug_log_level;
 	struct cds_log_complete log_complete;
 	qdf_spinlock_t bug_report_lock;
-	qdf_event_t connection_update_done_evt;
-	qdf_mutex_t qdf_conc_list_lock;
-	qdf_mc_timer_t dbs_opportunistic_timer;
-#ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH
-	void (*sap_restart_chan_switch_cb)(void *, uint32_t, uint32_t);
-#endif
-	QDF_STATUS (*sme_get_valid_channels)(void*, uint8_t *, uint32_t *);
-	void (*sme_get_nss_for_vdev)(void*, enum tQDF_ADAPTER_MODE,
-		uint8_t *, uint8_t *);
-
-	void (*cdp_update_mac_id)(void *soc, uint8_t , uint8_t);
 
-	/* This list is not sessionized. This mandatory channel list would be
-	 * as per OEMs preference as per the regulatory/other considerations.
-	 * So, this would remain same for all the interfaces.
-	 */
-	uint8_t sap_mandatory_channels[QDF_MAX_NUM_CHAN];
-	uint32_t sap_mandatory_channels_len;
-	bool do_hw_mode_change;
 	bool enable_fatal_event;
 	struct cds_config_info *cds_cfg;
 
-	/* This is to track if HW mode change is in progress */
-	uint32_t hw_mode_change_in_progress;
-
 	struct ol_tx_sched_wrr_ac_specs_t ac_specs[TX_WMM_AC_NUM];
 } cds_context_type, *p_cds_contextType;
 

core/cds/src/cds_api.c

@@ -426,13 +426,6 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
 		goto err_wma_complete_event;
 	}
 
-	if (!QDF_IS_STATUS_SUCCESS(qdf_mutex_create(
-				&cds_ctx->qdf_conc_list_lock))) {
-		cds_err("Failed to init qdf_conc_list_lock");
-		QDF_ASSERT(0);
-		goto err_wma_complete_event;
-	}
-
 	/* Now Open the CDS Scheduler */
 
 	if (pHddCtx->driver_status == DRIVER_MODULES_UNINITIALIZED ||
@@ -446,7 +439,7 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
 			QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_FATAL,
 				  "%s: Failed to open CDS Scheduler", __func__);
 			QDF_ASSERT(0);
-			goto err_concurrency_lock;
+			goto err_wma_complete_event;
 		}
 	}
 
@@ -591,7 +584,6 @@ QDF_STATUS cds_open(struct wlan_objmgr_psoc *psoc)
 		goto err_sme_close;
 	}
 
-	gp_cds_context->cdp_update_mac_id = cdp_update_mac_id;
 	QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_INFO_HIGH,
 		  "%s: CDS successfully Opened", __func__);
 	cds_register_all_modules();
@@ -622,9 +614,6 @@ err_bmi_close:
 err_sched_close:
 	cds_sched_close(gp_cds_context);
 
-err_concurrency_lock:
-	qdf_mutex_destroy(&cds_ctx->qdf_conc_list_lock);
-
 err_wma_complete_event:
 	qdf_event_destroy(&gp_cds_context->wmaCompleteEvent);
 
@@ -1095,12 +1084,6 @@ QDF_STATUS cds_close(struct wlan_objmgr_psoc *psoc, v_CONTEXT_t cds_context)
 		QDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
 	}
 
-	if (!QDF_IS_STATUS_SUCCESS(qdf_mutex_destroy(
-				   &gp_cds_context->qdf_conc_list_lock))) {
-		cds_err("Failed to destroy qdf_conc_list_lock");
-		QDF_ASSERT(QDF_IS_STATUS_SUCCESS(qdf_status));
-	}
-
 	cds_deinit_log_completion();
 	cds_deinit_ini_config();
 	qdf_timer_module_deinit();
@@ -2460,3 +2443,20 @@ inline void cds_pkt_stats_to_logger_thread(void *pl_hdr, void *pkt_dump,
 
 	wlan_pkt_stats_to_logger_thread(pl_hdr, pkt_dump, data);
 }
+
+/**
+ * cds_get_conparam() - Get the connection mode parameters
+ *
+ * Return the connection mode parameter set by insmod or set during statically
+ * linked driver
+ *
+ * Return: enum tQDF_GLOBAL_CON_MODE
+ */
+enum tQDF_GLOBAL_CON_MODE cds_get_conparam(void)
+{
+	enum tQDF_GLOBAL_CON_MODE con_mode;
+
+	con_mode = hdd_get_conparam();
+
+	return con_mode;
+}

core/cds/src/cds_concurrency.c

@@ -6804,21 +6804,6 @@ enum cds_con_mode cds_convert_device_mode_to_qdf_type(
 	return mode;
 }
 
-/**
- * cds_get_conparam() - Get the connection mode parameters
- *
- * Return the connection mode parameter set by insmod or set during statically
- * linked driver
- *
- * Return: enum tQDF_GLOBAL_CON_MODE
- */
-enum tQDF_GLOBAL_CON_MODE cds_get_conparam(void)
-{
-	enum tQDF_GLOBAL_CON_MODE con_mode;
-	con_mode = hdd_get_conparam();
-	return con_mode;
-}
-
 /**
  * cds_concurrent_open_sessions_running() - Checks for concurrent open session
  *

core/hdd/inc/wlan_hdd_ipa.h

@@ -117,6 +117,7 @@ struct sk_buff *hdd_ipa_tx_packet_ipa(hdd_context_t *hdd_ctx,
 bool hdd_ipa_is_present(hdd_context_t *hdd_ctx);
 void hdd_ipa_dump_info(hdd_context_t *hdd_ctx);
 QDF_STATUS hdd_ipa_uc_ol_init(hdd_context_t *hdd_ctx);
+void hdd_ipa_set_tx_flow_info(void);
 #else
 static inline QDF_STATUS hdd_ipa_init(hdd_context_t *hdd_ctx)
 {
@@ -256,5 +257,11 @@ QDF_STATUS hdd_ipa_uc_ol_init(hdd_context_t *hdd_ctx)
 {
 	return QDF_STATUS_SUCCESS;
 }
+
+static inline void hdd_ipa_set_tx_flow_info(void)
+{
+	return;
+}
+
 #endif /* IPA_OFFLOAD */
 #endif /* #ifndef HDD_IPA_H__ */

core/hdd/inc/wlan_hdd_main.h

@@ -1887,16 +1887,16 @@ void hdd_cfg80211_update_acs_config(hdd_adapter_t *adapter,
 int hdd_update_acs_timer_reason(hdd_adapter_t *adapter, uint8_t reason);
 
 /**
- * hdd_restart_sap() - Restarts SAP on the given channel
+ * hdd_switch_sap_channel() - Move SAP to the given channel
  * @adapter: AP adapter
  * @channel: Channel
  *
- * Restarts the SAP interface by invoking the function which executes the
- * callback to perform channel switch using (E)CSA.
+ * Moves the SAP interface by invoking the function which
+ * executes the callback to perform channel switch using (E)CSA.
  *
  * Return: None
  */
-void hdd_restart_sap(hdd_adapter_t *adapter, uint8_t channel);
+void hdd_switch_sap_channel(hdd_adapter_t *adapter, uint8_t channel);
 #ifdef WLAN_FEATURE_MEMDUMP
 /**
  * hdd_is_memdump_supported() - to check if memdump feature support
@@ -2193,6 +2193,11 @@ static inline int wlan_hdd_validate_session_id(u8 session_id)
 
 bool hdd_is_roaming_in_progress(hdd_adapter_t *adapter);
 void hdd_set_roaming_in_progress(bool value);
+bool hdd_is_connection_in_progress(uint8_t *session_id,
+	enum scan_reject_states *reason);
+void hdd_restart_sap(hdd_adapter_t *ap_adapter);
+void hdd_check_and_restart_sap_with_non_dfs_acs(void);
+bool hdd_set_connection_in_progress(bool value);
 
 /**
  * wlan_hdd_sap_get_valid_channellist() - Get SAPs valid channel list

core/hdd/src/wlan_hdd_assoc.c

@@ -1373,7 +1373,7 @@ static void hdd_send_association_event(struct net_device *dev,
 		hdd_stop_bus_bw_compute_timer(pAdapter);
 #endif
 	}
-	cds_dump_concurrency_info();
+	hdd_ipa_set_tx_flow_info();
 	/* Send SCC/MCC Switching event to IPA */
 	hdd_ipa_send_mcc_scc_msg(pHddCtx, pHddCtx->mcc_mode);
 
@@ -2984,18 +2984,6 @@ static QDF_STATUS hdd_association_completion_handler(hdd_adapter_t *pAdapter,
 					   WLAN_CONTROL_PATH);
 	}
 
-	if (QDF_STATUS_SUCCESS != cds_check_and_restart_sap(
-					roamResult, pHddStaCtx))
-		return QDF_STATUS_E_FAILURE;
-
-	if (NULL != pRoamInfo && NULL != pRoamInfo->pBssDesc) {
-		cds_force_sap_on_scc(roamResult,
-				pRoamInfo->pBssDesc->channelId);
-	} else {
-		hdd_err("pRoamInfo profile is not set properly");
-		return QDF_STATUS_E_FAILURE;
-	}
-
 	return QDF_STATUS_SUCCESS;
 }
 
@@ -5053,7 +5041,7 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
 				WLAN_NETIF_TX_DISABLE,
 				WLAN_CONTROL_PATH);
 		hdd_napi_serialize(1);
-		cds_set_connection_in_progress(true);
+		hdd_set_connection_in_progress(true);
 		hdd_set_roaming_in_progress(true);
 		cds_restart_opportunistic_timer(true);
 		break;
@@ -5063,7 +5051,7 @@ hdd_sme_roam_callback(void *pContext, tCsrRoamInfo *pRoamInfo, uint32_t roamId,
 		wlan_hdd_netif_queue_control(pAdapter,
 				WLAN_WAKE_ALL_NETIF_QUEUE,
 				WLAN_CONTROL_PATH);
-		cds_set_connection_in_progress(false);
+		hdd_set_connection_in_progress(false);
 		hdd_set_roaming_in_progress(false);
 		/*
 		 * If disconnect operation is in deferred state, do it now.

core/hdd/src/wlan_hdd_cfg.c

@@ -44,6 +44,7 @@
 #include <csr_api.h>
 #include <wlan_hdd_misc.h>
 #include <wlan_hdd_napi.h>
+#include <cds_api.h>
 #include <cds_concurrency.h>
 #include "wlan_hdd_he.h"
 

core/hdd/src/wlan_hdd_cfg80211.c

@@ -87,6 +87,7 @@
 #ifdef WLAN_FEATURE_LINK_LAYER_STATS
 #include "wlan_hdd_stats.h"
 #endif
+#include "cds_api.h"
 #include "cds_concurrency.h"
 #include "qwlan_version.h"
 #include "wlan_hdd_memdump.h"
@@ -8100,7 +8101,7 @@ __wlan_hdd_cfg80211_sap_configuration_set(struct wiphy *wiphy,
 				ap_ctx->sapConfig.sec_ch,
 				&ap_ctx->sapConfig.ch_params);
 
-		cds_restart_sap(hostapd_adapter);
+		hdd_restart_sap(hostapd_adapter);
 	}
 
 	if (tb[QCA_WLAN_VENDOR_ATTR_SAP_MANDATORY_FREQUENCY_LIST]) {
@@ -8672,7 +8673,7 @@ static int hdd_update_acs_channel(hdd_adapter_t *adapter, uint8_t reason,
 		sap_config->acs_cfg.ch_width = channel_list->chan_width;
 		hdd_ap_ctx->sapConfig.ch_width_orig =
 				channel_list->chan_width;
-		hdd_restart_sap(adapter, sap_config->acs_cfg.pri_ch);
+		hdd_switch_sap_channel(adapter, sap_config->acs_cfg.pri_ch);
 		break;
 
 	default:
@@ -13195,18 +13196,6 @@ static int wlan_hdd_cfg80211_connect_start(hdd_adapter_t *pAdapter,
 			pRoamProfile->nAddIEScanLength =
 				pAdapter->scan_info.scanAddIE.length;
 		}
-		/*
-		 * When policy manager is enabled from ini file, we shouldn't
-		 * check for other concurrency rules.
-		 */
-		if (wma_is_hw_dbs_capable() == false) {
-			cds_handle_conc_rule1(pAdapter, pRoamProfile);
-			if (true != cds_handle_conc_rule2(
-					pAdapter, pRoamProfile, &roamId)) {
-				status = 0;
-				goto conn_failure;
-			}
-		}
 
 		if ((wma_is_hw_dbs_capable() == true) &&
 			(false == wlan_hdd_handle_sap_sta_dfs_conc(pAdapter,

core/hdd/src/wlan_hdd_hostapd.c

@@ -619,45 +619,6 @@ static int hdd_stop_bss_link(hdd_adapter_t *pHostapdAdapter,
 	return (status == QDF_STATUS_SUCCESS) ? 0 : -EBUSY;
 }
 
-/**
- * hdd_issue_stored_joinreq() - This function will trigger stations's
- *                              cached connect request to proceed.
- * @hdd_ctx: pointer to hdd context.
- * @sta_adater: pointer to station adapter.
- *
- * This function will call SME to release station's stored/cached connect
- * request to proceed.
- *
- * Return: none.
- */
-static void hdd_issue_stored_joinreq(hdd_adapter_t *sta_adapter,
-		hdd_context_t *hdd_ctx)
-{
-	tHalHandle hal_handle;
-	uint32_t roam_id;
-
-	if (NULL == sta_adapter) {
-		hdd_err("Invalid station adapter, ignore issueing join req");
-		return;
-	}
-	hal_handle = WLAN_HDD_GET_HAL_CTX(sta_adapter);
-
-	if (true ==  cds_is_sta_connection_pending()) {
-		MTRACE(qdf_trace(QDF_MODULE_ID_HDD,
-				TRACE_CODE_HDD_ISSUE_JOIN_REQ,
-				sta_adapter->sessionId, roam_id));
-		if (QDF_STATUS_SUCCESS !=
-			sme_issue_stored_joinreq(hal_handle,
-				&roam_id,
-				sta_adapter->sessionId)) {
-			/* change back to NotAssociated */
-			hdd_conn_set_connection_state(sta_adapter,
-				eConnectionState_NotConnected);
-		}
-		cds_change_sta_conn_pending_status(false);
-	}
-}
-
 /**
  * hdd_chan_change_notify() - Function to notify hostapd about channel change
  * @hostapd_adapter	hostapd adapter
@@ -1315,7 +1276,7 @@ QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 		wrqu.data.length = strlen(startBssEvent);
 		we_event = IWEVCUSTOM;
 		we_custom_event_generic = we_custom_start_event;
-		cds_dump_concurrency_info();
+		hdd_ipa_set_tx_flow_info();
 		/* Send SCC/MCC Switching event to IPA */
 		hdd_ipa_send_mcc_scc_msg(pHddCtx, pHddCtx->mcc_mode);
 
@@ -1373,13 +1334,6 @@ QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
 			pHddApCtx->dfs_cac_block_tx = true;
 			pHddCtx->dev_dfs_cac_status = DFS_CAC_NEVER_DONE;
 		}
-		if (pHddCtx->config->conc_custom_rule2 &&
-			(QDF_P2P_GO_MODE == pHostapdAdapter->device_mode)) {
-			hdd_adapter_t *sta_adapter = hdd_get_adapter(pHddCtx,
-					QDF_STA_MODE);
-			hdd_info("P2PGO is going down now");
-			hdd_issue_stored_joinreq(sta_adapter, pHddCtx);
-		}
 		hdd_info("bss_stop_reason=%d", pHddApCtx->bss_stop_reason);
 		if (pHddApCtx->bss_stop_reason !=
 			BSS_STOP_DUE_TO_MCC_SCC_SWITCH) {
@@ -2168,7 +2122,7 @@ stopbss:
 		if (eSAP_STOP_BSS_EVENT == sapEvent)
 			qdf_event_set(&pHostapdState->qdf_stop_bss_event);
 
-		cds_dump_concurrency_info();
+		hdd_ipa_set_tx_flow_info();
 		/* Send SCC/MCC Switching event to IPA */
 		hdd_ipa_send_mcc_scc_msg(pHddCtx, pHddCtx->mcc_mode);
 	}
@@ -7355,7 +7309,7 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 
 	ENTER();
 
-	if (!update_beacon && cds_is_connection_in_progress(NULL, NULL)) {
+	if (!update_beacon && hdd_is_connection_in_progress(NULL, NULL)) {
 		hdd_err("Can't start BSS: connection is in progress");
 		return -EINVAL;
 	}
@@ -7854,7 +7808,7 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 		}
 	}
 
-	if (!cds_set_connection_in_progress(true)) {
+	if (!hdd_set_connection_in_progress(true)) {
 		hdd_err("Can't start BSS: set connnection in progress failed");
 		ret = -EINVAL;
 		goto error;
@@ -7873,7 +7827,7 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 		pSapEventCallback, pConfig, pHostapdAdapter->dev);
 	if (!QDF_IS_STATUS_SUCCESS(status)) {
 		wlansap_reset_sap_config_add_ie(pConfig, eUPDATE_IE_ALL);
-		cds_set_connection_in_progress(false);
+		hdd_set_connection_in_progress(false);
 		hdd_err("SAP Start Bss fail");
 		ret = -EINVAL;
 		goto error;
@@ -7888,7 +7842,7 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 
 	if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
 		hdd_err("ERROR: HDD qdf wait for single_event failed!!");
-		cds_set_connection_in_progress(false);
+		hdd_set_connection_in_progress(false);
 		sme_get_command_q_status(hHal);
 		wlansap_stop_bss(WLAN_HDD_GET_SAP_CTX_PTR(pHostapdAdapter));
 		QDF_ASSERT(0);
@@ -7921,7 +7875,7 @@ int wlan_hdd_cfg80211_start_bss(hdd_adapter_t *pHostapdAdapter,
 	/* Check and restart SAP if it is on unsafe channel */
 	hdd_unsafe_channel_restart_sap(pHddCtx);
 
-	cds_set_connection_in_progress(false);
+	hdd_set_connection_in_progress(false);
 	pHostapdState->bCommit = true;
 	EXIT();
 
@@ -8237,7 +8191,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
 		pAdapter->device_mode, cds_is_sub_20_mhz_enabled());
 
 
-	if (cds_is_connection_in_progress(NULL, NULL)) {
+	if (hdd_is_connection_in_progress(NULL, NULL)) {
 		hdd_err("Can't start BSS: connection is in progress");
 		return -EBUSY;
 	}

core/hdd/src/wlan_hdd_ipa.c

@@ -59,6 +59,8 @@
 
 #include "cdp_txrx_ipa.h"
 #include <cdp_txrx_handle.h>
+#include "wlan_policy_mgr_api.h"
+
 #define HDD_IPA_DESC_BUFFER_RATIO          4
 #define HDD_IPA_IPV4_NAME_EXT              "_ipv4"
 #define HDD_IPA_IPV6_NAME_EXT              "_ipv6"
@@ -1373,6 +1375,302 @@ void hdd_ipa_dump_info(hdd_context_t *hdd_ctx)
 	hdd_ipa_dump_iface_context(hdd_ipa);
 }
 
+/**
+ * hdd_ipa_set_tx_flow_info() - To set TX flow info if IPA is
+ * enabled
+ *
+ * This routine is called to set TX flow info if IPA is enabled
+ *
+ * Return: None
+ */
+void hdd_ipa_set_tx_flow_info(void)
+{
+	hdd_adapter_list_node_t *adapterNode = NULL, *pNext = NULL;
+	QDF_STATUS status;
+	hdd_adapter_t *adapter;
+	hdd_station_ctx_t *pHddStaCtx;
+	hdd_ap_ctx_t *hdd_ap_ctx;
+	hdd_hostapd_state_t *hostapd_state;
+	struct qdf_mac_addr staBssid = QDF_MAC_ADDR_ZERO_INITIALIZER;
+	struct qdf_mac_addr p2pBssid = QDF_MAC_ADDR_ZERO_INITIALIZER;
+	struct qdf_mac_addr apBssid = QDF_MAC_ADDR_ZERO_INITIALIZER;
+	uint8_t staChannel = 0, p2pChannel = 0, apChannel = 0;
+	const char *p2pMode = "DEV";
+	hdd_context_t *hdd_ctx;
+	cds_context_type *cds_ctx;
+#ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL
+	uint8_t targetChannel = 0;
+	uint8_t preAdapterChannel = 0;
+	uint8_t channel24;
+	uint8_t channel5;
+	hdd_adapter_t *preAdapterContext = NULL;
+	hdd_adapter_t *adapter2_4 = NULL;
+	hdd_adapter_t *adapter5 = NULL;
+	void *soc = cds_get_context(QDF_MODULE_ID_SOC);
+#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
+	struct wlan_objmgr_psoc *psoc;
+
+	hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+	if (!hdd_ctx) {
+		cds_err("HDD context is NULL");
+		return;
+	}
+
+	cds_ctx = cds_get_context(QDF_MODULE_ID_QDF);
+	if (!cds_ctx) {
+		cds_err("Invalid CDS Context");
+		return;
+	}
+
+	psoc = hdd_ctx->hdd_psoc;
+	status = hdd_get_front_adapter(hdd_ctx, &adapterNode);
+	while (NULL != adapterNode && QDF_STATUS_SUCCESS == status) {
+		adapter = adapterNode->pAdapter;
+		switch (adapter->device_mode) {
+		case QDF_STA_MODE:
+			pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
+			if (eConnectionState_Associated ==
+			    pHddStaCtx->conn_info.connState) {
+				staChannel =
+					pHddStaCtx->conn_info.operationChannel;
+				qdf_copy_macaddr(&staBssid,
+						 &pHddStaCtx->conn_info.bssId);
+#ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL
+				targetChannel = staChannel;
+#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
+			}
+			break;
+		case QDF_P2P_CLIENT_MODE:
+			pHddStaCtx = WLAN_HDD_GET_STATION_CTX_PTR(adapter);
+			if (eConnectionState_Associated ==
+			    pHddStaCtx->conn_info.connState) {
+				p2pChannel =
+					pHddStaCtx->conn_info.operationChannel;
+				qdf_copy_macaddr(&p2pBssid,
+						&pHddStaCtx->conn_info.bssId);
+				p2pMode = "CLI";
+#ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL
+				targetChannel = p2pChannel;
+#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
+			}
+			break;
+		case QDF_P2P_GO_MODE:
+			hdd_ap_ctx = WLAN_HDD_GET_AP_CTX_PTR(adapter);
+			hostapd_state = WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter);
+			if (hostapd_state->bssState == BSS_START
+			    && hostapd_state->qdf_status ==
+			    QDF_STATUS_SUCCESS) {
+				p2pChannel = hdd_ap_ctx->operatingChannel;
+				qdf_copy_macaddr(&p2pBssid,
+						 &adapter->macAddressCurrent);
+#ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL
+				targetChannel = p2pChannel;
+#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
+			}
+			p2pMode = "GO";
+			break;
+		case QDF_SAP_MODE:
+			hdd_ap_ctx = WLAN_HDD_GET_AP_CTX_PTR(adapter);
+			hostapd_state = WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter);
+			if (hostapd_state->bssState == BSS_START
+			    && hostapd_state->qdf_status ==
+			    QDF_STATUS_SUCCESS) {
+				apChannel = hdd_ap_ctx->operatingChannel;
+				qdf_copy_macaddr(&apBssid,
+						&adapter->macAddressCurrent);
+#ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL
+				targetChannel = apChannel;
+#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
+			}
+			break;
+		case QDF_IBSS_MODE:
+		default:
+			break;
+		}
+#ifdef QCA_LL_LEGACY_TX_FLOW_CONTROL
+		if (targetChannel) {
+			/*
+			 * This is first adapter detected as active
+			 * set as default for none concurrency case
+			 */
+			if (!preAdapterChannel) {
+				/* If IPA UC data path is enabled,
+				 * target should reserve extra tx descriptors
+				 * for IPA data path.
+				 * Then host data path should allow less TX
+				 * packet pumping in case IPA
+				 * data path enabled
+				 */
+				if (hdd_ipa_uc_is_enabled(hdd_ctx) &&
+				    (QDF_SAP_MODE == adapter->device_mode)) {
+					adapter->tx_flow_low_watermark =
+					hdd_ctx->config->TxFlowLowWaterMark +
+					WLAN_TFC_IPAUC_TX_DESC_RESERVE;
+				} else {
+					adapter->tx_flow_low_watermark =
+						hdd_ctx->config->
+							TxFlowLowWaterMark;
+				}
+				adapter->tx_flow_high_watermark_offset =
+				   hdd_ctx->config->TxFlowHighWaterMarkOffset;
+				cdp_fc_ll_set_tx_pause_q_depth(soc,
+					adapter->sessionId,
+					hdd_ctx->config->TxFlowMaxQueueDepth);
+				cds_info("MODE %d,CH %d,LWM %d,HWM %d,TXQDEP %d",
+				    adapter->device_mode,
+				    targetChannel,
+				    adapter->tx_flow_low_watermark,
+				    adapter->tx_flow_low_watermark +
+				    adapter->tx_flow_high_watermark_offset,
+				    hdd_ctx->config->TxFlowMaxQueueDepth);
+				preAdapterChannel = targetChannel;
+				preAdapterContext = adapter;
+			} else {
+				/*
+				 * SCC, disable TX flow control for both
+				 * SCC each adapter cannot reserve dedicated
+				 * channel resource, as a result, if any adapter
+				 * blocked OS Q by flow control,
+				 * blocked adapter will lost chance to recover
+				 */
+				if (preAdapterChannel == targetChannel) {
+					/* Current adapter */
+					adapter->tx_flow_low_watermark = 0;
+					adapter->
+					tx_flow_high_watermark_offset = 0;
+					cdp_fc_ll_set_tx_pause_q_depth(soc,
+						adapter->sessionId,
+						hdd_ctx->config->
+						TxHbwFlowMaxQueueDepth);
+					cds_info("SCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+					       hdd_device_mode_to_string(
+							adapter->device_mode),
+					       adapter->device_mode,
+					       targetChannel,
+					       adapter->tx_flow_low_watermark,
+					       adapter->tx_flow_low_watermark +
+					       adapter->
+					       tx_flow_high_watermark_offset,
+					       hdd_ctx->config->
+					       TxHbwFlowMaxQueueDepth);
+
+					if (!preAdapterContext) {
+						cds_err("SCC: Previous adapter context NULL");
+						continue;
+					}
+
+					/* Previous adapter */
+					preAdapterContext->
+					tx_flow_low_watermark = 0;
+					preAdapterContext->
+					tx_flow_high_watermark_offset = 0;
+					cdp_fc_ll_set_tx_pause_q_depth(soc,
+						preAdapterContext->sessionId,
+						hdd_ctx->config->
+						TxHbwFlowMaxQueueDepth);
+					cds_info("SCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+					       hdd_device_mode_to_string(
+						preAdapterContext->device_mode
+							  ),
+					       preAdapterContext->device_mode,
+					       targetChannel,
+					       preAdapterContext->
+					       tx_flow_low_watermark,
+					       preAdapterContext->
+					       tx_flow_low_watermark +
+					       preAdapterContext->
+					       tx_flow_high_watermark_offset,
+					       hdd_ctx->config->
+					       TxHbwFlowMaxQueueDepth);
+				}
+				/*
+				 * MCC, each adapter will have dedicated
+				 * resource
+				 */
+				else {
+					/* current channel is 2.4 */
+					if (targetChannel <=
+				     WLAN_HDD_TX_FLOW_CONTROL_MAX_24BAND_CH) {
+						channel24 = targetChannel;
+						channel5 = preAdapterChannel;
+						adapter2_4 = adapter;
+						adapter5 = preAdapterContext;
+					} else {
+						/* Current channel is 5 */
+						channel24 = preAdapterChannel;
+						channel5 = targetChannel;
+						adapter2_4 = preAdapterContext;
+						adapter5 = adapter;
+					}
+
+					if (!adapter5) {
+						cds_err("MCC: 5GHz adapter context NULL");
+						continue;
+					}
+					adapter5->tx_flow_low_watermark =
+						hdd_ctx->config->
+						TxHbwFlowLowWaterMark;
+					adapter5->
+					tx_flow_high_watermark_offset =
+						hdd_ctx->config->
+						TxHbwFlowHighWaterMarkOffset;
+					cdp_fc_ll_set_tx_pause_q_depth(soc,
+						adapter5->sessionId,
+						hdd_ctx->config->
+						TxHbwFlowMaxQueueDepth);
+					cds_info("MCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+					    hdd_device_mode_to_string(
+						    adapter5->device_mode),
+					    adapter5->device_mode,
+					    channel5,
+					    adapter5->tx_flow_low_watermark,
+					    adapter5->
+					    tx_flow_low_watermark +
+					    adapter5->
+					    tx_flow_high_watermark_offset,
+					    hdd_ctx->config->
+					    TxHbwFlowMaxQueueDepth);
+
+					if (!adapter2_4) {
+						cds_err("MCC: 2.4GHz adapter context NULL");
+						continue;
+					}
+					adapter2_4->tx_flow_low_watermark =
+						hdd_ctx->config->
+						TxLbwFlowLowWaterMark;
+					adapter2_4->
+					tx_flow_high_watermark_offset =
+						hdd_ctx->config->
+						TxLbwFlowHighWaterMarkOffset;
+					cdp_fc_ll_set_tx_pause_q_depth(soc,
+						adapter2_4->sessionId,
+						hdd_ctx->config->
+						TxLbwFlowMaxQueueDepth);
+					cds_info("MCC: MODE %s(%d), CH %d, LWM %d, HWM %d, TXQDEP %d",
+						hdd_device_mode_to_string(
+						    adapter2_4->device_mode),
+						adapter2_4->device_mode,
+						channel24,
+						adapter2_4->
+						tx_flow_low_watermark,
+						adapter2_4->
+						tx_flow_low_watermark +
+						adapter2_4->
+						tx_flow_high_watermark_offset,
+						hdd_ctx->config->
+						TxLbwFlowMaxQueueDepth);
+
+				}
+			}
+		}
+		targetChannel = 0;
+#endif /* QCA_LL_LEGACY_TX_FLOW_CONTROL */
+		status = hdd_get_next_adapter(hdd_ctx, adapterNode, &pNext);
+		adapterNode = pNext;
+	}
+	hdd_ctx->mcc_mode = policy_mgr_current_concurrency_is_mcc(psoc);
+}
+
 /**
  * __hdd_ipa_uc_stat_query() - Query the IPA stats
  * @hdd_ctx: Global HDD context

core/hdd/src/wlan_hdd_main.c

@@ -3714,7 +3714,7 @@ hdd_adapter_t *hdd_open_adapter(hdd_context_t *hdd_ctx, uint8_t session_type,
 		hdd_debug("current_intf_count=%d",
 		       hdd_ctx->current_intf_count);
 
-		cds_check_and_restart_sap_with_non_dfs_acs();
+		hdd_check_and_restart_sap_with_non_dfs_acs();
 	}
 
 	if (QDF_STATUS_SUCCESS != hdd_debugfs_init(adapter))
@@ -3952,16 +3952,6 @@ QDF_STATUS hdd_stop_adapter(hdd_context_t *hdd_ctx, hdd_adapter_t *adapter,
 
 	case QDF_SAP_MODE:
 	case QDF_P2P_GO_MODE:
-		if (hdd_ctx->config->conc_custom_rule1 &&
-			(QDF_SAP_MODE == adapter->device_mode)) {
-			/*
-			 * Before stopping the sap adapter, lets make sure there
-			 * is no sap restart work pending.
-			 */
-			cds_flush_work(&hdd_ctx->sap_start_work);
-			hdd_info("Canceled the pending SAP restart work");
-			cds_change_sap_restart_required_status(false);
-		}
 		/* Any softap specific cleanup here... */
 		if (adapter->device_mode == QDF_P2P_GO_MODE)
 			wlan_hdd_cleanup_remain_on_channel_ctx(adapter);
@@ -6493,16 +6483,16 @@ static uint8_t hdd_get_safe_channel_from_pcl_and_acs_range(
 }
 
 /**
- * hdd_restart_sap() - Restarts SAP on the given channel
+ * hdd_switch_sap_channel() - Move SAP to the given channel
  * @adapter: AP adapter
  * @channel: Channel
  *
- * Restarts the SAP interface by invoking the function which executes the
- * callback to perform channel switch using (E)CSA.
+ * Moves the SAP interface by invoking the function which
+ * executes the callback to perform channel switch using (E)CSA.
  *
  * Return: None
  */
-void hdd_restart_sap(hdd_adapter_t *adapter, uint8_t channel)
+void hdd_switch_sap_channel(hdd_adapter_t *adapter, uint8_t channel)
 {
 	hdd_ap_ctx_t *hdd_ap_ctx;
 	tHalHandle *hal_handle;
@@ -6636,7 +6626,7 @@ void hdd_unsafe_channel_restart_sap(hdd_context_t *hdd_ctxt)
 			hdd_info("sending coex indication");
 			wlan_hdd_send_svc_nlink_msg(hdd_ctxt->radio_index,
 					WLAN_SVC_LTE_COEX_IND, NULL, 0);
-			hdd_restart_sap(adapter_temp, restart_chan);
+			hdd_switch_sap_channel(adapter_temp, restart_chan);
 		}
 
 next_adapater:
@@ -6916,7 +6906,7 @@ static void hdd_lte_coex_restart_sap(hdd_adapter_t *adapter,
 		hdd_info("sending coex indication");
 		wlan_hdd_send_svc_nlink_msg(hdd_ctx->radio_index,
 				WLAN_SVC_LTE_COEX_IND, NULL, 0);
-		hdd_restart_sap(adapter, restart_chan);
+		hdd_switch_sap_channel(adapter, restart_chan);
 	}
 }
 
@@ -9184,6 +9174,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);
 	EXIT();
 
 	return ret;
@@ -10942,6 +10934,291 @@ bool hdd_is_roaming_in_progress(hdd_adapter_t *adapter)
 	return ret_status;
 }
 
+/**
+ * hdd_is_connection_in_progress() - check if connection is in
+ * progress
+ * @session_id: session id
+ * @reason: scan reject reason
+ *
+ * Go through each adapter and check if Connection is in progress
+ *
+ * Return: true if connection is in progress else false
+ */
+bool hdd_is_connection_in_progress(uint8_t *session_id,
+				enum scan_reject_states *reason)
+{
+	hdd_adapter_list_node_t *adapter_node = NULL, *next = NULL;
+	hdd_station_ctx_t *hdd_sta_ctx = NULL;
+	hdd_adapter_t *adapter = NULL;
+	QDF_STATUS status = 0;
+	uint8_t sta_id = 0;
+	uint8_t *sta_mac = NULL;
+	hdd_context_t *hdd_ctx;
+
+	hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+	if (!hdd_ctx) {
+		hdd_err("HDD context is NULL");
+		return false;
+	}
+
+	if (true == hdd_ctx->btCoexModeSet) {
+		hdd_info("BTCoex Mode operation in progress");
+		return true;
+	}
+	status = hdd_get_front_adapter(hdd_ctx, &adapter_node);
+	while (NULL != adapter_node && QDF_STATUS_SUCCESS == status) {
+		adapter = adapter_node->pAdapter;
+		if (!adapter)
+			goto end;
+
+		hdd_info("Adapter with device mode %s(%d) exists",
+			hdd_device_mode_to_string(adapter->device_mode),
+			adapter->device_mode);
+		if (((QDF_STA_MODE == adapter->device_mode)
+			|| (QDF_P2P_CLIENT_MODE == adapter->device_mode)
+			|| (QDF_P2P_DEVICE_MODE == adapter->device_mode))
+			&& (eConnectionState_Connecting ==
+				(WLAN_HDD_GET_STATION_CTX_PTR(adapter))->
+					conn_info.connState)) {
+			hdd_err("%p(%d) Connection is in progress",
+				WLAN_HDD_GET_STATION_CTX_PTR(adapter),
+				adapter->sessionId);
+			if (session_id && reason) {
+				*session_id = adapter->sessionId;
+				*reason = eHDD_CONNECTION_IN_PROGRESS;
+			}
+			return true;
+		}
+		if ((QDF_STA_MODE == adapter->device_mode) &&
+				sme_neighbor_middle_of_roaming(
+					WLAN_HDD_GET_HAL_CTX(adapter),
+					adapter->sessionId)) {
+			hdd_err("%p(%d) Reassociation in progress",
+				WLAN_HDD_GET_STATION_CTX_PTR(adapter),
+				adapter->sessionId);
+			if (session_id && reason) {
+				*session_id = adapter->sessionId;
+				*reason = eHDD_REASSOC_IN_PROGRESS;
+			}
+			return true;
+		}
+		if ((QDF_STA_MODE == adapter->device_mode) ||
+			(QDF_P2P_CLIENT_MODE == adapter->device_mode) ||
+			(QDF_P2P_DEVICE_MODE == adapter->device_mode)) {
+			hdd_sta_ctx =
+				WLAN_HDD_GET_STATION_CTX_PTR(adapter);
+			if ((eConnectionState_Associated ==
+				hdd_sta_ctx->conn_info.connState)
+				&& (false ==
+				hdd_sta_ctx->conn_info.uIsAuthenticated)) {
+				sta_mac = (uint8_t *)
+					&(adapter->macAddressCurrent.bytes[0]);
+				hdd_err("client " MAC_ADDRESS_STR
+					" is in middle of WPS/EAPOL exchange.",
+					MAC_ADDR_ARRAY(sta_mac));
+				if (session_id && reason) {
+					*session_id = adapter->sessionId;
+					*reason = eHDD_EAPOL_IN_PROGRESS;
+				}
+				return true;
+			}
+		} else if ((QDF_SAP_MODE == adapter->device_mode) ||
+				(QDF_P2P_GO_MODE == adapter->device_mode)) {
+			for (sta_id = 0; sta_id < WLAN_MAX_STA_COUNT;
+				sta_id++) {
+				if (!((adapter->aStaInfo[sta_id].isUsed)
+				    && (OL_TXRX_PEER_STATE_CONN ==
+				    adapter->aStaInfo[sta_id].tlSTAState)))
+					continue;
+
+				sta_mac = (uint8_t *)
+						&(adapter->aStaInfo[sta_id].
+							macAddrSTA.bytes[0]);
+				hdd_err("client " MAC_ADDRESS_STR
+				" of SAP/GO is in middle of WPS/EAPOL exchange",
+				MAC_ADDR_ARRAY(sta_mac));
+				if (session_id && reason) {
+					*session_id = adapter->sessionId;
+					*reason = eHDD_SAP_EAPOL_IN_PROGRESS;
+				}
+				return true;
+			}
+			if (hdd_ctx->connection_in_progress) {
+				hdd_err("AP/GO: connection is in progress");
+				return true;
+			}
+		}
+end:
+		status = hdd_get_next_adapter(hdd_ctx, adapter_node, &next);
+		adapter_node = next;
+	}
+	return false;
+}
+
+/**
+ * hdd_restart_sap() - to restart SAP in driver internally
+ * @ap_adapter: Pointer to SAP hdd_adapter_t structure
+ *
+ * Return: None
+ */
+void hdd_restart_sap(hdd_adapter_t *ap_adapter)
+{
+	hdd_ap_ctx_t *hdd_ap_ctx;
+	hdd_hostapd_state_t *hostapd_state;
+	QDF_STATUS qdf_status;
+	hdd_context_t *hdd_ctx = WLAN_HDD_GET_CTX(ap_adapter);
+	tsap_Config_t *sap_config;
+	void *sap_ctx;
+
+	hdd_ap_ctx = WLAN_HDD_GET_AP_CTX_PTR(ap_adapter);
+	sap_config = &hdd_ap_ctx->sapConfig;
+	sap_ctx = hdd_ap_ctx->sapContext;
+
+	mutex_lock(&hdd_ctx->sap_lock);
+	if (test_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags)) {
+		wlan_hdd_del_station(ap_adapter);
+		hdd_cleanup_actionframe(hdd_ctx, ap_adapter);
+		hostapd_state = WLAN_HDD_GET_HOSTAP_STATE_PTR(ap_adapter);
+		qdf_event_reset(&hostapd_state->qdf_stop_bss_event);
+		if (QDF_STATUS_SUCCESS == wlansap_stop_bss(sap_ctx)) {
+			qdf_status =
+				qdf_wait_single_event(&hostapd_state->
+					qdf_stop_bss_event,
+					SME_CMD_TIMEOUT_VALUE);
+
+			if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
+				cds_err("SAP Stop Failed");
+				goto end;
+			}
+		}
+		clear_bit(SOFTAP_BSS_STARTED, &ap_adapter->event_flags);
+		cds_decr_session_set_pcl(
+			ap_adapter->device_mode, ap_adapter->sessionId);
+		cds_err("SAP Stop Success");
+
+		if (0 != wlan_hdd_cfg80211_update_apies(ap_adapter)) {
+			cds_err("SAP Not able to set AP IEs");
+			wlansap_reset_sap_config_add_ie(sap_config,
+					eUPDATE_IE_ALL);
+			goto end;
+		}
+
+		qdf_event_reset(&hostapd_state->qdf_event);
+		if (wlansap_start_bss(sap_ctx, hdd_hostapd_sap_event_cb,
+				      sap_config,
+				      ap_adapter->dev) != QDF_STATUS_SUCCESS) {
+			cds_err("SAP Start Bss fail");
+			wlansap_reset_sap_config_add_ie(sap_config,
+					eUPDATE_IE_ALL);
+			goto end;
+		}
+
+		cds_info("Waiting for SAP to start");
+		qdf_status =
+			qdf_wait_single_event(&hostapd_state->qdf_event,
+					SME_CMD_TIMEOUT_VALUE);
+		wlansap_reset_sap_config_add_ie(sap_config,
+				eUPDATE_IE_ALL);
+		if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
+			cds_err("SAP Start failed");
+			goto end;
+		}
+		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,
+						ap_adapter->sessionId);
+		hostapd_state->bCommit = true;
+	}
+end:
+	mutex_unlock(&hdd_ctx->sap_lock);
+	return;
+}
+
+/**
+ * hdd_check_and_restart_sap_with_non_dfs_acs() - Restart SAP
+ * with non dfs acs
+ *
+ * Restarts SAP in non-DFS ACS mode when STA-AP mode DFS is not supported
+ *
+ * Return: None
+ */
+void hdd_check_and_restart_sap_with_non_dfs_acs(void)
+{
+	hdd_adapter_t *ap_adapter;
+	hdd_context_t *hdd_ctx;
+	cds_context_type *cds_ctx;
+
+	hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+	if (!hdd_ctx) {
+		cds_err("HDD context is NULL");
+		return;
+	}
+
+	cds_ctx = cds_get_context(QDF_MODULE_ID_QDF);
+	if (!cds_ctx) {
+		cds_err("Invalid CDS Context");
+		return;
+	}
+
+	if (cds_get_concurrency_mode() != (QDF_STA_MASK | QDF_SAP_MASK)) {
+		cds_info("Concurrency mode is not SAP");
+		return;
+	}
+
+	ap_adapter = hdd_get_adapter(hdd_ctx, QDF_SAP_MODE);
+	if (ap_adapter != NULL &&
+			test_bit(SOFTAP_BSS_STARTED,
+				&ap_adapter->event_flags)
+			&& CDS_IS_DFS_CH(ap_adapter->sessionCtx.ap.
+				operatingChannel)) {
+
+		cds_warn("STA-AP Mode DFS not supported. Restart SAP with Non DFS ACS");
+		ap_adapter->sessionCtx.ap.sapConfig.channel =
+			AUTO_CHANNEL_SELECT;
+		ap_adapter->sessionCtx.ap.sapConfig.
+			acs_cfg.acs_mode = true;
+
+		cds_restart_sap(ap_adapter);
+	}
+}
+
+/**
+ * hdd_set_connection_in_progress() - to set the connection in
+ * progress flag
+ * @value: value to set
+ *
+ * This function will set the passed value to connection in progress flag.
+ * If value is previously being set to true then no need to set it again.
+ *
+ * Return: true if value is being set correctly and false otherwise.
+ */
+bool hdd_set_connection_in_progress(bool value)
+{
+	bool status = true;
+	hdd_context_t *hdd_ctx;
+
+	hdd_ctx = cds_get_context(QDF_MODULE_ID_HDD);
+	if (!hdd_ctx) {
+		cds_err("HDD context is NULL");
+		return false;
+	}
+
+	qdf_spin_lock(&hdd_ctx->connection_status_lock);
+	/*
+	 * if the value is set to true previously and if someone is
+	 * trying to make it true again then it could be some race
+	 * condition being triggered. Avoid this situation by returning
+	 * false
+	 */
+	if (hdd_ctx->connection_in_progress && value)
+		status = false;
+	else
+		hdd_ctx->connection_in_progress = value;
+	qdf_spin_unlock(&hdd_ctx->connection_status_lock);
+	return status;
+}
+
 /* Register the module init/exit functions */
 module_init(hdd_module_init);
 module_exit(hdd_module_exit);

core/hdd/src/wlan_hdd_p2p.c

@@ -867,7 +867,7 @@ static int wlan_hdd_request_remain_on_channel(struct wiphy *wiphy,
 	ret = wlan_hdd_validate_context(pHddCtx);
 	if (0 != ret)
 		return ret;
-	if (cds_is_connection_in_progress(NULL, NULL)) {
+	if (hdd_is_connection_in_progress(NULL, NULL)) {
 		hdd_err("Connection is in progress");
 		isBusy = true;
 	}

core/hdd/src/wlan_hdd_scan.c

@@ -1593,7 +1593,7 @@ static int __wlan_hdd_cfg80211_scan(struct wiphy *wiphy,
 #endif
 
 	/* Check if scan is allowed at this point of time */
-	if (cds_is_connection_in_progress(&curr_session_id, &curr_reason)) {
+	if (hdd_is_connection_in_progress(&curr_session_id, &curr_reason)) {
 		hdd_err("Scan not allowed");
 		if (pHddCtx->last_scan_reject_session_id != curr_session_id ||
 		    pHddCtx->last_scan_reject_reason != curr_reason ||

core/mac/inc/sir_api.h

@@ -56,6 +56,7 @@ typedef struct sAniSirGlobal *tpAniSirGlobal;
 #include "wmi_unified.h"
 #include "wmi_unified_param.h"
 #include <dot11f.h>
+#include "wlan_policy_mgr_api.h"
 
 #define OFFSET_OF(structType, fldName)   (&((structType *)0)->fldName)
 
@@ -3257,53 +3258,6 @@ struct sir_wifi_start_log {
 };
 
 
-/**
- * enum hw_mode_bandwidth - bandwidth of wifi channel.
- *
- * @HW_MODE_5_MHZ: 5 Mhz bandwidth
- * @HW_MODE_10_MHZ: 10 Mhz bandwidth
- * @HW_MODE_20_MHZ: 20 Mhz bandwidth
- * @HW_MODE_40_MHZ: 40 Mhz bandwidth
- * @HW_MODE_80_MHZ: 80 Mhz bandwidth
- * @HW_MODE_80_PLUS_80_MHZ: 80 Mhz plus 80 Mhz bandwidth
- * @HW_MODE_160_MHZ: 160 Mhz bandwidth
- * @HW_MODE_MAX_BANDWIDTH: Max place holder
- *
- * These are generic IDs that identify the various roles
- * in the software system
- */
-enum hw_mode_bandwidth {
-	HW_MODE_BW_NONE,
-	HW_MODE_5_MHZ,
-	HW_MODE_10_MHZ,
-	HW_MODE_20_MHZ,
-	HW_MODE_40_MHZ,
-	HW_MODE_80_MHZ,
-	HW_MODE_80_PLUS_80_MHZ,
-	HW_MODE_160_MHZ,
-	HW_MODE_MAX_BANDWIDTH
-};
-
-/**
- * enum set_hw_mode_status - Status of set HW mode command
- * @SET_HW_MODE_STATUS_OK: command successful
- * @SET_HW_MODE_STATUS_EINVAL: Requested invalid hw_mode
- * @SET_HW_MODE_STATUS_ECANCELED: HW mode change cancelled
- * @SET_HW_MODE_STATUS_ENOTSUP: HW mode not supported
- * @SET_HW_MODE_STATUS_EHARDWARE: HW mode change prevented by hardware
- * @SET_HW_MODE_STATUS_EPENDING: HW mode change is pending
- * @SET_HW_MODE_STATUS_ECOEX: HW mode change conflict with Coex
- */
-enum set_hw_mode_status {
-	SET_HW_MODE_STATUS_OK,
-	SET_HW_MODE_STATUS_EINVAL,
-	SET_HW_MODE_STATUS_ECANCELED,
-	SET_HW_MODE_STATUS_ENOTSUP,
-	SET_HW_MODE_STATUS_EHARDWARE,
-	SET_HW_MODE_STATUS_EPENDING,
-	SET_HW_MODE_STATUS_ECOEX,
-};
-
 /**
  * struct sir_pcl_list - Format of PCL
  * @pcl_list: List of preferred channels

core/mac/src/pe/lim/lim_api.c

@@ -68,6 +68,7 @@
 #include "cds_packet.h"
 #include "cds_utils.h"
 #include "sys_startup.h"
+#include "cds_api.h"
 #include "cds_concurrency.h"
 #include "nan_datapath.h"
 #include "wma.h"

core/sme/inc/sme_api.h

@@ -1449,4 +1449,17 @@ QDF_STATUS sme_get_beacon_frm(tHalHandle hal, tCsrRoamProfile *profile,
 
 QDF_STATUS sme_delete_all_tdls_peers(tHalHandle hal, uint8_t session_id);
 
+/**
+ * sme_register_set_connection_info_cb() - Register connection
+ * info callback
+ * @hal - MAC global handle
+ * @callback_routine - callback routine from HDD
+ *
+ * This API is invoked by HDD to register its callback to mac
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS sme_register_set_connection_info_cb(tHalHandle hHal,
+					  bool (*set_connection_info_cb)(bool));
+
 #endif /* #if !defined( __SME_API_H ) */

core/sme/inc/sme_internal.h

@@ -257,6 +257,7 @@ typedef struct tagSmeStruct {
 	void *encrypt_decrypt_context;
 	void (*lost_link_info_cb)(void *context,
 			struct sir_lost_link_info *lost_link_info);
+	bool (*set_connection_info_cb)(bool);
 } tSmeStruct, *tpSmeStruct;
 
 #endif /* #if !defined( __SMEINTERNAL_H ) */

core/sme/src/common/sme_api.c

@@ -286,7 +286,6 @@ end:
 static QDF_STATUS sme_process_hw_mode_trans_ind(tpAniSirGlobal mac,
 						uint8_t *msg)
 {
-	hw_mode_transition_cb callback = NULL;
 	struct sir_hw_mode_trans_ind *param;
 
 	param = (struct sir_hw_mode_trans_ind *)msg;
@@ -295,14 +294,10 @@ static QDF_STATUS sme_process_hw_mode_trans_ind(tpAniSirGlobal mac,
 		return QDF_STATUS_E_FAILURE;
 	}
 
-	callback = mac->sme.sme_hw_mode_trans_cb;
-	if (callback) {
-		sms_log(mac, LOGE, FL("Calling registered callback..."));
-		callback(param->old_hw_mode_index,
-			param->new_hw_mode_index,
-			param->num_vdev_mac_entries,
-			param->vdev_mac_map);
-	}
+	cds_hw_mode_transition_cb(param->old_hw_mode_index,
+		param->new_hw_mode_index,
+		param->num_vdev_mac_entries,
+		param->vdev_mac_map);
 
 	return QDF_STATUS_SUCCESS;
 }
@@ -16520,3 +16515,17 @@ QDF_STATUS sme_set_peer_param(uint8_t *peer_addr, uint32_t param_id,
 	return wma_set_peer_param(wma_handle, peer_addr, param_id,
 				  param_value, vdev_id);
 }
+
+QDF_STATUS sme_register_set_connection_info_cb(tHalHandle hHal,
+					  bool (*set_connection_info_cb)(bool))
+{
+	QDF_STATUS status = QDF_STATUS_SUCCESS;
+	tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
+
+	status = sme_acquire_global_lock(&pMac->sme);
+	if (QDF_IS_STATUS_SUCCESS(status)) {
+		pMac->sme.set_connection_info_cb = set_connection_info_cb;
+		sme_release_global_lock(&pMac->sme);
+	}
+	return status;
+}

core/sme/src/csr/csr_api_roam.c

@@ -19515,7 +19515,7 @@ void csr_roaming_report_diag_event(tpAniSirGlobal mac_ctx,
 * param  pMac global structure
 * param  pMsgBuf - Contains the session ID for which the handler should apply
 * --------------------------------------------------------------------------*/
-void csr_process_ho_fail_ind(tpAniSirGlobal pMac, void *pMsgBuf)
+void csr_process_ho_fail_ind(tpAniSirGlobal mac_ctx, void *pMsgBuf)
 {
 	tSirSmeHOFailureInd *pSmeHOFailInd = (tSirSmeHOFailureInd *) pMsgBuf;
 	uint32_t sessionId;
@@ -19528,23 +19528,23 @@ void csr_process_ho_fail_ind(tpAniSirGlobal pMac, void *pMsgBuf)
 		return;
 	}
 	/* Roaming is supported only on Infra STA Mode. */
-	if (!csr_roam_is_sta_mode(pMac, sessionId)) {
+	if (!csr_roam_is_sta_mode(mac_ctx, sessionId)) {
 		QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
 			  "LFR3:HO Fail cannot be handled for session %d",
 			  sessionId);
 		return;
 	}
-	cds_set_connection_in_progress(false);
-	csr_roam_roaming_offload_timer_action(pMac, 0, sessionId,
+	mac_ctx->sme.set_connection_info_cb(false);
+	csr_roam_roaming_offload_timer_action(mac_ctx, 0, sessionId,
 			ROAMING_OFFLOAD_TIMER_STOP);
-	csr_roam_call_callback(pMac, sessionId, NULL, 0,
+	csr_roam_call_callback(mac_ctx, sessionId, NULL, 0,
 			eCSR_ROAM_NAPI_OFF, eSIR_SME_SUCCESS);
-	csr_roam_synch_clean_up(pMac, sessionId);
-	csr_roaming_report_diag_event(pMac, NULL,
+	csr_roam_synch_clean_up(mac_ctx, sessionId);
+	csr_roaming_report_diag_event(mac_ctx, NULL,
 			eCSR_REASON_ROAM_HO_FAIL);
 	QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
 		  "LFR3:Issue Disconnect on session %d", sessionId);
-	csr_roam_disconnect(pMac, sessionId,
+	csr_roam_disconnect(mac_ctx, sessionId,
 			eCSR_DISCONNECT_REASON_ROAM_HO_FAIL);
 }
 #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
@@ -20337,7 +20337,7 @@ QDF_STATUS csr_roam_synch_callback(tpAniSirGlobal mac_ctx,
 			roam_synch_data->hw_mode_trans_ind.new_hw_mode_index,
 			roam_synch_data->hw_mode_trans_ind.num_vdev_mac_entries,
 			roam_synch_data->hw_mode_trans_ind.vdev_mac_map);
-		cds_set_connection_in_progress(false);
+		mac_ctx->sme.set_connection_info_cb(false);
 		session->roam_synch_in_progress = false;
 		cds_check_concurrent_intf_and_restart_sap(session->pContext);
 		sme_release_global_lock(&mac_ctx->sme);

core/wma/inc/wma.h

@@ -51,6 +51,8 @@
 #include "cds_ieee80211_common.h"
 #include "wlan_objmgr_psoc_obj.h"
 #include <cdp_txrx_handle.h>
+#include "wlan_policy_mgr_api.h"
+
 /* Platform specific configuration for max. no. of fragments */
 #define QCA_OL_11AC_TX_MAX_FRAGS            2
 
@@ -1168,16 +1170,6 @@ typedef struct {
 	uint32_t ibssPs1RxChainInAtimEnable;
 } ibss_power_save_params;
 
-/**
- * struct dbs_hw_mode_info - WLAN_DBS_HW_MODES_TLV Format
- * @tlv_header: TLV header, TLV tag and len; tag equals WMITLV_TAG_ARRAY_UINT32
- * @hw_mode_list: WLAN_DBS_HW_MODE_LIST entries
- */
-struct dbs_hw_mode_info {
-	uint32_t tlv_header;
-	uint32_t *hw_mode_list;
-};
-
 /**
  * struct mac_ss_bw_info - hw_mode_list PHY/MAC params for each MAC
  * @mac_tx_stream: Max TX stream
@@ -1190,24 +1182,6 @@ struct mac_ss_bw_info {
 	uint32_t mac_bw;
 };
 
-/**
- * struct dual_mac_config - Dual MAC configurations
- * @prev_scan_config: Previous scan configuration
- * @prev_fw_mode_config: Previous FW mode configuration
- * @cur_scan_config: Current scan configuration
- * @cur_fw_mode_config: Current FW mode configuration
- * @req_scan_config: Requested scan configuration
- * @req_fw_mode_config: Requested FW mode configuration
- */
-struct dual_mac_config {
-	uint32_t prev_scan_config;
-	uint32_t prev_fw_mode_config;
-	uint32_t cur_scan_config;
-	uint32_t cur_fw_mode_config;
-	uint32_t req_scan_config;
-	uint32_t req_fw_mode_config;
-};
-
 /**
  * struct wma_ini_config - Structure to hold wma ini configuration
  * @max_no_of_peers: Max Number of supported
@@ -1240,23 +1214,6 @@ struct hw_mode_idx_to_mac_cap_idx {
 	uint8_t hw_mode_id;
 };
 
-/**
- * struct extended_caps - new extended caps given by firmware
- * @num_hw_modes: number of hardware modes for current SOC
- * @each_hw_mode_cap: hw mode id to phy id mapping
- * @each_phy_cap_per_hwmode: PHY's caps for each hw mode
- * @num_phy_for_hal_reg_cap: number of phy for hal reg cap
- * @hw_mode_to_mac_cap_map: map between hw_mode to capabilities
- */
-struct extended_caps {
-	WMI_SOC_MAC_PHY_HW_MODE_CAPS num_hw_modes;
-	WMI_HW_MODE_CAPABILITIES *each_hw_mode_cap;
-	WMI_MAC_PHY_CAPABILITIES *each_phy_cap_per_hwmode;
-	WMI_SOC_HAL_REG_CAPABILITIES num_phy_for_hal_reg_cap;
-	WMI_HAL_REG_CAPABILITIES_EXT *each_phy_hal_reg_cap;
-	struct hw_mode_idx_to_mac_cap_idx *hw_mode_to_mac_cap_map;
-};
-
 /**
  * struct t_wma_handle - wma context
  * @wmi_handle: wmi handle

core/wma/inc/wma_api.h

@@ -40,6 +40,7 @@
 #include "cds_concurrency.h"
 #include "cds_utils.h"
 #include "scheduler_api.h"
+#include "wlan_policy_mgr_api.h"
 
 typedef void *WMA_HANDLE;
 
@@ -149,6 +150,9 @@ QDF_STATUS wma_update_channel_list(WMA_HANDLE handle, void *scan_chan_info);
 
 uint8_t *wma_get_vdev_address_by_vdev_id(uint8_t vdev_id);
 struct wma_txrx_node *wma_get_interface_by_vdev_id(uint8_t vdev_id);
+QDF_STATUS wma_get_connection_info(uint8_t vdev_id,
+		struct policy_mgr_vdev_entry_info *conn_table_entry);
+
 bool wma_is_vdev_up(uint8_t vdev_id);
 
 void *wma_get_beacon_buffer_by_vdev_id(uint8_t vdev_id, uint32_t *buffer_size);
@@ -305,4 +309,5 @@ 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);
 #endif

core/wma/src/wma_utils.c

@@ -2433,6 +2433,25 @@ uint8_t *wma_get_vdev_address_by_vdev_id(uint8_t vdev_id)
 	return wma->interfaces[vdev_id].addr;
 }
 
+QDF_STATUS wma_get_connection_info(uint8_t vdev_id,
+		struct policy_mgr_vdev_entry_info *conn_table_entry)
+{
+	struct wma_txrx_node *wma_conn_table_entry;
+
+	wma_conn_table_entry = wma_get_interface_by_vdev_id(vdev_id);
+	if (NULL == wma_conn_table_entry) {
+		WMA_LOGE("%s: can't find vdev_id %d in WMA table", __func__, vdev_id);
+		return QDF_STATUS_E_FAILURE;
+	}
+	conn_table_entry->chan_width = wma_conn_table_entry->chan_width;
+	conn_table_entry->mac_id = wma_conn_table_entry->mac_id;
+	conn_table_entry->mhz = wma_conn_table_entry->mhz;
+	conn_table_entry->sub_type = wma_conn_table_entry->sub_type;
+	conn_table_entry->type = wma_conn_table_entry->type;
+
+	return QDF_STATUS_SUCCESS;
+}
+
 /**
  * wma_get_interface_by_vdev_id() - lookup interface entry using vdev ID
  * @vdev_id: vdev id
@@ -3977,3 +3996,15 @@ QDF_STATUS wma_send_vdev_stop_to_fw(t_wma_handle *wma, uint8_t vdev_id)
 
 	return status;
 }
+
+bool wma_is_service_enabled(WMI_SERVICE service_type)
+{
+	tp_wma_handle wma;
+	wma = cds_get_context(QDF_MODULE_ID_WMA);
+	if (!wma) {
+		WMA_LOGE("%s: Invalid WMA handle", __func__);
+		return false;
+	}
+
+	return WMI_SERVICE_IS_ENABLED(wma->wmi_service_bitmap, service_type);
+}