qcacld-3.0: Migrate validate beacon interval API

Move the beacon interval validation logic from the CSR module to the
interface manager module.
Add a path to send events to the SAP event handler from the MLME
module.

Change-Id: Ia86f219b3f209b53e7818a80f95b2c0555550736
CRs-fixed: 2796676

components/cmn_services/interface_mgr/inc/wlan_if_mgr_roam.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2020-2021, 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 above
@@ -54,6 +54,49 @@ struct bssid_search_arg {
 	uint8_t vdev_id;
 };
 
+/**
+ * allow_mcc_go_diff_bi_definition - Defines the config values for allowing
+ * different beacon intervals between P2P-G0 and STA
+ * @ALLOW_MCC_GO_DIFF_BI_WFA_CERT: GO Beacon interval is not changed.
+ *	MCC GO doesn't work well in optimized way. In worst scenario, it may
+ *	invite STA disconnection.
+ * @ALLOW_MCC_GO_DIFF_BI_WORKAROUND: Workaround 1 disassoc all the clients and
+ *	update beacon Interval.
+ * @ALLOW_MCC_GO_DIFF_BI_TEAR_DOWN: Tear down the P2P link in
+ *	auto/Non-autonomous -GO case.
+ * @ALLOW_MCC_GO_DIFF_BI_NO_DISCONNECT: Don't disconnect the P2P client in
+ *	autonomous/Non-autonomous -GO case update the BI dynamically
+ */
+enum allow_mcc_go_diff_bi_definition {
+	ALLOW_MCC_GO_DIFF_BI_WFA_CERT = 1,
+	ALLOW_MCC_GO_DIFF_BI_WORKAROUND,
+	ALLOW_MCC_GO_DIFF_BI_TEAR_DOWN,
+	ALLOW_MCC_GO_DIFF_BI_NO_DISCONNECT,
+};
+
+/**
+ * struct beacon_interval_arg - Contains beacon interval validation arguments
+ * @curr_vdev_id: current iterator vdev ID
+ * @curr_bss_opmode: current iterator BSS's opmode
+ * @ch_freq: current operating channel frequency
+ * @bss_beacon_interval: beacon interval that can be updated by callee
+ * @status: status to be filled by callee
+ * @is_done: boolean to stop iterating
+ * @update_beacon_interval: boolean to mark beacon interval as updated by callee
+ *
+ * This structure is used to pass the candidate validation information to the
+ * callback
+ */
+struct beacon_interval_arg {
+	uint8_t curr_vdev_id;
+	enum QDF_OPMODE curr_bss_opmode;
+	qdf_freq_t ch_freq;
+	uint16_t bss_beacon_interval;
+	QDF_STATUS status;
+	bool is_done;
+	bool update_beacon_interval;
+};
+
 /**
  * if_mgr_enable_roaming() - interface manager enable roaming
  * @pdev: pdev object
@@ -120,6 +163,23 @@ QDF_STATUS if_mgr_enable_roaming_after_p2p_disconnect(
 				struct wlan_objmgr_vdev *vdev,
 				enum wlan_cm_rso_control_requestor requestor);
 
+/**
+ * if_mgr_is_beacon_interval_valid() - checks if the concurrent session is
+ * valid
+ * @pdev: pdev object
+ * @vdev_id: vdev ID
+ * @candidate: concurrent candidate info
+ *
+ * This function validates the beacon interval with all other active vdevs.
+ *
+ * Context: It should run in thread context
+ *
+ * Return: true if session is valid, false if not
+ */
+bool if_mgr_is_beacon_interval_valid(struct wlan_objmgr_pdev *pdev,
+				     uint8_t vdev_id,
+				     struct validate_bss_data *candidate);
+
 /**
  * if_mgr_validate_candidate() - validate candidate event handler
  * @vdev: vdev object

components/cmn_services/interface_mgr/src/wlan_if_mgr_roam.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2020-2021, 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 above
@@ -29,6 +29,9 @@
 #include "wlan_p2p_ucfg_api.h"
 #include "cds_api.h"
 #include "sme_api.h"
+#include "wlan_vdev_mgr_utils_api.h"
+#include "wni_api.h"
+#include "wlan_mlme_vdev_mgr_interface.h"
 
 static void if_mgr_enable_roaming_on_vdev(struct wlan_objmgr_pdev *pdev,
 					  void *object, void *arg)
@@ -177,6 +180,519 @@ QDF_STATUS if_mgr_enable_roaming_after_p2p_disconnect(
 	return status;
 }
 
+/**
+ * if_mgr_calculate_mcc_beacon_interval() - Calculates the new beacon interval
+ * @sta_bi: station beacon interval
+ * @go_given_bi: P2P GO's given beacon interval
+ *
+ * This function has 3 stages. First it modifies the input go_given_bi to be
+ * within 100 to 199. Then it checks if the sta_bi and go_given_bi are multiples
+ * of each other. If they are, that means the 2 values are compatible, and just
+ * return as is, otherwise, find new compatible BI for P2P GO
+ *
+ * Return: valid beacon interval value
+ */
+static uint16_t if_mgr_calculate_mcc_beacon_interval(uint16_t sta_bi,
+						     uint16_t go_given_bi)
+{
+	uint8_t num_beacons, is_multiple;
+	uint16_t go_calculated_bi, go_final_bi, sta_calculated_bi;
+
+	/* ensure BI ranges between 100 and 200 */
+	if (go_given_bi < 100)
+		go_calculated_bi = 100;
+	else
+		go_calculated_bi = 100 + (go_given_bi % 100);
+
+	if (sta_bi == 0) {
+		/* There is possibility to receive zero as value.
+		 * Which will cause divide by zero. Hence initialise with 100
+		 */
+		sta_bi = 100;
+		ifmgr_warn("sta_bi 2nd parameter is zero, initialize to %d",
+			   sta_bi);
+	}
+	/* check, if either one is multiple of another */
+	if (sta_bi > go_calculated_bi)
+		is_multiple = !(sta_bi % go_calculated_bi);
+	else
+		is_multiple = !(go_calculated_bi % sta_bi);
+
+	/* if it is multiple, then accept GO's beacon interval
+	 * range [100,199] as it is
+	 */
+	if (is_multiple)
+		return go_calculated_bi;
+
+	/* else , if it is not multiple, then then check for number of beacons
+	 * to be inserted based on sta BI
+	 */
+	num_beacons = sta_bi / 100;
+	if (num_beacons) {
+		/* GO's final beacon interval will be aligned to sta beacon
+		 * interval, but in the range of [100, 199].
+		 */
+		sta_calculated_bi = sta_bi / num_beacons;
+		go_final_bi = sta_calculated_bi;
+	} else {
+		/* if STA beacon interval is less than 100, use GO's change
+		 * beacon interval instead of updating to STA's beacon interval.
+		 */
+		go_final_bi = go_calculated_bi;
+	}
+
+	return go_final_bi;
+}
+
+static QDF_STATUS
+if_mgr_send_chng_mcc_beacon_interval(struct wlan_objmgr_vdev *vdev,
+				     struct beacon_interval_arg *bss_arg)
+{
+	struct scheduler_msg msg = {0};
+	struct wlan_change_bi *p_msg;
+	uint16_t len = 0;
+	QDF_STATUS status;
+	uint8_t *mac_addr;
+
+	if (!bss_arg->update_beacon_interval)
+		return QDF_STATUS_SUCCESS;
+
+	bss_arg->update_beacon_interval = false;
+
+	len = sizeof(*p_msg);
+	p_msg = qdf_mem_malloc(len);
+	if (!p_msg)
+		return QDF_STATUS_E_NOMEM;
+
+	p_msg->message_type = eWNI_SME_CHNG_MCC_BEACON_INTERVAL;
+	p_msg->length = len;
+
+	mac_addr = wlan_vdev_get_hw_macaddr(vdev);
+	qdf_mem_copy(&p_msg->bssid, mac_addr, QDF_MAC_ADDR_SIZE);
+	ifmgr_debug(QDF_MAC_ADDR_FMT, QDF_MAC_ADDR_REF(mac_addr));
+	p_msg->session_id = wlan_vdev_get_id(vdev);
+	ifmgr_debug("session %d BeaconInterval %d", p_msg->session_id,
+			bss_arg->bss_beacon_interval);
+	p_msg->beacon_interval = bss_arg->bss_beacon_interval;
+
+	msg.type = eWNI_SME_CHNG_MCC_BEACON_INTERVAL;
+	msg.bodyval = 0;
+	msg.bodyptr = p_msg;
+
+	status = scheduler_post_message(QDF_MODULE_ID_PE,
+					QDF_MODULE_ID_PE,
+					QDF_MODULE_ID_PE, &msg);
+
+	if (status != QDF_STATUS_SUCCESS)
+		qdf_mem_free(p_msg);
+
+	return status;
+}
+
+static void if_mgr_update_beacon_interval(struct wlan_objmgr_pdev *pdev,
+					  void *object, void *arg)
+{
+	struct wlan_objmgr_psoc *psoc;
+	uint8_t allow_mcc_go_diff_bi;
+	struct wlan_objmgr_peer *peer;
+	enum wlan_peer_type bss_persona;
+	struct beacon_interval_arg *bss_arg = arg;
+	struct wlan_objmgr_vdev *vdev = object;
+	uint8_t vdev_id = wlan_vdev_get_id(vdev);
+
+	psoc = wlan_pdev_get_psoc(pdev);
+	if (!psoc)
+		return;
+
+	policy_mgr_get_allow_mcc_go_diff_bi(psoc, &allow_mcc_go_diff_bi);
+
+	peer = wlan_objmgr_vdev_try_get_bsspeer(vdev, WLAN_IF_MGR_ID);
+	if (!peer)
+		return;
+
+	bss_persona = wlan_peer_get_peer_type(peer);
+
+	wlan_objmgr_peer_release_ref(peer, WLAN_IF_MGR_ID);
+
+	/*
+	 * If GO in MCC support different beacon interval,
+	 * change the BI of the P2P-GO
+	 */
+	if (bss_persona == WLAN_PEER_P2P_GO)
+		return;
+	/*
+	 * Handle different BI scenario based on the
+	 * configuration set. If Config is not set to 0x04 then
+	 * Disconnect all the P2P clients associated. If config
+	 * is set to 0x04 then update the BI without
+	 * disconnecting all the clients
+	 */
+	if (allow_mcc_go_diff_bi == ALLOW_MCC_GO_DIFF_BI_NO_DISCONNECT &&
+	    bss_arg->update_beacon_interval) {
+		bss_arg->status =
+			if_mgr_send_chng_mcc_beacon_interval(vdev, bss_arg);
+		return;
+	} else if (bss_arg->update_beacon_interval) {
+		/*
+		 * If the configuration of fAllowMCCGODiffBI is set to
+		 * other than 0x04
+		 */
+		bss_arg->status = wlan_sap_disconnect_all_p2p_client(vdev_id);
+		return;
+	}
+}
+
+static QDF_STATUS
+if_mgr_update_mcc_p2p_beacon_interval(struct wlan_objmgr_vdev *vdev,
+				      struct beacon_interval_arg *bss_arg)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct wlan_objmgr_pdev *pdev;
+	uint8_t enable_mcc_mode;
+
+	pdev = wlan_vdev_get_pdev(vdev);
+	if (!pdev)
+		return QDF_STATUS_E_FAILURE;
+
+	psoc = wlan_pdev_get_psoc(pdev);
+	if (!psoc)
+		return QDF_STATUS_E_FAILURE;
+
+	/* If MCC is not supported just break and return SUCCESS */
+	wlan_mlme_get_mcc_feature(psoc, &enable_mcc_mode);
+	if (!enable_mcc_mode)
+		return QDF_STATUS_E_FAILURE;
+
+	wlan_objmgr_pdev_iterate_obj_list(pdev, WLAN_VDEV_OP,
+					  if_mgr_update_beacon_interval,
+					  bss_arg, 0, WLAN_IF_MGR_ID);
+
+	return bss_arg->status;
+}
+
+static bool if_mgr_validate_sta_bcn_intrvl(struct wlan_objmgr_vdev *vdev,
+					   struct beacon_interval_arg *bss_arg)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct vdev_mlme_obj *vdev_mlme;
+	struct wlan_objmgr_peer *peer;
+	uint16_t new_bcn_interval;
+	uint32_t beacon_interval;
+	struct wlan_channel *chan;
+	enum QDF_OPMODE curr_persona;
+	enum wlan_peer_type bss_persona;
+	uint8_t allow_mcc_go_diff_bi;
+	uint8_t conc_rule1 = 0, conc_rule2 = 0;
+	uint8_t vdev_id = wlan_vdev_get_id(vdev);
+
+	psoc = wlan_vdev_get_psoc(vdev);
+	if (!psoc)
+		return false;
+
+	peer = wlan_objmgr_vdev_try_get_bsspeer(vdev, WLAN_IF_MGR_ID);
+	if (!peer)
+		return false;
+
+	curr_persona = wlan_vdev_mlme_get_opmode(vdev);
+	bss_persona = wlan_peer_get_peer_type(peer);
+
+	wlan_objmgr_peer_release_ref(peer, WLAN_IF_MGR_ID);
+
+	if (curr_persona == QDF_P2P_CLIENT_MODE) {
+		ifmgr_debug("Bcn Intrvl validation not require for STA/CLIENT");
+		return false;
+	}
+
+	chan = wlan_vdev_get_active_channel(vdev);
+	if (!chan) {
+		ifmgr_err("failed to get active channel");
+		return false;
+	}
+
+	vdev_mlme =
+		wlan_objmgr_vdev_get_comp_private_obj(vdev,
+						      WLAN_UMAC_COMP_IF_MGR);
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return false;
+	}
+
+	wlan_util_vdev_mlme_get_param(vdev_mlme, WLAN_MLME_CFG_BEACON_INTERVAL,
+				      &beacon_interval);
+
+	if (bss_persona == WLAN_PEER_AP &&
+	    (chan->ch_cfreq1 != bss_arg->ch_freq ||
+	     chan->ch_cfreq2 != bss_arg->ch_freq)) {
+		ifmgr_debug("*** MCC with SAP+STA sessions ****");
+		bss_arg->status = QDF_STATUS_SUCCESS;
+		return true;
+	}
+
+	if (bss_persona == WLAN_PEER_P2P_GO &&
+	    (chan->ch_cfreq1 != bss_arg->ch_freq ||
+	     chan->ch_cfreq2 != bss_arg->ch_freq) &&
+	    beacon_interval != bss_arg->bss_beacon_interval) {
+		policy_mgr_get_allow_mcc_go_diff_bi(psoc,
+						    &allow_mcc_go_diff_bi);
+
+		switch (allow_mcc_go_diff_bi) {
+		case ALLOW_MCC_GO_DIFF_BI_WFA_CERT:
+			bss_arg->status = QDF_STATUS_SUCCESS;
+			return true;
+		case ALLOW_MCC_GO_DIFF_BI_WORKAROUND:
+			/* fall through */
+		case ALLOW_MCC_GO_DIFF_BI_NO_DISCONNECT:
+			policy_mgr_get_conc_rule1(psoc, &conc_rule1);
+			policy_mgr_get_conc_rule2(psoc, &conc_rule2);
+			if (conc_rule1 || conc_rule2)
+				new_bcn_interval = CUSTOM_CONC_GO_BI;
+			else
+				new_bcn_interval =
+					if_mgr_calculate_mcc_beacon_interval(
+						bss_arg->bss_beacon_interval,
+						beacon_interval);
+
+			ifmgr_debug("Peer AP BI : %d, new Beacon Interval: %d",
+				    bss_arg->bss_beacon_interval,
+				    new_bcn_interval);
+
+			/* Update the beacon interval */
+			if (new_bcn_interval != beacon_interval) {
+				ifmgr_err("Beacon Interval got changed config used: %d",
+					  allow_mcc_go_diff_bi);
+				bss_arg->bss_beacon_interval = new_bcn_interval;
+				bss_arg->update_beacon_interval = true;
+				bss_arg->status =
+					if_mgr_update_mcc_p2p_beacon_interval(
+								vdev,
+								bss_arg);
+				return true;
+			}
+			bss_arg->status = QDF_STATUS_SUCCESS;
+			return true;
+		case ALLOW_MCC_GO_DIFF_BI_TEAR_DOWN:
+			bss_arg->update_beacon_interval = false;
+			bss_arg->status = wlan_sap_stop_bss(vdev_id);
+			return true;
+		default:
+			ifmgr_err("BcnIntrvl is diff can't connect to preferred AP");
+			bss_arg->status = QDF_STATUS_E_FAILURE;
+			return true;
+		}
+	}
+	return false;
+}
+
+static bool if_mgr_validate_p2pcli_bcn_intrvl(struct wlan_objmgr_vdev *vdev,
+				       struct beacon_interval_arg *bss_arg)
+{
+	enum QDF_OPMODE curr_persona;
+	enum wlan_peer_type bss_persona;
+	uint32_t beacon_interval;
+	struct wlan_channel *chan;
+	struct wlan_objmgr_peer *peer;
+	struct vdev_mlme_obj *vdev_mlme;
+
+	curr_persona = wlan_vdev_mlme_get_opmode(vdev);
+
+	peer = wlan_objmgr_vdev_try_get_bsspeer(vdev, WLAN_IF_MGR_ID);
+	if (!peer)
+		return false;
+
+	bss_persona = wlan_peer_get_peer_type(peer);
+
+	wlan_objmgr_peer_release_ref(peer, WLAN_IF_MGR_ID);
+
+	chan = wlan_vdev_get_active_channel(vdev);
+	if (!chan) {
+		ifmgr_err("failed to get active channel");
+		return false;
+	}
+
+	vdev_mlme =
+		wlan_objmgr_vdev_get_comp_private_obj(vdev,
+						      WLAN_UMAC_COMP_IF_MGR);
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return false;
+	}
+
+	wlan_util_vdev_mlme_get_param(vdev_mlme, WLAN_MLME_CFG_BEACON_INTERVAL,
+				      &beacon_interval);
+
+	if (curr_persona == QDF_STA_MODE) {
+		ifmgr_debug("Ignore Beacon Interval Validation...");
+	} else if (bss_persona == WLAN_PEER_P2P_GO) {
+		if ((chan->ch_cfreq1 != bss_arg->ch_freq ||
+		     chan->ch_cfreq2 != bss_arg->ch_freq) &&
+		    beacon_interval != bss_arg->bss_beacon_interval) {
+			ifmgr_err("BcnIntrvl is diff can't connect to P2P_GO network");
+			bss_arg->status = QDF_STATUS_E_FAILURE;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+static bool
+if_mgr_validate_p2pgo_bcn_intrvl(struct wlan_objmgr_vdev *vdev,
+				 struct beacon_interval_arg *bss_arg)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct vdev_mlme_obj *vdev_mlme;
+	enum QDF_OPMODE curr_persona;
+	uint32_t beacon_interval;
+	struct wlan_channel *chan;
+	uint8_t conc_rule1 = 0, conc_rule2 = 0;
+	uint16_t new_bcn_interval;
+
+	curr_persona = wlan_vdev_mlme_get_opmode(vdev);
+
+	chan = wlan_vdev_get_active_channel(vdev);
+	if (!chan) {
+		ifmgr_err("failed to get active channel");
+		return false;
+	}
+
+	vdev_mlme =
+		wlan_objmgr_vdev_get_comp_private_obj(vdev,
+						      WLAN_UMAC_COMP_IF_MGR);
+	if (!vdev_mlme) {
+		QDF_ASSERT(0);
+		return false;
+	}
+
+	psoc = wlan_vdev_get_psoc(vdev);
+	if (!psoc)
+		return false;
+
+	wlan_util_vdev_mlme_get_param(vdev_mlme, WLAN_MLME_CFG_BEACON_INTERVAL,
+				      &beacon_interval);
+
+	if ((curr_persona == QDF_P2P_CLIENT_MODE) ||
+	    (curr_persona == QDF_STA_MODE)) {
+		/* check for P2P_client scenario */
+		if ((chan->ch_cfreq1 == 0) && (chan->ch_cfreq2 == 0) &&
+		    (beacon_interval == 0))
+			return false;
+
+		if (wlan_vdev_mlme_get_state(vdev) == WLAN_VDEV_S_UP &&
+		    (chan->ch_cfreq1 != bss_arg->ch_freq ||
+		     chan->ch_cfreq2 != bss_arg->ch_freq) &&
+		    beacon_interval != bss_arg->bss_beacon_interval) {
+			/*
+			 * Updated beaconInterval should be used only when
+			 * we are starting a new BSS not incase of
+			 * client or STA case
+			 */
+			policy_mgr_get_conc_rule1(psoc, &conc_rule1);
+			policy_mgr_get_conc_rule2(psoc, &conc_rule2);
+
+			/* Calculate beacon Interval for P2P-GO incase of MCC */
+			if (conc_rule1 || conc_rule2) {
+				new_bcn_interval = CUSTOM_CONC_GO_BI;
+			} else {
+				new_bcn_interval =
+					if_mgr_calculate_mcc_beacon_interval(
+						beacon_interval,
+						bss_arg->bss_beacon_interval);
+			}
+			if (new_bcn_interval != bss_arg->bss_beacon_interval)
+				bss_arg->bss_beacon_interval = new_bcn_interval;
+			bss_arg->status = QDF_STATUS_SUCCESS;
+			return true;
+		}
+	}
+	return false;
+}
+
+static void if_mgr_validate_beacon_interval(struct wlan_objmgr_pdev *pdev,
+					    void *object, void *arg)
+{
+	struct beacon_interval_arg *bss_arg = arg;
+	struct wlan_objmgr_vdev *vdev = object;
+	uint8_t iter_vdev_id = wlan_vdev_get_id(vdev);
+	bool is_done = false;
+
+	if (iter_vdev_id == bss_arg->curr_vdev_id)
+		return;
+
+	if (wlan_vdev_mlme_get_state(vdev) != WLAN_VDEV_S_UP)
+		return;
+
+	if (bss_arg->is_done)
+		return;
+
+	switch (bss_arg->curr_bss_opmode) {
+	case QDF_STA_MODE:
+		is_done = if_mgr_validate_sta_bcn_intrvl(vdev, bss_arg);
+		break;
+	case QDF_P2P_CLIENT_MODE:
+		is_done = if_mgr_validate_p2pcli_bcn_intrvl(vdev, bss_arg);
+		break;
+	case QDF_SAP_MODE:
+	case QDF_IBSS_MODE:
+		break;
+	case QDF_P2P_GO_MODE:
+		is_done = if_mgr_validate_p2pgo_bcn_intrvl(vdev, bss_arg);
+		break;
+	default:
+		ifmgr_err("BSS opmode not supported: %d",
+			  bss_arg->curr_bss_opmode);
+	}
+
+	if (is_done)
+		bss_arg->is_done = is_done;
+}
+
+bool if_mgr_is_beacon_interval_valid(struct wlan_objmgr_pdev *pdev,
+				     uint8_t vdev_id,
+				     struct validate_bss_data *candidate)
+{
+	struct wlan_objmgr_psoc *psoc;
+	struct beacon_interval_arg bss_arg;
+	uint8_t enable_mcc_mode;
+	struct wlan_objmgr_vdev *vdev;
+
+	psoc = wlan_pdev_get_psoc(pdev);
+	if (!psoc)
+		return false;
+
+	wlan_mlme_get_mcc_feature(psoc, &enable_mcc_mode);
+	if (!enable_mcc_mode)
+		return false;
+
+	vdev = wlan_objmgr_get_vdev_by_id_from_pdev(pdev, vdev_id,
+						    WLAN_IF_MGR_ID);
+	if (!vdev)
+		return false;
+
+	bss_arg.curr_vdev_id = vdev_id;
+	bss_arg.curr_bss_opmode = wlan_vdev_mlme_get_opmode(vdev);
+	bss_arg.ch_freq = candidate->chan_freq;
+	bss_arg.bss_beacon_interval = candidate->beacon_interval;
+	bss_arg.is_done = false;
+
+	wlan_objmgr_vdev_release_ref(vdev, WLAN_IF_MGR_ID);
+
+	wlan_objmgr_pdev_iterate_obj_list(pdev, WLAN_VDEV_OP,
+					  if_mgr_validate_beacon_interval,
+					  &bss_arg, 0,
+					  WLAN_IF_MGR_ID);
+
+	if (!bss_arg.is_done)
+		return true;
+
+	if (bss_arg.bss_beacon_interval != candidate->beacon_interval) {
+		candidate->beacon_interval = bss_arg.bss_beacon_interval;
+		if (bss_arg.status == QDF_STATUS_SUCCESS)
+			return true;
+	}
+
+	return false;
+}
+
 static void if_mgr_get_vdev_id_from_bssid(struct wlan_objmgr_pdev *pdev,
 					  void *object, void *arg)
 {
@@ -213,7 +729,10 @@ QDF_STATUS if_mgr_validate_candidate(struct wlan_objmgr_vdev *vdev,
 	enum QDF_OPMODE op_mode;
 	enum policy_mgr_con_mode mode;
 	struct bssid_search_arg bssid_arg;
-	uint32_t chan_freq = event_data->validate_bss_info.chan_freq;
+	struct validate_bss_data *candidate_info =
+		&event_data->validate_bss_info;
+	uint32_t chan_freq = candidate_info->chan_freq;
+	uint32_t conc_freq = 0;
 
 	op_mode = wlan_vdev_mlme_get_opmode(vdev);
 
@@ -229,7 +748,7 @@ QDF_STATUS if_mgr_validate_candidate(struct wlan_objmgr_vdev *vdev,
 	 * Ignore the BSS if any other vdev is already connected to it.
 	 */
 	qdf_copy_macaddr(&bssid_arg.peer_addr,
-			 &event_data->validate_bss_info.peer_addr);
+			 &candidate_info->peer_addr);
 	bssid_arg.vdev_id = WLAN_INVALID_VDEV_ID;
 	wlan_objmgr_pdev_iterate_obj_list(pdev, WLAN_VDEV_OP,
 					  if_mgr_get_vdev_id_from_bssid,
@@ -253,7 +772,8 @@ QDF_STATUS if_mgr_validate_candidate(struct wlan_objmgr_vdev *vdev,
 	if (!policy_mgr_is_concurrency_allowed(psoc, mode, chan_freq,
 					       HW_MODE_20_MHZ)) {
 		ifmgr_info("Concurrency not allowed for this channel freq %d bssid "QDF_MAC_ADDR_FMT", selecting next",
-			   chan_freq, QDF_MAC_ADDR_REF(bssid_arg.peer_addr.bytes));
+			   chan_freq,
+			   QDF_MAC_ADDR_REF(bssid_arg.peer_addr.bytes));
 		return QDF_STATUS_E_INVAL;
 	}
 
@@ -268,5 +788,33 @@ QDF_STATUS if_mgr_validate_candidate(struct wlan_objmgr_vdev *vdev,
 		return QDF_STATUS_E_INVAL;
 	}
 
+	/* validate beacon interval */
+	if (policy_mgr_concurrent_open_sessions_running(psoc) &&
+	    !if_mgr_is_beacon_interval_valid(pdev, wlan_vdev_get_id(vdev),
+					     candidate_info)) {
+		conc_freq = wlan_get_conc_freq();
+		ifmgr_debug("csr Conc Channel freq: %d",
+			    conc_freq);
+
+		if (conc_freq) {
+			if ((conc_freq == chan_freq) ||
+			    (policy_mgr_is_hw_dbs_capable(psoc) &&
+			    !wlan_reg_is_same_band_freqs(conc_freq,
+							 chan_freq))) {
+				/*
+				 * make this 0 because we do not want the below
+				 * check to pass as we don't want to connect on
+				 * other channel
+				 */
+				ifmgr_debug("Conc chnl freq match: %d",
+					    conc_freq);
+				conc_freq = 0;
+			}
+		}
+	}
+
+	if (conc_freq)
+		return QDF_STATUS_E_INVAL;
+
 	return QDF_STATUS_SUCCESS;
 }

components/mlme/core/inc/wlan_mlme_vdev_mgr_interface.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2020 The Linux Foundation. All rights reserved.
+ * Copyright (c) 2018-2021 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
@@ -454,4 +454,30 @@ void mlme_vdev_self_peer_delete_resp(struct del_vdev_params *param);
  * Return: none
  */
 void mlme_vdev_del_resp(uint8_t vdev_id);
+
+/**
+ * wlan_sap_disconnect_all_p2p_client() - send SAP disconnect all P2P
+ *	client event to the SAP event handler
+ * @vdev_id: vdev id of SAP
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_sap_disconnect_all_p2p_client(uint8_t vdev_id);
+
+/**
+ * wlan_sap_stop_bss() - send SAP stop bss event to the SAP event
+ *	handler
+ * @vdev_id: vdev id of SAP
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS wlan_sap_stop_bss(uint8_t vdev_id);
+
+/**
+ * wlan_get_conc_freq() - get concurrent operation frequency
+ *
+ * Return: concurrent frequency
+ */
+qdf_freq_t wlan_get_conc_freq(void);
+
 #endif

components/mlme/core/src/wlan_mlme_vdev_mgr_interface.c

@@ -16,7 +16,8 @@
  * PERFORMANCE OF THIS SOFTWARE.
  */
 /**
- * DOC: define internal APIs related to the mlme component
+ * DOC: define internal APIs related to the mlme component, legacy APIs are
+ *	called for the time being, but will be cleaned up after convergence
  */
 #include "wlan_mlme_main.h"
 #include "wlan_mlme_vdev_mgr_interface.h"
@@ -31,6 +32,7 @@
 #include "wlan_crypto_global_api.h"
 #include "target_if_wfa_testcmd.h"
 #include <../../core/src/wlan_cm_vdev_api.h>
+#include "csr_api.h"
 
 static struct vdev_mlme_ops sta_mlme_ops;
 static struct vdev_mlme_ops ap_mlme_ops;
@@ -1646,6 +1648,21 @@ QDF_STATUS mlme_vdev_self_peer_delete(struct scheduler_msg *self_peer_del_msg)
 	return status;
 }
 
+QDF_STATUS wlan_sap_disconnect_all_p2p_client(uint8_t vdev_id)
+{
+	return csr_mlme_vdev_disconnect_all_p2p_client_event(vdev_id);
+}
+
+QDF_STATUS wlan_sap_stop_bss(uint8_t vdev_id)
+{
+	return csr_mlme_vdev_stop_bss(vdev_id);
+}
+
+qdf_freq_t wlan_get_conc_freq(void)
+{
+	return csr_mlme_get_concurrent_operation_freq();
+}
+
 /**
  * ap_mlme_vdev_csa_complete() - callback to initiate csa complete
  *

components/mlme/dispatcher/inc/wlan_mlme_public_struct.h

@@ -93,6 +93,9 @@
  */
 #define AP_OFF_RSSI_OFFSET 20
 
+/* Default beacon interval of 100 ms */
+#define CUSTOM_CONC_GO_BI 100
+
 enum diagwlan_status_eventsubtype {
 	DIAG_WLAN_STATUS_CONNECT = 0,
 	DIAG_WLAN_STATUS_DISCONNECT
@@ -2573,4 +2576,21 @@ struct mlme_roam_debug_info {
 	struct roam_initial_data roam_init_info;
 	struct roam_msg_info roam_msg_info;
 };
+
+/**
+ * struct wlan_change_bi - Message struct to update beacon interval
+ * @message_type: type of message
+ * @length: length of message
+ * @beacon_interval: beacon interval to update to (seconds)
+ * @bssid: BSSID of vdev
+ * @session_id: session ID of vdev
+ */
+struct wlan_change_bi {
+	uint16_t message_type;
+	uint16_t length;
+	uint16_t beacon_interval;
+	struct qdf_mac_addr bssid;
+	uint8_t session_id;
+};
+
 #endif

core/mac/inc/sir_api.h

@@ -1702,15 +1702,6 @@ struct sir_delete_session {
 	uint8_t vdev_id;
 };
 
-/* Beacon Interval */
-struct change_bi_params {
-	uint16_t messageType;
-	uint16_t length;
-	uint16_t beaconInterval;        /* Beacon Interval */
-	struct qdf_mac_addr bssid;
-	uint8_t sessionId;      /* Session ID */
-};
-
 #ifdef QCA_HT_2040_COEX
 struct set_ht2040_mode {
 	uint16_t messageType;

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

@@ -6377,7 +6377,7 @@ static void __lim_process_sme_session_update(struct mac_context *mac_ctx,
 static void __lim_process_sme_change_bi(struct mac_context *mac,
 					uint32_t *msg_buf)
 {
-	struct change_bi_params *pChangeBIParams;
+	struct wlan_change_bi *pChangeBIParams;
 	struct pe_session *pe_session;
 	uint8_t sessionId = 0;
 	tUpdateBeaconParams beaconParams;
@@ -6390,7 +6390,7 @@ static void __lim_process_sme_change_bi(struct mac_context *mac,
 	}
 
 	qdf_mem_zero(&beaconParams, sizeof(tUpdateBeaconParams));
-	pChangeBIParams = (struct change_bi_params *)msg_buf;
+	pChangeBIParams = (struct wlan_change_bi *)msg_buf;
 
 	pe_session = pe_find_session_by_bssid(mac,
 				pChangeBIParams->bssid.bytes,
@@ -6402,19 +6402,19 @@ static void __lim_process_sme_change_bi(struct mac_context *mac,
 
 	/*Update pe_session Beacon Interval */
 	if (pe_session->beaconParams.beaconInterval !=
-	    pChangeBIParams->beaconInterval) {
+	    pChangeBIParams->beacon_interval) {
 		pe_session->beaconParams.beaconInterval =
-			pChangeBIParams->beaconInterval;
+			pChangeBIParams->beacon_interval;
 	}
 
 	/*Update sch beaconInterval */
 	if (mac->sch.beacon_interval !=
-	    pChangeBIParams->beaconInterval) {
+	    pChangeBIParams->beacon_interval) {
 		mac->sch.beacon_interval =
-			pChangeBIParams->beaconInterval;
+			pChangeBIParams->beacon_interval;
 
 		pe_debug("LIM send update BeaconInterval Indication: %d",
-			pChangeBIParams->beaconInterval);
+			pChangeBIParams->beacon_interval);
 
 		if (false == mac->sap.SapDfsInfo.is_dfs_cac_timer_running) {
 			/* Update beacon */
@@ -6423,7 +6423,7 @@ static void __lim_process_sme_change_bi(struct mac_context *mac,
 			beaconParams.bss_idx = pe_session->vdev_id;
 			/* Set change in beacon Interval */
 			beaconParams.beaconInterval =
-				pChangeBIParams->beaconInterval;
+				pChangeBIParams->beacon_interval;
 			beaconParams.paramChangeBitmap =
 				PARAM_BCN_INTERVAL_CHANGED;
 			lim_send_beacon_params(mac, &beaconParams, pe_session);

core/sme/inc/csr_api.h

@@ -1361,4 +1361,29 @@ void csr_fill_auth_type(enum csr_akm_type *auth_type,
  */
 enum csr_cfgdot11mode csr_phy_mode_to_dot11mode(enum wlan_phymode phy_mode);
 
+/*
+ * csr_mlme_vdev_disconnect_all_p2p_client_event() - Callback for MLME module
+ *	to send a disconnect all P2P event to the SAP event handler
+ * @vdev_id: vdev id of SAP
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS csr_mlme_vdev_disconnect_all_p2p_client_event(uint8_t vdev_id);
+
+/*
+ * csr_mlme_vdev_stop_bss() - Callback for MLME module to send a stop BSS event
+ *	to the SAP event handler
+ * @vdev_id: vdev id of SAP
+ *
+ * Return: QDF_STATUS
+ */
+QDF_STATUS csr_mlme_vdev_stop_bss(uint8_t vdev_id);
+
+/*
+ * csr_mlme_get_concurrent_operation_freq() - Callback for MLME module to
+ *	get the concurrent operation frequency
+ *
+ * Return: concurrent frequency
+ */
+qdf_freq_t csr_mlme_get_concurrent_operation_freq(void);
 #endif

core/sme/inc/csr_internal.h

@@ -794,9 +794,6 @@ bool csr_is_all_session_disconnected(struct mac_context *mac);
 
 bool csr_is_concurrent_session_running(struct mac_context *mac);
 bool csr_is_infra_ap_started(struct mac_context *mac);
-bool csr_is_valid_mc_concurrent_session(struct mac_context *mac,
-					uint32_t sessionId,
-					struct bss_description *bss_desc);
 bool csr_is_conn_state_connected_infra_ap(struct mac_context *mac,
 		uint32_t sessionId);
 QDF_STATUS csr_get_snr(struct mac_context *mac, tCsrSnrCallback callback,

core/sme/inc/csr_support.h

@@ -328,24 +328,6 @@ QDF_STATUS csr_reassoc(struct mac_context *mac, uint32_t sessionId,
 		tCsrRoamModifyProfileFields *pModProfileFields,
 		uint32_t *pRoamId, bool fForce);
 
-/**
- * csr_validate_mcc_beacon_interval() - to validate the mcc beacon interval
- * @mac_ctx: pointer to mac context
- * @ch_freq: channel frequency
- * @bcn_interval: provided beacon interval
- * @cur_session_id: current session id
- * @cur_bss_persona: Current BSS persona
- *
- * This API will validate the mcc beacon interval
- *
- * Return: QDF_STATUS
- */
-QDF_STATUS csr_validate_mcc_beacon_interval(struct mac_context *mac_ctx,
-					    uint32_t ch_freq,
-					    uint16_t *bcn_interval,
-					    uint32_t cur_session_id,
-					    enum QDF_OPMODE cur_bss_persona);
-
 bool csr_is_profile11r(struct mac_context *mac, struct csr_roam_profile *pProfile);
 bool csr_is_auth_type11r(struct mac_context *mac, enum csr_akm_type AuthType,
 			 uint8_t mdiePresent);

core/sme/src/csr/csr_api_roam.c

@@ -78,6 +78,7 @@
 #include "wlan_cm_roam_api.h"
 #include "wlan_if_mgr_public_struct.h"
 #include "wlan_if_mgr_ucfg_api.h"
+#include "wlan_if_mgr_roam.h"
 #include "wlan_roam_debug.h"
 
 #define RSN_AUTH_KEY_MGMT_SAE           WLAN_RSN_SEL(WLAN_AKM_SAE)
@@ -4513,7 +4514,7 @@ static bool csr_roam_select_bss(struct mac_context *mac_ctx,
 		enum csr_join_state *roam_state,
 		struct scan_result_list *bss_list)
 {
-	uint32_t conc_freq = 0, chan_freq;
+	uint32_t chan_freq;
 	bool status = false;
 	struct tag_csrscan_result *scan_result = NULL;
 	tCsrScanResultInfo *result = NULL;
@@ -4550,51 +4551,32 @@ static bool csr_roam_select_bss(struct mac_context *mac_ctx,
 			result->BssDescriptor.bssId,
 			sizeof(tSirMacAddr));
 		candidate_info.chan_freq = result->BssDescriptor.chan_freq;
+		candidate_info.beacon_interval =
+			result->BssDescriptor.beaconInterval;
+		candidate_info.chan_freq = result->BssDescriptor.chan_freq;
 		event_data.validate_bss_info = candidate_info;
 		qdf_status = ucfg_if_mgr_deliver_event(vdev,
 						WLAN_IF_MGR_EV_VALIDATE_CANDIDATE,
 						&event_data);
 
+		result->BssDescriptor.beaconInterval =
+						candidate_info.beacon_interval;
+
 		if (QDF_IS_STATUS_ERROR(qdf_status)) {
 			*roam_state = eCsrStopRoamingDueToConcurrency;
 			status = true;
 			*roam_bss_entry = csr_ll_next(&bss_list->List,
-						*roam_bss_entry,
-						LL_ACCESS_LOCK);
+						      *roam_bss_entry,
+						      LL_ACCESS_LOCK);
 			continue;
 		}
-		if (policy_mgr_concurrent_open_sessions_running(mac_ctx->psoc)
-			&& !csr_is_valid_mc_concurrent_session(mac_ctx,
-					vdev_id, &result->BssDescriptor)) {
-			conc_freq = csr_get_concurrent_operation_freq(
-					mac_ctx);
-			sme_debug("csr Conc Channel freq: %d", conc_freq);
-
-			if (conc_freq) {
-				if ((conc_freq == chan_freq) ||
-				    (policy_mgr_is_hw_dbs_capable(mac_ctx->psoc)
-				    && !WLAN_REG_IS_SAME_BAND_FREQS(
-				    conc_freq, chan_freq))) {
-				/*
-				 * make this 0 because we do not want the below
-				 * check to pass as we don't want to connect on
-				 * other channel
-				 */
-					sme_debug("Conc chnl freq match: %d",
-						  conc_freq);
-					conc_freq = 0;
-				}
-			}
-		}
 
-		/* Ok to roam this */
-		if (!conc_freq &&
-		    QDF_IS_STATUS_SUCCESS(csr_roam_should_roam(mac_ctx,
-					  vdev_id, &result->BssDescriptor,
-					  roam_id))) {
+		if (QDF_IS_STATUS_SUCCESS(csr_roam_should_roam(mac_ctx, vdev_id,
+					  &result->BssDescriptor, roam_id))) {
 			status = false;
 			break;
 		}
+
 		*roam_state = eCsrStopRoamingDueToConcurrency;
 		status = true;
 		*roam_bss_entry = csr_ll_next(&bss_list->List, *roam_bss_entry,
@@ -14418,7 +14400,7 @@ QDF_STATUS csr_send_mb_disassoc_req_msg(struct mac_context *mac,
 QDF_STATUS csr_send_chng_mcc_beacon_interval(struct mac_context *mac,
 						uint32_t sessionId)
 {
-	struct change_bi_params *pMsg;
+	struct wlan_change_bi *pMsg;
 	uint16_t len = 0;
 	QDF_STATUS status = QDF_STATUS_SUCCESS;
 	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
@@ -14444,19 +14426,19 @@ QDF_STATUS csr_send_chng_mcc_beacon_interval(struct mac_context *mac,
 	else
 		status = QDF_STATUS_SUCCESS;
 	if (QDF_IS_STATUS_SUCCESS(status)) {
-		pMsg->messageType = eWNI_SME_CHNG_MCC_BEACON_INTERVAL;
+		pMsg->message_type = eWNI_SME_CHNG_MCC_BEACON_INTERVAL;
 		pMsg->length = len;
 
 		qdf_copy_macaddr(&pMsg->bssid, &pSession->self_mac_addr);
 		sme_debug("CSR Attempting to change BI for Bssid= "
 			  QDF_MAC_ADDR_FMT,
 			  QDF_MAC_ADDR_REF(pMsg->bssid.bytes));
-		pMsg->sessionId = sessionId;
+		pMsg->session_id = sessionId;
 		sme_debug("session %d BeaconInterval %d",
 			sessionId,
 			mac->roam.roamSession[sessionId].bssParams.
 			beaconInterval);
-		pMsg->beaconInterval =
+		pMsg->beacon_interval =
 			mac->roam.roamSession[sessionId].bssParams.beaconInterval;
 		status = umac_send_mb_message_to_mac(pMsg);
 	}
@@ -14684,7 +14666,7 @@ QDF_STATUS csr_send_mb_start_bss_req_msg(struct mac_context *mac, uint32_t
 					 struct bss_description *bss_desc)
 {
 	struct start_bss_req *pMsg;
-	uint16_t wTmp;
+	struct validate_bss_data candidate_info;
 	struct csr_roam_session *pSession = CSR_GET_SESSION(mac, sessionId);
 
 	if (!pSession) {
@@ -14706,18 +14688,19 @@ QDF_STATUS csr_send_mb_start_bss_req_msg(struct mac_context *mac, uint32_t
 	qdf_copy_macaddr(&pMsg->self_macaddr, &pSession->self_mac_addr);
 	/* beaconInterval */
 	if (bss_desc && bss_desc->beaconInterval)
-		wTmp = bss_desc->beaconInterval;
+		candidate_info.beacon_interval = bss_desc->beaconInterval;
 	else if (pParam->beaconInterval)
-		wTmp = pParam->beaconInterval;
+		candidate_info.beacon_interval = pParam->beaconInterval;
 	else
-		wTmp = MLME_CFG_BEACON_INTERVAL_DEF;
+		candidate_info.beacon_interval = MLME_CFG_BEACON_INTERVAL_DEF;
+
+	candidate_info.chan_freq = pParam->operation_chan_freq;
+	if_mgr_is_beacon_interval_valid(mac->pdev, sessionId,
+					&candidate_info);
 
-	csr_validate_mcc_beacon_interval(mac,
-					 pParam->operation_chan_freq,
-					 &wTmp, sessionId, pParam->bssPersona);
 	/* Update the beacon Interval */
-	pParam->beaconInterval = wTmp;
-	pMsg->beaconInterval = wTmp;
+	pParam->beaconInterval = candidate_info.beacon_interval;
+	pMsg->beaconInterval = candidate_info.beacon_interval;
 	pMsg->dot11mode =
 		csr_translate_to_wni_cfg_dot11_mode(mac,
 						    pParam->uCfgDot11Mode);

core/sme/src/csr/csr_util.c

@@ -1144,40 +1144,6 @@ bool csr_is_conn_state_disconnected(struct mac_context *mac, uint8_t vdev_id)
 }
 #endif
 
-/**
- * csr_is_valid_mc_concurrent_session() - To check concurren session is valid
- * @mac_ctx: pointer to mac context
- * @session_id: session id
- * @bss_descr: bss description
- *
- * This function validates the concurrent session
- *
- * Return: true or false
- */
-bool csr_is_valid_mc_concurrent_session(struct mac_context *mac_ctx,
-		uint32_t session_id,
-		struct bss_description *bss_descr)
-{
-	struct csr_roam_session *pSession = NULL;
-	enum QDF_OPMODE opmode;
-
-	/* Check for MCC support */
-	if (!mac_ctx->roam.configParam.fenableMCCMode)
-		return false;
-	if (!CSR_IS_SESSION_VALID(mac_ctx, session_id))
-		return false;
-	/* Validate BeaconInterval */
-	pSession = CSR_GET_SESSION(mac_ctx, session_id);
-	opmode = wlan_get_opmode_from_vdev_id(mac_ctx->pdev, session_id);
-	if (QDF_STATUS_SUCCESS == csr_validate_mcc_beacon_interval(
-				mac_ctx,
-				bss_descr->chan_freq,
-				&bss_descr->beaconInterval, session_id,
-				opmode))
-		return true;
-	return false;
-}
-
 bool csr_is_infra_bss_desc(struct bss_description *pSirBssDesc)
 {
 	tSirMacCapabilityInfo dot11Caps = csr_get_bss_capabilities(pSirBssDesc);
@@ -2123,386 +2089,6 @@ bool csr_is_profile_rsn(struct csr_roam_profile *pProfile)
 	return fRSNProfile;
 }
 #endif
-/**
- * csr_update_mcc_p2p_beacon_interval() - update p2p beacon interval
- * @mac_ctx: pointer to mac context
- *
- * This function is to update the mcc p2p beacon interval
- *
- * Return: QDF_STATUS
- */
-static QDF_STATUS csr_update_mcc_p2p_beacon_interval(struct mac_context *mac_ctx)
-{
-	uint32_t session_id = 0;
-	struct csr_roam_session *roam_session;
-
-	/* If MCC is not supported just break and return SUCCESS */
-	if (!mac_ctx->roam.configParam.fenableMCCMode)
-		return QDF_STATUS_E_FAILURE;
-
-	for (session_id = 0; session_id < WLAN_MAX_VDEVS; session_id++) {
-		/*
-		 * If GO in MCC support different beacon interval,
-		 * change the BI of the P2P-GO
-		 */
-		roam_session = &mac_ctx->roam.roamSession[session_id];
-		if (roam_session->bssParams.bssPersona != QDF_P2P_GO_MODE)
-			continue;
-		/*
-		 * Handle different BI scneario based on the
-		 * configuration set.If Config is set to 0x02 then
-		 * Disconnect all the P2P clients associated. If config
-		 * is set to 0x04 then update the BI without
-		 * disconnecting all the clients
-		 */
-		if ((mac_ctx->roam.configParam.fAllowMCCGODiffBI == 0x04)
-				&& (roam_session->bssParams.
-					updatebeaconInterval)) {
-			return csr_send_chng_mcc_beacon_interval(mac_ctx,
-					session_id);
-		} else if (roam_session->bssParams.updatebeaconInterval) {
-			/*
-			 * If the configuration of fAllowMCCGODiffBI is set to
-			 * other than 0x04
-			 */
-			return csr_roam_call_callback(mac_ctx,
-					session_id,
-					NULL, 0,
-					eCSR_ROAM_DISCONNECT_ALL_P2P_CLIENTS,
-					eCSR_ROAM_RESULT_NONE);
-		}
-	}
-	return QDF_STATUS_E_FAILURE;
-}
-
-static uint16_t csr_calculate_mcc_beacon_interval(struct mac_context *mac,
-						  uint16_t sta_bi,
-						  uint16_t go_gbi)
-{
-	uint8_t num_beacons = 0;
-	uint8_t is_multiple = 0;
-	uint16_t go_cbi = 0;
-	uint16_t go_fbi = 0;
-	uint16_t sta_cbi = 0;
-
-	/* If GO's given beacon Interval is less than 100 */
-	if (go_gbi < 100)
-		go_cbi = 100;
-	/* if GO's given beacon Interval is greater than or equal to 100 */
-	else
-		go_cbi = 100 + (go_gbi % 100);
-
-	if (sta_bi == 0) {
-		/* There is possibility to receive zero as value.
-		 * Which will cause divide by zero. Hence initialise with 100
-		 */
-		sta_bi = 100;
-		sme_warn("sta_bi 2nd parameter is zero, initialize to %d",
-			sta_bi);
-	}
-	/* check, if either one is multiple of another */
-	if (sta_bi > go_cbi)
-		is_multiple = !(sta_bi % go_cbi);
-	else
-		is_multiple = !(go_cbi % sta_bi);
-
-	/* if it is multiple, then accept GO's beacon interval
-	 * range [100,199] as it is
-	 */
-	if (is_multiple)
-		return go_cbi;
-
-	/* else , if it is not multiple, then then check for number of beacons
-	 * to be inserted based on sta BI
-	 */
-	num_beacons = sta_bi / 100;
-	if (num_beacons) {
-		/* GO's final beacon interval will be aligned to sta beacon
-		 * interval, but in the range of [100, 199].
-		 */
-		sta_cbi = sta_bi / num_beacons;
-		go_fbi = sta_cbi;
-	} else
-		/* if STA beacon interval is less than 100, use GO's change
-		 * bacon interval instead of updating to STA's beacon interval.
-		 */
-		go_fbi = go_cbi;
-
-	return go_fbi;
-}
-
-/**
- * csr_validate_p2pcli_bcn_intrvl() - to validate p2pcli beacon interval
- * @mac_ctx: pointer to mac context
- * @chnl_id: channel id variable
- * @bcn_interval: pointer to given beacon interval
- * @session_id: given session id
- * @status: fill the status in terms of QDF_STATUS to inform caller
- *
- * This API can provide the validation the beacon interval and re-calculate
- * in case concurrency
- *
- * Return: bool
- */
-static bool csr_validate_p2pcli_bcn_intrvl(struct mac_context *mac_ctx,
-		uint32_t ch_freq, uint16_t *bcn_interval, uint32_t session_id,
-		QDF_STATUS *status)
-{
-	struct csr_roam_session *roamsession;
-	enum QDF_OPMODE opmode;
-
-	opmode = wlan_get_opmode_from_vdev_id(mac_ctx->pdev, session_id);
-	roamsession = &mac_ctx->roam.roamSession[session_id];
-	if (opmode == QDF_STA_MODE) {
-		/* check for P2P client mode */
-		sme_debug("Ignore Beacon Interval Validation...");
-	} else if (opmode == QDF_P2P_GO_MODE) {
-		/* Check for P2P go scenario */
-		if (roamsession->bssParams.operation_chan_freq != ch_freq &&
-		    roamsession->bssParams.beaconInterval != *bcn_interval) {
-			sme_err("BcnIntrvl is diff can't connect to P2P_GO network");
-			*status = QDF_STATUS_E_FAILURE;
-			return true;
-		}
-	}
-	return false;
-}
-
-/**
- * csr_validate_p2pgo_bcn_intrvl() - to validate p2pgo beacon interval
- * @mac_ctx: pointer to mac context
- * @chnl_id: channel id variable
- * @bcn_interval: pointer to given beacon interval
- * @session_id: given session id
- * @status: fill the status in terms of QDF_STATUS to inform caller
- *
- * This API can provide the validation the beacon interval and re-calculate
- * in case concurrency
- *
- * Return: bool
- */
-static bool csr_validate_p2pgo_bcn_intrvl(struct mac_context *mac_ctx,
-		uint32_t ch_freq, uint16_t *bcn_interval,
-		uint32_t session_id, QDF_STATUS *status)
-{
-	struct csr_roam_session *roamsession;
-	struct csr_config *cfg_param;
-	tCsrRoamConnectedProfile *conn_profile;
-	uint16_t new_bcn_interval;
-	enum QDF_OPMODE opmode;
-
-	roamsession = &mac_ctx->roam.roamSession[session_id];
-	cfg_param = &mac_ctx->roam.configParam;
-	conn_profile = &roamsession->connectedProfile;
-	opmode = wlan_get_opmode_from_vdev_id(mac_ctx->pdev, session_id);
-	if (opmode == QDF_P2P_CLIENT_MODE || opmode == QDF_STA_MODE) {
-		/* check for P2P_client scenario */
-		if ((conn_profile->op_freq == 0) &&
-		    (conn_profile->beaconInterval == 0))
-			return false;
-
-		/* This is temp ifdef will be removed in near future */
-#ifdef FEATURE_CM_ENABLE
-		if (cm_is_vdevid_connected(mac_ctx->pdev, session_id) &&
-#else
-		if (csr_is_conn_state_connected_infra(mac_ctx, session_id) &&
-#endif
-		    conn_profile->op_freq != ch_freq &&
-		    conn_profile->beaconInterval != *bcn_interval) {
-			/*
-			 * Updated beaconInterval should be used only when
-			 * we are starting a new BSS not incase of
-			 * client or STA case
-			 */
-
-			/* Calculate beacon Interval for P2P-GO incase of MCC */
-			if (cfg_param->conc_custom_rule1 ||
-					cfg_param->conc_custom_rule2) {
-				new_bcn_interval = CSR_CUSTOM_CONC_GO_BI;
-			} else {
-				new_bcn_interval =
-					csr_calculate_mcc_beacon_interval(
-						mac_ctx,
-						conn_profile->beaconInterval,
-						*bcn_interval);
-			}
-			if (*bcn_interval != new_bcn_interval)
-				*bcn_interval = new_bcn_interval;
-			*status = QDF_STATUS_SUCCESS;
-			return true;
-		}
-	}
-	return false;
-}
-
-/**
- * csr_validate_sta_bcn_intrvl() - to validate sta beacon interval
- * @mac_ctx: pointer to mac context
- * @chnl_id: channel id variable
- * @bcn_interval: pointer to given beacon interval
- * @session_id: given session id
- * @status: fill the status in terms of QDF_STATUS to inform caller
- *
- * This API can provide the validation the beacon interval and re-calculate
- * in case concurrency
- *
- * Return: bool
- */
-static bool csr_validate_sta_bcn_intrvl(struct mac_context *mac_ctx,
-			uint32_t ch_freq, uint16_t *bcn_interval,
-			uint32_t session_id, QDF_STATUS *status)
-{
-	struct csr_roam_session *roamsession;
-	struct csr_config *cfg_param;
-	uint16_t new_bcn_interval;
-	enum QDF_OPMODE opmode;
-
-	roamsession = &mac_ctx->roam.roamSession[session_id];
-	cfg_param = &mac_ctx->roam.configParam;
-
-	opmode = wlan_get_opmode_from_vdev_id(mac_ctx->pdev, session_id);
-	if (opmode == QDF_P2P_CLIENT_MODE) {
-		/* check for P2P client mode */
-		sme_debug("Bcn Intrvl validation not require for STA/CLIENT");
-		return false;
-	}
-	if (opmode == QDF_SAP_MODE &&
-	    roamsession->bssParams.operation_chan_freq != ch_freq) {
-		/*
-		 * IF SAP has started and STA wants to connect
-		 * on different channel MCC should
-		 *  MCC should not be enabled so making it
-		 * false to enforce on same channel
-		 */
-		sme_debug("*** MCC with SAP+STA sessions ****");
-		*status = QDF_STATUS_SUCCESS;
-		return true;
-	}
-	/*
-	 * Check for P2P go scenario
-	 * if GO in MCC support different
-	 * beacon interval,
-	 * change the BI of the P2P-GO
-	 */
-	if (opmode == QDF_P2P_GO_MODE &&
-	    roamsession->bssParams.operation_chan_freq != ch_freq &&
-	    roamsession->bssParams.beaconInterval != *bcn_interval) {
-		/* if GO in MCC support diff beacon interval, return success */
-		if (cfg_param->fAllowMCCGODiffBI == 0x01) {
-			*status = QDF_STATUS_SUCCESS;
-			return true;
-		}
-		/*
-		 * Send only Broadcast disassoc and update bcn_interval
-		 * If configuration is set to 0x04 then dont
-		 * disconnect all the station
-		 */
-		if ((cfg_param->fAllowMCCGODiffBI == 0x02)
-			|| (cfg_param->fAllowMCCGODiffBI == 0x04)) {
-			/* Check to pass the right beacon Interval */
-			if (cfg_param->conc_custom_rule1 ||
-				cfg_param->conc_custom_rule2) {
-				new_bcn_interval = CSR_CUSTOM_CONC_GO_BI;
-			} else {
-				new_bcn_interval =
-				csr_calculate_mcc_beacon_interval(
-					mac_ctx, *bcn_interval,
-					roamsession->bssParams.beaconInterval);
-			}
-			sme_debug("Peer AP BI : %d, new Beacon Interval: %d",
-				*bcn_interval, new_bcn_interval);
-			/* Update the becon Interval */
-			if (new_bcn_interval !=
-					roamsession->bssParams.beaconInterval) {
-				/* Update the bcn_interval now */
-				sme_err("Beacon Interval got changed config used: %d",
-					cfg_param->fAllowMCCGODiffBI);
-
-				roamsession->bssParams.beaconInterval =
-					new_bcn_interval;
-				roamsession->bssParams.updatebeaconInterval =
-					true;
-				*status = csr_update_mcc_p2p_beacon_interval(
-					mac_ctx);
-				return true;
-			}
-			*status = QDF_STATUS_SUCCESS;
-			return true;
-		}
-		if (cfg_param->fAllowMCCGODiffBI
-				== 0x03) {
-			/* Disconnect the P2P session */
-			roamsession->bssParams.updatebeaconInterval = false;
-			*status = csr_roam_call_callback(mac_ctx,
-					session_id, NULL, 0,
-					eCSR_ROAM_SEND_P2P_STOP_BSS,
-					eCSR_ROAM_RESULT_NONE);
-			return true;
-		}
-		sme_err("BcnIntrvl is diff can't connect to preferred AP");
-		*status = QDF_STATUS_E_FAILURE;
-		return true;
-	}
-	return false;
-}
-
-QDF_STATUS csr_validate_mcc_beacon_interval(struct mac_context *mac_ctx,
-					    uint32_t ch_freq,
-					    uint16_t *bcn_interval,
-					    uint32_t cur_session_id,
-					    enum QDF_OPMODE cur_bss_persona)
-{
-	uint32_t session_id = 0;
-	QDF_STATUS status;
-	bool is_done;
-
-	/* If MCC is not supported just break */
-	if (!mac_ctx->roam.configParam.fenableMCCMode)
-		return QDF_STATUS_E_FAILURE;
-
-	for (session_id = 0; session_id < WLAN_MAX_VDEVS; session_id++) {
-		if (cur_session_id == session_id)
-			continue;
-
-		if (!CSR_IS_SESSION_VALID(mac_ctx, session_id))
-			continue;
-
-		switch (cur_bss_persona) {
-		case QDF_STA_MODE:
-			is_done = csr_validate_sta_bcn_intrvl(
-						mac_ctx, ch_freq, bcn_interval,
-						session_id, &status);
-			if (true == is_done)
-				return status;
-			break;
-
-		case QDF_P2P_CLIENT_MODE:
-			is_done = csr_validate_p2pcli_bcn_intrvl(mac_ctx,
-					ch_freq, bcn_interval, session_id,
-					&status);
-			if (true == is_done)
-				return status;
-			break;
-
-		case QDF_SAP_MODE:
-		case QDF_IBSS_MODE:
-			break;
-
-		case QDF_P2P_GO_MODE:
-			is_done = csr_validate_p2pgo_bcn_intrvl(mac_ctx,
-					ch_freq, bcn_interval,
-					session_id, &status);
-			if (true == is_done)
-				return status;
-			break;
-
-		default:
-			sme_err("Persona not supported: %d", cur_bss_persona);
-			return QDF_STATUS_E_FAILURE;
-		}
-	}
-	return QDF_STATUS_SUCCESS;
-}
 
 /**
  * csr_is_auth_type11r() - Check if Authentication type is 11R
@@ -3956,3 +3542,37 @@ enum csr_cfgdot11mode csr_phy_mode_to_dot11mode(enum wlan_phymode phy_mode)
 		return eCSR_CFG_DOT11_MODE_MAX;
 	}
 }
+
+QDF_STATUS csr_mlme_vdev_disconnect_all_p2p_client_event(uint8_t vdev_id)
+{
+	struct mac_context *mac_ctx = cds_get_context(QDF_MODULE_ID_SME);
+
+	if (!mac_ctx)
+		return QDF_STATUS_E_FAILURE;
+
+	return csr_roam_call_callback(mac_ctx, vdev_id, NULL, 0,
+				      eCSR_ROAM_DISCONNECT_ALL_P2P_CLIENTS,
+				      eCSR_ROAM_RESULT_NONE);
+}
+
+QDF_STATUS csr_mlme_vdev_stop_bss(uint8_t vdev_id)
+{
+	struct mac_context *mac_ctx = cds_get_context(QDF_MODULE_ID_SME);
+
+	if (!mac_ctx)
+		return QDF_STATUS_E_FAILURE;
+
+	return csr_roam_call_callback(mac_ctx, vdev_id, NULL, 0,
+				      eCSR_ROAM_SEND_P2P_STOP_BSS,
+				      eCSR_ROAM_RESULT_NONE);
+}
+
+qdf_freq_t csr_mlme_get_concurrent_operation_freq(void)
+{
+	struct mac_context *mac_ctx = cds_get_context(QDF_MODULE_ID_SME);
+
+	if (!mac_ctx)
+		return QDF_STATUS_E_FAILURE;
+
+	return csr_get_concurrent_operation_freq(mac_ctx);
+}